@storm-software/workspace-tools 1.295.86 → 1.296.1

package/dist/chunk-LMYTVXGX.js

@@ -0,0 +1,100 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunkCQDBLKPFjs = require('./chunk-CQDBLKPF.js');
+
+// ../config-tools/src/utilities/find-up.ts
+var _fs = require('fs');
+var _path = require('path');
+var MAX_PATH_SEARCH_DEPTH = 30;
+var depth = 0;
+function findFolderUp(startPath, endFileNames = [], endDirectoryNames = []) {
+  const _startPath = _nullishCoalesce(startPath, () => ( process.cwd()));
+  if (endDirectoryNames.some(
+    (endDirName) => _fs.existsSync.call(void 0, _path.join.call(void 0, _startPath, endDirName))
+  )) {
+    return _startPath;
+  }
+  if (endFileNames.some((endFileName) => _fs.existsSync.call(void 0, _path.join.call(void 0, _startPath, endFileName)))) {
+    return _startPath;
+  }
+  if (_startPath !== "/" && depth++ < MAX_PATH_SEARCH_DEPTH) {
+    const parent = _path.join.call(void 0, _startPath, "..");
+    return findFolderUp(parent, endFileNames, endDirectoryNames);
+  }
+  return void 0;
+}
+
+// ../config-tools/src/utilities/find-workspace-root.ts
+var rootFiles = [
+  "storm-workspace.json",
+  "storm-workspace.yaml",
+  "storm-workspace.yml",
+  "storm-workspace.js",
+  "storm-workspace.ts",
+  ".storm-workspace.json",
+  ".storm-workspace.yaml",
+  ".storm-workspace.yml",
+  ".storm-workspace.js",
+  ".storm-workspace.ts",
+  "lerna.json",
+  "nx.json",
+  "turbo.json",
+  "npm-workspace.json",
+  "yarn-workspace.json",
+  "pnpm-workspace.json",
+  "npm-workspace.yaml",
+  "yarn-workspace.yaml",
+  "pnpm-workspace.yaml",
+  "npm-workspace.yml",
+  "yarn-workspace.yml",
+  "pnpm-workspace.yml",
+  "npm-lock.json",
+  "yarn-lock.json",
+  "pnpm-lock.json",
+  "npm-lock.yaml",
+  "yarn-lock.yaml",
+  "pnpm-lock.yaml",
+  "npm-lock.yml",
+  "yarn-lock.yml",
+  "pnpm-lock.yml",
+  "bun.lockb"
+];
+var rootDirectories = [
+  ".storm-workspace",
+  ".nx",
+  ".git",
+  ".github",
+  ".vscode",
+  ".verdaccio"
+];
+function findWorkspaceRootSafe(pathInsideMonorepo) {
+  if (process.env.STORM_WORKSPACE_ROOT || process.env.NX_WORKSPACE_ROOT_PATH) {
+    return _chunkCQDBLKPFjs.correctPaths.call(void 0, 
+      _nullishCoalesce(process.env.STORM_WORKSPACE_ROOT, () => ( process.env.NX_WORKSPACE_ROOT_PATH))
+    );
+  }
+  return _chunkCQDBLKPFjs.correctPaths.call(void 0, 
+    findFolderUp(
+      _nullishCoalesce(pathInsideMonorepo, () => ( process.cwd())),
+      rootFiles,
+      rootDirectories
+    )
+  );
+}
+function findWorkspaceRoot(pathInsideMonorepo) {
+  const result = findWorkspaceRootSafe(pathInsideMonorepo);
+  if (!result) {
+    throw new Error(
+      `Cannot find workspace root upwards from known path. Files search list includes: 
+${rootFiles.join(
+        "\n"
+      )}
+Path: ${pathInsideMonorepo ? pathInsideMonorepo : process.cwd()}`
+    );
+  }
+  return result;
+}
+
+
+
+exports.findWorkspaceRoot = findWorkspaceRoot;

package/dist/chunk-LQHVZMFV.js

@@ -0,0 +1,79 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunk7JRL2LE3js = require('./chunk-7JRL2LE3.js');
+
+// src/base/cargo-base-executor.untyped.ts
+var _untyped = require('untyped');
+var cargo_base_executor_untyped_default = _untyped.defineUntypedSchema.call(void 0, {
+  ..._chunk7JRL2LE3js.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"
+    }
+  }
+});
+
+
+
+exports.cargo_base_executor_untyped_default = cargo_base_executor_untyped_default;

package/dist/chunk-LULOWPU2.js

@@ -0,0 +1,110 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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 _chunkHXQRGLIIjs = require('./chunk-HXQRGLII.js');
+
+
+var _chunkCQIILJEFjs = require('./chunk-CQIILJEF.js');
+
+
+
+
+
+
+
+
+
+var _chunkGZA2CV3Cjs = require('./chunk-GZA2CV3C.js');
+
+
+var _chunkLMYTVXGXjs = require('./chunk-LMYTVXGX.js');
+
+// src/base/base-generator.ts
+var withRunGenerator = (name, generatorFn, generatorOptions = {
+  skipReadingConfig: false
+}) => async (tree, _options) => {
+  const stopwatch = _chunkGZA2CV3Cjs.getStopwatch.call(void 0, name);
+  let options = _options;
+  let config;
+  try {
+    _chunkGZA2CV3Cjs.writeInfo.call(void 0, 
+      `${_chunkGZA2CV3Cjs.brandIcon.call(void 0, config)}  Running the ${name} generator...
+
+`,
+      config
+    );
+    const workspaceRoot = _chunkLMYTVXGXjs.findWorkspaceRoot.call(void 0, );
+    if (!generatorOptions.skipReadingConfig) {
+      _chunkGZA2CV3Cjs.writeDebug.call(void 0, 
+        `Loading the Storm Config from environment variables and storm.config.js file...
+ - workspaceRoot: ${workspaceRoot}`,
+        config
+      );
+      config = await _chunkCQIILJEFjs.getConfig.call(void 0, workspaceRoot);
+    }
+    if (_optionalChain([generatorOptions, 'optionalAccess', _ => _.hooks, 'optionalAccess', _2 => _2.applyDefaultOptions])) {
+      _chunkGZA2CV3Cjs.writeDebug.call(void 0, "Running the applyDefaultOptions hook...", config);
+      options = await Promise.resolve(
+        generatorOptions.hooks.applyDefaultOptions(options, config)
+      );
+      _chunkGZA2CV3Cjs.writeDebug.call(void 0, "Completed the applyDefaultOptions hook", config);
+    }
+    _chunkGZA2CV3Cjs.writeTrace.call(void 0, 
+      `Generator schema options \u2699\uFE0F 
+${Object.keys(_nullishCoalesce(options, () => ( {}))).map((key) => ` - ${key}=${JSON.stringify(options[key])}`).join("\n")}`,
+      config
+    );
+    const tokenized = await _chunkHXQRGLIIjs.applyWorkspaceTokens.call(void 0, 
+      options,
+      { workspaceRoot: tree.root, config },
+      _chunkHXQRGLIIjs.applyWorkspaceBaseTokens
+    );
+    if (_optionalChain([generatorOptions, 'optionalAccess', _3 => _3.hooks, 'optionalAccess', _4 => _4.preProcess])) {
+      _chunkGZA2CV3Cjs.writeDebug.call(void 0, "Running the preProcess hook...", config);
+      await Promise.resolve(
+        generatorOptions.hooks.preProcess(tokenized, config)
+      );
+      _chunkGZA2CV3Cjs.writeDebug.call(void 0, "Completed the preProcess hook", config);
+    }
+    const result = await Promise.resolve(
+      generatorFn(tree, tokenized, config)
+    );
+    if (result) {
+      if (result.success === false || result.error && _optionalChain([result, 'optionalAccess', _5 => _5.error, 'optionalAccess', _6 => _6.message]) && typeof _optionalChain([result, 'optionalAccess', _7 => _7.error, 'optionalAccess', _8 => _8.message]) === "string" && _optionalChain([result, 'optionalAccess', _9 => _9.error, 'optionalAccess', _10 => _10.name]) && typeof _optionalChain([result, 'optionalAccess', _11 => _11.error, 'optionalAccess', _12 => _12.name]) === "string") {
+        throw new Error(`The ${name} generator failed to run`, {
+          cause: _optionalChain([result, 'optionalAccess', _13 => _13.error])
+        });
+      } else if (result.success && result.data) {
+        return result;
+      }
+    }
+    if (_optionalChain([generatorOptions, 'optionalAccess', _14 => _14.hooks, 'optionalAccess', _15 => _15.postProcess])) {
+      _chunkGZA2CV3Cjs.writeDebug.call(void 0, "Running the postProcess hook...", config);
+      await Promise.resolve(generatorOptions.hooks.postProcess(config));
+      _chunkGZA2CV3Cjs.writeDebug.call(void 0, "Completed the postProcess hook", config);
+    }
+    return () => {
+      _chunkGZA2CV3Cjs.writeSuccess.call(void 0, `Completed running the ${name} generator!
+`, config);
+    };
+  } catch (error) {
+    return () => {
+      _chunkGZA2CV3Cjs.writeFatal.call(void 0, 
+        "A fatal error occurred while running the generator - the process was forced to terminate",
+        config
+      );
+      _chunkGZA2CV3Cjs.writeError.call(void 0, 
+        `An exception was thrown in the generator's process 
+ - Details: ${error.message}
+ - Stacktrace: ${error.stack}`,
+        config
+      );
+    };
+  } finally {
+    stopwatch();
+  }
+};
+
+
+
+exports.withRunGenerator = withRunGenerator;

package/dist/chunk-LZ3H2OH5.mjs

@@ -0,0 +1,158 @@
+import {
+  base_executor_untyped_default
+} from "./chunk-ZCTECGQS.mjs";
+
+// src/base/typescript-build-executor.untyped.ts
+import { defineUntypedSchema } from "untyped";
+var typescript_build_executor_untyped_default = defineUntypedSchema({
+  ...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: {}
+  }
+});
+
+export {
+  typescript_build_executor_untyped_default
+};

package/dist/chunk-MKJITWLN.js

@@ -0,0 +1,40 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkCQDBLKPFjs = require('./chunk-CQDBLKPF.js');
+
+// src/utils/github.ts
+var _jiti = require('jiti');
+async function getGitHubTools(workspaceConfig) {
+  try {
+    const jiti = _jiti.createJiti.call(void 0, workspaceConfig.workspaceRoot, {
+      fsCache: workspaceConfig.skipCache ? false : _chunkCQDBLKPFjs.joinPaths.call(void 0, 
+        workspaceConfig.workspaceRoot,
+        workspaceConfig.directories.cache || "node_modules/.cache/storm",
+        "jiti"
+      ),
+      interopDefault: true
+    });
+    const core = await jiti.import(
+      jiti.esmResolve("@actions/core")
+    );
+    return {
+      error: core.error,
+      warning: core.warning,
+      info: core.info,
+      getIDToken: core.getIDToken
+    };
+  } catch (e) {
+    return {
+      error: (message) => console.error(message),
+      warning: (message) => console.warn(message),
+      info: (message) => console.log(message),
+      getIDToken: async () => {
+        throw new Error("getIDToken is not supported in this environment");
+      }
+    };
+  }
+}
+
+
+
+exports.getGitHubTools = getGitHubTools;

package/dist/chunk-MNA3AU4B.mjs

@@ -0,0 +1,49 @@
+import {
+  getWorkspaceConfig
+} from "./chunk-35G4LHK2.mjs";
+
+// src/release/js-version-actions.ts
+import JsVersionActions from "@nx/js/src/release/version-actions.js";
+var StormJsVersionActions = class extends JsVersionActions {
+  /**
+   * 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);
+  }
+  /**
+   * Reads the current version of a package from the registry.
+   *
+   * @param tree - The file system tree to read from.
+   * @param currentVersionResolverMetadata - Metadata for resolving the current version.
+   * @returns The current version and log text.
+   */
+  readCurrentVersionFromRegistry(tree, currentVersionResolverMetadata) {
+    currentVersionResolverMetadata ??= {};
+    currentVersionResolverMetadata.registry ??= this.workspaceConfig?.registry?.npm;
+    return super.readCurrentVersionFromRegistry(
+      tree,
+      currentVersionResolverMetadata
+    );
+  }
+};
+
+export {
+  StormJsVersionActions
+};

package/dist/chunk-NIETCJS4.mjs

@@ -0,0 +1,82 @@
+import {
+  normalizeOptions,
+  typeScriptLibraryGeneratorFn
+} from "./chunk-4VWDSVQJ.mjs";
+import {
+  typesNodeVersion
+} from "./chunk-QC5ON3X4.mjs";
+import {
+  withRunGenerator
+} from "./chunk-ALL63TSY.mjs";
+import {
+  joinPaths
+} from "./chunk-TBW5MCN6.mjs";
+import {
+  __dirname
+} from "./chunk-C3NYIWL4.mjs";
+
+// src/generators/node-library/generator.ts
+import {
+  formatFiles,
+  generateFiles,
+  names,
+  offsetFromRoot
+} from "@nx/devkit";
+async function nodeLibraryGeneratorFn(tree, schema, config) {
+  const filesDir = joinPaths(
+    __dirname,
+    "src",
+    "generators",
+    "node-library",
+    "files"
+  );
+  const tsLibraryGeneratorOptions = {
+    platform: "node",
+    devDependencies: {
+      "@types/node": typesNodeVersion
+    },
+    buildExecutor: "@storm-software/workspace-tools:unbuild",
+    ...schema,
+    directory: schema.directory,
+    description: schema.description
+  };
+  const options = await normalizeOptions(tree, tsLibraryGeneratorOptions);
+  const { className, name, propertyName } = names(options.name);
+  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 (NodeJs Platform)",
+  nodeLibraryGeneratorFn,
+  {
+    hooks: {
+      applyDefaultOptions: (options) => {
+        options.description ??= "A library used by Storm Software to support NodeJs applications";
+        options.platform ??= "node";
+        return options;
+      }
+    }
+  }
+);
+
+export {
+  nodeLibraryGeneratorFn,
+  generator_default
+};