@storm-software/workspace-tools 1.295.69 → 1.295.71

package/dist/chunk-MHKQN2Y7.mjs

@@ -0,0 +1,77 @@
+import {
+  normalizeOptions,
+  typeScriptLibraryGeneratorFn
+} from "./chunk-4VWDSVQJ.mjs";
+import {
+  withRunGenerator
+} from "./chunk-46GNS53C.mjs";
+import {
+  joinPaths
+} from "./chunk-TBW5MCN6.mjs";
+import {
+  __dirname
+} from "./chunk-BWV5PEQM.mjs";
+
+// src/generators/neutral-library/generator.ts
+import {
+  formatFiles,
+  generateFiles,
+  names,
+  offsetFromRoot
+} from "@nx/devkit";
+async function neutralLibraryGeneratorFn(tree, schema, config) {
+  const filesDir = joinPaths(
+    __dirname,
+    "src",
+    "generators",
+    "neutral-library",
+    "files"
+  );
+  const tsLibraryGeneratorOptions = {
+    ...schema,
+    platform: "neutral",
+    devDependencies: {},
+    buildExecutor: "@storm-software/workspace-tools:unbuild"
+  };
+  const options = await normalizeOptions(tree, tsLibraryGeneratorOptions);
+  const { className, name, propertyName } = names(
+    options.projectNames.projectFileName
+  );
+  generateFiles(tree, filesDir, options.projectRoot, {
+    ...schema,
+    dot: ".",
+    className,
+    name,
+    namespace: process.env.STORM_NAMESPACE ?? "storm-software",
+    description: schema.description ?? "",
+    propertyName,
+    js: !!options.js,
+    cliCommand: "nx",
+    strict: void 0,
+    tmpl: "",
+    offsetFromRoot: offsetFromRoot(options.projectRoot),
+    buildable: options.bundler && options.bundler !== "none",
+    hasUnitTestRunner: options.unitTestRunner !== "none"
+  });
+  await typeScriptLibraryGeneratorFn(tree, tsLibraryGeneratorOptions, config);
+  await formatFiles(tree);
+  return null;
+}
+var generator_default = withRunGenerator(
+  "TypeScript Library Creator (Neutral Platform)",
+  neutralLibraryGeneratorFn,
+  {
+    hooks: {
+      applyDefaultOptions: (options) => {
+        options.description ??= "A library used by Storm Software to support either browser or NodeJs applications";
+        options.platform = "neutral";
+        return options;
+      }
+    }
+  }
+);
+
+export {
+  neutralLibraryGeneratorFn,
+  generator_default
+};

package/dist/chunk-OKSECMVK.js

@@ -0,0 +1,32 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/generators/init/init.ts
+
+
+
+var _devkit = require('@nx/devkit');
+async function initGenerator(tree, schema) {
+  const task = _devkit.addDependenciesToPackageJson.call(void 0, 
+    tree,
+    {
+      nx: "^19.6.2",
+      "@nx/workspace": "^19.6.2",
+      "@nx/js": "^19.6.2",
+      "@storm-software/eslint": "latest",
+      "@storm-software/prettier": "latest",
+      "@storm-software/config-tools": "latest",
+      "@storm-software/testing-tools": "latest",
+      "@storm-software/git-tools": "latest",
+      "@storm-software/linting-tools": "latest"
+    },
+    {}
+  );
+  if (!schema.skipFormat) {
+    await _devkit.formatFiles.call(void 0, tree);
+  }
+  return task;
+}
+var init_default = initGenerator;
+
+
+
+
+exports.initGenerator = initGenerator; exports.init_default = init_default;

package/dist/chunk-P6HSE7LH.js

@@ -0,0 +1 @@
+"use strict";

package/dist/chunk-PHIKLLXQ.js

@@ -0,0 +1,32 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunk32KQVUCFjs = require('./chunk-32KQVUCF.js');
+
+
+var _chunkGSGT2T27js = require('./chunk-GSGT2T27.js');
+
+// src/executors/cargo-build/executor.ts
+async function cargoBuildExecutor(options, context) {
+  const command = _chunk32KQVUCFjs.buildCargoCommand.call(void 0, "build", options, context);
+  return await _chunk32KQVUCFjs.cargoCommand.call(void 0, context.root, ...command);
+}
+var executor_default = _chunkGSGT2T27js.withRunExecutor.call(void 0, 
+  "Cargo - Build",
+  cargoBuildExecutor,
+  {
+    skipReadingConfig: false,
+    hooks: {
+      applyDefaultOptions: (options) => {
+        options.outputPath ??= "dist/{projectRoot}/target";
+        options.toolchain ??= "stable";
+        return options;
+      }
+    }
+  }
+);
+
+
+
+
+exports.cargoBuildExecutor = cargoBuildExecutor; exports.executor_default = executor_default;

package/dist/chunk-PMPKOMMD.js

@@ -0,0 +1,158 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunk7JRL2LE3js = require('./chunk-7JRL2LE3.js');
+
+// src/base/typescript-build-executor.untyped.ts
+var _untyped = require('untyped');
+var typescript_build_executor_untyped_default = _untyped.defineUntypedSchema.call(void 0, {
+  ..._chunk7JRL2LE3js.base_executor_untyped_default,
+  $schema: {
+    id: "TypeScriptBuildExecutorSchema",
+    title: "TypeScript Build Executor",
+    description: "A type definition for the base TypeScript build executor schema",
+    required: ["entry", "tsconfig"]
+  },
+  entry: {
+    $schema: {
+      title: "Entry File(s)",
+      format: "path",
+      type: "array",
+      description: "The entry file or files to build",
+      items: { type: "string" }
+    },
+    $default: ["{sourceRoot}/index.ts"]
+  },
+  tsconfig: {
+    $schema: {
+      title: "TSConfig Path",
+      type: "string",
+      format: "path",
+      description: "The path to the tsconfig file"
+    },
+    $default: "{projectRoot}/tsconfig.json"
+  },
+  bundle: {
+    $schema: {
+      title: "Bundle",
+      type: "boolean",
+      description: "Bundle the output"
+    }
+  },
+  minify: {
+    $schema: {
+      title: "Minify",
+      type: "boolean",
+      description: "Minify the output"
+    }
+  },
+  debug: {
+    $schema: {
+      title: "Debug",
+      type: "boolean",
+      description: "Debug the output"
+    }
+  },
+  sourcemap: {
+    $schema: {
+      title: "Sourcemap",
+      type: "boolean",
+      description: "Generate a sourcemap"
+    }
+  },
+  silent: {
+    $schema: {
+      title: "Silent",
+      type: "boolean",
+      description: "Should the build run silently - only report errors back to the user"
+    },
+    $default: false
+  },
+  target: {
+    $schema: {
+      title: "Target",
+      type: "string",
+      description: "The target to build",
+      enum: [
+        "es3",
+        "es5",
+        "es6",
+        "es2015",
+        "es2016",
+        "es2017",
+        "es2018",
+        "es2019",
+        "es2020",
+        "es2021",
+        "es2022",
+        "es2023",
+        "es2024",
+        "esnext",
+        "node12",
+        "node14",
+        "node16",
+        "node18",
+        "node20",
+        "node22",
+        "browser",
+        "chrome58",
+        "chrome59",
+        "chrome60"
+      ]
+    },
+    $default: "esnext",
+    $resolve: (val = "esnext") => typeof val === "string" ? val.toLowerCase() : val
+  },
+  format: {
+    $schema: {
+      title: "Format",
+      type: "array",
+      description: "The format to build",
+      items: {
+        type: "string",
+        enum: ["cjs", "esm", "iife"]
+      }
+    },
+    $resolve: (val = ["cjs", "esm"]) => [].concat(val)
+  },
+  platform: {
+    $schema: {
+      title: "Platform",
+      type: "string",
+      description: "The platform to build",
+      enum: ["neutral", "node", "browser"]
+    },
+    $default: "neutral"
+  },
+  external: {
+    $schema: {
+      title: "External",
+      type: "array",
+      description: "The external dependencies"
+    },
+    $resolve: (val = []) => [].concat(val)
+  },
+  define: {
+    $schema: {
+      title: "Define",
+      type: "object",
+      tsType: "Record<string, string>",
+      description: "The define values"
+    },
+    $resolve: (val = {}) => val,
+    $default: {}
+  },
+  env: {
+    $schema: {
+      title: "Environment Variables",
+      type: "object",
+      tsType: "Record<string, string>",
+      description: "The environment variable values"
+    },
+    $resolve: (val = {}) => val,
+    $default: {}
+  }
+});
+
+
+
+exports.typescript_build_executor_untyped_default = typescript_build_executor_untyped_default;

package/dist/chunk-QC5ON3X4.mjs

@@ -0,0 +1,40 @@
+// src/utils/versions.ts
+var tsupVersion = "8.4.0";
+var prettierPackageJsonVersion = "2.4.6";
+var prettierPrismaVersion = "5.0.0";
+var prettierVersion = "^3.0.3";
+var swcCliVersion = "~0.1.62";
+var swcCoreVersion = "~1.3.95";
+var swcHelpersVersion = "~0.5.3";
+var swcNodeVersion = "1.6.8";
+var tsLibVersion = "2.6.2";
+var typesNodeVersion = "20.9.0";
+var verdaccioVersion = "5.27.0";
+var typescriptVersion = "~5.2.2";
+var eslintVersion = "~8.53.0";
+var lintStagedVersion = "15.0.2";
+var semanticReleaseVersion = "22.0.7";
+var nxVersion = "^18.0.4";
+var nodeVersion = "20.11.0";
+var pnpmVersion = "8.10.2";
+
+export {
+  tsupVersion,
+  prettierPackageJsonVersion,
+  prettierPrismaVersion,
+  prettierVersion,
+  swcCliVersion,
+  swcCoreVersion,
+  swcHelpersVersion,
+  swcNodeVersion,
+  tsLibVersion,
+  typesNodeVersion,
+  verdaccioVersion,
+  typescriptVersion,
+  eslintVersion,
+  lintStagedVersion,
+  semanticReleaseVersion,
+  nxVersion,
+  nodeVersion,
+  pnpmVersion
+};

package/dist/chunk-QLV3LANL.js

@@ -0,0 +1,32 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunk32KQVUCFjs = require('./chunk-32KQVUCF.js');
+
+
+var _chunkGSGT2T27js = require('./chunk-GSGT2T27.js');
+
+// src/executors/cargo-clippy/executor.ts
+async function cargoClippyExecutor(options, context) {
+  const command = _chunk32KQVUCFjs.buildCargoCommand.call(void 0, "clippy", options, context);
+  return await _chunk32KQVUCFjs.cargoCommand.call(void 0, context.root, ...command);
+}
+var executor_default = _chunkGSGT2T27js.withRunExecutor.call(void 0, 
+  "Cargo - Clippy",
+  cargoClippyExecutor,
+  {
+    skipReadingConfig: false,
+    hooks: {
+      applyDefaultOptions: (options) => {
+        options.toolchain ??= "stable";
+        options.fix ??= false;
+        return options;
+      }
+    }
+  }
+);
+
+
+
+
+exports.cargoClippyExecutor = cargoClippyExecutor; exports.executor_default = executor_default;

package/dist/chunk-QQB6GFYM.mjs

@@ -0,0 +1,79 @@
+import {
+  base_executor_untyped_default
+} from "./chunk-ZCTECGQS.mjs";
+
+// src/base/cargo-base-executor.untyped.ts
+import { defineUntypedSchema } from "untyped";
+var cargo_base_executor_untyped_default = defineUntypedSchema({
+  ...base_executor_untyped_default,
+  $schema: {
+    id: "cargoBaseExecutor",
+    title: "Cargo Base Executor",
+    description: "A base type definition for a Cargo/rust related executor schema"
+  },
+  package: {
+    $schema: {
+      title: "Cargo.toml Path",
+      type: "string",
+      format: "path",
+      description: "The path to the Cargo.toml file"
+    },
+    $default: "{projectRoot}/Cargo.toml"
+  },
+  toolchain: {
+    $schema: {
+      title: "Toolchain",
+      description: "The type of toolchain to use for the build",
+      enum: ["stable", "beta", "nightly"],
+      default: "stable"
+    },
+    $default: "stable"
+  },
+  target: {
+    $schema: {
+      title: "Target",
+      type: "string",
+      description: "The target to build"
+    }
+  },
+  allTargets: {
+    $schema: {
+      title: "All Targets",
+      type: "boolean",
+      description: "Build all targets"
+    }
+  },
+  profile: {
+    $schema: {
+      title: "Profile",
+      type: "string",
+      description: "The profile to build"
+    }
+  },
+  release: {
+    $schema: {
+      title: "Release",
+      type: "boolean",
+      description: "Build in release mode"
+    }
+  },
+  features: {
+    $schema: {
+      title: "Features",
+      type: "string",
+      description: "The features to build",
+      oneOf: [{ type: "string" }, { type: "array", items: { type: "string" } }]
+    }
+  },
+  allFeatures: {
+    $schema: {
+      title: "All Features",
+      type: "boolean",
+      description: "Build all features"
+    }
+  }
+});
+
+export {
+  cargo_base_executor_untyped_default
+};

package/dist/chunk-QVYCDING.js

@@ -0,0 +1,23 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/utils/create-cli-options.ts
+var _devkit = require('@nx/devkit');
+function createCliOptions(obj) {
+  const args = [];
+  for (const key in obj) {
+    const value = obj[key];
+    if (value) {
+      const arg = _devkit.names.call(void 0, key).fileName;
+      if (Array.isArray(value)) {
+        args.push(
+          `--${arg.toLowerCase()}=${value.map((v) => v.trim()).join(",")}`
+        );
+      } else {
+        args.push(`--${arg.toLowerCase()}=${value}`);
+      }
+    }
+  }
+  return args;
+}
+
+
+
+exports.createCliOptions = createCliOptions;

package/dist/chunk-R4NPC2W7.mjs

@@ -0,0 +1,213 @@
+import {
+  getCrateRegistryVersion
+} from "./chunk-EGI64HQ2.mjs";
+import {
+  parseCargoToml,
+  parseCargoTomlWithTree,
+  stringifyCargoToml
+} from "./chunk-JCPIXJ3N.mjs";
+import {
+  getWorkspaceConfig
+} from "./chunk-K7B3YICS.mjs";
+
+// src/release/rust-version-actions.ts
+import {
+  joinPathFragments
+} from "@nx/devkit";
+import { VersionActions } from "nx/release";
+var StormRustVersionActions = class extends VersionActions {
+  validManifestFilenames = ["Cargo.toml"];
+  /**
+   * The Storm workspace configuration object, which is loaded from the `storm-workspace.json` file.
+   *
+   * @remarks
+   * This member variable is populated during the {@link init} method.
+   */
+  workspaceConfig = null;
+  constructor(releaseGroup, projectGraphNode, finalConfigForProject) {
+    super(releaseGroup, projectGraphNode, finalConfigForProject);
+  }
+  /**
+   * Asynchronous initialization of the version actions and resolution of manifest paths.
+   *
+   * @remarks
+   * This does NOT validate that manifest files exist - that happens later in validate().
+   *
+   * @params tree - The file system tree to read from.
+   */
+  async init(tree) {
+    this.workspaceConfig = await getWorkspaceConfig();
+    return super.init(tree);
+  }
+  async readCurrentVersionFromSourceManifest(tree) {
+    const sourceCargoTomlPath = joinPathFragments(
+      this.projectGraphNode.data.root,
+      "Cargo.toml"
+    );
+    try {
+      const cargoToml = parseCargoTomlWithTree(
+        tree,
+        this.projectGraphNode.data.root,
+        this.projectGraphNode.name
+      );
+      return {
+        manifestPath: sourceCargoTomlPath,
+        currentVersion: cargoToml.package.version
+      };
+    } catch {
+      throw new Error(
+        `Unable to determine the current version for project "${this.projectGraphNode.name}" from ${sourceCargoTomlPath}, please ensure that the "version" field is set within the Cargo.toml file`
+      );
+    }
+  }
+  async readCurrentVersionFromRegistry(tree, currentVersionResolverMetadata) {
+    const cargoToml = parseCargoTomlWithTree(
+      tree,
+      this.projectGraphNode.data.root,
+      this.projectGraphNode.name
+    );
+    const crateName = cargoToml.package.name;
+    const metadata = currentVersionResolverMetadata;
+    const registryArg = typeof metadata?.registry === "string" ? metadata.registry : this.workspaceConfig?.registry?.cargo || "https://crates.io";
+    const tagArg = typeof metadata?.tag === "string" ? metadata.tag : "latest";
+    let currentVersion = null;
+    try {
+      currentVersion = await getCrateRegistryVersion(
+        crateName,
+        tagArg,
+        registryArg
+      );
+    } catch {
+    }
+    return {
+      currentVersion: currentVersion || "0.0.0",
+      // Make troubleshooting easier by including the registry and tag data in the log text
+      logText: `"cargoRegistry=${registryArg}" tag=${tagArg}`
+    };
+  }
+  async readCurrentVersionOfDependency(tree, projectGraph, dependencyProjectName) {
+    const cargoToml = parseCargoTomlWithTree(
+      tree,
+      this.projectGraphNode.data.root,
+      this.projectGraphNode.name
+    );
+    if (!projectGraph.nodes[dependencyProjectName]?.data?.root) {
+      return {
+        currentVersion: null,
+        dependencyCollection: null
+      };
+    }
+    const dependencyCargoToml = parseCargoTomlWithTree(
+      tree,
+      projectGraph.nodes[dependencyProjectName]?.data.root,
+      dependencyProjectName
+    );
+    if (!dependencyCargoToml?.package?.name) {
+      return {
+        currentVersion: null,
+        dependencyCollection: null
+      };
+    }
+    let currentVersion = null;
+    let dependencyCollection = null;
+    for (const depType of ["dependencies", "dev-dependencies"]) {
+      if (cargoToml[depType] && cargoToml[depType][dependencyCargoToml.package.name]) {
+        currentVersion = typeof cargoToml[depType][dependencyCargoToml.package.name] === "string" ? cargoToml[depType][dependencyCargoToml.package.name] : cargoToml[depType][dependencyCargoToml.package.name].version;
+        dependencyCollection = depType;
+        break;
+      }
+    }
+    return {
+      currentVersion,
+      dependencyCollection
+    };
+  }
+  async updateProjectVersion(tree, newVersion) {
+    const logMessages = [];
+    for (const manifestToUpdate of this.manifestsToUpdate) {
+      const cargoTomlString = tree.read(manifestToUpdate.manifestPath)?.toString();
+      if (!cargoTomlString) {
+        throw new Error(
+          `Unable to read Cargo.toml at path: ${manifestToUpdate.manifestPath}`
+        );
+      }
+      const cargoToml = parseCargoToml(cargoTomlString);
+      cargoToml.package.version = newVersion;
+      tree.write(manifestToUpdate.manifestPath, stringifyCargoToml(cargoToml));
+      logMessages.push(
+        `\u270D\uFE0F  New version ${newVersion} written to manifest: ${manifestToUpdate.manifestPath}`
+      );
+    }
+    return logMessages;
+  }
+  /**
+   * Updates the dependencies of the project in the specified Cargo.toml files.
+   *
+   * @param tree - The file system tree to read from and write to.
+   * @param projectGraph - The project graph to use for resolving dependencies.
+   * @param dependenciesToUpdate - A mapping of dependency names to their new versions.
+   * @returns An array of log messages indicating the results of the updates.
+   */
+  async updateProjectDependencies(tree, projectGraph, dependenciesToUpdate = {}) {
+    const numDependenciesToUpdate = Object.keys(dependenciesToUpdate).length;
+    if (numDependenciesToUpdate === 0) {
+      return [];
+    }
+    const logMessages = [];
+    for (const manifestToUpdate of this.manifestsToUpdate) {
+      const cargoTomlString = tree.read(manifestToUpdate.manifestPath)?.toString();
+      if (!cargoTomlString) {
+        throw new Error(
+          `Unable to read Cargo.toml at path: ${manifestToUpdate.manifestPath}`
+        );
+      }
+      const cargoToml = parseCargoToml(cargoTomlString);
+      for (const depType of ["dependencies", "dev-dependencies"]) {
+        if (cargoToml[depType]) {
+          for (const [dep, version] of Object.entries(dependenciesToUpdate)) {
+            try {
+              const projectRoot = projectGraph.nodes[dep]?.data.root;
+              if (!projectRoot) {
+                throw new Error(
+                  `Unable to determine the project root for "${dep}" from the project graph metadata, please ensure that the "@storm-software/workspace-tools" plugin is installed and the project graph has been built. If the issue persists, please report this issue on https://github.com/storm-software/storm-ops/issues`
+                );
+              }
+              const dependencyCargoTomlString = tree.read(manifestToUpdate.manifestPath)?.toString();
+              if (!dependencyCargoTomlString) {
+                throw new Error(
+                  `Unable to read Cargo.toml at path: ${manifestToUpdate.manifestPath}`
+                );
+              }
+              const dependencyCargoToml = parseCargoToml(
+                dependencyCargoTomlString
+              );
+              const dependencyCrateName = cargoToml[depType][dependencyCargoToml.package.name] ? dependencyCargoToml.package.name : dep;
+              if (typeof cargoToml[depType][dependencyCrateName] === "string") {
+                cargoToml[depType][dependencyCrateName] = version;
+              } else {
+                cargoToml[depType][dependencyCrateName].version = version;
+              }
+              tree.write(
+                manifestToUpdate.manifestPath,
+                stringifyCargoToml(cargoToml)
+              );
+            } catch (error) {
+              throw new Error(
+                `Unable to update ${depType === "dev-dependencies" ? "dev-dependency" : "dependency"} "${dep}" in manifest at path: ${manifestToUpdate.manifestPath}.`,
+                { cause: error }
+              );
+            }
+          }
+        }
+      }
+      logMessages.push(
+        `\u270D\uFE0F  Updated ${numDependenciesToUpdate} ${numDependenciesToUpdate === 1 ? "dependency" : "dependencies"} in manifest: ${manifestToUpdate.manifestPath}`
+      );
+    }
+    return logMessages;
+  }
+};
+
+export {
+  StormRustVersionActions
+};