json-sort-cli 4.2.3 → 4.3.1

package/cli.js

@@ -1,426 +1,5 @@
 #!/usr/bin/env node
 
-import { createRequire } from "node:module";
-import path from "node:path";
-import { glob } from "codsen-glob";
-import updateNotifier from "update-notifier";
-import { ProcessingError, processFiles } from "./process-files.js";
-
-const require1 = createRequire(import.meta.url);
-const pkg = require1("./package.json");
-const prefix = "✨ json-sort-cli: ";
-const nonJsonFormats = new Set([".yml", ".toml", ".yaml"]);
-const ignoredBasenames = new Set([
-  ".DS_Store",
-  "npm-debug.log",
-  ".svn",
-  "CVS",
-  "config.gypi",
-  ".lock-wscript",
-  "package-lock.json",
-  "npm-shrinkwrap.json",
-  "yarn.lock",
-]);
-const flagDefinitions = {
-  arrays: { short: "a", type: "boolean" },
-  ci: { short: "c", type: "boolean" },
-  dry: { short: "d", type: "boolean" },
-  help: { short: "h", type: "boolean" },
-  indentationCount: { short: "i", type: "value" },
-  lineEnding: { short: "l", type: "value" },
-  nodemodules: { short: "n", type: "boolean" },
-  pack: { short: "p", type: "boolean" },
-  silent: { short: "s", type: "boolean" },
-  tabs: { short: "t", type: "boolean" },
-  version: { short: "v", type: "boolean" },
-};
-const shortToLong = new Map(
-  Object.entries(flagDefinitions).map(([long, definition]) => [
-    definition.short,
-    long,
-  ]),
-);
-
-const help = `
-Usage
-  $ jsonsort YOURFILE.json
-  $ sortjson templatesfolder1 templatesfolder2 package.json
-  $ jsonsort
-
-With no arguments, jsonsort recursively sorts JSON files below the current
-directory. Discovered symbolic links are not followed. An explicitly selected
-symbolic-link directory is resolved as the selected root; symbolic-link files
-are rejected before reading.
-
-Options
-  -n, --nodemodules      Include JSON files inside node_modules; lockfiles remain excluded
-  -t, --tabs             Use tabs for indentation
-  -i, --indentationCount Use 0-10 spaces or tabs (default: 2 spaces or 1 tab)
-  -s, --silent           Suppress all terminal output; use the exit code for the result
-  -h, --help             Show this help
-  -v, --version          Show the current version
-  -a, --arrays           Sort arrays that contain only strings
-  -d, --dry              List candidate files without reading or writing them
-  -p, --pack             Exclude package.json files
-  -c, --ci               Check without writing; exit 9 when canonical output differs
-  -l, --lineEnding       Use "cr", "crlf", or "lf" instead of the detected line ending
-
-Use -- before a path that begins with a dash. Invalid options exit 1 before
-file discovery. Processing failures exit 1 and don't stop independent files.
-
-Example
-  $ jsonsort "templates/**/*.json" --arrays --lineEnding lf
-`;
-
-function argumentError(message) {
-  throw new TypeError(
-    `json-sort-cli/parseArguments(): [THROW_ID_01] ${message}`,
-  );
-}
-
-function requestsSilent(rawArguments) {
-  let optionsEnded = false;
-  for (const argument of rawArguments) {
-    if (optionsEnded) {
-      continue;
-    }
-    if (argument === "--") {
-      optionsEnded = true;
-    } else if (argument === "--silent") {
-      return true;
-    } else if (argument.startsWith("-") && !argument.startsWith("--")) {
-      for (const short of argument.slice(1)) {
-        const name = shortToLong.get(short);
-        if (!name) {
-          break;
-        }
-        if (name === "silent") {
-          return true;
-        }
-        if (flagDefinitions[name].type === "value") {
-          break;
-        }
-      }
-    }
-  }
-  return false;
-}
-
-function parseArguments(rawArguments) {
-  const expanded = rawArguments.flatMap((argument) => {
-    const match = argument.match(/^-(i|l)\s+(.+)$/u);
-    return match ? [`-${match[1]}`, match[2]] : [argument];
-  });
-  const flags = Object.fromEntries(
-    Object.keys(flagDefinitions).map((name) => [name, false]),
-  );
-  flags.indentationCount = undefined;
-  flags.lineEnding = undefined;
-  const input = [];
-  const seen = new Set();
-  let optionsEnded = false;
-
-  function setFlag(name, value = true) {
-    if (seen.has(name)) {
-      argumentError(`Option --${name} was provided more than once`);
-    }
-    seen.add(name);
-    flags[name] = value;
-  }
-
-  for (let index = 0; index < expanded.length; index += 1) {
-    const argument = expanded[index];
-    if (optionsEnded) {
-      input.push(argument);
-      continue;
-    }
-    if (argument === "--") {
-      optionsEnded = true;
-      continue;
-    }
-    if (!argument.startsWith("-") || argument === "-") {
-      input.push(argument);
-      continue;
-    }
-
-    if (argument.startsWith("--")) {
-      const equalsIndex = argument.indexOf("=");
-      const name = argument.slice(
-        2,
-        equalsIndex === -1 ? undefined : equalsIndex,
-      );
-      const definition = flagDefinitions[name];
-      if (!definition) {
-        argumentError(`Unknown option --${name}`);
-      }
-      if (definition.type === "boolean") {
-        if (equalsIndex !== -1) {
-          argumentError(`Option --${name} doesn't accept a value`);
-        }
-        setFlag(name);
-        continue;
-      }
-
-      let value =
-        equalsIndex === -1 ? undefined : argument.slice(equalsIndex + 1);
-      if (value === undefined) {
-        value = expanded[index + 1];
-        const flagShapedValue =
-          value?.startsWith("-") &&
-          !(name === "indentationCount" && /^-\d/u.test(value));
-        if (value === undefined || flagShapedValue) {
-          argumentError(`Option --${name} requires a value`);
-        }
-        index += 1;
-      }
-      if (value === "") {
-        argumentError(`Option --${name} requires a value`);
-      }
-      setFlag(name, value);
-      continue;
-    }
-
-    let shortFlags = argument.slice(1);
-    while (shortFlags.length) {
-      const short = shortFlags[0];
-      const name = shortToLong.get(short);
-      if (!name) {
-        argumentError(`Unknown option -${short}`);
-      }
-      const definition = flagDefinitions[name];
-      shortFlags = shortFlags.slice(1);
-      if (definition.type === "boolean") {
-        setFlag(name);
-        continue;
-      }
-
-      let value = shortFlags.replace(/^=/u, "");
-      shortFlags = "";
-      if (!value) {
-        value = expanded[index + 1];
-        const flagShapedValue =
-          value?.startsWith("-") &&
-          !(name === "indentationCount" && /^-\d/u.test(value));
-        if (value === undefined || flagShapedValue) {
-          argumentError(`Option -${short} requires a value`);
-        }
-        index += 1;
-      }
-      setFlag(name, value);
-    }
-  }
-
-  const defaultIndentation = flags.tabs ? 1 : 2;
-  const indentationCount =
-    flags.indentationCount === undefined
-      ? defaultIndentation
-      : Number(flags.indentationCount);
-  if (
-    !Number.isInteger(indentationCount) ||
-    indentationCount < 0 ||
-    indentationCount > 10
-  ) {
-    argumentError("indentationCount must be an integer from 0 to 10");
-  }
-  if (
-    flags.lineEnding !== undefined &&
-    !["cr", "crlf", "lf"].includes(flags.lineEnding)
-  ) {
-    argumentError('lineEnding must be "cr", "crlf", or "lf"');
-  }
-  if (
-    input.length === 0 &&
-    expanded.length > 0 &&
-    !flags.help &&
-    !flags.version
-  ) {
-    argumentError(
-      "Provide at least one path, or run jsonsort with no arguments",
-    );
-  }
-
-  return {
-    flags,
-    indentationCount,
-    input: input.length ? input : ["**/*.json"],
-  };
-}
-
-function isCandidate(filePath) {
-  const basename = path.basename(filePath);
-  if (ignoredBasenames.has(basename)) {
-    return false;
-  }
-
-  const extension = path.extname(filePath).toLowerCase();
-  return (
-    extension === ".json" ||
-    (basename.startsWith(".") && !nonJsonFormats.has(extension))
-  );
-}
-
-function createPrinter() {
-  const useColour = Boolean(process.stdout.isTTY && !process.env.NO_COLOR);
-  const colours = { green: 32, grey: 90, red: 31, white: 37, yellow: 33 };
-  const colour = (value, name) =>
-    useColour ? `\u001b[${colours[name]}m${value}\u001b[39m` : value;
-  return { colour };
-}
-
-async function main() {
-  const rawArguments = process.argv.slice(2);
-  const silentRequested = requestsSilent(rawArguments);
-  let parsed;
-  try {
-    parsed = parseArguments(rawArguments);
-  } catch (error) {
-    if (!silentRequested) {
-      console.error(error.message);
-    }
-    process.exitCode = 1;
-    return;
-  }
-
-  const { flags, indentationCount, input } = parsed;
-  if (flags.version) {
-    console.log(pkg.version);
-    return;
-  }
-  if (flags.help) {
-    console.log(help);
-    return;
-  }
-
-  if (!flags.silent && !flags.ci && process.stdout.isTTY) {
-    try {
-      updateNotifier({ pkg }).notify();
-    } catch {}
-  }
-
-  const { colour } = createPrinter();
-  let paths;
-  try {
-    paths = await glob(
-      [
-        ...input,
-        "!**/package-lock.json",
-        "!**/npm-shrinkwrap.json",
-        "!**/yarn.lock",
-        ...(flags.nodemodules ? [] : ["!**/node_modules/**"]),
-        ...(flags.pack ? ["!**/package.json"] : []),
-      ],
-      {
-        dot: true,
-        expandDirectories: { files: [".*", "*.json", "*.JSON"] },
-        followSymbolicLinks: false,
-      },
-    );
-    paths = paths.filter(isCandidate);
-  } catch (error) {
-    if (!flags.silent) {
-      console.error(`${prefix}${error}`);
-    }
-    process.exitCode = 1;
-    return;
-  }
-
-  if (!paths.length) {
-    if (!flags.silent) {
-      console.log(`${prefix}The inputs don't lead to any JSON files. Exiting.`);
-    }
-    return;
-  }
-
-  if (flags.dry) {
-    if (!flags.silent) {
-      console.log(
-        `${prefix}We'd try to sort the following files:\n${paths.join("\n")}`,
-      );
-    }
-    return;
-  }
-
-  try {
-    const { successful, unsorted } = await processFiles(paths, {
-      arrays: flags.arrays,
-      ci: flags.ci,
-      indentationCount,
-      lineEnding: flags.lineEnding || undefined,
-      pack: flags.pack,
-      tabs: flags.tabs,
-      onOutcome(outcome) {
-        if (flags.silent) {
-          return;
-        }
-        if (outcome.status === "failure") {
-          console.error(
-            `${prefix}${outcome.path} - BAD (${outcome.stage}) - ${outcome.error}`,
-          );
-        } else if (!flags.ci) {
-          console.log(`${prefix}${outcome.path} - OK`);
-        }
-      },
-    });
-
-    if (flags.silent) {
-      if (flags.ci && unsorted.length) {
-        process.exitCode = 9;
-      }
-      return;
-    }
-    if (flags.ci) {
-      if (unsorted.length) {
-        console.log(
-          `${prefix}${colour("Unsorted files:", "red")}\n${unsorted.join("\n")}`,
-        );
-        process.exitCode = 9;
-      } else {
-        console.log(
-          `${prefix}${colour("All files were already sorted:", "white")}\n${successful.join("\n")}`,
-        );
-      }
-      return;
-    }
-    console.log(
-      `\n${prefix}${colour(
-        `All ${successful.length} file${successful.length === 1 ? "" : "s"} sorted`,
-        "green",
-      )}`,
-    );
-  } catch (error) {
-    if (!(error instanceof ProcessingError)) {
-      if (!flags.silent) {
-        console.error(`${prefix}${error}`);
-      }
-      process.exitCode = 1;
-      return;
-    }
-
-    if (!flags.silent) {
-      if (flags.ci) {
-        const unsorted = new Set(error.unsorted);
-        const alreadySorted = error.successful.filter(
-          (filePath) => !unsorted.has(filePath),
-        );
-        if (alreadySorted.length) {
-          console.log(
-            `${prefix}${alreadySorted.length} file${alreadySorted.length === 1 ? "" : "s"} already sorted:\n${alreadySorted.join("\n")}`,
-          );
-        }
-        if (error.unsorted.length) {
-          console.log(`${prefix}Unsorted files:\n${error.unsorted.join("\n")}`);
-        }
-      } else if (error.successful.length) {
-        console.log(
-          `\n${prefix}${error.successful.length} file${error.successful.length === 1 ? "" : "s"} sorted`,
-        );
-      }
-      console.error(
-        `${prefix}${error.failures.length} file${error.failures.length === 1 ? "" : "s"} could not be ${flags.ci ? "checked" : "sorted"} - ${error.failures.map(({ path: failedPath }) => failedPath).join(" - ")}`,
-      );
-    }
-    process.exitCode = 1;
-  }
-}
+import { main } from "./cli-main.js";
 
 await main();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "json-sort-cli",
-  "version": "4.2.3",
-  "description": "Command line app to deep sort JSON files, retains package.json special key order",
+  "version": "4.3.1",
+  "description": "Deep-sort JSON files or standard input; package.json retains its special key order",
   "keywords": [
     "app",
     "cli",
@@ -52,9 +52,12 @@
   },
   "c8": {
     "all": true,
+    "branches": 100,
     "check-coverage": true,
-    "exclude": ["**/test/**/*.*"],
-    "lines": 97
+    "exclude": ["**/test/**/*.*", "cli-update-notifier.js"],
+    "functions": 100,
+    "lines": 100,
+    "statements": 100
   },
   "lect": {
     "licence": {
@@ -62,12 +65,11 @@
     }
   },
   "dependencies": {
-    "codsen-glob": "^1.1.0",
-    "sort-package-json": "^2.15.1",
-    "update-notifier": "^7.3.1"
+    "codsen-glob": "^1.1.2",
+    "sort-package-json": "^2.15.1"
   },
   "devDependencies": {
-    "p-map": "^7.0.4"
+    "p-map": "^7.0.7"
   },
   "engines": {
     "node": ">=18.20.8"