@xylabs/ts-scripts-yarn3 2.19.10 → 2.19.12

package/dist/lib/xy/xyCommonCommands.mjs

@@ -1,27 +1,603 @@
-import {
-  cleanDocs,
-  dead,
-  deps,
-  genDocs,
-  gitignoreGen,
-  gitlint,
-  gitlintFix,
-  license,
-  npmignoreGen,
-  retest,
-  test,
-  tsconfigGen,
-  tsconfigGenClean,
-  updateYarnPlugins,
-  updateYarnVersion,
-  yarn3Only
-} from "../../actions";
-const xyCommonCommands = (args) => {
+// src/lib/checkResult.ts
+import chalk from "chalk";
+var checkResult = (name, result, level = "error", exitOnFail = false) => {
+  if (result) {
+    const exiting = exitOnFail ? "[Exiting Process]" : "[Continuing]";
+    const chalkFunc = level === "error" ? chalk.red : chalk.yellow;
+    console[level](chalkFunc(`${name} had ${result} failures ${exiting}`));
+    if (exitOnFail) {
+      process.exit(result);
+    }
+  }
+};
+
+// src/lib/createBuildConfig.ts
+import { readFileSync } from "fs";
+
+// src/lib/defaultBuildConfig.ts
+var defaultBuildConfig = {
+  compilerOptions: {
+    rootDir: "src",
+    rootDirs: ["package.json"]
+  },
+  exclude: ["**/build", "**/dist", "**/node_modules", "**/*.spec.*", "**/*.spec", "**/*.stories.*", "**/*.example.*", "**/spec/*", "**/stories/*"],
+  include: ["src"]
+};
+
+// src/lib/createBuildConfig.ts
+var getGeneralTypescriptConfig = (location) => {
+  let generalConfig;
+  try {
+    generalConfig = readFileSync(`${location}/tsconfig.json`, { encoding: "utf8" });
+  } catch (ex) {
+    return false;
+  }
+  return JSON.parse(generalConfig);
+};
+var createBuildConfig = (location, module, target, outDirSuffix) => {
+  const generalConfigObject = getGeneralTypescriptConfig(location);
+  if (generalConfigObject === false) {
+    return void 0;
+  }
+  return {
+    ...generalConfigObject,
+    compilerOptions: {
+      ...defaultBuildConfig.compilerOptions,
+      ...generalConfigObject.compilerOptions ?? {},
+      module,
+      outDir: `./${generalConfigObject.compilerOptions?.outDir ?? "dist"}/${outDirSuffix}`,
+      target
+    },
+    exclude: [...generalConfigObject.exclude ?? [], ...defaultBuildConfig.exclude],
+    include: [...generalConfigObject.include ?? [], ...defaultBuildConfig.include]
+  };
+};
+
+// src/lib/processEx.ts
+import chalk2 from "chalk";
+
+// src/lib/withError.ts
+var withError = (ex, closure, predicate = (ex2) => ex2.name !== void 0 && ex2.message !== void 0) => {
+  return predicate(ex) ? closure(ex) : void 0;
+};
+
+// src/lib/withErrnoException.ts
+var withErrnoException = (ex, closure) => {
+  return withError(ex, closure, (ex2) => ex2.errno !== void 0);
+};
+
+// src/lib/processEx.ts
+var processEx = (ex) => {
+  const error = typeof ex === "string" ? Error(ex) : ex;
+  const exitCode = withErrnoException(error, (error2) => {
+    if (error2.code === "ENOENT") {
+      console.error(chalk2.red(`'${error2.path}' not found.`));
+    } else {
+      console.error(chalk2.red(`Errno: ${error2.code}`));
+    }
+    return error2.errno ?? -1;
+  }) ?? withError(error, (error2) => {
+    console.error(chalk2.red(`${error2.name}: ${error2.message}`));
+    return -1;
+  }) ?? (() => {
+    console.error(chalk2.red(`Unexpected Error: ${JSON.stringify(ex, null, 2)}`));
+    return -1;
+  })();
+  process.exit(process.exitCode ?? exitCode);
+};
+
+// src/lib/safeExit.ts
+var safeExit = (func, exitOnFail = true) => {
+  try {
+    const result = func();
+    if (result && exitOnFail) {
+      process.exit(result);
+    }
+    return result;
+  } catch (ex) {
+    return processEx(ex);
+  }
+};
+
+// src/lib/file/constants.ts
+var WINDOWS_NEWLINE_REGEX = /\r\n/g;
+var CROSS_PLATFORM_NEWLINE = "\n";
+
+// src/lib/file/fileLines.ts
+import { existsSync, readFileSync as readFileSync2, writeFileSync } from "node:fs";
+
+// src/lib/string/empty.ts
+var empty = (value) => value?.trim().length === 0;
+var notEmpty = (value) => !empty(value);
+
+// src/lib/string/union.ts
+var union = (a, b) => /* @__PURE__ */ new Set([...new Set(a), ...new Set(b)]);
+
+// src/lib/file/ReadFileSyncOptions.ts
+var defaultReadFileSyncOptions = { encoding: "utf-8" };
+
+// src/lib/file/fileLines.ts
+var readLines = (uri, options = defaultReadFileSyncOptions) => existsSync(uri) ? readFileSync2(uri, options).replace(WINDOWS_NEWLINE_REGEX, CROSS_PLATFORM_NEWLINE).split(CROSS_PLATFORM_NEWLINE) : [];
+var readNonEmptyLines = (uri, options = defaultReadFileSyncOptions) => readLines(uri, options).filter(notEmpty);
+var writeLines = (uri, lines, options = defaultReadFileSyncOptions) => {
+  const existing = existsSync(uri) ? readFileSync2(uri, options) : void 0;
+  const desired = lines.join(CROSS_PLATFORM_NEWLINE);
+  if (existing !== desired)
+    writeFileSync(uri, desired, options);
+};
+
+// src/lib/generateIgnoreFiles.ts
+import chalk3 from "chalk";
+
+// src/lib/yarn/isYarnVersionOrGreater.ts
+import { spawnSync } from "child_process";
+var isYarnVersionOrGreater = (major, minor, patch) => {
+  const result = spawnSync("yarn", ["-v"], { encoding: "utf8", shell: true });
+  const version = result.stdout.toString().replaceAll("\n", "");
+  const versionNumbers = version.split(".").map((ver) => 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];
+};
+
+// src/lib/yarn/workspace/yarnWorkspaces.ts
+import { spawnSync as spawnSync2 } from "child_process";
+var yarnWorkspaces = () => {
+  const result = spawnSync2("yarn", ["workspaces", "list", "--json", "--recursive"], { encoding: "utf8", shell: true });
+  if (result.error) {
+    throw result.error;
+  }
+  const list = result.stdout.toString().split("\n").slice(0, -1).map((item) => {
+    return JSON.parse(item);
+  });
+  return list;
+};
+
+// src/lib/yarn/workspace/yarnWorkspace.ts
+var yarnWorkspace = (pkg) => {
+  const workspace = yarnWorkspaces().find(({ name }) => name === pkg);
+  if (!workspace)
+    throw new Error(`Workspace ${pkg} not found`);
+  return workspace;
+};
+
+// src/lib/yarn/yarnInitCwd.ts
+var INIT_CWD = () => {
+  if (!process.env.INIT_CWD)
+    console.error("Missing INIT_CWD");
+  return process.env.INIT_CWD;
+};
+
+// src/lib/generateIgnoreFiles.ts
+var mergeEntries = (a, b) => [...union(a, b)].sort();
+var generateIgnoreFiles = (filename3, pkg) => {
+  console.log(chalk3.green(`Generate ${filename3} Files`));
+  const cwd = INIT_CWD() ?? ".";
+  const workspaces = pkg ? [yarnWorkspace(pkg)] : yarnWorkspaces();
+  const readEntries = (location) => readNonEmptyLines(`${location}/${filename3}`);
+  const writeEntries = (location, entries) => writeLines(`${location}/${filename3}`, entries);
+  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;
+};
+
+// src/lib/runSteps.ts
+import chalk4 from "chalk";
+import { spawnSync as spawnSync3 } from "child_process";
+import { existsSync as existsSync2 } from "fs";
+var runSteps = (name, steps, exitOnFail = true, messages) => {
+  return safeExit(() => {
+    const pkgName = process.env.npm_package_name;
+    console.log(chalk4.green(`${name} [${pkgName}]`));
+    let totalStatus = 0;
+    for (let i = 0; i < steps.length; i++) {
+      const [command, args, config] = steps[i];
+      if (messages?.[i]) {
+        console.log(chalk4.gray(messages?.[i]));
+      }
+      const argList = Array.isArray(args) ? args : args.split(" ");
+      if (command === "node" && !existsSync2(argList[0])) {
+        throw Error(`File not found [${argList[0]}]`);
+      }
+      const status = spawnSync3(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);
+};
+
+// src/actions/clean-docs.ts
+import chalk5 from "chalk";
+import path from "path";
+import { rimrafSync } from "rimraf";
+var cleanDocs = () => {
+  const pkgName = process.env.npm_package_name;
+  console.log(chalk5.green(`Cleaning Docs [${pkgName}]`));
+  yarnWorkspaces().map(({ location }) => rimrafSync(path.join(location, "docs"), { glob: true }));
+  return 0;
+};
+
+// src/actions/dead.ts
+var dead = () => {
+  return runSteps("Dead", [["yarn", ["ts-prune", "-p", "tsconfig.json"]]]);
+};
+
+// src/actions/deps.ts
+import chalk6 from "chalk";
+var deps = ({ pkg, incremental }) => {
+  pkg ? depsPackage({ pkg }) : depsAll({ incremental });
+  return 0;
+};
+var depsPackage = ({ pkg }) => {
+  const steps = [["yarn", ["workspace", pkg, "run", "package-deps"]]];
+  return runSteps(`Deps [${pkg}]`, [...steps]);
+};
+var depsAll = ({ incremental, jobs }) => {
+  const start = Date.now();
+  const jobsOptions = jobs ? ["-j", `${jobs}`] : [];
+  if (jobs) {
+    console.log(chalk6.blue(`Jobs set to [${jobs}]`));
+  }
+  const incrementalOptions = incremental ? ["--since", "-pA"] : ["-pA"];
+  const steps = [["yarn", ["workspaces", "foreach", ...jobsOptions, ...incrementalOptions, "run", "package-deps"]]];
+  const result = runSteps(`Deps${incremental ? "-Incremental" : ""} [All]`, [...steps]);
+  console.log(`${chalk6.gray("Dep checked in")} [${chalk6.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${chalk6.gray("seconds")}`);
+  return result;
+};
+
+// src/actions/gen-docs.ts
+var genDocs = ({ pkg, incremental }) => {
+  return pkg ? genDocsPackage({ pkg }) : genDocsAll({ incremental });
+};
+var genDocsPackage = ({ pkg }) => {
+  const steps = [["yarn", ["workspace", pkg, "run", "package-gen-docs"]]];
+  return runSteps(`GenDocs [${pkg}]`, [...steps]);
+};
+var genDocsAll = ({ incremental }) => {
+  const incrementalOptions = incremental ? ["--since", "-pA"] : ["-pA"];
+  const steps = [["yarn", ["workspaces", "foreach", ...incrementalOptions, "run", "package-gen-docs"]]];
+  return runSteps(`GenDocs [All${incremental ? "-Incremental" : ""}]`, [...steps]);
+};
+
+// src/actions/gitignore-gen.ts
+var filename = ".gitignore";
+var gitignoreGen = (pkg) => generateIgnoreFiles(filename, pkg);
+
+// src/actions/gitlint.ts
+import chalk7 from "chalk";
+import { sync } from "parse-git-config";
+var gitlint = () => {
+  console.log(`
+Gitlint Start [${process.cwd()}]
+`);
+  let valid = 0;
+  let warnings = 0;
+  const errors = 0;
+  const gitConfig = sync();
+  const warn = (message) => {
+    console.warn(chalk7.yellow(`Warning: ${message}`));
+    warnings++;
+  };
+  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) {
+    warn("Please set core.autocrlf to FALSE in .git/config file [run yarn gitlint-fix]");
+  } else {
+    valid++;
+  }
+  if (gitConfig.core.eol !== "lf") {
+    warn('Please set core.eol to "lf" in .git/config file [run yarn gitlint-fix]');
+  } else {
+    valid++;
+  }
+  const resultMessages = [];
+  if (valid > 0) {
+    resultMessages.push(chalk7.green(`Passed: ${valid}`));
+  }
+  if (warnings > 0) {
+    resultMessages.push(chalk7.yellow(`Warnings: ${warnings}`));
+  }
+  if (errors > 0) {
+    resultMessages.push(chalk7.red(` Errors: ${errors}`));
+  }
+  console.warn(`Gitlint Finish [ ${resultMessages.join(" | ")} ]
+`);
+  return warnings + errors === 0 ? 1 : 0;
+};
+
+// src/actions/gitlint-fix.ts
+import chalk8 from "chalk";
+import { execSync } from "child_process";
+import { sync as sync2 } from "parse-git-config";
+var gitlintFix = () => {
+  console.log(`
+Gitlint Fix Start [${process.cwd()}]
+`);
+  const gitConfig = sync2();
+  if (gitConfig.core.ignorecase) {
+    execSync("git config core.ignorecase false", { stdio: "inherit" });
+    console.warn(chalk8.yellow("\nGitlint Fix: Updated core.ignorecase to be false\n"));
+  }
+  if (gitConfig.core.autocrlf !== false) {
+    execSync("git config core.autocrlf false", { stdio: "inherit" });
+    console.warn(chalk8.yellow("\nGitlint Fix: Updated core.autocrlf to be false\n"));
+  }
+  if (gitConfig.core.eol !== "lf") {
+    execSync("git config core.eol lf", { stdio: "inherit" });
+    console.warn(chalk8.yellow('\nGitlint Fix: Updated core.eol to be "lf"\n'));
+  }
+  return 1;
+};
+
+// src/actions/license.ts
+import chalk9 from "chalk";
+import { init } from "license-checker";
+var license = async (pkg) => {
+  const workspaces = yarnWorkspaces();
+  const workspaceList = workspaces.filter(({ name }) => {
+    return pkg === void 0 || name === pkg;
+  });
+  const exclude = [
+    "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(chalk9.green("License Checker"));
+  return (await Promise.all(
+    workspaceList.map(({ location, name }) => {
+      return new Promise((resolve) => {
+        init({ production: true, start: location }, (error, packages) => {
+          if (error) {
+            console.error(chalk9.red(`License Checker [${name}] Error`));
+            console.error(chalk9.gray(error));
+            console.log("\n");
+            resolve(1);
+          } else {
+            console.log(chalk9.green(`License Checker [${name}]`));
+            let count = 0;
+            Object.entries(packages).forEach(([name2, info]) => {
+              const licenses = Array.isArray(info.licenses) ? info.licenses : [info.licenses];
+              licenses.forEach((license2) => {
+                if (license2) {
+                  if (license2[0] === "(" && license2[license2.length - 1] === ")") {
+                    license2 = license2.substring(1, license2.length - 2);
+                  }
+                  const orLicenses = license2.split(" OR ");
+                  let orLicenseFound = false;
+                  orLicenses.forEach((orLicense) => {
+                    if (exclude.includes(orLicense)) {
+                      orLicenseFound = true;
+                    }
+                  });
+                  if (!orLicenseFound) {
+                    count++;
+                    console.warn(chalk9.yellow(`${name2}: Package License not allowed [${license2}]`));
+                  }
+                }
+              });
+            });
+            console.log("\n");
+            resolve(count);
+          }
+        });
+      });
+    })
+  )).reduce((prev, value) => prev || value, 0);
+};
+
+// src/actions/npmignore-gen.ts
+var filename2 = ".npmignore";
+var npmignoreGen = (pkg) => generateIgnoreFiles(filename2, pkg);
+
+// src/actions/retest.ts
+var retest = () => {
+  return runSteps("Test", [
+    ["yarn", ["jest", "--clearCache"]],
+    ["yarn", ["jest", "."]]
+  ]);
+};
+
+// src/actions/test.ts
+var test = () => {
+  return runSteps("Test", [["yarn", ["jest", "."]]]);
+};
+
+// src/actions/tsconfig-gen-cjs.ts
+import chalk10 from "chalk";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+var tsconfigGenCjs = (pkg) => {
+  const workspaces = pkg ? [yarnWorkspace(pkg)] : yarnWorkspaces();
+  console.log(chalk10.green("Generate Configs [CJS]"));
+  return workspaces.map(({ location, name }) => {
+    try {
+      const configObject = createBuildConfig(location, "CommonJS", "ES6", "cjs");
+      if (configObject) {
+        const config = JSON.stringify(createBuildConfig(location, "CommonJS", "ES6", "cjs"), null, 2);
+        let currentConfig;
+        try {
+          currentConfig = readFileSync3(`${location}/.tsconfig.build.cjs.json`, { encoding: "utf8" });
+        } catch (ex) {
+          currentConfig = void 0;
+        }
+        if (currentConfig !== config) {
+          console.log(chalk10.gray(`Updating CJS tsconfig [${name}]`));
+          writeFileSync2(`${location}/.tsconfig.build.cjs.json`, config, { encoding: "utf8" });
+        }
+      }
+      return 0;
+    } catch (ex) {
+      const error = ex;
+      console.error(`tsconfig (CJS) generate failed [${name}] [${error.message}]`);
+      return 1;
+    }
+  }).reduce((prev, value) => prev || value, 0);
+};
+
+// src/actions/tsconfig-gen-esm.ts
+import chalk11 from "chalk";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+var tsconfigGenEsm = (pkg) => {
+  const workspaces = pkg ? [yarnWorkspace(pkg)] : yarnWorkspaces();
+  console.log(chalk11.green("Generate Configs [ESM]"));
+  return workspaces.map(({ location, name }) => {
+    try {
+      const configObject = createBuildConfig(location, "ESNext", "ESNext", "esm");
+      if (configObject) {
+        const config = JSON.stringify(configObject, null, 2);
+        let currentConfig;
+        try {
+          currentConfig = readFileSync4(`${location}/.tsconfig.build.esm.json`, { encoding: "utf8" });
+        } catch (ex) {
+          currentConfig = void 0;
+        }
+        if (currentConfig !== config) {
+          console.log(chalk11.gray(`Updating ESM tsconfig [${name}]`));
+          writeFileSync3(`${location}/.tsconfig.build.esm.json`, config, { encoding: "utf8" });
+        }
+      }
+      return 0;
+    } catch (ex) {
+      const error = ex;
+      console.error(`tsconfig (ESM) generate failed [${name}] [${error.message}]`);
+      return 1;
+    }
+  }).reduce((prev, value) => prev || value, 0);
+};
+
+// src/actions/tsconfig-gen-test.ts
+import chalk12 from "chalk";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
+var tsconfigName = ".tsconfig.build.test.json";
+var tsconfig = JSON.stringify(
+  {
+    extends: "./tsconfig.json",
+    include: ["src/**/*.spec.ts"]
+  },
+  null,
+  2
+);
+var tsconfigGenTest = (pkg) => {
+  const workspaces = pkg ? [yarnWorkspace(pkg)] : yarnWorkspaces();
+  console.log(chalk12.green("Generate Configs [Test]"));
+  return workspaces.map(({ location, name }) => {
+    try {
+      let currentConfig;
+      try {
+        currentConfig = readFileSync5(`${location}/${tsconfigName}`, { encoding: "utf8" });
+      } catch (ex) {
+        currentConfig = void 0;
+      }
+      if (currentConfig !== tsconfig) {
+        console.log(chalk12.gray(`Updating TEST tsconfig [${name}]`));
+        writeFileSync4(`${location}/${tsconfigName}`, tsconfig, { encoding: "utf8" });
+      }
+      return 0;
+    } catch (ex) {
+      const error = ex;
+      console.error(`tsconfig (TEST) generate failed [${name}] [${error.message}]`);
+      return 1;
+    }
+  }).reduce((prev, value) => prev || value, 0);
+};
+
+// src/actions/tsconfig-gen.ts
+var tsconfigGen = ({ target, pkg }) => {
+  switch (target) {
+    case "esm":
+      return tsconfigGenEsm(pkg) || tsconfigGenTest(pkg);
+    case "cjs":
+      return tsconfigGenCjs(pkg) || tsconfigGenTest(pkg);
+    default:
+      return tsconfigGenEsm(pkg) || tsconfigGenCjs(pkg) || tsconfigGenTest(pkg);
+  }
+};
+
+// src/actions/tsconfig-gen-clean.ts
+import chalk13 from "chalk";
+import { rmSync } from "fs";
+var tsconfigGenClean = (pkg) => {
+  const workspaces = pkg ? [yarnWorkspace(pkg)] : yarnWorkspaces();
+  console.log(chalk13.green("Clean TSConfigs"));
+  return workspaces.map(({ location, name }) => {
+    const dist = `${location}/**/.tsconfig*`;
+    try {
+      rmSync(dist, { force: true, recursive: true });
+      return 0;
+    } catch (ex) {
+      const error = ex;
+      console.error(`Clean Failed [${name}, ${error.message}]`);
+      return 1;
+    }
+  }).reduce((prev, result) => prev || result, 0);
+};
+
+// src/actions/upplug.ts
+var updateYarnPlugins = () => {
+  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"]]
+  ]);
+};
+
+// src/actions/upyarn.ts
+var updateYarnVersion = () => {
+  return runSteps("Update Yarn Version", [["yarn", ["set", "version", "latest"]]]);
+};
+
+// src/actions/yarn3only.ts
+var yarn3Only = () => {
+  const [valid, version] = isYarnVersionOrGreater(3);
+  if (!valid) {
+    processEx(`Invalid Yarn version [${version}]`);
+  }
+  return 0;
+};
+
+// src/lib/xy/xyCommonCommands.ts
+var xyCommonCommands = (args) => {
   return args.command(
     "license [package]",
     "License - Check licenses of dependencies",
-    (yargs2) => {
-      return yargs2.positional("package", {
+    (yargs) => {
+      return yargs.positional("package", {
         describe: "Specific package to check"
       });
     },
@@ -33,8 +609,8 @@ const xyCommonCommands = (args) => {
   ).command(
     "dead [package]",
     "Dead - Check for dead code",
-    (yargs2) => {
-      return yargs2.positional("package", {
+    (yargs) => {
+      return yargs.positional("package", {
         describe: "Specific package to check"
       });
     },
@@ -46,8 +622,8 @@ const xyCommonCommands = (args) => {
   ).command(
     "deps [package]",
     "Deps - Check for unused or missing dependencies",
-    (yargs2) => {
-      return yargs2.positional("package", {
+    (yargs) => {
+      return yargs.positional("package", {
         describe: "Specific package to check"
       });
     },
@@ -59,8 +635,8 @@ const xyCommonCommands = (args) => {
   ).command(
     "gen-docs [package]",
     "GenDocs - Generate TypeDocs",
-    (yargs2) => {
-      return yargs2.positional("package", {
+    (yargs) => {
+      return yargs.positional("package", {
         describe: "Specific package to generate docs for"
       });
     },
@@ -72,7 +648,7 @@ const xyCommonCommands = (args) => {
   ).command(
     "clean-docs",
     "CleanDocs - Clean TypeDocs",
-    (yargs2) => yargs2,
+    (yargs) => yargs,
     (argv) => {
       if (argv.verbose)
         console.log("Cleaning TypeDocs: all");
@@ -81,8 +657,8 @@ const xyCommonCommands = (args) => {
   ).command(
     "gitlint [package]",
     "Gitlint - Lint your git config",
-    (yargs2) => {
-      return yargs2;
+    (yargs) => {
+      return yargs;
     },
     (argv) => {
       if (argv.verbose)
@@ -92,8 +668,8 @@ const xyCommonCommands = (args) => {
   ).command(
     "gitignore-gen",
     "GitIgnore Gen - Generate .gitignore files",
-    (yargs2) => {
-      return yargs2;
+    (yargs) => {
+      return yargs;
     },
     (argv) => {
       if (argv.verbose)
@@ -103,8 +679,8 @@ const xyCommonCommands = (args) => {
   ).command(
     "npmignore-gen",
     "NpmIgnore Gen - Generate .npmignore files",
-    (yargs2) => {
-      return yargs2;
+    (yargs) => {
+      return yargs;
     },
     (argv) => {
       if (argv.verbose)
@@ -114,8 +690,8 @@ const xyCommonCommands = (args) => {
   ).command(
     "retest",
     "Re-Test - Run Jest Tests with cleaned cache",
-    (yargs2) => {
-      return yargs2;
+    (yargs) => {
+      return yargs;
     },
     (argv) => {
       if (argv.verbose)
@@ -125,8 +701,8 @@ const xyCommonCommands = (args) => {
   ).command(
     "test",
     "Test - Run Jest Tests",
-    (yargs2) => {
-      return yargs2;
+    (yargs) => {
+      return yargs;
     },
     (argv) => {
       if (argv.verbose)
@@ -136,8 +712,8 @@ const xyCommonCommands = (args) => {
   ).command(
     "tsconfig-gen [package]",
     "Tsconfig Gen - Generate tsconfig.json file for building",
-    (yargs2) => {
-      return yargs2.positional("package", {
+    (yargs) => {
+      return yargs.positional("package", {
         describe: "Specific package for generation"
       });
     },
@@ -149,8 +725,8 @@ const xyCommonCommands = (args) => {
   ).command(
     "tsconfig-clean",
     "Tsconfig Clean - Remove generated tsconfig.json files",
-    (yargs2) => {
-      return yargs2;
+    (yargs) => {
+      return yargs;
     },
     (argv) => {
       if (argv.verbose)
@@ -160,8 +736,8 @@ const xyCommonCommands = (args) => {
   ).command(
     "upplug",
     "UpPlug - Update Yarn Plugins",
-    (yargs2) => {
-      return yargs2;
+    (yargs) => {
+      return yargs;
     },
     (argv) => {
       if (argv.verbose)
@@ -171,8 +747,8 @@ const xyCommonCommands = (args) => {
   ).command(
     "upyarn",
     "UpYarn - Update Yarn Version",
-    (yargs2) => {
-      return yargs2;
+    (yargs) => {
+      return yargs;
     },
     (argv) => {
       if (argv.verbose)
@@ -182,8 +758,8 @@ const xyCommonCommands = (args) => {
   ).command(
     "yarn3only",
     "Yarn3Only - Check if using Yarn v3",
-    (yargs2) => {
-      return yargs2;
+    (yargs) => {
+      return yargs;
     },
     (argv) => {
       if (argv.verbose)