jiek 2.2.6 → 2.2.7-alpha.1

package/dist/bin/index.cjs

@@ -0,0 +1,488 @@
+'use strict';
+
+var childProcess = require('node:child_process');
+var fs = require('node:fs');
+var path = require('node:path');
+var process = require('node:process');
+var bumper = require('@jiek/utils/bumper');
+var commander = require('commander');
+var detectIndent = require('detect-indent');
+var jsoncParser = require('jsonc-parser');
+var filterSupport = require('@jiek/__internal__/+/utils/filterSupport');
+var loadConfig = require('@jiek/__internal__/+/utils/loadConfig');
+var resolveExports = require('@jiek/__internal__/+/utils/resolveExports');
+var getInternalModuleName = require('@jiek/__internal__/+/utils/getInternalModuleName');
+require('./build');
+var parseArgv = require('@jiek/__internal__/+/bin/parseArgv');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var childProcess__namespace = /*#__PURE__*/_interopNamespace(childProcess);
+var fs__default = /*#__PURE__*/_interopDefault(fs);
+var path__default = /*#__PURE__*/_interopDefault(path);
+var process__default = /*#__PURE__*/_interopDefault(process);
+var detectIndent__default = /*#__PURE__*/_interopDefault(detectIndent);
+var parseArgv__default = /*#__PURE__*/_interopDefault(parseArgv);
+
+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 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 filterSupport.getSelectedProjectsGraph() ?? {};
+  const selectedProjectsGraphEntries = Object.entries(value);
+  if (selectedProjectsGraphEntries.length === 0) {
+    throw new Error("no packages selected");
+  }
+  for (const [dir, manifest] of selectedProjectsGraphEntries) {
+    callback(dir, manifest);
+  }
+}
+commander.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: bumper$1 }) => {
+  let shouldPassThrough = false;
+  const passThroughOptions = process__default.default.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$1 && bumper.TAGS.includes(bumper$1)) {
+      args.push("--tag", bumper$1);
+    }
+    args.push(...passThroughOptions);
+    childProcess__namespace.execSync(args.join(" "), {
+      cwd: dir,
+      stdio: "inherit",
+      env: {
+        ...process__default.default.env,
+        JIEK_PUBLISH_OUTDIR: JSON.stringify(outdir),
+        JIEK_PUBLISH_BUMPER: JSON.stringify(bumper$1)
+      }
+    });
+  });
+});
+async function prepublish({ bumper: bumper$1 } = {}) {
+  const {
+    JIEK_PUBLISH_OUTDIR: outdirEnv,
+    JIEK_PUBLISH_BUMPER: bumperEnv
+  } = process__default.default.env;
+  const outdir = outdirEnv ? JSON.parse(outdirEnv) : "dist";
+  bumper$1 = bumper$1 ?? (bumperEnv ? JSON.parse(bumperEnv) : false);
+  const generateNewManifest = (dir, manifest) => {
+    const {
+      name,
+      type,
+      exports: entrypoints = {},
+      imports: internalEntrypoints = {}
+    } = manifest;
+    if (!name) {
+      throw new Error(`package.json in ${dir} must have a name field`);
+    }
+    const pkgIsModule = type === "module";
+    const newManifest = { ...manifest };
+    const commonOptions = {
+      pkgIsModule,
+      pkgName: name,
+      config: loadConfig.loadConfig(dir),
+      dir,
+      noFilter: true,
+      isPublish: true
+    };
+    const [resolvedEntrypoints, exports, resolvedOutdir] = resolveExports.resolveExports({
+      entrypoints,
+      defaultOutdir: outdir,
+      ...commonOptions
+    });
+    newManifest.exports = {
+      ...resolvedEntrypoints,
+      ...exports
+    };
+    const [resolvedInternalEntrypoints, imports] = resolveExports.resolveExports({
+      entrypoints: internalEntrypoints,
+      defaultOutdir: `${outdir}/.internal`,
+      ...commonOptions
+    });
+    newManifest.imports = {
+      ...resolvedInternalEntrypoints,
+      ...imports
+    };
+    return [newManifest, resolvedOutdir];
+  };
+  const generateNewPackageJSONString = ({
+    oldJSONString,
+    oldJSON,
+    manifest,
+    formattingOptions
+  }) => {
+    const internalModuleName = getInternalModuleName.getInternalModuleName(manifest.name);
+    let newJSONString = oldJSONString;
+    const update = (path2, value) => {
+      newJSONString = jsoncParser.applyEdits(
+        newJSONString,
+        jsoncParser.modify(newJSONString, path2, value, { formattingOptions })
+      );
+    };
+    update(["publishConfig", "typesVersions"], {
+      "<5.0": {
+        "*": [
+          "*",
+          "./*",
+          "./*/index.d.ts",
+          "./*/index.d.mts",
+          "./*/index.d.cts"
+        ]
+      }
+    });
+    update(["dependencies", internalModuleName], `file:./${outdir}/.internal`);
+    update(["dependenciesMeta", internalModuleName], {
+      "injected": true
+    });
+    update(["imports"], void 0);
+    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 = jsoncParser.applyEdits(
+          newJSONString,
+          jsoncParser.modify(
+            newJSONString,
+            ["publishConfig", key],
+            value,
+            { formattingOptions }
+          )
+        );
+      } else {
+        const exports = value;
+        for (const [k, v] of Object.entries(exports)) {
+          newJSONString = jsoncParser.applyEdits(
+            newJSONString,
+            jsoncParser.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;
+              indexPublishConfig.types = indexExports.types;
+              break;
+            }
+          }
+          indexPublishConfig.types = indexPublishConfig[manifest?.type === "module" ? "module" : "main"].replace(/\.([cm]?)js$/, ".d.$1ts");
+          for (const [k, v] of Object.entries(indexPublishConfig)) {
+            if (v === void 0) continue;
+            newJSONString = jsoncParser.applyEdits(
+              newJSONString,
+              jsoncParser.modify(
+                newJSONString,
+                ["publishConfig", k],
+                v,
+                { formattingOptions }
+              )
+            );
+          }
+        }
+      }
+    }
+    if (oldJSON.devDependencies) {
+      newJSONString = jsoncParser.applyEdits(
+        newJSONString,
+        jsoncParser.modify(
+          newJSONString,
+          ["devDependencies"],
+          void 0,
+          { formattingOptions }
+        )
+      );
+    }
+    if (oldJSON.peerDependencies) {
+      const peerDependenciesMeta = Object.keys(oldJSON.peerDependencies).reduce(
+        (acc, key) => {
+          acc[key] = { optional: true };
+          return acc;
+        },
+        {}
+      );
+      newJSONString = jsoncParser.applyEdits(
+        newJSONString,
+        jsoncParser.modify(
+          newJSONString,
+          ["peerDependenciesMeta"],
+          peerDependenciesMeta,
+          { formattingOptions }
+        )
+      );
+    }
+    if (oldJSON.files) {
+      newJSONString = jsoncParser.applyEdits(
+        newJSONString,
+        jsoncParser.modify(
+          newJSONString,
+          ["files"],
+          void 0,
+          { formattingOptions }
+        )
+      );
+    }
+    return newJSONString;
+  };
+  await forEachSelectedProjectsGraphEntries((dir, originalManifest) => {
+    const [manifest, resolvedOutdir] = generateNewManifest(dir, originalManifest);
+    const resolveByDir = (...paths) => path__default.default.resolve(dir, ...paths);
+    const oldJSONString = fs__default.default.readFileSync(resolveByDir("package.json"), "utf-8");
+    const oldJSON = JSON.parse(oldJSONString);
+    if (typeof oldJSON.version !== "string") {
+      throw new TypeError(`${dir}/package.json must have a version field with a string value`);
+    }
+    const { indent = "    " } = detectIndent__default.default(oldJSONString);
+    const formattingOptions = {
+      tabSize: indent.length,
+      insertSpaces: true
+    };
+    const newVersion = bumper$1 ? bumper.bump(oldJSON.version, bumper$1 === true ? "patch" : bumper$1) : oldJSON.version;
+    const modifyVersionPackageJSON = jsoncParser.applyEdits(
+      oldJSONString,
+      jsoncParser.modify(oldJSONString, ["version"], newVersion, { formattingOptions })
+    );
+    const newJSONString = generateNewPackageJSONString({
+      oldJSONString: modifyVersionPackageJSON,
+      oldJSON: {
+        ...oldJSON,
+        version: newVersion
+      },
+      manifest,
+      formattingOptions
+    });
+    const withPublishConfigDirectoryOldJSONString = jsoncParser.applyEdits(
+      modifyVersionPackageJSON,
+      jsoncParser.modify(modifyVersionPackageJSON, ["publishConfig", "directory"], resolvedOutdir, { formattingOptions })
+    );
+    if (!fs__default.default.existsSync(resolveByDir(resolvedOutdir))) {
+      fs__default.default.mkdirSync(resolveByDir(resolvedOutdir));
+    }
+    const jiekTempDir = resolveByDir("node_modules/.jiek/.tmp");
+    if (!fs__default.default.existsSync(resolveByDir(jiekTempDir))) {
+      fs__default.default.mkdirSync(resolveByDir(jiekTempDir), { recursive: true });
+    }
+    fs__default.default.writeFileSync(resolveByDir(resolvedOutdir, "package.json"), newJSONString);
+    fs__default.default.writeFileSync(resolveByDir(jiekTempDir, "package.json"), modifyVersionPackageJSON);
+    fs__default.default.writeFileSync(resolveByDir("package.json"), withPublishConfigDirectoryOldJSONString);
+    const allBuildFiles = fs__default.default.readdirSync(resolveByDir(resolvedOutdir), { recursive: true }).filter((file) => typeof file === "string").filter((file) => file !== "package.json");
+    const resolvedExports = manifest.exports;
+    Object.keys(resolvedExports).forEach((key) => {
+      if (key === ".") return;
+      if (/\.[cm]?js$/.test(key)) return;
+      const resourceFileSuffixes = [
+        ".d.ts",
+        ".d.mts",
+        ".d.cts",
+        ".css",
+        ".scss",
+        ".sass",
+        ".less",
+        ".styl",
+        ".stylus",
+        ".json",
+        ".json5"
+      ];
+      if (resourceFileSuffixes.find((suffix) => key.endsWith(suffix))) return;
+      const value = resolvedExports[key];
+      const filepath = resolveByDir(resolvedOutdir, key);
+      fs__default.default.mkdirSync(filepath, { recursive: true });
+      const pkgJSONPath = resolveByDir(resolvedOutdir, key, "package.json");
+      const relativePath = Array.from({ length: key.split("/").length - 1 }, () => "..").join("/");
+      const { type } = manifest;
+      const pkgJSON = { type };
+      if ("default" in value) {
+        pkgJSON[type === "module" ? "module" : "main"] = [
+          relativePath,
+          value.default?.replace(/^\.\//, "")
+        ].join("/");
+      }
+      if ("import" in value) {
+        pkgJSON.module = [
+          relativePath,
+          value.import?.replace(/^\.\//, "")
+        ].join("/");
+      }
+      if ("require" in value) {
+        pkgJSON.main = [
+          relativePath,
+          value.require?.replace(/^\.\//, "")
+        ].join("/");
+      }
+      fs__default.default.writeFileSync(pkgJSONPath, JSON.stringify(pkgJSON));
+    });
+    fs__default.default.mkdirSync(resolveByDir(resolvedOutdir, resolvedOutdir));
+    for (const file of allBuildFiles) {
+      const filepath = resolveByDir(resolvedOutdir, file);
+      const newFilepath = resolveByDir(resolvedOutdir, resolvedOutdir, file);
+      const stat = fs__default.default.statSync(filepath);
+      if (stat.isDirectory()) {
+        fs__default.default.mkdirSync(newFilepath, { recursive: true });
+        continue;
+      }
+      if (stat.isFile()) {
+        fs__default.default.cpSync(filepath, newFilepath);
+        fs__default.default.rmSync(filepath);
+      }
+    }
+    if (oldJSON.files) {
+      if (Array.isArray(oldJSON.files)) {
+        if (oldJSON.files.every((file) => typeof file !== "string")) {
+          throw new TypeError(`${dir}/package.json files field must be an array of string`);
+        }
+      } else {
+        throw new TypeError(`${dir}/package.json files field must be an array`);
+      }
+    }
+    const resolvedOutdirAbs = resolveByDir(resolvedOutdir);
+    const files = (oldJSON.files ?? fs__default.default.readdirSync(resolveByDir("."))).filter(
+      (file) => ![
+        "node_modules",
+        "package.json",
+        "pnpm-lock.yaml"
+      ].includes(file) && resolveByDir(file) !== resolvedOutdirAbs
+    );
+    for (const file of files) {
+      const path2 = resolveByDir(file);
+      try {
+        const stat = fs__default.default.statSync(path2);
+        if (stat.isDirectory()) {
+          fs__default.default.cpSync(path2, resolveByDir(resolvedOutdir, file), { recursive: true });
+          continue;
+        }
+        if (stat.isFile()) {
+          fs__default.default.cpSync(path2, resolveByDir(resolvedOutdir, file));
+          continue;
+        }
+      } catch (e) {
+        console.warn(String(e));
+        continue;
+      }
+      throw new Error(`file type of ${path2} is not supported`);
+    }
+    if ("imports" in manifest && manifest.imports) {
+      Object.entries(manifest.imports).forEach(([key, value]) => {
+        if (typeof value !== "object") return;
+        const [start] = key.split("*");
+        manifest.imports[key] = JSON.parse(
+          JSON.stringify(value).replaceAll(`${resolvedOutdir}/.internal/`, start)
+        );
+      });
+      fs__default.default.writeFileSync(
+        resolveByDir(resolvedOutdir, resolvedOutdir, ".internal", "package.json"),
+        JSON.stringify(
+          {
+            name: getInternalModuleName.getInternalModuleName(manifest.name),
+            exports: JSON.parse(
+              JSON.stringify(manifest.imports).replaceAll("#", "./").replaceAll("~", "+")
+            )
+          },
+          null,
+          2
+        )
+      );
+    }
+  });
+}
+async function postpublish() {
+  await forEachSelectedProjectsGraphEntries((dir) => {
+    const jiekTempDir = path__default.default.resolve(dir, "node_modules/.jiek/.tmp");
+    const packageJSONPath = path__default.default.resolve(dir, "package.json");
+    const { name, version } = JSON.parse(fs__default.default.readFileSync(packageJSONPath, "utf-8"));
+    const jiekTempPackageJSONPath = path__default.default.resolve(jiekTempDir, "package.json");
+    if (fs__default.default.existsSync(jiekTempPackageJSONPath)) {
+      fs__default.default.copyFileSync(jiekTempPackageJSONPath, packageJSONPath);
+      fs__default.default.rmSync(jiekTempPackageJSONPath);
+      console.log(`${dir}/package.json has been restored`);
+      console.log(
+        `if you want to check the compatibility of the package, you can visit: https://arethetypeswrong.github.io/?p=${name}%40${version}`
+      );
+    } else {
+      throw new Error(
+        `jiek temp \`${dir}/package.json\` not found, please confirm the jiek pre-publish command has been executed`
+      );
+    }
+  });
+}
+commander.program.action(async () => {
+  const {
+    npm_lifecycle_event: NPM_LIFECYCLE_EVENT
+  } = process__default.default.env;
+  switch (NPM_LIFECYCLE_EVENT) {
+    case "prepublish":
+      await prepublish();
+      break;
+    case "postpublish":
+      await postpublish();
+      break;
+    default:
+      commander.program.help();
+  }
+});
+const prepublishDescription = `
+Prepare package.json for publish, you can add \`jk\` to the \`prepublish\` script in package.json, the command will automatically run \`jk prepublish\`.
+.e.g
+{
+  "scripts": {
+    "prepublish": "jk"
+  }
+}
+`.trim();
+commander.program.command("prepublish").description(prepublishDescription).option("-b, --bumper <bumper>", "bump version").option("-no-b, --no-bumper", "no bump version").action(prepublish);
+const postpublishDescription = `
+Restore package.json after publish, you can add \`jk\` to the \`postpublish\` script in package.json, the command will automatically run \`jk postpublish\`.
+.e.g
+{
+  "scripts": {
+    "postpublish": "jk"
+  }
+}
+`.trim();
+commander.program.command("postpublish").description(postpublishDescription).action(postpublish);
+
+parseArgv__default.default();

package/dist/index.d.cts

@@ -1,116 +1,4 @@
-import * as _rollup_plugin_terser from '@rollup/plugin-terser';
-import * as rollup_plugin_swc3 from 'rollup-plugin-swc3';
-import * as rollup_plugin_esbuild from 'rollup-plugin-esbuild';
-import { InputPluginOption, OutputOptions } from 'rollup';
-
-type Mapping2ROO<K extends keyof OutputOptions> = OutputOptions[K] | {
-    js?: OutputOptions[K];
-    dts?: OutputOptions[K];
-};
-interface ConfigGenerateContext {
-    path: string;
-    name: string;
-    input: string;
-    output: string;
-    external: (string | RegExp)[];
-    pkgIsModule: boolean;
-    conditionals: string[];
-}
-type OutputControl = boolean | ((context: ConfigGenerateContext) => boolean);
-declare const BUILDER_TYPES: readonly ["esbuild", "swc"];
-interface TemplateOptions {
-    /**
-     * When the user configures type: module, the generated output from entry points that don't
-     * have cts as a suffix will automatically include the CJS version.
-     * if it is not configured, and the generated output from entry points that do not have mts
-     * as a suffix will automatically include the ESM version.
-     *
-     * @default true
-     */
-    crossModuleConvertor?: boolean;
-    /**
-     * Auto-detect the builder from the installed dependencies.
-     * If the builder is not installed, it will prompt the user to install it.
-     * If exists multiple builders, it will fall back to the 'esbuild'.
-     *
-     * @default 'esbuild'
-     */
-    builder?: typeof BUILDER_TYPES[number] | ({
-        type: 'esbuild';
-    } & rollup_plugin_esbuild.Options) | ({
-        type: 'swc';
-    } & rollup_plugin_swc3.PluginOptions);
-    features?: {
-        /**
-         * When use esbuild type builder, it will inject `supported.import-attributes` option.
-         * When use swc type builder, it will inject `jsc.experimental.keepImportAttributes` option.
-         *
-         * And it will auto set the rollup output externalImportAttributes and importAttributesKey options.
-         *
-         * @default true
-         */
-        keepImportAttributes?: boolean | 'assert';
-    };
-    output?: {
-        /**
-         * @default true
-         *
-         * When minify is set to true, the output will with minified files.
-         * When minify is set to 'only-minify', the output will direct output minified files.
-         */
-        minify?: boolean | 'only-minify';
-        minifyOptions?: typeof BUILDER_TYPES[number] | 'terser' | ({
-            type: 'terser';
-        } & _rollup_plugin_terser.Options) | ({
-            type: 'esbuild';
-        } & Parameters<typeof rollup_plugin_esbuild.minify>[0]) | ({
-            type: 'swc';
-        } & Parameters<typeof rollup_plugin_swc3.minify>[0]);
-        /**
-         * @default 'dist'
-         */
-        dir?: Mapping2ROO<'dir'>;
-        sourcemap?: Mapping2ROO<'sourcemap'>;
-        strict?: Mapping2ROO<'strict'>;
-        js?: OutputControl;
-        dts?: OutputControl;
-    };
-    /**
-     * Set the external dependencies of the package.
-     */
-    external?: (string | RegExp)[];
-    plugins?: InputPluginOption | ((type: 'js' | 'dts', context: ConfigGenerateContext) => InputPluginOption) | {
-        js: InputPluginOption;
-        dts?: InputPluginOption;
-    } | {
-        js?: InputPluginOption;
-        dts: InputPluginOption;
-    };
-    /**
-     * https://www.npmjs.com/package/@rollup/plugin-inject#usage
-     *
-     * @example
-     * ```js
-     * {
-     *   // import { Promise } from 'es6-promise'
-     *   Promise: [ 'es6-promise', 'Promise' ],
-     *
-     *   // import { Promise as P } from 'es6-promise'
-     *   P: [ 'es6-promise', 'Promise' ],
-     *
-     *   // import $ from 'jquery'
-     *   $: 'jquery',
-     *
-     *   // import * as fs from 'fs'
-     *   fs: [ 'fs', '*' ],
-     *
-     *   // use a local module instead of a third-party one
-     *   'Object.assign': path.resolve( 'src/helpers/object-assign.js' ),
-     * }
-     * ```
-     */
-    injects?: Record<string, string | [string, string]>;
-}
+import { TemplateOptions } from '@jiek/__internal__/+/rollup/base';
 
 declare module 'jiek' {
     interface Config {