jiek 0.2.2 → 0.2.4

package/dist/cli.umd.js

@@ -0,0 +1,661 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(require('node:fs'), require('node:path'), require('@pnpm/filter-workspace-packages'), require('commander'), require('js-yaml'), require('@jiek/utils/getWorkspaceDir'), require('node:child_process'), require('@jiek/pkger'), require('detect-indent'), require('inquirer'), require('jsonc-parser'), require('micromatch'), require('@jiek/utils/bumper'), require('child_process')) :
+  typeof define === 'function' && define.amd ? define(['node:fs', 'node:path', '@pnpm/filter-workspace-packages', 'commander', 'js-yaml', '@jiek/utils/getWorkspaceDir', 'node:child_process', '@jiek/pkger', 'detect-indent', 'inquirer', 'jsonc-parser', 'micromatch', '@jiek/utils/bumper', 'child_process'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.fs, global.path, global.filterWorkspacePackages, global.commander, global.jsYaml, global.getWorkspaceDir, global.childProcess, global.pkger, global.detectIndent, global.inquirer, global.jsoncParser, global.micromatch, global.bumper, global.childProcess$1));
+})(this, (function (fs, path, filterWorkspacePackages, commander, jsYaml, getWorkspaceDir, childProcess, pkger, detectIndent, inquirer, jsoncParser, micromatch, bumper, childProcess$1) { 'use strict';
+
+  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 fs__default = /*#__PURE__*/_interopDefault(fs);
+  var path__default = /*#__PURE__*/_interopDefault(path);
+  var childProcess__namespace = /*#__PURE__*/_interopNamespace(childProcess);
+  var detectIndent__default = /*#__PURE__*/_interopDefault(detectIndent);
+  var inquirer__default = /*#__PURE__*/_interopDefault(inquirer);
+  var childProcess__namespace$1 = /*#__PURE__*/_interopNamespace(childProcess$1);
+
+  let root;
+  function getRoot() {
+    if (root)
+      return root;
+    const rootOption = commander.program.getOptionValue("root");
+    root = rootOption ? path__default.default.isAbsolute(rootOption) ? rootOption : path__default.default.resolve(process.cwd(), rootOption) : process.cwd();
+    return root;
+  }
+
+  let wd;
+  let notWorkspace = false;
+  function getWD() {
+    if (wd)
+      return { wd, notWorkspace };
+    const root = getRoot();
+    try {
+      wd = getWorkspaceDir.getWorkspaceDir(root, 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 !== "") {
+    commander.program.option("-f, --filter <filter>", "filter packages");
+  }
+  async function getSelectedProjectsGraph() {
+    let filter = commander.program.getOptionValue("filter");
+    const root = getRoot();
+    const { wd, notWorkspace } = getWD();
+    if (!notWorkspace && type === "pnpm") {
+      const pnpmWorkspaceFilePath = path__default.default.resolve(wd, "pnpm-workspace.yaml");
+      const pnpmWorkspaceFileContent = fs__default.default.readFileSync(pnpmWorkspaceFilePath, "utf-8");
+      const pnpmWorkspace = jsYaml.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__default.default.existsSync(path__default.default.resolve(root, "package.json"));
+        if (!packageJSONIsExist) {
+          throw new Error("root path is not workspace root, please provide a filter");
+        }
+        const packageJSON = JSON.parse(fs__default.default.readFileSync(path__default.default.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 filterWorkspacePackages.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__default.default.readFileSync(path__default.default.resolve(wd, "package.json"), "utf-8"))
+      }
+    };
+  }
+
+  let resolve;
+  function actionDone() {
+    resolve();
+  }
+  function actionRestore() {
+    new Promise((r) => resolve = r);
+  }
+
+  function commondir(files, cwd = process.cwd()) {
+    const resolvedFiles = files.map((file) => {
+      if (path__default.default.isAbsolute(file))
+        return file;
+      return path__default.default.resolve(cwd, file);
+    });
+    const sep = "/";
+    const [first = ""] = resolvedFiles;
+    const parts = first.split(sep);
+    let common = "";
+    for (let i = 0; i < parts.length; i++) {
+      const segment = parts[i];
+      if (resolvedFiles.every((file) => file.startsWith(common + segment))) {
+        common += segment + sep;
+      } else {
+        break;
+      }
+    }
+    return common;
+  }
+
+  function mergePackageJson(manifest, cwd) {
+    const {
+      jiek: { cwd: _, ...jiek } = {}
+    } = manifest;
+    let { exports } = manifest;
+    let includeIndex = false;
+    if (typeof exports === "string") {
+      includeIndex = true;
+      exports = { ".": exports };
+    }
+    if (exports === void 0) {
+      exports = { ".": "./src/index.ts" };
+    }
+    if (typeof exports === "object") {
+      if (Array.isArray(exports) && exports.length > 0) {
+        includeIndex = true;
+      } else {
+        includeIndex = !!exports["."];
+      }
+    }
+    const inputs = Array.isArray(exports) ? exports : Object.entries(exports).reduce((acc, [key, value]) => {
+      if (typeof value === "string")
+        return key === "." ? [value, ...acc] : acc.concat(value);
+      if (Array.isArray(value))
+        return acc.concat(value);
+      throw new TypeError(`Unexpected value type for key "${key}" in exports, expected string, got ${typeof value}`);
+    }, []);
+    if (inputs.length === 0)
+      throw new Error("No inputs found");
+    const absoluteInputs = inputs.map(
+      (input) => path__default.default.isAbsolute(input) ? input : path__default.default.resolve(cwd, input)
+    );
+    let cDir = path__default.default.dirname(absoluteInputs[0]);
+    if (absoluteInputs.length > 1) {
+      cDir = commondir(absoluteInputs, cwd);
+    }
+    const resolvedInputs = absoluteInputs.map((input) => {
+      return path__default.default.relative(cDir, input);
+    });
+    return {
+      ...manifest,
+      ...pkger.pkger({
+        cwd,
+        noIndex: !includeIndex,
+        source: path__default.default.relative(cwd, cDir),
+        inputs: resolvedInputs,
+        ...jiek
+      })
+    };
+  }
+
+  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;
+    }
+  }
+
+  const FILE_TEMPLATE = (manifest) => `
+const pkg = ${JSON.stringify(manifest, null, 2)}
+const { jiek = {} } = pkg
+const templateArg = jiek.templateArgFilePath
+  ? require.resolve(jiek.templateArgFilePath)
+  : {
+    styled: jiek.styled
+  }
+module.exports = require('jiek/rollup').template(templateArg, pkg)
+`.trimStart();
+  commander.program.command("build").action(async () => {
+    actionRestore();
+    const {
+      wd,
+      value = {}
+    } = await getSelectedProjectsGraph() ?? {};
+    if (Object.keys(value).length === 0) {
+      throw new Error("no package found");
+    }
+    const jiekTempDir = (...paths) => path__default.default.resolve(wd, "node_modules/.jiek", ...paths);
+    if (!fs__default.default.existsSync(jiekTempDir()))
+      fs__default.default.mkdirSync(jiekTempDir());
+    const rollupBinaryPath = require.resolve("rollup").replace(/dist\/rollup.js$/, "dist/bin/rollup");
+    let i = 0;
+    for (const [dir, manifest] of Object.entries(value)) {
+      const newManifest = mergePackageJson(manifest, dir);
+      const escapeManifestName = manifest.name?.replace(/^@/g, "").replace(/\//g, "+");
+      const configFile = jiekTempDir(
+        `${escapeManifestName ?? `anonymous-${i++}`}.rollup.config.js`
+      );
+      fs__default.default.writeFileSync(configFile, FILE_TEMPLATE(newManifest));
+      let prefix = "";
+      if (tsRegisterName) {
+        prefix = `node -r ${tsRegisterName} `;
+      }
+      childProcess__namespace.execSync(`${prefix}${rollupBinaryPath} -c ${configFile}`, {
+        cwd: dir,
+        stdio: "inherit"
+      });
+    }
+    actionDone();
+  });
+
+  let configName = "jiek.config";
+  function getConfigPath(root) {
+    const isSupportTsLoader = !!tsRegisterName;
+    function configWithExtIsExist(ext) {
+      const filenames = [
+        path__default.default.resolve(root, `${configName}.${ext}`),
+        path__default.default.resolve(root, `.${configName}.${ext}`)
+      ];
+      for (const filename of filenames) {
+        if (fs__default.default.existsSync(filename) && fs__default.default.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__default.default.resolve(root, configName);
+  }
+  function loadConfig() {
+    const { wd: root, notWorkspace } = getWD();
+    if (notWorkspace)
+      throw new Error("not in workspace");
+    let configPath = commander.program.getOptionValue("configPath");
+    if (!configPath) {
+      configPath = getConfigPath(root);
+    } else {
+      if (!fs__default.default.existsSync(configPath))
+        throw new Error(`config file not found: ${configPath}`);
+      if (!path__default.default.isAbsolute(configPath))
+        configPath = path__default.default.resolve(root, configPath);
+    }
+    const ext = path__default.default.extname(configPath);
+    let module;
+    switch (ext) {
+      case ".js":
+        module = require(configPath);
+        break;
+      case ".json":
+        return require(configPath);
+      case ".yaml":
+        return jsYaml.load(fs__default.default.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 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__default.default.resolve(wd, template);
+      templateString = fs__default.default.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__default.default.resolve(wd, "package.json");
+    const packageJSON = JSON.parse(fs__default.default.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__default.default.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__default.default.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 (micromatch.isMatch(relativePath, key)) {
+            matchedKey = key;
+            matchedRule = value;
+            break;
+          }
+          if (micromatch.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__default.default.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");
+  }
+  commander.program.command("init [name]").option("-t, --template <template>", "the package.json template file path or file content").action(async () => {
+    const [, name] = commander.program.args;
+    const cwd = process.cwd();
+    const { init = {} } = loadConfig() ?? {};
+    const { wd } = getWD();
+    const workspaceName = path__default.default.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__default.default.resolve(wd, readmeTemplate);
+      readme = fs__default.default.readFileSync(readmeTemplatePath, "utf-8");
+    }
+    const templateString = getTemplateStr(wd, template);
+    const { indent = "    " } = detectIndent__default.default(templateString);
+    const formattingOptions = {
+      tabSize: indent.length,
+      insertSpaces: true
+    };
+    const passFields = [
+      "license",
+      "author"
+    ];
+    let newJSONString = templateString;
+    for (const field of passFields) {
+      newJSONString = jsoncParser.applyEdits(newJSONString, jsoncParser.modify(
+        newJSONString,
+        [field],
+        getWDPackageJSONFiled(wd, field),
+        { formattingOptions }
+      ));
+    }
+    let [pkgName, pkgDir] = await getName(named, name, {
+      wd,
+      cwd,
+      workspaceName
+    });
+    if (!pkgDir) {
+      const { dir } = await inquirer__default.default.prompt({
+        type: "input",
+        name: "dir",
+        message: "package directory",
+        default: name
+      });
+      pkgDir = dir;
+    }
+    if (!pkgName) {
+      const { name: inputName } = await inquirer__default.default.prompt({
+        type: "input",
+        name: "name",
+        message: "package name",
+        default: name
+      });
+      pkgName = inputName;
+    }
+    newJSONString = jsoncParser.applyEdits(newJSONString, jsoncParser.modify(newJSONString, ["name"], pkgName, { formattingOptions }));
+    let pkgRepo = getWDPackageJSONFiled(wd, "repository");
+    if (typeof pkgRepo === "string") {
+      pkgRepo = {
+        type: "git",
+        url: pkgRepo,
+        directory: pkgDir
+      };
+    }
+    newJSONString = jsoncParser.applyEdits(newJSONString, jsoncParser.modify(
+      newJSONString,
+      ["repository"],
+      pkgRepo,
+      { formattingOptions }
+    ));
+    const homepage = `${pkgRepo?.url}/blob/master/${pkgDir}/README.md`;
+    newJSONString = jsoncParser.applyEdits(newJSONString, jsoncParser.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 = jsoncParser.applyEdits(newJSONString, jsoncParser.modify(
+      newJSONString,
+      ["bugs"],
+      bugs,
+      { formattingOptions }
+    ));
+    function pkgDirTo(to) {
+      if (!pkgDir)
+        throw new Error("pkgDir is not defined");
+      return path__default.default.resolve(pkgDir, to);
+    }
+    if (!fs__default.default.existsSync(pkgDir))
+      fs__default.default.mkdirSync(pkgDir);
+    const pkgJSONFilePath = pkgDirTo("package.json");
+    if (fs__default.default.existsSync(pkgJSONFilePath)) {
+      throw new Error("package.json already exists");
+    }
+    fs__default.default.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__default.default.writeFileSync(readmeFilePath, readmeContent);
+  });
+
+  commander.program.command("publish").aliases(["pub", "p"]).option("-b, --bumper <bumper>", "bump version", "patch").option("-p, --preview", "preview publish").action(async ({ preview, bumper: bumper$1, ...options }) => {
+    actionRestore();
+    const { value = {} } = await getSelectedProjectsGraph() ?? {};
+    const selectedProjectsGraphEntries = Object.entries(value);
+    if (selectedProjectsGraphEntries.length === 0) {
+      throw new Error("no packages selected");
+    }
+    const mainfests = selectedProjectsGraphEntries.map(([dir, manifest]) => [
+      dir,
+      mergePackageJson(manifest, dir)
+    ]);
+    const passArgs = Object.entries(options).reduce((acc, [key, value2]) => {
+      if (value2) {
+        acc.push(`--${key}`, value2);
+      }
+      return acc;
+    }, []);
+    for (const [dir, manifest] of mainfests) {
+      const oldJSONString = fs__default.default.readFileSync(path__default.default.join(dir, "package.json"), "utf-8");
+      const oldJSON = JSON.parse(oldJSONString) ?? "0.0.0";
+      const newVersion = bumper.bump(oldJSON.version, bumper$1);
+      const { indent = "    " } = detectIndent__default.default(oldJSONString);
+      const formattingOptions = {
+        tabSize: indent.length,
+        insertSpaces: true
+      };
+      let newJSONString = oldJSONString;
+      newJSONString = jsoncParser.applyEdits(newJSONString, jsoncParser.modify(
+        newJSONString,
+        ["version"],
+        newVersion,
+        { formattingOptions }
+      ));
+      for (const [key, value2] of Object.entries(manifest)) {
+        if (JSON.stringify(value2) === JSON.stringify(oldJSON[key]))
+          continue;
+        newJSONString = jsoncParser.applyEdits(newJSONString, jsoncParser.modify(
+          newJSONString,
+          ["publishConfig", key],
+          value2,
+          { formattingOptions }
+        ));
+      }
+      try {
+        fs__default.default.renameSync(path__default.default.join(dir, "package.json"), path__default.default.join(dir, "package.json.bak"));
+        fs__default.default.writeFileSync(path__default.default.join(dir, "package.json"), newJSONString);
+        console.log(newJSONString);
+        if (preview) {
+          console.warn("preview mode");
+          continue;
+        }
+        childProcess__namespace$1.execSync(["pnpm", "publish", "--access", "public", "--no-git-checks", ...passArgs].join(" "), {
+          cwd: dir,
+          stdio: "inherit"
+        });
+        const modifyVersionPackageJSON = jsoncParser.applyEdits(oldJSONString, jsoncParser.modify(oldJSONString, ["version"], newVersion, {}));
+        fs__default.default.writeFileSync(path__default.default.join(dir, "package.json.bak"), modifyVersionPackageJSON);
+      } finally {
+        fs__default.default.unlinkSync(path__default.default.join(dir, "package.json"));
+        fs__default.default.renameSync(path__default.default.join(dir, "package.json.bak"), path__default.default.join(dir, "package.json"));
+      }
+    }
+    actionDone();
+  });
+
+  const pkg = require("../package.json");
+  commander.program.version(pkg.version).description(pkg.description).option("--root <root>", "root path").option("-c, --config-path <configPath>", "config path");
+  commander.program.parse(process.argv);
+
+}));
+//# sourceMappingURL=cli.umd.js.map