@storm-software/workspace-tools 1.228.0 → 1.229.0

package/dist/chunk-FBLF4KJF.js

@@ -0,0 +1,306 @@
+"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 _chunk7YRW5HNXjs = require('./chunk-7YRW5HNX.js');
+
+
+var _chunkHI4G4OOGjs = require('./chunk-HI4G4OOG.js');
+
+
+var _chunkXCSSYTCUjs = require('./chunk-XCSSYTCU.js');
+
+
+var _chunk3GQAWCBQjs = require('./chunk-3GQAWCBQ.js');
+
+// src/base/typescript-library-generator.ts
+var _devkit = require('@nx/devkit');
+var _projectnameandrootutils = require('@nx/devkit/src/generators/project-name-and-root-utils');
+var _js = require('@nx/js');
+var _init = require('@nx/js/src/generators/init/init'); var _init2 = _interopRequireDefault(_init);
+var _generator = require('@nx/js/src/generators/setup-verdaccio/generator'); var _generator2 = _interopRequireDefault(_generator);
+async function typeScriptLibraryGeneratorFn(tree, schema, config) {
+  const options = await normalizeOptions(tree, {
+    ...schema
+  });
+  const tasks = [];
+  tasks.push(await _init2.default.call(void 0, tree, {
+    ...options,
+    tsConfigName: options.rootProject ? "tsconfig.json" : "tsconfig.base.json"
+  }));
+  tasks.push(_devkit.addDependenciesToPackageJson.call(void 0, tree, {}, {
+    "@storm-software/workspace-tools": "latest",
+    "@storm-software/testing-tools": "latest",
+    ..._nullishCoalesce(schema.devDependencies, () => ( {}))
+  }));
+  if (options.publishable) {
+    tasks.push(await _generator2.default.call(void 0, tree, {
+      ...options,
+      skipFormat: true
+    }));
+  }
+  const projectConfig = {
+    root: options.directory,
+    projectType: "library",
+    sourceRoot: _chunkXCSSYTCUjs.joinPaths.call(void 0, _nullishCoalesce(options.directory, () => ( "")), "src"),
+    targets: {
+      build: {
+        executor: schema.buildExecutor,
+        outputs: [
+          "{options.outputPath}"
+        ],
+        options: {
+          entry: [
+            _chunkXCSSYTCUjs.joinPaths.call(void 0, options.projectRoot, "src", "index.ts")
+          ],
+          outputPath: getOutputPath(options),
+          tsconfig: _chunkXCSSYTCUjs.joinPaths.call(void 0, options.projectRoot, "tsconfig.json"),
+          project: _chunkXCSSYTCUjs.joinPaths.call(void 0, options.projectRoot, "package.json"),
+          defaultConfiguration: "production",
+          platform: "neutral",
+          assets: [
+            {
+              input: options.projectRoot,
+              glob: "*.md",
+              output: "/"
+            },
+            {
+              input: "",
+              glob: "LICENSE",
+              output: "/"
+            }
+          ]
+        },
+        configurations: {
+          production: {
+            debug: false,
+            verbose: false
+          },
+          development: {
+            debug: true,
+            verbose: true
+          }
+        }
+      }
+    }
+  };
+  if (schema.platform) {
+    projectConfig.targets.build.options.platform = schema.platform === "worker" ? "node" : schema.platform;
+  }
+  _chunk7YRW5HNXjs.addProjectTag.call(void 0, projectConfig, _chunk7YRW5HNXjs.ProjectTagConstants.Platform.TAG_ID, schema.platform === "node" ? _chunk7YRW5HNXjs.ProjectTagConstants.Platform.NODE : schema.platform === "worker" ? _chunk7YRW5HNXjs.ProjectTagConstants.Platform.WORKER : schema.platform === "browser" ? _chunk7YRW5HNXjs.ProjectTagConstants.Platform.BROWSER : _chunk7YRW5HNXjs.ProjectTagConstants.Platform.NEUTRAL, {
+    overwrite: false
+  });
+  createProjectTsConfigJson(tree, options);
+  _devkit.addProjectConfiguration.call(void 0, tree, options.name, projectConfig);
+  let repository = {
+    type: "github",
+    url: _optionalChain([config, 'optionalAccess', _ => _.repository]) || `https://github.com/${_optionalChain([config, 'optionalAccess', _2 => _2.organization]) || "storm-software"}/${_optionalChain([config, 'optionalAccess', _3 => _3.namespace]) || _optionalChain([config, 'optionalAccess', _4 => _4.name]) || "repository"}.git`
+  };
+  let description = schema.description || "A package developed by Storm Software used to create modern, scalable web applications.";
+  if (tree.exists("package.json")) {
+    const packageJson = _devkit.readJson.call(void 0, tree, "package.json");
+    if (_optionalChain([packageJson, 'optionalAccess', _5 => _5.repository])) {
+      repository = packageJson.repository;
+    }
+    if (_optionalChain([packageJson, 'optionalAccess', _6 => _6.description])) {
+      description = packageJson.description;
+    }
+  }
+  if (!options.importPath) {
+    options.importPath = options.name;
+  }
+  const packageJsonPath = _chunkXCSSYTCUjs.joinPaths.call(void 0, options.projectRoot, "package.json");
+  if (tree.exists(packageJsonPath)) {
+    _devkit.updateJson.call(void 0, tree, packageJsonPath, (json) => {
+      if (!options.importPath) {
+        options.importPath = options.name;
+      }
+      json.name = options.importPath;
+      json.version = "0.0.1";
+      if (json.private && (options.publishable || options.rootProject)) {
+        json.private = void 0;
+      }
+      return {
+        ...json,
+        version: "0.0.1",
+        description,
+        repository: {
+          ...repository,
+          directory: options.projectRoot
+        },
+        type: "module",
+        dependencies: {
+          ...json.dependencies
+        },
+        publishConfig: {
+          access: "public"
+        }
+      };
+    });
+  } else {
+    _devkit.writeJson.call(void 0, tree, packageJsonPath, {
+      name: options.importPath,
+      version: "0.0.1",
+      description,
+      repository: {
+        ...repository,
+        directory: options.projectRoot
+      },
+      private: !options.publishable || options.rootProject,
+      type: "module",
+      publishConfig: {
+        access: "public"
+      }
+    });
+  }
+  if (tree.exists("package.json") && options.importPath) {
+    _devkit.updateJson.call(void 0, tree, "package.json", (json) => ({
+      ...json,
+      pnpm: {
+        ..._optionalChain([json, 'optionalAccess', _7 => _7.pnpm]),
+        overrides: {
+          ..._optionalChain([json, 'optionalAccess', _8 => _8.pnpm, 'optionalAccess', _9 => _9.overrides]),
+          [_nullishCoalesce(options.importPath, () => ( ""))]: "workspace:*"
+        }
+      }
+    }));
+  }
+  _js.addTsConfigPath.call(void 0, tree, options.importPath, [
+    _chunkXCSSYTCUjs.joinPaths.call(void 0, options.projectRoot, "./src", `index.${options.js ? "js" : "ts"}`)
+  ]);
+  _js.addTsConfigPath.call(void 0, tree, _chunkXCSSYTCUjs.joinPaths.call(void 0, options.importPath, "/*"), [
+    _chunkXCSSYTCUjs.joinPaths.call(void 0, options.projectRoot, "./src", "/*")
+  ]);
+  if (tree.exists("package.json")) {
+    const packageJson = _devkit.readJson.call(void 0, tree, "package.json");
+    if (_optionalChain([packageJson, 'optionalAccess', _10 => _10.repository])) {
+      repository = packageJson.repository;
+    }
+    if (_optionalChain([packageJson, 'optionalAccess', _11 => _11.description])) {
+      description = packageJson.description;
+    }
+  }
+  const tsconfigPath = _chunkXCSSYTCUjs.joinPaths.call(void 0, options.projectRoot, "tsconfig.json");
+  if (tree.exists(tsconfigPath)) {
+    _devkit.updateJson.call(void 0, tree, tsconfigPath, (json) => {
+      json.composite ??= true;
+      return json;
+    });
+  } else {
+    _devkit.writeJson.call(void 0, tree, tsconfigPath, {
+      extends: `${_devkit.offsetFromRoot.call(void 0, options.projectRoot)}tsconfig.base.json`,
+      composite: true,
+      compilerOptions: {
+        outDir: `${_devkit.offsetFromRoot.call(void 0, options.projectRoot)}dist/out-tsc`
+      },
+      files: [],
+      include: [
+        "src/**/*.ts",
+        "src/**/*.js"
+      ],
+      exclude: [
+        "jest.config.ts",
+        "src/**/*.spec.ts",
+        "src/**/*.test.ts"
+      ]
+    });
+  }
+  await _devkit.formatFiles.call(void 0, tree);
+  return null;
+}
+_chunk3GQAWCBQjs.__name.call(void 0, typeScriptLibraryGeneratorFn, "typeScriptLibraryGeneratorFn");
+function getOutputPath(options) {
+  const parts = [
+    "dist"
+  ];
+  if (options.projectRoot === ".") {
+    parts.push(options.name);
+  } else {
+    parts.push(options.projectRoot);
+  }
+  return _chunkXCSSYTCUjs.joinPaths.call(void 0, ...parts);
+}
+_chunk3GQAWCBQjs.__name.call(void 0, getOutputPath, "getOutputPath");
+function createProjectTsConfigJson(tree, options) {
+  const tsconfig = {
+    extends: options.rootProject ? void 0 : _js.getRelativePathToRootTsConfig.call(void 0, tree, options.projectRoot),
+    ..._nullishCoalesce(_optionalChain([options, 'optionalAccess', _12 => _12.tsconfigOptions]), () => ( {})),
+    compilerOptions: {
+      ...options.rootProject ? _js.tsConfigBaseOptions : {},
+      outDir: _chunkXCSSYTCUjs.joinPaths.call(void 0, _devkit.offsetFromRoot.call(void 0, options.projectRoot), "dist/out-tsc"),
+      noEmit: true,
+      ..._nullishCoalesce(_optionalChain([options, 'optionalAccess', _13 => _13.tsconfigOptions, 'optionalAccess', _14 => _14.compilerOptions]), () => ( {}))
+    },
+    files: [
+      ..._nullishCoalesce(_optionalChain([options, 'optionalAccess', _15 => _15.tsconfigOptions, 'optionalAccess', _16 => _16.files]), () => ( []))
+    ],
+    include: [
+      ..._nullishCoalesce(_optionalChain([options, 'optionalAccess', _17 => _17.tsconfigOptions, 'optionalAccess', _18 => _18.include]), () => ( [])),
+      "src/**/*.ts",
+      "src/**/*.js",
+      "bin/**/*"
+    ],
+    exclude: [
+      ..._nullishCoalesce(_optionalChain([options, 'optionalAccess', _19 => _19.tsconfigOptions, 'optionalAccess', _20 => _20.exclude]), () => ( [])),
+      "jest.config.ts",
+      "src/**/*.spec.ts",
+      "src/**/*.test.ts"
+    ]
+  };
+  _devkit.writeJson.call(void 0, tree, _chunkXCSSYTCUjs.joinPaths.call(void 0, options.projectRoot, "tsconfig.json"), tsconfig);
+}
+_chunk3GQAWCBQjs.__name.call(void 0, createProjectTsConfigJson, "createProjectTsConfigJson");
+async function normalizeOptions(tree, options) {
+  if (options.publishable) {
+    if (!options.importPath) {
+      throw new Error(`For publishable libs you have to provide a proper "--importPath" which needs to be a valid npm package name (e.g. my-awesome-lib or @myorg/my-lib)`);
+    }
+  }
+  let bundler = "tsc";
+  if (options.publishable === false && options.buildable === false) {
+    bundler = "none";
+  }
+  const { Linter } = _devkit.ensurePackage.call(void 0, "@nx/eslint", _chunkHI4G4OOGjs.nxVersion);
+  const { projectName, names: projectNames, projectRoot, importPath } = await _projectnameandrootutils.determineProjectNameAndRootOptions.call(void 0, tree, {
+    name: options.name,
+    projectType: "library",
+    directory: options.directory,
+    importPath: options.importPath,
+    rootProject: options.rootProject
+  });
+  options.rootProject = projectRoot === ".";
+  const normalized = _devkit.names.call(void 0, projectNames.projectFileName);
+  const fileName = normalized.fileName;
+  return {
+    js: false,
+    pascalCaseFiles: false,
+    skipFormat: false,
+    skipTsConfig: false,
+    includeBabelRc: false,
+    unitTestRunner: "jest",
+    linter: Linter.EsLint,
+    testEnvironment: "node",
+    config: "project",
+    compiler: "tsc",
+    bundler,
+    skipTypeCheck: false,
+    minimal: false,
+    hasPlugin: false,
+    isUsingTsSolutionConfig: false,
+    projectPackageManagerWorkspaceState: "included",
+    ...options,
+    fileName,
+    name: projectName,
+    projectNames,
+    projectRoot,
+    parsedTags: options.tags ? options.tags.split(",").map((s) => s.trim()) : [],
+    importPath
+  };
+}
+_chunk3GQAWCBQjs.__name.call(void 0, normalizeOptions, "normalizeOptions");
+
+
+
+
+
+
+exports.typeScriptLibraryGeneratorFn = typeScriptLibraryGeneratorFn; exports.getOutputPath = getOutputPath; exports.createProjectTsConfigJson = createProjectTsConfigJson; exports.normalizeOptions = normalizeOptions;

package/dist/chunk-FFBZYD6R.mjs

@@ -0,0 +1,59 @@
+import {
+  findWorkspaceRoot
+} from "./chunk-DMUTOQCB.mjs";
+import {
+  __name
+} from "./chunk-XUV4U54K.mjs";
+
+// src/utils/apply-workspace-tokens.ts
+var applyWorkspaceExecutorTokens = /* @__PURE__ */ __name(async (option, tokenizerOptions) => {
+  let result = option;
+  if (!result) {
+    return result;
+  }
+  let projectName;
+  let projectRoot;
+  let sourceRoot;
+  if (tokenizerOptions?.projectName) {
+    const context = tokenizerOptions;
+    projectName = context.projectName;
+    projectRoot = context.root;
+    sourceRoot = context.sourceRoot;
+  } else {
+    const projectConfig = tokenizerOptions;
+    projectRoot = projectConfig.root;
+    if (projectConfig.name) {
+      projectName = projectConfig.name;
+    }
+    if (projectConfig.sourceRoot) {
+      sourceRoot = projectConfig.sourceRoot;
+    }
+  }
+  if (tokenizerOptions.config) {
+    const configKeys = Object.keys(tokenizerOptions.config);
+    if (configKeys.some((configKey) => result.includes(`{${configKey}}`))) {
+      for (const configKey of configKeys) {
+        if (result.includes(`{${configKey}}`)) {
+          result = result.replaceAll(`{${configKey}}`, tokenizerOptions.config[configKey]);
+        }
+      }
+    }
+  }
+  if (result.includes("{projectName}")) {
+    result = result.replaceAll("{projectName}", projectName);
+  }
+  if (result.includes("{projectRoot}")) {
+    result = result.replaceAll("{projectRoot}", projectRoot);
+  }
+  if (result.includes("{sourceRoot}")) {
+    result = result.replaceAll("{sourceRoot}", sourceRoot);
+  }
+  if (result.includes("{workspaceRoot}")) {
+    result = result.replaceAll("{workspaceRoot}", tokenizerOptions.workspaceRoot ?? findWorkspaceRoot());
+  }
+  return result;
+}, "applyWorkspaceExecutorTokens");
+
+export {
+  applyWorkspaceExecutorTokens
+};

package/dist/chunk-FP4PPOO6.js

@@ -0,0 +1,32 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunkULBTYC2Bjs = require('./chunk-ULBTYC2B.js');
+
+
+var _chunkMSENNRAYjs = require('./chunk-MSENNRAY.js');
+
+
+var _chunk3GQAWCBQjs = require('./chunk-3GQAWCBQ.js');
+
+// src/executors/cargo-clippy/executor.ts
+async function cargoClippyExecutor(options, context) {
+  const command = _chunkULBTYC2Bjs.buildCargoCommand.call(void 0, "clippy", options, context);
+  return await _chunkULBTYC2Bjs.cargoCommand.call(void 0, ...command);
+}
+_chunk3GQAWCBQjs.__name.call(void 0, cargoClippyExecutor, "cargoClippyExecutor");
+var executor_default = _chunkMSENNRAYjs.withRunExecutor.call(void 0, "Cargo Clippy", cargoClippyExecutor, {
+  skipReadingConfig: false,
+  hooks: {
+    applyDefaultOptions: /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, (options) => {
+      options.toolchain ??= "stable";
+      options.fix ??= false;
+      return options;
+    }, "applyDefaultOptions")
+  }
+});
+
+
+
+
+exports.cargoClippyExecutor = cargoClippyExecutor; exports.executor_default = executor_default;

package/dist/chunk-GGGO542M.js

@@ -0,0 +1,93 @@
+"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 _chunkZMFVKBRMjs = require('./chunk-ZMFVKBRM.js');
+
+
+var _chunk3GQAWCBQjs = require('./chunk-3GQAWCBQ.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', _2 => _2.projectsConfigurations, 'optionalAccess', _3 => _3.projects]) || !context.projectsConfigurations.projects[context.projectName] || !_optionalChain([context, 'access', _4 => _4.projectsConfigurations, 'access', _5 => _5.projects, 'access', _6 => _6[context.projectName], 'optionalAccess', _7 => _7.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', _8 => _8.projectsConfigurations, 'access', _9 => _9.projects, 'access', _10 => _10[context.projectName], 'optionalAccess', _11 => _11.root]);
+  const packageRoot = _devkit.joinPathFragments.call(void 0, context.root, options.packageRoot ? options.packageRoot : root);
+  const cargoToml = _chunkZMFVKBRMjs.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 package "${cargoToml.package.name}" from project "${context.projectName}" because v${cargoToml.package.version} already exists in ${registry} with tag "latest"`);
+      return {
+        success: true
+      };
+    }
+  } catch (_) {
+  }
+  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
+    };
+  }
+}
+_chunk3GQAWCBQjs.__name.call(void 0, runExecutor, "runExecutor");
+var getRegistryVersion = /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, (name, version, registry) => {
+  return new Promise((resolve) => _https2.default.get(`${registry}/api/v1/crates/${encodeURIComponent(name)}/${encodeURIComponent(version)}`, (res) => {
+    res.on("data", (d) => {
+      resolve(d);
+    });
+  }).on("error", (e) => {
+    throw e;
+  }));
+}, "getRegistryVersion");
+
+
+
+
+exports.runExecutor = runExecutor; exports.getRegistryVersion = getRegistryVersion;

package/dist/chunk-GV44QHV3.mjs

@@ -0,0 +1,32 @@
+import {
+  buildCargoCommand,
+  cargoCommand
+} from "./chunk-QZHIWK5Z.mjs";
+import {
+  withRunExecutor
+} from "./chunk-6267MSX4.mjs";
+import {
+  __name
+} from "./chunk-XUV4U54K.mjs";
+
+// src/executors/cargo-format/executor.ts
+async function cargoFormatExecutor(options, context) {
+  const command = buildCargoCommand("fmt", options, context);
+  return await cargoCommand(...command);
+}
+__name(cargoFormatExecutor, "cargoFormatExecutor");
+var executor_default = withRunExecutor("Cargo Format", cargoFormatExecutor, {
+  skipReadingConfig: false,
+  hooks: {
+    applyDefaultOptions: /* @__PURE__ */ __name((options) => {
+      options.outputPath ??= "dist/target/{projectRoot}";
+      options.toolchain ??= "stable";
+      return options;
+    }, "applyDefaultOptions")
+  }
+});
+
+export {
+  cargoFormatExecutor,
+  executor_default
+};