@storm-software/workspace-tools 1.295.69 → 1.295.71

package/dist/chunk-32KQVUCF.js

@@ -0,0 +1,163 @@
+"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; }// src/utils/cargo.ts
+var _devkit = require('@nx/devkit');
+
+
+
+var _child_process = require('child_process');
+var _path = require('path');
+var INVALID_CARGO_ARGS = [
+  "allFeatures",
+  "allTargets",
+  "main",
+  "outputPath",
+  "package",
+  "tsConfig"
+];
+var childProcess;
+var buildCargoCommand = (baseCommand, options, context) => {
+  const args = [];
+  if (options.toolchain && options.toolchain !== "stable") {
+    args.push(`+${options.toolchain}`);
+  }
+  args.push(baseCommand);
+  for (const [key, value] of Object.entries(options).filter(
+    ([key2]) => key2 && key2 !== "_"
+  )) {
+    if (key === "toolchain" || key === "release" || INVALID_CARGO_ARGS.includes(key)) {
+      continue;
+    }
+    if (typeof value === "boolean") {
+      if (value) {
+        args.push(`--${key}`);
+      }
+    } else if (Array.isArray(value)) {
+      for (const item of value) {
+        args.push(`--${key}`, String(item));
+      }
+    } else {
+      args.push(`--${key}`, String(value));
+    }
+  }
+  if (context.projectName) {
+    args.push("-p", context.projectName);
+  }
+  if (options.allFeatures && !args.includes("--all-features")) {
+    args.push("--all-features");
+  }
+  if (options.allTargets && !args.includes("--all-targets")) {
+    args.push("--all-targets");
+  }
+  if (options.release && !args.includes("--profile")) {
+    args.push("--release");
+  }
+  if (options.outputPath && !args.includes("--target-dir")) {
+    args.push("--target-dir", options.outputPath);
+  }
+  return args;
+};
+async function cargoCommand(workspaceRoot, ...args) {
+  console.log(`> cargo ${args.join(" ")}`);
+  args.push("--color", "always");
+  return await Promise.resolve(runProcess(workspaceRoot, "cargo", ...args));
+}
+function cargoRunCommand(...args) {
+  console.log(`> cargo ${args.join(" ")}`);
+  return new Promise((resolve, reject) => {
+    childProcess = exports.childProcess = _child_process.spawn.call(void 0, "cargo", [...args, "--color", "always"], {
+      cwd: process.cwd(),
+      windowsHide: true,
+      detached: true,
+      shell: false,
+      stdio: ["inherit", "inherit", "inherit"]
+    });
+    process.on("exit", () => _optionalChain([childProcess, 'optionalAccess', _ => _.kill, 'call', _2 => _2()]));
+    process.on("SIGTERM", () => _optionalChain([childProcess, 'optionalAccess', _3 => _3.kill, 'call', _4 => _4()]));
+    process.on("SIGINT", () => _optionalChain([childProcess, 'optionalAccess', _5 => _5.kill, 'call', _6 => _6()]));
+    childProcess.on("error", (_err) => {
+      reject({ success: false });
+    });
+    childProcess.on("exit", (code) => {
+      childProcess = exports.childProcess = null;
+      if (code === 0) {
+        resolve({ success: true });
+      } else {
+        reject({ success: false });
+      }
+    });
+  });
+}
+function cargoCommandSync(args = "", options) {
+  const normalizedOptions = {
+    stdio: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _7 => _7.stdio]), () => ( "inherit")),
+    env: {
+      ...process.env,
+      ..._optionalChain([options, 'optionalAccess', _8 => _8.env])
+    }
+  };
+  try {
+    return {
+      output: _child_process.execSync.call(void 0, `cargo ${args}`, {
+        encoding: "utf8",
+        windowsHide: true,
+        stdio: normalizedOptions.stdio,
+        env: normalizedOptions.env,
+        maxBuffer: 1024 * 1024 * 10
+      }),
+      success: true
+    };
+  } catch (e) {
+    return {
+      output: e.message,
+      success: false
+    };
+  }
+}
+function cargoMetadata() {
+  const output = cargoCommandSync("metadata --format-version=1", {
+    stdio: "pipe"
+  });
+  if (!output.success) {
+    console.error("Failed to get cargo metadata");
+    return null;
+  }
+  return JSON.parse(output.output);
+}
+function isExternal(packageOrDep, workspaceRoot) {
+  const isRegistry = _nullishCoalesce(_optionalChain([packageOrDep, 'access', _9 => _9.source, 'optionalAccess', _10 => _10.startsWith, 'call', _11 => _11("registry+")]), () => ( false));
+  const isGit = _nullishCoalesce(_optionalChain([packageOrDep, 'access', _12 => _12.source, 'optionalAccess', _13 => _13.startsWith, 'call', _14 => _14("git+")]), () => ( false));
+  const isOutsideWorkspace = "path" in packageOrDep && _path.relative.call(void 0, workspaceRoot, packageOrDep.path).startsWith("..");
+  return isRegistry || isGit || isOutsideWorkspace;
+}
+function runProcess(workspaceRoot, processCmd, ...args) {
+  const metadata = cargoMetadata();
+  const targetDir = _nullishCoalesce(_optionalChain([metadata, 'optionalAccess', _15 => _15.target_directory]), () => ( _devkit.joinPathFragments.call(void 0, workspaceRoot, "dist")));
+  return new Promise((resolve) => {
+    if (process.env.VERCEL) {
+      return resolve({ success: true });
+    }
+    _child_process.execSync.call(void 0, `${processCmd} ${args.join(" ")}`, {
+      cwd: process.cwd(),
+      env: {
+        ...process.env,
+        RUSTC_WRAPPER: "",
+        CARGO_TARGET_DIR: targetDir,
+        CARGO_BUILD_TARGET_DIR: targetDir
+      },
+      windowsHide: true,
+      stdio: ["inherit", "inherit", "inherit"]
+    });
+    resolve({ success: true });
+  });
+}
+
+
+
+
+
+
+
+
+
+
+
+exports.INVALID_CARGO_ARGS = INVALID_CARGO_ARGS; exports.childProcess = childProcess; exports.buildCargoCommand = buildCargoCommand; exports.cargoCommand = cargoCommand; exports.cargoRunCommand = cargoRunCommand; exports.cargoCommandSync = cargoCommandSync; exports.cargoMetadata = cargoMetadata; exports.isExternal = isExternal; exports.runProcess = runProcess;

package/dist/chunk-34LSWMWV.mjs

@@ -0,0 +1,20 @@
+// src/base/base-generator.untyped.ts
+import { defineUntypedSchema } from "untyped";
+var base_generator_untyped_default = defineUntypedSchema({
+  $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"
+    }
+  }
+});
+
+export {
+  base_generator_untyped_default
+};

package/dist/chunk-3J2CP54B.mjs

@@ -0,0 +1,100 @@
+import {
+  correctPaths
+} from "./chunk-TBW5MCN6.mjs";
+
+// ../config-tools/src/utilities/find-up.ts
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+var MAX_PATH_SEARCH_DEPTH = 30;
+var depth = 0;
+function findFolderUp(startPath, endFileNames = [], endDirectoryNames = []) {
+  const _startPath = startPath ?? process.cwd();
+  if (endDirectoryNames.some(
+    (endDirName) => existsSync(join(_startPath, endDirName))
+  )) {
+    return _startPath;
+  }
+  if (endFileNames.some((endFileName) => existsSync(join(_startPath, endFileName)))) {
+    return _startPath;
+  }
+  if (_startPath !== "/" && depth++ < MAX_PATH_SEARCH_DEPTH) {
+    const parent = join(_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 correctPaths(
+      process.env.STORM_WORKSPACE_ROOT ?? process.env.NX_WORKSPACE_ROOT_PATH
+    );
+  }
+  return correctPaths(
+    findFolderUp(
+      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;
+}
+
+export {
+  findWorkspaceRoot
+};

package/dist/chunk-3QM6CFXC.mjs

@@ -0,0 +1,49 @@
+import {
+  getWorkspaceConfig
+} from "./chunk-K7B3YICS.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-437WGH2M.mjs

@@ -0,0 +1,32 @@
+// src/generators/init/init.ts
+import {
+  addDependenciesToPackageJson,
+  formatFiles
+} from "@nx/devkit";
+async function initGenerator(tree, schema) {
+  const task = addDependenciesToPackageJson(
+    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 formatFiles(tree);
+  }
+  return task;
+}
+var init_default = initGenerator;
+
+export {
+  initGenerator,
+  init_default
+};

package/dist/chunk-46GNS53C.mjs

@@ -0,0 +1,110 @@
+import {
+  applyWorkspaceBaseTokens,
+  applyWorkspaceTokens
+} from "./chunk-2QMGYIOO.mjs";
+import {
+  getConfig
+} from "./chunk-K7B3YICS.mjs";
+import {
+  brandIcon,
+  getStopwatch,
+  writeDebug,
+  writeError,
+  writeFatal,
+  writeInfo,
+  writeSuccess,
+  writeTrace
+} from "./chunk-T55IDP24.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
+};