@tego/devkit 1.3.14

package/lib/builder/build/utils/buildPluginUtils.mjs

@@ -0,0 +1,118 @@
+// src/builder/build/utils/buildPluginUtils.ts
+import fs from "node:fs";
+import { builtinModules } from "node:module";
+import path from "node:path";
+import chalk from "chalk";
+var requireRegex = /require\s*\(['"`](.*?)['"`]\)/g;
+var importRegex = /^import(?:['"\s]*([\w*${}\s,]+)from\s*)?['"\s]['"\s](.*[@\w_-]+)['"\s].*/gm;
+function isNotBuiltinModule(packageName) {
+  return !builtinModules.includes(packageName);
+}
+var isValidPackageName = (str) => {
+  const pattern = /^(?:@[a-zA-Z0-9_-]+\/)?[a-zA-Z0-9_-]+$/;
+  return pattern.test(str);
+};
+function getPackageNameFromString(str) {
+  if (str.startsWith(".")) return null;
+  const arr = str.split("/");
+  let packageName;
+  if (arr[0].startsWith("@")) {
+    packageName = arr.slice(0, 2).join("/");
+  } else {
+    packageName = arr[0];
+  }
+  packageName = packageName.trim();
+  return isValidPackageName(packageName) ? packageName : null;
+}
+function getPackagesFromFiles(files) {
+  const packageNames = files.map((item) => [
+    ...[...item.matchAll(importRegex)].map((item2) => item2[2]),
+    ...[...item.matchAll(requireRegex)].map((item2) => item2[1])
+  ]).flat().map(getPackageNameFromString).filter(Boolean).filter(isNotBuiltinModule);
+  return [...new Set(packageNames)];
+}
+function getSourcePackages(fileSources) {
+  return getPackagesFromFiles(fileSources);
+}
+function getIncludePackages(sourcePackages, external, pluginPrefix) {
+  return sourcePackages.filter((packageName) => !external.includes(packageName)).filter((packageName) => !pluginPrefix.some((prefix) => packageName.startsWith(prefix)));
+}
+function getExcludePackages(sourcePackages, external, pluginPrefix) {
+  const includePackages = getIncludePackages(sourcePackages, external, pluginPrefix);
+  return sourcePackages.filter((packageName) => !includePackages.includes(packageName));
+}
+function getPackageJsonPackages(packageJson) {
+  return [
+    .../* @__PURE__ */ new Set([...Object.keys(packageJson.devDependencies || {}), ...Object.keys(packageJson.dependencies || {})])
+  ];
+}
+function checkEntryExists(cwd, entry, log) {
+  const srcDir = path.join(cwd, "src", entry);
+  if (!fs.existsSync(srcDir)) {
+    log("Missing %s. Please create it.", chalk.red(`src/${entry}`));
+    process.exit(-1);
+  }
+  return srcDir;
+}
+function checkDependencies(packageJson, log) {
+}
+function getFileSize(filePath) {
+  const stat = fs.statSync(filePath);
+  return stat.size;
+}
+function formatFileSize(fileSize) {
+  const kb = fileSize / 1024;
+  return kb.toFixed(2) + " KB";
+}
+function buildCheck(options) {
+  const { cwd, log, entry, files, packageJson } = options;
+  checkEntryExists(cwd, entry, log);
+  checkDependencies(packageJson, log);
+}
+function checkRequire(sourceFiles, log) {
+  const requireArr = sourceFiles.map((filePath) => {
+    const code = fs.readFileSync(filePath, "utf-8");
+    return [...code.matchAll(requireRegex)].map((item) => ({
+      filePath,
+      code: item[0]
+    }));
+  }).flat();
+  if (requireArr.length) {
+    log("%s not allowed. Please use %s instead.", chalk.red("require()"), chalk.red("import"));
+    requireArr.forEach((item, index) => {
+      console.log("%s. %s in %s;", index + 1, chalk.red(item.code), chalk.red(item.filePath));
+    });
+    console.log("\n");
+    process.exit(-1);
+  }
+}
+function checkFileSize(outDir, log) {
+  const files = fs.readdirSync(outDir);
+  files.forEach((file) => {
+    const fileSize = getFileSize(path.join(outDir, file));
+    if (fileSize > 1024 * 1024) {
+      log(
+        `The %s size %s exceeds 1MB. You can use dynamic import \`import()\` for lazy loading content.`,
+        chalk.red(file),
+        chalk.red(formatFileSize(fileSize))
+      );
+    }
+  });
+}
+export {
+  buildCheck,
+  checkDependencies,
+  checkEntryExists,
+  checkFileSize,
+  checkRequire,
+  formatFileSize,
+  getExcludePackages,
+  getFileSize,
+  getIncludePackages,
+  getPackageJsonPackages,
+  getPackageNameFromString,
+  getPackagesFromFiles,
+  getSourcePackages,
+  isNotBuiltinModule,
+  isValidPackageName
+};

package/lib/builder/build/utils/getDepsConfig.mjs

@@ -0,0 +1,86 @@
+// src/builder/build/utils/getDepsConfig.ts
+import { createRequire } from "node:module";
+import path from "node:path";
+import fs from "fs-extra";
+var require2 = createRequire(import.meta.url);
+function winPath(path2) {
+  const isExtendedLengthPath = path2.startsWith("\\\\?\\");
+  if (isExtendedLengthPath) {
+    return path2;
+  }
+  return path2.replace(/\\/g, "/");
+}
+function getRltExternalsFromDeps(depExternals, current) {
+  return Object.entries(depExternals).reduce((r, [dep, target]) => {
+    if (dep !== current.name) {
+      r[dep] = winPath(path.relative(current.outputDir, path.dirname(target)));
+    }
+    return r;
+  }, {});
+}
+function findPackageJson(filePath) {
+  const directory = path.dirname(filePath);
+  const packageJsonPath = path.resolve(directory, "package.json");
+  if (fs.existsSync(packageJsonPath)) {
+    return directory;
+  } else if (directory !== "/") {
+    return findPackageJson(directory);
+  } else {
+    throw new Error("package.json not found.");
+  }
+}
+function getDepPkgPath(dep, cwd) {
+  try {
+    return require2.resolve(`${dep}/package.json`, { paths: [cwd] });
+  } catch {
+    const mainFile = require2.resolve(`${dep}`, { paths: cwd ? [cwd] : void 0 });
+    const packageDir = mainFile.slice(0, mainFile.indexOf(dep.replace("/", path.sep)) + dep.length);
+    const result = path.join(packageDir, "package.json");
+    if (!fs.existsSync(result)) {
+      return path.join(findPackageJson(mainFile), "package.json");
+    }
+    return result;
+  }
+}
+function getDepsConfig(cwd, outDir, depsName, external) {
+  const pkgExternals = external.reduce((r, dep) => ({ ...r, [dep]: dep }), {});
+  const depExternals = {};
+  const deps = depsName.reduce((acc, packageName) => {
+    const depEntryPath = require2.resolve(packageName, { paths: [cwd] });
+    const depPkgPath = getDepPkgPath(packageName, cwd);
+    const depPkg = require2(depPkgPath);
+    const depDir = path.dirname(depPkgPath);
+    const outputDir = path.join(outDir, packageName);
+    const mainFile = path.join(outputDir, depEntryPath.replace(depDir, ""));
+    acc[depEntryPath] = {
+      nccConfig: {
+        minify: true,
+        target: "es5",
+        quiet: true,
+        externals: {}
+      },
+      depDir,
+      pkg: depPkg,
+      outputDir,
+      mainFile
+    };
+    return acc;
+  }, {});
+  Object.values(deps).forEach((depConfig) => {
+    const rltDepExternals = getRltExternalsFromDeps(depExternals, {
+      name: depConfig.pkg.name,
+      outputDir: depConfig.outputDir
+    });
+    depConfig.nccConfig.externals = {
+      ...pkgExternals,
+      ...rltDepExternals
+    };
+  });
+  return deps;
+}
+export {
+  getDepPkgPath,
+  getDepsConfig,
+  getRltExternalsFromDeps,
+  winPath
+};

package/lib/builder/build/utils/getPackages.mjs

@@ -0,0 +1,63 @@
+// src/builder/build/utils/getPackages.ts
+import path from "node:path";
+import Topo from "@hapi/topo";
+import { findWorkspacePackages } from "@pnpm/workspace.find-packages";
+import fg from "fast-glob";
+import fs from "fs-extra";
+import { ROOT_PATH } from "../constant.mjs";
+import { toUnixPath } from "./utils.mjs";
+function getPackagesPath(pkgs) {
+  const allPackageJson = fg.sync(["apps/*/package.json", "packages/*/package.json"], {
+    cwd: ROOT_PATH,
+    absolute: true,
+    onlyFiles: true
+  });
+  if (pkgs.length === 0) {
+    return allPackageJson.map(toUnixPath).map((item) => path.dirname(item));
+  }
+  const allPackageInfo = allPackageJson.map((packageJsonPath) => ({
+    name: fs.readJsonSync(packageJsonPath).name,
+    path: path.dirname(toUnixPath(packageJsonPath))
+  })).reduce(
+    (acc, cur) => {
+      acc[cur.name] = cur.path;
+      return acc;
+    },
+    {}
+  );
+  const allPackagePaths = Object.values(allPackageInfo);
+  const pkgNames = pkgs.filter((item) => allPackageInfo[item]);
+  const relativePaths = pkgNames.length ? pkgs.filter((item) => !pkgNames.includes(item)) : pkgs;
+  const pkgPaths = pkgs.map((item) => allPackageInfo[item]);
+  const absPaths = allPackagePaths.filter(
+    (absPath) => relativePaths.some((relativePath) => absPath.endsWith(relativePath))
+  );
+  const dirPaths = fg.sync(pkgs, { onlyDirectories: true, absolute: true, cwd: ROOT_PATH });
+  const dirMatchPaths = allPackagePaths.filter((pkgPath) => dirPaths.some((dirPath) => pkgPath.startsWith(dirPath)));
+  return [.../* @__PURE__ */ new Set([...pkgPaths, ...absPaths, ...dirMatchPaths])];
+}
+async function getPackages(pkgs) {
+  const packagePaths = getPackagesPath(pkgs);
+  const allProjects = await findWorkspacePackages(ROOT_PATH, {
+    supportedArchitectures: {
+      os: ["current"],
+      cpu: ["current"],
+      libc: ["current"]
+    }
+  });
+  const packages = allProjects.filter((pkg) => packagePaths.includes(toUnixPath(pkg.dir)));
+  return sortPackages(packages);
+}
+function sortPackages(packages) {
+  const sorter = new Topo.Sorter();
+  for (const pkg of packages) {
+    const pkgJson = fs.readJsonSync(`${pkg.dir}/package.json`);
+    const after = Object.keys({ ...pkgJson.dependencies, ...pkgJson.devDependencies, ...pkgJson.peerDependencies });
+    sorter.add(pkg, { after, group: pkg.manifest.name });
+  }
+  return sorter.nodes;
+}
+export {
+  getPackages,
+  sortPackages
+};

package/lib/builder/build/utils/index.mjs

@@ -0,0 +1,2 @@
+// src/builder/build/utils/index.ts
+export * from "./utils.mjs";

package/lib/builder/build/utils/utils.mjs

@@ -0,0 +1,60 @@
+// src/builder/build/utils/utils.ts
+import { createRequire } from "node:module";
+import path from "node:path";
+import chalk from "chalk";
+import fg from "fast-glob";
+import fs from "fs-extra";
+import { require as tsxRequire } from "tsx/cjs/api";
+import { NODE_MODULES } from "../constant.mjs";
+var require2 = createRequire(import.meta.url);
+var getPkgLog = (pkgName) => {
+  const pkgStr = chalk.underline.magentaBright(pkgName);
+  const pkgLog = (msg, ...optionalParams) => console.log(`${pkgStr}: ${msg}`, ...optionalParams);
+  return pkgLog;
+};
+function toUnixPath(filepath) {
+  return filepath.replace(/\\/g, "/");
+}
+function getPackageJson(cwd) {
+  return require2(path.join(cwd, "package.json"));
+}
+function defineConfig(config) {
+  return config;
+}
+function getUserConfig(cwd) {
+  const config = defineConfig({
+    modifyTsupConfig: (config2) => config2,
+    modifyViteConfig: (config2) => config2
+  });
+  const buildConfigs = fg.sync(["./build.config.js", "./build.config.ts"], { cwd });
+  if (buildConfigs.length > 1) {
+    throw new Error(`Multiple build configs found: ${buildConfigs.join(", ")}`);
+  }
+  if (buildConfigs.length === 1) {
+    const userConfig = tsxRequire(buildConfigs[0], path.resolve(cwd, "index.js"));
+    Object.assign(config, userConfig.default || userConfig);
+  }
+  return config;
+}
+var CACHE_DIR = path.join(NODE_MODULES, ".cache", "tachybase");
+function writeToCache(key, data) {
+  const cachePath = path.join(CACHE_DIR, `${key}.json`);
+  fs.ensureDirSync(path.dirname(cachePath));
+  fs.writeJsonSync(cachePath, data, { spaces: 2 });
+}
+function readFromCache(key) {
+  const cachePath = path.join(CACHE_DIR, `${key}.json`);
+  if (fs.existsSync(cachePath)) {
+    return fs.readJsonSync(cachePath);
+  }
+  return {};
+}
+export {
+  defineConfig,
+  getPackageJson,
+  getPkgLog,
+  getUserConfig,
+  readFromCache,
+  toUnixPath,
+  writeToCache
+};

package/lib/builder/buildable-packages/app-web-package.mjs

@@ -0,0 +1,38 @@
+// src/builder/buildable-packages/app-web-package.ts
+import path from "node:path";
+import { createRsbuild, loadConfig } from "@rsbuild/core";
+import { ROOT_PATH } from "../build/constant.mjs";
+import { tarPlugin } from "../build/tarPlugin.mjs";
+import { getPkgLog } from "../build/utils/index.mjs";
+var AppWebPackage = class {
+  static name = "app web";
+  name;
+  dir;
+  context;
+  constructor(name, dir, context) {
+    this.name = name;
+    this.dir = dir;
+    this.context = context;
+  }
+  async build() {
+    const log = getPkgLog(this.name);
+    if (this.context.onlyTar) {
+      return await tarPlugin(this.dir, log);
+    }
+    const config = await loadConfig({
+      cwd: path.join(ROOT_PATH, "apps/web")
+    });
+    const rsbuild = await createRsbuild({
+      rsbuildConfig: config.content,
+      cwd: path.join(ROOT_PATH, "apps/web")
+    });
+    await rsbuild.build();
+    if (this.context.tar) {
+      await tarPlugin(this.dir, log);
+    }
+    log("done");
+  }
+};
+export {
+  AppWebPackage
+};

package/lib/builder/buildable-packages/lib-package.mjs

@@ -0,0 +1,63 @@
+// src/builder/buildable-packages/lib-package.ts
+import { buildCjs } from "../build/buildCjs.mjs";
+import { buildClient } from "../build/buildClient.mjs";
+import { buildDeclaration } from "../build/buildDeclaration.mjs";
+import { buildEsm } from "../build/buildEsm.mjs";
+import { CORE_CLIENT, ESM_PACKAGES } from "../build/constant.mjs";
+import { tarPlugin } from "../build/tarPlugin.mjs";
+import { getPkgLog, getUserConfig } from "../build/utils/index.mjs";
+var LibPackage = class {
+  static name = "lib";
+  name;
+  dir;
+  context;
+  isEsm = false;
+  isClient = false;
+  constructor(name, dir, context) {
+    this.name = name;
+    this.dir = dir;
+    this.context = context;
+    this.isEsm = ESM_PACKAGES.includes(this.name);
+    this.isClient = this.dir === CORE_CLIENT;
+  }
+  async build() {
+    const log = getPkgLog(this.name);
+    if (this.context.onlyTar) {
+      return await tarPlugin(this.dir, log);
+    }
+    const userConfig = getUserConfig(this.dir);
+    if (userConfig.beforeBuild) {
+      log("beforeBuild");
+      await userConfig.beforeBuild(log);
+    }
+    if (!this.isClient) {
+      await buildCjs(this.dir, userConfig, this.context.sourcemap, log);
+      if (this.context.dts) {
+        await buildDeclaration(this.dir, "lib", log);
+      }
+    }
+    if (this.isClient) {
+      await buildClient(this.dir, userConfig, this.context.sourcemap, log);
+      if (this.context.dts) {
+        await buildDeclaration(this.dir, "es", log);
+      }
+    }
+    if (this.isEsm) {
+      await buildEsm(this.dir, userConfig, this.context.sourcemap, log);
+      if (this.context.dts) {
+        await buildDeclaration(this.dir, "es", log);
+      }
+    }
+    if (userConfig.afterBuild) {
+      log("afterBuild");
+      await userConfig.afterBuild(log);
+    }
+    if (this.context.tar) {
+      await tarPlugin(this.dir, log);
+    }
+    log("done");
+  }
+};
+export {
+  LibPackage
+};