@storm-software/workspace-tools 1.295.86 → 1.296.1

package/dist/chunk-4VWDSVQJ.mjs

@@ -0,0 +1,321 @@
+import {
+  nxVersion
+} from "./chunk-QC5ON3X4.mjs";
+import {
+  ProjectTagConstants,
+  addProjectTag
+} from "./chunk-2GQSCZ3J.mjs";
+import {
+  joinPaths
+} from "./chunk-TBW5MCN6.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, options, config) {
+  const normalized = await normalizeOptions(tree, { ...options });
+  const tasks = [];
+  tasks.push(
+    await jsInitGenerator(tree, {
+      ...normalized,
+      tsConfigName: normalized.rootProject ? "tsconfig.json" : "tsconfig.base.json"
+    })
+  );
+  tasks.push(
+    addDependenciesToPackageJson(
+      tree,
+      {},
+      {
+        "@storm-software/workspace-tools": "latest",
+        "@storm-software/testing-tools": "latest",
+        ...options.devDependencies ?? {}
+      }
+    )
+  );
+  if (normalized.publishable) {
+    tasks.push(await setupVerdaccio(tree, { ...normalized, skipFormat: true }));
+  }
+  const projectConfig = {
+    root: normalized.directory,
+    projectType: "library",
+    sourceRoot: joinPaths(normalized.directory ?? "", "src"),
+    targets: {
+      build: {
+        executor: options.buildExecutor,
+        outputs: ["{options.outputPath}"],
+        options: {
+          entry: [joinPaths(normalized.projectRoot, "src", "index.ts")],
+          outputPath: getOutputPath(normalized),
+          tsconfig: joinPaths(normalized.projectRoot, "tsconfig.json"),
+          project: joinPaths(normalized.projectRoot, "package.json"),
+          defaultConfiguration: "production",
+          platform: "neutral",
+          assets: [
+            {
+              input: normalized.projectRoot,
+              glob: "*.md",
+              output: "/"
+            },
+            {
+              input: "",
+              glob: "LICENSE",
+              output: "/"
+            }
+          ]
+        },
+        configurations: {
+          production: {
+            debug: false,
+            verbose: false
+          },
+          development: {
+            debug: true,
+            verbose: true
+          }
+        }
+      }
+    }
+  };
+  if (options.platform) {
+    projectConfig.targets.build.options.platform = options.platform === "worker" ? "node" : options.platform;
+  }
+  addProjectTag(
+    projectConfig,
+    ProjectTagConstants.Platform.TAG_ID,
+    options.platform === "node" ? ProjectTagConstants.Platform.NODE : options.platform === "worker" ? ProjectTagConstants.Platform.WORKER : options.platform === "browser" ? ProjectTagConstants.Platform.BROWSER : ProjectTagConstants.Platform.NEUTRAL,
+    { overwrite: false }
+  );
+  createProjectTsConfigJson(tree, normalized);
+  addProjectConfiguration(tree, normalized.name, projectConfig);
+  let repository = {
+    type: "github",
+    url: config?.repository || `https://github.com/${(typeof config?.organization === "string" ? config?.organization : config?.organization?.name) || "storm-software"}/${config?.namespace || config?.name || "repository"}.git`
+  };
+  let description = options.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 (!normalized.importPath) {
+    normalized.importPath = normalized.name;
+  }
+  const packageJsonPath = joinPaths(normalized.projectRoot, "package.json");
+  if (tree.exists(packageJsonPath)) {
+    updateJson(tree, packageJsonPath, (json) => {
+      if (!normalized.importPath) {
+        normalized.importPath = normalized.name;
+      }
+      json.name = normalized.importPath;
+      json.version = "0.0.1";
+      if (json.private && (normalized.publishable || normalized.rootProject)) {
+        json.private = void 0;
+      }
+      return {
+        ...json,
+        version: "0.0.1",
+        description,
+        repository: {
+          ...repository,
+          directory: normalized.projectRoot
+        },
+        type: "module",
+        dependencies: {
+          ...json.dependencies
+        },
+        publishConfig: {
+          access: "public"
+        }
+      };
+    });
+  } else {
+    writeJson(tree, packageJsonPath, {
+      name: normalized.importPath,
+      version: "0.0.1",
+      description,
+      repository: {
+        ...repository,
+        directory: normalized.projectRoot
+      },
+      private: !normalized.publishable || normalized.rootProject,
+      type: "module",
+      publishConfig: {
+        access: "public"
+      }
+    });
+  }
+  if (tree.exists("package.json") && normalized.importPath) {
+    updateJson(tree, "package.json", (json) => ({
+      ...json,
+      pnpm: {
+        ...json?.pnpm,
+        overrides: {
+          ...json?.pnpm?.overrides,
+          [normalized.importPath ?? ""]: "workspace:*"
+        }
+      }
+    }));
+  }
+  addTsConfigPath(tree, normalized.importPath, [
+    joinPaths(
+      normalized.projectRoot,
+      "./src",
+      `index.${normalized.js ? "js" : "ts"}`
+    )
+  ]);
+  addTsConfigPath(tree, joinPaths(normalized.importPath, "/*"), [
+    joinPaths(normalized.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(normalized.projectRoot, "tsconfig.json");
+  if (tree.exists(tsconfigPath)) {
+    updateJson(tree, tsconfigPath, (json) => {
+      json.composite ??= true;
+      return json;
+    });
+  } else {
+    writeJson(tree, tsconfigPath, {
+      extends: `${offsetFromRoot(normalized.projectRoot)}tsconfig.base.json`,
+      composite: true,
+      compilerOptions: {
+        outDir: `${offsetFromRoot(normalized.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;
+}
+function getOutputPath(options) {
+  const parts = ["dist"];
+  if (options.projectRoot === ".") {
+    parts.push(options.name);
+  } else {
+    parts.push(options.projectRoot);
+  }
+  return joinPaths(...parts);
+}
+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);
+}
+async function normalizeOptions(tree, options, config) {
+  let importPath = options.importPath;
+  if (!importPath && config?.namespace) {
+    importPath = `@${config?.namespace}/${options.name}`;
+  }
+  if (options.publishable) {
+    if (!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 rootProject = false;
+  const {
+    projectName,
+    names: projectNames,
+    projectRoot,
+    importPath: normalizedImportPath
+  } = await determineProjectNameAndRootOptions(tree, {
+    name: options.name,
+    projectType: "library",
+    directory: options.directory,
+    importPath,
+    rootProject
+  });
+  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: normalizedImportPath,
+    rootProject,
+    shouldUseSwcJest: false
+  };
+}
+
+export {
+  typeScriptLibraryGeneratorFn,
+  getOutputPath,
+  createProjectTsConfigJson,
+  normalizeOptions
+};

package/dist/chunk-54BBSJHK.mjs

@@ -0,0 +1,40 @@
+import {
+  joinPaths
+} from "./chunk-TBW5MCN6.mjs";
+
+// src/utils/github.ts
+import { createJiti } from "jiti";
+async function getGitHubTools(workspaceConfig) {
+  try {
+    const jiti = createJiti(workspaceConfig.workspaceRoot, {
+      fsCache: workspaceConfig.skipCache ? false : joinPaths(
+        workspaceConfig.workspaceRoot,
+        workspaceConfig.directories.cache || "node_modules/.cache/storm",
+        "jiti"
+      ),
+      interopDefault: true
+    });
+    const core = await jiti.import(
+      jiti.esmResolve("@actions/core")
+    );
+    return {
+      error: core.error,
+      warning: core.warning,
+      info: core.info,
+      getIDToken: core.getIDToken
+    };
+  } catch {
+    return {
+      error: (message) => console.error(message),
+      warning: (message) => console.warn(message),
+      info: (message) => console.log(message),
+      getIDToken: async () => {
+        throw new Error("getIDToken is not supported in this environment");
+      }
+    };
+  }
+}
+
+export {
+  getGitHubTools
+};

package/dist/chunk-57OGFZNB.js

@@ -0,0 +1,321 @@
+"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 _chunkSZWM7COVjs = require('./chunk-SZWM7COV.js');
+
+
+
+var _chunkTAP26ZJQjs = require('./chunk-TAP26ZJQ.js');
+
+
+var _chunkCQDBLKPFjs = require('./chunk-CQDBLKPF.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, options, config) {
+  const normalized = await normalizeOptions(tree, { ...options });
+  const tasks = [];
+  tasks.push(
+    await _init2.default.call(void 0, tree, {
+      ...normalized,
+      tsConfigName: normalized.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(options.devDependencies, () => ( {}))
+      }
+    )
+  );
+  if (normalized.publishable) {
+    tasks.push(await _generator2.default.call(void 0, tree, { ...normalized, skipFormat: true }));
+  }
+  const projectConfig = {
+    root: normalized.directory,
+    projectType: "library",
+    sourceRoot: _chunkCQDBLKPFjs.joinPaths.call(void 0, _nullishCoalesce(normalized.directory, () => ( "")), "src"),
+    targets: {
+      build: {
+        executor: options.buildExecutor,
+        outputs: ["{options.outputPath}"],
+        options: {
+          entry: [_chunkCQDBLKPFjs.joinPaths.call(void 0, normalized.projectRoot, "src", "index.ts")],
+          outputPath: getOutputPath(normalized),
+          tsconfig: _chunkCQDBLKPFjs.joinPaths.call(void 0, normalized.projectRoot, "tsconfig.json"),
+          project: _chunkCQDBLKPFjs.joinPaths.call(void 0, normalized.projectRoot, "package.json"),
+          defaultConfiguration: "production",
+          platform: "neutral",
+          assets: [
+            {
+              input: normalized.projectRoot,
+              glob: "*.md",
+              output: "/"
+            },
+            {
+              input: "",
+              glob: "LICENSE",
+              output: "/"
+            }
+          ]
+        },
+        configurations: {
+          production: {
+            debug: false,
+            verbose: false
+          },
+          development: {
+            debug: true,
+            verbose: true
+          }
+        }
+      }
+    }
+  };
+  if (options.platform) {
+    projectConfig.targets.build.options.platform = options.platform === "worker" ? "node" : options.platform;
+  }
+  _chunkTAP26ZJQjs.addProjectTag.call(void 0, 
+    projectConfig,
+    _chunkTAP26ZJQjs.ProjectTagConstants.Platform.TAG_ID,
+    options.platform === "node" ? _chunkTAP26ZJQjs.ProjectTagConstants.Platform.NODE : options.platform === "worker" ? _chunkTAP26ZJQjs.ProjectTagConstants.Platform.WORKER : options.platform === "browser" ? _chunkTAP26ZJQjs.ProjectTagConstants.Platform.BROWSER : _chunkTAP26ZJQjs.ProjectTagConstants.Platform.NEUTRAL,
+    { overwrite: false }
+  );
+  createProjectTsConfigJson(tree, normalized);
+  _devkit.addProjectConfiguration.call(void 0, tree, normalized.name, projectConfig);
+  let repository = {
+    type: "github",
+    url: _optionalChain([config, 'optionalAccess', _ => _.repository]) || `https://github.com/${(typeof _optionalChain([config, 'optionalAccess', _2 => _2.organization]) === "string" ? _optionalChain([config, 'optionalAccess', _3 => _3.organization]) : _optionalChain([config, 'optionalAccess', _4 => _4.organization, 'optionalAccess', _5 => _5.name])) || "storm-software"}/${_optionalChain([config, 'optionalAccess', _6 => _6.namespace]) || _optionalChain([config, 'optionalAccess', _7 => _7.name]) || "repository"}.git`
+  };
+  let description = options.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', _8 => _8.repository])) {
+      repository = packageJson.repository;
+    }
+    if (_optionalChain([packageJson, 'optionalAccess', _9 => _9.description])) {
+      description = packageJson.description;
+    }
+  }
+  if (!normalized.importPath) {
+    normalized.importPath = normalized.name;
+  }
+  const packageJsonPath = _chunkCQDBLKPFjs.joinPaths.call(void 0, normalized.projectRoot, "package.json");
+  if (tree.exists(packageJsonPath)) {
+    _devkit.updateJson.call(void 0, tree, packageJsonPath, (json) => {
+      if (!normalized.importPath) {
+        normalized.importPath = normalized.name;
+      }
+      json.name = normalized.importPath;
+      json.version = "0.0.1";
+      if (json.private && (normalized.publishable || normalized.rootProject)) {
+        json.private = void 0;
+      }
+      return {
+        ...json,
+        version: "0.0.1",
+        description,
+        repository: {
+          ...repository,
+          directory: normalized.projectRoot
+        },
+        type: "module",
+        dependencies: {
+          ...json.dependencies
+        },
+        publishConfig: {
+          access: "public"
+        }
+      };
+    });
+  } else {
+    _devkit.writeJson.call(void 0, tree, packageJsonPath, {
+      name: normalized.importPath,
+      version: "0.0.1",
+      description,
+      repository: {
+        ...repository,
+        directory: normalized.projectRoot
+      },
+      private: !normalized.publishable || normalized.rootProject,
+      type: "module",
+      publishConfig: {
+        access: "public"
+      }
+    });
+  }
+  if (tree.exists("package.json") && normalized.importPath) {
+    _devkit.updateJson.call(void 0, tree, "package.json", (json) => ({
+      ...json,
+      pnpm: {
+        ..._optionalChain([json, 'optionalAccess', _10 => _10.pnpm]),
+        overrides: {
+          ..._optionalChain([json, 'optionalAccess', _11 => _11.pnpm, 'optionalAccess', _12 => _12.overrides]),
+          [_nullishCoalesce(normalized.importPath, () => ( ""))]: "workspace:*"
+        }
+      }
+    }));
+  }
+  _js.addTsConfigPath.call(void 0, tree, normalized.importPath, [
+    _chunkCQDBLKPFjs.joinPaths.call(void 0, 
+      normalized.projectRoot,
+      "./src",
+      `index.${normalized.js ? "js" : "ts"}`
+    )
+  ]);
+  _js.addTsConfigPath.call(void 0, tree, _chunkCQDBLKPFjs.joinPaths.call(void 0, normalized.importPath, "/*"), [
+    _chunkCQDBLKPFjs.joinPaths.call(void 0, normalized.projectRoot, "./src", "/*")
+  ]);
+  if (tree.exists("package.json")) {
+    const packageJson = _devkit.readJson.call(void 0, tree, "package.json");
+    if (_optionalChain([packageJson, 'optionalAccess', _13 => _13.repository])) {
+      repository = packageJson.repository;
+    }
+    if (_optionalChain([packageJson, 'optionalAccess', _14 => _14.description])) {
+      description = packageJson.description;
+    }
+  }
+  const tsconfigPath = _chunkCQDBLKPFjs.joinPaths.call(void 0, normalized.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, normalized.projectRoot)}tsconfig.base.json`,
+      composite: true,
+      compilerOptions: {
+        outDir: `${_devkit.offsetFromRoot.call(void 0, normalized.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;
+}
+function getOutputPath(options) {
+  const parts = ["dist"];
+  if (options.projectRoot === ".") {
+    parts.push(options.name);
+  } else {
+    parts.push(options.projectRoot);
+  }
+  return _chunkCQDBLKPFjs.joinPaths.call(void 0, ...parts);
+}
+function createProjectTsConfigJson(tree, options) {
+  const tsconfig = {
+    extends: options.rootProject ? void 0 : _js.getRelativePathToRootTsConfig.call(void 0, tree, options.projectRoot),
+    ..._nullishCoalesce(_optionalChain([options, 'optionalAccess', _15 => _15.tsconfigOptions]), () => ( {})),
+    compilerOptions: {
+      ...options.rootProject ? _js.tsConfigBaseOptions : {},
+      outDir: _chunkCQDBLKPFjs.joinPaths.call(void 0, _devkit.offsetFromRoot.call(void 0, options.projectRoot), "dist/out-tsc"),
+      noEmit: true,
+      ..._nullishCoalesce(_optionalChain([options, 'optionalAccess', _16 => _16.tsconfigOptions, 'optionalAccess', _17 => _17.compilerOptions]), () => ( {}))
+    },
+    files: [..._nullishCoalesce(_optionalChain([options, 'optionalAccess', _18 => _18.tsconfigOptions, 'optionalAccess', _19 => _19.files]), () => ( []))],
+    include: [
+      ..._nullishCoalesce(_optionalChain([options, 'optionalAccess', _20 => _20.tsconfigOptions, 'optionalAccess', _21 => _21.include]), () => ( [])),
+      "src/**/*.ts",
+      "src/**/*.js",
+      "bin/**/*"
+    ],
+    exclude: [
+      ..._nullishCoalesce(_optionalChain([options, 'optionalAccess', _22 => _22.tsconfigOptions, 'optionalAccess', _23 => _23.exclude]), () => ( [])),
+      "jest.config.ts",
+      "src/**/*.spec.ts",
+      "src/**/*.test.ts"
+    ]
+  };
+  _devkit.writeJson.call(void 0, tree, _chunkCQDBLKPFjs.joinPaths.call(void 0, options.projectRoot, "tsconfig.json"), tsconfig);
+}
+async function normalizeOptions(tree, options, config) {
+  let importPath = options.importPath;
+  if (!importPath && _optionalChain([config, 'optionalAccess', _24 => _24.namespace])) {
+    importPath = `@${_optionalChain([config, 'optionalAccess', _25 => _25.namespace])}/${options.name}`;
+  }
+  if (options.publishable) {
+    if (!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", _chunkSZWM7COVjs.nxVersion);
+  const rootProject = false;
+  const {
+    projectName,
+    names: projectNames,
+    projectRoot,
+    importPath: normalizedImportPath
+  } = await _projectnameandrootutils.determineProjectNameAndRootOptions.call(void 0, tree, {
+    name: options.name,
+    projectType: "library",
+    directory: options.directory,
+    importPath,
+    rootProject
+  });
+  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: normalizedImportPath,
+    rootProject,
+    shouldUseSwcJest: false
+  };
+}
+
+
+
+
+
+
+exports.typeScriptLibraryGeneratorFn = typeScriptLibraryGeneratorFn; exports.getOutputPath = getOutputPath; exports.createProjectTsConfigJson = createProjectTsConfigJson; exports.normalizeOptions = normalizeOptions;