jiek 2.0.1 → 2.0.2-alpha.10

package/{dist/cli.js → cli.js}

@@ -1,20 +1,113 @@
+import * as childProcess from 'node:child_process';
 import fs from 'node:fs';
-import path, { isAbsolute, relative, resolve as resolve$1 } from 'node:path';
+import path, { isAbsolute, relative, resolve } from 'node:path';
+import { TAGS, bump } from '@jiek/utils/bumper';
 import { program } from 'commander';
 import detectIndent from 'detect-indent';
-import inquirer from 'inquirer';
 import { applyEdits, modify } from 'jsonc-parser';
-import require$$0 from 'util';
-import require$$0$1 from 'path';
-import { isWorkspaceDir, getWorkspaceDir } from '@jiek/utils/getWorkspaceDir';
 import { createRequire } from 'node:module';
 import { filterPackagesFromDir } from '@pnpm/filter-workspace-packages';
 import { load } from 'js-yaml';
-import * as childProcess from 'node:child_process';
-import { bump, TAGS } from '@jiek/utils/bumper';
+import { isWorkspaceDir, getWorkspaceDir } from '@jiek/utils/getWorkspaceDir';
 import { resolveEntrypoints, filterLeafs, DEFAULT_SKIP_VALUES, entrypoints2Exports } from '@jiek/pkger/entrypoints';
+import require$$0 from 'util';
+import require$$0$1 from 'path';
 import 'jiek/cli-only-build';
 
+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 {
+  const require = createRequire(import.meta.url);
+  require.resolve("@pnpm/filter-workspace-packages");
+  type = "pnpm";
+} catch {
+}
+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 === "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}`);
+}
+
 var utils$1 = {};
 
 var hasRequiredUtils$1;
@@ -4121,98 +4214,94 @@ function requireMicromatch () {
 
 var micromatchExports = requireMicromatch();
 
-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 type = "";
-try {
-  const require = createRequire(import.meta.url);
-  require.resolve("@pnpm/filter-workspace-packages");
-  type = "pnpm";
-} catch {
-}
-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"))
-      }
-    };
+const intersection = (a, b) => new Set([...a].filter((i) => b.has(i)));
+const {
+  JIEK_OUT_DIR
+} = process.env;
+const OUTDIR = JIEK_OUT_DIR ?? "dist";
+function getOutDirs({
+  cwd = process.cwd(),
+  defaultOutdir = OUTDIR,
+  config,
+  pkgName
+}) {
+  const { build = {} } = config ?? {};
+  const outdir = build?.output?.dir;
+  function resolveOutdir(type) {
+    const dir = (typeof outdir === "object" ? outdir[type] ?? outdir[{
+      js: "dts",
+      dts: "js"
+    }[type]] : outdir) ?? defaultOutdir;
+    return (isAbsolute(dir) ? dir : `./${relative(cwd, resolve(cwd, dir))}`).replace("{{PKG_NAME}}", pkgName);
   }
-  if (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 === 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");
+  return {
+    js: resolveOutdir("js"),
+    dts: resolveOutdir("dts")
+  };
+}
+function getExports({
+  entrypoints,
+  pkgName,
+  pkgIsModule,
+  entries,
+  config,
+  dir,
+  defaultOutdir = OUTDIR,
+  // FIXME dts support
+  outdir = getOutDirs({ pkgName, defaultOutdir, config, cwd: dir }).js,
+  noFilter,
+  isPublish
+}) {
+  const {
+    build = {},
+    publish: {
+      withSuffix = false,
+      withSource = true
+    } = {}
+  } = config ?? {};
+  const {
+    crossModuleConvertor = true
+  } = build;
+  const [, resolvedEntrypoints] = resolveEntrypoints(entrypoints);
+  if (entries) {
+    Object.entries(resolvedEntrypoints).forEach(([key]) => {
+      if (!entries.some((e) => micromatchExports.isMatch(key, e, { matchBase: true }))) {
+        delete resolvedEntrypoints[key];
       }
-      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}`);
-}
-
-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;
+  const filteredResolvedEntrypoints = noFilter ? resolvedEntrypoints : filterLeafs(
+    resolvedEntrypoints,
+    {
+      skipValue: [
+        // ignore values that filename starts with `.jk-noentry`
+        /(^|\/)\.jk-noentry/,
+        ...DEFAULT_SKIP_VALUES
+      ]
     }
-  }
-  return { wd, notWorkspace };
+  );
+  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,
+      withSuffix: isPublish ? withSuffix : void 0,
+      withSource: isPublish ? withSource : void 0,
+      withConditional: {
+        ...crossModuleWithConditional
+      }
+    }),
+    outdir
+  ];
 }
 
 const require$1 = createRequire(import.meta.url);
@@ -4321,394 +4410,65 @@ function loadConfig(dirOrOptions) {
   return module.default ?? module;
 }
 
-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 (micromatchExports.isMatch(relativePath, key)) {
-          matchedKey = key;
-          matchedRule = value;
-          break;
-        }
-        if (micromatchExports.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);
-});
-
-let resolve;
-function actionDone() {
-  resolve();
-}
-function actionRestore() {
-  new Promise((r) => resolve = r);
-}
-
-const intersection = (a, b) => new Set([...a].filter((i) => b.has(i)));
-const {
-  JIEK_OUT_DIR
-} = process.env;
-const OUTDIR = JIEK_OUT_DIR ?? "dist";
-function getOutDirs({
-  cwd = process.cwd(),
-  defaultOutdir = OUTDIR,
-  config,
-  pkgName
-}) {
-  const { build = {} } = config ?? {};
-  const outdir = build?.output?.dir;
-  function resolveOutdir(type) {
-    const dir = (typeof outdir === "object" ? outdir[type] ?? outdir[{
-      js: "dts",
-      dts: "js"
-    }[type]] : outdir) ?? defaultOutdir;
-    return (isAbsolute(dir) ? dir : `./${relative(cwd, resolve$1(cwd, dir))}`).replace("{{PKG_NAME}}", pkgName);
-  }
-  return {
-    js: resolveOutdir("js"),
-    dts: resolveOutdir("dts")
-  };
-}
-function getExports({
-  entrypoints,
-  pkgName,
-  pkgIsModule,
-  entries,
-  config,
-  dir,
-  defaultOutdir = OUTDIR,
-  // FIXME dts support
-  outdir = getOutDirs({ pkgName, defaultOutdir, config, cwd: dir }).js,
-  noFilter,
-  isPublish
-}) {
-  const {
-    build = {},
-    publish: {
-      withSuffix = false,
-      withSource = true
-    } = {}
-  } = config ?? {};
-  const {
-    crossModuleConvertor = true
-  } = build;
-  const [, resolvedEntrypoints] = resolveEntrypoints(entrypoints);
-  if (entries) {
-    Object.entries(resolvedEntrypoints).forEach(([key]) => {
-      if (!entries.some((e) => micromatchExports.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,
-      withSuffix: isPublish ? withSuffix : void 0,
-      withSource: isPublish ? withSource : void 0,
-      withConditional: {
-        ...crossModuleWithConditional
-      }
-    }),
-    outdir
-  ];
-}
-
 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();
 
-program.command("publish").aliases(["pub", "p"]).option("-b, --bumper <bumper>", "bump version", "patch").option("-no-b, --no-bumper", "no bump version").option("-o, --outdir <OUTDIR>", outdirDescription, String, "dist").option("-s, --silent", "no output").option("-p, --preview", "preview publish").action(async ({ outdir, preview, silent, bumper, ...options }) => {
-  actionRestore();
+const description = `
+Publish package to npm registry, and auto generate exports field and other fields in published package.json.
+If you want to through the options to the \`pnpm publish\` command, you can pass the options after '--'.
+`.trim();
+async function forEachSelectedProjectsGraphEntries(callback) {
   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]) => {
+  for (const [dir, manifest] of selectedProjectsGraphEntries) {
+    callback(dir, manifest);
+  }
+}
+program.command("publish").description(description).aliases(["pub", "p"]).option("-b, --bumper <bumper>", "bump version", "patch").option("-no-b, --no-bumper", "no bump version").option("-o, --outdir <OUTDIR>", outdirDescription, String, "dist").action(async ({ outdir, bumper }) => {
+  let shouldPassThrough = false;
+  const passThroughOptions = process.argv.reduce(
+    (acc, value) => {
+      if (shouldPassThrough) {
+        acc.push(value);
+      }
+      if (value === "--") {
+        shouldPassThrough = true;
+      }
+      return acc;
+    },
+    []
+  );
+  await forEachSelectedProjectsGraphEntries((dir) => {
+    const args = ["pnpm", "publish", "--access", "public", "--no-git-checks"];
+    if (bumper && TAGS.includes(bumper)) {
+      args.push("--tag", bumper);
+    }
+    args.push(...passThroughOptions);
+    childProcess.execSync(args.join(" "), {
+      cwd: dir,
+      stdio: "inherit",
+      env: {
+        ...process.env,
+        JIEK_PUBLISH_OUTDIR: JSON.stringify(outdir),
+        JIEK_PUBLISH_BUMPER: JSON.stringify(bumper)
+      }
+    });
+  });
+});
+async function prepublish() {
+  const {
+    JIEK_PUBLISH_OUTDIR: outdirEnv,
+    JIEK_PUBLISH_BUMPER: bumperEnv
+  } = process.env;
+  const outdir = outdirEnv ? JSON.parse(outdirEnv) : "dist";
+  const bumper = bumperEnv ? JSON.parse(bumperEnv) : false;
+  const generateNewManifest = (dir, manifest) => {
     const { name, type, exports: entrypoints = {} } = manifest;
     if (!name) {
       throw new Error(`package.json in ${dir} must have a name field`);
@@ -4729,35 +4489,38 @@ program.command("publish").aliases(["pub", "p"]).option("-b, --bumper <bumper>",
       ...resolvedEntrypoints,
       ...exports
     };
-    return [dir, newManifest, resolvedOutdir];
-  });
-  const passArgs = Object.entries(options).reduce((acc, [key, value2]) => {
-    if (value2) {
-      acc.push(`--${key}`, value2);
-    }
-    return acc;
-  }, []);
-  for (const [dir, manifest, resolvedOutdir] of manifests) {
-    const oldJSONString = fs.readFileSync(path.join(dir, "package.json"), "utf-8");
-    const oldJSON = JSON.parse(oldJSONString) ?? "0.0.0";
-    const newVersion = bumper ? bump(oldJSON.version, bumper) : oldJSON.version;
-    const { indent = "    " } = detectIndent(oldJSONString);
-    const formattingOptions = {
-      tabSize: indent.length,
-      insertSpaces: true
-    };
+    return [newManifest, resolvedOutdir];
+  };
+  const generateNewPackageJSONString = ({
+    oldJSONString,
+    oldJSON,
+    manifest,
+    formattingOptions
+  }) => {
     let newJSONString = oldJSONString;
     newJSONString = applyEdits(
       newJSONString,
       modify(
         newJSONString,
-        ["version"],
-        newVersion,
+        ["publishConfig", "typesVersions"],
+        {
+          "<5.0": {
+            "*": [
+              "*",
+              `./*`,
+              `./*/index.d.ts`,
+              `./*/index.d.mts`,
+              `./*/index.d.cts`
+            ]
+          }
+        },
         { formattingOptions }
       )
     );
-    for (const [key, value2] of Object.entries(manifest)) {
-      if (JSON.stringify(value2) === JSON.stringify(oldJSON[key]))
+    for (const [key, value] of Object.entries(manifest)) {
+      if (key === "version")
+        continue;
+      if (JSON.stringify(value) === JSON.stringify(oldJSON[key]))
         continue;
       if (key !== "exports") {
         newJSONString = applyEdits(
@@ -4765,12 +4528,12 @@ program.command("publish").aliases(["pub", "p"]).option("-b, --bumper <bumper>",
           modify(
             newJSONString,
             ["publishConfig", key],
-            value2,
+            value,
             { formattingOptions }
           )
         );
       } else {
-        const exports = value2;
+        const exports = value;
         for (const [k, v] of Object.entries(exports)) {
           newJSONString = applyEdits(
             newJSONString,
@@ -4812,46 +4575,138 @@ program.command("publish").aliases(["pub", "p"]).option("-b, --bumper <bumper>",
         }
       }
     }
-    newJSONString = applyEdits(
-      newJSONString,
-      modify(
-        newJSONString,
-        ["publishConfig", "typesVersions"],
-        {
-          "<5.0": {
-            "*": [
-              "*",
-              `${resolvedOutdir}/*`,
-              `${resolvedOutdir}/*/index.d.ts`,
-              `${resolvedOutdir}/*/index.d.mts`,
-              `${resolvedOutdir}/*/index.d.cts`
-            ]
-          }
+    if (oldJSON["peerDependencies"]) {
+      const peerDependenciesMeta = Object.keys(oldJSON["peerDependencies"]).reduce(
+        (acc, key) => {
+          acc[key] = { optional: true };
+          return acc;
         },
-        { formattingOptions }
-      )
+        {}
+      );
+      newJSONString = applyEdits(
+        newJSONString,
+        modify(
+          newJSONString,
+          ["peerDependenciesMeta"],
+          peerDependenciesMeta,
+          { formattingOptions }
+        )
+      );
+    }
+    if (oldJSON["files"]) {
+      newJSONString = applyEdits(
+        newJSONString,
+        modify(
+          newJSONString,
+          ["files"],
+          void 0,
+          { formattingOptions }
+        )
+      );
+    }
+    return newJSONString;
+  };
+  await forEachSelectedProjectsGraphEntries((dir, originalManifest) => {
+    const [manifest, resolvedOutdir] = generateNewManifest(dir, originalManifest);
+    const resolveByDir = (...paths) => path.resolve(dir, ...paths);
+    const oldJSONString = fs.readFileSync(resolveByDir("package.json"), "utf-8");
+    const oldJSON = JSON.parse(oldJSONString) ?? "0.0.0";
+    if (typeof oldJSON.version !== "string") {
+      throw new Error(`${dir}/package.json must have a version field with a string value`);
+    }
+    const { indent = "    " } = detectIndent(oldJSONString);
+    const formattingOptions = {
+      tabSize: indent.length,
+      insertSpaces: true
+    };
+    const newVersion = bumper ? bump(oldJSON.version, bumper) : oldJSON.version;
+    const modifyVersionPackageJSON = applyEdits(
+      oldJSONString,
+      modify(oldJSONString, ["version"], newVersion, { formattingOptions })
     );
-    try {
-      fs.renameSync(path.join(dir, "package.json"), path.join(dir, "package.json.bak"));
-      fs.writeFileSync(path.join(dir, "package.json"), newJSONString);
-      !silent && console.log(newJSONString);
-      if (preview) {
-        continue;
+    const newJSONString = generateNewPackageJSONString({
+      oldJSONString: modifyVersionPackageJSON,
+      oldJSON: {
+        ...oldJSON,
+        version: newVersion
+      },
+      manifest,
+      formattingOptions
+    });
+    const withPublishConfigDirectoryOldJSONString = applyEdits(
+      modifyVersionPackageJSON,
+      modify(modifyVersionPackageJSON, ["publishConfig", "directory"], resolvedOutdir, { formattingOptions })
+    );
+    if (oldJSON.files) {
+      if (!Array.isArray(oldJSON.files)) {
+        throw new Error(`${dir}/package.json files field must be an array`);
       }
-      const args = ["pnpm", "publish", "--access", "public", "--no-git-checks", ...passArgs];
-      if (bumper && TAGS.includes(bumper)) {
-        args.push("--tag", bumper);
+      if (Array.isArray(oldJSON.files) && oldJSON.files.every((file) => typeof file !== "string")) {
+        throw new Error(`${dir}/package.json files field must be an array of string`);
       }
-      childProcess.execSync(args.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"));
     }
+    const resolvedOutdirAbs = resolveByDir(resolvedOutdir);
+    const files = oldJSON.files ?? fs.readdirSync(resolveByDir(".")).filter((file) => file !== "node_modules" && resolveByDir(file) !== resolvedOutdirAbs);
+    for (const file of files) {
+      const path2 = resolveByDir(file);
+      try {
+        const stat = fs.statSync(path2);
+        if (stat.isDirectory()) {
+          fs.symlinkSync(path2, resolveByDir(resolvedOutdir, file), "dir");
+          continue;
+        }
+        if (stat.isFile()) {
+          fs.symlinkSync(path2, resolveByDir(resolvedOutdir, file), "file");
+          continue;
+        }
+      } catch (e) {
+        console.warn(String(e));
+        continue;
+      }
+      throw new Error(`file type of ${path2} is not supported`);
+    }
+    if (!fs.existsSync(resolveByDir(resolvedOutdir))) {
+      fs.mkdirSync(resolveByDir(resolvedOutdir));
+    }
+    const jiekTempDir = resolveByDir("node_modules/.jiek/.tmp");
+    if (!fs.existsSync(resolveByDir(jiekTempDir))) {
+      fs.mkdirSync(resolveByDir(jiekTempDir), { recursive: true });
+    }
+    fs.writeFileSync(resolveByDir(resolvedOutdir, "package.json"), newJSONString);
+    fs.writeFileSync(resolveByDir(jiekTempDir, "package.json"), modifyVersionPackageJSON);
+    fs.writeFileSync(resolveByDir("package.json"), withPublishConfigDirectoryOldJSONString);
+  });
+}
+async function postpublish() {
+  await forEachSelectedProjectsGraphEntries((dir) => {
+    const jiekTempDir = path.resolve(dir, "node_modules/.jiek/.tmp");
+    const packageJSON = path.resolve(dir, "package.json");
+    const jiekTempPackageJSON = path.resolve(jiekTempDir, "package.json");
+    if (fs.existsSync(jiekTempPackageJSON)) {
+      fs.copyFileSync(jiekTempPackageJSON, packageJSON);
+      fs.rmSync(jiekTempPackageJSON);
+      console.log(`${dir}/package.json has been restored`);
+    } else {
+      throw new Error(
+        `jiek temp \`${dir}/package.json\` not found, please confirm the jiek pre-publish command has been executed`
+      );
+    }
+  });
+}
+program.action(async () => {
+  const {
+    npm_lifecycle_event: NPM_LIFECYCLE_EVENT
+  } = process.env;
+  switch (NPM_LIFECYCLE_EVENT) {
+    case "prepublish":
+      await prepublish();
+      break;
+    case "postpublish":
+      await postpublish();
+      break;
+    default:
+      program.help();
   }
-  actionDone();
 });
+program.command("prepublish").action(prepublish);
+program.command("postpublish").action(postpublish);