@xylabs/ts-scripts-yarn3 3.14.1 → 3.15.0

package/dist/lib/index.cjs

@@ -0,0 +1,617 @@
+"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/lib/index.ts
+var lib_exports = {};
+__export(lib_exports, {
+  CROSS_PLATFORM_NEWLINE: () => CROSS_PLATFORM_NEWLINE,
+  DuplicateDetector: () => DuplicateDetector,
+  INIT_CWD: () => INIT_CWD,
+  WINDOWS_NEWLINE_REGEX: () => WINDOWS_NEWLINE_REGEX,
+  checkResult: () => checkResult,
+  createBuildConfig: () => createBuildConfig,
+  defaultBuildConfig: () => defaultBuildConfig,
+  defaultReadFileSyncOptions: () => defaultReadFileSyncOptions,
+  detectDuplicateDependencies: () => detectDuplicateDependencies,
+  empty: () => empty,
+  generateIgnoreFiles: () => generateIgnoreFiles,
+  isYarnVersionOrGreater: () => isYarnVersionOrGreater,
+  loadConfig: () => loadConfig,
+  multiLineToJSONArray: () => multiLineToJSONArray,
+  notEmpty: () => notEmpty,
+  parsedPackageJSON: () => parsedPackageJSON,
+  processEx: () => processEx,
+  readLines: () => readLines,
+  readNonEmptyLines: () => readNonEmptyLines,
+  runStepAsync: () => runStepAsync,
+  runSteps: () => runSteps,
+  runStepsAsync: () => runStepsAsync,
+  runXy: () => runXy,
+  runXyWithWarning: () => runXyWithWarning,
+  safeExit: () => safeExit,
+  safeExitAsync: () => safeExitAsync,
+  tryReadFileSync: () => tryReadFileSync,
+  union: () => union,
+  withErrnoException: () => withErrnoException,
+  withError: () => withError,
+  writeLines: () => writeLines,
+  yarnWorkspace: () => yarnWorkspace,
+  yarnWorkspaces: () => yarnWorkspaces
+});
+module.exports = __toCommonJS(lib_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/createBuildConfig.ts
+var import_node_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 = /* @__PURE__ */ __name((location) => {
+  let generalConfig;
+  try {
+    generalConfig = (0, import_node_fs.readFileSync)(`${location}/tsconfig.json`, {
+      encoding: "utf8"
+    });
+  } catch {
+    return false;
+  }
+  return JSON.parse(generalConfig);
+}, "getGeneralTypescriptConfig");
+var createBuildConfig = /* @__PURE__ */ __name((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
+    ]
+  };
+}, "createBuildConfig");
+
+// src/lib/dependencies/detectDuplicateDependencies.ts
+var import_node_child_process = require("child_process");
+
+// 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");
+var safeExitAsync = /* @__PURE__ */ __name(async (func, exitOnFail = true) => {
+  try {
+    const result = await func();
+    if (result && exitOnFail) {
+      process.exit(result);
+    }
+    return result;
+  } catch (ex) {
+    return processEx(ex);
+  }
+}, "safeExitAsync");
+
+// src/lib/dependencies/DuplicateDetector.ts
+var import_node_os = require("os");
+var import_chalk3 = __toESM(require("chalk"), 1);
+var import_lodash_es = require("lodash-es");
+
+// src/lib/jsonFormatters.ts
+var multiLineToJSONArray = /* @__PURE__ */ __name((output) => {
+  const withCommas = output.replaceAll("\r\n", "").replaceAll("\n", ",");
+  const cleanCollection = withCommas.slice(0, Math.max(0, withCommas.length - 1));
+  const collection = `[${cleanCollection}]`;
+  return JSON.parse(collection);
+}, "multiLineToJSONArray");
+
+// src/lib/dependencies/DuplicateDetector.ts
+var trimVirtualMeta = /* @__PURE__ */ __name((value) => {
+  const virtualParts = value.split("virtual:");
+  if (virtualParts.length > 1) {
+    const hashParts = virtualParts[1].split("#");
+    return virtualParts[0] + hashParts[1];
+  } else {
+    return value;
+  }
+}, "trimVirtualMeta");
+var trimObjectDependencyVirtualMeta = /* @__PURE__ */ __name((obj) => {
+  const resultObj = {};
+  for (const [key, value] of Object.entries(obj)) {
+    resultObj[trimVirtualMeta(key)] = {
+      descriptor: trimVirtualMeta(value.descriptor),
+      locator: trimVirtualMeta(value.locator)
+    };
+  }
+  return resultObj;
+}, "trimObjectDependencyVirtualMeta");
+var trimDependencyVirtualMeta = /* @__PURE__ */ __name((dependencies) => {
+  return dependencies.map((dependency) => {
+    return {
+      children: trimObjectDependencyVirtualMeta(dependency.children),
+      value: trimVirtualMeta(dependency.value)
+    };
+  });
+}, "trimDependencyVirtualMeta");
+var DuplicateDetector = class {
+  static {
+    __name(this, "DuplicateDetector");
+  }
+  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 > 0) {
+      console.log(import_chalk3.default.yellow(`${import_node_os.EOL}Duplicates found for: ${this.dependency}`));
+      const duplicateVersions = result.duplicateVersions.toString().replaceAll(",", `${import_node_os.EOL}  `);
+      console.log(import_chalk3.default.grey(`  ${duplicateVersions}`, import_node_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_lodash_es.uniq)(acc.duplicateVersions);
+    }
+    return acc;
+  }
+  resultsFactory = /* @__PURE__ */ __name((dependency) => ({
+    currentVersion: void 0,
+    dependency,
+    duplicateVersions: []
+  }), "resultsFactory");
+};
+
+// src/lib/dependencies/detectDuplicateDependencies.ts
+var detectDuplicateDependencies = /* @__PURE__ */ __name((depsFromPackageJSON, DefaultDependencies) => {
+  let exitCode = 0;
+  const dependencies = depsFromPackageJSON?.length ? depsFromPackageJSON : DefaultDependencies;
+  return safeExit(() => {
+    if (dependencies) {
+      for (const dependency of dependencies) {
+        let output;
+        try {
+          const cmd = `yarn why ${dependency} --json`;
+          output = (0, import_node_child_process.execSync)(cmd).toString();
+        } catch (e) {
+          console.error(`Error running yarn why: ${e}`);
+          exitCode = 1;
+          exitCode;
+          continue;
+        }
+        if (output) {
+          exitCode = new DuplicateDetector(output, dependency).detect();
+          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`);
+          }
+          exitCode;
+        }
+      }
+      return exitCode;
+    } else {
+      console.log("\u{1F6A8} No dependencies where passed");
+      return exitCode;
+    }
+  });
+}, "detectDuplicateDependencies");
+
+// 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_fs2 = 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_fs2.existsSync)(uri) ? (0, import_node_fs2.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_fs2.existsSync)(uri) ? (0, import_node_fs2.readFileSync)(uri, options) : void 0;
+  const desired = lines.join(CROSS_PLATFORM_NEWLINE);
+  if (existing !== desired) (0, import_node_fs2.writeFileSync)(uri, desired, options);
+}, "writeLines");
+
+// src/lib/file/tryReadFileSync.ts
+var import_node_fs3 = require("fs");
+var tryReadFileSync = /* @__PURE__ */ __name((uri, options = defaultReadFileSyncOptions) => {
+  return (0, import_node_fs3.existsSync)(uri) ? (0, import_node_fs3.readFileSync)(uri, options) : void 0;
+}, "tryReadFileSync");
+
+// src/lib/generateIgnoreFiles.ts
+var import_chalk4 = __toESM(require("chalk"), 1);
+
+// src/lib/yarn/isYarnVersionOrGreater.ts
+var import_node_child_process2 = require("child_process");
+var isYarnVersionOrGreater = /* @__PURE__ */ __name((major, minor, patch) => {
+  const result = (0, import_node_child_process2.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_process3 = require("child_process");
+var yarnWorkspaces = /* @__PURE__ */ __name(() => {
+  const result = (0, import_node_child_process3.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((filename, pkg) => {
+  console.log(import_chalk4.default.green(`Generate ${filename} Files`));
+  const cwd = INIT_CWD() ?? ".";
+  const workspaces = pkg ? [
+    yarnWorkspace(pkg)
+  ] : yarnWorkspaces();
+  const readEntries = /* @__PURE__ */ __name((location) => readNonEmptyLines(`${location}/${filename}`), "readEntries");
+  const writeEntries = /* @__PURE__ */ __name((location, entries) => writeLines(`${location}/${filename}`, 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 ${filename} Files [${name}] [${error.message}]`);
+      return 1;
+    }
+  });
+  const succeeded = results.every((result) => result === 0);
+  return succeeded ? 0 : 1;
+}, "generateIgnoreFiles");
+
+// src/lib/loadConfig.ts
+var import_chalk5 = __toESM(require("chalk"), 1);
+var import_cosmiconfig = require("cosmiconfig");
+var import_lodash_es2 = require("lodash-es");
+var config;
+var loadConfig = /* @__PURE__ */ __name(async (params) => {
+  if (config) {
+    return (0, import_lodash_es2.merge)({}, config, params);
+  }
+  const cosmicConfigResult = await (0, import_cosmiconfig.cosmiconfig)("xy", {
+    cache: true
+  }).search();
+  config = cosmicConfigResult?.config;
+  const configFilePath = cosmicConfigResult?.filepath;
+  if (configFilePath) {
+    console.log(import_chalk5.default.gray(`Loading config from ${configFilePath}`));
+  }
+  return (0, import_lodash_es2.merge)({}, config, params);
+}, "loadConfig");
+
+// src/lib/parsedPackageJSON.ts
+var import_node_fs4 = require("fs");
+var parsedPackageJSON = /* @__PURE__ */ __name((path) => {
+  const pathToPackageJSON = path ?? process.env.npm_package_json ?? "";
+  const packageJSON = (0, import_node_fs4.readFileSync)(pathToPackageJSON).toString();
+  return JSON.parse(packageJSON);
+}, "parsedPackageJSON");
+
+// src/lib/runSteps.ts
+var import_node_child_process4 = require("child_process");
+var import_node_fs5 = require("fs");
+var import_chalk6 = __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_chalk6.default.green(`${name} [${pkgName}]`));
+    let totalStatus = 0;
+    for (const [i, [command, args, config2]] of steps.entries()) {
+      if (messages?.[i]) {
+        console.log(import_chalk6.default.gray(messages?.[i]));
+      }
+      const argList = Array.isArray(args) ? args : args.split(" ");
+      if (command === "node" && !(0, import_node_fs5.existsSync)(argList[0])) {
+        throw new Error(`File not found [${argList[0]}]`);
+      }
+      const status = (0, import_node_child_process4.spawnSync)(command, Array.isArray(args) ? args : args.split(" "), {
+        ...config2,
+        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/lib/runStepsAsync.ts
+var import_node_child_process5 = require("child_process");
+var import_node_fs6 = require("fs");
+var import_chalk7 = __toESM(require("chalk"), 1);
+var runStepAsync = /* @__PURE__ */ __name((name, step, exitOnFail = true, message) => {
+  return new Promise((resolve) => {
+    const [command, args, config2] = step;
+    if (message) {
+      console.log(import_chalk7.default.gray(message));
+    }
+    const argList = Array.isArray(args) ? args : args.split(" ");
+    if (command === "node" && !(0, import_node_fs6.existsSync)(argList[0])) {
+      throw new Error(`File not found [${argList[0]}]`);
+    }
+    (0, import_node_child_process5.spawn)(command, Array.isArray(args) ? args : args.split(" "), {
+      ...config2,
+      env: {
+        FORCE_COLOR: "3",
+        ...process.env
+      },
+      shell: true,
+      stdio: "inherit"
+    }).on("close", (code) => {
+      if (code) {
+        console.error(import_chalk7.default.red(`Command Exited With Non-Zero Result [${import_chalk7.default.gray(code)}] | ${import_chalk7.default.yellow(command)} ${import_chalk7.default.white(Array.isArray(args) ? args.join(" ") : args)}`));
+        checkResult(name, code, "error", exitOnFail);
+        resolve(code);
+      } else {
+        resolve(0);
+      }
+    });
+  });
+}, "runStepAsync");
+var runStepsAsync = /* @__PURE__ */ __name(async (name, steps, exitOnFail = true, messages) => {
+  return await safeExitAsync(async () => {
+    const pkgName = process.env.npm_package_name;
+    console.log(import_chalk7.default.green(`${name} [${pkgName}]`));
+    let result = 0;
+    for (const [i, step] of steps.entries()) {
+      result += await runStepAsync(name, step, exitOnFail, messages?.[i]);
+    }
+    return result;
+  });
+}, "runStepsAsync");
+
+// src/lib/runXy.ts
+var runXy = /* @__PURE__ */ __name((command) => {
+  return runSteps(`XY [${command}]`, [
+    [
+      "yarn",
+      [
+        "xy",
+        command,
+        ...process.argv.filter((value, index) => index > 1 ? value : void 0)
+      ]
+    ]
+  ]);
+}, "runXy");
+
+// src/lib/runXyWithWarning.ts
+var import_chalk8 = __toESM(require("chalk"), 1);
+var runXyWithWarning = /* @__PURE__ */ __name((command) => {
+  const commandString = `yarn ${command}`;
+  const commandXyString = `yarn xy ${command}`;
+  console.warn(import_chalk8.default.yellow(`WARNING: [${import_chalk8.default.white(commandString)}] is deprecated for XY Labs Scripts.`));
+  console.warn(import_chalk8.default.gray(`Did you mean [${import_chalk8.default.magenta(commandXyString)}]?`));
+  return 1;
+}, "runXyWithWarning");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CROSS_PLATFORM_NEWLINE,
+  DuplicateDetector,
+  INIT_CWD,
+  WINDOWS_NEWLINE_REGEX,
+  checkResult,
+  createBuildConfig,
+  defaultBuildConfig,
+  defaultReadFileSyncOptions,
+  detectDuplicateDependencies,
+  empty,
+  generateIgnoreFiles,
+  isYarnVersionOrGreater,
+  loadConfig,
+  multiLineToJSONArray,
+  notEmpty,
+  parsedPackageJSON,
+  processEx,
+  readLines,
+  readNonEmptyLines,
+  runStepAsync,
+  runSteps,
+  runStepsAsync,
+  runXy,
+  runXyWithWarning,
+  safeExit,
+  safeExitAsync,
+  tryReadFileSync,
+  union,
+  withErrnoException,
+  withError,
+  writeLines,
+  yarnWorkspace,
+  yarnWorkspaces
+});
+//# sourceMappingURL=index.cjs.map