@storm-software/workspace-tools 1.295.69 → 1.295.71

package/dist/chunk-237PJK2V.js

@@ -0,0 +1,128 @@
+"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 _chunk32KQVUCFjs = require('./chunk-32KQVUCF.js');
+
+
+var _chunkGSGT2T27js = require('./chunk-GSGT2T27.js');
+
+
+var _chunkAGR3NCGAjs = require('./chunk-AGR3NCGA.js');
+
+
+
+
+
+var _chunkCQDBLKPFjs = require('./chunk-CQDBLKPF.js');
+
+// src/executors/napi/executor.ts
+var _jiti = require('jiti');
+var _fileutils = require('nx/src/utils/fileutils');
+async function napiExecutor(options, context, config) {
+  const jiti = _jiti.createJiti.call(void 0, config.workspaceRoot, {
+    fsCache: config.skipCache ? false : _chunkCQDBLKPFjs.joinPaths.call(void 0, 
+      config.workspaceRoot,
+      config.directories.cache || "node_modules/.cache/storm",
+      "jiti"
+    ),
+    interopDefault: true
+  });
+  const { NapiCli } = await jiti.import(
+    jiti.esmResolve("@napi-rs/cli")
+  );
+  if (!_optionalChain([context, 'access', _ => _.projectGraph, 'optionalAccess', _2 => _2.nodes, 'access', _3 => _3[_nullishCoalesce(context.projectName, () => ( ""))]])) {
+    throw new Error(
+      "The Napi Build process failed because the project could not be found in the project graph. Please run this command from a workspace root directory."
+    );
+  }
+  const projectRoot = _optionalChain([context, 'access', _4 => _4.projectGraph, 'optionalAccess', _5 => _5.nodes, 'access', _6 => _6[_nullishCoalesce(context.projectName, () => ( ""))], 'optionalAccess', _7 => _7.data, 'access', _8 => _8.root]);
+  const packageJson = _chunkCQDBLKPFjs.joinPaths.call(void 0, _nullishCoalesce(projectRoot, () => ( ".")), "package.json");
+  if (!_fileutils.fileExists.call(void 0, packageJson)) {
+    throw new Error(`Could not find package.json at ${packageJson}`);
+  }
+  const napi = new NapiCli();
+  const normalizedOptions = { ...options };
+  const metadata = _chunk32KQVUCFjs.cargoMetadata.call(void 0, );
+  normalizedOptions.targetDir = options.targetDir || _optionalChain([metadata, 'optionalAccess', _9 => _9.target_directory]) || _chunkCQDBLKPFjs.joinPaths.call(void 0, config.workspaceRoot, "dist", "target");
+  normalizedOptions.outputDir = options.outputPath;
+  normalizedOptions.packageJsonPath ??= packageJson;
+  if (options.cwd) {
+    normalizedOptions.cwd = _chunkCQDBLKPFjs.correctPaths.call(void 0, options.cwd);
+  } else {
+    const absoluteProjectRoot = _chunkCQDBLKPFjs.correctPaths.call(void 0, 
+      _chunkCQDBLKPFjs.joinPaths.call(void 0, config.workspaceRoot, projectRoot || ".")
+    );
+    normalizedOptions.cwd = absoluteProjectRoot;
+    if (normalizedOptions.outputDir) {
+      normalizedOptions.outputDir = _chunkCQDBLKPFjs.relative.call(void 0, 
+        normalizedOptions.cwd,
+        _chunkCQDBLKPFjs.correctPaths.call(void 0, 
+          _chunkCQDBLKPFjs.isAbsolute.call(void 0, normalizedOptions.outputDir) ? normalizedOptions.outputDir : _chunkCQDBLKPFjs.joinPaths.call(void 0, config.workspaceRoot, normalizedOptions.outputDir)
+        )
+      );
+    }
+    if (normalizedOptions.packageJsonPath) {
+      normalizedOptions.packageJsonPath = _chunkCQDBLKPFjs.relative.call(void 0, 
+        normalizedOptions.cwd,
+        _chunkCQDBLKPFjs.correctPaths.call(void 0, 
+          _chunkCQDBLKPFjs.isAbsolute.call(void 0, normalizedOptions.packageJsonPath) ? normalizedOptions.packageJsonPath : _chunkCQDBLKPFjs.joinPaths.call(void 0, config.workspaceRoot, normalizedOptions.packageJsonPath)
+        )
+      );
+    }
+    if (normalizedOptions.configPath) {
+      normalizedOptions.configPath = _chunkCQDBLKPFjs.relative.call(void 0, 
+        normalizedOptions.cwd,
+        _chunkCQDBLKPFjs.correctPaths.call(void 0, 
+          _chunkCQDBLKPFjs.isAbsolute.call(void 0, normalizedOptions.configPath) ? normalizedOptions.configPath : _chunkCQDBLKPFjs.joinPaths.call(void 0, config.workspaceRoot, normalizedOptions.configPath)
+        )
+      );
+    }
+    if (normalizedOptions.manifestPath) {
+      normalizedOptions.manifestPath = _chunkCQDBLKPFjs.relative.call(void 0, 
+        normalizedOptions.cwd,
+        _chunkCQDBLKPFjs.correctPaths.call(void 0, 
+          _chunkCQDBLKPFjs.isAbsolute.call(void 0, normalizedOptions.manifestPath) ? normalizedOptions.manifestPath : _chunkCQDBLKPFjs.joinPaths.call(void 0, config.workspaceRoot, normalizedOptions.manifestPath)
+        )
+      );
+    }
+  }
+  if (process.env.VERCEL) {
+    return { success: true };
+  }
+  _chunkAGR3NCGAjs.writeDebug.call(void 0, 
+    `Normalized Napi Options: 
+packageJsonPath: ${normalizedOptions.packageJsonPath} 
+outputDir: ${normalizedOptions.outputDir} 
+targetDir: ${normalizedOptions.targetDir} 
+manifestPath: ${normalizedOptions.manifestPath} 
+configPath: ${normalizedOptions.configPath} 
+cwd: ${normalizedOptions.cwd}`,
+    config
+  );
+  const { task } = await napi.build(normalizedOptions);
+  return { success: true, terminalOutput: await task };
+}
+var executor_default = _chunkGSGT2T27js.withRunExecutor.call(void 0, 
+  "Napi - Build Bindings",
+  napiExecutor,
+  {
+    skipReadingConfig: false,
+    hooks: {
+      applyDefaultOptions: (options) => {
+        options.outputPath ??= "{sourceRoot}";
+        options.toolchain ??= "stable";
+        options.dtsCache ??= true;
+        options.platform ??= true;
+        options.constEnum ??= false;
+        options.verbose ??= false;
+        options.jsBinding ??= "binding.js";
+        options.dts ??= "binding.d.ts";
+        return options;
+      }
+    }
+  }
+);
+
+
+
+
+exports.napiExecutor = napiExecutor; exports.executor_default = executor_default;

package/dist/chunk-2AVWFUXP.js

@@ -0,0 +1,112 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunk7CJRMBX3js = require('./chunk-7CJRMBX3.js');
+
+// src/base/typescript-library-generator.untyped.ts
+var _untyped = require('untyped');
+var typescript_library_generator_untyped_default = _untyped.defineUntypedSchema.call(void 0, {
+  ..._chunk7CJRMBX3js.base_generator_untyped_default,
+  $schema: {
+    id: "TypeScriptLibraryGeneratorSchema",
+    title: "TypeScript Library Generator",
+    description: "A type definition for the base TypeScript Library Generator schema",
+    required: ["directory", "name"]
+  },
+  name: {
+    $schema: {
+      title: "Name",
+      type: "string",
+      description: "The name of the library"
+    }
+  },
+  description: {
+    $schema: {
+      title: "Description",
+      type: "string",
+      description: "The description of the library"
+    }
+  },
+  buildExecutor: {
+    $schema: {
+      title: "Build Executor",
+      type: "string",
+      description: "The executor to use for building the library"
+    },
+    $default: "@storm-software/workspace-tools:unbuild"
+  },
+  platform: {
+    $schema: {
+      title: "Platform",
+      type: "string",
+      description: "The platform to target with the library",
+      enum: ["neutral", "node", "worker", "browser"]
+    },
+    $default: "neutral"
+  },
+  importPath: {
+    $schema: {
+      title: "Import Path",
+      type: "string",
+      description: "The import path for the library"
+    }
+  },
+  tags: {
+    $schema: {
+      title: "Tags",
+      type: "string",
+      description: "The tags for the library"
+    }
+  },
+  unitTestRunner: {
+    $schema: {
+      title: "Unit Test Runner",
+      type: "string",
+      enum: ["jest", "vitest", "none"],
+      description: "The unit test runner to use"
+    }
+  },
+  testEnvironment: {
+    $schema: {
+      title: "Test Environment",
+      type: "string",
+      enum: ["jsdom", "node"],
+      description: "The test environment to use"
+    }
+  },
+  pascalCaseFiles: {
+    $schema: {
+      title: "Pascal Case Files",
+      type: "boolean",
+      description: "Use PascalCase for file names"
+    },
+    $default: false
+  },
+  strict: {
+    $schema: {
+      title: "Strict",
+      type: "boolean",
+      description: "Enable strict mode"
+    },
+    $default: true
+  },
+  publishable: {
+    $schema: {
+      title: "Publishable",
+      type: "boolean",
+      description: "Make the library publishable"
+    },
+    $default: false
+  },
+  buildable: {
+    $schema: {
+      title: "Buildable",
+      type: "boolean",
+      description: "Make the library buildable"
+    },
+    $default: true
+  }
+});
+
+
+
+exports.typescript_library_generator_untyped_default = typescript_library_generator_untyped_default;

package/dist/chunk-2GQSCZ3J.mjs

@@ -0,0 +1,128 @@
+// ../package-constants/src/tags.ts
+var ProjectTagConstants = {
+  Language: {
+    TAG_ID: "language",
+    TYPESCRIPT: "typescript",
+    RUST: "rust"
+  },
+  ProjectType: {
+    TAG_ID: "type",
+    LIBRARY: "library",
+    APPLICATION: "application"
+  },
+  ProjectLinking: {
+    TAG_ID: "project-linking",
+    REFERENCE: "reference",
+    ALIAS: "alias"
+  },
+  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"
+  },
+  Builder: {
+    TAG_ID: "builder",
+    TSC: "tsc",
+    TSUP: "tsup",
+    TSDOWN: "tsdown",
+    VITE: "vite",
+    ROLLDOWN: "rolldown"
+  }
+};
+var formatProjectTag = (variant, value) => {
+  return `${variant}:${value}`;
+};
+var hasProjectTag = (project, variant) => {
+  project.tags = project.tags ?? [];
+  const prefix = formatProjectTag(variant, "");
+  return project.tags.some(
+    (tag) => tag.startsWith(prefix) && tag.length > prefix.length
+  );
+};
+var getProjectTag = (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, "");
+};
+var isEqualProjectTag = (project, variant, value) => {
+  const tag = getProjectTag(project, variant);
+  return !!(tag && tag?.toUpperCase() === value.toUpperCase());
+};
+
+// src/utils/project-tags.ts
+var addProjectTag = (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));
+  }
+};
+var addPluginProjectTag = (project, plugin) => {
+  project.tags = project.tags ?? [];
+  project.tags.push(
+    formatProjectTag(ProjectTagConstants.Plugin.TAG_ID, plugin)
+  );
+};
+var setDefaultProjectTags = (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);
+  }
+};
+
+export {
+  ProjectTagConstants,
+  formatProjectTag,
+  hasProjectTag,
+  getProjectTag,
+  isEqualProjectTag,
+  addProjectTag,
+  addPluginProjectTag,
+  setDefaultProjectTags
+};

package/dist/chunk-2HPK7P5W.js

@@ -0,0 +1,93 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunk4ZQUYG5Tjs = require('./chunk-4ZQUYG5T.js');
+
+
+
+var _chunkTAP26ZJQjs = require('./chunk-TAP26ZJQ.js');
+
+
+var _chunkCQDBLKPFjs = require('./chunk-CQDBLKPF.js');
+
+// src/utils/package-helpers.ts
+
+
+
+var _devkit = require('@nx/devkit');
+var _child_process = require('child_process');
+var _fs = require('fs');
+var _promises = require('fs/promises');
+var _path = require('path');
+var _prettier = require('prettier');
+var PackageManagerTypes = {
+  PackageJson: "package.json",
+  CargoToml: "Cargo.toml"
+};
+var getPackageInfo = (project) => {
+  if (_chunkTAP26ZJQjs.isEqualProjectTag.call(void 0, 
+    project,
+    _chunkTAP26ZJQjs.ProjectTagConstants.Language.TAG_ID,
+    _chunkTAP26ZJQjs.ProjectTagConstants.Language.RUST
+  ) && _fs.existsSync.call(void 0, _devkit.joinPathFragments.call(void 0, project.root, "Cargo.toml"))) {
+    return {
+      type: "Cargo.toml",
+      content: _chunk4ZQUYG5Tjs.parseCargoToml.call(void 0, _devkit.joinPathFragments.call(void 0, project.root, "Cargo.toml"))
+    };
+  } else if (_chunkTAP26ZJQjs.isEqualProjectTag.call(void 0, 
+    project,
+    _chunkTAP26ZJQjs.ProjectTagConstants.Language.TAG_ID,
+    _chunkTAP26ZJQjs.ProjectTagConstants.Language.TYPESCRIPT
+  ) && _fs.existsSync.call(void 0, _devkit.joinPathFragments.call(void 0, project.root, "package.json"))) {
+    return {
+      type: "package.json",
+      content: _devkit.readJsonFile.call(void 0, 
+        _devkit.joinPathFragments.call(void 0, project.root, "package.json")
+      )
+    };
+  }
+  return null;
+};
+async function addPackageJsonGitHead(packageRoot) {
+  const packageJsonPath = _chunkCQDBLKPFjs.joinPaths.call(void 0, packageRoot, "package.json");
+  if (!packageJsonPath) {
+    throw new Error(
+      "No file path provided. Please provide a valid path to the package.json file."
+    );
+  }
+  const packageJsonValue = JSON.parse(await _promises.readFile.call(void 0, packageJsonPath, "utf8"));
+  if (!packageJsonValue || typeof packageJsonValue !== "object") {
+    throw new Error(
+      `Invalid package.json file at ${packageJsonPath}. Please ensure it is a valid JSON file.`
+    );
+  }
+  const gitHead = _child_process.execFileSync.call(void 0, "git", ["rev-parse", "HEAD"], {
+    cwd: _path.dirname.call(void 0, _path.resolve.call(void 0, packageJsonPath)),
+    encoding: "utf8"
+  }).trim();
+  packageJsonValue.gitHead = gitHead;
+  return _promises.writeFile.call(void 0, 
+    packageJsonPath,
+    await _prettier.format.call(void 0, JSON.stringify(packageJsonValue), {
+      parser: "json",
+      proseWrap: "preserve",
+      trailingComma: "none",
+      tabWidth: 2,
+      semi: true,
+      singleQuote: false,
+      quoteProps: "as-needed",
+      insertPragma: false,
+      bracketSameLine: true,
+      printWidth: 80,
+      bracketSpacing: true,
+      arrowParens: "avoid",
+      endOfLine: "lf",
+      plugins: ["prettier-plugin-packagejson"]
+    })
+  );
+}
+
+
+
+
+
+exports.PackageManagerTypes = PackageManagerTypes; exports.getPackageInfo = getPackageInfo; exports.addPackageJsonGitHead = addPackageJsonGitHead;

package/dist/chunk-2NAUEEZT.js

@@ -0,0 +1,31 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunk32KQVUCFjs = require('./chunk-32KQVUCF.js');
+
+
+var _chunkGSGT2T27js = require('./chunk-GSGT2T27.js');
+
+// src/executors/cargo-check/executor.ts
+async function cargoCheckExecutor(options, context) {
+  const command = _chunk32KQVUCFjs.buildCargoCommand.call(void 0, "check", options, context);
+  return await _chunk32KQVUCFjs.cargoCommand.call(void 0, context.root, ...command);
+}
+var executor_default = _chunkGSGT2T27js.withRunExecutor.call(void 0, 
+  "Cargo - Check",
+  cargoCheckExecutor,
+  {
+    skipReadingConfig: false,
+    hooks: {
+      applyDefaultOptions: (options) => {
+        options.toolchain ??= "stable";
+        return options;
+      }
+    }
+  }
+);
+
+
+
+
+exports.cargoCheckExecutor = cargoCheckExecutor; exports.executor_default = executor_default;

package/dist/chunk-2QMGYIOO.mjs

@@ -0,0 +1,81 @@
+import {
+  findWorkspaceRoot
+} from "./chunk-3J2CP54B.mjs";
+
+// ../config-tools/src/utilities/apply-workspace-tokens.ts
+var applyWorkspaceBaseTokens = async (option, tokenParams) => {
+  let result = option;
+  if (!result) {
+    return result;
+  }
+  if (tokenParams) {
+    const optionKeys = Object.keys(tokenParams);
+    if (optionKeys.some((optionKey) => result.includes(`{${optionKey}}`))) {
+      for (const optionKey of optionKeys) {
+        if (result.includes(`{${optionKey}}`)) {
+          result = result.replaceAll(
+            `{${optionKey}}`,
+            tokenParams?.[optionKey] || ""
+          );
+        }
+      }
+    }
+  }
+  if (tokenParams.config) {
+    const configKeys = Object.keys(tokenParams.config);
+    if (configKeys.some((configKey) => result.includes(`{${configKey}}`))) {
+      for (const configKey of configKeys) {
+        if (result.includes(`{${configKey}}`)) {
+          result = result.replaceAll(
+            `{${configKey}}`,
+            tokenParams.config[configKey] || ""
+          );
+        }
+      }
+    }
+  }
+  if (result.includes("{workspaceRoot}")) {
+    result = result.replaceAll(
+      "{workspaceRoot}",
+      tokenParams.workspaceRoot ?? tokenParams.config?.workspaceRoot ?? findWorkspaceRoot()
+    );
+  }
+  return result;
+};
+var applyWorkspaceProjectTokens = (option, tokenParams) => {
+  return applyWorkspaceBaseTokens(option, tokenParams);
+};
+var applyWorkspaceTokens = async (options, tokenParams, tokenizerFn) => {
+  if (!options) {
+    return {};
+  }
+  const result = {};
+  for (const option of Object.keys(options)) {
+    if (typeof options[option] === "string") {
+      result[option] = await Promise.resolve(
+        tokenizerFn(options[option], tokenParams)
+      );
+    } else if (Array.isArray(options[option])) {
+      result[option] = await Promise.all(
+        options[option].map(
+          async (item) => typeof item === "string" ? await Promise.resolve(tokenizerFn(item, tokenParams)) : item
+        )
+      );
+    } else if (typeof options[option] === "object") {
+      result[option] = await applyWorkspaceTokens(
+        options[option],
+        tokenParams,
+        tokenizerFn
+      );
+    } else {
+      result[option] = options[option];
+    }
+  }
+  return result;
+};
+
+export {
+  applyWorkspaceBaseTokens,
+  applyWorkspaceProjectTokens,
+  applyWorkspaceTokens
+};