@storm-software/workspace-tools 1.228.0 → 1.229.0

package/dist/chunk-HAT7PSQD.mjs

@@ -0,0 +1,509 @@
+import {
+  addPackageDependencies,
+  addPackageJsonExports,
+  addWorkspacePackageJsonFields,
+  copyAssets
+} from "./chunk-UDAQKEJS.mjs";
+import {
+  withRunExecutor
+} from "./chunk-6267MSX4.mjs";
+import {
+  LogLevelLabel,
+  getStopwatch,
+  isVerbose,
+  loadStormConfig,
+  writeDebug,
+  writeError,
+  writeFatal,
+  writeInfo,
+  writeSuccess,
+  writeTrace
+} from "./chunk-WJ5TU6JU.mjs";
+import {
+  joinPaths
+} from "./chunk-PVTEDLBL.mjs";
+import {
+  __name,
+  __require
+} from "./chunk-XUV4U54K.mjs";
+
+// ../unbuild/src/build.ts
+import { hfs as hfs2 } from "@humanfs/node";
+import { createProjectGraphAsync as createProjectGraphAsync2, readProjectsConfigurationFromProjectGraph, writeJsonFile } from "@nx/devkit";
+import { getHelperDependency as getHelperDependency2, HelperDependency as HelperDependency2 } from "@nx/js";
+import { calculateProjectBuildableDependencies as calculateProjectBuildableDependencies2 } from "@nx/js/src/utils/buildable-libs-utils";
+import defu from "defu";
+import { relative as relative2 } from "node:path";
+import { findWorkspaceRoot } from "nx/src/utils/find-workspace-root";
+import { build as unbuild } from "unbuild";
+
+// ../unbuild/src/clean.ts
+import { hfs } from "@humanfs/node";
+async function clean(name = "Unbuild", directory, config) {
+  writeDebug(` \u{1F9F9}  Cleaning ${name} output path: ${directory}`, config);
+  const stopwatch = getStopwatch(`${name} output clean`);
+  await hfs.deleteAll(directory);
+  stopwatch();
+}
+__name(clean, "clean");
+
+// ../unbuild/src/plugins/analyze.ts
+var formatBytes = /* @__PURE__ */ __name((bytes) => {
+  if (bytes === 0) return "0 Byte";
+  const k = 1e3;
+  const dm = 3;
+  const sizes = [
+    "Bytes",
+    "KB",
+    "MB",
+    "GB"
+  ];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / k ** i).toFixed(dm))} ${sizes[i]}`;
+}, "formatBytes");
+var analyzePlugin = /* @__PURE__ */ __name((options, resolvedOptions) => {
+  return {
+    name: "storm:analyzer",
+    renderChunk(source, chunk) {
+      const sourceBytes = formatBytes(source.length);
+      const fileName = chunk.fileName;
+      writeInfo(` - ${fileName} ${sourceBytes}`, resolvedOptions.config);
+    }
+  };
+}, "analyzePlugin");
+
+// ../unbuild/src/plugins/on-error.ts
+var onErrorPlugin = /* @__PURE__ */ __name((options, resolvedOptions) => ({
+  name: "storm:on-error",
+  buildEnd(error) {
+    if (error) {
+      writeError(`The following errors occurred during the build:
+${error ? error.message : "Unknown build error"}
+
+    `, resolvedOptions.config);
+      throw new Error("Storm unbuild process failed with errors.");
+    }
+  },
+  renderError(error) {
+    writeError(`The following errors occurred during the build:
+${error ? error.message : "Unknown build error"}
+
+  `, resolvedOptions.config);
+    throw new Error("Storm unbuild process failed with errors.");
+  }
+}), "onErrorPlugin");
+
+// ../unbuild/src/plugins/swc.ts
+var swcPlugin = /* @__PURE__ */ __name((options, resolvedOptions) => {
+  const { transform } = __require("@swc/core");
+  return {
+    name: "storm:swc",
+    transform(code, filename) {
+      return transform(code, {
+        filename,
+        jsc: {
+          transform: {
+            react: {
+              runtime: "automatic"
+            }
+          }
+        }
+      });
+    }
+  };
+}, "swcPlugin");
+
+// ../unbuild/src/plugins/tsc.ts
+import { createProjectGraphAsync } from "@nx/devkit";
+import { calculateProjectBuildableDependencies } from "@nx/js/src/utils/buildable-libs-utils";
+import { getHelperDependency, HelperDependency } from "@nx/js/src/utils/compiler-helper-dependency";
+import ts2Plugin from "rollup-plugin-typescript2";
+
+// ../unbuild/src/utilities/helpers.ts
+import { joinPathFragments } from "@nx/devkit";
+import { computeCompilerOptionsPaths } from "@nx/js/src/utils/buildable-libs-utils";
+import { dirname, extname } from "node:path";
+import { pathToFileURL } from "node:url";
+import ts from "typescript";
+async function loadConfig(configPath) {
+  if (!/\.(js|mjs)$/.test(extname(configPath))) {
+    throw new Error("Unsupported config file format");
+  }
+  return import(pathToFileURL(configPath).toString()).then((config) => config.default);
+}
+__name(loadConfig, "loadConfig");
+async function createTsCompilerOptions(config, tsConfigPath, projectRoot, dependencies) {
+  const tsConfigFile = ts.readConfigFile(joinPathFragments(config.workspaceRoot, projectRoot, tsConfigPath), ts.sys.readFile);
+  const tsConfig = ts.parseJsonConfigFileContent(tsConfigFile.config, ts.sys, dirname(joinPathFragments(config.workspaceRoot, projectRoot, tsConfigPath)));
+  const compilerOptions = {
+    rootDir: projectRoot,
+    declaration: true,
+    paths: computeCompilerOptionsPaths(tsConfig, dependencies ?? [])
+  };
+  writeTrace(compilerOptions, config);
+  return compilerOptions;
+}
+__name(createTsCompilerOptions, "createTsCompilerOptions");
+
+// ../unbuild/src/plugins/tsc.ts
+var tscPlugin = /* @__PURE__ */ __name(async (options, resolvedOptions) => {
+  const projectGraph = await createProjectGraphAsync({
+    exitOnError: true
+  });
+  const result = calculateProjectBuildableDependencies(void 0, projectGraph, resolvedOptions.config.workspaceRoot, resolvedOptions.projectName, process.env.NX_TASK_TARGET_TARGET || "build", process.env.NX_TASK_TARGET_CONFIGURATION || "production", true);
+  let dependencies = result.dependencies;
+  const tsLibDependency = getHelperDependency(HelperDependency.tsc, resolvedOptions.tsconfig, dependencies, projectGraph, true);
+  if (tsLibDependency) {
+    dependencies = dependencies.filter((deps) => deps.name !== tsLibDependency.name);
+    dependencies.push(tsLibDependency);
+  }
+  return ts2Plugin({
+    check: options.emitTypes !== false,
+    tsconfig: resolvedOptions.tsconfig,
+    tsconfigOverride: {
+      compilerOptions: await createTsCompilerOptions(resolvedOptions.config, resolvedOptions.tsconfig, resolvedOptions.projectRoot, dependencies)
+    }
+  });
+}, "tscPlugin");
+
+// ../unbuild/src/plugins/type-definitions.ts
+import { relative } from "node:path";
+var typeDefinitions = /* @__PURE__ */ __name((options, resolvedOptions) => ({
+  name: "storm:dts-bundle",
+  async generateBundle(_opts, bundle) {
+    for (const file of Object.values(bundle)) {
+      if (file.type === "asset" || !file.isEntry || file.facadeModuleId == null) {
+        continue;
+      }
+      const hasDefaultExport = file.exports.includes("default");
+      const entrySourceFileName = relative(options.projectRoot, file.facadeModuleId);
+      const entrySourceDtsName = entrySourceFileName.replace(/\.[cm]?[jt]sx?$/, "");
+      const dtsFileName = file.fileName.replace(/\.[cm]?js$/, ".d.ts");
+      const relativeSourceDtsName = JSON.stringify("./" + entrySourceDtsName);
+      const dtsFileSource = hasDefaultExport ? `
+export * from ${relativeSourceDtsName};
+export { default } from ${relativeSourceDtsName};
+            ` : `export * from ${relativeSourceDtsName};
+`;
+      this.emitFile({
+        type: "asset",
+        fileName: dtsFileName,
+        source: dtsFileSource
+      });
+    }
+  }
+}), "typeDefinitions");
+
+// ../unbuild/src/config.ts
+var getDefaultBuildPlugins = /* @__PURE__ */ __name(async (options, resolvedOptions) => Promise.all([
+  analyzePlugin(options, resolvedOptions),
+  swcPlugin(options, resolvedOptions),
+  typeDefinitions(options, resolvedOptions),
+  tscPlugin(options, resolvedOptions),
+  onErrorPlugin(options, resolvedOptions)
+].map((plugin) => Promise.resolve(plugin))), "getDefaultBuildPlugins");
+
+// ../unbuild/src/build.ts
+async function resolveOptions(options) {
+  const projectRoot = options.projectRoot;
+  if (!projectRoot) {
+    throw new Error("Cannot find project root");
+  }
+  const outputPath = options.outputPath || joinPaths("dist", projectRoot);
+  const workspaceRoot = findWorkspaceRoot(projectRoot);
+  if (!workspaceRoot) {
+    throw new Error("Cannot find workspace root");
+  }
+  const config = await loadStormConfig(workspaceRoot.dir);
+  writeDebug("  \u2699\uFE0F   Resolving build options", config);
+  const stopwatch = getStopwatch("Build options resolution");
+  if (options.configPath) {
+    const configFile = await loadConfig(options.configPath);
+    if (configFile) {
+      options = defu(options, configFile);
+    }
+  }
+  const projectGraph = await createProjectGraphAsync2({
+    exitOnError: true
+  });
+  const projectJsonPath = joinPaths(config.workspaceRoot, projectRoot, "project.json");
+  if (!await hfs2.isFile(projectJsonPath)) {
+    throw new Error("Cannot find project.json configuration");
+  }
+  const projectJson = await hfs2.json(projectJsonPath);
+  const projectName = projectJson.name;
+  const packageJsonPath = joinPaths(workspaceRoot.dir, projectRoot, "package.json");
+  if (!await hfs2.isFile(packageJsonPath)) {
+    throw new Error("Cannot find package.json configuration");
+  }
+  const packageJson = await hfs2.json(packageJsonPath);
+  let tsconfig = options.tsconfig;
+  if (!tsconfig) {
+    tsconfig = joinPaths(workspaceRoot.dir, projectRoot, "tsconfig.json");
+  }
+  if (!await hfs2.isFile(tsconfig)) {
+    throw new Error("Cannot find tsconfig.json configuration");
+  }
+  let sourceRoot = projectJson.sourceRoot;
+  if (!sourceRoot) {
+    sourceRoot = joinPaths(projectRoot, "src");
+  }
+  if (!await hfs2.isDirectory(sourceRoot)) {
+    throw new Error("Cannot find sourceRoot directory");
+  }
+  const projectConfigurations = readProjectsConfigurationFromProjectGraph(projectGraph);
+  if (!projectConfigurations?.projects?.[projectName]) {
+    throw new Error("The Build process failed because the project does not have a valid configuration in the project.json file. Check if the file exists in the root of the project.");
+  }
+  const result = calculateProjectBuildableDependencies2(void 0, projectGraph, workspaceRoot.dir, projectName, process.env.NX_TASK_TARGET_TARGET || "build", process.env.NX_TASK_TARGET_CONFIGURATION || "production", true);
+  let dependencies = result.dependencies;
+  const tsLibDependency = getHelperDependency2(HelperDependency2.tsc, tsconfig, dependencies, projectGraph, true);
+  if (tsLibDependency) {
+    dependencies = dependencies.filter((deps) => deps.name !== tsLibDependency.name);
+    dependencies.push(tsLibDependency);
+  }
+  const resolvedOptions = {
+    name: projectName,
+    config,
+    projectRoot,
+    sourceRoot,
+    projectName,
+    tsconfig,
+    clean: false,
+    entries: [
+      {
+        builder: "mkdist",
+        input: `.${sourceRoot.replace(projectRoot, "")}`,
+        outDir: joinPaths(relative2(joinPaths(config.workspaceRoot, projectRoot), config.workspaceRoot).replaceAll("\\", "/"), outputPath, "dist").replaceAll("\\", "/"),
+        declaration: options.emitTypes !== false,
+        format: "esm"
+      },
+      {
+        builder: "mkdist",
+        input: `.${sourceRoot.replace(projectRoot, "")}`,
+        outDir: joinPaths(relative2(joinPaths(config.workspaceRoot, projectRoot), config.workspaceRoot).replaceAll("\\", "/"), outputPath, "dist").replaceAll("\\", "/"),
+        declaration: options.emitTypes !== false,
+        format: "cjs",
+        ext: "cjs"
+      }
+    ],
+    declaration: options.emitTypes !== false ? "compatible" : false,
+    failOnWarn: false,
+    sourcemap: options.sourcemap ?? !!options.debug,
+    outDir: outputPath,
+    parallel: true,
+    stub: false,
+    stubOptions: {
+      jiti: {}
+    },
+    externals: options.external ?? [],
+    dependencies: [],
+    peerDependencies: [],
+    devDependencies: [],
+    hooks: {},
+    alias: {},
+    replace: {},
+    rollup: {
+      replace: {},
+      alias: {},
+      json: {},
+      commonjs: {
+        sourceMap: options.sourcemap ?? true
+      },
+      emitCJS: true,
+      cjsBridge: true,
+      dts: {
+        respectExternal: true,
+        tsconfig
+      },
+      output: {
+        banner: options.banner || `
+//      \u26A1 Built by Storm Software
+  `,
+        footer: options.footer
+      },
+      resolve: {
+        preferBuiltins: true,
+        extensions: [
+          ".cjs",
+          ".mjs",
+          ".js",
+          ".jsx",
+          ".ts",
+          ".tsx",
+          ".json"
+        ]
+      },
+      esbuild: {
+        minify: !!options.minify,
+        splitting: options.splitting !== false,
+        treeShaking: options.treeShaking !== false,
+        color: true,
+        logLevel: config.logLevel === LogLevelLabel.FATAL ? LogLevelLabel.ERROR : isVerbose() ? "verbose" : config.logLevel
+      }
+    }
+  };
+  dependencies = dependencies.filter((dep) => dep.node.type === "npm" || dep.node.type === "lib" || dep.node.type === "app");
+  if (dependencies.length > 0) {
+    resolvedOptions.dependencies = dependencies.map((dep) => dep.name);
+  }
+  if (packageJson.devDependencies) {
+    resolvedOptions.devDependencies = Object.keys(packageJson.devDependencies);
+  }
+  if (packageJson.peerDependencies) {
+    resolvedOptions.peerDependencies = Object.keys(packageJson.peerDependencies);
+  }
+  if (options.rollup) {
+    let rollup = {};
+    if (typeof options.rollup === "string") {
+      const rollupFile = await loadConfig(options.rollup);
+      if (rollupFile) {
+        rollup = rollupFile;
+      }
+    } else {
+      rollup = options.rollup;
+    }
+    resolvedOptions.rollup = defu(resolvedOptions.rollup ?? {}, rollup);
+  }
+  resolvedOptions.hooks = {
+    "rollup:options": /* @__PURE__ */ __name(async (ctx, opts) => {
+      opts.plugins = options.plugins ?? await getDefaultBuildPlugins(options, resolvedOptions);
+    }, "rollup:options")
+  };
+  stopwatch();
+  return resolvedOptions;
+}
+__name(resolveOptions, "resolveOptions");
+async function generatePackageJson(options) {
+  if (options.generatePackageJson !== false && await hfs2.isFile(joinPaths(options.projectRoot, "package.json"))) {
+    writeDebug("  \u270D\uFE0F   Writing package.json file", options.config);
+    const stopwatch = getStopwatch("Write package.json file");
+    const packageJsonPath = joinPaths(options.projectRoot, "project.json");
+    if (!await hfs2.isFile(packageJsonPath)) {
+      throw new Error("Cannot find package.json configuration");
+    }
+    let packageJson = await hfs2.json(joinPaths(options.config.workspaceRoot, options.projectRoot, "package.json"));
+    if (!packageJson) {
+      throw new Error("Cannot find package.json configuration file");
+    }
+    packageJson = await addPackageDependencies(options.config.workspaceRoot, options.projectRoot, options.projectName, packageJson);
+    packageJson = await addWorkspacePackageJsonFields(options.config, options.projectRoot, options.sourceRoot, options.projectName, false, packageJson);
+    packageJson = await addPackageJsonExports(options.sourceRoot, packageJson);
+    await writeJsonFile(joinPaths(options.outDir, "package.json"), packageJson);
+    stopwatch();
+  }
+  return options;
+}
+__name(generatePackageJson, "generatePackageJson");
+async function executeUnbuild(options) {
+  writeDebug(`  \u{1F680}  Running ${options.name} (${options.projectRoot}) build`, options.config);
+  const stopwatch = getStopwatch(`${options.name} (${options.projectRoot}) build`);
+  try {
+    await unbuild(options.projectRoot, false, {
+      ...options,
+      rootDir: options.projectRoot
+    });
+  } finally {
+    stopwatch();
+  }
+  return options;
+}
+__name(executeUnbuild, "executeUnbuild");
+async function copyBuildAssets(options) {
+  writeDebug(`  \u{1F4CB}  Copying asset files to output directory: ${options.outDir}`, options.config);
+  const stopwatch = getStopwatch(`${options.name} asset copy`);
+  await copyAssets(options.config, options.assets ?? [], options.outDir, options.projectRoot, options.projectName, options.sourceRoot, options.generatePackageJson, options.includeSrc);
+  stopwatch();
+  return options;
+}
+__name(copyBuildAssets, "copyBuildAssets");
+async function cleanOutputPath(options) {
+  if (options.clean !== false && options.outDir) {
+    await clean(options.name, options.outDir, options.config);
+  }
+  return options;
+}
+__name(cleanOutputPath, "cleanOutputPath");
+async function build(options) {
+  writeDebug(` \u26A1  Executing Storm Unbuild pipeline`);
+  const stopwatch = getStopwatch("Unbuild pipeline");
+  try {
+    const resolvedOptions = await resolveOptions(options);
+    await cleanOutputPath(resolvedOptions);
+    await generatePackageJson(resolvedOptions);
+    await executeUnbuild(resolvedOptions);
+    await copyBuildAssets(resolvedOptions);
+    writeSuccess(`  \u{1F3C1}  The ${resolvedOptions.name} build completed successfully`, resolvedOptions.config);
+  } catch (error) {
+    writeFatal("  \u274C  Fatal errors occurred during the build that could not be recovered from. The build process has been terminated.");
+    throw error;
+  } finally {
+    stopwatch();
+  }
+}
+__name(build, "build");
+
+// src/executors/unbuild/executor.ts
+import { defu as defu2 } from "defu";
+async function unbuildExecutorFn(options, context, config) {
+  writeInfo("\u{1F4E6}  Running Storm Unbuild executor on the workspace", config);
+  if (!context.projectsConfigurations?.projects || !context.projectName || !context.projectsConfigurations.projects[context.projectName] || !context.projectsConfigurations.projects[context.projectName]?.root) {
+    throw new Error("The Build process failed because the context is not valid. Please run this command from a workspace.");
+  }
+  await build(defu2({
+    ...options,
+    projectRoot: context.projectsConfigurations.projects?.[context.projectName].root,
+    projectName: context.projectName,
+    sourceRoot: context.projectsConfigurations.projects?.[context.projectName]?.sourceRoot,
+    platform: options.platform,
+    name: context.projectName
+  }, {
+    stubOptions: {
+      jiti: {
+        cache: "node_modules/.cache/storm"
+      }
+    },
+    rollup: {
+      emitCJS: true,
+      watch: false,
+      cjsBridge: false,
+      dts: {
+        respectExternal: true
+      },
+      replace: {},
+      alias: {},
+      resolve: {},
+      json: {},
+      commonjs: {},
+      esbuild: {
+        target: options.target,
+        format: "esm",
+        platform: options.platform,
+        minify: options.minify,
+        treeShaking: options.treeShaking
+      }
+    }
+  }));
+  return {
+    success: true
+  };
+}
+__name(unbuildExecutorFn, "unbuildExecutorFn");
+var executor_default = withRunExecutor("TypeScript Unbuild build", unbuildExecutorFn, {
+  skipReadingConfig: false,
+  hooks: {
+    applyDefaultOptions: /* @__PURE__ */ __name(async (options, config) => {
+      options.entry ??= [
+        "{sourceRoot}"
+      ];
+      options.outputPath ??= "dist/{projectRoot}";
+      options.tsconfig ??= "{projectRoot}/tsconfig.json";
+      return options;
+    }, "applyDefaultOptions")
+  }
+});
+
+export {
+  unbuildExecutorFn,
+  executor_default
+};

package/dist/chunk-HI4G4OOG.js

@@ -0,0 +1,40 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/utils/versions.ts
+var tsupVersion = "^7.2.0";
+var prettierPackageJsonVersion = "2.4.6";
+var prettierPrismaVersion = "5.0.0";
+var prettierVersion = "^3.0.3";
+var swcCliVersion = "~0.1.62";
+var swcCoreVersion = "~1.3.95";
+var swcHelpersVersion = "~0.5.3";
+var swcNodeVersion = "1.6.8";
+var tsLibVersion = "2.6.2";
+var typesNodeVersion = "20.9.0";
+var verdaccioVersion = "5.27.0";
+var typescriptVersion = "~5.2.2";
+var eslintVersion = "~8.53.0";
+var lintStagedVersion = "15.0.2";
+var semanticReleaseVersion = "22.0.7";
+var nxVersion = "^18.0.4";
+var nodeVersion = "20.11.0";
+var pnpmVersion = "8.10.2";
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.tsupVersion = tsupVersion; exports.prettierPackageJsonVersion = prettierPackageJsonVersion; exports.prettierPrismaVersion = prettierPrismaVersion; exports.prettierVersion = prettierVersion; exports.swcCliVersion = swcCliVersion; exports.swcCoreVersion = swcCoreVersion; exports.swcHelpersVersion = swcHelpersVersion; exports.swcNodeVersion = swcNodeVersion; exports.tsLibVersion = tsLibVersion; exports.typesNodeVersion = typesNodeVersion; exports.verdaccioVersion = verdaccioVersion; exports.typescriptVersion = typescriptVersion; exports.eslintVersion = eslintVersion; exports.lintStagedVersion = lintStagedVersion; exports.semanticReleaseVersion = semanticReleaseVersion; exports.nxVersion = nxVersion; exports.nodeVersion = nodeVersion; exports.pnpmVersion = pnpmVersion;

package/dist/chunk-I734UVDT.js

@@ -0,0 +1,22 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/base/base-executor.untyped.ts
+var _untyped = require('untyped');
+var base_executor_untyped_default = _untyped.defineUntypedSchema.call(void 0, {
+  $schema: {
+    id: "baseExecutor",
+    title: "Base Executor",
+    description: "A base type definition for an executor schema"
+  },
+  outputPath: {
+    $schema: {
+      title: "Output Path",
+      type: "string",
+      format: "path",
+      description: "The output path for the build"
+    },
+    $default: "dist/{projectRoot}"
+  }
+});
+
+
+
+exports.base_executor_untyped_default = base_executor_untyped_default;

package/dist/chunk-I7OZOKTH.js

@@ -0,0 +1,65 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+
+var _chunkFBLF4KJFjs = require('./chunk-FBLF4KJF.js');
+
+
+var _chunkHI4G4OOGjs = require('./chunk-HI4G4OOG.js');
+
+
+var _chunkNCVJPQSPjs = require('./chunk-NCVJPQSP.js');
+
+
+var _chunk3GQAWCBQjs = require('./chunk-3GQAWCBQ.js');
+
+// src/generators/node-library/generator.ts
+var _devkit = require('@nx/devkit');
+async function nodeLibraryGeneratorFn(tree, schema, config) {
+  const filesDir = _devkit.joinPathFragments.call(void 0, __dirname, "./files");
+  const tsLibraryGeneratorOptions = {
+    platform: "node",
+    devDependencies: {
+      "@types/node": _chunkHI4G4OOGjs.typesNodeVersion
+    },
+    buildExecutor: "@storm-software/workspace-tools:unbuild",
+    ...schema,
+    directory: schema.directory,
+    description: schema.description
+  };
+  const options = await _chunkFBLF4KJFjs.normalizeOptions.call(void 0, tree, tsLibraryGeneratorOptions);
+  const { className, name, propertyName } = _devkit.names.call(void 0, options.name);
+  _devkit.generateFiles.call(void 0, tree, filesDir, options.projectRoot, {
+    ...schema,
+    dot: ".",
+    className,
+    name,
+    namespace: _nullishCoalesce(process.env.STORM_NAMESPACE, () => ( "storm-software")),
+    description: _nullishCoalesce(schema.description, () => ( "")),
+    propertyName,
+    js: !!options.js,
+    cliCommand: "nx",
+    strict: void 0,
+    tmpl: "",
+    offsetFromRoot: _devkit.offsetFromRoot.call(void 0, options.projectRoot),
+    buildable: options.bundler && options.bundler !== "none",
+    hasUnitTestRunner: options.unitTestRunner !== "none"
+  });
+  await _chunkFBLF4KJFjs.typeScriptLibraryGeneratorFn.call(void 0, tree, tsLibraryGeneratorOptions, config);
+  await _devkit.formatFiles.call(void 0, tree);
+  return null;
+}
+_chunk3GQAWCBQjs.__name.call(void 0, nodeLibraryGeneratorFn, "nodeLibraryGeneratorFn");
+var generator_default = _chunkNCVJPQSPjs.withRunGenerator.call(void 0, "TypeScript Library Creator (NodeJs Platform)", nodeLibraryGeneratorFn, {
+  hooks: {
+    applyDefaultOptions: /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, (options) => {
+      options.description ??= "A library used by Storm Software to support NodeJs applications";
+      options.platform ??= "node";
+      return options;
+    }, "applyDefaultOptions")
+  }
+});
+
+
+
+
+exports.nodeLibraryGeneratorFn = nodeLibraryGeneratorFn; exports.generator_default = generator_default;