@xylabs/ts-scripts-yarn3 3.14.2 → 3.15.1

package/dist/xy/xyCommonCommands.cjs

@@ -0,0 +1,723 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/xy/xyCommonCommands.ts
+var xyCommonCommands_exports = {};
+__export(xyCommonCommands_exports, {
+  xyCommonCommands: () => xyCommonCommands
+});
+module.exports = __toCommonJS(xyCommonCommands_exports);
+
+// src/lib/checkResult.ts
+var import_chalk = __toESM(require("chalk"), 1);
+var checkResult = /* @__PURE__ */ __name((name, result, level = "error", exitOnFail = false) => {
+  if (result) {
+    const exiting = exitOnFail ? "[Exiting Process]" : "[Continuing]";
+    const chalkFunc = level === "error" ? import_chalk.default.red : import_chalk.default.yellow;
+    console[level](chalkFunc(`${name} had ${result} failures ${exiting}`));
+    if (exitOnFail) {
+      process.exit(result);
+    }
+  }
+}, "checkResult");
+
+// src/lib/processEx.ts
+var import_chalk2 = __toESM(require("chalk"), 1);
+
+// src/lib/withError.ts
+var withError = /* @__PURE__ */ __name((ex, closure, predicate = (ex2) => ex2.name !== void 0 && ex2.message !== void 0) => {
+  return predicate(ex) ? closure(ex) : void 0;
+}, "withError");
+
+// src/lib/withErrnoException.ts
+var withErrnoException = /* @__PURE__ */ __name((ex, closure) => {
+  return withError(ex, closure, (ex2) => ex2.errno !== void 0);
+}, "withErrnoException");
+
+// src/lib/processEx.ts
+var processEx = /* @__PURE__ */ __name((ex) => {
+  const error = typeof ex === "string" ? new Error(ex) : ex;
+  const exitCode = withErrnoException(error, (error2) => {
+    if (error2.code === "ENOENT") {
+      console.error(import_chalk2.default.red(`'${error2.path}' not found.`));
+    } else {
+      console.error(import_chalk2.default.red(`Errno: ${error2.code}`));
+    }
+    return error2.errno ?? -1;
+  }) ?? withError(error, (error2) => {
+    console.error(import_chalk2.default.red(`${error2.name}: ${error2.message}`));
+    return -1;
+  }) ?? (() => {
+    console.error(import_chalk2.default.red(`Unexpected Error: ${JSON.stringify(ex, null, 2)}`));
+    return -1;
+  })();
+  process.exit(process.exitCode ?? exitCode);
+}, "processEx");
+
+// src/lib/safeExit.ts
+var safeExit = /* @__PURE__ */ __name((func, exitOnFail = true) => {
+  try {
+    const result = func();
+    if (result && exitOnFail) {
+      process.exit(result);
+    }
+    return result;
+  } catch (ex) {
+    return processEx(ex);
+  }
+}, "safeExit");
+
+// src/lib/file/constants.ts
+var WINDOWS_NEWLINE_REGEX = /\r\n/g;
+var CROSS_PLATFORM_NEWLINE = "\n";
+
+// src/lib/file/fileLines.ts
+var import_node_fs = require("fs");
+
+// src/lib/string/empty.ts
+var empty = /* @__PURE__ */ __name((value) => value?.trim().length === 0, "empty");
+var notEmpty = /* @__PURE__ */ __name((value) => !empty(value), "notEmpty");
+
+// src/lib/string/union.ts
+var union = /* @__PURE__ */ __name((a, b) => /* @__PURE__ */ new Set([
+  ...new Set(a),
+  ...new Set(b)
+]), "union");
+
+// src/lib/file/ReadFileSyncOptions.ts
+var defaultReadFileSyncOptions = {
+  encoding: "utf8"
+};
+
+// src/lib/file/fileLines.ts
+var readLines = /* @__PURE__ */ __name((uri, options = defaultReadFileSyncOptions) => (0, import_node_fs.existsSync)(uri) ? (0, import_node_fs.readFileSync)(uri, options).replace(WINDOWS_NEWLINE_REGEX, CROSS_PLATFORM_NEWLINE).split(CROSS_PLATFORM_NEWLINE) : [], "readLines");
+var readNonEmptyLines = /* @__PURE__ */ __name((uri, options = defaultReadFileSyncOptions) => readLines(uri, options).filter(notEmpty), "readNonEmptyLines");
+var writeLines = /* @__PURE__ */ __name((uri, lines, options = defaultReadFileSyncOptions) => {
+  const existing = (0, import_node_fs.existsSync)(uri) ? (0, import_node_fs.readFileSync)(uri, options) : void 0;
+  const desired = lines.join(CROSS_PLATFORM_NEWLINE);
+  if (existing !== desired) (0, import_node_fs.writeFileSync)(uri, desired, options);
+}, "writeLines");
+
+// src/lib/generateIgnoreFiles.ts
+var import_chalk3 = __toESM(require("chalk"), 1);
+
+// src/lib/yarn/isYarnVersionOrGreater.ts
+var import_node_child_process = require("child_process");
+var isYarnVersionOrGreater = /* @__PURE__ */ __name((major, minor, patch) => {
+  const result = (0, import_node_child_process.spawnSync)("yarn", [
+    "-v"
+  ], {
+    encoding: "utf8",
+    shell: true
+  });
+  const version = result.stdout.toString().replaceAll("\n", "");
+  const versionNumbers = version.split(".").map((ver) => Number.parseInt(ver));
+  const majorDelta = versionNumbers[0] - major;
+  const minorDelta = versionNumbers[1] - (minor ?? versionNumbers[1]);
+  const patchDelta = versionNumbers[2] - (patch ?? versionNumbers[2]);
+  const majorOk = majorDelta >= 0;
+  const minorOk = majorDelta > 0 || minorDelta >= 0;
+  const patchOk = majorDelta > 0 || minorDelta > 0 || patchDelta >= 0;
+  return [
+    majorOk && minorOk && patchOk,
+    version
+  ];
+}, "isYarnVersionOrGreater");
+
+// src/lib/yarn/workspace/yarnWorkspaces.ts
+var import_node_child_process2 = require("child_process");
+var yarnWorkspaces = /* @__PURE__ */ __name(() => {
+  const result = (0, import_node_child_process2.spawnSync)("yarn", [
+    "workspaces",
+    "list",
+    "--json",
+    "--recursive"
+  ], {
+    encoding: "utf8",
+    shell: true
+  });
+  if (result.error) {
+    throw result.error;
+  }
+  return result.stdout.toString().split("\n").slice(0, -1).map((item) => {
+    return JSON.parse(item);
+  });
+}, "yarnWorkspaces");
+
+// src/lib/yarn/workspace/yarnWorkspace.ts
+var yarnWorkspace = /* @__PURE__ */ __name((pkg) => {
+  const workspace = yarnWorkspaces().find(({ name }) => name === pkg);
+  if (!workspace) throw new Error(`Workspace ${pkg} not found`);
+  return workspace;
+}, "yarnWorkspace");
+
+// src/lib/yarn/yarnInitCwd.ts
+var INIT_CWD = /* @__PURE__ */ __name(() => {
+  if (!process.env.INIT_CWD) console.error("Missing INIT_CWD");
+  return process.env.INIT_CWD;
+}, "INIT_CWD");
+
+// src/lib/generateIgnoreFiles.ts
+var mergeEntries = /* @__PURE__ */ __name((a, b) => [
+  ...union(a, b)
+].sort(), "mergeEntries");
+var generateIgnoreFiles = /* @__PURE__ */ __name((filename3, pkg) => {
+  console.log(import_chalk3.default.green(`Generate ${filename3} Files`));
+  const cwd = INIT_CWD() ?? ".";
+  const workspaces = pkg ? [
+    yarnWorkspace(pkg)
+  ] : yarnWorkspaces();
+  const readEntries = /* @__PURE__ */ __name((location) => readNonEmptyLines(`${location}/${filename3}`), "readEntries");
+  const writeEntries = /* @__PURE__ */ __name((location, entries) => writeLines(`${location}/${filename3}`, entries), "writeEntries");
+  const results = workspaces.map(({ location, name }) => {
+    try {
+      writeEntries(location, mergeEntries(readEntries(cwd), readEntries(location)));
+      return 0;
+    } catch (ex) {
+      const error = ex;
+      console.error(`Generate ${filename3} Files [${name}] [${error.message}]`);
+      return 1;
+    }
+  });
+  const succeeded = results.every((result) => result === 0);
+  return succeeded ? 0 : 1;
+}, "generateIgnoreFiles");
+
+// src/lib/runSteps.ts
+var import_node_child_process3 = require("child_process");
+var import_node_fs2 = require("fs");
+var import_chalk4 = __toESM(require("chalk"), 1);
+var runSteps = /* @__PURE__ */ __name((name, steps, exitOnFail = true, messages) => {
+  return safeExit(() => {
+    const pkgName = process.env.npm_package_name;
+    console.log(import_chalk4.default.green(`${name} [${pkgName}]`));
+    let totalStatus = 0;
+    for (const [i, [command, args, config]] of steps.entries()) {
+      if (messages?.[i]) {
+        console.log(import_chalk4.default.gray(messages?.[i]));
+      }
+      const argList = Array.isArray(args) ? args : args.split(" ");
+      if (command === "node" && !(0, import_node_fs2.existsSync)(argList[0])) {
+        throw new Error(`File not found [${argList[0]}]`);
+      }
+      const status = (0, import_node_child_process3.spawnSync)(command, Array.isArray(args) ? args : args.split(" "), {
+        ...config,
+        encoding: "utf8",
+        env: {
+          FORCE_COLOR: "3",
+          ...process.env
+        },
+        shell: true,
+        stdio: "inherit"
+      }).status ?? 0;
+      checkResult(name, status, "error", exitOnFail);
+      totalStatus += status ?? 0;
+    }
+    return totalStatus;
+  }, !!exitOnFail);
+}, "runSteps");
+
+// src/actions/clean-docs.ts
+var import_node_path = __toESM(require("path"), 1);
+var import_chalk5 = __toESM(require("chalk"), 1);
+var import_rimraf = require("rimraf");
+var cleanDocs = /* @__PURE__ */ __name(() => {
+  const pkgName = process.env.npm_package_name;
+  console.log(import_chalk5.default.green(`Cleaning Docs [${pkgName}]`));
+  for (const { location } of yarnWorkspaces()) (0, import_rimraf.rimrafSync)(import_node_path.default.join(location, "docs"), {
+    glob: true
+  });
+  return 0;
+}, "cleanDocs");
+
+// src/actions/dead.ts
+var dead = /* @__PURE__ */ __name(() => {
+  return runSteps("Dead", [
+    [
+      "yarn",
+      [
+        "ts-prune",
+        "-p",
+        "tsconfig.json"
+      ]
+    ]
+  ]);
+}, "dead");
+
+// src/actions/deps.ts
+var import_chalk6 = __toESM(require("chalk"), 1);
+var deps = /* @__PURE__ */ __name(({ pkg, incremental }) => {
+  pkg ? depsPackage({
+    pkg
+  }) : depsAll({
+    incremental
+  });
+  return 0;
+}, "deps");
+var depsPackage = /* @__PURE__ */ __name(({ pkg }) => {
+  const steps = [
+    [
+      "yarn",
+      [
+        "workspace",
+        pkg,
+        "run",
+        "package-deps"
+      ]
+    ]
+  ];
+  return runSteps(`Deps [${pkg}]`, [
+    ...steps
+  ]);
+}, "depsPackage");
+var depsAll = /* @__PURE__ */ __name(({ incremental, jobs, verbose }) => {
+  const start = Date.now();
+  const jobsOptions = jobs ? [
+    "-j",
+    `${jobs}`
+  ] : [];
+  const verboseOptions = verbose ? [
+    "--verbose"
+  ] : [
+    "--no-verbose"
+  ];
+  if (jobs) {
+    console.log(import_chalk6.default.blue(`Jobs set to [${jobs}]`));
+  }
+  const incrementalOptions = incremental ? [
+    "--since",
+    "-pA"
+  ] : [
+    "-pA"
+  ];
+  const steps = [
+    [
+      "yarn",
+      [
+        "workspaces",
+        "foreach",
+        ...jobsOptions,
+        ...incrementalOptions,
+        ...verboseOptions,
+        "run",
+        "package-deps"
+      ]
+    ]
+  ];
+  const result = runSteps(`Deps${incremental ? "-Incremental" : ""} [All]`, [
+    ...steps
+  ]);
+  console.log(`${import_chalk6.default.gray("Dep checked in")} [${import_chalk6.default.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${import_chalk6.default.gray("seconds")}`);
+  return result;
+}, "depsAll");
+
+// src/actions/gen-docs.ts
+var genDocs = /* @__PURE__ */ __name(({ pkg, incremental }) => {
+  return pkg ? genDocsPackage({
+    pkg
+  }) : genDocsAll({
+    incremental
+  });
+}, "genDocs");
+var genDocsPackage = /* @__PURE__ */ __name(({ pkg }) => {
+  const steps = [
+    [
+      "yarn",
+      [
+        "workspace",
+        pkg,
+        "run",
+        "package-gen-docs"
+      ]
+    ]
+  ];
+  return runSteps(`GenDocs [${pkg}]`, [
+    ...steps
+  ]);
+}, "genDocsPackage");
+var genDocsAll = /* @__PURE__ */ __name(({ incremental }) => {
+  const incrementalOptions = incremental ? [
+    "--since",
+    "-pA"
+  ] : [
+    "-pA"
+  ];
+  const steps = [
+    [
+      "yarn",
+      [
+        "workspaces",
+        "foreach",
+        ...incrementalOptions,
+        "run",
+        "package-gen-docs"
+      ]
+    ]
+  ];
+  return runSteps(`GenDocs [All${incremental ? "-Incremental" : ""}]`, [
+    ...steps
+  ]);
+}, "genDocsAll");
+
+// src/actions/gitignore-gen.ts
+var filename = ".gitignore";
+var gitignoreGen = /* @__PURE__ */ __name((pkg) => generateIgnoreFiles(filename, pkg), "gitignoreGen");
+
+// src/actions/gitlint.ts
+var import_chalk7 = __toESM(require("chalk"), 1);
+var import_parse_git_config = __toESM(require("parse-git-config"), 1);
+var gitlint = /* @__PURE__ */ __name(() => {
+  console.log(`
+Gitlint Start [${process.cwd()}]
+`);
+  let valid = 0;
+  let warnings = 0;
+  const errors = 0;
+  const gitConfig = import_parse_git_config.default.sync();
+  const warn = /* @__PURE__ */ __name((message) => {
+    console.warn(import_chalk7.default.yellow(`Warning: ${message}`));
+    warnings++;
+  }, "warn");
+  if (gitConfig.core.ignorecase) {
+    warn("Please set core.ignorecase to FALSE in .git/config file [run yarn gitlint-fix]");
+  } else {
+    valid++;
+  }
+  if (gitConfig.core.autocrlf === false) {
+    valid++;
+  } else {
+    warn("Please set core.autocrlf to FALSE in .git/config file [run yarn gitlint-fix]");
+  }
+  if (gitConfig.core.eol === "lf") {
+    valid++;
+  } else {
+    warn('Please set core.eol to "lf" in .git/config file [run yarn gitlint-fix]');
+  }
+  const resultMessages = [];
+  if (valid > 0) {
+    resultMessages.push(import_chalk7.default.green(`Passed: ${valid}`));
+  }
+  if (warnings > 0) {
+    resultMessages.push(import_chalk7.default.yellow(`Warnings: ${warnings}`));
+  }
+  if (errors > 0) {
+    resultMessages.push(import_chalk7.default.red(` Errors: ${errors}`));
+  }
+  console.warn(`Gitlint Finish [ ${resultMessages.join(" | ")} ]
+`);
+  return warnings + errors === 0 ? 1 : 0;
+}, "gitlint");
+
+// src/actions/gitlint-fix.ts
+var import_node_child_process4 = require("child_process");
+var import_chalk8 = __toESM(require("chalk"), 1);
+var import_parse_git_config2 = __toESM(require("parse-git-config"), 1);
+var gitlintFix = /* @__PURE__ */ __name(() => {
+  console.log(`
+Gitlint Fix Start [${process.cwd()}]
+`);
+  const gitConfig = import_parse_git_config2.default.sync();
+  if (gitConfig.core.ignorecase) {
+    (0, import_node_child_process4.execSync)("git config core.ignorecase false", {
+      stdio: "inherit"
+    });
+    console.warn(import_chalk8.default.yellow("\nGitlint Fix: Updated core.ignorecase to be false\n"));
+  }
+  if (gitConfig.core.autocrlf !== false) {
+    (0, import_node_child_process4.execSync)("git config core.autocrlf false", {
+      stdio: "inherit"
+    });
+    console.warn(import_chalk8.default.yellow("\nGitlint Fix: Updated core.autocrlf to be false\n"));
+  }
+  if (gitConfig.core.eol !== "lf") {
+    (0, import_node_child_process4.execSync)("git config core.eol lf", {
+      stdio: "inherit"
+    });
+    console.warn(import_chalk8.default.yellow('\nGitlint Fix: Updated core.eol to be "lf"\n'));
+  }
+  return 1;
+}, "gitlintFix");
+
+// src/actions/license.ts
+var import_chalk9 = __toESM(require("chalk"), 1);
+var import_license_checker = require("license-checker");
+var license = /* @__PURE__ */ __name(async (pkg) => {
+  const workspaces = yarnWorkspaces();
+  const workspaceList = workspaces.filter(({ name }) => {
+    return pkg === void 0 || name === pkg;
+  });
+  const exclude = /* @__PURE__ */ new Set([
+    "MIT",
+    "MIT*",
+    "ISC",
+    "Apache-2.0",
+    "BSD",
+    "BSD*",
+    "BSD-2-Clause",
+    "BSD-3-Clause",
+    "CC-BY-4.0",
+    "Unlicense",
+    "CC-BY-3.0",
+    "CC0-1.0",
+    "LGPL-3.0-only",
+    "LGPL-3.0",
+    "LGPL-3.0-or-later",
+    "Python-2.0"
+  ]);
+  console.log(import_chalk9.default.green("License Checker"));
+  return (await Promise.all(workspaceList.map(({ location, name }) => {
+    return new Promise((resolve) => {
+      (0, import_license_checker.init)({
+        production: true,
+        start: location
+      }, (error, packages) => {
+        if (error) {
+          console.error(import_chalk9.default.red(`License Checker [${name}] Error`));
+          console.error(import_chalk9.default.gray(error));
+          console.log("\n");
+          resolve(1);
+        } else {
+          console.log(import_chalk9.default.green(`License Checker [${name}]`));
+          let count = 0;
+          for (const [name2, info] of Object.entries(packages)) {
+            const licenses = Array.isArray(info.licenses) ? info.licenses : [
+              info.licenses
+            ];
+            for (let license2 of licenses) {
+              if (license2) {
+                if (license2[0] === "(" && license2.at(-1) === ")") {
+                  license2 = license2.slice(1, -2);
+                }
+                const orLicenses = license2.split(" OR ");
+                let orLicenseFound = false;
+                for (const orLicense of orLicenses) {
+                  if (exclude.has(orLicense)) {
+                    orLicenseFound = true;
+                  }
+                }
+                if (!orLicenseFound) {
+                  count++;
+                  console.warn(import_chalk9.default.yellow(`${name2}: Package License not allowed [${license2}]`));
+                }
+              }
+            }
+          }
+          console.log("\n");
+          resolve(count);
+        }
+      });
+    });
+  }))).reduce((prev, value) => prev || value, 0);
+}, "license");
+
+// src/actions/npmignore-gen.ts
+var filename2 = ".npmignore";
+var npmignoreGen = /* @__PURE__ */ __name((pkg) => generateIgnoreFiles(filename2, pkg), "npmignoreGen");
+
+// src/actions/retest.ts
+var retest = /* @__PURE__ */ __name(() => {
+  return runSteps("Test", [
+    [
+      "yarn",
+      [
+        "jest",
+        "--clearCache"
+      ]
+    ],
+    [
+      "yarn",
+      [
+        "jest",
+        "."
+      ]
+    ]
+  ]);
+}, "retest");
+
+// src/actions/test.ts
+var test = /* @__PURE__ */ __name(() => {
+  return runSteps("Test", [
+    [
+      "yarn",
+      [
+        "jest",
+        "."
+      ]
+    ]
+  ]);
+}, "test");
+
+// src/actions/upplug.ts
+var updateYarnPlugins = /* @__PURE__ */ __name(() => {
+  return runSteps("Update Yarn Plugins", [
+    [
+      "yarn",
+      [
+        "plugin",
+        "import",
+        "https://mskelton.dev/yarn-outdated/v3"
+      ]
+    ],
+    [
+      "yarn",
+      [
+        "plugin",
+        "import",
+        "version"
+      ]
+    ],
+    [
+      "yarn",
+      [
+        "plugin",
+        "import",
+        "interactive-tools"
+      ]
+    ],
+    [
+      "yarn",
+      [
+        "plugin",
+        "import",
+        "workspace-tools"
+      ]
+    ]
+  ]);
+}, "updateYarnPlugins");
+
+// src/actions/upyarn.ts
+var updateYarnVersion = /* @__PURE__ */ __name(() => {
+  return runSteps("Update Yarn Version", [
+    [
+      "yarn",
+      [
+        "set",
+        "version",
+        "latest"
+      ]
+    ]
+  ]);
+}, "updateYarnVersion");
+
+// src/actions/yarn3only.ts
+var yarn3Only = /* @__PURE__ */ __name(() => {
+  const [valid, version] = isYarnVersionOrGreater(3);
+  if (!valid) {
+    processEx(`Invalid Yarn version [${version}]`);
+  }
+  return 0;
+}, "yarn3Only");
+
+// src/xy/param.ts
+var packagePositionalParam = /* @__PURE__ */ __name((yargs) => {
+  return yargs.positional("package", {
+    describe: "Specific package to target"
+  });
+}, "packagePositionalParam");
+
+// src/xy/xyCommonCommands.ts
+var xyCommonCommands = /* @__PURE__ */ __name((args) => {
+  return args.command("license [package]", "License - Check licenses of dependencies", (yargs) => {
+    return packagePositionalParam(yargs);
+  }, async (argv) => {
+    if (argv.verbose) console.log(`License: ${argv.package ?? "all"}`);
+    process.exitCode = await license();
+  }).command("dead [package]", "Dead - Check for dead code", (yargs) => {
+    return packagePositionalParam(yargs);
+  }, (argv) => {
+    if (argv.verbose) console.log("Dead");
+    process.exitCode = dead();
+  }).command("deps [package]", "Deps - Check for unused or missing dependencies", (yargs) => {
+    return packagePositionalParam(yargs);
+  }, (argv) => {
+    if (argv.verbose) console.log(`Checking Dependencies: ${argv.package ?? "all"}`);
+    process.exitCode = deps({
+      incremental: !!argv.incremental,
+      jobs: argv.jobs,
+      pkg: argv.package
+    });
+  }).command("gen-docs [package]", "GenDocs - Generate TypeDocs", (yargs) => {
+    return packagePositionalParam(yargs);
+  }, (argv) => {
+    if (argv.verbose) console.log(`Generating TypeDocs: ${argv.package ?? "all"}`);
+    process.exitCode = genDocs({
+      incremental: !!argv.incremental,
+      pkg: argv.package
+    });
+  }).command("clean-docs", "CleanDocs - Clean TypeDocs", (yargs) => yargs, (argv) => {
+    if (argv.verbose) console.log("Cleaning TypeDocs: all");
+    process.exitCode = cleanDocs();
+  }).command("gitlint [package]", "Gitlint - Lint your git config", (yargs) => {
+    return yargs;
+  }, (argv) => {
+    if (argv.verbose) console.log("Gitlint");
+    process.exitCode = argv.fix ? gitlintFix() : gitlint();
+  }).command("gitignore-gen", "GitIgnore Gen - Generate .gitignore files", (yargs) => {
+    return yargs;
+  }, (argv) => {
+    if (argv.verbose) console.log("GitIgnore Gen");
+    process.exitCode = gitignoreGen();
+  }).command("npmignore-gen", "NpmIgnore Gen - Generate .npmignore files", (yargs) => {
+    return yargs;
+  }, (argv) => {
+    if (argv.verbose) console.log("NpmIgnore Gen");
+    process.exitCode = npmignoreGen();
+  }).command("retest", "Re-Test - Run Jest Tests with cleaned cache", (yargs) => {
+    return yargs;
+  }, (argv) => {
+    if (argv.verbose) console.log("Re-Testing");
+    process.exitCode = retest();
+  }).command("test", "Test - Run Jest Tests", (yargs) => {
+    return yargs;
+  }, (argv) => {
+    if (argv.verbose) console.log("Testing");
+    process.exitCode = test();
+  }).command("upplug", "UpPlug - Update Yarn Plugins", (yargs) => {
+    return yargs;
+  }, (argv) => {
+    if (argv.verbose) console.log("UpPlug");
+    process.exitCode = updateYarnPlugins();
+  }).command("upyarn", "UpYarn - Update Yarn Version", (yargs) => {
+    return yargs;
+  }, (argv) => {
+    if (argv.verbose) console.log("UpYarn");
+    process.exitCode = updateYarnVersion();
+  }).command("yarn3only", "Yarn3Only - Check if using Yarn v3", (yargs) => {
+    return yargs;
+  }, (argv) => {
+    if (argv.verbose) console.log("Yarn 3 Check");
+    process.exitCode = yarn3Only();
+  });
+}, "xyCommonCommands");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  xyCommonCommands
+});
+//# sourceMappingURL=xyCommonCommands.cjs.map