jiek 0.4.7-alpha.14 → 0.4.7-alpha.3

package/dist/cli.mjs

@@ -0,0 +1,803 @@
+import fs from 'node:fs';
+import path, { resolve as resolve$1, relative } 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 { MultiBar, Presets } from 'cli-progress';
+import { execaCommand } from 'execa';
+import detectIndent from 'detect-indent';
+import inquirer from 'inquirer';
+import { applyEdits, modify } from 'jsonc-parser';
+import { isMatch } from 'micromatch';
+import * as childProcess from 'node:child_process';
+import { bump } from '@jiek/utils/bumper';
+import { resolveEntrypoints, filterLeafs, DEFAULT_SKIP_VALUES, entrypoints2Exports } from '@jiek/pkger/entrypoints';
+
+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 = false;
+function getWD() {
+  if (wd)
+    return { wd, notWorkspace };
+  const root = getRoot();
+  if (root !== void 0) {
+    const isWorkspace = isWorkspaceDir(root, type);
+    notWorkspace = !isWorkspace;
+    wd = root;
+    return { wd, notWorkspace };
+  }
+  try {
+    wd = getWorkspaceDir(type);
+  } catch (e) {
+    if ("message" in e && e.message === "workspace root not found") {
+      wd = root;
+      notWorkspace = true;
+    } else {
+      throw e;
+    }
+  }
+  return { wd, notWorkspace };
+}
+
+let type = "";
+try {
+  require.resolve("@pnpm/filter-workspace-packages");
+  type = "pnpm";
+} catch {
+}
+if (type !== "") {
+  program.option("-f, --filter <filter>", "filter packages");
+}
+async function getSelectedProjectsGraph() {
+  let filter = program.getOptionValue("filter");
+  const root = getRoot();
+  const { wd, notWorkspace } = getWD();
+  if (!notWorkspace && type === "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 !== 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;
+      }, {})
+    };
+  }
+  return {
+    wd,
+    root,
+    value: {
+      [wd]: JSON.parse(fs.readFileSync(path.resolve(wd, "package.json"), "utf-8"))
+    }
+  };
+}
+
+var pkg = require("../package.json");
+
+program.version(pkg.version).description(pkg.description).option("--root <root>", "root path").option("-c, --config-path <configPath>", "config path");
+
+let resolve;
+function actionDone() {
+  resolve();
+}
+function actionRestore() {
+  new Promise((r) => resolve = r);
+}
+
+function packageIsExist(name) {
+  try {
+    require.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;
+  }
+}
+
+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(dir) {
+  const { wd: root } = getWD();
+  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(configPath);
+      break;
+    case ".json":
+      return require(configPath);
+    case ".yaml":
+      return load(fs.readFileSync(configPath, "utf-8"));
+    case ".ts":
+      if (tsRegisterName) {
+        require(tsRegisterName);
+        module = require(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 FILE_TEMPLATE = (manifest) => `
+const manifest = ${JSON.stringify(manifest, null, 2)}
+module.exports = require('jiek/rollup').template(manifest)
+`.trimStart();
+program.command("build").option("-s, --silent", "Don't display logs.").option("-e, --entries <ENTRIES>", "Specify the entries of the package.json's 'exports' field.(support glob)").action(async ({
+  silent,
+  entries
+}) => {
+  actionRestore();
+  const { build } = loadConfig();
+  silent = silent ?? build?.silent ?? false;
+  const {
+    wd,
+    value = {}
+  } = await getSelectedProjectsGraph() ?? {};
+  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");
+  const multiBars = new MultiBar({
+    clearOnComplete: false,
+    hideCursor: true,
+    format: "- {bar} | {status} | {input} | {message}"
+  }, Presets.shades_classic);
+  let i = 0;
+  await Promise.all(
+    Object.entries(value).map(async ([dir, manifest]) => {
+      const escapeManifestName = manifest.name?.replace(/^@/g, "").replace(/\//g, "+");
+      const configFile = jiekTempDir(
+        `${escapeManifestName ?? `anonymous-${i++}`}.rollup.config.js`
+      );
+      fs.writeFileSync(configFile, FILE_TEMPLATE(manifest));
+      let prefix = "";
+      if (tsRegisterName) {
+        prefix = `node -r ${tsRegisterName} `;
+      }
+      const command = `${prefix}${rollupBinaryPath} --silent -c ${configFile}`;
+      const child = execaCommand(command, {
+        ipc: true,
+        cwd: dir,
+        env: {
+          ...process.env,
+          JIEK_ROOT: wd,
+          JIEK_ENTRIES: entries
+        }
+      });
+      const bars = {};
+      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
+            }))
+          );
+          console.log(`Package '${manifest.name}' has ${targetsLength} targets to build`);
+          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, {
+              input: input.padEnd(inputMaxLen),
+              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;
+          bar.update(
+            {
+              start: 0,
+              resolve: 20,
+              end: 50
+            }[event ?? "start"] ?? 0,
+            {
+              input: input.padEnd(inputMaxLen),
+              status: event?.padEnd(10),
+              message: `${tags?.join(", ")}: ${message}`
+            }
+          );
+        }
+      });
+      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}`)));
+      });
+    })
+  ).finally(() => {
+    multiBars.stop();
+  });
+  actionDone();
+});
+
+const PACKAGE_JSON_TEMPLATE = `{
+  "name": "",
+  "version": "0.0.1",
+  "description": "",
+  "license": "",
+  "author": "",
+  "files": ["dist"],
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "scripts": {
+  },
+  "homepage": "",
+  "repository": "",
+  "bugs": ""
+}`.trimStart();
+const README_TEMPLATE = `# $name
+
+## Installation
+
+\`\`\`bash
+npm install $name
+# or
+pnpm install $name
+# or
+yarn add $name
+\`\`\`
+
+## Usage
+
+
+## License
+
+$license
+`.trimStart();
+function getTemplateStr(wd, template) {
+  let templateString = template ?? PACKAGE_JSON_TEMPLATE;
+  let isTemplateFile = false;
+  try {
+    if (template)
+      JSON.parse(template);
+  } catch (e) {
+    isTemplateFile = true;
+  }
+  if (isTemplateFile) {
+    const templatePath = path.resolve(wd, template);
+    templateString = fs.readFileSync(templatePath, "utf-8");
+  }
+  return templateString;
+}
+const wdCache = /* @__PURE__ */ new Map();
+function getWDPackageJSONFiled(wd, field) {
+  if (wdCache.has(wd)) {
+    return wdCache.get(wd)[field];
+  }
+  const packageJSONPath = path.resolve(wd, "package.json");
+  const packageJSON = JSON.parse(fs.readFileSync(packageJSONPath, "utf-8"));
+  wdCache.set(wd, packageJSON);
+  return packageJSON[field];
+}
+async function getName(named, name, {
+  wd,
+  cwd,
+  workspaceName
+}) {
+  const relativePath = cwd.replace(`${wd}/`, "");
+  let basename = path.basename(cwd);
+  if (typeof named === "function") {
+    return named(name, {
+      full: wd,
+      relative: cwd
+    });
+  }
+  let isParentMatched = false;
+  let matchedKey;
+  let matchedRule;
+  if (typeof named === "object") {
+    const isWD = cwd === wd;
+    if (isWD) {
+      const { rule } = await inquirer.prompt({
+        type: "list",
+        name: "rule",
+        message: "choose a rule",
+        default: "default",
+        choices: ["default"].concat(Object.keys(named))
+      });
+      if (rule !== "default") {
+        matchedKey = rule;
+        matchedRule = named[rule];
+      }
+    } else {
+      for (const [key, value] of Object.entries(named)) {
+        if (isMatch(relativePath, key)) {
+          matchedKey = key;
+          matchedRule = value;
+          break;
+        }
+        if (isMatch(`${relativePath}/jiek_ignore_dont_use_same_file_name`, key)) {
+          isParentMatched = true;
+          matchedKey = key;
+          matchedRule = value;
+          break;
+        }
+      }
+    }
+  }
+  if (!matchedRule) {
+    matchedKey = "packages/*";
+    matchedRule = `@${workspaceName}/$basename`;
+  }
+  if (!matchedRule) {
+    throw new Error("no matched rule");
+  }
+  if (!name && isParentMatched) {
+    basename = await inquirer.prompt({
+      type: "input",
+      name: "name",
+      message: `the matched rule is \`${String(matchedRule)}\`, please input the basename
+`
+    }).then(({ name: name2 }) => name2);
+  }
+  if (typeof matchedRule === "function") {
+    return matchedRule(name, {
+      full: wd,
+      relative: cwd,
+      basename
+    });
+  }
+  if (typeof matchedRule === "string") {
+    const dirName = name ?? basename;
+    return [
+      matchedRule.replace(/\$basename/g, dirName),
+      matchedKey?.replace(/\/\*$/g, `/${dirName}`)
+    ];
+  }
+  throw new Error("no matched rule");
+}
+program.command("init [name]").option("-t, --template <template>", "the package.json template file path or file content").action(async () => {
+  const [, name] = program.args;
+  const cwd = process.cwd();
+  const { init = {} } = loadConfig() ?? {};
+  const { wd } = getWD();
+  const workspaceName = path.basename(wd);
+  const {
+    named,
+    template,
+    bug = {},
+    readme: _readme = README_TEMPLATE,
+    readmeTemplate
+  } = init;
+  const resolvedBug = {
+    template: "bug_report.yml",
+    labels: ["bug"],
+    ...bug
+  };
+  let readme = _readme;
+  if (readmeTemplate) {
+    const readmeTemplatePath = path.resolve(wd, readmeTemplate);
+    readme = fs.readFileSync(readmeTemplatePath, "utf-8");
+  }
+  const templateString = getTemplateStr(wd, template);
+  const { indent = "    " } = detectIndent(templateString);
+  const formattingOptions = {
+    tabSize: indent.length,
+    insertSpaces: true
+  };
+  const passFields = [
+    "license",
+    "author"
+  ];
+  let newJSONString = templateString;
+  for (const field of passFields) {
+    newJSONString = applyEdits(
+      newJSONString,
+      modify(
+        newJSONString,
+        [field],
+        getWDPackageJSONFiled(wd, field),
+        { formattingOptions }
+      )
+    );
+  }
+  let [pkgName, pkgDir] = await getName(named, name, {
+    wd,
+    cwd,
+    workspaceName
+  });
+  if (!pkgDir) {
+    const { dir } = await inquirer.prompt({
+      type: "input",
+      name: "dir",
+      message: "package directory",
+      default: name
+    });
+    pkgDir = dir;
+  }
+  if (!pkgName) {
+    const { name: inputName } = await inquirer.prompt({
+      type: "input",
+      name: "name",
+      message: "package name",
+      default: name
+    });
+    pkgName = inputName;
+  }
+  newJSONString = applyEdits(newJSONString, modify(newJSONString, ["name"], pkgName, { formattingOptions }));
+  let pkgRepo = getWDPackageJSONFiled(wd, "repository");
+  if (typeof pkgRepo === "string") {
+    pkgRepo = {
+      type: "git",
+      url: pkgRepo,
+      directory: pkgDir
+    };
+  }
+  newJSONString = applyEdits(
+    newJSONString,
+    modify(
+      newJSONString,
+      ["repository"],
+      pkgRepo,
+      { formattingOptions }
+    )
+  );
+  const homepage = `${pkgRepo?.url}/blob/master/${pkgDir}/README.md`;
+  newJSONString = applyEdits(
+    newJSONString,
+    modify(
+      newJSONString,
+      ["homepage"],
+      homepage,
+      { formattingOptions }
+    )
+  );
+  let labels = resolvedBug.labels;
+  if (typeof labels === "function") {
+    labels = labels({
+      name: pkgName,
+      dir: pkgDir
+    });
+  }
+  labels.push(`scope:${pkgName}`);
+  const bugs = `${pkgRepo?.url}/issues/new?template=${resolvedBug.template}&labels=${labels.join(",")}`;
+  newJSONString = applyEdits(
+    newJSONString,
+    modify(
+      newJSONString,
+      ["bugs"],
+      bugs,
+      { formattingOptions }
+    )
+  );
+  function pkgDirTo(to) {
+    if (!pkgDir)
+      throw new Error("pkgDir is not defined");
+    return path.resolve(pkgDir, to);
+  }
+  if (!fs.existsSync(pkgDir))
+    fs.mkdirSync(pkgDir);
+  const pkgJSONFilePath = pkgDirTo("package.json");
+  if (fs.existsSync(pkgJSONFilePath)) {
+    throw new Error("package.json already exists");
+  }
+  fs.writeFileSync(pkgJSONFilePath, newJSONString);
+  console.log(newJSONString, "written to", pkgJSONFilePath);
+  const license = getWDPackageJSONFiled(wd, "license");
+  const readmeFilePath = pkgDirTo("README.md");
+  if (typeof readme === "function") {
+    readme = readme({
+      dir: pkgDir,
+      packageJson: JSON.parse(newJSONString)
+    });
+  }
+  const readmeContent = readme.replace(/\$name/g, pkgName).replace(/\$license/g, license);
+  fs.writeFileSync(readmeFilePath, readmeContent);
+});
+
+const intersection = (a, b) => new Set([...a].filter((i) => b.has(i)));
+function getExports({
+  entrypoints,
+  pkgIsModule,
+  entries,
+  config,
+  dir,
+  noFilter
+}) {
+  const dirResolve = (...paths) => resolve$1(dir ?? process.cwd(), ...paths);
+  const dirRelative = (path) => relative(dir ?? process.cwd(), path);
+  const { build = {} } = config ?? {};
+  const {
+    crossModuleConvertor = true
+  } = build;
+  const jsOutdir = `./${dirRelative(dirResolve(
+    (typeof build?.output?.dir === "object" ? build.output.dir.js : build?.output?.dir) ?? "dist"
+  ))}`;
+  const [, resolvedEntrypoints] = resolveEntrypoints(entrypoints);
+  if (entries) {
+    Object.entries(resolvedEntrypoints).forEach(([key]) => {
+      if (!entries.some((e) => isMatch(key, e, { matchBase: true }))) {
+        delete resolvedEntrypoints[key];
+      }
+    });
+  }
+  const filteredResolvedEntrypoints = noFilter ? resolvedEntrypoints : filterLeafs(
+    resolvedEntrypoints,
+    {
+      skipValue: [
+        // ignore values that filename starts with `.jk-noentry`
+        /(^|\/)\.jk-noentry/,
+        ...DEFAULT_SKIP_VALUES
+      ]
+    }
+  );
+  const crossModuleWithConditional = crossModuleConvertor ? {
+    import: (opts) => !pkgIsModule && intersection(
+      new Set(opts.conditionals),
+      /* @__PURE__ */ new Set(["import", "module"])
+    ).size === 0 ? opts.dist.replace(/\.js$/, ".mjs") : false,
+    require: (opts) => pkgIsModule && intersection(
+      new Set(opts.conditionals),
+      /* @__PURE__ */ new Set(["require", "node"])
+    ).size === 0 ? opts.dist.replace(/\.js$/, ".cjs") : false
+  } : {};
+  return [
+    filteredResolvedEntrypoints,
+    entrypoints2Exports(filteredResolvedEntrypoints, {
+      outdir: jsOutdir,
+      withConditional: {
+        ...crossModuleWithConditional
+      }
+    })
+  ];
+}
+
+program.command("publish").aliases(["pub", "p"]).option("-b, --bumper <bumper>", "bump version", "patch").option("-p, --preview", "preview publish").action(async ({ preview, bumper, ...options }) => {
+  actionRestore();
+  const { value = {} } = await getSelectedProjectsGraph() ?? {};
+  const selectedProjectsGraphEntries = Object.entries(value);
+  if (selectedProjectsGraphEntries.length === 0) {
+    throw new Error("no packages selected");
+  }
+  const manifests = selectedProjectsGraphEntries.map(([dir, manifest]) => {
+    const { type, exports: entrypoints = {} } = manifest;
+    const pkgIsModule = type === "module";
+    const newManifest = { ...manifest };
+    const [resolvedEntrypoints, exports] = getExports({
+      entrypoints,
+      pkgIsModule,
+      config: loadConfig(dir),
+      dir,
+      noFilter: true
+    });
+    newManifest.exports = {
+      ...resolvedEntrypoints,
+      ...exports
+    };
+    return [dir, newManifest];
+  });
+  const passArgs = Object.entries(options).reduce((acc, [key, value2]) => {
+    if (value2) {
+      acc.push(`--${key}`, value2);
+    }
+    return acc;
+  }, []);
+  for (const [dir, manifest] of manifests) {
+    const oldJSONString = fs.readFileSync(path.join(dir, "package.json"), "utf-8");
+    const oldJSON = JSON.parse(oldJSONString) ?? "0.0.0";
+    const newVersion = bump(oldJSON.version, bumper);
+    const { indent = "    " } = detectIndent(oldJSONString);
+    const formattingOptions = {
+      tabSize: indent.length,
+      insertSpaces: true
+    };
+    let newJSONString = oldJSONString;
+    newJSONString = applyEdits(
+      newJSONString,
+      modify(
+        newJSONString,
+        ["version"],
+        newVersion,
+        { formattingOptions }
+      )
+    );
+    for (const [key, value2] of Object.entries(manifest)) {
+      if (JSON.stringify(value2) === JSON.stringify(oldJSON[key]))
+        continue;
+      if (key !== "exports") {
+        newJSONString = applyEdits(
+          newJSONString,
+          modify(
+            newJSONString,
+            ["publishConfig", key],
+            value2,
+            { formattingOptions }
+          )
+        );
+      } else {
+        const exports = value2;
+        for (const [k, v] of Object.entries(exports)) {
+          newJSONString = applyEdits(
+            newJSONString,
+            modify(
+              newJSONString,
+              ["publishConfig", "exports", k],
+              v,
+              { formattingOptions }
+            )
+          );
+        }
+        const index = exports?.["."];
+        const indexPublishConfig = {};
+        if (index) {
+          switch (typeof index) {
+            case "string":
+              indexPublishConfig[manifest?.type === "module" ? "module" : "main"] = index;
+              break;
+            case "object": {
+              const indexExports = index;
+              indexPublishConfig.main = indexExports["require"] ?? indexExports["default"];
+              indexPublishConfig.module = indexExports["import"] ?? indexExports["module"] ?? indexExports["default"];
+              break;
+            }
+          }
+          for (const [k, v] of Object.entries(indexPublishConfig)) {
+            if (v === void 0)
+              continue;
+            newJSONString = applyEdits(
+              newJSONString,
+              modify(
+                newJSONString,
+                ["publishConfig", k],
+                v,
+                { formattingOptions }
+              )
+            );
+          }
+        }
+      }
+    }
+    try {
+      fs.renameSync(path.join(dir, "package.json"), path.join(dir, "package.json.bak"));
+      fs.writeFileSync(path.join(dir, "package.json"), newJSONString);
+      console.log(newJSONString);
+      if (preview) {
+        console.warn("preview mode");
+        continue;
+      }
+      childProcess.execSync(["pnpm", "publish", "--access", "public", "--no-git-checks", ...passArgs].join(" "), {
+        cwd: dir,
+        stdio: "inherit"
+      });
+      const modifyVersionPackageJSON = applyEdits(oldJSONString, modify(oldJSONString, ["version"], newVersion, {}));
+      fs.writeFileSync(path.join(dir, "package.json.bak"), modifyVersionPackageJSON);
+    } finally {
+      fs.unlinkSync(path.join(dir, "package.json"));
+      fs.renameSync(path.join(dir, "package.json.bak"), path.join(dir, "package.json"));
+    }
+  }
+  actionDone();
+});
+
+program.parse(process.argv);