jiek 2.0.2-alpha.1 → 2.0.2-alpha.11

package/cli-only-build.js

@@ -0,0 +1,667 @@
+import fs from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { filterPackagesFromDir } from '@pnpm/filter-workspace-packages';
+import { program } from 'commander';
+import { load } from 'js-yaml';
+import { isWorkspaceDir, getWorkspaceDir } from '@jiek/utils/getWorkspaceDir';
+import { confirm } from '@inquirer/prompts';
+import { MultiBar, Presets } from 'cli-progress';
+import { execaCommand } from 'execa';
+
+let root;
+function getRoot() {
+  if (root)
+    return root;
+  const rootOption = program.getOptionValue("root");
+  root = rootOption ? path.isAbsolute(rootOption) ? rootOption : path.resolve(process.cwd(), rootOption) : void 0;
+  return root;
+}
+
+let wd;
+let notWorkspace$1 = false;
+function getWD() {
+  if (wd)
+    return { wd, notWorkspace: notWorkspace$1 };
+  const root = getRoot();
+  if (root !== void 0) {
+    const isWorkspace = isWorkspaceDir(root, type$1);
+    notWorkspace$1 = !isWorkspace;
+    wd = root;
+    return { wd, notWorkspace: notWorkspace$1 };
+  }
+  try {
+    wd = getWorkspaceDir(type$1);
+  } catch (e) {
+    if ("message" in e && e.message === "workspace root not found") {
+      wd = root;
+      notWorkspace$1 = true;
+    } else {
+      throw e;
+    }
+  }
+  return { wd, notWorkspace: notWorkspace$1 };
+}
+
+let type$1 = "";
+try {
+  const require = createRequire(import.meta.url);
+  require.resolve("@pnpm/filter-workspace-packages");
+  type$1 = "pnpm";
+} catch {
+}
+function filterPackagesGraph(filters) {
+  return Promise.all(filters.map(async (filter) => getSelectedProjectsGraph(filter)));
+}
+async function getSelectedProjectsGraph(filter = program.getOptionValue("filter")) {
+  let root = getRoot();
+  const { wd, notWorkspace } = getWD();
+  if (notWorkspace) {
+    return {
+      wd,
+      root,
+      value: {
+        [wd]: JSON.parse(fs.readFileSync(path.resolve(wd, "package.json"), "utf-8"))
+      }
+    };
+  }
+  if (type$1 === "pnpm") {
+    const pnpmWorkspaceFilePath = path.resolve(wd, "pnpm-workspace.yaml");
+    const pnpmWorkspaceFileContent = fs.readFileSync(pnpmWorkspaceFilePath, "utf-8");
+    const pnpmWorkspace = load(pnpmWorkspaceFileContent);
+    if (root === wd && !filter) {
+      throw new Error("root path is workspace root, please provide a filter");
+    }
+    if (root === void 0) {
+      root = process.cwd();
+    }
+    if (root !== wd && !filter) {
+      const packageJSONIsExist = fs.existsSync(path.resolve(root, "package.json"));
+      if (!packageJSONIsExist) {
+        throw new Error("root path is not workspace root, please provide a filter");
+      }
+      const packageJSON = JSON.parse(fs.readFileSync(path.resolve(root, "package.json"), "utf-8"));
+      if (!packageJSON.name) {
+        throw new Error("root path is not workspace root, please provide a filter");
+      }
+      filter = packageJSON.name;
+    }
+    const { selectedProjectsGraph } = await filterPackagesFromDir(wd, [{
+      filter: filter ?? "",
+      followProdDepsOnly: true
+    }], {
+      prefix: root,
+      workspaceDir: wd,
+      patterns: pnpmWorkspace.packages
+    });
+    return {
+      wd,
+      root,
+      value: Object.entries(selectedProjectsGraph).reduce((acc, [key, value]) => {
+        acc[key] = value.package.manifest;
+        return acc;
+      }, {})
+    };
+  }
+  throw new Error(`not supported package manager ${type$1}`);
+}
+
+var name = "jiek";
+var type = "module";
+var version = "2.0.2-alpha.10";
+var description$1 = "A lightweight toolkit for compiling and managing libraries based on `package.json` metadata and suitable for `Monorepo`.";
+var author = "YiJie <yijie4188@gmail.com>";
+var repository = {
+	url: "nwylzw/jiek",
+	directory: "packages/jiek"
+};
+var homepage = "https://github.com/NWYLZW/jiek/tree/master/packages/jiek#readme";
+var bugs = "https://github.com/NWYLZW/jiek/issues?q=is%3Aissue+is%3Aopen+jiek";
+var bin = {
+	jiek: "bin/jiek.js",
+	jk: "bin/jiek.js",
+	"jiek-build": "bin/jiek-build.js",
+	jb: "bin/jiek-build.js"
+};
+var files = [
+	"dist",
+	"src",
+	"bin",
+	"LICENSE",
+	"README.md"
+];
+var scripts = {
+	prepublish: "jb -nm && jk",
+	postpublish: "jk"
+};
+var exports = {
+	"./package.json": "./package.json",
+	".": "./src/index.ts",
+	"./cli": "./src/cli.ts",
+	"./cli-only-build": "./src/cli-only-build.ts",
+	"./rollup": "./src/rollup/index.ts"
+};
+var imports = {
+	"#~/*": "./src/*"
+};
+var dependencies = {
+	"@jiek/pkger": "workspace:^",
+	"@jiek/rollup-plugin-dts": "^6.2.1",
+	"@jiek/utils": "workspace:^",
+	"@inquirer/prompts": "^7.1.0",
+	"@rollup/plugin-commonjs": "^28.0.0",
+	"@rollup/plugin-json": "^6.0.1",
+	"@rollup/plugin-node-resolve": "^15.3.0",
+	"cli-progress": "^3.12.0",
+	commander: "^12.0.0",
+	"detect-indent": "^6.1.0",
+	execa: "9.3.1",
+	"js-yaml": "^4.1.0",
+	"jsonc-parser": "^3.2.1",
+	rollup: "4.13.2"
+};
+var peerDependencies = {
+	"@rollup/plugin-terser": "^0.4.4",
+	"@pnpm/filter-workspace-packages": "^7.2.13",
+	"esbuild-register": "^3.5.0",
+	postcss: "^8.4.47",
+	"rollup-plugin-postcss": "^4.0.2",
+	"rollup-plugin-esbuild": "^6.1.0",
+	"rollup-plugin-swc3": "^0.12.1",
+	typescript: "^4.0.0||^5.0.0"
+};
+var devDependencies = {
+	"@npm/types": "^1.0.2",
+	"@pnpm/filter-workspace-packages": "^7.2.13",
+	"@pnpm/workspace.pkgs-graph": "^2.0.15",
+	"@rollup/plugin-terser": "^0.4.4",
+	"@types/cli-progress": "^3.11.5",
+	"@types/inquirer": "^9.0.7",
+	"@types/js-yaml": "^4.0.9",
+	"@types/micromatch": "^4.0.6",
+	"esbuild-register": "^3.5.0",
+	micromatch: "^4.0.5",
+	"node-sass": "^9.0.0",
+	postcss: "^8.4.47",
+	"rollup-plugin-postcss": "^4.0.2",
+	"rollup-plugin-esbuild": "^6.1.0",
+	"rollup-plugin-swc3": "^0.12.1"
+};
+var pkg = {
+	name: name,
+	type: type,
+	version: version,
+	description: description$1,
+	author: author,
+	repository: repository,
+	homepage: homepage,
+	bugs: bugs,
+	bin: bin,
+	files: files,
+	scripts: scripts,
+	exports: exports,
+	imports: imports,
+	dependencies: dependencies,
+	peerDependencies: peerDependencies,
+	devDependencies: devDependencies
+};
+
+const entriesDescription = `
+Specify the build entry-points of the package.json's 'exports' field.
+Support glob pattern and array.
+.e.g. '.', './*', './sub/*', './a,./b'.
+`.trim();
+const filterDescription = `
+Filter the packages from the workspace.
+Support fuzzy match and array.
+.e.g. 'core,utils'.
+`.trim();
+const outdirDescription = `
+The output directory of the build, which relative to the target subpackage root directory.
+Support with variables: 'PKG_NAME',
+.e.g. 'dist/{{PKG_NAME}}'.
+`.trim();
+
+const { notWorkspace } = getWD();
+const IS_WORKSPACE = !notWorkspace;
+
+program.name("jk/jiek").version(pkg.version).description(`${pkg.description} - Version ${pkg.version}`).option("--root <root>", "The root path of the project").option("-c, --config-path <configPath>", "Custom jiek config path");
+if (type$1 !== "" && IS_WORKSPACE) {
+  program.option("-f, --filter <filter>", filterDescription);
+}
+
+const require$2 = createRequire(import.meta.url);
+function packageIsExist(name) {
+  try {
+    require$2.resolve(name);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+let tsRegisterName;
+const registers = [
+  process.env.JIEK_TS_REGISTER,
+  "esbuild-register",
+  "@swc-node/register",
+  "ts-node/register"
+].filter(Boolean);
+for (const register of registers) {
+  if (packageIsExist(register)) {
+    tsRegisterName = register;
+    break;
+  }
+}
+
+const require$1 = createRequire(import.meta.url);
+let configName = "jiek.config";
+function getConfigPath(root, dir) {
+  const isSupportTsLoader = !!tsRegisterName;
+  function configWithExtIsExist(ext) {
+    const filenames = [
+      path.resolve(process.cwd(), `${configName}.${ext}`),
+      path.resolve(process.cwd(), `.${configName}.${ext}`),
+      path.resolve(root, `${configName}.${ext}`),
+      path.resolve(root, `.${configName}.${ext}`)
+    ];
+    if (dir) {
+      filenames.unshift(...[
+        path.resolve(dir, `${configName}.${ext}`),
+        path.resolve(dir, `.${configName}.${ext}`)
+      ]);
+    }
+    for (const filename of filenames) {
+      if (fs.existsSync(filename) && fs.lstatSync(filename).isFile()) {
+        return filename;
+      }
+    }
+    return;
+  }
+  configName = configWithExtIsExist("js") ?? configName;
+  configName = configWithExtIsExist("json") ?? configName;
+  configName = configWithExtIsExist("yaml") ?? configName;
+  if (isSupportTsLoader) {
+    configName = configWithExtIsExist("ts") ?? configName;
+  }
+  return path.resolve(root, configName);
+}
+function loadConfig(dirOrOptions) {
+  let dir;
+  let root;
+  if (typeof dirOrOptions === "object") {
+    dir = dirOrOptions.dir;
+    root = dirOrOptions.root ?? getWD().wd;
+  } else {
+    dir = dirOrOptions;
+    root = getWD().wd;
+  }
+  let configPath = program.getOptionValue("configPath");
+  if (!configPath) {
+    configPath = getConfigPath(root, dir);
+  } else {
+    if (!fs.existsSync(configPath)) {
+      throw new Error(`config file not found: ${configPath}`);
+    }
+    if (!path.isAbsolute(configPath)) {
+      configPath = path.resolve(root, configPath);
+    }
+  }
+  const ext = path.extname(configPath);
+  let module;
+  switch (ext) {
+    case ".js":
+      module = require$1(configPath);
+      break;
+    case ".json":
+      return require$1(configPath);
+    case ".yaml":
+      return load(fs.readFileSync(configPath, "utf-8"));
+    case ".ts":
+      if (tsRegisterName) {
+        require$1(tsRegisterName);
+        module = require$1(configPath);
+        break;
+      }
+      throw new Error(
+        "ts config file is not supported without ts register, please install esbuild-register or set JIEK_TS_REGISTER env for custom ts register"
+      );
+    case ".config":
+      module = {};
+      break;
+    default:
+      throw new Error(`unsupported config file type: ${ext}`);
+  }
+  if (!module)
+    throw new Error("config file is empty");
+  return module.default ?? module;
+}
+
+const BUILDER_TYPES = ["esbuild", "swc"];
+const BUILDER_TYPE_PACKAGE_NAME_MAP = {
+  esbuild: "rollup-plugin-esbuild",
+  swc: "rollup-plugin-swc3"
+};
+
+const FILE_TEMPLATE = (manifest) => `
+module.exports = require('jiek/rollup').template(${JSON.stringify(manifest, null, 2)})
+`.trimStart();
+const require = createRequire(import.meta.url);
+const isDefault = process.env.JIEK_IS_ONLY_BUILD === "true";
+const description = `
+Build the package according to the 'exports' field from the package.json.
+If you want to through the options to the \`rollup\` command, you can pass the options after '--'.
+${isDefault ? "This command is the default command." : ""}
+`.trim();
+async function checkDependency(dependency) {
+  try {
+    require.resolve(dependency);
+  } catch (e) {
+    console.error(`The package '${dependency}' is not installed, please install it first.`);
+    const { notWorkspace } = getWD();
+    const command2 = `pnpm install -${notWorkspace ? "" : "w"}D ${dependency}`;
+    if (await confirm({ message: "Do you want to install it now?" })) {
+      await execaCommand(command2);
+    } else {
+      console.warn(`You can run the command '${command2}' to install it manually.`);
+      process.exit(1);
+    }
+  }
+}
+let DEFAULT_BUILDER_TYPE;
+Object.entries(BUILDER_TYPE_PACKAGE_NAME_MAP).forEach(([type, packageName]) => {
+  try {
+    require.resolve(packageName);
+    DEFAULT_BUILDER_TYPE = type;
+  } catch {
+  }
+});
+if (!DEFAULT_BUILDER_TYPE) {
+  DEFAULT_BUILDER_TYPE = "esbuild";
+}
+function parseBoolean(v) {
+  if (v === void 0)
+    return true;
+  return Boolean(v);
+}
+const buildFilterDescription = `
+${filterDescription}
+If you pass the --filter option, it will merge into the filters of the command.
+`.trim();
+const buildEntriesDescription = `
+${entriesDescription}
+If you pass the --entries option, it will merge into the entries of the command.
+`.trim();
+const command = isDefault ? (() => {
+  const c = program.name("jb/jiek-build").helpCommand(false);
+  if (IS_WORKSPACE) {
+    c.argument("[filters]", buildFilterDescription);
+  } else {
+    c.argument("[entries]", buildEntriesDescription);
+  }
+  return c;
+})() : program.command(`build [${IS_WORKSPACE ? "filters" : "entries"}]`);
+command.description(description).option("-t, --type <TYPE>", `The type of build, support ${BUILDER_TYPES.map((s) => `"${s}"`).join(", ")}.`, (v) => {
+  if (!BUILDER_TYPES.includes(v)) {
+    throw new Error(`The value of 'type' must be ${BUILDER_TYPES.map((s) => `"${s}"`).join(", ")}`);
+  }
+  return String(v);
+}, "esbuild").option("-o, --outdir <OUTDIR>", outdirDescription, String, "dist").option("-e, --entries <ENTRIES>", entriesDescription).option("--external <EXTERNAL>", "Specify the external dependencies of the package.", String).option("-nj, --noJs", "Do not output js files.", parseBoolean).option("-nd, --noDts", "Do not output dts files.", parseBoolean).option("-nm, --noMin", "Do not output minify files.", parseBoolean).option(
+  "--minType <MINTYPE>",
+  'The type of minify, support "builder" and "terser".',
+  (v) => {
+    if (!["builder", "terser"].includes(v)) {
+      throw new Error('The value of `minType` must be "builder" or "terser"');
+    }
+    return String(v);
+  }
+).option("-nc, --noClean", "Do not clean the output directory before building.", parseBoolean).option(
+  "-om, --onlyMin",
+  "Only output minify files, but dts files will still be output, it only replaces the js files.",
+  parseBoolean
+).option("--tsconfig <TSCONFIG>", "The path of the tsconfig file which is used to generate js and dts files.", String).option("--dtsconfig <DTSCONFIG>", "The path of the tsconfig file which is used to generate dts files.", String).option("-w, --watch", "Watch the file changes.", parseBoolean).option("-s, --silent", "Don't display logs.", parseBoolean).option("-v, --verbose", "Display debug logs.", parseBoolean).action(async (commandFiltersOrEntries, options) => {
+  let {
+    type,
+    outdir,
+    watch,
+    silent,
+    verbose,
+    entries: optionEntries,
+    external,
+    noJs: withoutJs,
+    noDts: withoutDts,
+    noMin: withoutMin,
+    minType: minifyType,
+    noClean,
+    onlyMin,
+    tsconfig,
+    dtsconfig
+  } = options;
+  const resolvedType = type ?? DEFAULT_BUILDER_TYPE;
+  if (!withoutJs) {
+    await checkDependency(BUILDER_TYPE_PACKAGE_NAME_MAP[resolvedType]);
+    if (minifyType === "builder") {
+      minifyType = resolvedType;
+    }
+  }
+  if (!withoutMin) {
+    await checkDependency(
+      {
+        ...BUILDER_TYPE_PACKAGE_NAME_MAP,
+        terser: "@rollup/plugin-terser"
+      }[resolvedType]
+    );
+  }
+  let shouldPassThrough = false;
+  const passThroughOptions = process.argv.reduce(
+    (acc, value) => {
+      if (shouldPassThrough) {
+        acc.push(value);
+      }
+      if (value === "--") {
+        shouldPassThrough = true;
+      }
+      return acc;
+    },
+    []
+  );
+  const { build } = loadConfig();
+  silent = silent ?? build?.silent ?? false;
+  if (withoutMin && onlyMin) {
+    throw new Error("Cannot use both --without-minify and --only-minify");
+  }
+  if (onlyMin && withoutJs) {
+    throw new Error("Cannot use --without-js and --only-minify at the same time");
+  }
+  let entries = [
+    optionEntries,
+    IS_WORKSPACE ? void 0 : commandFiltersOrEntries
+  ].filter(Boolean).join(",");
+  if (entries.length === 0) {
+    entries = void 0;
+  }
+  const env = {
+    ...process.env,
+    JIEK_BUILDER: type,
+    JIEK_OUT_DIR: outdir,
+    JIEK_CLEAN: String(!noClean),
+    JIEK_ENTRIES: entries,
+    JIEK_EXTERNAL: external,
+    JIEK_WITHOUT_JS: String(withoutJs),
+    JIEK_WITHOUT_DTS: String(withoutDts),
+    JIEK_WITHOUT_MINIFY: String(withoutMin),
+    JIEK_ONLY_MINIFY: String(onlyMin),
+    JIEK_MINIFY_TYPE: minifyType,
+    JIEK_TSCONFIG: tsconfig,
+    JIEK_DTSCONFIG: dtsconfig
+  };
+  const multiBars = new MultiBar({
+    clearOnComplete: false,
+    hideCursor: true,
+    format: "- {bar} | {status} | {pkgName} | {input} | {message}"
+  }, Presets.shades_classic);
+  const buildPackage = async ({
+    wd,
+    value = {}
+  }) => {
+    if (Object.keys(value).length === 0) {
+      throw new Error("no package found");
+    }
+    const wdNodeModules = path.resolve(wd, "node_modules");
+    if (!fs.existsSync(wdNodeModules)) {
+      fs.mkdirSync(wdNodeModules);
+    }
+    const jiekTempDir = (...paths) => path.resolve(wdNodeModules, ".jiek", ...paths);
+    if (!fs.existsSync(jiekTempDir())) {
+      fs.mkdirSync(jiekTempDir());
+    }
+    const rollupBinaryPath = require.resolve("rollup").replace(/dist\/rollup.js$/, "dist/bin/rollup");
+    let i = 0;
+    await Promise.all(
+      Object.entries(value).map(async ([dir, manifest]) => {
+        if (!manifest.name) {
+          throw new Error("package.json must have a name field");
+        }
+        const escapeManifestName = manifest.name.replace(/^@/g, "").replace(/\//g, "+");
+        const configFile = jiekTempDir(
+          `${escapeManifestName ?? `anonymous-${i++}`}.rollup.config.js`
+        );
+        fs.writeFileSync(configFile, FILE_TEMPLATE(manifest));
+        const command2 = [rollupBinaryPath, "--silent", "-c", configFile];
+        if (tsRegisterName) {
+          command2.unshift(`node -r ${tsRegisterName}`);
+        }
+        if (watch) {
+          command2.push("--watch");
+        }
+        command2.push(...passThroughOptions);
+        const child = execaCommand(command2.join(" "), {
+          ipc: true,
+          cwd: dir,
+          env: {
+            ...env,
+            JIEK_NAME: manifest.name,
+            JIEK_ROOT: wd
+          }
+        });
+        const bars = {};
+        const times = {};
+        const locks = {};
+        let inputMaxLen = 10;
+        child.on("message", (e) => {
+          if (e.type === "debug")
+            console.log(...Array.isArray(e.data) ? e.data : [e.data]);
+        });
+        !silent && child.on("message", (e) => {
+          if (e.type === "init") {
+            const { leafMap, targetsLength } = e.data;
+            const leafs = Array.from(leafMap.entries()).flatMap(
+              ([input, pathAndCondiions]) => pathAndCondiions.map(([path2, ...conditions]) => ({
+                input,
+                path: path2,
+                conditions
+              }))
+            );
+            let initMessage = `Package '${manifest.name}' has ${targetsLength} targets to build`;
+            if (watch) {
+              initMessage += " and watching...";
+            }
+            console.log(initMessage);
+            leafs.forEach(({ input }) => {
+              inputMaxLen = Math.max(inputMaxLen, input.length);
+            });
+            leafs.forEach(({ input, path: path2 }) => {
+              const key = `${input}:${path2}`;
+              if (bars[key])
+                return;
+              bars[key] = multiBars.create(50, 0, {
+                pkgName: manifest.name,
+                input: input.padEnd(inputMaxLen + 5),
+                status: "waiting".padEnd(10)
+              }, {
+                barsize: 20,
+                linewrap: true
+              });
+            });
+          }
+          if (e.type === "progress") {
+            const {
+              path: path2,
+              tags,
+              input,
+              event,
+              message
+            } = e.data;
+            const bar = bars[`${input}:${path2}`];
+            if (!bar)
+              return;
+            const time = times[`${input}:${path2}`];
+            bar.update(
+              {
+                start: 0,
+                resolve: 20,
+                end: 50
+              }[event ?? "start"] ?? 0,
+              {
+                input: (time ? `${input}(x${time.toString().padStart(2, "0")})` : input).padEnd(inputMaxLen + 5),
+                status: event?.padEnd(10),
+                message: `${tags?.join(", ")}: ${message}`
+              }
+            );
+          }
+          if (e.type === "watchChange") {
+            const {
+              path: path2,
+              input
+            } = e.data;
+            const key = `${input}:${path2}`;
+            const bar = bars[key];
+            if (!bar)
+              return;
+            let time = times[key] ?? 1;
+            if (!locks[key]) {
+              time += 1;
+              times[key] = time;
+              setTimeout(() => {
+                locks[key] = false;
+              }, 100);
+              bar.update(0, {
+                input: `${input}(x${time.toString().padStart(2, "0")})`.padEnd(inputMaxLen + 5),
+                status: "watching".padEnd(10),
+                message: "watching..."
+              });
+            }
+            locks[key] = true;
+          }
+        });
+        await new Promise((resolve, reject) => {
+          let errorStr = "";
+          child.stderr?.on("data", (data) => {
+            errorStr += data;
+          });
+          child.once("exit", (code) => code === 0 ? resolve() : reject(new Error(`rollup build failed:
+${errorStr}`)));
+          verbose && child.stdout?.pipe(process.stdout);
+        });
+      })
+    );
+  };
+  const commandFilters = IS_WORKSPACE ? commandFiltersOrEntries : void 0;
+  const filters = [
+    .../* @__PURE__ */ new Set([
+      ...program.getOptionValue("filter")?.split(",").map((s) => s.trim()).filter((s) => s.length > 0) ?? [],
+      ...commandFilters?.split(",").map((s) => s.trim()).filter((s) => s.length > 0) ?? []
+    ])
+  ];
+  try {
+    if (filters.length > 0) {
+      const packages = await filterPackagesGraph(filters);
+      await Promise.all(packages.map(buildPackage));
+    } else {
+      await buildPackage(await getSelectedProjectsGraph());
+    }
+  } finally {
+    multiBars.stop();
+  }
+});
+
+program.parse(process.argv);