@storm-software/workspace-tools 1.228.0 → 1.229.0

package/dist/chunk-XSRDTQ5C.mjs

@@ -0,0 +1,306 @@
+import {
+  ProjectTagConstants,
+  addProjectTag
+} from "./chunk-66TYTM73.mjs";
+import {
+  nxVersion
+} from "./chunk-EK75QNMS.mjs";
+import {
+  joinPaths
+} from "./chunk-PVTEDLBL.mjs";
+import {
+  __name
+} from "./chunk-XUV4U54K.mjs";
+
+// src/base/typescript-library-generator.ts
+import { addDependenciesToPackageJson, addProjectConfiguration, ensurePackage, formatFiles, names, offsetFromRoot, readJson, updateJson, writeJson } from "@nx/devkit";
+import { determineProjectNameAndRootOptions } from "@nx/devkit/src/generators/project-name-and-root-utils";
+import { addTsConfigPath, getRelativePathToRootTsConfig, tsConfigBaseOptions } from "@nx/js";
+import jsInitGenerator from "@nx/js/src/generators/init/init";
+import setupVerdaccio from "@nx/js/src/generators/setup-verdaccio/generator";
+async function typeScriptLibraryGeneratorFn(tree, schema, config) {
+  const options = await normalizeOptions(tree, {
+    ...schema
+  });
+  const tasks = [];
+  tasks.push(await jsInitGenerator(tree, {
+    ...options,
+    tsConfigName: options.rootProject ? "tsconfig.json" : "tsconfig.base.json"
+  }));
+  tasks.push(addDependenciesToPackageJson(tree, {}, {
+    "@storm-software/workspace-tools": "latest",
+    "@storm-software/testing-tools": "latest",
+    ...schema.devDependencies ?? {}
+  }));
+  if (options.publishable) {
+    tasks.push(await setupVerdaccio(tree, {
+      ...options,
+      skipFormat: true
+    }));
+  }
+  const projectConfig = {
+    root: options.directory,
+    projectType: "library",
+    sourceRoot: joinPaths(options.directory ?? "", "src"),
+    targets: {
+      build: {
+        executor: schema.buildExecutor,
+        outputs: [
+          "{options.outputPath}"
+        ],
+        options: {
+          entry: [
+            joinPaths(options.projectRoot, "src", "index.ts")
+          ],
+          outputPath: getOutputPath(options),
+          tsconfig: joinPaths(options.projectRoot, "tsconfig.json"),
+          project: joinPaths(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;
+  }
+  addProjectTag(projectConfig, ProjectTagConstants.Platform.TAG_ID, schema.platform === "node" ? ProjectTagConstants.Platform.NODE : schema.platform === "worker" ? ProjectTagConstants.Platform.WORKER : schema.platform === "browser" ? ProjectTagConstants.Platform.BROWSER : ProjectTagConstants.Platform.NEUTRAL, {
+    overwrite: false
+  });
+  createProjectTsConfigJson(tree, options);
+  addProjectConfiguration(tree, options.name, projectConfig);
+  let repository = {
+    type: "github",
+    url: config?.repository || `https://github.com/${config?.organization || "storm-software"}/${config?.namespace || config?.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 = readJson(tree, "package.json");
+    if (packageJson?.repository) {
+      repository = packageJson.repository;
+    }
+    if (packageJson?.description) {
+      description = packageJson.description;
+    }
+  }
+  if (!options.importPath) {
+    options.importPath = options.name;
+  }
+  const packageJsonPath = joinPaths(options.projectRoot, "package.json");
+  if (tree.exists(packageJsonPath)) {
+    updateJson(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 {
+    writeJson(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) {
+    updateJson(tree, "package.json", (json) => ({
+      ...json,
+      pnpm: {
+        ...json?.pnpm,
+        overrides: {
+          ...json?.pnpm?.overrides,
+          [options.importPath ?? ""]: "workspace:*"
+        }
+      }
+    }));
+  }
+  addTsConfigPath(tree, options.importPath, [
+    joinPaths(options.projectRoot, "./src", `index.${options.js ? "js" : "ts"}`)
+  ]);
+  addTsConfigPath(tree, joinPaths(options.importPath, "/*"), [
+    joinPaths(options.projectRoot, "./src", "/*")
+  ]);
+  if (tree.exists("package.json")) {
+    const packageJson = readJson(tree, "package.json");
+    if (packageJson?.repository) {
+      repository = packageJson.repository;
+    }
+    if (packageJson?.description) {
+      description = packageJson.description;
+    }
+  }
+  const tsconfigPath = joinPaths(options.projectRoot, "tsconfig.json");
+  if (tree.exists(tsconfigPath)) {
+    updateJson(tree, tsconfigPath, (json) => {
+      json.composite ??= true;
+      return json;
+    });
+  } else {
+    writeJson(tree, tsconfigPath, {
+      extends: `${offsetFromRoot(options.projectRoot)}tsconfig.base.json`,
+      composite: true,
+      compilerOptions: {
+        outDir: `${offsetFromRoot(options.projectRoot)}dist/out-tsc`
+      },
+      files: [],
+      include: [
+        "src/**/*.ts",
+        "src/**/*.js"
+      ],
+      exclude: [
+        "jest.config.ts",
+        "src/**/*.spec.ts",
+        "src/**/*.test.ts"
+      ]
+    });
+  }
+  await formatFiles(tree);
+  return null;
+}
+__name(typeScriptLibraryGeneratorFn, "typeScriptLibraryGeneratorFn");
+function getOutputPath(options) {
+  const parts = [
+    "dist"
+  ];
+  if (options.projectRoot === ".") {
+    parts.push(options.name);
+  } else {
+    parts.push(options.projectRoot);
+  }
+  return joinPaths(...parts);
+}
+__name(getOutputPath, "getOutputPath");
+function createProjectTsConfigJson(tree, options) {
+  const tsconfig = {
+    extends: options.rootProject ? void 0 : getRelativePathToRootTsConfig(tree, options.projectRoot),
+    ...options?.tsconfigOptions ?? {},
+    compilerOptions: {
+      ...options.rootProject ? tsConfigBaseOptions : {},
+      outDir: joinPaths(offsetFromRoot(options.projectRoot), "dist/out-tsc"),
+      noEmit: true,
+      ...options?.tsconfigOptions?.compilerOptions ?? {}
+    },
+    files: [
+      ...options?.tsconfigOptions?.files ?? []
+    ],
+    include: [
+      ...options?.tsconfigOptions?.include ?? [],
+      "src/**/*.ts",
+      "src/**/*.js",
+      "bin/**/*"
+    ],
+    exclude: [
+      ...options?.tsconfigOptions?.exclude ?? [],
+      "jest.config.ts",
+      "src/**/*.spec.ts",
+      "src/**/*.test.ts"
+    ]
+  };
+  writeJson(tree, joinPaths(options.projectRoot, "tsconfig.json"), tsconfig);
+}
+__name(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 } = ensurePackage("@nx/eslint", nxVersion);
+  const { projectName, names: projectNames, projectRoot, importPath } = await determineProjectNameAndRootOptions(tree, {
+    name: options.name,
+    projectType: "library",
+    directory: options.directory,
+    importPath: options.importPath,
+    rootProject: options.rootProject
+  });
+  options.rootProject = projectRoot === ".";
+  const normalized = names(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
+  };
+}
+__name(normalizeOptions, "normalizeOptions");
+
+export {
+  typeScriptLibraryGeneratorFn,
+  getOutputPath,
+  createProjectTsConfigJson,
+  normalizeOptions
+};

package/dist/chunk-XUV4U54K.mjs

@@ -0,0 +1,21 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// ../../node_modules/.pnpm/tsup@8.3.5_@microsoft+api-extractor@7.49.1_@types+node@22.10.7__@swc+core@1.7.26_@swc+helpers_ekim6y52mwpq6ssxiprcp44dam/node_modules/tsup/assets/esm_shims.js
+import { fileURLToPath } from "url";
+import path from "path";
+var getFilename = /* @__PURE__ */ __name(() => fileURLToPath(import.meta.url), "getFilename");
+var getDirname = /* @__PURE__ */ __name(() => path.dirname(getFilename()), "getDirname");
+var __dirname = /* @__PURE__ */ getDirname();
+
+export {
+  __name,
+  __require,
+  __dirname
+};

package/dist/chunk-ZCZVVZBX.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-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 = _chunkMSENNRAYjs.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-ZFIZ5Q46.js

@@ -0,0 +1,288 @@
+"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",
+        "browser"
+      ]
+    },
+    $default: "neutral"
+  },
+  devDependencies: {
+    $schema: {
+      title: "Dev Dependencies",
+      type: "object",
+      description: "The dev dependencies to install"
+    }
+  },
+  dependencies: {
+    $schema: {
+      title: "Dependencies",
+      type: "object",
+      description: "The dependencies to install"
+    }
+  },
+  peerDependencies: {
+    $schema: {
+      title: "Peer Dependencies",
+      type: "object",
+      description: "The peer dependencies to install"
+    }
+  },
+  peerDependenciesMeta: {
+    $schema: {
+      title: "Peer Dependencies Meta",
+      type: "object",
+      description: "The peer dependencies meta"
+    }
+  },
+  tags: {
+    $schema: {
+      title: "Tags",
+      type: "string",
+      description: "The tags for the library"
+    }
+  },
+  tsconfigOptions: {
+    $schema: {
+      title: "TypeScript Config (tsconfig.json) Options",
+      type: "object",
+      description: "The TypeScript configuration options"
+    }
+  },
+  skipFormat: {
+    $schema: {
+      title: "Skip Format",
+      type: "boolean",
+      description: "Skip formatting"
+    }
+  },
+  skipTsConfig: {
+    $schema: {
+      title: "Skip TsConfig",
+      type: "boolean",
+      description: "Skip TypeScript configuration"
+    }
+  },
+  skipPackageJson: {
+    $schema: {
+      title: "Skip Package Json",
+      type: "boolean",
+      description: "Skip package.json"
+    }
+  },
+  includeBabelRc: {
+    $schema: {
+      title: "Include Babel Rc",
+      type: "boolean",
+      description: "Include Babel configuration"
+    }
+  },
+  unitTestRunner: {
+    $schema: {
+      title: "Unit Test Runner",
+      type: "string",
+      enum: [
+        "jest",
+        "vitest",
+        "none"
+      ],
+      description: "The unit test runner to use"
+    }
+  },
+  linter: {
+    $schema: {
+      title: "Linter",
+      type: "string",
+      description: "The linter to use"
+    }
+  },
+  testEnvironment: {
+    $schema: {
+      title: "Test Environment",
+      type: "string",
+      enum: [
+        "jsdom",
+        "node"
+      ],
+      description: "The test environment to use"
+    }
+  },
+  importPath: {
+    $schema: {
+      title: "Import Path",
+      type: "string",
+      description: "The import path for the library"
+    }
+  },
+  js: {
+    $schema: {
+      title: "JavaScript",
+      type: "boolean",
+      description: "Use JavaScript instead of TypeScript"
+    }
+  },
+  pascalCaseFiles: {
+    $schema: {
+      title: "Pascal Case Files",
+      type: "boolean",
+      description: "Use PascalCase for file names"
+    }
+  },
+  strict: {
+    $schema: {
+      title: "Strict",
+      type: "boolean",
+      description: "Enable strict mode"
+    }
+  },
+  publishable: {
+    $schema: {
+      title: "Publishable",
+      type: "boolean",
+      description: "Make the library publishable"
+    }
+  },
+  buildable: {
+    $schema: {
+      title: "Buildable",
+      type: "boolean",
+      description: "Make the library buildable"
+    }
+  },
+  setParserOptionsProject: {
+    $schema: {
+      title: "Set Parser Options Project",
+      type: "boolean",
+      description: "Set parser options project"
+    }
+  },
+  config: {
+    $schema: {
+      title: "Config",
+      type: "string",
+      enum: [
+        "workspace",
+        "project",
+        "npm-scripts"
+      ],
+      description: "The configuration type"
+    }
+  },
+  compiler: {
+    $schema: {
+      title: "Compiler",
+      type: "string",
+      description: "The compiler to use"
+    }
+  },
+  bundler: {
+    $schema: {
+      title: "Bundler",
+      type: "string",
+      description: "The bundler to use"
+    }
+  },
+  skipTypeCheck: {
+    $schema: {
+      title: "Skip Type Check",
+      type: "boolean",
+      description: "Skip type checking"
+    }
+  },
+  minimal: {
+    $schema: {
+      title: "Minimal",
+      type: "boolean",
+      description: "Create a minimal library"
+    }
+  },
+  rootProject: {
+    $schema: {
+      title: "Root Project",
+      type: "boolean",
+      description: "Create a root project"
+    }
+  },
+  simpleName: {
+    $schema: {
+      title: "Simple Name",
+      type: "boolean",
+      description: "Use a simple name for the library"
+    }
+  },
+  addPlugin: {
+    $schema: {
+      title: "Add Plugin",
+      type: "boolean",
+      description: "Add a plugin to the library"
+    }
+  },
+  useProjectJson: {
+    $schema: {
+      title: "Use Project Json",
+      type: "boolean",
+      description: "Use project.json"
+    }
+  },
+  skipWorkspacesWarning: {
+    $schema: {
+      title: "Skip Workspaces Warning",
+      type: "boolean",
+      description: "Skip workspaces warning"
+    }
+  },
+  useTscExecutor: {
+    $schema: {
+      title: "Use Tsc Executor",
+      type: "boolean",
+      description: "Use TSC executor"
+    }
+  }
+});
+
+
+
+exports.typescript_library_generator_untyped_default = typescript_library_generator_untyped_default;

package/dist/chunk-ZMFVKBRM.js

@@ -0,0 +1,55 @@
+"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 _chunk3GQAWCBQjs = require('./chunk-3GQAWCBQ.js');
+
+// src/utils/toml.ts
+var _jtoml = require('@ltd/j-toml'); var _jtoml2 = _interopRequireDefault(_jtoml);
+var _devkit = require('@nx/devkit');
+function parseCargoTomlWithTree(tree, projectRoot, projectName) {
+  const cargoTomlString = _optionalChain([tree, 'access', _ => _.read, 'call', _2 => _2(`${projectRoot}/Cargo.toml`), 'optionalAccess', _3 => _3.toString, 'call', _4 => _4()]);
+  if (!cargoTomlString) {
+    _devkit.logger.error(`Cannot find a Cargo.toml file in the ${projectName}`);
+    throw new Error();
+  }
+  return parseCargoToml(cargoTomlString);
+}
+_chunk3GQAWCBQjs.__name.call(void 0, parseCargoTomlWithTree, "parseCargoTomlWithTree");
+function parseCargoToml(cargoString) {
+  if (!cargoString) {
+    throw new Error("Cargo.toml is empty");
+  }
+  return _jtoml2.default.parse(cargoString, {
+    x: {
+      comment: true
+    }
+  });
+}
+_chunk3GQAWCBQjs.__name.call(void 0, parseCargoToml, "parseCargoToml");
+function stringifyCargoToml(cargoToml) {
+  const tomlString = _jtoml2.default.stringify(cargoToml, {
+    newlineAround: "section"
+  });
+  if (Array.isArray(tomlString)) {
+    return tomlString.join("\n");
+  }
+  return tomlString;
+}
+_chunk3GQAWCBQjs.__name.call(void 0, stringifyCargoToml, "stringifyCargoToml");
+function modifyCargoTable(toml, section, key, value) {
+  toml[section] ??= _jtoml2.default.Section({});
+  toml[section][key] = typeof value === "object" && !Array.isArray(value) ? _jtoml2.default.inline(value) : typeof value === "function" ? value() : value;
+}
+_chunk3GQAWCBQjs.__name.call(void 0, modifyCargoTable, "modifyCargoTable");
+function modifyCargoNestedTable(toml, section, key, value) {
+  toml[section] ??= {};
+  toml[section][key] = _jtoml2.default.Section(value);
+}
+_chunk3GQAWCBQjs.__name.call(void 0, modifyCargoNestedTable, "modifyCargoNestedTable");
+
+
+
+
+
+
+
+exports.parseCargoTomlWithTree = parseCargoTomlWithTree; exports.parseCargoToml = parseCargoToml; exports.stringifyCargoToml = stringifyCargoToml; exports.modifyCargoTable = modifyCargoTable; exports.modifyCargoNestedTable = modifyCargoNestedTable;