@storm-software/pulumi-tools 0.7.4 → 0.7.6

package/dist/{chunk-MEALEKRV.js → chunk-FN7UDXGG.js}

@@ -227,22 +227,131 @@ var _promises = require('fs/promises'); var _promises2 = _interopRequireDefault(
 var _path = require('path'); var path6 = _interopRequireWildcard(_path);
 
 // ../config-tools/src/utilities/correct-paths.ts
-var _devkit = require('@nx/devkit');
-var correctPaths = /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, (path7) => {
-  if (!path7) {
-    return "";
+var _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input = "") {
+  if (!input) {
+    return input;
+  }
+  return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+_chunk3GQAWCBQjs.__name.call(void 0, normalizeWindowsPath, "normalizeWindowsPath");
+var _UNC_REGEX = /^[/\\]{2}/;
+var _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+var _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+var correctPaths = /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, function(path7) {
+  if (!path7 || path7.length === 0) {
+    return ".";
+  }
+  path7 = normalizeWindowsPath(path7);
+  const isUNCPath = path7.match(_UNC_REGEX);
+  const isPathAbsolute = isAbsolute(path7);
+  const trailingSeparator = path7[path7.length - 1] === "/";
+  path7 = normalizeString(path7, !isPathAbsolute);
+  if (path7.length === 0) {
+    if (isPathAbsolute) {
+      return "/";
+    }
+    return trailingSeparator ? "./" : ".";
+  }
+  if (trailingSeparator) {
+    path7 += "/";
   }
-  if (!path7.toUpperCase().startsWith("C:") && path7.includes("\\")) {
-    path7 = `C:${path7}`;
+  if (_DRIVE_LETTER_RE.test(path7)) {
+    path7 += "/";
   }
-  return path7.replaceAll("\\", "/");
+  if (isUNCPath) {
+    if (!isPathAbsolute) {
+      return `//./${path7}`;
+    }
+    return `//${path7}`;
+  }
+  return isPathAbsolute && !isAbsolute(path7) ? `/${path7}` : path7;
 }, "correctPaths");
-var joinPaths = /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, (...paths) => {
-  if (!paths || paths.length === 0) {
-    return "";
+var joinPaths = /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, function(...segments) {
+  let path7 = "";
+  for (const seg of segments) {
+    if (!seg) {
+      continue;
+    }
+    if (path7.length > 0) {
+      const pathTrailing = path7[path7.length - 1] === "/";
+      const segLeading = seg[0] === "/";
+      const both = pathTrailing && segLeading;
+      if (both) {
+        path7 += seg.slice(1);
+      } else {
+        path7 += pathTrailing || segLeading ? seg : `/${seg}`;
+      }
+    } else {
+      path7 += seg;
+    }
   }
-  return correctPaths(_devkit.joinPathFragments.call(void 0, ...paths.map((path7) => correctPaths(path7))));
+  return correctPaths(path7);
 }, "joinPaths");
+function normalizeString(path7, allowAboveRoot) {
+  let res = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let char = null;
+  for (let index = 0; index <= path7.length; ++index) {
+    if (index < path7.length) {
+      char = path7[index];
+    } else if (char === "/") {
+      break;
+    } else {
+      char = "/";
+    }
+    if (char === "/") {
+      if (lastSlash === index - 1 || dots === 1) {
+      } else if (dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+          if (res.length > 2) {
+            const lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex === -1) {
+              res = "";
+              lastSegmentLength = 0;
+            } else {
+              res = res.slice(0, lastSlashIndex);
+              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+            }
+            lastSlash = index;
+            dots = 0;
+            continue;
+          } else if (res.length > 0) {
+            res = "";
+            lastSegmentLength = 0;
+            lastSlash = index;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          res += res.length > 0 ? "/.." : "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0) {
+          res += `/${path7.slice(lastSlash + 1, index)}`;
+        } else {
+          res = path7.slice(lastSlash + 1, index);
+        }
+        lastSegmentLength = index - lastSlash - 1;
+      }
+      lastSlash = index;
+      dots = 0;
+    } else if (char === "." && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+_chunk3GQAWCBQjs.__name.call(void 0, normalizeString, "normalizeString");
+var isAbsolute = /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, function(p) {
+  return _IS_ABSOLUTE_RE.test(p);
+}, "isAbsolute");
 
 // ../config-tools/src/utilities/find-up.ts
 
@@ -1348,7 +1457,7 @@ ${Object.keys(_nullishCoalesce(options, () => ( {}))).map((key) => ` - ${key}=${
 }, "withRunGenerator");
 
 // ../workspace-tools/src/generators/init/init.ts
-
+var _devkit = require('@nx/devkit');
 async function initGenerator(tree, schema) {
   const task = _devkit.addDependenciesToPackageJson.call(void 0, tree, {
     nx: "^19.6.2",
@@ -1545,9 +1654,10 @@ var executor_default3 = withRunExecutor("Cargo Clippy", cargoClippyExecutor, {
 });
 
 // ../workspace-tools/src/executors/cargo-doc/executor.ts
-var _deepclone = require('deep-clone'); var _deepclone2 = _interopRequireDefault(_deepclone);
 async function cargoDocExecutor(options, context2) {
-  const opts = _deepclone2.default.call(void 0, options);
+  const opts = {
+    ...options
+  };
   opts["no-deps"] = opts.noDeps;
   delete opts.noDeps;
   const command = buildCargoCommand("doc", options, context2);
@@ -1602,7 +1712,6 @@ var _jtoml = require('@ltd/j-toml'); var _jtoml2 = _interopRequireDefault(_jtoml
 var LARGE_BUFFER2 = 1024 * 1e6;
 
 // ../esbuild/src/build.ts
-var _node = require('@humanfs/node');
 
 
 // ../build-tools/src/config.ts
@@ -1700,7 +1809,7 @@ var addPackageDependencies = /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0
       if (_fs.existsSync.call(void 0, projectPackageJsonPath)) {
         const projectPackageJsonContent = await _promises.readFile.call(void 0, projectPackageJsonPath, "utf8");
         const projectPackageJson = JSON.parse(projectPackageJsonContent);
-        if (projectPackageJson.private !== false) {
+        if (projectPackageJson.private !== true) {
           localPackages.push(projectPackageJson);
         }
       }
@@ -1889,6 +1998,8 @@ var _estoolkit = require('es-toolkit');
 var _compat = require('es-toolkit/compat');
 var _esbuild = require('esbuild'); var esbuild2 = _interopRequireWildcard(_esbuild); var esbuild = _interopRequireWildcard(_esbuild);
 var _globby = require('globby');
+
+
 var _findworkspaceroot = require('nx/src/utils/find-workspace-root');
 
 // ../esbuild/src/base/renderer-engine.ts
@@ -2034,13 +2145,13 @@ var RendererEngine = class {
 
 // ../esbuild/src/clean.ts
 
-async function clean(name = "ESBuild", directory, config) {
-  writeDebug(` \u{1F9F9}  Cleaning ${name} output path: ${directory}`, config);
-  const stopwatch = getStopwatch(`${name} output clean`);
-  await _node.hfs.deleteAll(directory);
-  stopwatch();
+async function cleanDirectories(name = "ESBuild", directory, config) {
+  await _promises.rm.call(void 0, directory, {
+    recursive: true,
+    force: true
+  });
 }
-_chunk3GQAWCBQjs.__name.call(void 0, clean, "clean");
+_chunk3GQAWCBQjs.__name.call(void 0, cleanDirectories, "cleanDirectories");
 
 // ../esbuild/src/plugins/esm-split-code-to-cjs.ts
 
@@ -2212,8 +2323,9 @@ var resolvePathsPlugin = /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, (o
 }), "resolvePathsPlugin");
 
 // ../esbuild/src/plugins/tsc.ts
-
 var _apiextractor = require('@microsoft/api-extractor');
+
+
 function bundleTypeDefinitions(filename, outfile, externals, options) {
   const { dependencies, peerDependencies, devDependencies } = _chunk3GQAWCBQjs.__require.call(void 0, joinPaths(options.projectRoot, "package.json"));
   const dependenciesKeys = Object.keys(_nullishCoalesce(dependencies, () => ( {}))).flatMap((p) => [
@@ -2286,18 +2398,18 @@ var tscPlugin = /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, (options, r
         const entryPoint = resolvedOptions.entryPoints[0].replace(sourceRoot, "").replace(/\.ts$/, "");
         const bundlePath = joinPaths(resolvedOptions.outdir, entryPoint);
         let dtsPath;
-        if (await _node.hfs.isFile(joinPaths(resolvedOptions.config.workspaceRoot, typeOutDir, `${entryPoint}.d.ts`))) {
+        if (_fs.existsSync.call(void 0, joinPaths(resolvedOptions.config.workspaceRoot, typeOutDir, `${entryPoint}.d.ts`))) {
           dtsPath = joinPaths(resolvedOptions.config.workspaceRoot, typeOutDir, `${entryPoint}.d.ts`);
-        } else if (await _node.hfs.isFile(joinPaths(resolvedOptions.config.workspaceRoot, typeOutDir, `${entryPoint.replace(/^src\//, "")}.d.ts`))) {
+        } else if (_fs.existsSync.call(void 0, joinPaths(resolvedOptions.config.workspaceRoot, typeOutDir, `${entryPoint.replace(/^src\//, "")}.d.ts`))) {
           dtsPath = joinPaths(resolvedOptions.config.workspaceRoot, typeOutDir, `${entryPoint.replace(/^src\//, "")}.d.ts`);
         }
         const ext = resolvedOptions.outExtension.dts || resolvedOptions.format === "esm" ? "d.mts" : "d.ts";
         if (process.env.WATCH !== "true" && process.env.DEV !== "true") {
           bundleTypeDefinitions(dtsPath, bundlePath, _nullishCoalesce(resolvedOptions.external, () => ( [])), resolvedOptions);
-          const dtsContents = await _node.hfs.text(`${bundlePath}.d.ts`);
-          await _node.hfs.write(`${bundlePath}.${ext}`, dtsContents);
+          const dtsContents = await _promises2.default.readFile(`${bundlePath}.d.ts`, "utf8");
+          await _promises2.default.writeFile(`${bundlePath}.${ext}`, dtsContents);
         } else {
-          await _node.hfs.write(`${bundlePath}.${ext}`, `export * from './${entryPoint}'`);
+          await _promises2.default.writeFile(`${bundlePath}.${ext}`, `export * from './${entryPoint}'`);
         }
       }
     });
@@ -2546,10 +2658,11 @@ var resolveOptions = /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, async
     exitOnError: true
   });
   const projectJsonPath = joinPaths(workspaceRoot3.dir, projectRoot, "project.json");
-  if (!await _node.hfs.isFile(projectJsonPath)) {
+  if (!_fs.existsSync.call(void 0, projectJsonPath)) {
     throw new Error("Cannot find project.json configuration");
   }
-  const projectJson = await _node.hfs.json(projectJsonPath);
+  const projectJsonFile = await _promises2.default.readFile(projectJsonPath, "utf8");
+  const projectJson = JSON.parse(projectJsonFile);
   const projectName = projectJson.name;
   const projectConfigurations = _devkit.readProjectsConfigurationFromProjectGraph.call(void 0, projectGraph);
   if (!_optionalChain([projectConfigurations, 'optionalAccess', _120 => _120.projects, 'optionalAccess', _121 => _121[projectName]])) {
@@ -2559,10 +2672,11 @@ var resolveOptions = /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, async
   options.name ??= `${projectName}-${options.format}`;
   options.target ??= DEFAULT_TARGET;
   const packageJsonPath = joinPaths(workspaceRoot3.dir, options.projectRoot, "package.json");
-  if (!await _node.hfs.isFile(packageJsonPath)) {
+  if (!_fs.existsSync.call(void 0, packageJsonPath)) {
     throw new Error("Cannot find package.json configuration");
   }
-  const packageJson = await _node.hfs.json(packageJsonPath);
+  const packageJsonFile = await _promises2.default.readFile(packageJsonPath, "utf8");
+  const packageJson = JSON.parse(packageJsonFile);
   const outExtension = getOutputExtensionMap(options, packageJson.type);
   const env = getEnv("esbuild", options);
   const result = {
@@ -2641,14 +2755,15 @@ var resolveOptions = /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, async
   return result;
 }, "resolveOptions");
 async function generatePackageJson(context2) {
-  if (context2.options.generatePackageJson !== false && await _node.hfs.isFile(joinPaths(context2.options.projectRoot, "package.json"))) {
+  if (context2.options.generatePackageJson !== false && _fs.existsSync.call(void 0, joinPaths(context2.options.projectRoot, "package.json"))) {
     writeDebug("  \u270D\uFE0F   Writing package.json file", context2.options.config);
     const stopwatch = getStopwatch("Write package.json file");
     const packageJsonPath = joinPaths(context2.options.projectRoot, "project.json");
-    if (!await _node.hfs.isFile(packageJsonPath)) {
+    if (!_fs.existsSync.call(void 0, packageJsonPath)) {
       throw new Error("Cannot find package.json configuration");
     }
-    let packageJson = await _node.hfs.json(joinPaths(context2.options.config.workspaceRoot, context2.options.projectRoot, "package.json"));
+    const packageJsonFile = await _promises2.default.readFile(joinPaths(context2.options.config.workspaceRoot, context2.options.projectRoot, "package.json"), "utf8");
+    let packageJson = JSON.parse(packageJsonFile);
     if (!packageJson) {
       throw new Error("Cannot find package.json configuration file");
     }
@@ -2721,7 +2836,7 @@ async function executeEsBuild(context2) {
   const result = await esbuild2.build(context2.options);
   if (result.metafile) {
     const metafilePath = `${context2.options.outdir}/${context2.options.name}.meta.json`;
-    await _node.hfs.write(metafilePath, JSON.stringify(result.metafile));
+    await _promises2.default.writeFile(metafilePath, JSON.stringify(result.metafile));
   }
   stopwatch();
   return context2;
@@ -2778,7 +2893,10 @@ async function dependencyCheck(options) {
 _chunk3GQAWCBQjs.__name.call(void 0, dependencyCheck, "dependencyCheck");
 async function cleanOutputPath(context2) {
   if (context2.options.clean !== false && context2.options.outdir) {
-    await clean(context2.options.name, context2.options.outdir, context2.options.config);
+    writeDebug(` \u{1F9F9}  Cleaning ${context2.options.name} output path: ${context2.options.outdir}`, context2.options.config);
+    const stopwatch = getStopwatch(`${context2.options.name} output clean`);
+    await cleanDirectories(context2.options.name, context2.options.outdir, context2.options.config);
+    stopwatch();
   }
   return context2;
 }
@@ -2918,17 +3036,18 @@ var executor_default7 = withRunExecutor("Size-Limit Performance Test Executor",
 
 
 
+
 var _tsdown = require('tsdown');
 
 // ../tsdown/src/clean.ts
 
-async function clean2(name = "ESBuild", directory, config) {
-  writeDebug(` \u{1F9F9}  Cleaning ${name} output path: ${directory}`, config);
-  const stopwatch = getStopwatch(`${name} output clean`);
-  await _node.hfs.deleteAll(directory);
-  stopwatch();
+async function cleanDirectories2(name = "TSDown", directory, config) {
+  await _promises.rm.call(void 0, directory, {
+    recursive: true,
+    force: true
+  });
 }
-_chunk3GQAWCBQjs.__name.call(void 0, clean2, "clean");
+_chunk3GQAWCBQjs.__name.call(void 0, cleanDirectories2, "cleanDirectories");
 
 // ../tsdown/src/config.ts
 var DEFAULT_BUILD_OPTIONS2 = {
@@ -2966,10 +3085,11 @@ var resolveOptions2 = /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, async
     exitOnError: true
   });
   const projectJsonPath = joinPaths(workspaceRoot3.dir, projectRoot, "project.json");
-  if (!await _node.hfs.isFile(projectJsonPath)) {
+  if (!_fs.existsSync.call(void 0, projectJsonPath)) {
     throw new Error("Cannot find project.json configuration");
   }
-  const projectJson = await _node.hfs.json(projectJsonPath);
+  const projectJsonFile = await _promises2.default.readFile(projectJsonPath, "utf8");
+  const projectJson = JSON.parse(projectJsonFile);
   const projectName = projectJson.name;
   const projectConfigurations = _devkit.readProjectsConfigurationFromProjectGraph.call(void 0, projectGraph);
   if (!_optionalChain([projectConfigurations, 'optionalAccess', _153 => _153.projects, 'optionalAccess', _154 => _154[projectName]])) {
@@ -2979,7 +3099,7 @@ var resolveOptions2 = /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, async
   options.name ??= `${projectName}-${options.format}`;
   options.target ??= DEFAULT_TARGET;
   const packageJsonPath = joinPaths(workspaceRoot3.dir, options.projectRoot, "package.json");
-  if (!await _node.hfs.isFile(packageJsonPath)) {
+  if (!_fs.existsSync.call(void 0, packageJsonPath)) {
     throw new Error("Cannot find package.json configuration");
   }
   const env = getEnv("tsdown", options);
@@ -3034,17 +3154,18 @@ var resolveOptions2 = /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, async
   return result;
 }, "resolveOptions");
 async function generatePackageJson2(options) {
-  if (options.generatePackageJson !== false && await _node.hfs.isFile(joinPaths(options.projectRoot, "package.json"))) {
+  if (options.generatePackageJson !== false && _fs.existsSync.call(void 0, 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 _node.hfs.isFile(packageJsonPath)) {
+    if (!_fs.existsSync.call(void 0, packageJsonPath)) {
       throw new Error("Cannot find package.json configuration");
     }
-    let packageJson = await _node.hfs.json(joinPaths(options.config.workspaceRoot, options.projectRoot, "package.json"));
-    if (!packageJson) {
+    const packageJsonFile = await _promises2.default.readFile(joinPaths(options.config.workspaceRoot, options.projectRoot, "package.json"), "utf8");
+    if (!packageJsonFile) {
       throw new Error("Cannot find package.json configuration file");
     }
+    let packageJson = JSON.parse(packageJsonFile);
     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.exports ??= {};
@@ -3112,7 +3233,10 @@ async function reportResults2(options) {
 _chunk3GQAWCBQjs.__name.call(void 0, reportResults2, "reportResults");
 async function cleanOutputPath2(options) {
   if (options.clean !== false && options.outdir) {
-    await clean2(options.name, options.outdir, options.config);
+    writeDebug(` \u{1F9F9}  Cleaning ${options.name} output path: ${options.outdir}`, options.config);
+    const stopwatch = getStopwatch(`${options.name} output clean`);
+    await cleanDirectories2(options.name, options.outdir, options.config);
+    stopwatch();
   }
   return options;
 }
@@ -3233,7 +3357,7 @@ async function unbuildExecutorFn(options, context2, config) {
     throw new Error("The Build process failed because the project's source root is not valid. Please run this command from a workspace root directory.");
   }
   const jiti = _jiti.createJiti.call(void 0, config.workspaceRoot, {
-    fsCache: config.skipCache ? false : joinPaths(config.directories.cache || "node_modules/.cache/storm", "jiti"),
+    fsCache: config.skipCache ? false : joinPaths(config.workspaceRoot, config.directories.cache || "node_modules/.cache/storm", "jiti"),
     interopDefault: true
   });
   const stormUnbuild = await jiti.import(jiti.esmResolve("@storm-software/unbuild/build"));
@@ -3246,7 +3370,7 @@ async function unbuildExecutorFn(options, context2, config) {
   }, {
     stubOptions: {
       jiti: {
-        cache: "node_modules/.cache/storm"
+        fsCache: config.skipCache ? false : joinPaths(config.workspaceRoot, config.directories.cache || "node_modules/.cache/storm", "jiti")
       }
     },
     rollup: {
@@ -3280,7 +3404,6 @@ var executor_default10 = withRunExecutor("TypeScript Unbuild build", unbuildExec
       options.entry ??= [
         "{sourceRoot}"
       ];
-      options.outputPath ??= "dist/{projectRoot}";
       options.tsconfig ??= "{projectRoot}/tsconfig.json";
       return options;
     }, "applyDefaultOptions")
@@ -3360,48 +3483,48 @@ var nodeVersion = "20.11.0";
 var pnpmVersion = "8.10.2";
 
 // ../workspace-tools/src/base/typescript-library-generator.ts
-async function typeScriptLibraryGeneratorFn(tree, schema, config) {
-  const options = await normalizeOptions(tree, {
-    ...schema
+async function typeScriptLibraryGeneratorFn(tree, options, config) {
+  const normalized = await normalizeOptions(tree, {
+    ...options
   });
   const tasks = [];
   tasks.push(await _init2.default.call(void 0, tree, {
-    ...options,
-    tsConfigName: options.rootProject ? "tsconfig.json" : "tsconfig.base.json"
+    ...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(schema.devDependencies, () => ( {}))
+    ..._nullishCoalesce(options.devDependencies, () => ( {}))
   }));
-  if (options.publishable) {
+  if (normalized.publishable) {
     tasks.push(await _generator2.default.call(void 0, tree, {
-      ...options,
+      ...normalized,
       skipFormat: true
     }));
   }
   const projectConfig = {
-    root: options.directory,
+    root: normalized.directory,
     projectType: "library",
-    sourceRoot: joinPaths(_nullishCoalesce(options.directory, () => ( "")), "src"),
+    sourceRoot: joinPaths(_nullishCoalesce(normalized.directory, () => ( "")), "src"),
     targets: {
       build: {
-        executor: schema.buildExecutor,
+        executor: options.buildExecutor,
         outputs: [
           "{options.outputPath}"
         ],
         options: {
           entry: [
-            joinPaths(options.projectRoot, "src", "index.ts")
+            joinPaths(normalized.projectRoot, "src", "index.ts")
           ],
-          outputPath: getOutputPath(options),
-          tsconfig: joinPaths(options.projectRoot, "tsconfig.json"),
-          project: joinPaths(options.projectRoot, "package.json"),
+          outputPath: getOutputPath(normalized),
+          tsconfig: joinPaths(normalized.projectRoot, "tsconfig.json"),
+          project: joinPaths(normalized.projectRoot, "package.json"),
           defaultConfiguration: "production",
           platform: "neutral",
           assets: [
             {
-              input: options.projectRoot,
+              input: normalized.projectRoot,
               glob: "*.md",
               output: "/"
             },
@@ -3425,19 +3548,19 @@ async function typeScriptLibraryGeneratorFn(tree, schema, config) {
       }
     }
   };
-  if (schema.platform) {
-    projectConfig.targets.build.options.platform = schema.platform === "worker" ? "node" : schema.platform;
+  if (options.platform) {
+    projectConfig.targets.build.options.platform = options.platform === "worker" ? "node" : options.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, {
+  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, options);
-  _devkit.addProjectConfiguration.call(void 0, tree, options.name, projectConfig);
+  createProjectTsConfigJson(tree, normalized);
+  _devkit.addProjectConfiguration.call(void 0, tree, normalized.name, projectConfig);
   let repository = {
     type: "github",
     url: _optionalChain([config, 'optionalAccess', _171 => _171.repository]) || `https://github.com/${_optionalChain([config, 'optionalAccess', _172 => _172.organization]) || "storm-software"}/${_optionalChain([config, 'optionalAccess', _173 => _173.namespace]) || _optionalChain([config, 'optionalAccess', _174 => _174.name]) || "repository"}.git`
   };
-  let description = schema.description || "A package developed by Storm Software used to create modern, scalable web applications.";
+  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', _175 => _175.repository])) {
@@ -3447,18 +3570,18 @@ async function typeScriptLibraryGeneratorFn(tree, schema, config) {
       description = packageJson.description;
     }
   }
-  if (!options.importPath) {
-    options.importPath = options.name;
+  if (!normalized.importPath) {
+    normalized.importPath = normalized.name;
   }
-  const packageJsonPath = joinPaths(options.projectRoot, "package.json");
+  const packageJsonPath = joinPaths(normalized.projectRoot, "package.json");
   if (tree.exists(packageJsonPath)) {
     _devkit.updateJson.call(void 0, tree, packageJsonPath, (json) => {
-      if (!options.importPath) {
-        options.importPath = options.name;
+      if (!normalized.importPath) {
+        normalized.importPath = normalized.name;
       }
-      json.name = options.importPath;
+      json.name = normalized.importPath;
       json.version = "0.0.1";
-      if (json.private && (options.publishable || options.rootProject)) {
+      if (json.private && (normalized.publishable || normalized.rootProject)) {
         json.private = void 0;
       }
       return {
@@ -3467,7 +3590,7 @@ async function typeScriptLibraryGeneratorFn(tree, schema, config) {
         description,
         repository: {
           ...repository,
-          directory: options.projectRoot
+          directory: normalized.projectRoot
         },
         type: "module",
         dependencies: {
@@ -3480,37 +3603,37 @@ async function typeScriptLibraryGeneratorFn(tree, schema, config) {
     });
   } else {
     _devkit.writeJson.call(void 0, tree, packageJsonPath, {
-      name: options.importPath,
+      name: normalized.importPath,
       version: "0.0.1",
       description,
       repository: {
         ...repository,
-        directory: options.projectRoot
+        directory: normalized.projectRoot
       },
-      private: !options.publishable || options.rootProject,
+      private: !normalized.publishable || normalized.rootProject,
       type: "module",
       publishConfig: {
         access: "public"
       }
     });
   }
-  if (tree.exists("package.json") && options.importPath) {
+  if (tree.exists("package.json") && normalized.importPath) {
     _devkit.updateJson.call(void 0, tree, "package.json", (json) => ({
       ...json,
       pnpm: {
         ..._optionalChain([json, 'optionalAccess', _177 => _177.pnpm]),
         overrides: {
           ..._optionalChain([json, 'optionalAccess', _178 => _178.pnpm, 'optionalAccess', _179 => _179.overrides]),
-          [_nullishCoalesce(options.importPath, () => ( ""))]: "workspace:*"
+          [_nullishCoalesce(normalized.importPath, () => ( ""))]: "workspace:*"
         }
       }
     }));
   }
-  _js.addTsConfigPath.call(void 0, tree, options.importPath, [
-    joinPaths(options.projectRoot, "./src", `index.${options.js ? "js" : "ts"}`)
+  _js.addTsConfigPath.call(void 0, tree, normalized.importPath, [
+    joinPaths(normalized.projectRoot, "./src", `index.${normalized.js ? "js" : "ts"}`)
   ]);
-  _js.addTsConfigPath.call(void 0, tree, joinPaths(options.importPath, "/*"), [
-    joinPaths(options.projectRoot, "./src", "/*")
+  _js.addTsConfigPath.call(void 0, tree, joinPaths(normalized.importPath, "/*"), [
+    joinPaths(normalized.projectRoot, "./src", "/*")
   ]);
   if (tree.exists("package.json")) {
     const packageJson = _devkit.readJson.call(void 0, tree, "package.json");
@@ -3521,7 +3644,7 @@ async function typeScriptLibraryGeneratorFn(tree, schema, config) {
       description = packageJson.description;
     }
   }
-  const tsconfigPath = joinPaths(options.projectRoot, "tsconfig.json");
+  const tsconfigPath = joinPaths(normalized.projectRoot, "tsconfig.json");
   if (tree.exists(tsconfigPath)) {
     _devkit.updateJson.call(void 0, tree, tsconfigPath, (json) => {
       json.composite ??= true;
@@ -3529,10 +3652,10 @@ async function typeScriptLibraryGeneratorFn(tree, schema, config) {
     });
   } else {
     _devkit.writeJson.call(void 0, tree, tsconfigPath, {
-      extends: `${_devkit.offsetFromRoot.call(void 0, options.projectRoot)}tsconfig.base.json`,
+      extends: `${_devkit.offsetFromRoot.call(void 0, normalized.projectRoot)}tsconfig.base.json`,
       composite: true,
       compilerOptions: {
-        outDir: `${_devkit.offsetFromRoot.call(void 0, options.projectRoot)}dist/out-tsc`
+        outDir: `${_devkit.offsetFromRoot.call(void 0, normalized.projectRoot)}dist/out-tsc`
       },
       files: [],
       include: [
@@ -3591,9 +3714,13 @@ function createProjectTsConfigJson(tree, options) {
   _devkit.writeJson.call(void 0, tree, joinPaths(options.projectRoot, "tsconfig.json"), tsconfig);
 }
 _chunk3GQAWCBQjs.__name.call(void 0, createProjectTsConfigJson, "createProjectTsConfigJson");
-async function normalizeOptions(tree, options) {
+async function normalizeOptions(tree, options, config) {
+  let importPath = options.importPath;
+  if (!importPath && _optionalChain([config, 'optionalAccess', _191 => _191.namespace])) {
+    importPath = `@${_optionalChain([config, 'optionalAccess', _192 => _192.namespace])}/${options.name}`;
+  }
   if (options.publishable) {
-    if (!options.importPath) {
+    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)`);
     }
   }
@@ -3602,14 +3729,14 @@ async function normalizeOptions(tree, options) {
     bundler = "none";
   }
   const { Linter } = _devkit.ensurePackage.call(void 0, "@nx/eslint", nxVersion);
-  const { projectName, names: projectNames, projectRoot, importPath } = await _projectnameandrootutils.determineProjectNameAndRootOptions.call(void 0, tree, {
+  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: options.importPath,
-    rootProject: options.rootProject
+    importPath,
+    rootProject
   });
-  options.rootProject = projectRoot === ".";
   const normalized = _devkit.names.call(void 0, projectNames.projectFileName);
   const fileName = normalized.fileName;
   return {
@@ -3635,14 +3762,15 @@ async function normalizeOptions(tree, options) {
     projectNames,
     projectRoot,
     parsedTags: options.tags ? options.tags.split(",").map((s) => s.trim()) : [],
-    importPath
+    importPath: normalizedImportPath,
+    rootProject
   };
 }
 _chunk3GQAWCBQjs.__name.call(void 0, normalizeOptions, "normalizeOptions");
 
 // ../workspace-tools/src/generators/browser-library/generator.ts
 async function browserLibraryGeneratorFn(tree, schema, config) {
-  const filesDir = _devkit.joinPathFragments.call(void 0, __dirname, "./files");
+  const filesDir = joinPaths(__dirname, "src", "generators", "browser-library", "files");
   const tsLibraryGeneratorOptions = {
     buildExecutor: "@storm-software/workspace-tools:unbuild",
     platform: "browser",
@@ -3720,7 +3848,7 @@ async function configSchemaGeneratorFn(tree, options, config) {
     name: "StormWorkspaceConfiguration"
   });
   writeTrace(jsonSchema, config);
-  const outputPath = options.outputFile.replaceAll("{workspaceRoot}", "").replaceAll(_nullishCoalesce(_optionalChain([config, 'optionalAccess', _191 => _191.workspaceRoot]), () => ( findWorkspaceRoot())), _optionalChain([options, 'access', _192 => _192.outputFile, 'optionalAccess', _193 => _193.startsWith, 'call', _194 => _194("./")]) ? "" : "./");
+  const outputPath = options.outputFile.replaceAll("{workspaceRoot}", "").replaceAll(_nullishCoalesce(_optionalChain([config, 'optionalAccess', _193 => _193.workspaceRoot]), () => ( findWorkspaceRoot())), _optionalChain([options, 'access', _194 => _194.outputFile, 'optionalAccess', _195 => _195.startsWith, 'call', _196 => _196("./")]) ? "" : "./");
   writeTrace(`\u{1F4DD}  Writing Storm Configuration JSON Schema to "${outputPath}"`, config);
   _devkit.writeJson.call(void 0, tree, outputPath, jsonSchema, {
     spaces: 2
@@ -3744,7 +3872,7 @@ var generator_default2 = withRunGenerator("Configuration Schema Creator", config
 // ../workspace-tools/src/generators/neutral-library/generator.ts
 
 async function neutralLibraryGeneratorFn(tree, schema, config) {
-  const filesDir = _devkit.joinPathFragments.call(void 0, __dirname, "./files");
+  const filesDir = joinPaths(__dirname, "src", "generators", "neutral-library", "files");
   const tsLibraryGeneratorOptions = {
     ...schema,
     platform: "neutral",
@@ -3787,7 +3915,7 @@ var generator_default3 = withRunGenerator("TypeScript Library Creator (Neutral P
 // ../workspace-tools/src/generators/node-library/generator.ts
 
 async function nodeLibraryGeneratorFn(tree, schema, config) {
-  const filesDir = _devkit.joinPathFragments.call(void 0, __dirname, "./files");
+  const filesDir = joinPaths(__dirname, "src", "generators", "node-library", "files");
   const tsLibraryGeneratorOptions = {
     platform: "node",
     devDependencies: {
@@ -4417,37 +4545,17 @@ var typescript_library_generator_untyped_default = _untyped.defineUntypedSchema.
       enum: [
         "neutral",
         "node",
+        "worker",
         "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: {
+  importPath: {
     $schema: {
-      title: "Peer Dependencies Meta",
-      type: "object",
-      description: "The peer dependencies meta"
+      title: "Import Path",
+      type: "string",
+      description: "The import path for the library"
     }
   },
   tags: {
@@ -4457,41 +4565,6 @@ var typescript_library_generator_untyped_default = _untyped.defineUntypedSchema.
       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",
@@ -4504,13 +4577,6 @@ var typescript_library_generator_untyped_default = _untyped.defineUntypedSchema.
       description: "The unit test runner to use"
     }
   },
-  linter: {
-    $schema: {
-      title: "Linter",
-      type: "string",
-      description: "The linter to use"
-    }
-  },
   testEnvironment: {
     $schema: {
       title: "Test Environment",
@@ -4522,136 +4588,37 @@ var typescript_library_generator_untyped_default = _untyped.defineUntypedSchema.
       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"
-    }
+    },
+    $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"
-    }
-  },
-  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"
-    }
+    },
+    $default: true
   }
 });
 
@@ -4664,21 +4631,27 @@ var _retrieveworkspacefiles = require('nx/src/project-graph/utils/retrieve-works
 // ../workspace-tools/src/utils/lock-file.ts
 
 
-var _devkitexports = require('nx/src/devkit-exports');
+
 var _npmparser = require('nx/src/plugins/js/lock-file/npm-parser');
 var _pnpmparser = require('nx/src/plugins/js/lock-file/pnpm-parser');
 var _yarnparser = require('nx/src/plugins/js/lock-file/yarn-parser');
 var YARN_LOCK_FILE = "yarn.lock";
 var NPM_LOCK_FILE = "package-lock.json";
 var PNPM_LOCK_FILE = "pnpm-lock.yaml";
-var YARN_LOCK_PATH = _path.join.call(void 0, _devkitexports.workspaceRoot, YARN_LOCK_FILE);
-var NPM_LOCK_PATH = _path.join.call(void 0, _devkitexports.workspaceRoot, NPM_LOCK_FILE);
-var PNPM_LOCK_PATH = _path.join.call(void 0, _devkitexports.workspaceRoot, PNPM_LOCK_FILE);
+var YARN_LOCK_PATH = _path.join.call(void 0, _devkit.workspaceRoot, YARN_LOCK_FILE);
+var NPM_LOCK_PATH = _path.join.call(void 0, _devkit.workspaceRoot, NPM_LOCK_FILE);
+var PNPM_LOCK_PATH = _path.join.call(void 0, _devkit.workspaceRoot, PNPM_LOCK_FILE);
 
 // ../workspace-tools/src/utils/package-helpers.ts
 
 
 
+// ../workspace-tools/src/utils/plugin-helpers.ts
+
+
+
+
+
 // ../workspace-tools/src/utils/typia-transform.ts
 var _transform = require('typia/lib/transform'); var _transform2 = _interopRequireDefault(_transform);