@storm-software/workspace-tools 1.295.86 → 1.295.87

package/dist/chunk-77B77QNY.mjs

@@ -0,0 +1,148 @@
+// src/utils/lock-file.ts
+import {
+  output,
+  readJsonFile,
+  workspaceRoot
+} from "@nx/devkit";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import {
+  getNpmLockfileDependencies,
+  getNpmLockfileNodes
+} from "nx/src/plugins/js/lock-file/npm-parser";
+import {
+  getPnpmLockfileDependencies,
+  getPnpmLockfileNodes
+} from "nx/src/plugins/js/lock-file/pnpm-parser";
+import {
+  getYarnLockfileDependencies,
+  getYarnLockfileNodes
+} from "nx/src/plugins/js/lock-file/yarn-parser";
+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 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);
+function getLockFileNodes(packageManager, contents, lockFileHash, context) {
+  try {
+    if (packageManager === "yarn") {
+      const packageJson = readJsonFile(
+        join(context.workspaceRoot, "package.json")
+      );
+      return getYarnLockfileNodes(contents, lockFileHash, packageJson);
+    }
+    if (packageManager === "pnpm") {
+      return getPnpmLockfileNodes(contents, lockFileHash);
+    }
+    if (packageManager === "npm") {
+      return getNpmLockfileNodes(contents, lockFileHash);
+    }
+  } catch (e) {
+    if (!isPostInstallProcess()) {
+      output.error({
+        title: `Failed to parse ${packageManager} lockfile`,
+        bodyLines: errorBodyLines(e)
+      });
+    }
+    throw e;
+  }
+  throw new Error(`Unknown package manager: ${packageManager}`);
+}
+function getLockFileDependencies(packageManager, contents, lockFileHash, context, keyMap) {
+  try {
+    if (packageManager === "yarn") {
+      return getYarnLockfileDependencies(
+        contents,
+        lockFileHash,
+        context,
+        keyMap
+      );
+    }
+    if (packageManager === "pnpm") {
+      return getPnpmLockfileDependencies(
+        contents,
+        lockFileHash,
+        context,
+        keyMap
+      );
+    }
+    if (packageManager === "npm") {
+      return getNpmLockfileDependencies(
+        contents,
+        lockFileHash,
+        context,
+        keyMap
+      );
+    }
+  } catch (e) {
+    if (!isPostInstallProcess()) {
+      output.error({
+        title: `Failed to parse ${packageManager} lockfile`,
+        bodyLines: errorBodyLines(e)
+      });
+    }
+    throw e;
+  }
+  throw new Error(`Unknown package manager: ${packageManager}`);
+}
+function lockFileExists(packageManager) {
+  if (packageManager === "yarn") {
+    return existsSync(YARN_LOCK_PATH);
+  }
+  if (packageManager === "pnpm") {
+    return existsSync(PNPM_LOCK_PATH);
+  }
+  if (packageManager === "npm") {
+    return existsSync(NPM_LOCK_PATH);
+  }
+  throw new Error(
+    `Unknown package manager ${packageManager} or lock file missing`
+  );
+}
+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}`);
+}
+function errorBodyLines(originalError, additionalInfo = []) {
+  const result = [
+    "Please open an issue at `https://github.com/storm-software/storm-ops/issues/new?template=1-bug.yml` and provide a reproduction.",
+    ...additionalInfo
+  ];
+  if (originalError.message) {
+    result.push(`
+Original error: ${originalError.message}
+
+`);
+  }
+  if (originalError.stack) {
+    result.push(originalError.stack);
+  }
+  return result;
+}
+function isPostInstallProcess() {
+  return process.env.npm_command === "install" && process.env.npm_lifecycle_event === "postinstall";
+}
+
+export {
+  YARN_LOCK_FILE,
+  NPM_LOCK_FILE,
+  PNPM_LOCK_FILE,
+  LOCK_FILES,
+  YARN_LOCK_PATH,
+  NPM_LOCK_PATH,
+  PNPM_LOCK_PATH,
+  getLockFileNodes,
+  getLockFileDependencies,
+  lockFileExists,
+  getLockFileName
+};

package/dist/chunk-7CJRMBX3.js

@@ -0,0 +1,20 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/base/base-generator.untyped.ts
+var _untyped = require('untyped');
+var base_generator_untyped_default = _untyped.defineUntypedSchema.call(void 0, {
+  $schema: {
+    id: "BaseGeneratorSchema",
+    title: "Base Generator",
+    description: "A type definition for the base Generator schema"
+  },
+  directory: {
+    $schema: {
+      title: "Directory",
+      type: "string",
+      description: "The directory to create the library in"
+    }
+  }
+});
+
+
+
+exports.base_generator_untyped_default = base_generator_untyped_default;

package/dist/chunk-7JRL2LE3.js

@@ -0,0 +1,21 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/base/base-executor.untyped.ts
+var _untyped = require('untyped');
+var base_executor_untyped_default = _untyped.defineUntypedSchema.call(void 0, {
+  $schema: {
+    id: "baseExecutor",
+    title: "Base Executor",
+    description: "A base type definition for an executor schema"
+  },
+  outputPath: {
+    $schema: {
+      title: "Output Path",
+      type: "string",
+      format: "path",
+      description: "The output path for the build"
+    }
+  }
+});
+
+
+
+exports.base_executor_untyped_default = base_executor_untyped_default;

package/dist/chunk-7MM5MBEP.mjs

@@ -0,0 +1,32 @@
+import {
+  buildCargoCommand,
+  cargoCommand
+} from "./chunk-GKLFEOKK.mjs";
+import {
+  withRunExecutor
+} from "./chunk-35ERFW7I.mjs";
+
+// src/executors/cargo-clippy/executor.ts
+async function cargoClippyExecutor(options, context) {
+  const command = buildCargoCommand("clippy", options, context);
+  return await cargoCommand(context.root, ...command);
+}
+var executor_default = withRunExecutor(
+  "Cargo - Clippy",
+  cargoClippyExecutor,
+  {
+    skipReadingConfig: false,
+    hooks: {
+      applyDefaultOptions: (options) => {
+        options.toolchain ??= "stable";
+        options.fix ??= false;
+        return options;
+      }
+    }
+  }
+);
+
+export {
+  cargoClippyExecutor,
+  executor_default
+};

package/dist/chunk-AH7KAAQJ.mjs

@@ -0,0 +1,17 @@
+import {
+  findWorkspaceRoot
+} from "./chunk-3J2CP54B.mjs";
+
+// src/utils/get-project-configurations.ts
+import { retrieveProjectConfigurationsWithoutPluginInference } from "nx/src/project-graph/utils/retrieve-workspace-files";
+var getProjectConfigurations = async () => {
+  return retrieveProjectConfigurationsWithoutPluginInference(
+    findWorkspaceRoot()
+  );
+};
+var getProjectConfiguration = (projectName) => getProjectConfigurations()?.[projectName];
+
+export {
+  getProjectConfigurations,
+  getProjectConfiguration
+};

package/dist/chunk-ALL63TSY.mjs

@@ -0,0 +1,110 @@
+import {
+  applyWorkspaceBaseTokens,
+  applyWorkspaceTokens
+} from "./chunk-2QMGYIOO.mjs";
+import {
+  getConfig
+} from "./chunk-35G4LHK2.mjs";
+import {
+  brandIcon,
+  getStopwatch,
+  writeDebug,
+  writeError,
+  writeFatal,
+  writeInfo,
+  writeSuccess,
+  writeTrace
+} from "./chunk-4AR5RJMF.mjs";
+import {
+  findWorkspaceRoot
+} from "./chunk-3J2CP54B.mjs";
+
+// src/base/base-generator.ts
+var withRunGenerator = (name, generatorFn, generatorOptions = {
+  skipReadingConfig: false
+}) => async (tree, _options) => {
+  const stopwatch = getStopwatch(name);
+  let options = _options;
+  let config;
+  try {
+    writeInfo(
+      `${brandIcon(config)}  Running the ${name} generator...
+
+`,
+      config
+    );
+    const workspaceRoot = findWorkspaceRoot();
+    if (!generatorOptions.skipReadingConfig) {
+      writeDebug(
+        `Loading the Storm Config from environment variables and storm.config.js file...
+ - workspaceRoot: ${workspaceRoot}`,
+        config
+      );
+      config = await getConfig(workspaceRoot);
+    }
+    if (generatorOptions?.hooks?.applyDefaultOptions) {
+      writeDebug("Running the applyDefaultOptions hook...", config);
+      options = await Promise.resolve(
+        generatorOptions.hooks.applyDefaultOptions(options, config)
+      );
+      writeDebug("Completed the applyDefaultOptions hook", config);
+    }
+    writeTrace(
+      `Generator schema options \u2699\uFE0F 
+${Object.keys(options ?? {}).map((key) => ` - ${key}=${JSON.stringify(options[key])}`).join("\n")}`,
+      config
+    );
+    const tokenized = await applyWorkspaceTokens(
+      options,
+      { workspaceRoot: tree.root, config },
+      applyWorkspaceBaseTokens
+    );
+    if (generatorOptions?.hooks?.preProcess) {
+      writeDebug("Running the preProcess hook...", config);
+      await Promise.resolve(
+        generatorOptions.hooks.preProcess(tokenized, config)
+      );
+      writeDebug("Completed the preProcess hook", config);
+    }
+    const result = await Promise.resolve(
+      generatorFn(tree, tokenized, config)
+    );
+    if (result) {
+      if (result.success === false || result.error && result?.error?.message && typeof result?.error?.message === "string" && result?.error?.name && typeof result?.error?.name === "string") {
+        throw new Error(`The ${name} generator failed to run`, {
+          cause: result?.error
+        });
+      } else if (result.success && result.data) {
+        return result;
+      }
+    }
+    if (generatorOptions?.hooks?.postProcess) {
+      writeDebug("Running the postProcess hook...", config);
+      await Promise.resolve(generatorOptions.hooks.postProcess(config));
+      writeDebug("Completed the postProcess hook", config);
+    }
+    return () => {
+      writeSuccess(`Completed running the ${name} generator!
+`, config);
+    };
+  } catch (error) {
+    return () => {
+      writeFatal(
+        "A fatal error occurred while running the generator - the process was forced to terminate",
+        config
+      );
+      writeError(
+        `An exception was thrown in the generator's process 
+ - Details: ${error.message}
+ - Stacktrace: ${error.stack}`,
+        config
+      );
+    };
+  } finally {
+    stopwatch();
+  }
+};
+
+export {
+  withRunGenerator
+};

package/dist/chunk-ANHKV7HZ.js

@@ -0,0 +1,22 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }// src/utils/registry-helpers.ts
+var _https = require('https'); var _https2 = _interopRequireDefault(_https);
+var getCrateRegistryVersion = (name, tag = "latest", registry = "https://crates.io") => {
+  return new Promise(
+    (resolve) => _https2.default.get(
+      `${registry}/api/v1/crates/${encodeURIComponent(name)}/${encodeURIComponent(
+        tag
+      )}`,
+      (res) => {
+        res.on("data", (d) => {
+          resolve(d);
+        });
+      }
+    ).on("error", (e) => {
+      throw e;
+    })
+  );
+};
+
+
+
+exports.getCrateRegistryVersion = getCrateRegistryVersion;

package/dist/chunk-AY3HOPOX.js

@@ -0,0 +1,41 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunk32KQVUCFjs = require('./chunk-32KQVUCF.js');
+
+
+var _chunkCBVZ57E6js = require('./chunk-CBVZ57E6.js');
+
+// src/executors/cargo-doc/executor.ts
+async function cargoDocExecutor(options, context) {
+  const opts = { ...options };
+  opts["no-deps"] = opts.noDeps;
+  delete opts.noDeps;
+  const command = _chunk32KQVUCFjs.buildCargoCommand.call(void 0, "doc", options, context);
+  return await _chunk32KQVUCFjs.cargoCommand.call(void 0, context.root, ...command);
+}
+var executor_default = _chunkCBVZ57E6js.withRunExecutor.call(void 0, 
+  "Cargo - Doc",
+  cargoDocExecutor,
+  {
+    skipReadingConfig: false,
+    hooks: {
+      applyDefaultOptions: (options) => {
+        options.outputPath ??= "dist/{projectRoot}/docs";
+        options.toolchain ??= "stable";
+        options.release ??= options.profile ? false : true;
+        options.allFeatures ??= true;
+        options.lib ??= true;
+        options.bins ??= true;
+        options.examples ??= true;
+        options.noDeps ??= false;
+        return options;
+      }
+    }
+  }
+);
+
+
+
+
+exports.cargoDocExecutor = cargoDocExecutor; exports.executor_default = executor_default;

package/dist/chunk-BAPFD3TO.js

@@ -0,0 +1,79 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return 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 _chunkTAP26ZJQjs = require('./chunk-TAP26ZJQ.js');
+
+// src/utils/plugin-helpers.ts
+
+
+var _devkit = require('@nx/devkit');
+var _defu = require('defu'); var _defu2 = _interopRequireDefault(_defu);
+var _fs = require('fs');
+var _path = require('path');
+function getProjectPlatform(project, ignoreTags = false) {
+  const tsconfigJson = _devkit.readJsonFile.call(void 0, _path.join.call(void 0, project.root, "tsconfig.json"));
+  if (!tsconfigJson) {
+    throw new Error(`No tsconfig.json found in project root: ${project.root}`);
+  }
+  const packageJson = _devkit.readJsonFile.call(void 0, _path.join.call(void 0, project.root, "package.json"));
+  if (!packageJson) {
+    throw new Error(`No package.json found in project root: ${project.root}`);
+  }
+  let platformTag = void 0;
+  if (!ignoreTags) {
+    platformTag = _chunkTAP26ZJQjs.getProjectTag.call(void 0, project, _chunkTAP26ZJQjs.ProjectTagConstants.Platform.TAG_ID);
+  }
+  if (platformTag !== _chunkTAP26ZJQjs.ProjectTagConstants.Platform.NEUTRAL) {
+    const types = Array.isArray(_optionalChain([tsconfigJson, 'access', _ => _.compilerOptions, 'optionalAccess', _2 => _2.types])) ? tsconfigJson.compilerOptions.types : [];
+    if (platformTag === _chunkTAP26ZJQjs.ProjectTagConstants.Platform.WORKER || types.some((type) => type.toLowerCase() === "@cloudflare/workers-types") || _optionalChain([packageJson, 'access', _3 => _3.devDependencies, 'optionalAccess', _4 => _4["@cloudflare/workers-types"]]) || _optionalChain([packageJson, 'access', _5 => _5.devDependencies, 'optionalAccess', _6 => _6["wrangler"]])) {
+      return "worker";
+    }
+    if (platformTag === _chunkTAP26ZJQjs.ProjectTagConstants.Platform.NODE || _optionalChain([types, 'optionalAccess', _7 => _7.some, 'call', _8 => _8((type) => type.toLowerCase() === "node")]) || _optionalChain([packageJson, 'access', _9 => _9.devDependencies, 'optionalAccess', _10 => _10["@types/node"]])) {
+      return "node";
+    }
+    if (platformTag === _chunkTAP26ZJQjs.ProjectTagConstants.Platform.BROWSER || _optionalChain([types, 'optionalAccess', _11 => _11.some, 'call', _12 => _12((type) => type.toLowerCase() === "dom")]) || packageJson.dependencies && Object.keys(packageJson.dependencies).some(
+      (dependency) => dependency.includes("react")
+    ) || packageJson.devDependencies && Object.keys(packageJson.devDependencies).some(
+      (devDependency) => devDependency.includes("react")
+    )) {
+      return "browser";
+    }
+  }
+  return "neutral";
+}
+function getProjectConfigFromProjectJsonPath(projectJsonPath, packageJson) {
+  return getProjectConfigFromProjectRoot(_path.dirname.call(void 0, projectJsonPath), packageJson);
+}
+function getProjectConfigFromProjectRoot(projectRoot, packageJson) {
+  const { nx, name } = packageJson;
+  const projectJson = _devkit.readJsonFile.call(void 0, _path.join.call(void 0, projectRoot, "project.json"));
+  return _defu2.default.call(void 0, _nullishCoalesce(nx, () => ( {})), projectJson, {
+    targets: {},
+    tags: [],
+    name,
+    root: projectRoot
+  });
+}
+function getProjectRoot(configPath, workspaceRoot) {
+  try {
+    const projectRoot = _path.dirname.call(void 0, configPath);
+    if (!_fs.existsSync.call(void 0, _path.join.call(void 0, workspaceRoot, projectRoot, "package.json")) && !_fs.existsSync.call(void 0, _path.join.call(void 0, workspaceRoot, projectRoot, "project.json"))) {
+      return null;
+    }
+    return projectRoot;
+  } catch (error_) {
+    console.error(error_);
+    return null;
+  }
+}
+function getRoot(projectRoot, context) {
+  return projectRoot.replaceAll("\\", "/").replace(context.workspaceRoot.replaceAll("\\", "/"), "").replace(/^\//g, "").replace(/\/$/g, "");
+}
+
+
+
+
+
+
+
+exports.getProjectPlatform = getProjectPlatform; exports.getProjectConfigFromProjectJsonPath = getProjectConfigFromProjectJsonPath; exports.getProjectConfigFromProjectRoot = getProjectConfigFromProjectRoot; exports.getProjectRoot = getProjectRoot; exports.getRoot = getRoot;