@storm-software/workspace-tools 1.267.19 → 1.267.21

package/dist/chunk-BNMJYJOZ.mjs

@@ -1,446 +0,0 @@
-import {
-  cargoMetadata,
-  isExternal
-} from "./chunk-62XRHQ44.mjs";
-import {
-  ProjectTagConstants,
-  addProjectTag,
-  setDefaultProjectTags
-} from "./chunk-JMCJJNBJ.mjs";
-import {
-  __name
-} from "./chunk-L2DHGVS5.mjs";
-
-// src/plugins/rust/cargo-toml.ts
-import { createNodesFromFiles, joinPathFragments, readJsonFile, workspaceRoot } from "@nx/devkit";
-import { existsSync } from "node:fs";
-import { dirname } from "node:path";
-import { DependencyType } from "nx/src/config/project-graph";
-var name = "storm-software/rust";
-var description = "Plugin for parsing Cargo.toml files";
-var DefaultCargoPluginProfileMap = {
-  development: "dev",
-  production: "prod"
-};
-var DEFAULT_ERROR_MESSAGE = "An error occurred in the Storm Rust Nx plugin.";
-var createNodesV2 = [
-  "*/**/Cargo.toml",
-  async (configFiles, options, context) => {
-    return await createNodesFromFiles((configFile, options2, context2) => {
-      try {
-        console.log(`Processing Cargo.toml file: ${configFile}`);
-        const profiles = options2?.profiles ?? {};
-        const includeApps = options2?.includeApps ?? true;
-        const toolchain = options2?.toolchain;
-        const skipDocs = options2?.skipDocs ?? false;
-        const metadata = cargoMetadata();
-        if (!metadata) {
-          return {};
-        }
-        const { packages: cargoPackages } = metadata;
-        const externalNodes = {};
-        const projects = {};
-        const profs = {
-          ...DefaultCargoPluginProfileMap,
-          ...profiles
-        };
-        const configurations = Object.keys(profs).reduce((ret, key) => {
-          ret[key] = {
-            profile: profs[key]
-          };
-          return ret;
-        }, {});
-        const cargoPackageMap = cargoPackages.reduce((acc, p) => {
-          if (!acc.has(p.name)) {
-            acc.set(p.name, p);
-          }
-          return acc;
-        }, /* @__PURE__ */ new Map());
-        for (const cargoPackage of cargoPackages) {
-          if (!isExternal(cargoPackage, context2.workspaceRoot)) {
-            const root = dirname(configFile);
-            const project = {
-              root,
-              name: cargoPackage.name
-            };
-            if (existsSync(joinPathFragments(root, "project.json"))) {
-              const projectJson = readJsonFile(joinPathFragments(root, "project.json"));
-              if (projectJson) {
-                Object.keys(projectJson).forEach((key) => {
-                  if (!project[key]) {
-                    project[key] = projectJson[key];
-                  }
-                });
-              }
-            }
-            if (includeApps === false && project.projectType === "application") {
-              continue;
-            }
-            project.targets = {
-              "lint-markdown": {
-                cache: true,
-                outputs: [
-                  "{projectRoot}/**/*.md",
-                  "{projectRoot}/**/*.mdx"
-                ],
-                inputs: [
-                  "linting",
-                  "{projectRoot}/**/*.md",
-                  "{projectRoot}/**/*.mdx"
-                ],
-                dependsOn: [
-                  "^lint-markdown"
-                ],
-                executor: "nx:run-commands",
-                options: {
-                  command: 'pnpm exec markdownlint-cli2 "{projectRoot}/*.{md,mdx}" "{projectRoot}/**/*.{md,mdx}" --config "node_modules/@storm-software/markdownlint/config/base.markdownlint-cli2.jsonc" --fix'
-                }
-              },
-              "lint-ls": {
-                cache: true,
-                inputs: [
-                  "linting",
-                  "rust",
-                  "^production"
-                ],
-                dependsOn: [
-                  "^lint-ls"
-                ],
-                options: {
-                  command: 'pnpm exec ls-lint --config="./node_modules/@storm-software/linting-tools/ls-lint/.ls-lint.yml" ',
-                  color: true
-                }
-              },
-              lint: {
-                cache: true,
-                inputs: [
-                  "linting",
-                  "rust",
-                  "^production"
-                ],
-                dependsOn: [
-                  "lint-ls",
-                  "lint-markdown",
-                  "^lint"
-                ],
-                executor: "@storm-software/workspace-tools:cargo-clippy",
-                options: {
-                  toolchain,
-                  fix: false
-                },
-                defaultConfiguration: "development",
-                configurations
-              },
-              check: {
-                cache: true,
-                inputs: [
-                  "linting",
-                  "rust",
-                  "^production"
-                ],
-                dependsOn: [
-                  "lint",
-                  "^check"
-                ],
-                executor: "@storm-software/workspace-tools:cargo-check",
-                options: {
-                  toolchain
-                },
-                defaultConfiguration: "development",
-                configurations
-              },
-              "format-readme": {
-                cache: true,
-                inputs: [
-                  "linting",
-                  "documentation",
-                  "{projectRoot}/{README.md,package.json,Cargo.toml,executors.json,generators.json}"
-                ],
-                outputs: [
-                  "{projectRoot}/README.md"
-                ],
-                dependsOn: [
-                  "^format-readme"
-                ],
-                executor: "nx:run-commands",
-                options: {
-                  command: 'pnpm exec storm-git readme --templates="tools/readme-templates" --project="{projectName}"'
-                }
-              },
-              "format-toml": {
-                cache: true,
-                inputs: [
-                  "linting",
-                  "{projectRoot}/**/*.toml"
-                ],
-                outputs: [
-                  "{projectRoot}/**/*.toml"
-                ],
-                dependsOn: [
-                  "^format-toml"
-                ],
-                executor: "nx:run-commands",
-                options: {
-                  command: 'pnpm exec taplo format --config="node_modules/@storm-software/linting-tools/taplo/config.toml" --cache-path="node_modules/.cache/taplo/{projectRoot}" --colors="always" "{projectRoot}/*.toml" "{projectRoot}/**/*.toml" '
-                }
-              },
-              "format-clippy": {
-                cache: true,
-                inputs: [
-                  "linting",
-                  "rust",
-                  "^production"
-                ],
-                dependsOn: [
-                  "^format-clippy"
-                ],
-                executor: "@storm-software/workspace-tools:cargo-clippy",
-                options: {
-                  toolchain,
-                  fix: true
-                },
-                defaultConfiguration: "development",
-                configurations
-              },
-              format: {
-                cache: true,
-                inputs: [
-                  "linting",
-                  "documentation",
-                  "rust",
-                  "^production"
-                ],
-                dependsOn: [
-                  "format-readme",
-                  "format-clippy",
-                  "format-toml",
-                  "^format"
-                ],
-                executor: "@storm-software/workspace-tools:cargo-format",
-                options: {
-                  toolchain,
-                  fix: true
-                },
-                defaultConfiguration: "development",
-                configurations
-              },
-              clean: {
-                cache: true,
-                inputs: [
-                  "rust",
-                  "^production"
-                ],
-                outputs: [
-                  `{workspaceRoot}/dist/target/{projectRoot}`
-                ],
-                executor: "nx:run-commands",
-                options: {
-                  command: `pnpm exec rimraf dist/target/crates/${cargoPackage.name}`,
-                  color: true,
-                  cwd: "{workspaceRoot}"
-                }
-              },
-              build: {
-                cache: true,
-                inputs: [
-                  "rust",
-                  "^production"
-                ],
-                dependsOn: [
-                  "build-base",
-                  "^build"
-                ],
-                executor: "@storm-software/workspace-tools:cargo-build",
-                outputs: [
-                  `{workspaceRoot}/dist/target/{projectRoot}`
-                ],
-                options: {
-                  toolchain
-                },
-                defaultConfiguration: "development",
-                configurations
-              },
-              rebuild: {
-                cache: false,
-                inputs: [
-                  "rust",
-                  "^production"
-                ],
-                dependsOn: [
-                  "clean",
-                  "^build"
-                ],
-                executor: "@storm-software/workspace-tools:cargo-build",
-                outputs: [
-                  `{workspaceRoot}/dist/target/{projectRoot}`
-                ],
-                options: {
-                  toolchain
-                },
-                defaultConfiguration: "development",
-                configurations
-              },
-              test: {
-                cache: true,
-                inputs: [
-                  "testing",
-                  "rust",
-                  "^production"
-                ],
-                dependsOn: [
-                  "build",
-                  "^test"
-                ],
-                executor: "@monodon/rust:test",
-                outputs: [
-                  "{options.target-dir}"
-                ],
-                options: {
-                  "target-dir": `{workspaceRoot}/dist/target/{projectRoot}`
-                },
-                defaultConfiguration: "development",
-                configurations
-              }
-            };
-            if (skipDocs != true) {
-              project.targets.docs = {
-                cache: true,
-                inputs: [
-                  "linting",
-                  "documentation",
-                  "default",
-                  "^production"
-                ],
-                dependsOn: [
-                  "format-readme",
-                  "lint-docs",
-                  "^docs"
-                ],
-                outputs: [
-                  `{workspaceRoot}/dist/docs/{projectRoot}`
-                ],
-                executor: "@storm-software/workspace-tools:cargo-doc",
-                options: {
-                  toolchain
-                },
-                defaultConfiguration: "production",
-                configurations
-              };
-            }
-            if (cargoPackage.publish === null || cargoPackage.publish === void 0 || cargoPackage.publish === true || Array.isArray(cargoPackage.publish) && cargoPackage.publish.length > 0) {
-              addProjectTag(project, ProjectTagConstants.Registry.TAG_ID, ProjectTagConstants.Registry.CARGO, {
-                overwrite: true
-              });
-              project.targets["nx-release-publish"] = {
-                cache: true,
-                inputs: [
-                  "linting",
-                  "testing",
-                  "documentation",
-                  "rust",
-                  "^production"
-                ],
-                dependsOn: [
-                  "build",
-                  "^nx-release-publish"
-                ],
-                executor: "@storm-software/workspace-tools:cargo-publish",
-                options: {
-                  packageRoot: root
-                },
-                defaultConfiguration: "production",
-                configurations
-              };
-            }
-            addProjectTag(project, ProjectTagConstants.Language.TAG_ID, ProjectTagConstants.Language.RUST, {
-              overwrite: true
-            });
-            setDefaultProjectTags(project, name);
-            projects[root] = {
-              ...project,
-              release: {
-                ...project.release,
-                version: {
-                  ...project.release?.version,
-                  generator: "@storm-software/workspace-tools:release-version"
-                }
-              }
-            };
-          }
-          for (const dep of cargoPackage.dependencies) {
-            if (isExternal(dep, context2.workspaceRoot)) {
-              const externalDepName = `cargo:${dep.name}`;
-              if (!externalNodes?.[externalDepName]) {
-                externalNodes[externalDepName] = {
-                  type: "cargo",
-                  name: externalDepName,
-                  data: {
-                    packageName: dep.name,
-                    version: cargoPackageMap.get(dep.name)?.version ?? "0.0.0"
-                  }
-                };
-              }
-            }
-          }
-        }
-        return {
-          projects,
-          externalNodes
-        };
-      } catch (e) {
-        console.error(DEFAULT_ERROR_MESSAGE);
-        console.error(e);
-        throw new Error(DEFAULT_ERROR_MESSAGE, {
-          cause: e
-        });
-      }
-    }, configFiles, options, context);
-  }
-];
-var createDependencies = /* @__PURE__ */ __name((_, context) => {
-  const metadata = cargoMetadata();
-  if (!metadata) {
-    return [];
-  }
-  const { packages: cargoPackages } = metadata;
-  const dependencies = [];
-  for (const pkg of cargoPackages) {
-    if (context.projects[pkg.name]) {
-      console.debug(`Local Cargo package found: ${pkg.name}`);
-      for (const deps of pkg.dependencies) {
-        if (!cargoPackages.find((p) => p.name === deps.name)) {
-          console.debug(`Dependency ${deps.name} not found in the cargo metadata.`);
-          continue;
-        }
-        if (context.projects[deps.name]) {
-          dependencies.push(createDependency(pkg, deps.name, DependencyType.static));
-        } else {
-          const externalDepName = `cargo:${deps.name}`;
-          if (externalDepName in (context.externalNodes ?? {})) {
-            dependencies.push(createDependency(pkg, externalDepName, DependencyType.static));
-          }
-        }
-      }
-    }
-  }
-  return dependencies;
-}, "createDependencies");
-function createDependency(pkg, depName, type) {
-  const target = pkg.manifest_path.replace(/\\/g, "/");
-  return {
-    type,
-    source: pkg.name,
-    target: depName,
-    sourceFile: target.replace(`${workspaceRoot.replace(/\\/g, "/")}/`, "")
-  };
-}
-__name(createDependency, "createDependency");
-
-export {
-  name,
-  description,
-  DefaultCargoPluginProfileMap,
-  DEFAULT_ERROR_MESSAGE,
-  createNodesV2,
-  createDependencies
-};

package/dist/chunk-CUWWZLK7.mjs

@@ -1,37 +0,0 @@
-import {
-  ProjectTagConstants,
-  isEqualProjectTag
-} from "./chunk-JMCJJNBJ.mjs";
-import {
-  parseCargoToml
-} from "./chunk-H72YBOLR.mjs";
-import {
-  __name
-} from "./chunk-L2DHGVS5.mjs";
-
-// src/utils/package-helpers.ts
-import { joinPathFragments, readJsonFile } from "@nx/devkit";
-import { existsSync } from "node:fs";
-var PackageManagerTypes = {
-  PackageJson: "package.json",
-  CargoToml: "Cargo.toml"
-};
-var getPackageInfo = /* @__PURE__ */ __name((project) => {
-  if (isEqualProjectTag(project, ProjectTagConstants.Language.TAG_ID, ProjectTagConstants.Language.RUST) && existsSync(joinPathFragments(project.root, "Cargo.toml"))) {
-    return {
-      type: "Cargo.toml",
-      content: parseCargoToml(joinPathFragments(project.root, "Cargo.toml"))
-    };
-  } else if (isEqualProjectTag(project, ProjectTagConstants.Language.TAG_ID, ProjectTagConstants.Language.TYPESCRIPT) && existsSync(joinPathFragments(project.root, "package.json"))) {
-    return {
-      type: "package.json",
-      content: readJsonFile(joinPathFragments(project.root, "package.json"))
-    };
-  }
-  return null;
-}, "getPackageInfo");
-
-export {
-  PackageManagerTypes,
-  getPackageInfo
-};

package/dist/chunk-HOXPAVCL.js

@@ -1,32 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-
-var _chunkULBTYC2Bjs = require('./chunk-ULBTYC2B.js');
-
-
-var _chunk6CGAYKQLjs = require('./chunk-6CGAYKQL.js');
-
-
-var _chunk3GQAWCBQjs = require('./chunk-3GQAWCBQ.js');
-
-// src/executors/cargo-format/executor.ts
-async function cargoFormatExecutor(options, context) {
-  const command = _chunkULBTYC2Bjs.buildCargoCommand.call(void 0, "fmt", options, context);
-  return await _chunkULBTYC2Bjs.cargoCommand.call(void 0, ...command);
-}
-_chunk3GQAWCBQjs.__name.call(void 0, cargoFormatExecutor, "cargoFormatExecutor");
-var executor_default = _chunk6CGAYKQLjs.withRunExecutor.call(void 0, "Cargo Format", cargoFormatExecutor, {
-  skipReadingConfig: false,
-  hooks: {
-    applyDefaultOptions: /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, (options) => {
-      options.outputPath ??= "dist/target/{projectRoot}";
-      options.toolchain ??= "stable";
-      return options;
-    }, "applyDefaultOptions")
-  }
-});
-
-
-
-
-exports.cargoFormatExecutor = cargoFormatExecutor; exports.executor_default = executor_default;

package/dist/chunk-ICPUM2HS.js

@@ -1,50 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-var _chunk6CGAYKQLjs = require('./chunk-6CGAYKQL.js');
-
-
-var _chunkG4QFSE5Bjs = require('./chunk-G4QFSE5B.js');
-
-
-var _chunk3GQAWCBQjs = require('./chunk-3GQAWCBQ.js');
-
-// src/executors/typia/executor.ts
-var _fsextra = require('fs-extra');
-var _TypiaProgrammerjs = require('typia/lib/programmers/TypiaProgrammer.js');
-async function typiaExecutorFn(options, _, config) {
-  if (options.clean !== false) {
-    _chunkG4QFSE5Bjs.writeInfo.call(void 0, `\u{1F9F9} Cleaning output path: ${options.outputPath}`, config);
-    _fsextra.removeSync.call(void 0, options.outputPath);
-  }
-  await Promise.all(options.entry.map((entry) => {
-    _chunkG4QFSE5Bjs.writeInfo.call(void 0, `\u{1F680} Running Typia on entry: ${entry}`, config);
-    return _TypiaProgrammerjs.TypiaProgrammer.build({
-      input: entry,
-      output: options.outputPath,
-      project: options.tsconfig
-    });
-  }));
-  return {
-    success: true
-  };
-}
-_chunk3GQAWCBQjs.__name.call(void 0, typiaExecutorFn, "typiaExecutorFn");
-var executor_default = _chunk6CGAYKQLjs.withRunExecutor.call(void 0, "Typia runtime validation generator", typiaExecutorFn, {
-  skipReadingConfig: false,
-  hooks: {
-    applyDefaultOptions: /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, (options) => {
-      options.entry ??= [
-        "{sourceRoot}/index.ts"
-      ];
-      options.outputPath ??= "{sourceRoot}/__generated__/typia";
-      options.tsconfig ??= "{projectRoot}/tsconfig.json";
-      options.clean ??= true;
-      return options;
-    }, "applyDefaultOptions")
-  }
-});
-
-
-
-
-exports.typiaExecutorFn = typiaExecutorFn; exports.executor_default = executor_default;

package/dist/chunk-JJ4PSTY4.mjs

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

package/dist/chunk-JMCJJNBJ.mjs

@@ -1,102 +0,0 @@
-import {
-  __name
-} from "./chunk-L2DHGVS5.mjs";
-
-// src/utils/project-tags.ts
-var ProjectTagConstants = {
-  Language: {
-    TAG_ID: "language",
-    TYPESCRIPT: "typescript",
-    RUST: "rust"
-  },
-  ProjectType: {
-    TAG_ID: "type",
-    LIBRARY: "library",
-    APPLICATION: "application"
-  },
-  DistStyle: {
-    TAG_ID: "dist-style",
-    NORMAL: "normal",
-    CLEAN: "clean"
-  },
-  Provider: {
-    TAG_ID: "provider"
-  },
-  Platform: {
-    TAG_ID: "platform",
-    NODE: "node",
-    BROWSER: "browser",
-    NEUTRAL: "neutral",
-    WORKER: "worker"
-  },
-  Registry: {
-    TAG_ID: "registry",
-    CARGO: "cargo",
-    NPM: "npm",
-    CONTAINER: "container",
-    CYCLONE: "cyclone"
-  },
-  Plugin: {
-    TAG_ID: "plugin"
-  }
-};
-var formatProjectTag = /* @__PURE__ */ __name((variant, value) => {
-  return `${variant}:${value}`;
-}, "formatProjectTag");
-var hasProjectTag = /* @__PURE__ */ __name((project, variant) => {
-  project.tags = project.tags ?? [];
-  const prefix = formatProjectTag(variant, "");
-  return project.tags.some((tag) => tag.startsWith(prefix) && tag.length > prefix.length);
-}, "hasProjectTag");
-var getProjectTag = /* @__PURE__ */ __name((project, variant) => {
-  if (!hasProjectTag(project, variant)) {
-    return void 0;
-  }
-  project.tags = project.tags ?? [];
-  const prefix = formatProjectTag(variant, "");
-  const tag = project.tags.find((tag2) => tag2.startsWith(prefix));
-  return tag?.replace(prefix, "");
-}, "getProjectTag");
-var isEqualProjectTag = /* @__PURE__ */ __name((project, variant, value) => {
-  const tag = getProjectTag(project, variant);
-  return !!(tag && tag?.toUpperCase() === value.toUpperCase());
-}, "isEqualProjectTag");
-var addProjectTag = /* @__PURE__ */ __name((project, variant, value, options = {
-  overwrite: false
-}) => {
-  project.tags = project.tags ?? [];
-  if (options.overwrite || !hasProjectTag(project, variant)) {
-    project.tags = project.tags.filter((tag) => !tag.startsWith(formatProjectTag(variant, "")));
-    project.tags.push(formatProjectTag(variant, value));
-  }
-}, "addProjectTag");
-var addPluginProjectTag = /* @__PURE__ */ __name((project, plugin) => {
-  project.tags = project.tags ?? [];
-  project.tags.push(formatProjectTag(ProjectTagConstants.Plugin.TAG_ID, plugin));
-}, "addPluginProjectTag");
-var setDefaultProjectTags = /* @__PURE__ */ __name((project, plugin) => {
-  project.tags = project.tags ?? [];
-  addProjectTag(project, ProjectTagConstants.ProjectType.TAG_ID, project.projectType === "application" ? ProjectTagConstants.ProjectType.APPLICATION : ProjectTagConstants.ProjectType.LIBRARY, {
-    overwrite: true
-  });
-  addProjectTag(project, ProjectTagConstants.DistStyle.TAG_ID, project.targets && Object.keys(project.targets).includes("clean-package") ? ProjectTagConstants.DistStyle.CLEAN : ProjectTagConstants.DistStyle.NORMAL, {
-    overwrite: true
-  });
-  addProjectTag(project, ProjectTagConstants.Platform.TAG_ID, project.targets?.build?.options.platform === "node" ? ProjectTagConstants.Platform.NODE : project.targets?.build?.options.platform === "worker" ? ProjectTagConstants.Platform.WORKER : project.targets?.build?.options.platform === "browser" ? ProjectTagConstants.Platform.BROWSER : ProjectTagConstants.Platform.NEUTRAL, {
-    overwrite: false
-  });
-  if (plugin) {
-    addPluginProjectTag(project, plugin);
-  }
-}, "setDefaultProjectTags");
-
-export {
-  ProjectTagConstants,
-  formatProjectTag,
-  hasProjectTag,
-  getProjectTag,
-  isEqualProjectTag,
-  addProjectTag,
-  addPluginProjectTag,
-  setDefaultProjectTags
-};