jiek 2.2.7-alpha.3 → 2.2.7-alpha.5

package/dist/.internal/bin/common.js

@@ -0,0 +1,750 @@
+import { g as getWD, t as type$1, r as require, f as filterPackagesGraph, a as getSelectedProjectsGraph } from '../.chunks/filterSupport.BXWpLBpT.js';
+import { program } from 'commander';
+import { existsSync, mkdirSync, writeFileSync, statSync } from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import { MultiBar, Presets } from 'cli-progress';
+import { e as execaCommand } from '../.chunks/index.BHuJRlvZ.js';
+import { execSync } from 'node:child_process';
+import { confirm } from '@inquirer/prompts';
+import { BUILDER_TYPE_PACKAGE_NAME_MAP, BUILDER_TYPES } from '../rollup/base.js';
+import Koa from 'koa';
+import { l as loadConfig, t as tsRegisterName } from '../.chunks/loadConfig.CFfzkm_p.js';
+import 'node:module';
+import 'js-yaml';
+import '@jiek/utils/getWorkspaceDir';
+import 'node:url';
+import 'node:string_decoder';
+import 'node:util';
+import 'node:tty';
+import 'child_process';
+import 'path';
+import 'fs';
+import 'node:timers/promises';
+import 'node:os';
+import 'node:events';
+import 'node:v8';
+import 'node:stream';
+import 'node:buffer';
+import 'node:stream/promises';
+
+var name = "jiek";
+var type = "module";
+var version = "2.2.7-alpha.4";
+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 homepage = "https://github.com/NWYLZW/jiek/tree/master/packages/jiek#readme";
+var repository = {
+	url: "nwylzw/jiek",
+	directory: "packages/jiek"
+};
+var bugs = "https://github.com/NWYLZW/jiek/issues?q=is%3Aissue+is%3Aopen+jiek";
+var keywords = [
+	"cli",
+	"zero-config",
+	"bundler",
+	"library",
+	"monorepo",
+	"builder",
+	"rollup",
+	"workspace"
+];
+var exports = {
+	"./package.json": "./package.json",
+	".": "./src/index.ts",
+	"./bin-helper": {
+		require: "./bin-helper/index.cjs",
+		"default": "./bin-helper/index.js"
+	},
+	"./rollup": "./src/rollup/index.ts"
+};
+var imports = {
+	"#~/*": "./src/*.ts"
+};
+var bin = {
+	jiek: "bin/index.cjs",
+	jk: "bin/index.cjs",
+	"jiek-build": "bin/build.cjs",
+	jb: "bin/build.cjs"
+};
+var files = [
+	"LICENSE",
+	"README.md",
+	"bin",
+	"bin-helper",
+	"dist",
+	"src"
+];
+var scripts = {
+	prepublish: "pnpm test && jb -nm && jk",
+	postpublish: "jk",
+	test: "vitest run"
+};
+var peerDependencies = {
+	"@pnpm/filter-workspace-packages": "^7.2.13||^8.0.0||^9.0.0||^10.0.0||>=1000.0.0",
+	"@rollup/plugin-terser": "^0.4.4",
+	"esbuild-register": "^3.5.0",
+	postcss: "^8.4.47",
+	"rollup-plugin-esbuild": "^6.1.0",
+	"rollup-plugin-postcss": "^4.0.2",
+	"rollup-plugin-swc3": "^0.12.1",
+	typescript: "^4.0.0||^5.0.0",
+	"vite-bundle-analyzer": "0.16.0-beta.3"
+};
+var dependencies = {
+	"@inquirer/prompts": "^7.2.0",
+	"@jiek/pkger": "workspace:^",
+	"@jiek/rollup-plugin-dts": "^6.3.8",
+	"@jiek/utils": "workspace:^",
+	"@rollup/plugin-commonjs": "^28.0.0",
+	"@rollup/plugin-inject": "^5.0.5",
+	"@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",
+	"js-yaml": "^4.1.0",
+	"jsonc-parser": "^3.2.1",
+	koa: "^2.15.3",
+	rollup: "^4.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/koa": "^2.15.0",
+	"@types/micromatch": "^4.0.6",
+	"@types/react": "^18.3.14",
+	"esbuild-register": "^3.5.0",
+	execa: "~9.3.1",
+	micromatch: "^4.0.5",
+	"node-sass": "^9.0.0",
+	postcss: "^8.4.47",
+	"rollup-plugin-esbuild": "^6.1.0",
+	"rollup-plugin-postcss": "^4.0.2",
+	"rollup-plugin-swc3": "^0.12.1",
+	"vite-bundle-analyzer": "0.16.0-beta.3"
+};
+var publishConfig = {
+	directory: "./dist/.internal"
+};
+var pkg = {
+	name: name,
+	type: type,
+	version: version,
+	description: description$1,
+	author: author,
+	homepage: homepage,
+	repository: repository,
+	bugs: bugs,
+	keywords: keywords,
+	exports: exports,
+	imports: imports,
+	bin: bin,
+	files: files,
+	scripts: scripts,
+	peerDependencies: peerDependencies,
+	dependencies: dependencies,
+	devDependencies: devDependencies,
+	publishConfig: publishConfig
+};
+
+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("-c, --config-path <configPath>", "Custom jiek config path").option("--env.<name>=<value>", "Set the environment variable.");
+if (type$1 !== "" && IS_WORKSPACE) {
+  program.option("-f, --filter <filter>", filterDescription);
+}
+
+function Main() {
+  const { useState, useMemo, useEffect, useCallback } = React;
+  const [path, setPath] = useState(() => location.pathname.replace(/^\/ana\/?/, ""));
+  const [pkgName, entry] = useMemo(() => {
+    const pkgName2 = /^(@[^/]+\/[^/]+|[^/]+)\/?/.exec(path)?.[1];
+    return [
+      pkgName2,
+      pkgName2 != null ? path.replace(`${pkgName2}/`, "") : void 0
+    ];
+  }, [path]);
+  const push = useCallback((newPath) => {
+    setPath(newPath);
+    document.title = `${document.title.replace(/ - \/.*/, "")} - /${newPath}`;
+    history.pushState(null, "", `/ana/${newPath}`);
+  }, []);
+  const filterModules = useCallback((startWith) => {
+    const modules = analyzeModule.filter((m) => m.filename.startsWith(startWith));
+    dispatchEvent(new CustomEvent("send:filter", { detail: { analyzeModule: modules } }));
+  }, []);
+  useEffect(() => {
+    if (path !== "") {
+      document.title = `${document.title.replace(/ - \/.*/, "")} - /${path}`;
+    } else {
+      document.title = document.title.replace(/ - \/.*/, "");
+    }
+    filterModules(path);
+  }, [path, filterModules]);
+  useEffect(() => {
+    const offGraphClick = listen("graph:click", ({ detail }) => {
+      if (!detail) return;
+      let root = detail.node;
+      while (root.parent) {
+        root = root.parent;
+      }
+      if (root.filename === path) return;
+      push(root.filename);
+    });
+    return () => {
+      offGraphClick();
+    };
+  }, [push]);
+  function listen(type, listener) {
+    window.addEventListener(type, listener);
+    return () => {
+      window.removeEventListener(type, listener);
+    };
+  }
+  return /* @__PURE__ */ React.createElement(
+    "div",
+    {
+      style: {
+        padding: "12px 55px"
+      }
+    },
+    "/",
+    /* @__PURE__ */ React.createElement(
+      "select",
+      {
+        style: {
+          appearance: "none",
+          border: "none",
+          background: "none"
+        },
+        value: pkgName,
+        onChange: (e) => push(e.target.value)
+      },
+      /* @__PURE__ */ React.createElement("option", { value: "" }, "All"),
+      analyzeModule.map((m) => /^(@[^/]+\/[^/]+|[^/]+)\/?/.exec(m.filename)?.[1]).filter((v, i, a) => a.indexOf(v) === i).map((v) => /* @__PURE__ */ React.createElement("option", { key: v, value: v }, v))
+    ),
+    pkgName != null && /* @__PURE__ */ React.createElement(React.Fragment, null, "/", /* @__PURE__ */ React.createElement(
+      "select",
+      {
+        style: {
+          appearance: "none",
+          border: "none",
+          background: "none"
+        },
+        value: entry,
+        onChange: (e) => push(`${pkgName}/${e.target.value}`)
+      },
+      /* @__PURE__ */ React.createElement("option", { value: "" }, "All"),
+      analyzeModule.filter((m) => m.filename.startsWith(`${pkgName}/`)).map((m) => m.filename.replace(`${pkgName}/`, "")).filter((v, i, a) => a.indexOf(v) === i).map((v) => /* @__PURE__ */ React.createElement("option", { key: v, value: v }, v))
+    ))
+  );
+}
+
+function render() {
+  CUSTOM_SIDE_BAR = true;
+  window.addEventListener("client:ready", () => window.dispatchEvent(
+    new CustomEvent("send:ui", {
+      detail: { type: "Main", Component: __REPLACE_INJECT__ }
+    })
+  ));
+}
+const CLIENT_CUSTOM_RENDER_SCRIPT = [
+  Main.toString(),
+  render.toString().replace("__REPLACE_INJECT__", Main.name),
+  `(${render.name})()`
+].join("\n");
+
+function parseBoolean(v) {
+  if (v === void 0) return true;
+  return Boolean(v);
+}
+
+async function checkDependency(dependency) {
+  try {
+    require.resolve(dependency);
+  } catch {
+    console.error(`The package '${dependency}' is not installed, please install it first.`);
+    const { notWorkspace } = getWD();
+    const command = `pnpm add -${notWorkspace ? "" : "w"}D ${dependency}`;
+    if (await confirm({ message: `Do you want to add it now? (${command})` })) {
+      execSync(command, {
+        stdio: "inherit",
+        cwd: process.cwd(),
+        env: process.env
+      });
+    } else {
+      console.warn(`You can run the command '${command}' to install it manually.`);
+      process.exit(1);
+    }
+  }
+}
+
+const registerAnalyzerCommandOptions = (command) => command.option("--ana", "Enable the bundle analyzer.", parseBoolean).option("--ana.dir <DIR>", "The directory of the bundle analyzer.", ".jk-analyses").option(
+  "--ana.mode <MODE>",
+  'The mode of the bundle analyzer, support "static", "json" and "server".',
+  "server"
+).option("--ana.open", "Open the bundle analyzer in the browser.", parseBoolean).option(
+  "--ana.size <SIZE>",
+  'The default size of the bundle analyzer, support "stat", "parsed" and "gzip".',
+  "parsed"
+);
+const useAnalyzer = async (options, server) => {
+  const modules = [];
+  let bundleAnalyzerModule;
+  const analyzer = options.ana ? {
+    dir: options["ana.dir"],
+    mode: options["ana.mode"],
+    open: options["ana.open"],
+    size: options["ana.size"]
+  } : void 0;
+  if (options.ana && ![
+    "stat",
+    "parsed",
+    "gzip"
+  ].includes(analyzer?.size ?? "")) {
+    throw new Error('The value of `ana.size` must be "stat", "parsed" or "gzip"');
+  }
+  if (analyzer) {
+    await checkDependency("vite-bundle-analyzer");
+    bundleAnalyzerModule = await import('vite-bundle-analyzer');
+  }
+  const refreshAnalyzer = async (cwd, applyModules) => {
+    if (!(analyzer && server && bundleAnalyzerModule)) return;
+    if (analyzer.mode === "json") {
+      const anaDir = path.resolve(cwd, analyzer.dir);
+      if (!existsSync(anaDir)) {
+        mkdirSync(anaDir, { recursive: true });
+      }
+      const gitIgnorePath = path.resolve(anaDir, ".gitignore");
+      if (!existsSync(gitIgnorePath)) {
+        writeFileSync(gitIgnorePath, "*\n!.gitignore\n");
+      }
+      const npmIgnorePath = path.resolve(anaDir, ".npmignore");
+      if (!existsSync(npmIgnorePath)) {
+        writeFileSync(npmIgnorePath, "*\n");
+      }
+      if (!statSync(anaDir).isDirectory()) {
+        throw new Error(`The directory '${anaDir}' is not a directory.`);
+      }
+    }
+    const { renderView, injectHTMLTag } = bundleAnalyzerModule;
+    applyModules.forEach((m) => {
+      const index = modules.findIndex(({ filename }) => filename === m.filename);
+      if (index === -1) {
+        modules.push(m);
+      } else {
+        modules[index] = m;
+      }
+    });
+    let html = await renderView(modules, {
+      title: `Jiek Analyzer`,
+      mode: analyzer.size
+    });
+    html = injectHTMLTag({
+      html,
+      injectTo: "body",
+      descriptors: [
+        { kind: "script", text: CLIENT_CUSTOM_RENDER_SCRIPT }
+      ]
+    });
+    void server.renderTo("/ana", html);
+  };
+  return {
+    modules,
+    refreshAnalyzer,
+    ANALYZER_ENV: {
+      JIEK_ANALYZER: analyzer ? JSON.stringify(analyzer) : void 0
+    }
+  };
+};
+
+const createServer = (port, host) => {
+  const app = new Koa();
+  app.listen(port, host);
+  const streams = /* @__PURE__ */ new Map();
+  app.use(async (ctx) => {
+    let stream = streams.get(ctx.path);
+    if (stream == null) {
+      const maybeKey = streams.keys().find((p) => ctx.path.startsWith(p));
+      stream = maybeKey != null ? streams.get(maybeKey) : void 0;
+    }
+    if (stream != null) {
+      ctx.body = stream;
+    }
+  });
+  return {
+    port,
+    host,
+    rootUrl: `http://${host}:${port}`,
+    renderTo: async (path, stream) => {
+      streams.set(path, stream);
+    }
+  };
+};
+
+const FILE_TEMPLATE = (manifest) => `
+module.exports = require('jiek/rollup').template(${JSON.stringify(manifest, null, 2)})
+`.trimStart();
+const ROLLUP_BIN = require.resolve("rollup").replace(/dist\/rollup.js$/, "dist/bin/rollup");
+const isDefault = process.env.JIEK_BIN__FILENAME === "build.cjs";
+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();
+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";
+}
+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();
+let 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 = 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("--noConvert", "Specify the `crossModuleConvertor` option to false.", parseBoolean).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
+);
+command = command.option("--features.keepImportAttributes", "Keep the import attributes in the output.");
+command = command.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);
+command = command.option("-w, --watch", "Watch the file changes.", parseBoolean).option("-p, --port <PORT>", "The port of the server.", Number.parseInt, 8888);
+command = registerAnalyzerCommandOptions(command);
+command = command.option("-s, --silent", "Don't display logs.", parseBoolean).option("-v, --verbose", "Display debug logs.", parseBoolean);
+command.action(async (commandFiltersOrEntries, options) => {
+  let {
+    type,
+    outdir,
+    watch,
+    silent,
+    verbose,
+    entries: optionEntries,
+    external,
+    noConvert,
+    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 && minifyType === "terser") {
+    await checkDependency("@rollup/plugin-terser");
+  }
+  let shouldPassThrough = false;
+  const passThroughOptions = process.argv.reduce(
+    (acc, value) => {
+      if (shouldPassThrough) {
+        acc.push(value);
+      }
+      if (value === "--") {
+        shouldPassThrough = true;
+      }
+      return acc;
+    },
+    []
+  );
+  const shouldCreateServer = [
+    options.ana === true && options["ana.mode"] === "server"
+  ].some(Boolean);
+  const server = shouldCreateServer ? createServer(options.port, "localhost") : void 0;
+  const {
+    ANALYZER_ENV,
+    refreshAnalyzer
+  } = await useAnalyzer(options, server);
+  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 = {
+    ...ANALYZER_ENV,
+    JIEK_BUILDER: type,
+    JIEK_OUT_DIR: outdir,
+    JIEK_CLEAN: String(!noClean),
+    JIEK_ENTRIES: entries,
+    JIEK_EXTERNAL: external,
+    JIEK_CROSS_MODULE_CONVERTOR: String(!noConvert),
+    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,
+    JIEK_FEATURES: JSON.stringify({
+      keepImportAttributes: options["features.keepImportAttributes"]
+    }),
+    ...process.env
+  };
+  const multiBars = new MultiBar({
+    clearOnComplete: false,
+    hideCursor: true,
+    format: "- {bar} | {status} | {pkgName} | {input} | {message}"
+  }, Presets.shades_classic);
+  const { wd } = getWD();
+  const wdNodeModules = path.resolve(wd, "node_modules");
+  if (!existsSync(wdNodeModules)) {
+    mkdirSync(wdNodeModules);
+  }
+  const resolveByJiekTemp = (...paths) => path.resolve(wdNodeModules, ".jiek", ...paths);
+  const jiekTemp = resolveByJiekTemp();
+  if (!existsSync(jiekTemp)) {
+    try {
+      mkdirSync(jiekTemp);
+    } catch (e) {
+      if (e.code !== "EEXIST") {
+        throw e;
+      }
+    }
+  }
+  let i = 0;
+  const buildPackage = async ([pkgCWD, manifest], {
+    resolveByJiekTemp: resolveByJiekTemp2
+  }) => {
+    if (manifest.name == null) {
+      throw new Error("package.json must have a name field");
+    }
+    const escapeManifestName = manifest.name.replace(/^@/g, "").replace(/\//g, "+");
+    const configFile = resolveByJiekTemp2(
+      `${escapeManifestName ?? `anonymous-${i++}`}.rollup.config.js`
+    );
+    writeFileSync(configFile, FILE_TEMPLATE(manifest));
+    const command2 = [ROLLUP_BIN, "--silent", "-c", configFile];
+    if (tsRegisterName != null) {
+      command2.unshift(`node -r ${tsRegisterName}`);
+    }
+    if (watch) {
+      command2.push("--watch");
+    }
+    command2.push(...passThroughOptions);
+    const child = execaCommand(command2.join(" "), {
+      ipc: true,
+      cwd: pkgCWD,
+      windowsHide: true,
+      env: {
+        ...env,
+        JIEK_NAME: manifest.name,
+        JIEK_ROOT: wd
+      }
+    });
+    const bars = {};
+    const times = {};
+    const locks = {};
+    let inputMaxLen = 10;
+    child.on("message", (e) => {
+      if (silent && [
+        "init",
+        "progress",
+        "watchChange"
+      ].includes(e.type)) return;
+      switch (e.type) {
+        case "init": {
+          const { leafMap, targetsLength } = e.data;
+          const leafs = Array.from(leafMap.entries()).flatMap(
+            ([input, pathAndConditions]) => pathAndConditions.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
+            });
+          });
+          break;
+        }
+        case "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}`
+            }
+          );
+          break;
+        }
+        case "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;
+          break;
+        }
+        case "modulesAnalyze": {
+          const {
+            data: {
+              type: type2,
+              modules: pkgModules
+            }
+          } = e;
+          void refreshAnalyzer(
+            pkgCWD,
+            pkgModules.map((m) => ({
+              ...m,
+              type: type2,
+              filename: `${manifest.name}/${m.filename}`,
+              label: `${manifest.name}/${m.label}`
+            }))
+          );
+          break;
+        }
+        case "debug": {
+          console.log(...Array.isArray(e.data) ? e.data : [e.data]);
+          break;
+        }
+      }
+    });
+    await new Promise((resolve, reject) => {
+      let errorStr = `rollup build failed
+package name: ${manifest.name}
+cwd: ${pkgCWD}
+
+`;
+      child.stderr?.on("data", (data) => {
+        errorStr += data;
+      });
+      child.once("exit", (code) => code === 0 ? resolve() : reject(new Error(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 {
+    const packages = (filters.length > 0 ? await filterPackagesGraph(filters) : [await getSelectedProjectsGraph()]).flatMap(({ value }) => Object.entries(value ?? {}));
+    await Promise.allSettled(
+      packages.map(async ([cwd, manifest]) => buildPackage([cwd, manifest], { resolveByJiekTemp }))
+    );
+  } finally {
+    multiBars.stop();
+    !silent && console.log("Build complete");
+  }
+});