@storm-software/workspace-tools 1.295.69 → 1.295.71

package/dist/chunk-BAPFD3TO.js

@@ -0,0 +1,79 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 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 _chunkTAP26ZJQjs = require('./chunk-TAP26ZJQ.js');
+
+// src/utils/plugin-helpers.ts
+
+
+var _devkit = require('@nx/devkit');
+var _defu = require('defu'); var _defu2 = _interopRequireDefault(_defu);
+var _fs = require('fs');
+var _path = require('path');
+function getProjectPlatform(project, ignoreTags = false) {
+  const tsconfigJson = _devkit.readJsonFile.call(void 0, _path.join.call(void 0, project.root, "tsconfig.json"));
+  if (!tsconfigJson) {
+    throw new Error(`No tsconfig.json found in project root: ${project.root}`);
+  }
+  const packageJson = _devkit.readJsonFile.call(void 0, _path.join.call(void 0, project.root, "package.json"));
+  if (!packageJson) {
+    throw new Error(`No package.json found in project root: ${project.root}`);
+  }
+  let platformTag = void 0;
+  if (!ignoreTags) {
+    platformTag = _chunkTAP26ZJQjs.getProjectTag.call(void 0, project, _chunkTAP26ZJQjs.ProjectTagConstants.Platform.TAG_ID);
+  }
+  if (platformTag !== _chunkTAP26ZJQjs.ProjectTagConstants.Platform.NEUTRAL) {
+    const types = Array.isArray(_optionalChain([tsconfigJson, 'access', _ => _.compilerOptions, 'optionalAccess', _2 => _2.types])) ? tsconfigJson.compilerOptions.types : [];
+    if (platformTag === _chunkTAP26ZJQjs.ProjectTagConstants.Platform.WORKER || types.some((type) => type.toLowerCase() === "@cloudflare/workers-types") || _optionalChain([packageJson, 'access', _3 => _3.devDependencies, 'optionalAccess', _4 => _4["@cloudflare/workers-types"]]) || _optionalChain([packageJson, 'access', _5 => _5.devDependencies, 'optionalAccess', _6 => _6["wrangler"]])) {
+      return "worker";
+    }
+    if (platformTag === _chunkTAP26ZJQjs.ProjectTagConstants.Platform.NODE || _optionalChain([types, 'optionalAccess', _7 => _7.some, 'call', _8 => _8((type) => type.toLowerCase() === "node")]) || _optionalChain([packageJson, 'access', _9 => _9.devDependencies, 'optionalAccess', _10 => _10["@types/node"]])) {
+      return "node";
+    }
+    if (platformTag === _chunkTAP26ZJQjs.ProjectTagConstants.Platform.BROWSER || _optionalChain([types, 'optionalAccess', _11 => _11.some, 'call', _12 => _12((type) => type.toLowerCase() === "dom")]) || packageJson.dependencies && Object.keys(packageJson.dependencies).some(
+      (dependency) => dependency.includes("react")
+    ) || packageJson.devDependencies && Object.keys(packageJson.devDependencies).some(
+      (devDependency) => devDependency.includes("react")
+    )) {
+      return "browser";
+    }
+  }
+  return "neutral";
+}
+function getProjectConfigFromProjectJsonPath(projectJsonPath, packageJson) {
+  return getProjectConfigFromProjectRoot(_path.dirname.call(void 0, projectJsonPath), packageJson);
+}
+function getProjectConfigFromProjectRoot(projectRoot, packageJson) {
+  const { nx, name } = packageJson;
+  const projectJson = _devkit.readJsonFile.call(void 0, _path.join.call(void 0, projectRoot, "project.json"));
+  return _defu2.default.call(void 0, _nullishCoalesce(nx, () => ( {})), projectJson, {
+    targets: {},
+    tags: [],
+    name,
+    root: projectRoot
+  });
+}
+function getProjectRoot(configPath, workspaceRoot) {
+  try {
+    const projectRoot = _path.dirname.call(void 0, configPath);
+    if (!_fs.existsSync.call(void 0, _path.join.call(void 0, workspaceRoot, projectRoot, "package.json")) && !_fs.existsSync.call(void 0, _path.join.call(void 0, workspaceRoot, projectRoot, "project.json"))) {
+      return null;
+    }
+    return projectRoot;
+  } catch (error_) {
+    console.error(error_);
+    return null;
+  }
+}
+function getRoot(projectRoot, context) {
+  return projectRoot.replaceAll("\\", "/").replace(context.workspaceRoot.replaceAll("\\", "/"), "").replace(/^\//g, "").replace(/\/$/g, "");
+}
+
+
+
+
+
+
+
+exports.getProjectPlatform = getProjectPlatform; exports.getProjectConfigFromProjectJsonPath = getProjectConfigFromProjectJsonPath; exports.getProjectConfigFromProjectRoot = getProjectConfigFromProjectRoot; exports.getProjectRoot = getProjectRoot; exports.getRoot = getRoot;

package/dist/chunk-BRMFLUTQ.js

@@ -0,0 +1,117 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 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 _chunk4ZQUYG5Tjs = require('./chunk-4ZQUYG5T.js');
+
+// src/executors/cargo-publish/executor.ts
+var _devkit = require('@nx/devkit');
+var _child_process = require('child_process');
+var _fs = require('fs');
+var _https = require('https'); var _https2 = _interopRequireDefault(_https);
+var LARGE_BUFFER = 1024 * 1e6;
+async function runExecutor(options, context) {
+  const isDryRun = process.env.NX_DRY_RUN === "true" || options.dryRun || false;
+  if (!context.projectName) {
+    throw new Error("The executor requires a projectName.");
+  }
+  console.info(
+    `\u{1F680}  Running Storm Cargo Publish executor on the ${context.projectName} crate`
+  );
+  if (!context.projectName || !_optionalChain([context, 'access', _ => _.projectsConfigurations, 'optionalAccess', _2 => _2.projects]) || !context.projectsConfigurations.projects[context.projectName] || !_optionalChain([context, 'access', _3 => _3.projectsConfigurations, 'access', _4 => _4.projects, 'access', _5 => _5[context.projectName], 'optionalAccess', _6 => _6.root])) {
+    throw new Error("The executor requires projectsConfigurations.");
+  }
+  const registry = options.registry ? options.registry : process.env.STORM_REGISTRY_CARGO ? process.env.STORM_REGISTRY_CARGO : "https://crates.io";
+  const root = _optionalChain([context, 'access', _7 => _7.projectsConfigurations, 'access', _8 => _8.projects, 'access', _9 => _9[context.projectName], 'optionalAccess', _10 => _10.root]);
+  const packageRoot = _devkit.joinPathFragments.call(void 0, 
+    context.root,
+    options.packageRoot ? options.packageRoot : root
+  );
+  const cargoToml = _chunk4ZQUYG5Tjs.parseCargoToml.call(void 0, 
+    _fs.readFileSync.call(void 0, _devkit.joinPathFragments.call(void 0, packageRoot, "Cargo.toml"), "utf-8")
+  );
+  try {
+    const result = await getRegistryVersion(
+      cargoToml.package.name,
+      cargoToml.package.version,
+      registry
+    );
+    if (result) {
+      console.warn(
+        `Skipped publishing crate ${cargoToml.package.name} v${cargoToml.package.version} - ${result}`
+      );
+      return {
+        success: true
+      };
+    }
+  } catch (e) {
+  }
+  const cargoPublishCommandSegments = [
+    `cargo publish --allow-dirty -p ${cargoToml.package.name}`
+  ];
+  if (isDryRun) {
+    cargoPublishCommandSegments.push("--dry-run");
+  }
+  try {
+    const cargoPublishCommand = cargoPublishCommandSegments.join(" ");
+    console.log("");
+    console.log(`Running "${cargoPublishCommand}"...`);
+    console.log("");
+    _child_process.execSync.call(void 0, cargoPublishCommand, {
+      maxBuffer: LARGE_BUFFER,
+      env: {
+        ...process.env,
+        FORCE_COLOR: "true"
+      },
+      cwd: packageRoot,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    console.log("");
+    if (isDryRun) {
+      console.log(`Would publish to ${registry}, but [dry-run] was set`);
+    } else {
+      console.log(`Published to ${registry}`);
+    }
+    return {
+      success: true
+    };
+  } catch (error) {
+    console.error(`Failed to publish to ${registry}`);
+    console.error(error);
+    console.log("");
+    return {
+      success: false
+    };
+  }
+}
+var getRegistryVersion = (name, version, registry) => {
+  const url = `${registry}/api/v1/crates/${encodeURIComponent(name)}/${encodeURIComponent(
+    version
+  )}`;
+  console.log(`Checking for existing version at: ${url}`);
+  return new Promise(
+    (resolve) => _https2.default.get(url, (res) => {
+      res.on("data", (d) => {
+        if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+          const response = JSON.parse(d.toString());
+          const updatedAt = _optionalChain([response, 'access', _11 => _11.version, 'optionalAccess', _12 => _12.updated_at]);
+          const publishedBy = _optionalChain([response, 'access', _13 => _13.version, 'optionalAccess', _14 => _14.published_by, 'optionalAccess', _15 => _15.name]);
+          resolve(
+            `The ${name} v${version} crate was previously published${publishedBy ? ` by ${publishedBy}` : ""}${updatedAt ? ` on ${new Date(updatedAt).toLocaleDateString("en-US", {
+              year: "numeric",
+              month: "long",
+              day: "numeric",
+              weekday: "long"
+            })}` : ""}.`
+          );
+        }
+        resolve(null);
+      });
+    }).on("error", () => {
+      resolve(null);
+    })
+  );
+};
+
+
+
+
+exports.runExecutor = runExecutor; exports.getRegistryVersion = getRegistryVersion;

package/dist/chunk-BWV5PEQM.mjs

@@ -0,0 +1,10 @@
+// ../../node_modules/.pnpm/tsup@8.4.0_patch_hash=751a554d775c3572381af4e7e5fa22eeda6dd6856012fb1cf521d6806eb2dc74__7523d452f16c8f87bbfc60ebffdffa7e/node_modules/tsup/assets/esm_shims.js
+import { fileURLToPath } from "url";
+import path from "path";
+var getFilename = () => fileURLToPath(import.meta.url);
+var getDirname = () => path.dirname(getFilename());
+var __dirname = /* @__PURE__ */ getDirname();
+
+export {
+  __dirname
+};

package/dist/chunk-C3TC7AUW.js

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

package/dist/chunk-CJVTWYOM.mjs

@@ -0,0 +1,50 @@
+import {
+  withRunExecutor
+} from "./chunk-SEZ726NO.mjs";
+import {
+  writeInfo
+} from "./chunk-T55IDP24.mjs";
+
+// src/executors/typia/executor.ts
+import { removeSync } from "fs-extra";
+import { TypiaProgrammer } from "typia/lib/programmers/TypiaProgrammer.js";
+async function typiaExecutorFn(options, _, config) {
+  if (options.clean !== false) {
+    writeInfo(`\u{1F9F9} Cleaning output path: ${options.outputPath}`, config);
+    removeSync(options.outputPath);
+  }
+  await Promise.all(
+    options.entry.map((entry) => {
+      writeInfo(`\u{1F680} Running Typia on entry: ${entry}`, config);
+      return TypiaProgrammer.build({
+        input: entry,
+        output: options.outputPath,
+        project: options.tsconfig
+      });
+    })
+  );
+  return {
+    success: true
+  };
+}
+var executor_default = withRunExecutor(
+  "Typia runtime validation generator",
+  typiaExecutorFn,
+  {
+    skipReadingConfig: false,
+    hooks: {
+      applyDefaultOptions: (options) => {
+        options.entry ??= ["{sourceRoot}/index.ts"];
+        options.outputPath ??= "{sourceRoot}/__generated__/typia";
+        options.tsconfig ??= "{projectRoot}/tsconfig.json";
+        options.clean ??= true;
+        return options;
+      }
+    }
+  }
+);
+
+export {
+  typiaExecutorFn,
+  executor_default
+};

package/dist/chunk-CNL74KSJ.mjs

@@ -0,0 +1,52 @@
+import {
+  withRunExecutor
+} from "./chunk-SEZ726NO.mjs";
+import {
+  writeInfo
+} from "./chunk-T55IDP24.mjs";
+
+// src/executors/size-limit/executor.ts
+import { joinPathFragments } from "@nx/devkit";
+import esBuildPlugin from "@size-limit/esbuild";
+import esBuildWhyPlugin from "@size-limit/esbuild-why";
+import filePlugin from "@size-limit/file";
+import sizeLimit from "size-limit";
+async function sizeLimitExecutorFn(options, context, config) {
+  if (!context?.projectName || !context.projectsConfigurations?.projects || !context.projectsConfigurations.projects[context.projectName]) {
+    throw new Error(
+      "The Size-Limit process failed because the context is not valid. Please run this command from a workspace."
+    );
+  }
+  writeInfo(`\u{1F4CF}   Running Size-Limit on ${context.projectName}`, config);
+  sizeLimit([filePlugin, esBuildPlugin, esBuildWhyPlugin], {
+    checks: options.entry ?? context.projectsConfigurations.projects[context.projectName]?.sourceRoot ?? joinPathFragments(
+      context.projectsConfigurations.projects[context.projectName]?.root ?? "./",
+      "src"
+    )
+  }).then((result) => {
+    writeInfo(
+      `\u{1F4CF}   ${context.projectName} Size-Limit result: ${JSON.stringify(result)}`,
+      config
+    );
+  });
+  return {
+    success: true
+  };
+}
+var executor_default = withRunExecutor(
+  "Size-Limit Performance Test Executor",
+  sizeLimitExecutorFn,
+  {
+    skipReadingConfig: false,
+    hooks: {
+      applyDefaultOptions: (options) => {
+        return options;
+      }
+    }
+  }
+);
+
+export {
+  sizeLimitExecutorFn,
+  executor_default
+};

package/dist/chunk-CQDBLKPF.js

@@ -0,0 +1,172 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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; }// ../config-tools/src/utilities/correct-paths.ts
+var _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input = "") {
+  if (!input) {
+    return input;
+  }
+  return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+var _UNC_REGEX = /^[/\\]{2}/;
+var _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+var _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+var _ROOT_FOLDER_RE = /^\/([A-Za-z]:)?$/;
+var correctPaths = function(path) {
+  if (!path || path.length === 0) {
+    return ".";
+  }
+  path = normalizeWindowsPath(path);
+  const isUNCPath = _optionalChain([path, 'optionalAccess', _ => _.match, 'call', _2 => _2(_UNC_REGEX)]);
+  const isPathAbsolute = isAbsolute(path);
+  const trailingSeparator = path[path.length - 1] === "/";
+  path = normalizeString(path, !isPathAbsolute);
+  if (path.length === 0) {
+    if (isPathAbsolute) {
+      return "/";
+    }
+    return trailingSeparator ? "./" : ".";
+  }
+  if (trailingSeparator) {
+    path += "/";
+  }
+  if (_DRIVE_LETTER_RE.test(path)) {
+    path += "/";
+  }
+  if (isUNCPath) {
+    if (!isPathAbsolute) {
+      return `//./${path}`;
+    }
+    return `//${path}`;
+  }
+  return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
+};
+var joinPaths = function(...segments) {
+  let path = "";
+  for (const seg of segments) {
+    if (!seg) {
+      continue;
+    }
+    if (path.length > 0) {
+      const pathTrailing = path[path.length - 1] === "/";
+      const segLeading = seg[0] === "/";
+      const both = pathTrailing && segLeading;
+      if (both) {
+        path += seg.slice(1);
+      } else {
+        path += pathTrailing || segLeading ? seg : `/${seg}`;
+      }
+    } else {
+      path += seg;
+    }
+  }
+  return correctPaths(path);
+};
+function cwd() {
+  if (typeof process !== "undefined" && typeof process.cwd === "function") {
+    return process.cwd().replace(/\\/g, "/");
+  }
+  return "/";
+}
+var resolve = function(...arguments_) {
+  arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
+  let resolvedPath = "";
+  let resolvedAbsolute = false;
+  for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
+    const path = index >= 0 ? arguments_[index] : cwd();
+    if (!path || path.length === 0) {
+      continue;
+    }
+    resolvedPath = `${path}/${resolvedPath}`;
+    resolvedAbsolute = isAbsolute(path);
+  }
+  resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+  if (resolvedAbsolute && !isAbsolute(resolvedPath)) {
+    return `/${resolvedPath}`;
+  }
+  return resolvedPath.length > 0 ? resolvedPath : ".";
+};
+function normalizeString(path, allowAboveRoot) {
+  let res = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let char = null;
+  for (let index = 0; index <= path.length; ++index) {
+    if (index < path.length) {
+      char = path[index];
+    } else if (char === "/") {
+      break;
+    } else {
+      char = "/";
+    }
+    if (char === "/") {
+      if (lastSlash === index - 1 || dots === 1) {
+      } else if (dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+          if (res.length > 2) {
+            const lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex === -1) {
+              res = "";
+              lastSegmentLength = 0;
+            } else {
+              res = res.slice(0, lastSlashIndex);
+              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+            }
+            lastSlash = index;
+            dots = 0;
+            continue;
+          } else if (res.length > 0) {
+            res = "";
+            lastSegmentLength = 0;
+            lastSlash = index;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          res += res.length > 0 ? "/.." : "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0) {
+          res += `/${path.slice(lastSlash + 1, index)}`;
+        } else {
+          res = path.slice(lastSlash + 1, index);
+        }
+        lastSegmentLength = index - lastSlash - 1;
+      }
+      lastSlash = index;
+      dots = 0;
+    } else if (char === "." && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+var isAbsolute = function(p) {
+  return _IS_ABSOLUTE_RE.test(p);
+};
+var relative = function(from, to) {
+  const _from = resolve(from).replace(_ROOT_FOLDER_RE, "$1").split("/");
+  const _to = resolve(to).replace(_ROOT_FOLDER_RE, "$1").split("/");
+  if (_to[0][1] === ":" && _from[0][1] === ":" && _from[0] !== _to[0]) {
+    return _to.join("/");
+  }
+  const _fromCopy = [..._from];
+  for (const segment of _fromCopy) {
+    if (_to[0] !== segment) {
+      break;
+    }
+    _from.shift();
+    _to.shift();
+  }
+  return [..._from.map(() => ".."), ..._to].join("/");
+};
+
+
+
+
+
+
+exports.correctPaths = correctPaths; exports.joinPaths = joinPaths; exports.isAbsolute = isAbsolute; exports.relative = relative;

package/dist/chunk-CZPRVK6P.mjs

@@ -0,0 +1,31 @@
+import {
+  buildCargoCommand,
+  cargoCommand
+} from "./chunk-GKLFEOKK.mjs";
+import {
+  withRunExecutor
+} from "./chunk-SEZ726NO.mjs";
+
+// src/executors/cargo-check/executor.ts
+async function cargoCheckExecutor(options, context) {
+  const command = buildCargoCommand("check", options, context);
+  return await cargoCommand(context.root, ...command);
+}
+var executor_default = withRunExecutor(
+  "Cargo - Check",
+  cargoCheckExecutor,
+  {
+    skipReadingConfig: false,
+    hooks: {
+      applyDefaultOptions: (options) => {
+        options.toolchain ??= "stable";
+        return options;
+      }
+    }
+  }
+);
+
+export {
+  cargoCheckExecutor,
+  executor_default
+};

package/dist/chunk-DIUWF7BW.js

@@ -0,0 +1,17 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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 _chunkLMYTVXGXjs = require('./chunk-LMYTVXGX.js');
+
+// src/utils/get-project-configurations.ts
+var _retrieveworkspacefiles = require('nx/src/project-graph/utils/retrieve-workspace-files');
+var getProjectConfigurations = async () => {
+  return _retrieveworkspacefiles.retrieveProjectConfigurationsWithoutPluginInference.call(void 0, 
+    _chunkLMYTVXGXjs.findWorkspaceRoot.call(void 0, )
+  );
+};
+var getProjectConfiguration = (projectName) => _optionalChain([getProjectConfigurations, 'call', _ => _(), 'optionalAccess', _2 => _2[projectName]]);
+
+
+
+
+exports.getProjectConfigurations = getProjectConfigurations; exports.getProjectConfiguration = getProjectConfiguration;