@storm-software/workspace-tools 1.267.19 → 1.267.21

package/dist/chunk-MZSZKV4N.mjs

@@ -0,0 +1,47 @@
+import {
+  ProjectTagConstants,
+  isEqualProjectTag
+} from "./chunk-F66XEAID.mjs";
+import {
+  parseCargoToml
+} from "./chunk-U65XVJ4Y.mjs";
+
+// src/utils/package-helpers.ts
+import {
+  joinPathFragments,
+  readJsonFile
+} from "@nx/devkit";
+import { existsSync } from "node:fs";
+var PackageManagerTypes = {
+  PackageJson: "package.json",
+  CargoToml: "Cargo.toml"
+};
+var getPackageInfo = (project) => {
+  if (isEqualProjectTag(
+    project,
+    ProjectTagConstants.Language.TAG_ID,
+    ProjectTagConstants.Language.RUST
+  ) && existsSync(joinPathFragments(project.root, "Cargo.toml"))) {
+    return {
+      type: "Cargo.toml",
+      content: parseCargoToml(joinPathFragments(project.root, "Cargo.toml"))
+    };
+  } else if (isEqualProjectTag(
+    project,
+    ProjectTagConstants.Language.TAG_ID,
+    ProjectTagConstants.Language.TYPESCRIPT
+  ) && existsSync(joinPathFragments(project.root, "package.json"))) {
+    return {
+      type: "package.json",
+      content: readJsonFile(
+        joinPathFragments(project.root, "package.json")
+      )
+    };
+  }
+  return null;
+};
+
+export {
+  PackageManagerTypes,
+  getPackageInfo
+};

package/dist/chunk-O6RRIC6I.js

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

package/dist/chunk-OKSECMVK.js

@@ -0,0 +1,32 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// 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",
+      "@nx/workspace": "^19.6.2",
+      "@nx/js": "^19.6.2",
+      "@storm-software/eslint": "latest",
+      "@storm-software/prettier": "latest",
+      "@storm-software/config-tools": "latest",
+      "@storm-software/testing-tools": "latest",
+      "@storm-software/git-tools": "latest",
+      "@storm-software/linting-tools": "latest"
+    },
+    {}
+  );
+  if (!schema.skipFormat) {
+    await _devkit.formatFiles.call(void 0, tree);
+  }
+  return task;
+}
+var init_default = initGenerator;
+
+
+
+
+exports.initGenerator = initGenerator; exports.init_default = init_default;

package/dist/chunk-Q2HYWACQ.mjs

@@ -0,0 +1,50 @@
+import {
+  withRunExecutor
+} from "./chunk-UYSJG2E5.mjs";
+import {
+  writeInfo
+} from "./chunk-2M22JVJQ.mjs";
+
+// src/executors/typia/executor.ts
+import { removeSync } from "fs-extra";
+import { TypiaProgrammer } from "typia/lib/programmers/TypiaProgrammer.js";
+async function typiaExecutorFn(options, _, config) {
+  if (options.clean !== false) {
+    writeInfo(`\u{1F9F9} Cleaning output path: ${options.outputPath}`, config);
+    removeSync(options.outputPath);
+  }
+  await Promise.all(
+    options.entry.map((entry) => {
+      writeInfo(`\u{1F680} Running Typia on entry: ${entry}`, config);
+      return TypiaProgrammer.build({
+        input: entry,
+        output: options.outputPath,
+        project: options.tsconfig
+      });
+    })
+  );
+  return {
+    success: true
+  };
+}
+var executor_default = withRunExecutor(
+  "Typia runtime validation generator",
+  typiaExecutorFn,
+  {
+    skipReadingConfig: false,
+    hooks: {
+      applyDefaultOptions: (options) => {
+        options.entry ??= ["{sourceRoot}/index.ts"];
+        options.outputPath ??= "{sourceRoot}/__generated__/typia";
+        options.tsconfig ??= "{projectRoot}/tsconfig.json";
+        options.clean ??= true;
+        return options;
+      }
+    }
+  }
+);
+
+export {
+  typiaExecutorFn,
+  executor_default
+};

package/dist/{chunk-62XRHQ44.mjs → chunk-QFWQZOVG.mjs}

@@ -1,10 +1,9 @@
-import {
-  __name
-} from "./chunk-L2DHGVS5.mjs";
-
 // src/utils/cargo.ts
 import { joinPathFragments, workspaceRoot } from "@nx/devkit";
-import { execSync, spawn } from "node:child_process";
+import {
+  execSync,
+  spawn
+} from "node:child_process";
 import { relative } from "node:path";
 var INVALID_CARGO_ARGS = [
   "allFeatures",
@@ -15,7 +14,7 @@ var INVALID_CARGO_ARGS = [
   "tsConfig"
 ];
 var childProcess;
-var buildCargoCommand = /* @__PURE__ */ __name((baseCommand, options, context) => {
+var buildCargoCommand = (baseCommand, options, context) => {
   const args = [];
   if (options.toolchain && options.toolchain !== "stable") {
     args.push(`+${options.toolchain}`);
@@ -53,54 +52,38 @@ var buildCargoCommand = /* @__PURE__ */ __name((baseCommand, options, context) =
     args.push("--target-dir", options.outputPath);
   }
   return args;
-}, "buildCargoCommand");
+};
 async function cargoCommand(...args) {
   console.log(`> cargo ${args.join(" ")}`);
   args.push("--color", "always");
   return await Promise.resolve(runProcess("cargo", ...args));
 }
-__name(cargoCommand, "cargoCommand");
 function cargoRunCommand(...args) {
   console.log(`> cargo ${args.join(" ")}`);
   return new Promise((resolve, reject) => {
-    childProcess = spawn("cargo", [
-      ...args,
-      "--color",
-      "always"
-    ], {
+    childProcess = spawn("cargo", [...args, "--color", "always"], {
       cwd: process.cwd(),
       windowsHide: true,
       detached: true,
       shell: false,
-      stdio: [
-        "inherit",
-        "inherit",
-        "inherit"
-      ]
+      stdio: ["inherit", "inherit", "inherit"]
     });
     process.on("exit", () => childProcess?.kill());
     process.on("SIGTERM", () => childProcess?.kill());
     process.on("SIGINT", () => childProcess?.kill());
     childProcess.on("error", (_err) => {
-      reject({
-        success: false
-      });
+      reject({ success: false });
     });
     childProcess.on("exit", (code) => {
       childProcess = null;
       if (code === 0) {
-        resolve({
-          success: true
-        });
+        resolve({ success: true });
       } else {
-        reject({
-          success: false
-        });
+        reject({ success: false });
       }
     });
   });
 }
-__name(cargoRunCommand, "cargoRunCommand");
 function cargoCommandSync(args = "", options) {
   const normalizedOptions = {
     stdio: options?.stdio ?? "inherit",
@@ -127,7 +110,6 @@ function cargoCommandSync(args = "", options) {
     };
   }
 }
-__name(cargoCommandSync, "cargoCommandSync");
 function cargoMetadata() {
   const output = cargoCommandSync("metadata --format-version=1", {
     stdio: "pipe"
@@ -138,22 +120,18 @@ function cargoMetadata() {
   }
   return JSON.parse(output.output);
 }
-__name(cargoMetadata, "cargoMetadata");
 function isExternal(packageOrDep, workspaceRoot2) {
   const isRegistry = packageOrDep.source?.startsWith("registry+") ?? false;
   const isGit = packageOrDep.source?.startsWith("git+") ?? false;
   const isOutsideWorkspace = "path" in packageOrDep && relative(workspaceRoot2, packageOrDep.path).startsWith("..");
   return isRegistry || isGit || isOutsideWorkspace;
 }
-__name(isExternal, "isExternal");
 function runProcess(processCmd, ...args) {
   const metadata = cargoMetadata();
   const targetDir = metadata?.target_directory ?? joinPathFragments(workspaceRoot, "dist", "cargo");
   return new Promise((resolve) => {
     if (process.env.VERCEL) {
-      return resolve({
-        success: true
-      });
+      return resolve({ success: true });
     }
     execSync(`${processCmd} ${args.join(" ")}`, {
       cwd: process.cwd(),
@@ -164,18 +142,11 @@ function runProcess(processCmd, ...args) {
         CARGO_BUILD_TARGET_DIR: targetDir
       },
       windowsHide: true,
-      stdio: [
-        "inherit",
-        "inherit",
-        "inherit"
-      ]
-    });
-    resolve({
-      success: true
+      stdio: ["inherit", "inherit", "inherit"]
     });
+    resolve({ success: true });
   });
 }
-__name(runProcess, "runProcess");
 
 export {
   INVALID_CARGO_ARGS,

package/dist/{chunk-DHGZTMND.js → chunk-QVYCDING.js}

@@ -1,8 +1,4 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-var _chunk3GQAWCBQjs = require('./chunk-3GQAWCBQ.js');
-
-// src/utils/create-cli-options.ts
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/utils/create-cli-options.ts
 var _devkit = require('@nx/devkit');
 function createCliOptions(obj) {
   const args = [];
@@ -11,7 +7,9 @@ function createCliOptions(obj) {
     if (value) {
       const arg = _devkit.names.call(void 0, key).fileName;
       if (Array.isArray(value)) {
-        args.push(`--${arg.toLowerCase()}=${value.map((v) => v.trim()).join(",")}`);
+        args.push(
+          `--${arg.toLowerCase()}=${value.map((v) => v.trim()).join(",")}`
+        );
       } else {
         args.push(`--${arg.toLowerCase()}=${value}`);
       }
@@ -19,7 +17,6 @@ function createCliOptions(obj) {
   }
   return args;
 }
-_chunk3GQAWCBQjs.__name.call(void 0, createCliOptions, "createCliOptions");
 
 
 

package/dist/{chunk-Z4NKRWWJ.js → chunk-RJRBED5Q.js}

@@ -1,7 +1,7 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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 _chunkUALZJZUKjs = require('./chunk-UALZJZUK.js');
+var _chunkJ2Z4WP3Ejs = require('./chunk-J2Z4WP3E.js');
 
 
 
@@ -11,48 +11,58 @@ var _chunkUALZJZUKjs = require('./chunk-UALZJZUK.js');
 
 
 
-var _chunkG4QFSE5Bjs = require('./chunk-G4QFSE5B.js');
+var _chunkWE4HK4RNjs = require('./chunk-WE4HK4RN.js');
 
 
-var _chunk4JOIS7WWjs = require('./chunk-4JOIS7WW.js');
-
-
-var _chunk3GQAWCBQjs = require('./chunk-3GQAWCBQ.js');
+var _chunk4WHSR4FKjs = require('./chunk-4WHSR4FK.js');
 
 // src/base/base-generator.ts
-var withRunGenerator = /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, (name, generatorFn, generatorOptions = {
+var withRunGenerator = (name, generatorFn, generatorOptions = {
   skipReadingConfig: false
 }) => async (tree, _options) => {
-  const stopwatch = _chunkG4QFSE5Bjs.getStopwatch.call(void 0, name);
+  const stopwatch = _chunkWE4HK4RNjs.getStopwatch.call(void 0, name);
   let options = _options;
   let config;
   try {
-    _chunkG4QFSE5Bjs.writeInfo.call(void 0, `\u26A1 Running the ${name} generator...
+    _chunkWE4HK4RNjs.writeInfo.call(void 0, `\u26A1 Running the ${name} generator...
 
 `, config);
-    const workspaceRoot = _chunk4JOIS7WWjs.findWorkspaceRoot.call(void 0, );
+    const workspaceRoot = _chunk4WHSR4FKjs.findWorkspaceRoot.call(void 0, );
     if (!generatorOptions.skipReadingConfig) {
-      _chunkG4QFSE5Bjs.writeDebug.call(void 0, `Loading the Storm Config from environment variables and storm.config.js file...
- - workspaceRoot: ${workspaceRoot}`, config);
-      config = await _chunkG4QFSE5Bjs.getConfig.call(void 0, workspaceRoot);
+      _chunkWE4HK4RNjs.writeDebug.call(void 0, 
+        `Loading the Storm Config from environment variables and storm.config.js file...
+ - workspaceRoot: ${workspaceRoot}`,
+        config
+      );
+      config = await _chunkWE4HK4RNjs.getConfig.call(void 0, workspaceRoot);
     }
     if (_optionalChain([generatorOptions, 'optionalAccess', _ => _.hooks, 'optionalAccess', _2 => _2.applyDefaultOptions])) {
-      _chunkG4QFSE5Bjs.writeDebug.call(void 0, "Running the applyDefaultOptions hook...", config);
-      options = await Promise.resolve(generatorOptions.hooks.applyDefaultOptions(options, config));
-      _chunkG4QFSE5Bjs.writeDebug.call(void 0, "Completed the applyDefaultOptions hook", config);
+      _chunkWE4HK4RNjs.writeDebug.call(void 0, "Running the applyDefaultOptions hook...", config);
+      options = await Promise.resolve(
+        generatorOptions.hooks.applyDefaultOptions(options, config)
+      );
+      _chunkWE4HK4RNjs.writeDebug.call(void 0, "Completed the applyDefaultOptions hook", config);
     }
-    _chunkG4QFSE5Bjs.writeTrace.call(void 0, `Generator schema options \u2699\uFE0F 
-${Object.keys(_nullishCoalesce(options, () => ( {}))).map((key) => ` - ${key}=${JSON.stringify(options[key])}`).join("\n")}`, config);
-    const tokenized = await _chunkUALZJZUKjs.applyWorkspaceTokens.call(void 0, options, {
-      workspaceRoot: tree.root,
+    _chunkWE4HK4RNjs.writeTrace.call(void 0, 
+      `Generator schema options \u2699\uFE0F 
+${Object.keys(_nullishCoalesce(options, () => ( {}))).map((key) => ` - ${key}=${JSON.stringify(options[key])}`).join("\n")}`,
       config
-    }, _chunkUALZJZUKjs.applyWorkspaceBaseTokens);
+    );
+    const tokenized = await _chunkJ2Z4WP3Ejs.applyWorkspaceTokens.call(void 0, 
+      options,
+      { workspaceRoot: tree.root, config },
+      _chunkJ2Z4WP3Ejs.applyWorkspaceBaseTokens
+    );
     if (_optionalChain([generatorOptions, 'optionalAccess', _3 => _3.hooks, 'optionalAccess', _4 => _4.preProcess])) {
-      _chunkG4QFSE5Bjs.writeDebug.call(void 0, "Running the preProcess hook...", config);
-      await Promise.resolve(generatorOptions.hooks.preProcess(tokenized, config));
-      _chunkG4QFSE5Bjs.writeDebug.call(void 0, "Completed the preProcess hook", config);
+      _chunkWE4HK4RNjs.writeDebug.call(void 0, "Running the preProcess hook...", config);
+      await Promise.resolve(
+        generatorOptions.hooks.preProcess(tokenized, config)
+      );
+      _chunkWE4HK4RNjs.writeDebug.call(void 0, "Completed the preProcess hook", config);
     }
-    const result = await Promise.resolve(generatorFn(tree, tokenized, config));
+    const result = await Promise.resolve(
+      generatorFn(tree, tokenized, config)
+    );
     if (result) {
       if (result.success === false || result.error && _optionalChain([result, 'optionalAccess', _5 => _5.error, 'optionalAccess', _6 => _6.message]) && typeof _optionalChain([result, 'optionalAccess', _7 => _7.error, 'optionalAccess', _8 => _8.message]) === "string" && _optionalChain([result, 'optionalAccess', _9 => _9.error, 'optionalAccess', _10 => _10.name]) && typeof _optionalChain([result, 'optionalAccess', _11 => _11.error, 'optionalAccess', _12 => _12.name]) === "string") {
         throw new Error(`The ${name} generator failed to run`, {
@@ -63,25 +73,31 @@ ${Object.keys(_nullishCoalesce(options, () => ( {}))).map((key) => ` - ${key}=${
       }
     }
     if (_optionalChain([generatorOptions, 'optionalAccess', _14 => _14.hooks, 'optionalAccess', _15 => _15.postProcess])) {
-      _chunkG4QFSE5Bjs.writeDebug.call(void 0, "Running the postProcess hook...", config);
+      _chunkWE4HK4RNjs.writeDebug.call(void 0, "Running the postProcess hook...", config);
       await Promise.resolve(generatorOptions.hooks.postProcess(config));
-      _chunkG4QFSE5Bjs.writeDebug.call(void 0, "Completed the postProcess hook", config);
+      _chunkWE4HK4RNjs.writeDebug.call(void 0, "Completed the postProcess hook", config);
     }
     return () => {
-      _chunkG4QFSE5Bjs.writeSuccess.call(void 0, `Completed running the ${name} generator!
+      _chunkWE4HK4RNjs.writeSuccess.call(void 0, `Completed running the ${name} generator!
 `, config);
     };
   } catch (error) {
     return () => {
-      _chunkG4QFSE5Bjs.writeFatal.call(void 0, "A fatal error occurred while running the generator - the process was forced to terminate", config);
-      _chunkG4QFSE5Bjs.writeError.call(void 0, `An exception was thrown in the generator's process 
+      _chunkWE4HK4RNjs.writeFatal.call(void 0, 
+        "A fatal error occurred while running the generator - the process was forced to terminate",
+        config
+      );
+      _chunkWE4HK4RNjs.writeError.call(void 0, 
+        `An exception was thrown in the generator's process 
  - Details: ${error.message}
- - Stacktrace: ${error.stack}`, config);
+ - Stacktrace: ${error.stack}`,
+        config
+      );
     };
   } finally {
     stopwatch();
   }
-}, "withRunGenerator");
+};
 
 
 

package/dist/chunk-S5Z4QGF3.js

@@ -0,0 +1,64 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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 _chunkRJRBED5Qjs = require('./chunk-RJRBED5Q.js');
+
+
+
+
+
+var _chunkWE4HK4RNjs = require('./chunk-WE4HK4RN.js');
+
+
+var _chunk4WHSR4FKjs = require('./chunk-4WHSR4FK.js');
+
+// src/generators/config-schema/generator.ts
+var _devkit = require('@nx/devkit');
+var _zodtojsonschema = require('zod-to-json-schema');
+async function configSchemaGeneratorFn(tree, options, config) {
+  _chunkWE4HK4RNjs.writeInfo.call(void 0, 
+    "\u{1F4E6}  Running Storm Workspace Configuration JSON Schema generator",
+    config
+  );
+  _chunkWE4HK4RNjs.writeTrace.call(void 0, 
+    `Determining the Storm Workspace Configuration JSON Schema...`,
+    config
+  );
+  const jsonSchema = _zodtojsonschema.zodToJsonSchema.call(void 0, _chunkWE4HK4RNjs.stormWorkspaceConfigSchema, {
+    name: "StormWorkspaceConfiguration"
+  });
+  _chunkWE4HK4RNjs.writeTrace.call(void 0, jsonSchema, config);
+  const outputPath = options.outputFile.replaceAll("{workspaceRoot}", "").replaceAll(
+    _nullishCoalesce(_optionalChain([config, 'optionalAccess', _ => _.workspaceRoot]), () => ( _chunk4WHSR4FKjs.findWorkspaceRoot.call(void 0, ))),
+    _optionalChain([options, 'access', _2 => _2.outputFile, 'optionalAccess', _3 => _3.startsWith, 'call', _4 => _4("./")]) ? "" : "./"
+  );
+  _chunkWE4HK4RNjs.writeTrace.call(void 0, 
+    `\u{1F4DD}  Writing Storm Configuration JSON Schema to "${outputPath}"`,
+    config
+  );
+  _devkit.writeJson.call(void 0, tree, outputPath, jsonSchema, { spaces: 2 });
+  await _devkit.formatFiles.call(void 0, tree);
+  _chunkWE4HK4RNjs.writeSuccess.call(void 0, 
+    "\u{1F680}  Storm Configuration JSON Schema creation has completed successfully!",
+    config
+  );
+  return {
+    success: true
+  };
+}
+var generator_default = _chunkRJRBED5Qjs.withRunGenerator.call(void 0, 
+  "Configuration Schema Creator",
+  configSchemaGeneratorFn,
+  {
+    hooks: {
+      applyDefaultOptions: (options) => {
+        options.outputFile ??= "{workspaceRoot}/storm-workspace.schema.json";
+        return options;
+      }
+    }
+  }
+);
+
+
+
+
+exports.configSchemaGeneratorFn = configSchemaGeneratorFn; exports.generator_default = generator_default;

package/dist/{chunk-CSHHIGIV.mjs → chunk-SITFTWPY.mjs}

@@ -4,14 +4,20 @@ import {
 } from "./chunk-EK75QNMS.mjs";
 import {
   withRunGenerator
-} from "./chunk-B67R3JAF.mjs";
+} from "./chunk-5HUW3BTP.mjs";
 import {
-  __dirname,
-  __name
-} from "./chunk-L2DHGVS5.mjs";
+  __dirname
+} from "./chunk-IEZKYJSF.mjs";
 
 // src/generators/preset/generator.ts
-import { addDependenciesToPackageJson, addProjectConfiguration, formatFiles, generateFiles, joinPathFragments, updateJson } from "@nx/devkit";
+import {
+  addDependenciesToPackageJson,
+  addProjectConfiguration,
+  formatFiles,
+  generateFiles,
+  joinPathFragments,
+  updateJson
+} from "@nx/devkit";
 import * as path from "node:path";
 async function presetGeneratorFn(tree, options) {
   const projectRoot = ".";
@@ -226,11 +232,20 @@ async function presetGeneratorFn(tree, options) {
       "nx-cloud": "latest"
     };
   }
-  await Promise.resolve(addDependenciesToPackageJson(tree, dependencies, {}, joinPathFragments(projectRoot, "package.json")));
+  await Promise.resolve(
+    addDependenciesToPackageJson(
+      tree,
+      dependencies,
+      {},
+      joinPathFragments(projectRoot, "package.json")
+    )
+  );
   return null;
 }
-__name(presetGeneratorFn, "presetGeneratorFn");
-var generator_default = withRunGenerator("Storm Workspace Preset Generator", presetGeneratorFn);
+var generator_default = withRunGenerator(
+  "Storm Workspace Preset Generator",
+  presetGeneratorFn
+);
 
 export {
   presetGeneratorFn,

package/dist/chunk-SNMXP6JV.mjs

@@ -0,0 +1,41 @@
+import {
+  buildCargoCommand,
+  cargoCommand
+} from "./chunk-QFWQZOVG.mjs";
+import {
+  withRunExecutor
+} from "./chunk-UYSJG2E5.mjs";
+
+// src/executors/cargo-doc/executor.ts
+async function cargoDocExecutor(options, context) {
+  const opts = { ...options };
+  opts["no-deps"] = opts.noDeps;
+  delete opts.noDeps;
+  const command = buildCargoCommand("doc", options, context);
+  return await cargoCommand(...command);
+}
+var executor_default = withRunExecutor(
+  "Cargo Doc",
+  cargoDocExecutor,
+  {
+    skipReadingConfig: false,
+    hooks: {
+      applyDefaultOptions: (options) => {
+        options.outputPath ??= "dist/docs/{projectRoot}";
+        options.toolchain ??= "stable";
+        options.release ??= options.profile ? false : true;
+        options.allFeatures ??= true;
+        options.lib ??= true;
+        options.bins ??= true;
+        options.examples ??= true;
+        options.noDeps ??= false;
+        return options;
+      }
+    }
+  }
+);
+
+export {
+  cargoDocExecutor,
+  executor_default
+};

package/dist/chunk-SPXJBMLY.js

@@ -0,0 +1,50 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkAJ3C2EDWjs = require('./chunk-AJ3C2EDW.js');
+
+
+var _chunkWE4HK4RNjs = require('./chunk-WE4HK4RN.js');
+
+// src/executors/typia/executor.ts
+var _fsextra = require('fs-extra');
+var _TypiaProgrammerjs = require('typia/lib/programmers/TypiaProgrammer.js');
+async function typiaExecutorFn(options, _, config) {
+  if (options.clean !== false) {
+    _chunkWE4HK4RNjs.writeInfo.call(void 0, `\u{1F9F9} Cleaning output path: ${options.outputPath}`, config);
+    _fsextra.removeSync.call(void 0, options.outputPath);
+  }
+  await Promise.all(
+    options.entry.map((entry) => {
+      _chunkWE4HK4RNjs.writeInfo.call(void 0, `\u{1F680} Running Typia on entry: ${entry}`, config);
+      return _TypiaProgrammerjs.TypiaProgrammer.build({
+        input: entry,
+        output: options.outputPath,
+        project: options.tsconfig
+      });
+    })
+  );
+  return {
+    success: true
+  };
+}
+var executor_default = _chunkAJ3C2EDWjs.withRunExecutor.call(void 0, 
+  "Typia runtime validation generator",
+  typiaExecutorFn,
+  {
+    skipReadingConfig: false,
+    hooks: {
+      applyDefaultOptions: (options) => {
+        options.entry ??= ["{sourceRoot}/index.ts"];
+        options.outputPath ??= "{sourceRoot}/__generated__/typia";
+        options.tsconfig ??= "{projectRoot}/tsconfig.json";
+        options.clean ??= true;
+        return options;
+      }
+    }
+  }
+);
+
+
+
+
+exports.typiaExecutorFn = typiaExecutorFn; exports.executor_default = executor_default;