screw-up 1.14.1 → 1.16.0

package/dist/main.js

@@ -1,22 +1,22 @@
 #!/usr/bin/env node
 /*!
  * name: screw-up
- * version: 1.14.1
+ * version: 1.16.0
  * description: Simply package metadata inserter on Vite plugin
  * author: Kouji Matsui (@kekyo@mi.kekyo.net)
  * license: MIT
  * repository.url: https://github.com/kekyo/screw-up.git
- * git.commit.hash: e56be312448cbae9f30fa0841439ee856f93d60e
+ * git.commit.hash: 1074e4634f2c667f15188d4a95db0f30a96a6497
  */
 import { join, dirname, resolve } from "path";
 import { createWriteStream, createReadStream, existsSync } from "fs";
-import { mkdir, writeFile, stat, readdir, mkdtemp, copyFile, rm } from "fs/promises";
+import { mkdir, writeFile, stat, readdir, mkdtemp, copyFile, rm, readFile } from "fs/promises";
 import { spawn } from "child_process";
 import { tmpdir } from "os";
 import { Readable } from "stream";
 import { createGunzip, createGzip } from "zlib";
 import { pipeline } from "stream/promises";
-import { b as resolveRawPackageJsonObject, f as findWorkspaceRoot, d as collectWorkspaceSiblings, e as replacePeerDependenciesWildcards, g as getFetchGitMetadata, c as createConsoleLogger, n as name } from "./packageMetadata-DOqeCvCs.js";
+import { b as resolveRawPackageJsonObject, f as findWorkspaceRoot, d as collectWorkspaceSiblings, e as replacePeerDependenciesWildcards, g as getFetchGitMetadata, c as createConsoleLogger, n as name } from "./packageMetadata-CYZtTJqC.js";
 /*!
  * name: tar-vern
  * version: 1.3.0
@@ -811,7 +811,7 @@ const parseArgs = (args, argOptionMap2) => {
         result.options[optionName] = true;
       } else {
         const argOptions = argOptionMap2.get(result.command);
-        if (argOptions.has(optionName)) {
+        if (argOptions == null ? void 0 : argOptions.has(optionName)) {
           i++;
           result.options[optionName] = args[i];
         } else {
@@ -821,7 +821,13 @@ const parseArgs = (args, argOptionMap2) => {
     } else if (arg.startsWith("-")) {
       const optionName = arg.slice(1);
       if (optionName.length == 1) {
-        result.options[optionName] = true;
+        const argOptions = result.command ? argOptionMap2.get(result.command) : void 0;
+        if (argOptions == null ? void 0 : argOptions.has(optionName)) {
+          i++;
+          result.options[optionName] = args[i];
+        } else {
+          result.options[optionName] = true;
+        }
       }
     } else if (!result.command) {
       result.command = arg;
@@ -853,6 +859,165 @@ const parseInheritableFields = (inheritableFieldsOption) => {
     inheritableFieldsOption.split(",").map((field) => field.trim()).filter((field) => field.length > 0)
   );
 };
+const readInputText = async (inputPath) => {
+  if (inputPath) {
+    const resolvedPath = resolve(inputPath);
+    return await readFile(resolvedPath, "utf-8");
+  }
+  return await new Promise((resolvePromise, rejectPromise) => {
+    let data = "";
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => resolvePromise(data));
+    process.stdin.on("error", (err) => rejectPromise(err));
+  });
+};
+const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const getValueByPath = (source, path) => {
+  return path.split(".").reduce((current, key) => {
+    if (current === void 0 || current === null) {
+      return void 0;
+    }
+    if (typeof current !== "object" && !Array.isArray(current)) {
+      return void 0;
+    }
+    return current[key];
+  }, source);
+};
+const stringifyValue = (value) => {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (value === null) {
+    return "null";
+  }
+  if (typeof value === "object") {
+    try {
+      return JSON.stringify(value);
+    } catch (e) {
+      return String(value);
+    }
+  }
+  return String(value);
+};
+const replacePlaceholders = (text, values, openBracket, closeBracket) => {
+  const pattern = new RegExp(
+    `${escapeRegExp(openBracket)}(.*?)${escapeRegExp(closeBracket)}`,
+    "g"
+  );
+  return text.replace(pattern, (match, key) => {
+    const trimmedKey = String(key).trim();
+    const resolvedValue = stringifyValue(getValueByPath(values, trimmedKey));
+    return resolvedValue !== void 0 ? resolvedValue : match;
+  });
+};
+const showFormatHelp = () => {
+  console.info(`Usage: screw-up format [options] [output]
+
+Format input text by replacing placeholders with package metadata
+
+Arguments:
+  output                        Optional output file path (default: stdout)
+
+Options:
+  -i, --input <path>            Input template file (default: stdin)
+  -b, --bracket <open,close>    Placeholder brackets (default: {,})
+  --inheritable-fields <list>   Comma-separated list of fields to inherit from parent
+  --no-wds                      Do not check working directory status to increase version
+  --no-git-version-override     Do not override version from Git (use package.json version)
+  -f, --force                   Allow formatting even if package.json does not exist
+  -h, --help                    Show help for format command
+`);
+};
+const parseBracketOption = (bracketOption) => {
+  if (!bracketOption) {
+    return { openBracket: "{", closeBracket: "}" };
+  }
+  const delimiterIndex = bracketOption.indexOf(",");
+  if (delimiterIndex === -1) {
+    return void 0;
+  }
+  const openBracket = bracketOption.slice(0, delimiterIndex);
+  const closeBracket = bracketOption.slice(delimiterIndex + 1);
+  if (!openBracket || !closeBracket) {
+    return void 0;
+  }
+  return { openBracket, closeBracket };
+};
+const formatCommand = async (args, logger2) => {
+  var _a, _b;
+  if (args.options.help || args.options.h) {
+    showFormatHelp();
+    return 1;
+  }
+  const outputPath = args.positional[0];
+  const inputPathOption = (_a = args.options["input"]) != null ? _a : args.options["i"];
+  const bracketOption = (_b = args.options["bracket"]) != null ? _b : args.options["b"];
+  const inheritableFieldsOption = args.options["inheritable-fields"];
+  const alwaysOverrideVersionFromGit = !args.options["no-git-version-override"];
+  const checkWorkingDirectoryStatus = args.options["no-wds"] ? false : true;
+  const ignorePackageJsonNotExist = args.options["force"] || args.options["f"] ? true : false;
+  const bracket = parseBracketOption(
+    typeof bracketOption === "string" ? bracketOption : void 0
+  );
+  if (!bracket) {
+    logger2.error(
+      'format: Invalid bracket option, expected "open,close" pattern.'
+    );
+    return 1;
+  }
+  const { openBracket, closeBracket } = bracket;
+  const targetDir = resolve(process.cwd());
+  const inheritableFields = parseInheritableFields(inheritableFieldsOption);
+  const _logger = {
+    debug: (msg) => {
+    },
+    info: (msg) => {
+    },
+    warn: (msg) => {
+    },
+    error: logger2.error
+  };
+  try {
+    const fetchGitMetadata = getFetchGitMetadata(
+      targetDir,
+      checkWorkingDirectoryStatus,
+      _logger
+    );
+    const computedPackageJson = await getComputedPackageJsonObject(
+      targetDir,
+      fetchGitMetadata,
+      alwaysOverrideVersionFromGit,
+      inheritableFields,
+      _logger,
+      ignorePackageJsonNotExist
+    );
+    if (!computedPackageJson) {
+      _logger.error(`format: Unable to read package.json from: ${targetDir}`);
+      return 1;
+    }
+    const inputText = await readInputText(
+      typeof inputPathOption === "string" ? inputPathOption : void 0
+    );
+    const formattedText = replacePlaceholders(
+      inputText,
+      computedPackageJson,
+      openBracket,
+      closeBracket
+    );
+    if (outputPath) {
+      const resolvedOutputPath = resolve(outputPath);
+      await writeFile(resolvedOutputPath, formattedText);
+    }
+    process.stdout.write(formattedText);
+  } catch (error) {
+    _logger.error(`format: Failed to format text: ${error}`);
+    return 1;
+  }
+  return 0;
+};
 const showDumpHelp = () => {
   console.info(`Usage: screw-up dump [options] [directory]
 
@@ -1162,7 +1327,7 @@ const publishCommand = async (args, logger2) => {
   }
 };
 const showHelp = async () => {
-  const { author, license, repository_url, version, git_commit_hash } = await import("./packageMetadata-DOqeCvCs.js").then((n) => n.p);
+  const { author, license, repository_url, version, git_commit_hash } = await import("./packageMetadata-CYZtTJqC.js").then((n) => n.p);
   console.info(`screw-up [${version}-${git_commit_hash}]
 Easy package metadata inserter CLI
 Copyright (c) ${author}
@@ -1172,6 +1337,7 @@ License: ${license}
 Usage: screw-up <command> [options]
 
 Commands:
+  format [output]                 Format text by replacing metadata placeholders
   dump [directory]                 Dump computed package.json as JSON
   pack [directory]                 Pack the project into a tar archive
   publish [directory|package.tgz]  Publish the project
@@ -1180,6 +1346,7 @@ Options:
   -h, --help                       Show help
 
 Examples:
+  screw-up format output.txt               # Format stdin template and write to file
   screw-up dump                            # Dump computed package.json as JSON
   screw-up pack                            # Pack current directory
   screw-up pack --pack-destination ./dist  # Pack to specific output directory
@@ -1198,6 +1365,7 @@ const argOptionMap = /* @__PURE__ */ new Map([
       "peer-deps-prefix"
     ])
   ],
+  ["format", /* @__PURE__ */ new Set(["input", "i", "bracket", "b", "inheritable-fields"])],
   ["publish", /* @__PURE__ */ new Set(["inheritable-fields", "peer-deps-prefix"])]
 ]);
 const cliMain = async (args, logger2) => {
@@ -1207,6 +1375,8 @@ const cliMain = async (args, logger2) => {
     return 1;
   }
   switch (parsedArgs.command) {
+    case "format":
+      return await formatCommand(parsedArgs, logger2);
     case "dump":
       return await dumpCommand(parsedArgs, logger2);
     case "pack":