@storm-software/workspace-tools 1.228.0 → 1.229.0

package/dist/chunk-PY52QA2R.js

@@ -0,0 +1,130 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunk3GQAWCBQjs = require('./chunk-3GQAWCBQ.js');
+
+// src/utils/lock-file.ts
+var _fs = require('fs');
+var _path = require('path');
+var _devkitexports = require('nx/src/devkit-exports');
+var _npmparser = require('nx/src/plugins/js/lock-file/npm-parser');
+var _pnpmparser = require('nx/src/plugins/js/lock-file/pnpm-parser');
+var _yarnparser = require('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 = _path.join.call(void 0, _devkitexports.workspaceRoot, YARN_LOCK_FILE);
+var NPM_LOCK_PATH = _path.join.call(void 0, _devkitexports.workspaceRoot, NPM_LOCK_FILE);
+var PNPM_LOCK_PATH = _path.join.call(void 0, _devkitexports.workspaceRoot, PNPM_LOCK_FILE);
+function getLockFileNodes(packageManager, contents, lockFileHash, context) {
+  try {
+    if (packageManager === "yarn") {
+      const packageJson = _devkitexports.readJsonFile.call(void 0, _path.join.call(void 0, context.workspaceRoot, "package.json"));
+      return _yarnparser.getYarnLockfileNodes.call(void 0, contents, lockFileHash, packageJson);
+    }
+    if (packageManager === "pnpm") {
+      return _pnpmparser.getPnpmLockfileNodes.call(void 0, contents, lockFileHash);
+    }
+    if (packageManager === "npm") {
+      return _npmparser.getNpmLockfileNodes.call(void 0, contents, lockFileHash);
+    }
+  } catch (e) {
+    if (!isPostInstallProcess()) {
+      _devkitexports.output.error({
+        title: `Failed to parse ${packageManager} lockfile`,
+        bodyLines: errorBodyLines(e)
+      });
+    }
+    throw e;
+  }
+  throw new Error(`Unknown package manager: ${packageManager}`);
+}
+_chunk3GQAWCBQjs.__name.call(void 0, getLockFileNodes, "getLockFileNodes");
+function getLockFileDependencies(packageManager, contents, lockFileHash, context) {
+  try {
+    if (packageManager === "yarn") {
+      return _yarnparser.getYarnLockfileDependencies.call(void 0, contents, lockFileHash, context);
+    }
+    if (packageManager === "pnpm") {
+      return _pnpmparser.getPnpmLockfileDependencies.call(void 0, contents, lockFileHash, context);
+    }
+    if (packageManager === "npm") {
+      return _npmparser.getNpmLockfileDependencies.call(void 0, contents, lockFileHash, context);
+    }
+  } catch (e) {
+    if (!isPostInstallProcess()) {
+      _devkitexports.output.error({
+        title: `Failed to parse ${packageManager} lockfile`,
+        bodyLines: errorBodyLines(e)
+      });
+    }
+    throw e;
+  }
+  throw new Error(`Unknown package manager: ${packageManager}`);
+}
+_chunk3GQAWCBQjs.__name.call(void 0, getLockFileDependencies, "getLockFileDependencies");
+function lockFileExists(packageManager) {
+  if (packageManager === "yarn") {
+    return _fs.existsSync.call(void 0, YARN_LOCK_PATH);
+  }
+  if (packageManager === "pnpm") {
+    return _fs.existsSync.call(void 0, PNPM_LOCK_PATH);
+  }
+  if (packageManager === "npm") {
+    return _fs.existsSync.call(void 0, NPM_LOCK_PATH);
+  }
+  throw new Error(`Unknown package manager ${packageManager} or lock file missing`);
+}
+_chunk3GQAWCBQjs.__name.call(void 0, lockFileExists, "lockFileExists");
+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}`);
+}
+_chunk3GQAWCBQjs.__name.call(void 0, getLockFileName, "getLockFileName");
+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;
+}
+_chunk3GQAWCBQjs.__name.call(void 0, errorBodyLines, "errorBodyLines");
+function isPostInstallProcess() {
+  return process.env.npm_command === "install" && process.env.npm_lifecycle_event === "postinstall";
+}
+_chunk3GQAWCBQjs.__name.call(void 0, isPostInstallProcess, "isPostInstallProcess");
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.YARN_LOCK_FILE = YARN_LOCK_FILE; exports.NPM_LOCK_FILE = NPM_LOCK_FILE; exports.PNPM_LOCK_FILE = PNPM_LOCK_FILE; exports.LOCK_FILES = LOCK_FILES; exports.YARN_LOCK_PATH = YARN_LOCK_PATH; exports.NPM_LOCK_PATH = NPM_LOCK_PATH; exports.PNPM_LOCK_PATH = PNPM_LOCK_PATH; exports.getLockFileNodes = getLockFileNodes; exports.getLockFileDependencies = getLockFileDependencies; exports.lockFileExists = lockFileExists; exports.getLockFileName = getLockFileName;

package/dist/chunk-QMJ7P54Z.mjs

@@ -0,0 +1,241 @@
+import {
+  nodeVersion,
+  pnpmVersion
+} from "./chunk-EK75QNMS.mjs";
+import {
+  withRunGenerator
+} from "./chunk-B3KIYNGT.mjs";
+import {
+  __dirname,
+  __name
+} from "./chunk-XUV4U54K.mjs";
+
+// src/generators/preset/generator.ts
+import { addDependenciesToPackageJson, addProjectConfiguration, formatFiles, generateFiles, joinPathFragments, updateJson } from "@nx/devkit";
+import * as path from "node:path";
+async function presetGeneratorFn(tree, options) {
+  const projectRoot = ".";
+  options.description ??= `\u26A1The ${options.namespace ? options.namespace : options.name} monorepo contains utility applications, tools, and various libraries to create modern and scalable web applications.`;
+  options.namespace ??= options.organization;
+  addProjectConfiguration(tree, `@${options.namespace}/${options.name}`, {
+    root: projectRoot,
+    projectType: "application",
+    targets: {
+      "local-registry": {
+        executor: "@nx/js:verdaccio",
+        options: {
+          port: 4873,
+          config: ".verdaccio/config.yml",
+          storage: "tmp/local-registry/storage"
+        }
+      }
+    }
+  });
+  updateJson(tree, "package.json", (json) => {
+    json.scripts = json.scripts || {};
+    json.version = "0.0.0";
+    json.triggerEmptyDevReleaseByIncrementingThisNumber = 0;
+    json.private = true;
+    json.keywords ??= [
+      options.name,
+      options.namespace,
+      "storm",
+      "storm-stack",
+      "storm-ops",
+      "acidic",
+      "acidic-engine",
+      "cyclone-ui",
+      "rust",
+      "nx",
+      "graphql",
+      "sullivanpj",
+      "monorepo"
+    ];
+    json.homepage ??= "https://stormsoftware.com";
+    json.bugs ??= {
+      url: `https://github.com/${options.organization}/${options.name}/issues`,
+      email: "support@stormsoftware.com"
+    };
+    json.license = "Apache-2.0";
+    json.author ??= {
+      name: "Storm Software",
+      email: "contact@stormsoftware.com",
+      url: "https://stormsoftware.com"
+    };
+    json.maintainers ??= [
+      {
+        "name": "Storm Software",
+        "email": "contact@stormsoftware.com",
+        "url": "https://stormsoftware.com"
+      },
+      {
+        "name": "Pat Sullivan",
+        "email": "admin@stormsoftware.com",
+        "url": "https://patsullivan.org"
+      }
+    ];
+    json.funding ??= {
+      type: "github",
+      url: "https://github.com/sponsors/storm-software"
+    };
+    json.namespace ??= `@${options.namespace}`;
+    json.description ??= options.description;
+    options.repositoryUrl ??= `https://github.com/${options.organization}/${options.name}`;
+    json.repository ??= {
+      type: "github",
+      url: `${options.repositoryUrl}.git`
+    };
+    json.packageManager ??= "pnpm@9.15.2";
+    json.engines ??= {
+      "node": ">=20.11.0",
+      "pnpm": ">=9.15.2"
+    };
+    json.prettier = "@storm-software/prettier/config.json";
+    json.nx ??= {
+      "includedScripts": [
+        "lint-sherif",
+        "lint-knip",
+        "lint-ls",
+        "lint",
+        "format",
+        "format-sherif",
+        "format-readme",
+        "format-prettier",
+        "format-toml",
+        "commit",
+        "release"
+      ]
+    };
+    json.scripts.adr = "pnpm log4brains adr new";
+    json.scripts["adr-preview"] = "pnpm log4brains preview";
+    json.scripts.prepare = "pnpm add lefthook -w && pnpm lefthook install";
+    json.scripts.preinstall = "npx -y only-allow pnpm";
+    json.scripts["install-csb"] = "corepack enable && pnpm install --no-frozen-lockfile";
+    json.scripts.clean = "rimraf dist && rimraf --glob packages/**/dist && rimraf --glob tools/**/dist && rimraf --glob docs/**/dist && rimraf --glob apps/**/dist && rimraf --glob libs/**/dist";
+    json.scripts.nuke = "nx clear-cache && rimraf .nx/cache && rimraf .nx/workspace-data && pnpm clean && rimraf pnpm-lock.yaml && rimraf --glob packages/**/node_modules && rimraf --glob tools/**/node_modules && rimraf node_modules";
+    json.scripts.prebuild = "pnpm clean";
+    json.scripts.build = "nx affected -t build --parallel=5";
+    json.scripts["build-all"] = "nx run-many -t build --all --parallel=5";
+    json.scripts["build-prod"] = "nx run-many -t build --all --prod --parallel=5";
+    json.scripts["build-tools"] = "nx run-many -t build --projects=tools/* --parallel=5";
+    json.scripts["build-docs"] = "nx run-many -t build --projects=docs/* --parallel=5";
+    if (!options.includeApps) {
+      json.scripts["build-packages"] = "nx run-many -t build --projects=packages/* --parallel=5";
+    } else {
+      json.scripts["build-apps"] = "nx run-many -t build --projects=apps/* --parallel=5";
+      json.scripts["build-libs"] = "nx run-many -t build --projects=libs/* --parallel=5";
+      json.scripts["build-storybook"] = "storybook build -s public";
+    }
+    json.scripts.nx = "nx";
+    json.scripts.graph = "nx graph";
+    json.scripts.lint = "pnpm storm-lint all --skip-cspell --skip-alex";
+    if (options.includeApps) {
+      json.scripts.start = "nx serve";
+      json.scripts.storybook = "pnpm storybook dev -p 6006";
+    }
+    json.scripts.help = "nx help";
+    json.scripts["dep-graph"] = "nx dep-graph";
+    json.scripts["local-registry"] = `nx local-registry @${options.namespace}/${options.name}`;
+    json.scripts.e2e = "nx e2e";
+    if (options.includeApps) {
+      json.scripts.test = "nx test && pnpm test-storybook";
+      json.scripts["test-storybook"] = "pnpm test-storybook";
+    } else {
+      json.scripts.test = "nx test";
+    }
+    json.scripts.lint = "pnpm storm-lint all --skip-cspell --skip-alex";
+    json.scripts.commit = "pnpm storm-git commit";
+    json.scripts["api-extractor"] = 'pnpm storm-docs api-extractor --outputPath="docs/api-reference" --clean';
+    json.scripts.release = "pnpm storm-git release";
+    json.scripts.format = "nx format:write";
+    json.scripts["format-sherif"] = "pnpm exec sherif -f -i typescript -i react -i react-dom";
+    json.scripts["format-toml"] = 'pnpm exec taplo format --config="./node_modules/@storm-software/linting-tools/taplo/config.toml" --cache-path="./node_modules/.cache/storm/taplo"';
+    json.scripts["format-readme"] = 'pnpm storm-git readme --templates="tools/readme-templates"';
+    json.scripts["format-prettier"] = "pnpm exec prettier --write --ignore-unknown --no-error-on-unmatched-pattern --cache && git update-index";
+    json.scripts.lint = "pnpm storm-lint all --skip-cspell";
+    json.scripts["lint-knip"] = "pnpm exec knip";
+    json.scripts["lint-sherif"] = "pnpm exec sherif -i typescript -i react -i react-dom";
+    json.scripts["lint-ls"] = 'pnpm exec ls-lint --config="./node_modules/@storm-software/linting-tools/ls-lint/ls-lint.yml"';
+    json.packageManager ??= `pnpm@${pnpmVersion}`;
+    json.engines = {
+      node: `>=${nodeVersion}`,
+      pnpm: `>=${pnpmVersion}`
+    };
+    return json;
+  });
+  generateFiles(tree, path.join(__dirname, "files"), projectRoot, {
+    ...options,
+    pnpmVersion,
+    nodeVersion
+  });
+  await formatFiles(tree);
+  let dependencies = {
+    "@ls-lint/ls-lint": "2.2.3",
+    "@ltd/j-toml": "1.38.0",
+    "@nx/devkit": "^20.2.2",
+    "@nx/eslint-plugin": "^20.2.2",
+    "@nx/js": "^20.2.2",
+    "@nx/workspace": "^20.2.2",
+    "@storm-software/config": "latest",
+    "@storm-software/git-tools": "latest",
+    "@storm-software/linting-tools": "latest",
+    "@storm-software/testing-tools": "latest",
+    "@storm-software/workspace-tools": "latest",
+    "@storm-software/eslint": "latest",
+    "@storm-software/cspell": "latest",
+    "@storm-software/prettier": "latest",
+    "@taplo/cli": "0.7.0",
+    "@types/node": "^20.14.10",
+    "copyfiles": "2.4.1",
+    "eslint": "9.5.0",
+    "jest": "29.7.0",
+    "jest-environment-node": "29.7.0",
+    "knip": "5.25.2",
+    "lefthook": "1.6.18",
+    "nx": "^20.2.2",
+    "prettier": "3.3.2",
+    "prettier-plugin-prisma": "5.0.0",
+    "rimraf": "5.0.7",
+    "sherif": "0.10.0",
+    "ts-jest": "29.1.5",
+    "ts-node": "10.9.2",
+    "tslib": "2.6.3",
+    "typescript": "5.5.3",
+    "verdaccio": "5.31.1"
+  };
+  if (options.includeApps) {
+    dependencies = {
+      ...dependencies,
+      react: "latest",
+      "react-dom": "latest",
+      storybook: "latest",
+      "@storybook/addons": "latest",
+      "@nx/react": "latest",
+      "@nx/next": "latest",
+      "@nx/node": "latest",
+      "@nx/storybook": "latest",
+      "jest-environment-jsdom": "29.7.0"
+    };
+  }
+  if (options.includeRust) {
+    dependencies = {
+      ...dependencies,
+      "@monodon/rust": "1.4.0"
+    };
+  }
+  if (options.nxCloud) {
+    dependencies = {
+      ...dependencies,
+      "nx-cloud": "latest"
+    };
+  }
+  await Promise.resolve(addDependenciesToPackageJson(tree, dependencies, {}, joinPathFragments(projectRoot, "package.json")));
+  return null;
+}
+__name(presetGeneratorFn, "presetGeneratorFn");
+var generator_default = withRunGenerator("Storm Workspace Preset Generator", presetGeneratorFn);
+
+export {
+  presetGeneratorFn,
+  generator_default
+};

package/dist/chunk-QZHIWK5Z.mjs

@@ -0,0 +1,190 @@
+import {
+  __name
+} from "./chunk-XUV4U54K.mjs";
+
+// src/utils/cargo.ts
+import { joinPathFragments, workspaceRoot } from "@nx/devkit";
+import { execSync, spawn } from "node:child_process";
+import { relative } from "node:path";
+var INVALID_CARGO_ARGS = [
+  "allFeatures",
+  "allTargets",
+  "main",
+  "outputPath",
+  "package",
+  "tsConfig"
+];
+var childProcess;
+var buildCargoCommand = /* @__PURE__ */ __name((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)) {
+    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}`, 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;
+}, "buildCargoCommand");
+async function cargoCommand(...args) {
+  console.log(`> cargo ${args.join(" ")}`);
+  args.push("--color", "always");
+  return await Promise.resolve(runProcess("cargo", ...args));
+}
+__name(cargoCommand, "cargoCommand");
+function cargoRunCommand(...args) {
+  console.log(`> cargo ${args.join(" ")}`);
+  return new Promise((resolve, reject) => {
+    childProcess = spawn("cargo", [
+      ...args,
+      "--color",
+      "always"
+    ], {
+      cwd: process.cwd(),
+      windowsHide: true,
+      detached: true,
+      shell: false,
+      stdio: [
+        "inherit",
+        "inherit",
+        "inherit"
+      ]
+    });
+    process.on("exit", () => childProcess?.kill());
+    process.on("SIGTERM", () => childProcess?.kill());
+    process.on("SIGINT", () => childProcess?.kill());
+    childProcess.on("error", (_err) => {
+      reject({
+        success: false
+      });
+    });
+    childProcess.on("exit", (code) => {
+      childProcess = null;
+      if (code === 0) {
+        resolve({
+          success: true
+        });
+      } else {
+        reject({
+          success: false
+        });
+      }
+    });
+  });
+}
+__name(cargoRunCommand, "cargoRunCommand");
+function cargoCommandSync(args = "", options) {
+  const normalizedOptions = {
+    stdio: options?.stdio ?? "inherit",
+    env: {
+      ...process.env,
+      ...options?.env
+    }
+  };
+  try {
+    return {
+      output: execSync(`cargo ${args}`, {
+        encoding: "utf8",
+        windowsHide: true,
+        stdio: normalizedOptions.stdio,
+        env: normalizedOptions.env,
+        maxBuffer: 1024 * 1024 * 10
+      }),
+      success: true
+    };
+  } catch (e) {
+    return {
+      output: e,
+      success: false
+    };
+  }
+}
+__name(cargoCommandSync, "cargoCommandSync");
+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);
+}
+__name(cargoMetadata, "cargoMetadata");
+function isExternal(packageOrDep, workspaceRoot2) {
+  const isRegistry = packageOrDep.source?.startsWith("registry+") ?? false;
+  const isGit = packageOrDep.source?.startsWith("git+") ?? false;
+  const isOutsideWorkspace = "path" in packageOrDep && relative(workspaceRoot2, packageOrDep.path).startsWith("..");
+  return isRegistry || isGit || isOutsideWorkspace;
+}
+__name(isExternal, "isExternal");
+function runProcess(processCmd, ...args) {
+  const metadata = cargoMetadata();
+  const targetDir = metadata?.target_directory ?? joinPathFragments(workspaceRoot, "dist", "cargo");
+  return new Promise((resolve) => {
+    if (process.env.VERCEL) {
+      return resolve({
+        success: true
+      });
+    }
+    execSync(`${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
+    });
+  });
+}
+__name(runProcess, "runProcess");
+
+export {
+  INVALID_CARGO_ARGS,
+  childProcess,
+  buildCargoCommand,
+  cargoCommand,
+  cargoRunCommand,
+  cargoCommandSync,
+  cargoMetadata,
+  isExternal,
+  runProcess
+};