@xylabs/ts-scripts-yarn3 2.19.10 → 2.19.12

package/dist/lib/xy/xy.js

@@ -26,23 +26,1666 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/xy/xy.ts
 var xy_exports = {};
 __export(xy_exports, {
   xy: () => xy
 });
 module.exports = __toCommonJS(xy_exports);
+var import_chalk25 = __toESM(require("chalk"));
+
+// src/actions/build.ts
+var import_chalk8 = __toESM(require("chalk"));
+
+// src/lib/checkResult.ts
 var import_chalk = __toESM(require("chalk"));
-var import_xyBuildCommands = require("./xyBuildCommands");
-var import_xyCommonCommands = require("./xyCommonCommands");
-var import_xyDeployCommands = require("./xyDeployCommands");
-var import_xyInstallCommands = require("./xyInstallCommands");
-var import_xyLintCommands = require("./xyLintCommands");
-var import_xyParseOptions = require("./xyParseOptions");
-const xy = () => {
-  const options = (0, import_xyParseOptions.xyParseOptions)();
-  return (0, import_xyBuildCommands.xyBuildCommands)((0, import_xyCommonCommands.xyCommonCommands)((0, import_xyInstallCommands.xyInstallCommands)((0, import_xyDeployCommands.xyDeployCommands)((0, import_xyLintCommands.xyLintCommands)(options))))).demandCommand(1).command("*", "", () => {
-    console.error(import_chalk.default.yellow(`Command not found [${import_chalk.default.magenta(process.argv[2])}]`));
-    console.log(import_chalk.default.gray("Try 'yarn xy --help' for list of commands"));
+var checkResult = (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);
+    }
+  }
+};
+
+// src/lib/createBuildConfig.ts
+var import_fs = require("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 = (0, import_fs.readFileSync)(`${location}/tsconfig.json`, { encoding: "utf8" });
+  } catch (ex) {
+    return false;
+  }
+  return JSON.parse(generalConfig);
+};
+var createBuildConfig = (location, module2, target, outDirSuffix) => {
+  const generalConfigObject = getGeneralTypescriptConfig(location);
+  if (generalConfigObject === false) {
+    return void 0;
+  }
+  return {
+    ...generalConfigObject,
+    compilerOptions: {
+      ...defaultBuildConfig.compilerOptions,
+      ...generalConfigObject.compilerOptions ?? {},
+      module: module2,
+      outDir: `./${generalConfigObject.compilerOptions?.outDir ?? "dist"}/${outDirSuffix}`,
+      target
+    },
+    exclude: [...generalConfigObject.exclude ?? [], ...defaultBuildConfig.exclude],
+    include: [...generalConfigObject.include ?? [], ...defaultBuildConfig.include]
+  };
+};
+
+// src/lib/dependencies/detectDuplicateDependencies.ts
+var import_child_process = require("child_process");
+
+// src/lib/processEx.ts
+var import_chalk2 = __toESM(require("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(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);
+};
+
+// 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);
+  }
+};
+var safeExitAsync = async (func, exitOnFail = true) => {
+  try {
+    const result = await func();
+    if (result && exitOnFail) {
+      process.exit(result);
+    }
+    return result;
+  } catch (ex) {
+    return processEx(ex);
+  }
+};
+
+// src/lib/dependencies/DuplicateDetector.ts
+var import_chalk3 = __toESM(require("chalk"));
+var import_uniq = __toESM(require("lodash/uniq"));
+var import_os = require("os");
+
+// src/lib/jsonFormatters.ts
+var multiLineToJSONArray = (output) => {
+  const withCommas = output.replace(/\r\n/g, "").replace(/\n/g, ",");
+  const cleanCollection = withCommas.substring(0, withCommas.length - 1);
+  const collection = `[${cleanCollection}]`;
+  return JSON.parse(collection);
+};
+
+// src/lib/dependencies/DuplicateDetector.ts
+var trimVirtualMeta = (value) => {
+  const virtualParts = value.split("virtual:");
+  if (virtualParts.length > 1) {
+    const hashParts = virtualParts[1].split("#");
+    return virtualParts[0] + hashParts[1];
+  } else {
+    return value;
+  }
+};
+var trimObjectDependencyVirtualMeta = (obj) => {
+  const resultObj = {};
+  Object.entries(obj).forEach(([key, value]) => {
+    resultObj[trimVirtualMeta(key)] = {
+      descriptor: trimVirtualMeta(value.descriptor),
+      locator: trimVirtualMeta(value.locator)
+    };
+  });
+  return resultObj;
+};
+var trimDependencyVirtualMeta = (dependencies) => {
+  return dependencies.map((dependency) => {
+    return { children: trimObjectDependencyVirtualMeta(dependency.children), value: trimVirtualMeta(dependency.value) };
+  });
+};
+var DuplicateDetector = class {
+  dependency;
+  dependencyEntries;
+  constructor(output, dependency) {
+    this.dependency = dependency;
+    this.dependencyEntries = trimDependencyVirtualMeta(multiLineToJSONArray(output));
+  }
+  detect() {
+    const result = this.dependencyEntries.reduce(this.detectReducer, this.resultsFactory(this.dependency));
+    if (result.duplicateVersions.length) {
+      console.log(import_chalk3.default.yellow(`${import_os.EOL}Duplicates found for: ${this.dependency}`));
+      console.log(import_chalk3.default.grey(`  ${result.duplicateVersions.toString().replaceAll(",", `${import_os.EOL}  `)}`, import_os.EOL));
+      return 1;
+    } else {
+      console.log(`${this.dependency} - OK`);
+      return 0;
+    }
+  }
+  detectReducer(acc, entry) {
+    const version = Object.entries(entry.children).map(([k]) => k)[0];
+    if (!acc.currentVersion) {
+      acc.currentVersion = version;
+      return acc;
+    }
+    if (acc.currentVersion && acc.currentVersion !== version && !version.includes("@virtual:")) {
+      if (acc.duplicateVersions.length === 0) {
+        acc.duplicateVersions.push(acc.currentVersion);
+      }
+      acc.duplicateVersions.push(version);
+      acc.duplicateVersions = (0, import_uniq.default)(acc.duplicateVersions);
+    }
+    return acc;
+  }
+  resultsFactory = (dependency) => ({ currentVersion: void 0, dependency, duplicateVersions: [] });
+};
+
+// src/lib/dependencies/detectDuplicateDependencies.ts
+var detectDuplicateDependencies = (depsFromPackageJSON, DefaultDependencies2) => {
+  let exitCode = 0;
+  const dependencies = depsFromPackageJSON?.length ? depsFromPackageJSON : DefaultDependencies2;
+  return safeExit(() => {
+    if (dependencies) {
+      dependencies.forEach((dependency) => {
+        let output;
+        try {
+          const cmd = `yarn why ${dependency} --json`;
+          output = (0, import_child_process.execSync)(cmd).toString();
+        } catch (e) {
+          console.error(`Error running yarn why: ${e}`);
+          exitCode = 1;
+          return exitCode;
+        }
+        if (output) {
+          exitCode = new DuplicateDetector(output, dependency).detect();
+          return exitCode;
+        } else {
+          console.log(`${dependency} - N/A`);
+          if (depsFromPackageJSON) {
+            exitCode = 1;
+            console.log(`\u{1F6A8} Library ${dependency} was requested in package.json but not found`);
+          }
+          return exitCode;
+        }
+      });
+      return exitCode;
+    } else {
+      console.log("\u{1F6A8} No dependencies where passed");
+      return exitCode;
+    }
+  });
+};
+
+// 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 = (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) => (0, import_node_fs.existsSync)(uri) ? (0, import_node_fs.readFileSync)(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 = (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);
+};
+
+// src/lib/generateIgnoreFiles.ts
+var import_chalk4 = __toESM(require("chalk"));
+
+// src/lib/yarn/isYarnVersionOrGreater.ts
+var import_child_process2 = require("child_process");
+var isYarnVersionOrGreater = (major, minor, patch) => {
+  const result = (0, import_child_process2.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
+var import_child_process3 = require("child_process");
+var yarnWorkspaces = () => {
+  const result = (0, import_child_process3.spawnSync)("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(import_chalk4.default.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/parsedPackageJSON.ts
+var import_fs2 = require("fs");
+var parsedPackageJSON = (path4) => {
+  const pathToPackageJSON = path4 ?? process.env.npm_package_json ?? "";
+  const packageJSON = (0, import_fs2.readFileSync)(pathToPackageJSON).toString();
+  return JSON.parse(packageJSON);
+};
+
+// src/lib/runSteps.ts
+var import_chalk5 = __toESM(require("chalk"));
+var import_child_process4 = require("child_process");
+var import_fs3 = require("fs");
+var runSteps = (name, steps, exitOnFail = true, messages) => {
+  return safeExit(() => {
+    const pkgName = process.env.npm_package_name;
+    console.log(import_chalk5.default.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(import_chalk5.default.gray(messages?.[i]));
+      }
+      const argList = Array.isArray(args) ? args : args.split(" ");
+      if (command === "node" && !(0, import_fs3.existsSync)(argList[0])) {
+        throw Error(`File not found [${argList[0]}]`);
+      }
+      const status = (0, import_child_process4.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);
+};
+
+// src/lib/runStepsAsync.ts
+var import_chalk6 = __toESM(require("chalk"));
+var import_child_process5 = require("child_process");
+var import_fs4 = require("fs");
+var runStepAsync = (name, step, exitOnFail = true, message) => {
+  return new Promise((resolve) => {
+    const [command, args, config] = step;
+    if (message) {
+      console.log(import_chalk6.default.gray(message));
+    }
+    const argList = Array.isArray(args) ? args : args.split(" ");
+    if (command === "node" && !(0, import_fs4.existsSync)(argList[0])) {
+      throw Error(`File not found [${argList[0]}]`);
+    }
+    (0, import_child_process5.spawn)(command, Array.isArray(args) ? args : args.split(" "), {
+      ...config,
+      env: { FORCE_COLOR: "3", ...process.env },
+      shell: true,
+      stdio: "inherit"
+    }).on("close", (code) => {
+      if (code) {
+        console.error(
+          import_chalk6.default.red(
+            `Command Exited With Non-Zero Result [${import_chalk6.default.gray(code)}] | ${import_chalk6.default.yellow(command)} ${import_chalk6.default.white(
+              Array.isArray(args) ? args.join(" ") : args
+            )}`
+          )
+        );
+        checkResult(name, code, "error", exitOnFail);
+        resolve(code);
+      } else {
+        resolve(0);
+      }
+    });
+  });
+};
+var runStepsAsync = async (name, steps, exitOnFail = true, messages) => {
+  return await safeExitAsync(async () => {
+    const pkgName = process.env.npm_package_name;
+    console.log(import_chalk6.default.green(`${name} [${pkgName}]`));
+    let result = 0;
+    for (let i = 0; i < steps.length; i++) {
+      result += await runStepAsync(name, steps[i], exitOnFail, messages?.[i]);
+    }
+    return result;
+  });
+};
+
+// src/lib/xy/xyCommonCommands.ts
+var xyCommonCommands = (args) => {
+  return args.command(
+    "license [package]",
+    "License - Check licenses of dependencies",
+    (yargs2) => {
+      return yargs2.positional("package", {
+        describe: "Specific package to check"
+      });
+    },
+    async (argv) => {
+      if (argv.verbose)
+        console.log(`License: ${argv.package ?? "all"}`);
+      process.exitCode = await license();
+    }
+  ).command(
+    "dead [package]",
+    "Dead - Check for dead code",
+    (yargs2) => {
+      return yargs2.positional("package", {
+        describe: "Specific package to check"
+      });
+    },
+    (argv) => {
+      if (argv.verbose)
+        console.log("Dead");
+      process.exitCode = dead();
+    }
+  ).command(
+    "deps [package]",
+    "Deps - Check for unused or missing dependencies",
+    (yargs2) => {
+      return yargs2.positional("package", {
+        describe: "Specific package to check"
+      });
+    },
+    (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",
+    (yargs2) => {
+      return yargs2.positional("package", {
+        describe: "Specific package to generate docs for"
+      });
+    },
+    (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",
+    (yargs2) => yargs2,
+    (argv) => {
+      if (argv.verbose)
+        console.log("Cleaning TypeDocs: all");
+      process.exitCode = cleanDocs();
+    }
+  ).command(
+    "gitlint [package]",
+    "Gitlint - Lint your git config",
+    (yargs2) => {
+      return yargs2;
+    },
+    (argv) => {
+      if (argv.verbose)
+        console.log("Gitlint");
+      process.exitCode = argv.fix ? gitlintFix() : gitlint();
+    }
+  ).command(
+    "gitignore-gen",
+    "GitIgnore Gen - Generate .gitignore files",
+    (yargs2) => {
+      return yargs2;
+    },
+    (argv) => {
+      if (argv.verbose)
+        console.log("GitIgnore Gen");
+      process.exitCode = gitignoreGen();
+    }
+  ).command(
+    "npmignore-gen",
+    "NpmIgnore Gen - Generate .npmignore files",
+    (yargs2) => {
+      return yargs2;
+    },
+    (argv) => {
+      if (argv.verbose)
+        console.log("NpmIgnore Gen");
+      process.exitCode = npmignoreGen();
+    }
+  ).command(
+    "retest",
+    "Re-Test - Run Jest Tests with cleaned cache",
+    (yargs2) => {
+      return yargs2;
+    },
+    (argv) => {
+      if (argv.verbose)
+        console.log("Re-Testing");
+      process.exitCode = retest();
+    }
+  ).command(
+    "test",
+    "Test - Run Jest Tests",
+    (yargs2) => {
+      return yargs2;
+    },
+    (argv) => {
+      if (argv.verbose)
+        console.log("Testing");
+      process.exitCode = test();
+    }
+  ).command(
+    "tsconfig-gen [package]",
+    "Tsconfig Gen - Generate tsconfig.json file for building",
+    (yargs2) => {
+      return yargs2.positional("package", {
+        describe: "Specific package for generation"
+      });
+    },
+    (argv) => {
+      if (argv.verbose)
+        console.log(`TsconfigGen: ${argv.package ?? "all"}`);
+      process.exitCode = tsconfigGen({ pkg: argv.package, target: argv.target });
+    }
+  ).command(
+    "tsconfig-clean",
+    "Tsconfig Clean - Remove generated tsconfig.json files",
+    (yargs2) => {
+      return yargs2;
+    },
+    (argv) => {
+      if (argv.verbose)
+        console.log("Tsconfig Clean");
+      process.exitCode = tsconfigGenClean();
+    }
+  ).command(
+    "upplug",
+    "UpPlug - Update Yarn Plugins",
+    (yargs2) => {
+      return yargs2;
+    },
+    (argv) => {
+      if (argv.verbose)
+        console.log("UpPlug");
+      process.exitCode = updateYarnPlugins();
+    }
+  ).command(
+    "upyarn",
+    "UpYarn - Update Yarn Version",
+    (yargs2) => {
+      return yargs2;
+    },
+    (argv) => {
+      if (argv.verbose)
+        console.log("UpYarn");
+      process.exitCode = updateYarnVersion();
+    }
+  ).command(
+    "yarn3only",
+    "Yarn3Only - Check if using Yarn v3",
+    (yargs2) => {
+      return yargs2;
+    },
+    (argv) => {
+      if (argv.verbose)
+        console.log("Yarn 3 Check");
+      process.exitCode = yarn3Only();
+    }
+  );
+};
+
+// src/lib/xy/xyDeployCommands.ts
+var xyDeployCommands = (args) => {
+  return args.command(
+    "deploy",
+    "Deploy - Deploy patch",
+    (yargs2) => {
+      return yargs2;
+    },
+    (argv) => {
+      if (argv.verbose)
+        console.log("Deploy patch");
+      process.exitCode = deploy();
+    }
+  ).command(
+    "deploy-minor",
+    "Deploy - Deploy minor",
+    (yargs2) => {
+      return yargs2;
+    },
+    (argv) => {
+      if (argv.verbose)
+        console.log("Deploy minor");
+      process.exitCode = deployMinor();
+    }
+  ).command(
+    "deploy-major",
+    "Deploy - Deploy major",
+    (yargs2) => {
+      return yargs2;
+    },
+    (argv) => {
+      if (argv.verbose)
+        console.log("Deploy major");
+      process.exitCode = deployMajor();
+    }
+  ).command(
+    "deploy-next",
+    "Deploy - Deploy next",
+    (yargs2) => {
+      return yargs2;
+    },
+    (argv) => {
+      if (argv.verbose)
+        console.log("Deploy next");
+      process.exitCode = deployNext();
+    }
+  );
+};
+
+// src/lib/xy/xyInstallCommands.ts
+var xyInstallCommands = (args) => {
+  return args.command(
+    "clean [package]",
+    "Clean",
+    (yargs2) => {
+      return yargs2.positional("package", {
+        describe: "Specific package to clean"
+      });
+    },
+    async (argv) => {
+      if (argv.verbose) {
+        console.log(`Cleaning: ${argv.package ?? "all"}`);
+      }
+      process.exitCode = await clean({
+        pkg: argv.package,
+        verbose: !!argv.verbose
+      });
+    }
+  ).command(
+    "reinstall",
+    "Reinstall - Clean & Install",
+    (yargs2) => {
+      return yargs2;
+    },
+    (argv) => {
+      if (argv.verbose)
+        console.log("Reinstalling");
+      process.exitCode = reinstall();
+    }
+  ).command(
+    "up",
+    "Up - Update dependencies",
+    (yargs2) => {
+      return yargs2;
+    },
+    (argv) => {
+      if (argv.verbose)
+        console.log("Up");
+      process.exitCode = up();
+    }
+  ).command(
+    "updo",
+    "Updo - Update dependencies [Interactive]",
+    (yargs2) => {
+      return yargs2;
+    },
+    (argv) => {
+      if (argv.verbose)
+        console.log("Updo");
+      process.exitCode = updo();
+    }
+  ).command(
+    "statics",
+    "Statics - Confirming Static Packages",
+    (yargs2) => {
+      return yargs2;
+    },
+    (argv) => {
+      if (argv.verbose)
+        console.log("Statics");
+      process.exitCode = statics();
+    }
+  ).command(
+    "dupdeps",
+    "Dupdeps - Duplicate Dependencies in package.json",
+    (yargs2) => {
+      return yargs2;
+    },
+    (argv) => {
+      if (argv.verbose)
+        console.log("Dupdeps");
+      process.exitCode = dupdeps();
+    }
+  );
+};
+
+// src/lib/xy/xyLintCommands.ts
+var import_chalk7 = __toESM(require("chalk"));
+var xyLintCommands = (args) => {
+  return args.command(
+    "cycle [package]",
+    "Cycle - Check for dependency cycles",
+    (yargs2) => {
+      return yargs2.positional("package", {
+        describe: "Specific package to check"
+      });
+    },
+    (argv) => {
+      const start = Date.now();
+      if (argv.verbose)
+        console.log("Cycle");
+      process.exitCode = cycle();
+      console.log(import_chalk7.default.blue(`Finished in ${Date.now() - start}ms`));
+    }
+  ).command(
+    "lint [package]",
+    "Lint - Run Eslint",
+    (yargs2) => {
+      return yargs2.positional("package", {
+        describe: "Specific package to check"
+      });
+    },
+    async (argv) => {
+      if (argv.verbose)
+        console.log("Lint");
+      const start = Date.now();
+      process.exitCode = argv.fix ? fix() : argv.profile ? lintProfile() : await lint({ pkg: argv.package });
+      console.log(import_chalk7.default.blue(`Finished in ${Date.now() - start}ms`));
+    }
+  ).command(
+    "fix [package]",
+    "Fix - Run Eslint w/fix",
+    (yargs2) => {
+      return yargs2.positional("package", {
+        describe: "Specific package to check"
+      });
+    },
+    (argv) => {
+      const start = Date.now();
+      if (argv.verbose)
+        console.log("Fix");
+      process.exitCode = fix();
+      console.log(import_chalk7.default.blue(`Finished in ${Date.now() - start}ms`));
+    }
+  ).command(
+    "relint [package]",
+    "Relint - Clean & Lint",
+    (yargs2) => {
+      return yargs2.positional("package", {
+        describe: "Specific package to relint"
+      });
+    },
+    (argv) => {
+      if (argv.verbose)
+        console.log("Relinting");
+      const start = Date.now();
+      process.exitCode = relint();
+      console.log(import_chalk7.default.blue(`Finished in ${Date.now() - start}ms`));
+    }
+  ).command(
+    "publint [package]",
+    "Publint - Run Publint",
+    (yargs2) => {
+      return yargs2.positional("package", {
+        describe: "Specific package to publint"
+      });
+    },
+    async (argv) => {
+      if (argv.verbose)
+        console.log("Publint");
+      const start = Date.now();
+      process.exitCode = await publint({ pkg: argv.package, verbose: !!argv.verbose });
+      console.log(import_chalk7.default.blue(`Finished in ${Date.now() - start}ms`));
+    }
+  ).command(
+    "sonar",
+    "Sonar - Run Sonar Check",
+    (yargs2) => {
+      return yargs2;
+    },
+    (argv) => {
+      const start = Date.now();
+      if (argv.verbose)
+        console.log("Sonar Check");
+      process.exitCode = sonar();
+      console.log(import_chalk7.default.blue(`Finished in ${Date.now() - start}ms`));
+    }
+  );
+};
+
+// src/lib/xy/xyParseOptions.ts
+var import_yargs = __toESM(require("yargs"));
+var import_helpers = require("yargs/helpers");
+var xyParseOptions = () => {
+  return (0, import_yargs.default)((0, import_helpers.hideBin)(process.argv)).scriptName("yarn xy").option("jobs", {
+    alias: "j",
+    default: void 0,
+    description: "Max parallel jobs",
+    type: "number"
+  }).option("verbose", {
+    alias: "v",
+    default: false,
+    description: "Run with verbose logging",
+    type: "boolean"
+  }).option("target", {
+    alias: "t",
+    choices: ["esm", "cjs"],
+    description: "Limit output to specific target",
+    type: "string"
+  }).option("incremental", {
+    alias: "i",
+    default: false,
+    description: "Attempt to perform the action only on changed packages",
+    type: "boolean"
+  }).option("fix", {
+    alias: "f",
+    default: false,
+    description: "Try to fix errors",
+    type: "boolean"
+  }).option("cache", {
+    alias: "c",
+    default: false,
+    description: "Use caching for performance",
+    type: "boolean"
+  }).option("profile", {
+    alias: "p",
+    default: false,
+    description: "Profile action",
+    type: "boolean"
+  });
+};
+
+// src/actions/build.ts
+var build = async ({ incremental, jobs, target, verbose, pkg }) => {
+  const start = Date.now();
+  const pkgOptions = pkg ? [pkg] : [];
+  const incrementalOptions = incremental ? ["-i"] : [];
+  const verboseOptions = verbose ? ["-v"] : [];
+  const targetOptions = target ? ["-t", target] : [];
+  const jobsOptions = jobs ? ["-j", `${jobs}`] : [];
+  if (jobs) {
+    console.log(import_chalk8.default.blue(`Jobs set to [${jobs}]`));
+  }
+  const result = await runStepsAsync(`Build${incremental ? "-Incremental" : ""} [${pkg ?? "All"}]`, [
+    ["yarn", ["xy", "compile", ...pkgOptions, ...targetOptions, ...verboseOptions, ...jobsOptions, ...incrementalOptions]],
+    ["yarn", ["xy", "lint", ...pkgOptions, ...verboseOptions, ...incrementalOptions]],
+    ["yarn", ["xy", "deps", ...pkgOptions, ...verboseOptions, ...jobsOptions, ...incrementalOptions]]
+  ]);
+  console.log(`${import_chalk8.default.gray("Built in")} [${import_chalk8.default.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${import_chalk8.default.gray("seconds")}`);
+  return result;
+};
+
+// src/actions/clean-docs.ts
+var import_chalk9 = __toESM(require("chalk"));
+var import_path = __toESM(require("path"));
+var import_rimraf = require("rimraf");
+var cleanDocs = () => {
+  const pkgName = process.env.npm_package_name;
+  console.log(import_chalk9.default.green(`Cleaning Docs [${pkgName}]`));
+  yarnWorkspaces().map(({ location }) => (0, import_rimraf.rimrafSync)(import_path.default.join(location, "docs"), { glob: true }));
+  return 0;
+};
+
+// src/actions/clean-eslint.ts
+var import_chalk10 = __toESM(require("chalk"));
+var import_path2 = __toESM(require("path"));
+var import_rimraf2 = require("rimraf");
+var cleanESLint = () => {
+  const pkg = process.env.INIT_CWD ?? ".";
+  const pkgName = process.env.npm_package_name;
+  console.log(import_chalk10.default.green(`Cleaning ESLint [${pkgName}]`));
+  (0, import_rimraf2.rimrafSync)(import_path2.default.join(pkg, ".eslintcache"), { glob: true });
+  return 0;
+};
+
+// src/actions/clean-jest.ts
+var cleanJest = () => {
+  const pkgName = process.env.npm_package_name;
+  return runSteps(`Cleaning Jest [${pkgName}]`, [["jest", ["--clearCache"]]]);
+};
+
+// src/actions/clean.ts
+var clean = async ({ verbose, pkg }) => {
+  return pkg ? await cleanPackage({ pkg, verbose }) : cleanAll({ verbose });
+};
+var cleanPackage = ({ verbose, pkg }) => {
+  const verboseOptions = verbose ? ["-v"] : [];
+  return runStepsAsync(`Clean [${pkg}]`, [["yarn", ["workspace", pkg, "run", "package-clean", ...verboseOptions]]]);
+};
+var cleanAll = ({ verbose }) => {
+  const verboseOptions = verbose ? ["-v"] : [];
+  return cleanJest() + cleanESLint() + cleanDocs() + runSteps("Clean", [["yarn", ["workspaces foreach -pA run package-clean", ...verboseOptions]]]);
+};
+
+// src/actions/compile.ts
+var import_chalk11 = __toESM(require("chalk"));
+var compile = ({ verbose, target, pkg, incremental }) => {
+  return pkg ? compilePackage({ pkg, target, verbose }) : compileAll({ incremental, target, verbose });
+};
+var compilePackage = ({ verbose, target, pkg }) => {
+  const verboseOptions = verbose ? ["-v"] : [];
+  const targetOptions = target ? ["-t", target] : [];
+  return runSteps(`Compile [${pkg}]`, [["yarn", ["workspace", pkg, "run", "package-compile", ...verboseOptions, ...targetOptions]]]);
+};
+var compileAll = ({ jobs, verbose, target, incremental }) => {
+  const start = Date.now();
+  const verboseOptions = verbose ? ["-v"] : [];
+  const targetOptions = target ? ["-t", target] : [];
+  const incrementalOptions = incremental ? ["--since", "-ptA"] : ["-ptA"];
+  const jobsOptions = jobs ? ["-j", `${jobs}`] : [];
+  if (jobs) {
+    console.log(import_chalk11.default.blue(`Jobs set to [${jobs}]`));
+  }
+  const result = runSteps(`Compile${incremental ? "-Incremental" : ""} [All]`, [
+    ["yarn", ["workspaces", "foreach", ...incrementalOptions, ...jobsOptions, "run", "package-compile", ...verboseOptions, ...targetOptions]]
+  ]);
+  console.log(`${import_chalk11.default.gray("Compiled in")} [${import_chalk11.default.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${import_chalk11.default.gray("seconds")}`);
+  return result;
+};
+
+// src/actions/copy-assets.ts
+var import_chalk12 = __toESM(require("chalk"));
+var import_cpy = __toESM(require("cpy"));
+var import_posix = __toESM(require("path/posix"));
+var copyPackageTargetAssets = async (target, name, location) => {
+  try {
+    const values = await (0, import_cpy.default)(
+      ["**/*.jpg", "**/*.png", "**/*.gif", "**/*.svg", "**/*.webp", "**/*.sass", "**/*.scss", "**/*.gif", "**/*.css"],
+      `../dist/${target}`,
+      {
+        cwd: import_posix.default.join(process.cwd(), location, "src"),
+        parents: true
+      }
+    );
+    values.forEach((value) => {
+      console.log(`${value.split("/").pop()} => ./dist/${target}`);
+    });
+    return 0;
+  } catch (reason) {
+    console.log(`Copy Failed: ${name}: ${reason}`);
+    return 1;
+  }
+};
+var copyTargetAssets = async (target, pkg) => {
+  const workspaces = yarnWorkspaces();
+  console.log(import_chalk12.default.green(`Copying Assets [${target.toUpperCase()}]`));
+  const workspaceList = workspaces.filter(({ name }) => {
+    return pkg === void 0 || name === pkg;
+  });
+  if (workspaceList.length === 0) {
+    console.error(`Package not found [${pkg}]`);
+  } else {
+    const results = await Promise.all(
+      workspaceList.map(async (workspace) => {
+        const { location, name } = workspace;
+        return await copyPackageTargetAssets(target, name, location);
+      })
+    );
+    return results.reduce((prev, result) => prev || result, 0);
+  }
+  return 0;
+};
+var copyAssets = async ({ target, pkg }) => {
+  switch (target) {
+    case "esm":
+      return await copyTargetAssets("esm", pkg);
+    case "cjs":
+      return await copyTargetAssets("cjs", pkg);
+    default:
+      return await copyTargetAssets("esm", pkg) || await copyTargetAssets("cjs", pkg);
+  }
+};
+
+// src/actions/cycle.ts
+var cycle = () => {
+  const rules = [`"'import/no-cycle': [1, { maxDepth: 6 }]"`, `"'import/no-internal-modules': ['off']"`];
+  return runSteps("Cycle", [["yarn", ["eslint", ...rules.map((rule) => ["--rule", rule]).flat(), "--cache", "."]]]);
+};
+
+// src/actions/dead.ts
+var dead = () => {
+  return runSteps("Dead", [["yarn", ["ts-prune", "-p", "tsconfig.json"]]]);
+};
+
+// src/actions/deploy.ts
+var deploy = () => {
+  return runSteps("Deploy [Patch]", [
+    ["yarn", "workspaces foreach --all version patch --deferred"],
+    ["yarn", "xy clean"],
+    ["yarn", "xy build"],
+    ["yarn", "xy cycle"],
+    ["yarn", "xy gen-docs"],
+    ["yarn", "version apply --all"],
+    ["yarn", "workspaces foreach -pt npm publish"]
+  ]);
+};
+
+// src/actions/deploy-major.ts
+var deployMajor = () => {
+  return runSteps("Deploy [Major]", [
+    ["yarn", "workspaces foreach --all version major --deferred"],
+    ["yarn", "xy clean"],
+    ["yarn", "xy build"],
+    ["yarn", "xy cycle"],
+    ["yarn", "version apply --all"],
+    ["yarn", "workspaces foreach -pt npm publish"]
+  ]);
+};
+
+// src/actions/deploy-minor.ts
+var deployMinor = () => {
+  return runSteps("Deploy [Minor]", [
+    ["yarn", "workspaces foreach --all version minor --deferred"],
+    ["yarn", "xy clean"],
+    ["yarn", "xy build"],
+    ["yarn", "xy cycle"],
+    ["yarn", "version apply --all"],
+    ["yarn", "workspaces foreach -pt npm publish"]
+  ]);
+};
+
+// src/actions/deploy-next.ts
+var deployNext = () => {
+  return runSteps("Deploy [Next]", [
+    ["yarn", "workspaces foreach --all version minor --deferred"],
+    ["yarn", "xy clean"],
+    ["yarn", "xy build"],
+    ["yarn", "xy cycle"],
+    ["yarn", "version apply --all --prerelease"],
+    ["yarn", "workspaces foreach -pt npm publish --tag next"]
+  ]);
+};
+
+// src/actions/deps.ts
+var import_chalk13 = __toESM(require("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(import_chalk13.default.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(`${import_chalk13.default.gray("Dep checked in")} [${import_chalk13.default.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${import_chalk13.default.gray("seconds")}`);
+  return result;
+};
+
+// src/actions/dupdeps.ts
+var import_chalk14 = __toESM(require("chalk"));
+var dupdeps = () => {
+  console.log(import_chalk14.default.green("Checking all Dependencies for Duplicates"));
+  const allDependencies = parsedPackageJSON()?.dependencies;
+  const dependencies = Object.entries(allDependencies).map(([k]) => k);
+  return detectDuplicateDependencies(dependencies);
+};
+
+// src/actions/fix.ts
+var fix = () => {
+  return runSteps("Fix", [["yarn", ["eslint", ".", "--fix", "--cache"]]]);
+};
+
+// 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
+var import_chalk15 = __toESM(require("chalk"));
+var import_parse_git_config = require("parse-git-config");
+var gitlint = () => {
+  console.log(`
+Gitlint Start [${process.cwd()}]
+`);
+  let valid = 0;
+  let warnings = 0;
+  const errors = 0;
+  const gitConfig = (0, import_parse_git_config.sync)();
+  const warn = (message) => {
+    console.warn(import_chalk15.default.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(import_chalk15.default.green(`Passed: ${valid}`));
+  }
+  if (warnings > 0) {
+    resultMessages.push(import_chalk15.default.yellow(`Warnings: ${warnings}`));
+  }
+  if (errors > 0) {
+    resultMessages.push(import_chalk15.default.red(` Errors: ${errors}`));
+  }
+  console.warn(`Gitlint Finish [ ${resultMessages.join(" | ")} ]
+`);
+  return warnings + errors === 0 ? 1 : 0;
+};
+
+// src/actions/gitlint-fix.ts
+var import_chalk16 = __toESM(require("chalk"));
+var import_child_process6 = require("child_process");
+var import_parse_git_config2 = require("parse-git-config");
+var gitlintFix = () => {
+  console.log(`
+Gitlint Fix Start [${process.cwd()}]
+`);
+  const gitConfig = (0, import_parse_git_config2.sync)();
+  if (gitConfig.core.ignorecase) {
+    (0, import_child_process6.execSync)("git config core.ignorecase false", { stdio: "inherit" });
+    console.warn(import_chalk16.default.yellow("\nGitlint Fix: Updated core.ignorecase to be false\n"));
+  }
+  if (gitConfig.core.autocrlf !== false) {
+    (0, import_child_process6.execSync)("git config core.autocrlf false", { stdio: "inherit" });
+    console.warn(import_chalk16.default.yellow("\nGitlint Fix: Updated core.autocrlf to be false\n"));
+  }
+  if (gitConfig.core.eol !== "lf") {
+    (0, import_child_process6.execSync)("git config core.eol lf", { stdio: "inherit" });
+    console.warn(import_chalk16.default.yellow('\nGitlint Fix: Updated core.eol to be "lf"\n'));
+  }
+  return 1;
+};
+
+// src/actions/license.ts
+var import_chalk17 = __toESM(require("chalk"));
+var import_license_checker = require("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(import_chalk17.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_chalk17.default.red(`License Checker [${name}] Error`));
+            console.error(import_chalk17.default.gray(error));
+            console.log("\n");
+            resolve(1);
+          } else {
+            console.log(import_chalk17.default.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(import_chalk17.default.yellow(`${name2}: Package License not allowed [${license2}]`));
+                  }
+                }
+              });
+            });
+            console.log("\n");
+            resolve(count);
+          }
+        });
+      });
+    })
+  )).reduce((prev, value) => prev || value, 0);
+};
+
+// src/actions/lint.ts
+var import_chalk18 = __toESM(require("chalk"));
+var import_eslint = require("eslint");
+var lintPackage = async ({ pkg }) => {
+  const workspace = yarnWorkspaces().find((workspace2) => workspace2.name === pkg);
+  if (!workspace) {
+    console.error(import_chalk18.default.red(`Unable to locate package [${import_chalk18.default.magenta(pkg)}]`));
+    process.exit(1);
+  }
+  const engine = new import_eslint.ESLint({ cache: true });
+  const lintResults = await engine.lintFiles(workspace.location);
+  console.log(lintResults);
+  const errorCount = lintResults.reduce((prev, lintResult) => prev + lintResult.errorCount, 0);
+  return errorCount;
+};
+var lint = async ({ pkg } = {}) => {
+  return pkg ? await lintPackage({ pkg }) : runSteps("Lint-Caching [All]", [["yarn", ["eslint", ".", "--cache"]]]);
+};
+
+// src/actions/lint-profile.ts
+var lintProfile = () => {
+  return runSteps("Lint Profile", [["yarn", ["xy", "lint"], { env: { ...process.env, TIMING: "1" } }]]);
+};
+
+// src/actions/npmignore-gen.ts
+var filename2 = ".npmignore";
+var npmignoreGen = (pkg) => generateIgnoreFiles(filename2, pkg);
+
+// src/actions/publint.ts
+var publint = async ({ verbose, pkg }) => {
+  return pkg ? await publintPackage({ pkg, verbose }) : publintAll({ verbose });
+};
+var publintPackage = ({ verbose, pkg }) => {
+  const verboseOptions = verbose ? ["-v"] : [];
+  return runStepsAsync(`Publint [${pkg}]`, [["yarn", ["workspace", pkg, "run", "package-publint", ...verboseOptions]]]);
+};
+var publintAll = ({ verbose }) => {
+  const verboseOptions = verbose ? ["-v"] : [];
+  return runSteps("Publint", [["yarn", ["workspaces foreach -pA run package-publint", ...verboseOptions]]]);
+};
+
+// src/actions/rebuild.ts
+var rebuild = ({ target }) => {
+  return runSteps("Rebuild", [
+    ["yarn", "xy clean"],
+    ["yarn", target ? `xy build -t ${target}` : "xy build"]
+  ]);
+};
+
+// src/actions/recompile.ts
+var import_chalk19 = __toESM(require("chalk"));
+var recompile = async ({ verbose, target, pkg, incremental }) => {
+  return pkg ? await recompilePackage({ pkg, target, verbose }) : await recompileAll({ incremental, target, verbose });
+};
+var recompilePackage = ({ verbose, target, pkg }) => {
+  const verboseOptions = verbose ? ["-v"] : [];
+  const targetOptions = target ? ["-t", target] : [];
+  return runStepsAsync(`Recompile [${pkg}]`, [["yarn", ["workspace", pkg, "run", "package-recompile", ...verboseOptions, ...targetOptions]]]);
+};
+var recompileAll = async ({ jobs, verbose, target, incremental }) => {
+  const start = Date.now();
+  const verboseOptions = verbose ? ["-v"] : [];
+  const targetOptions = target ? ["-t", target] : [];
+  const incrementalOptions = incremental ? ["--since", "-ptA"] : ["-ptA"];
+  const jobsOptions = jobs ? ["-j", `${jobs}`] : [];
+  if (jobs) {
+    console.log(import_chalk19.default.blue(`Jobs set to [${jobs}]`));
+  }
+  const result = await runStepsAsync(`Recompile${incremental ? "-Incremental" : ""} [All]`, [
+    ["yarn", ["workspaces", "foreach", ...incrementalOptions, ...jobsOptions, "run", "package-recompile", ...verboseOptions, ...targetOptions]]
+  ]);
+  console.log(`${import_chalk19.default.gray("Recompiled in")} [${import_chalk19.default.magenta(((Date.now() - start) / 1e3).toFixed(2))}] ${import_chalk19.default.gray("seconds")}`);
+  return result;
+};
+
+// src/actions/reinstall.ts
+var import_fs5 = require("fs");
+var reinstall = () => {
+  console.log("Reinstall [Clear Lock File]");
+  (0, import_fs5.closeSync)((0, import_fs5.openSync)("./yarn.lock", "w"));
+  console.log("Reinstall [Clear Node Modules]");
+  const workspaces = yarnWorkspaces();
+  const result = workspaces.map(({ location, name }) => {
+    const dist = `${location}/node_modules`;
+    try {
+      (0, import_fs5.rmSync)(dist, { force: true, recursive: true });
+      return 0;
+    } catch (ex) {
+      const error = ex;
+      console.error(`Reinstall [Clear Node Modules] Failed [${name}, ${error.message}]`);
+      return 1;
+    }
+  }).reduce((prev, result2) => prev || result2, 0);
+  return result || runSteps("Reinstall", [["yarn", "install --network-timeout 10000"]]);
+};
+
+// src/actions/relint.ts
+var import_fs6 = require("fs");
+var relint = () => {
+  console.log("Relint - Cleaning [.eslintcache]");
+  const workspaces = yarnWorkspaces();
+  const result = workspaces.map(({ location, name }) => {
+    const dist = `${location}/.eslintcache`;
+    try {
+      (0, import_fs6.rmSync)(dist, { force: true, recursive: true });
+      return 0;
+    } catch (ex) {
+      const error = ex;
+      console.error(`Relint - Cleaning [.eslintcache] Failed [${name}, ${error.message}]`);
+      return 1;
+    }
+  }).reduce((prev, result2) => prev || result2, 0);
+  return result || runSteps("Relint", [["yarn", ["eslint", ".", "--cache"]]]);
+};
+
+// src/actions/retest.ts
+var retest = () => {
+  return runSteps("Test", [
+    ["yarn", ["jest", "--clearCache"]],
+    ["yarn", ["jest", "."]]
+  ]);
+};
+
+// src/actions/sonar.ts
+var sonar = () => {
+  return runSteps("Sonar", [["yarn", ["eslint", "-c", "sonar.eslintrc", "."]]]);
+};
+
+// src/actions/statics.ts
+var import_chalk20 = __toESM(require("chalk"));
+var DefaultDependencies = ["axios", "@xylabs/pixel", "react", "graphql", "react-router", "@mui/material", "@mui/styles", "@mui/system"];
+var statics = () => {
+  console.log(import_chalk20.default.green("Check Required Static Dependencies"));
+  const statics2 = parsedPackageJSON()?.xy?.deps?.statics;
+  return detectDuplicateDependencies(statics2, DefaultDependencies);
+};
+
+// src/actions/test.ts
+var test = () => {
+  return runSteps("Test", [["yarn", ["jest", "."]]]);
+};
+
+// src/actions/tsconfig-gen-cjs.ts
+var import_chalk21 = __toESM(require("chalk"));
+var import_fs7 = require("fs");
+var tsconfigGenCjs = (pkg) => {
+  const workspaces = pkg ? [yarnWorkspace(pkg)] : yarnWorkspaces();
+  console.log(import_chalk21.default.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 = (0, import_fs7.readFileSync)(`${location}/.tsconfig.build.cjs.json`, { encoding: "utf8" });
+        } catch (ex) {
+          currentConfig = void 0;
+        }
+        if (currentConfig !== config) {
+          console.log(import_chalk21.default.gray(`Updating CJS tsconfig [${name}]`));
+          (0, import_fs7.writeFileSync)(`${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
+var import_chalk22 = __toESM(require("chalk"));
+var import_fs8 = require("fs");
+var tsconfigGenEsm = (pkg) => {
+  const workspaces = pkg ? [yarnWorkspace(pkg)] : yarnWorkspaces();
+  console.log(import_chalk22.default.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 = (0, import_fs8.readFileSync)(`${location}/.tsconfig.build.esm.json`, { encoding: "utf8" });
+        } catch (ex) {
+          currentConfig = void 0;
+        }
+        if (currentConfig !== config) {
+          console.log(import_chalk22.default.gray(`Updating ESM tsconfig [${name}]`));
+          (0, import_fs8.writeFileSync)(`${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
+var import_chalk23 = __toESM(require("chalk"));
+var import_fs9 = require("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(import_chalk23.default.green("Generate Configs [Test]"));
+  return workspaces.map(({ location, name }) => {
+    try {
+      let currentConfig;
+      try {
+        currentConfig = (0, import_fs9.readFileSync)(`${location}/${tsconfigName}`, { encoding: "utf8" });
+      } catch (ex) {
+        currentConfig = void 0;
+      }
+      if (currentConfig !== tsconfig) {
+        console.log(import_chalk23.default.gray(`Updating TEST tsconfig [${name}]`));
+        (0, import_fs9.writeFileSync)(`${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
+var import_chalk24 = __toESM(require("chalk"));
+var import_fs10 = require("fs");
+var tsconfigGenClean = (pkg) => {
+  const workspaces = pkg ? [yarnWorkspace(pkg)] : yarnWorkspaces();
+  console.log(import_chalk24.default.green("Clean TSConfigs"));
+  return workspaces.map(({ location, name }) => {
+    const dist = `${location}/**/.tsconfig*`;
+    try {
+      (0, import_fs10.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/up.ts
+var up = () => {
+  return runSteps("Up", [["yarn", "outdated"]]);
+};
+
+// src/actions/updo.ts
+var updo = () => {
+  return runSteps("Updo", [
+    ["yarn", "install"],
+    ["yarn", "upgrade-interactive"],
+    ["yarn", "dedupe"]
+  ]);
+};
+
+// 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/xyBuildCommands.ts
+var xyBuildCommands = (args) => {
+  return args.command(
+    "build [package]",
+    "Build - Compile & Lint",
+    (yargs2) => {
+      return yargs2.positional("package", {
+        describe: "Specific package to build"
+      });
+    },
+    async (argv) => {
+      if (argv.verbose) {
+        console.log(`Building: ${argv.package ?? "all"}`);
+      }
+      process.exitCode = await build({
+        incremental: !!argv.incremental,
+        jobs: argv.jobs,
+        pkg: argv.package,
+        target: argv.target,
+        verbose: !!argv.verbose
+      });
+    }
+  ).command(
+    "compile [package]",
+    "Compile with Typescript & Copy Images",
+    (yargs2) => {
+      return yargs2.positional("package", {
+        describe: "Specific package to compile"
+      });
+    },
+    async (argv) => {
+      if (argv.verbose) {
+        console.log(`Compiling: ${argv.package ?? "all"}`);
+      }
+      process.exitCode = await compile({
+        incremental: !!argv.incremental,
+        jobs: argv.jobs,
+        pkg: argv.package,
+        target: argv.target,
+        verbose: !!argv.verbose
+      });
+    }
+  ).command(
+    "recompile [package]",
+    "Re-compile with Typescript & Copy Images",
+    (yargs2) => {
+      return yargs2.positional("package", {
+        describe: "Specific package to re-compile"
+      });
+    },
+    async (argv) => {
+      if (argv.verbose) {
+        console.log(`Re-compiling: ${argv.package ?? "all"}`);
+      }
+      process.exitCode = await recompile({
+        incremental: !!argv.incremental,
+        jobs: argv.jobs,
+        pkg: argv.package,
+        target: argv.target,
+        verbose: !!argv.verbose
+      });
+    }
+  ).command(
+    "rebuild [package]",
+    "Rebuild - Clean, Compile & Lint",
+    (yargs2) => {
+      return yargs2.positional("package", {
+        describe: "Specific package to rebuild"
+      });
+    },
+    (argv) => {
+      if (argv.verbose)
+        console.log(`Rebuilding: ${argv.package ?? "all"}`);
+      process.exitCode = rebuild({ target: argv.target });
+    }
+  ).command(
+    "copy-assets [package]",
+    "Copy Assets - Copy the assets from src to dist",
+    (yargs2) => {
+      return yargs2.positional("package", {
+        describe: "Specific package to copy assets"
+      });
+    },
+    async (argv) => {
+      if (argv.verbose)
+        console.log(`Copying Assets: ${argv.package ?? "all"}`);
+      process.exitCode = await copyAssets({ target: argv.target });
+    }
+  );
+};
+
+// src/lib/xy/xy.ts
+var xy = () => {
+  const options = xyParseOptions();
+  return xyBuildCommands(xyCommonCommands(xyInstallCommands(xyDeployCommands(xyLintCommands(options))))).demandCommand(1).command("*", "", () => {
+    console.error(import_chalk25.default.yellow(`Command not found [${import_chalk25.default.magenta(process.argv[2])}]`));
+    console.log(import_chalk25.default.gray("Try 'yarn xy --help' for list of commands"));
   }).version().help().argv;
 };
 // Annotate the CommonJS export names for ESM import in node: