@storm-software/workspace-tools 1.296.79 → 1.296.84

package/dist/chunk-KSEB2U7B.js

@@ -0,0 +1,318 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkOGB3BDE5js = require('./chunk-OGB3BDE5.js');
+
+
+var _chunkMKJITWLNjs = require('./chunk-MKJITWLN.js');
+
+
+var _chunk46OIJVV3js = require('./chunk-46OIJVV3.js');
+
+
+var _chunk4ARF5MP2js = require('./chunk-4ARF5MP2.js');
+
+
+var _chunkCQDBLKPFjs = require('./chunk-CQDBLKPF.js');
+
+// src/executors/npm-publish/executor.ts
+var _jiti = require('jiti');
+var _child_process = require('child_process');
+var _promises = require('fs/promises');
+var _prettier = require('prettier');
+var LARGE_BUFFER = 1024 * 1e6;
+async function replaceDepsAliases(jiti, packageRoot, workspaceRoot, packageManager) {
+  if (packageManager === "bun") {
+    const { replaceDepsAliases: replaceBunDepsAliases } = await jiti.import(jiti.esmResolve("@storm-software/bun-tools"));
+    return replaceBunDepsAliases(packageRoot, workspaceRoot);
+  }
+  if (packageManager === "pnpm") {
+    const { replaceDepsAliases: replacePnpmDepsAliases } = await jiti.import(jiti.esmResolve("@storm-software/pnpm-tools"));
+    return replacePnpmDepsAliases(packageRoot, workspaceRoot);
+  }
+}
+async function npmPublishExecutorFn(options, context) {
+  const workspaceConfig = await _chunk4ARF5MP2js.getConfig.call(void 0, context.root);
+  const packageManager = await _chunkOGB3BDE5js.getWorkspacePackageManager.call(void 0, 
+    context.root,
+    workspaceConfig
+  );
+  const github = await _chunkMKJITWLNjs.getGitHubTools.call(void 0, workspaceConfig);
+  const isDryRun = process.env.NX_DRY_RUN === "true" || options.dryRun || false;
+  if (!context.projectName) {
+    github.error("The `npm-publish` executor requires a `projectName`.");
+    return { success: false };
+  }
+  const projectConfig = _optionalChain([context, 'access', _ => _.projectsConfigurations, 'optionalAccess', _2 => _2.projects, 'optionalAccess', _3 => _3[context.projectName]]);
+  if (!projectConfig) {
+    github.error(
+      `Could not find project configuration for \`${context.projectName}\``
+    );
+    return { success: false };
+  }
+  const packageRoot = _chunkCQDBLKPFjs.joinPaths.call(void 0, 
+    context.root,
+    options.packageRoot || _chunkCQDBLKPFjs.joinPaths.call(void 0, "dist", projectConfig.root)
+  );
+  const projectRoot = _optionalChain([context, 'access', _4 => _4.projectsConfigurations, 'access', _5 => _5.projects, 'access', _6 => _6[context.projectName], 'optionalAccess', _7 => _7.root]) ? _chunkCQDBLKPFjs.joinPaths.call(void 0, 
+    context.root,
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    context.projectsConfigurations.projects[context.projectName].root
+  ) : packageRoot;
+  const jiti = _jiti.createJiti.call(void 0, context.root, {
+    fsCache: _chunkCQDBLKPFjs.joinPaths.call(void 0, context.root, "node_modules/.cache/storm", "jiti"),
+    interopDefault: true
+  });
+  const { getNpmRegistry, getRegistry } = await jiti.import(jiti.esmResolve("@storm-software/npm-tools/helpers"));
+  const packageJsonPath = _chunkCQDBLKPFjs.joinPaths.call(void 0, packageRoot, "package.json");
+  const packageJsonFile = await _promises.readFile.call(void 0, packageJsonPath, "utf8");
+  if (!packageJsonFile) {
+    github.error(`Could not find \`package.json\` at ${packageJsonPath}`);
+    return { success: false };
+  }
+  const packageJson = JSON.parse(packageJsonFile);
+  const projectPackageJsonPath = _chunkCQDBLKPFjs.joinPaths.call(void 0, projectRoot, "package.json");
+  const projectPackageJsonFile = await _promises.readFile.call(void 0, projectPackageJsonPath, "utf8");
+  if (!projectPackageJsonFile) {
+    github.error(
+      `Could not find \`package.json\` at ${projectPackageJsonPath}`
+    );
+    return { success: false };
+  }
+  const projectPackageJson = JSON.parse(projectPackageJsonFile);
+  if (packageJson.version !== projectPackageJson.version) {
+    console.warn(
+      `The version in the package.json file at ${packageJsonPath} (current: ${packageJson.version}) does not match the version in the package.json file at ${projectPackageJsonPath} (current: ${projectPackageJson.version}). This file will be updated to match the version in the project package.json file.`
+    );
+    if (projectPackageJson.version) {
+      packageJson.version = projectPackageJson.version;
+      await _promises.writeFile.call(void 0, 
+        packageJsonPath,
+        await _prettier.format.call(void 0, JSON.stringify(packageJson), {
+          parser: "json",
+          proseWrap: "preserve",
+          trailingComma: "none",
+          tabWidth: 2,
+          semi: true,
+          singleQuote: false,
+          quoteProps: "as-needed",
+          insertPragma: false,
+          bracketSameLine: true,
+          printWidth: 80,
+          bracketSpacing: true,
+          arrowParens: "avoid",
+          endOfLine: "lf",
+          plugins: ["prettier-plugin-packagejson"]
+        })
+      );
+    }
+  }
+  const packageName = packageJson.name;
+  console.info(
+    `\u{1F680}  Running Storm NPM Publish executor on the ${packageName} package`
+  );
+  const packageTxt = packageName === context.projectName ? `package "${packageName}"` : `package "${packageName}" from project "${context.projectName}"`;
+  if (packageJson.private === true) {
+    console.warn(
+      `Skipped ${packageTxt}, because it has \`"private": true\` in ${packageJsonPath}`
+    );
+    return { success: true };
+  }
+  await replaceDepsAliases(jiti, packageRoot, context.root, packageManager);
+  await _chunk46OIJVV3js.addPackageJsonGitHead.call(void 0, packageRoot);
+  const npmPublishCommandSegments = [`npm publish --json`];
+  const npmViewCommandSegments = [
+    `npm view ${packageName} versions dist-tags --json`
+  ];
+  const registry = await Promise.resolve(
+    await _asyncNullishCoalesce(options.registry, async () => ( (await getRegistry() || getNpmRegistry())))
+  );
+  if (registry) {
+    npmPublishCommandSegments.push(`--registry="${registry}" `);
+    npmViewCommandSegments.push(`--registry="${registry}" `);
+  }
+  if (options.otp) {
+    npmPublishCommandSegments.push(`--otp="${options.otp}" `);
+  }
+  let token;
+  if (!options.otp && registry) {
+    token = await github.getIDToken(
+      `npm:${registry.replace(/^https?:\/\//, "")}`
+    );
+    if (!token) {
+      github.warning(
+        `Either a One time password (OTP) or an OpenID Connect (OIDC) token is generally required to publish ${packageTxt} to NPM. Usually the OIDC token should be provided automatically via GitHub Actions (see: https://github.com/actions/toolkit/tree/main/packages/core#oidc-token); however, the release process was unable to retrieve it. Please provide a \`otp\` executor option, or investigate why the OIDC token could not be retrieved.`
+      );
+    }
+  }
+  npmPublishCommandSegments.push("--provenance --access=public ");
+  if (isDryRun) {
+    npmPublishCommandSegments.push("--dry-run");
+  }
+  const tag = options.tag || _child_process.execSync.call(void 0, "npm config get tag", {
+    cwd: packageRoot,
+    env: {
+      NPM_ID_TOKEN: token,
+      ...process.env,
+      FORCE_COLOR: "true"
+    },
+    maxBuffer: LARGE_BUFFER,
+    killSignal: "SIGTERM"
+  }).toString().trim();
+  if (tag) {
+    npmPublishCommandSegments.push(`--tag="${tag}" `);
+  }
+  if (!isDryRun) {
+    const currentVersion = options.version || packageJson.version;
+    try {
+      try {
+        const result = _child_process.execSync.call(void 0, npmViewCommandSegments.join(" "), {
+          cwd: packageRoot,
+          env: {
+            NPM_ID_TOKEN: token,
+            ...process.env,
+            FORCE_COLOR: "true"
+          },
+          maxBuffer: LARGE_BUFFER,
+          killSignal: "SIGTERM"
+        });
+        const resultJson = JSON.parse(result.toString());
+        const distTags = resultJson["dist-tags"] || {};
+        if (distTags[tag] === currentVersion) {
+          console.warn(
+            `Skipped ${packageTxt} because v${currentVersion} already exists in ${registry} with tag "${tag}"`
+          );
+          return { success: true };
+        }
+      } catch (err) {
+        console.debug(
+          `An error occurred while checking for existing dist-tags. Please note: if this is the first time this package has been published to npm, this can be ignored. 
+
+Error: ${JSON.stringify(
+            err,
+            null,
+            2
+          )}`
+        );
+      }
+      try {
+        if (!isDryRun) {
+          const command = `npm dist-tag add ${packageName}@${currentVersion} ${tag} --registry="${registry}" `;
+          console.debug(
+            `Adding the dist-tag ${tag} - preparing to run the following: ${command}`
+          );
+          const result = _child_process.execSync.call(void 0, command, {
+            cwd: packageRoot,
+            env: {
+              NPM_ID_TOKEN: token,
+              ...process.env,
+              FORCE_COLOR: "true"
+            },
+            maxBuffer: LARGE_BUFFER,
+            killSignal: "SIGTERM"
+          });
+          console.info(
+            `Added the dist-tag ${tag} to v${currentVersion} for registry "${registry}". 
+
+Execution response: ${result.toString()}`
+          );
+        } else {
+          console.info(
+            `Would have added the dist-tag ${tag} to v${currentVersion} for registry "${registry}", but [dry-run] was set.
+`
+          );
+        }
+        return { success: true };
+      } catch (err) {
+        try {
+          const stdoutData = JSON.parse(_optionalChain([err, 'access', _8 => _8.stdout, 'optionalAccess', _9 => _9.toString, 'call', _10 => _10()]) || "{}");
+          if (_optionalChain([stdoutData, 'optionalAccess', _11 => _11.error]) && !(_optionalChain([stdoutData, 'access', _12 => _12.error, 'optionalAccess', _13 => _13.code, 'optionalAccess', _14 => _14.includes, 'call', _15 => _15("E404")]) && _optionalChain([stdoutData, 'access', _16 => _16.error, 'optionalAccess', _17 => _17.summary, 'optionalAccess', _18 => _18.includes, 'call', _19 => _19("no such package available")])) && !(_optionalChain([err, 'access', _20 => _20.stderr, 'optionalAccess', _21 => _21.toString, 'call', _22 => _22(), 'access', _23 => _23.includes, 'call', _24 => _24("E404")]) && _optionalChain([err, 'access', _25 => _25.stderr, 'optionalAccess', _26 => _26.toString, 'call', _27 => _27(), 'access', _28 => _28.includes, 'call', _29 => _29("no such package available")]))) {
+            const errorMessage = `An unexpected error occured while running the npm dist-tag add command: 
+
+${_optionalChain([stdoutData, 'optionalAccess', _30 => _30.error, 'optionalAccess', _31 => _31.summary]) ? `Summary: ${_optionalChain([stdoutData, 'optionalAccess', _32 => _32.error, 'optionalAccess', _33 => _33.summary])}${_optionalChain([stdoutData, 'optionalAccess', _34 => _34.error, 'optionalAccess', _35 => _35.code]) ? ` (${_optionalChain([stdoutData, 'optionalAccess', _36 => _36.error, 'optionalAccess', _37 => _37.code])})` : ""}
+` : ""}${_optionalChain([stdoutData, 'optionalAccess', _38 => _38.error, 'optionalAccess', _39 => _39.detail]) ? `Detail: ${_optionalChain([stdoutData, 'optionalAccess', _40 => _40.error, 'optionalAccess', _41 => _41.detail])}
+` : ""}`;
+            github.error(errorMessage);
+            return { success: false };
+          }
+        } catch (err2) {
+          const stdoutData = JSON.parse(_optionalChain([err2, 'access', _42 => _42.stdout, 'optionalAccess', _43 => _43.toString, 'call', _44 => _44()]) || "{}");
+          const errorMessage = `An unexpected error occured while processing the npm dist-tag add output: 
+
+${_optionalChain([stdoutData, 'optionalAccess', _45 => _45.error, 'optionalAccess', _46 => _46.summary]) ? `Summary: ${_optionalChain([stdoutData, 'optionalAccess', _47 => _47.error, 'optionalAccess', _48 => _48.summary])}${_optionalChain([stdoutData, 'optionalAccess', _49 => _49.error, 'optionalAccess', _50 => _50.code]) ? ` (${_optionalChain([stdoutData, 'optionalAccess', _51 => _51.error, 'optionalAccess', _52 => _52.code])})` : ""}
+` : ""}${_optionalChain([stdoutData, 'optionalAccess', _53 => _53.error, 'optionalAccess', _54 => _54.detail]) ? `Detail: ${_optionalChain([stdoutData, 'optionalAccess', _55 => _55.error, 'optionalAccess', _56 => _56.detail])}
+` : ""}`;
+          github.error(errorMessage);
+          return { success: false };
+        }
+      }
+    } catch (err) {
+      const stdoutData = JSON.parse(_optionalChain([err, 'access', _57 => _57.stdout, 'optionalAccess', _58 => _58.toString, 'call', _59 => _59()]) || "{}");
+      if (!(_optionalChain([stdoutData, 'access', _60 => _60.error, 'optionalAccess', _61 => _61.code, 'optionalAccess', _62 => _62.includes, 'call', _63 => _63("E404")]) && _optionalChain([stdoutData, 'access', _64 => _64.error, 'optionalAccess', _65 => _65.summary, 'optionalAccess', _66 => _66.toLowerCase, 'call', _67 => _67(), 'access', _68 => _68.includes, 'call', _69 => _69("not found")])) && !(_optionalChain([err, 'access', _70 => _70.stderr, 'optionalAccess', _71 => _71.toString, 'call', _72 => _72(), 'access', _73 => _73.includes, 'call', _74 => _74("E404")]) && _optionalChain([err, 'access', _75 => _75.stderr, 'optionalAccess', _76 => _76.toString, 'call', _77 => _77(), 'access', _78 => _78.toLowerCase, 'call', _79 => _79(), 'access', _80 => _80.includes, 'call', _81 => _81("not found")]))) {
+        const errorMessage = `An unexpected error occured while checking for existing dist-tags: 
+
+${_optionalChain([stdoutData, 'optionalAccess', _82 => _82.error, 'optionalAccess', _83 => _83.summary]) ? `Summary: ${_optionalChain([stdoutData, 'optionalAccess', _84 => _84.error, 'optionalAccess', _85 => _85.summary])}${_optionalChain([stdoutData, 'optionalAccess', _86 => _86.error, 'optionalAccess', _87 => _87.code]) ? ` (${_optionalChain([stdoutData, 'optionalAccess', _88 => _88.error, 'optionalAccess', _89 => _89.code])})` : ""}
+` : ""}${_optionalChain([stdoutData, 'optionalAccess', _90 => _90.error, 'optionalAccess', _91 => _91.detail]) ? `Detail: ${_optionalChain([stdoutData, 'optionalAccess', _92 => _92.error, 'optionalAccess', _93 => _93.detail])}
+` : ""}`;
+        github.error(errorMessage);
+        return { success: false };
+      }
+    }
+  }
+  try {
+    const cwd = packageRoot;
+    const command = npmPublishCommandSegments.join(" ");
+    console.info(
+      `Running publish command "${command}" in current working directory: "${cwd}" `
+    );
+    const result = _child_process.execSync.call(void 0, command, {
+      cwd,
+      env: {
+        NPM_ID_TOKEN: token,
+        ...process.env,
+        FORCE_COLOR: "true"
+      },
+      maxBuffer: LARGE_BUFFER,
+      killSignal: "SIGTERM"
+    });
+    if (isDryRun) {
+      console.info(
+        `Would publish tag "${tag}" to ${registry}, but [dry-run] was set. ${result ? `
+
+Execution response: ${result.toString()}` : ""}`
+      );
+    } else {
+      console.info(
+        `Published tag "${tag}" to ${registry}. ${result ? `
+
+Execution response: ${result.toString()}` : ""}`
+      );
+    }
+    return { success: true };
+  } catch (err) {
+    try {
+      const stdoutData = JSON.parse(_optionalChain([err, 'access', _94 => _94.stdout, 'optionalAccess', _95 => _95.toString, 'call', _96 => _96()]) || "{}");
+      const errorMessage = `An error occurred while publishing the npm package: 
+
+${_optionalChain([stdoutData, 'optionalAccess', _97 => _97.error, 'optionalAccess', _98 => _98.summary]) ? `Summary: ${_optionalChain([stdoutData, 'optionalAccess', _99 => _99.error, 'optionalAccess', _100 => _100.summary])}${_optionalChain([stdoutData, 'optionalAccess', _101 => _101.error, 'optionalAccess', _102 => _102.code]) ? ` (${_optionalChain([stdoutData, 'optionalAccess', _103 => _103.error, 'optionalAccess', _104 => _104.code])})` : ""}
+` : ""}${_optionalChain([stdoutData, 'optionalAccess', _105 => _105.error, 'optionalAccess', _106 => _106.detail]) ? `Detail: ${_optionalChain([stdoutData, 'optionalAccess', _107 => _107.error, 'optionalAccess', _108 => _108.detail])}
+` : ""}`;
+      github.error(errorMessage);
+      return { success: false };
+    } catch (err2) {
+      const errorMessage = `Something unexpected went wrong when processing the npm publish output. 
+
+Error: ${JSON.stringify(
+        Buffer.isBuffer(err2) ? err2.toString() : err2,
+        null,
+        2
+      )}`;
+      github.error(errorMessage);
+      return { success: false };
+    }
+  }
+}
+
+
+
+
+exports.LARGE_BUFFER = LARGE_BUFFER; exports.npmPublishExecutorFn = npmPublishExecutorFn;

package/dist/{chunk-2OVKSAE7.mjs → chunk-M7W3EPWR.mjs}

@@ -1,10 +1,10 @@
 import {
   normalizeOptions,
   typeScriptLibraryGeneratorFn
-} from "./chunk-NTTC774E.mjs";
+} from "./chunk-XSHN3XHD.mjs";
 import {
   typesNodeVersion
-} from "./chunk-QC5ON3X4.mjs";
+} from "./chunk-DEHA5C77.mjs";
 import {
   withRunGenerator
 } from "./chunk-Y5BPWYHW.mjs";
@@ -13,7 +13,7 @@ import {
 } from "./chunk-TBW5MCN6.mjs";
 import {
   __dirname
-} from "./chunk-DHJTU33T.mjs";
+} from "./chunk-4RR3IGJL.mjs";
 
 // src/generators/node-library/generator.ts
 import {

package/dist/{chunk-323C3SE6.js → chunk-MYALGFOC.js}

@@ -1,7 +1,7 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
 
 
-var _chunk2F7AZHRHjs = require('./chunk-2F7AZHRH.js');
+var _chunkILSI74FWjs = require('./chunk-ILSI74FW.js');
 
 
 var _chunkQSTZP7MXjs = require('./chunk-QSTZP7MX.js');
@@ -30,7 +30,7 @@ async function neutralLibraryGeneratorFn(tree, schema, config) {
     devDependencies: {},
     buildExecutor: "@storm-software/workspace-tools:unbuild"
   };
-  const options = await _chunk2F7AZHRHjs.normalizeOptions.call(void 0, tree, tsLibraryGeneratorOptions);
+  const options = await _chunkILSI74FWjs.normalizeOptions.call(void 0, tree, tsLibraryGeneratorOptions);
   const { className, name, propertyName } = _devkit.names.call(void 0, 
     options.projectNames.projectFileName
   );
@@ -50,7 +50,7 @@ async function neutralLibraryGeneratorFn(tree, schema, config) {
     buildable: options.bundler && options.bundler !== "none",
     hasUnitTestRunner: options.unitTestRunner !== "none"
   });
-  await _chunk2F7AZHRHjs.typeScriptLibraryGeneratorFn.call(void 0, tree, tsLibraryGeneratorOptions, config);
+  await _chunkILSI74FWjs.typeScriptLibraryGeneratorFn.call(void 0, tree, tsLibraryGeneratorOptions, config);
   await _devkit.formatFiles.call(void 0, tree);
   return null;
 }

package/dist/chunk-OGB3BDE5.js

@@ -0,0 +1,39 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunk4ARF5MP2js = require('./chunk-4ARF5MP2.js');
+
+// src/utils/package-manager.ts
+
+
+
+var _devkit = require('@nx/devkit');
+async function getWorkspacePackageManager(workspaceRoot, config) {
+  let packageManager = _optionalChain([config, 'optionalAccess', _ => _.packageManager]);
+  if (!packageManager) {
+    try {
+      packageManager = (await _chunk4ARF5MP2js.getConfig.call(void 0, workspaceRoot)).packageManager;
+    } catch (e) {
+      packageManager = void 0;
+    }
+  }
+  if (packageManager === "npm" || packageManager === "yarn" || packageManager === "pnpm" || packageManager === "bun") {
+    return packageManager;
+  }
+  return _devkit.detectPackageManager.call(void 0, workspaceRoot);
+}
+async function getWorkspacePackageManagerCommand(workspaceRoot, config) {
+  const packageManager = await getWorkspacePackageManager(
+    workspaceRoot,
+    config
+  );
+  return _devkit.getPackageManagerCommand.call(void 0, packageManager, workspaceRoot);
+}
+function getInstallCommand(packageManager) {
+  return _devkit.getPackageManagerCommand.call(void 0, packageManager).install;
+}
+
+
+
+
+
+exports.getWorkspacePackageManager = getWorkspacePackageManager; exports.getWorkspacePackageManagerCommand = getWorkspacePackageManagerCommand; exports.getInstallCommand = getInstallCommand;

package/dist/{chunk-77B77QNY.mjs → chunk-VQYZG5YE.mjs}

@@ -21,10 +21,17 @@ import {
 var YARN_LOCK_FILE = "yarn.lock";
 var NPM_LOCK_FILE = "package-lock.json";
 var PNPM_LOCK_FILE = "pnpm-lock.yaml";
-var LOCK_FILES = [YARN_LOCK_FILE, NPM_LOCK_FILE, PNPM_LOCK_FILE];
+var BUN_LOCK_FILE = "bun.lock";
+var LOCK_FILES = [
+  YARN_LOCK_FILE,
+  NPM_LOCK_FILE,
+  PNPM_LOCK_FILE,
+  BUN_LOCK_FILE
+];
 var YARN_LOCK_PATH = join(workspaceRoot, YARN_LOCK_FILE);
 var NPM_LOCK_PATH = join(workspaceRoot, NPM_LOCK_FILE);
 var PNPM_LOCK_PATH = join(workspaceRoot, PNPM_LOCK_FILE);
+var BUN_LOCK_PATH = join(workspaceRoot, BUN_LOCK_FILE);
 function getLockFileNodes(packageManager, contents, lockFileHash, context) {
   try {
     if (packageManager === "yarn") {
@@ -97,21 +104,30 @@ function lockFileExists(packageManager) {
   if (packageManager === "npm") {
     return existsSync(NPM_LOCK_PATH);
   }
+  if (packageManager === "bun") {
+    return existsSync(BUN_LOCK_PATH) || existsSync(join(workspaceRoot, "bun.lockb"));
+  }
   throw new Error(
     `Unknown package manager ${packageManager} or lock file missing`
   );
 }
+var LOCK_FILE_BY_PACKAGE_MANAGER = {
+  npm: "package-lock.json",
+  yarn: "yarn.lock",
+  pnpm: "pnpm-lock.yaml",
+  bun: "bun.lock"
+};
+var OTHER_LOCK_FILES = {
+  npm: ["yarn.lock", "pnpm-lock.yaml", "bun.lock", "bun.lockb"],
+  yarn: ["package-lock.json", "pnpm-lock.yaml", "bun.lock", "bun.lockb"],
+  pnpm: ["package-lock.json", "yarn.lock", "bun.lock", "bun.lockb"],
+  bun: ["package-lock.json", "yarn.lock", "pnpm-lock.yaml", "bun.lockb"]
+};
 function getLockFileName(packageManager) {
-  if (packageManager === "yarn") {
-    return YARN_LOCK_FILE;
-  }
-  if (packageManager === "pnpm") {
-    return PNPM_LOCK_FILE;
-  }
-  if (packageManager === "npm") {
-    return NPM_LOCK_FILE;
-  }
-  throw new Error(`Unknown package manager: ${packageManager}`);
+  return LOCK_FILE_BY_PACKAGE_MANAGER[packageManager];
+}
+function getOtherLockFileNames(packageManager) {
+  return OTHER_LOCK_FILES[packageManager];
 }
 function errorBodyLines(originalError, additionalInfo = []) {
   const result = [
@@ -137,12 +153,17 @@ export {
   YARN_LOCK_FILE,
   NPM_LOCK_FILE,
   PNPM_LOCK_FILE,
+  BUN_LOCK_FILE,
   LOCK_FILES,
   YARN_LOCK_PATH,
   NPM_LOCK_PATH,
   PNPM_LOCK_PATH,
+  BUN_LOCK_PATH,
   getLockFileNodes,
   getLockFileDependencies,
   lockFileExists,
-  getLockFileName
+  LOCK_FILE_BY_PACKAGE_MANAGER,
+  OTHER_LOCK_FILES,
+  getLockFileName,
+  getOtherLockFileNames
 };

package/dist/{chunk-NNDVMJGY.mjs → chunk-WTASIX7S.mjs}

@@ -6,15 +6,12 @@ var recommended_default = {
     allProjectFiles: ["sharedGlobals", "{projectRoot}/**/*"],
     default: ["sharedGlobals", "{projectRoot}/**/*"],
     sharedGlobals: [
-      "{workspaceRoot}/.github/workflows/*.yml",
-      "{workspaceRoot}/assets/**/*",
       "{workspaceRoot}/tsconfig.json",
-      "{workspaceRoot}/tsconfig.base.json",
+      "{workspaceRoot}/tsconfig.*.json",
       "{workspaceRoot}/.npm@(rc|ignore)",
       "{workspaceRoot}/package.json",
       "{workspaceRoot}/{pnpm-workspace,pnpm-lock,package-lock,yarn-lock}.@(yaml|yml)",
-      "{workspaceRoot}/bun.lockb",
-      "{workspaceRoot}/LICENSE",
+      "{workspaceRoot}/bun.lock{,b}",
       "{workspaceRoot}/.git@(attributes|ignore)",
       "{workspaceRoot}/{nx.json,.nxignore}",
       "{workspaceRoot}/storm-workspace{,.*}.@(json|yaml|toml)",
@@ -22,7 +19,6 @@ var recommended_default = {
       "{workspaceRoot}/storm-workspace.config.[jt]s",
       "{workspaceRoot}/.storm-workspace/config{,.*}.[jt]s",
       "{workspaceRoot}/devenv.@(lock|nix|yaml)",
-      "{workspaceRoot}/{flake,shell,devShell}.nix",
       "{workspaceRoot}/.envrc",
       "{workspaceRoot}/.env{,.local,.*}"
     ],
@@ -129,14 +125,12 @@ var recommended_default = {
       "{workspaceRoot}/Cargo.lock",
       "{workspaceRoot}/.cargo/config.toml",
       "{workspaceRoot}/rust-toolchain",
-      "{workspaceRoot}/rustfmt.toml",
-      "{workspaceRoot}/deny.toml",
       "{projectRoot}/Cargo.toml",
       "{projectRoot}/.cargo/config.toml",
       {
         runtime: "node -p '`${process.platform}_${process.arch}`'"
       },
-      "{projectRoot}/{project.json,CHANGELOG.md}",
+      "{projectRoot}/project.json",
       "{projectRoot}/.env{,.local}",
       "{projectRoot}/**/*.rs",
       "{projectRoot}/**/*.@(proto|acid|acidic|prisma)",
@@ -155,14 +149,22 @@ var recommended_default = {
       "{projectRoot}/package.json",
       "{projectRoot}/tsconfig.json",
       "{projectRoot}/tsconfig.*.json",
-      "{projectRoot}/{project.json,README.md,CHANGELOG.md}",
+      "{projectRoot}/project.json",
       "{projectRoot}/.env{,.*}",
-      "{projectRoot}/docs/**/*",
-      "{projectRoot}/**/*.stories.@(js|jsx|ts|tsx|mdx)",
+      "!{projectRoot}/docs/**/*",
+      "!{projectRoot}/**/*.stories.@(js|jsx|ts|tsx|mdx)",
       "{projectRoot}/**/*.@(proto|acid|acidic|prisma)",
       "{projectRoot}/src/**/*.@(cts|mts|ts|tsx|graphql|gql|js|cjs|mjs|jsx|json|jsonc|yaml|yml|toml|md|mdx)",
       "{projectRoot}/{build,tsup,tsdown,vite,contentlayer,powerlines,shell-shock,earthquake}.*.[jt]s?(x)",
       "{projectRoot}/{bin,tools,helpers,scripts}/**/*"
+    ],
+    ci: [
+      "sharedGlobals",
+      "{workspaceRoot}/.github/workflows/*.yml",
+      "{workspaceRoot}/assets/**/*",
+      "{workspaceRoot}/devenv.@(lock|nix|yaml)",
+      "{workspaceRoot}/.devenv{,.flake.nix}",
+      "{workspaceRoot}/.direnv"
     ]
   },
   targetDefaults: {
@@ -173,8 +175,8 @@ var recommended_default = {
       executor: "nx:run-commands",
       options: {
         commands: [
-          "pnpm exec rimraf --glob {projectRoot}/dist",
-          "pnpm exec rimraf dist/{projectRoot}"
+          "rimraf --glob {projectRoot}/dist",
+          "rimraf dist/{projectRoot}"
         ]
       }
     },
@@ -194,7 +196,7 @@ var recommended_default = {
         version: {
           currentVersionResolver: "git-tag",
           specifierSource: "conventional-commits",
-          groupPreVersionCommand: "pnpm build",
+          groupPreVersionCommand: "build",
           manifestRootsToUpdate: [
             "{projectRoot}",
             {

package/dist/{chunk-R4GXDUM2.mjs → chunk-WU2HALDD.mjs}

@@ -1,6 +1,9 @@
 import {
   getRoot
 } from "./chunk-K4QMCCQB.mjs";
+import {
+  getWorkspacePackageManagerCommand
+} from "./chunk-5BGCA73V.mjs";
 import {
   cargoMetadata,
   isExternal
@@ -33,6 +36,9 @@ var DefaultCargoPluginProfileMap = {
 var createNodesV2 = [
   "*/**/Cargo.toml",
   async (configFiles, options, context) => {
+    const { exec } = await getWorkspacePackageManagerCommand(
+      context.workspaceRoot
+    );
     return await createNodesFromFiles(
       (configFile, options2, context2) => {
         try {
@@ -97,7 +103,7 @@ var createNodesV2 = [
                   dependsOn: ["^lint-markdown"],
                   executor: "nx:run-commands",
                   options: {
-                    command: 'pnpm exec markdownlint-cli2 "{projectRoot}/*.{md,mdx}" "{projectRoot}/**/*.{md,mdx}" --config "node_modules/@storm-software/markdownlint/config/recommended.markdownlint-cli2.jsonc" --fix'
+                    command: `${exec} markdownlint-cli2 "{projectRoot}/*.{md,mdx}" "{projectRoot}/**/*.{md,mdx}" --config "node_modules/@storm-software/markdownlint/config/recommended.markdownlint-cli2.jsonc" --fix`
                   }
                 },
                 "lint-ls": {
@@ -105,7 +111,7 @@ var createNodesV2 = [
                   inputs: ["linting", "rust", "^production"],
                   dependsOn: ["^lint-ls"],
                   options: {
-                    command: 'pnpm exec ls-lint --config="./node_modules/@storm-software/linting-tools/ls-lint/.ls-lint.yml" ',
+                    command: `${exec} ls-lint --config="./node_modules/@storm-software/linting-tools/ls-lint/.ls-lint.yml" `,
                     color: true
                   }
                 },
@@ -143,7 +149,7 @@ var createNodesV2 = [
                   dependsOn: ["^format-readme"],
                   executor: "nx:run-commands",
                   options: {
-                    command: 'pnpm exec storm-git readme --templates="tools/readme-templates" --project="{projectName}"'
+                    command: `${exec} storm-git readme --templates="tools/readme-templates" --project="{projectName}"`
                   }
                 },
                 "format-toml": {
@@ -153,7 +159,7 @@ var createNodesV2 = [
                   dependsOn: ["^format-toml"],
                   executor: "nx:run-commands",
                   options: {
-                    command: 'pnpm exec taplo format --config="node_modules/@storm-software/linting-tools/taplo/config.toml" --cache-path="node_modules/.cache/taplo/{projectRoot}" --colors="always" "{projectRoot}/*.toml" "{projectRoot}/**/*.toml" '
+                    command: `${exec} taplo format --config="node_modules/@storm-software/linting-tools/taplo/config.toml" --cache-path="node_modules/.cache/taplo/{projectRoot}" --colors="always" "{projectRoot}/*.toml" "{projectRoot}/**/*.toml" `
                   }
                 },
                 "format-clippy": {
@@ -191,7 +197,7 @@ var createNodesV2 = [
                   outputs: [`{workspaceRoot}/dist/{projectRoot}/target`],
                   executor: "nx:run-commands",
                   options: {
-                    command: `pnpm exec rimraf dist/{projectRoot}/target`,
+                    command: `${exec} rimraf dist/{projectRoot}/target`,
                     color: true,
                     cwd: "{workspaceRoot}"
                   }