@storm-software/workspace-tools 1.228.1 → 1.229.0

package/dist/chunk-MSENNRAY.js

@@ -0,0 +1,118 @@
+"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 _chunkBWFTYFWMjs = require('./chunk-BWFTYFWM.js');
+
+
+var _chunk5CPYNJT2js = require('./chunk-5CPYNJT2.js');
+
+
+
+
+
+
+
+
+
+
+var _chunk36FMHXUDjs = require('./chunk-36FMHXUD.js');
+
+
+var _chunk5MKQX2FEjs = require('./chunk-5MKQX2FE.js');
+
+
+var _chunk3GQAWCBQjs = require('./chunk-3GQAWCBQ.js');
+
+// src/base/base-executor.ts
+var withRunExecutor = /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, (name, executorFn, executorOptions = {}) => async (_options, context) => {
+  const stopwatch = _chunk36FMHXUDjs.getStopwatch.call(void 0, name);
+  let options = _options;
+  let config = {};
+  try {
+    _chunk36FMHXUDjs.writeInfo.call(void 0, `\u26A1 Running the ${name} executor...
+`, config);
+    if (!_optionalChain([context, 'access', _ => _.projectsConfigurations, 'optionalAccess', _2 => _2.projects]) || !context.projectName || !context.projectsConfigurations.projects[context.projectName]) {
+      throw new Error("The Build process failed because the context is not valid. Please run this command from a workspace.");
+    }
+    const workspaceRoot = _chunk5MKQX2FEjs.findWorkspaceRoot.call(void 0, );
+    const projectRoot = _nullishCoalesce(_optionalChain([context, 'access', _3 => _3.projectsConfigurations, 'access', _4 => _4.projects, 'access', _5 => _5[context.projectName], 'optionalAccess', _6 => _6.root]), () => ( workspaceRoot));
+    const sourceRoot = _nullishCoalesce(_optionalChain([context, 'access', _7 => _7.projectsConfigurations, 'access', _8 => _8.projects, 'access', _9 => _9[context.projectName], 'optionalAccess', _10 => _10.sourceRoot]), () => ( workspaceRoot));
+    const projectName = _nullishCoalesce(_optionalChain([context, 'access', _11 => _11.projectsConfigurations, 'access', _12 => _12.projects, 'access', _13 => _13[context.projectName], 'optionalAccess', _14 => _14.name]), () => ( context.projectName));
+    config.workspaceRoot = workspaceRoot;
+    if (!executorOptions.skipReadingConfig) {
+      _chunk36FMHXUDjs.writeTrace.call(void 0, `Loading the Storm Config from environment variables and storm.config.js file...
+ - workspaceRoot: ${workspaceRoot}
+ - projectRoot: ${projectRoot}
+ - sourceRoot: ${sourceRoot}
+ - projectName: ${projectName}
+`, config);
+      config = await _chunk36FMHXUDjs.loadStormConfig.call(void 0, workspaceRoot);
+    }
+    if (_optionalChain([executorOptions, 'optionalAccess', _15 => _15.hooks, 'optionalAccess', _16 => _16.applyDefaultOptions])) {
+      _chunk36FMHXUDjs.writeDebug.call(void 0, "Running the applyDefaultOptions hook...", config);
+      options = await Promise.resolve(executorOptions.hooks.applyDefaultOptions(options, config));
+      _chunk36FMHXUDjs.writeDebug.call(void 0, "Completed the applyDefaultOptions hook", config);
+    }
+    _chunk36FMHXUDjs.writeTrace.call(void 0, `Executor schema options \u2699\uFE0F 
+${Object.keys(options).map((key) => ` - ${key}=${_isFunction(options[key]) ? "<function>" : JSON.stringify(options[key])}`).join("\n")}`, config);
+    const tokenized = await _chunk5CPYNJT2js.applyWorkspaceTokens.call(void 0, options, {
+      config,
+      workspaceRoot,
+      projectRoot,
+      sourceRoot,
+      projectName,
+      ...context.projectsConfigurations.projects[context.projectName],
+      ...executorOptions
+    }, _chunkBWFTYFWMjs.applyWorkspaceExecutorTokens);
+    if (_optionalChain([executorOptions, 'optionalAccess', _17 => _17.hooks, 'optionalAccess', _18 => _18.preProcess])) {
+      _chunk36FMHXUDjs.writeDebug.call(void 0, "Running the preProcess hook...", config);
+      await Promise.resolve(executorOptions.hooks.preProcess(tokenized, config));
+      _chunk36FMHXUDjs.writeDebug.call(void 0, "Completed the preProcess hook", config);
+    }
+    const ret = executorFn(tokenized, context, config);
+    if (_isFunction(_optionalChain([ret, 'optionalAccess', _19 => _19.next]))) {
+      const asyncGen = ret;
+      for await (const iter of asyncGen) {
+      }
+    }
+    const result = await Promise.resolve(ret);
+    if (result && (!result.success || result.error && _optionalChain([result, 'optionalAccess', _20 => _20.error, 'optionalAccess', _21 => _21.message]) && typeof _optionalChain([result, 'optionalAccess', _22 => _22.error, 'optionalAccess', _23 => _23.message]) === "string" && _optionalChain([result, 'optionalAccess', _24 => _24.error, 'optionalAccess', _25 => _25.name]) && typeof _optionalChain([result, 'optionalAccess', _26 => _26.error, 'optionalAccess', _27 => _27.name]) === "string")) {
+      _chunk36FMHXUDjs.writeTrace.call(void 0, `Failure determined by the ${name} executor 
+${_chunk36FMHXUDjs.formatLogMessage.call(void 0, result)}`, config);
+      console.error(result);
+      throw new Error(`The ${name} executor failed to run`, {
+        cause: _optionalChain([result, 'optionalAccess', _28 => _28.error])
+      });
+    }
+    if (_optionalChain([executorOptions, 'optionalAccess', _29 => _29.hooks, 'optionalAccess', _30 => _30.postProcess])) {
+      _chunk36FMHXUDjs.writeDebug.call(void 0, "Running the postProcess hook...", config);
+      await Promise.resolve(executorOptions.hooks.postProcess(config));
+      _chunk36FMHXUDjs.writeDebug.call(void 0, "Completed the postProcess hook", config);
+    }
+    _chunk36FMHXUDjs.writeSuccess.call(void 0, `Completed running the ${name} task executor!
+`, config);
+    return {
+      success: true
+    };
+  } catch (error) {
+    _chunk36FMHXUDjs.writeFatal.call(void 0, "A fatal error occurred while running the executor - the process was forced to terminate", config);
+    _chunk36FMHXUDjs.writeError.call(void 0, `An exception was thrown in the executor's process 
+ - Details: ${error.message}
+ - Stacktrace: ${error.stack}`, config);
+    return {
+      success: false
+    };
+  } finally {
+    stopwatch();
+  }
+}, "withRunExecutor");
+var _isFunction = /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, (value) => {
+  try {
+    return value instanceof Function || typeof value === "function" || !!(_optionalChain([value, 'optionalAccess', _31 => _31.constructor]) && _optionalChain([value, 'optionalAccess', _32 => _32.call]) && _optionalChain([value, 'optionalAccess', _33 => _33.apply]));
+  } catch (e) {
+    return false;
+  }
+}, "_isFunction");
+
+
+
+exports.withRunExecutor = withRunExecutor;

package/dist/chunk-NCVJPQSP.js

@@ -0,0 +1,88 @@
+"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 _chunk5CPYNJT2js = require('./chunk-5CPYNJT2.js');
+
+
+
+
+
+
+
+
+
+var _chunk36FMHXUDjs = require('./chunk-36FMHXUD.js');
+
+
+var _chunk5MKQX2FEjs = require('./chunk-5MKQX2FE.js');
+
+
+var _chunk3GQAWCBQjs = require('./chunk-3GQAWCBQ.js');
+
+// src/base/base-generator.ts
+var withRunGenerator = /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, (name, generatorFn, generatorOptions = {
+  skipReadingConfig: false
+}) => async (tree, _options) => {
+  const stopwatch = _chunk36FMHXUDjs.getStopwatch.call(void 0, name);
+  let options = _options;
+  let config;
+  try {
+    _chunk36FMHXUDjs.writeInfo.call(void 0, `\u26A1 Running the ${name} generator...
+
+`, config);
+    const workspaceRoot = _chunk5MKQX2FEjs.findWorkspaceRoot.call(void 0, );
+    if (!generatorOptions.skipReadingConfig) {
+      _chunk36FMHXUDjs.writeDebug.call(void 0, `Loading the Storm Config from environment variables and storm.config.js file...
+ - workspaceRoot: ${workspaceRoot}`, config);
+      config = await _chunk36FMHXUDjs.loadStormConfig.call(void 0, workspaceRoot);
+    }
+    if (_optionalChain([generatorOptions, 'optionalAccess', _ => _.hooks, 'optionalAccess', _2 => _2.applyDefaultOptions])) {
+      _chunk36FMHXUDjs.writeDebug.call(void 0, "Running the applyDefaultOptions hook...", config);
+      options = await Promise.resolve(generatorOptions.hooks.applyDefaultOptions(options, config));
+      _chunk36FMHXUDjs.writeDebug.call(void 0, "Completed the applyDefaultOptions hook", config);
+    }
+    _chunk36FMHXUDjs.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 _chunk5CPYNJT2js.applyWorkspaceTokens.call(void 0, options, {
+      workspaceRoot: tree.root,
+      config
+    }, _chunk5CPYNJT2js.applyWorkspaceBaseTokens);
+    if (_optionalChain([generatorOptions, 'optionalAccess', _3 => _3.hooks, 'optionalAccess', _4 => _4.preProcess])) {
+      _chunk36FMHXUDjs.writeDebug.call(void 0, "Running the preProcess hook...", config);
+      await Promise.resolve(generatorOptions.hooks.preProcess(tokenized, config));
+      _chunk36FMHXUDjs.writeDebug.call(void 0, "Completed the preProcess hook", 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`, {
+          cause: _optionalChain([result, 'optionalAccess', _13 => _13.error])
+        });
+      } else if (result.success && result.data) {
+        return result;
+      }
+    }
+    if (_optionalChain([generatorOptions, 'optionalAccess', _14 => _14.hooks, 'optionalAccess', _15 => _15.postProcess])) {
+      _chunk36FMHXUDjs.writeDebug.call(void 0, "Running the postProcess hook...", config);
+      await Promise.resolve(generatorOptions.hooks.postProcess(config));
+      _chunk36FMHXUDjs.writeDebug.call(void 0, "Completed the postProcess hook", config);
+    }
+    return () => {
+      _chunk36FMHXUDjs.writeSuccess.call(void 0, `Completed running the ${name} generator!
+`, config);
+    };
+  } catch (error) {
+    return () => {
+      _chunk36FMHXUDjs.writeFatal.call(void 0, "A fatal error occurred while running the generator - the process was forced to terminate", config);
+      _chunk36FMHXUDjs.writeError.call(void 0, `An exception was thrown in the generator's process 
+ - Details: ${error.message}
+ - Stacktrace: ${error.stack}`, config);
+    };
+  } finally {
+    stopwatch();
+  }
+}, "withRunGenerator");
+
+
+
+exports.withRunGenerator = withRunGenerator;

package/dist/chunk-NDDXQD7R.mjs

@@ -0,0 +1,61 @@
+import {
+  findWorkspaceRoot
+} from "./chunk-DMUTOQCB.mjs";
+import {
+  __name
+} from "./chunk-XUV4U54K.mjs";
+
+// ../config-tools/src/utilities/apply-workspace-tokens.ts
+var applyWorkspaceBaseTokens = /* @__PURE__ */ __name(async (option, tokenizerOptions) => {
+  let result = option;
+  if (!result) {
+    return result;
+  }
+  if (tokenizerOptions) {
+    const optionKeys = Object.keys(tokenizerOptions);
+    if (optionKeys.some((optionKey) => result.includes(`{${optionKey}}`))) {
+      for (const optionKey of optionKeys) {
+        if (result.includes(`{${optionKey}}`)) {
+          result = result.replaceAll(`{${optionKey}}`, tokenizerOptions.config?.[optionKey] ?? "");
+        }
+      }
+    }
+  }
+  if (tokenizerOptions.config) {
+    const configKeys = Object.keys(tokenizerOptions.config);
+    if (configKeys.some((configKey) => result.includes(`{${configKey}}`))) {
+      for (const configKey of configKeys) {
+        if (result.includes(`{${configKey}}`)) {
+          result = result.replaceAll(`{${configKey}}`, tokenizerOptions.config[configKey]);
+        }
+      }
+    }
+  }
+  if (result.includes("{workspaceRoot}")) {
+    result = result.replaceAll("{workspaceRoot}", tokenizerOptions.workspaceRoot ?? tokenizerOptions.config?.workspaceRoot ?? findWorkspaceRoot());
+  }
+  return result;
+}, "applyWorkspaceBaseTokens");
+var applyWorkspaceTokens = /* @__PURE__ */ __name(async (options, config, tokenizerFn) => {
+  if (!options) {
+    return {};
+  }
+  const result = {};
+  for (const option of Object.keys(options)) {
+    if (typeof options[option] === "string") {
+      result[option] = await Promise.resolve(tokenizerFn(options[option], config));
+    } else if (Array.isArray(options[option])) {
+      result[option] = await Promise.all(options[option].map(async (item) => typeof item === "string" ? await Promise.resolve(tokenizerFn(item, config)) : item));
+    } else if (typeof options[option] === "object") {
+      result[option] = await applyWorkspaceTokens(options[option], config, tokenizerFn);
+    } else {
+      result[option] = options[option];
+    }
+  }
+  return result;
+}, "applyWorkspaceTokens");
+
+export {
+  applyWorkspaceBaseTokens,
+  applyWorkspaceTokens
+};

package/dist/chunk-OA7KWN7D.mjs

@@ -0,0 +1,66 @@
+import {
+  normalizeOptions,
+  typeScriptLibraryGeneratorFn
+} from "./chunk-XSRDTQ5C.mjs";
+import {
+  typesNodeVersion
+} from "./chunk-EK75QNMS.mjs";
+import {
+  withRunGenerator
+} from "./chunk-B3KIYNGT.mjs";
+import {
+  __dirname,
+  __name
+} from "./chunk-XUV4U54K.mjs";
+
+// src/generators/node-library/generator.ts
+import { formatFiles, generateFiles, joinPathFragments, names, offsetFromRoot } from "@nx/devkit";
+async function nodeLibraryGeneratorFn(tree, schema, config) {
+  const filesDir = joinPathFragments(__dirname, "./files");
+  const tsLibraryGeneratorOptions = {
+    platform: "node",
+    devDependencies: {
+      "@types/node": typesNodeVersion
+    },
+    buildExecutor: "@storm-software/workspace-tools:unbuild",
+    ...schema,
+    directory: schema.directory,
+    description: schema.description
+  };
+  const options = await normalizeOptions(tree, tsLibraryGeneratorOptions);
+  const { className, name, propertyName } = names(options.name);
+  generateFiles(tree, filesDir, options.projectRoot, {
+    ...schema,
+    dot: ".",
+    className,
+    name,
+    namespace: process.env.STORM_NAMESPACE ?? "storm-software",
+    description: schema.description ?? "",
+    propertyName,
+    js: !!options.js,
+    cliCommand: "nx",
+    strict: void 0,
+    tmpl: "",
+    offsetFromRoot: offsetFromRoot(options.projectRoot),
+    buildable: options.bundler && options.bundler !== "none",
+    hasUnitTestRunner: options.unitTestRunner !== "none"
+  });
+  await typeScriptLibraryGeneratorFn(tree, tsLibraryGeneratorOptions, config);
+  await formatFiles(tree);
+  return null;
+}
+__name(nodeLibraryGeneratorFn, "nodeLibraryGeneratorFn");
+var generator_default = withRunGenerator("TypeScript Library Creator (NodeJs Platform)", nodeLibraryGeneratorFn, {
+  hooks: {
+    applyDefaultOptions: /* @__PURE__ */ __name((options) => {
+      options.description ??= "A library used by Storm Software to support NodeJs applications";
+      options.platform ??= "node";
+      return options;
+    }, "applyDefaultOptions")
+  }
+});
+
+export {
+  nodeLibraryGeneratorFn,
+  generator_default
+};

package/dist/chunk-OESA3G7F.mjs

@@ -0,0 +1,31 @@
+import {
+  buildCargoCommand,
+  cargoCommand
+} from "./chunk-QZHIWK5Z.mjs";
+import {
+  withRunExecutor
+} from "./chunk-6267MSX4.mjs";
+import {
+  __name
+} from "./chunk-XUV4U54K.mjs";
+
+// src/executors/cargo-check/executor.ts
+async function cargoCheckExecutor(options, context) {
+  const command = buildCargoCommand("check", options, context);
+  return await cargoCommand(...command);
+}
+__name(cargoCheckExecutor, "cargoCheckExecutor");
+var executor_default = withRunExecutor("Cargo Check", cargoCheckExecutor, {
+  skipReadingConfig: false,
+  hooks: {
+    applyDefaultOptions: /* @__PURE__ */ __name((options) => {
+      options.toolchain ??= "stable";
+      return options;
+    }, "applyDefaultOptions")
+  }
+});
+
+export {
+  cargoCheckExecutor,
+  executor_default
+};

package/dist/chunk-OJ3R7YBK.js

@@ -0,0 +1,302 @@
+"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 _chunkCT7IVPJYjs = require('./chunk-CT7IVPJY.js');
+
+
+var _chunkMSENNRAYjs = require('./chunk-MSENNRAY.js');
+
+
+
+
+
+
+
+
+
+var _chunk36FMHXUDjs = require('./chunk-36FMHXUD.js');
+
+
+var _chunkXCSSYTCUjs = require('./chunk-XCSSYTCU.js');
+
+
+var _chunk3GQAWCBQjs = require('./chunk-3GQAWCBQ.js');
+
+// ../tsdown/src/build.ts
+var _node = require('@humanfs/node');
+var _devkit = require('@nx/devkit');
+var _defu = require('defu'); var _defu2 = _interopRequireDefault(_defu);
+var _findworkspaceroot = require('nx/src/utils/find-workspace-root');
+var _tsdown = require('tsdown');
+
+// ../tsdown/src/clean.ts
+
+async function clean(name = "ESBuild", directory, config) {
+  _chunk36FMHXUDjs.writeDebug.call(void 0, ` \u{1F9F9}  Cleaning ${name} output path: ${directory}`, config);
+  const stopwatch = _chunk36FMHXUDjs.getStopwatch.call(void 0, `${name} output clean`);
+  await _node.hfs.deleteAll(directory);
+  stopwatch();
+}
+_chunk3GQAWCBQjs.__name.call(void 0, clean, "clean");
+
+// ../tsdown/src/config.ts
+var DEFAULT_BUILD_OPTIONS = {
+  platform: "node",
+  target: "node22",
+  format: [
+    "esm",
+    "cjs"
+  ],
+  tsconfig: "tsconfig.json",
+  envName: "production",
+  globalName: "globalThis",
+  unused: {
+    level: "error"
+  },
+  injectShims: true,
+  watch: false,
+  bundle: true,
+  treeshake: true,
+  clean: true,
+  debug: false
+};
+
+// ../tsdown/src/build.ts
+var resolveOptions = /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, async (userOptions) => {
+  const projectRoot = userOptions.projectRoot;
+  const workspaceRoot = _findworkspaceroot.findWorkspaceRoot.call(void 0, projectRoot);
+  if (!workspaceRoot) {
+    throw new Error("Cannot find Nx workspace root");
+  }
+  const config = await _chunk36FMHXUDjs.loadStormConfig.call(void 0, workspaceRoot.dir);
+  _chunk36FMHXUDjs.writeDebug.call(void 0, "  \u2699\uFE0F   Resolving build options", config);
+  const stopwatch = _chunk36FMHXUDjs.getStopwatch.call(void 0, "Build options resolution");
+  const projectGraph = await _devkit.createProjectGraphAsync.call(void 0, {
+    exitOnError: true
+  });
+  const projectJsonPath = _chunkXCSSYTCUjs.joinPaths.call(void 0, workspaceRoot.dir, projectRoot, "project.json");
+  if (!await _node.hfs.isFile(projectJsonPath)) {
+    throw new Error("Cannot find project.json configuration");
+  }
+  const projectJson = await _node.hfs.json(projectJsonPath);
+  const projectName = projectJson.name;
+  const projectConfigurations = _devkit.readProjectsConfigurationFromProjectGraph.call(void 0, projectGraph);
+  if (!_optionalChain([projectConfigurations, 'optionalAccess', _ => _.projects, 'optionalAccess', _2 => _2[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 options = _defu2.default.call(void 0, userOptions, DEFAULT_BUILD_OPTIONS);
+  options.name ??= `${projectName}-${options.format}`;
+  options.target ??= _chunkCT7IVPJYjs.DEFAULT_TARGET;
+  const packageJsonPath = _chunkXCSSYTCUjs.joinPaths.call(void 0, workspaceRoot.dir, options.projectRoot, "package.json");
+  if (!await _node.hfs.isFile(packageJsonPath)) {
+    throw new Error("Cannot find package.json configuration");
+  }
+  const env = _chunkCT7IVPJYjs.getEnv.call(void 0, "tsdown", options);
+  const result = {
+    ...options,
+    config,
+    ...userOptions,
+    tsconfig: _chunkXCSSYTCUjs.joinPaths.call(void 0, projectRoot, userOptions.tsconfig ? userOptions.tsconfig.replace(projectRoot, "") : "tsconfig.json"),
+    format: options.format || "cjs",
+    entryPoints: await _chunkCT7IVPJYjs.getEntryPoints.call(void 0, config, projectRoot, projectJson.sourceRoot, userOptions.entry || [
+      "./src/index.ts"
+    ], userOptions.emitOnAll),
+    outdir: userOptions.outputPath || _chunkXCSSYTCUjs.joinPaths.call(void 0, "dist", projectRoot),
+    plugins: [],
+    name: userOptions.name || projectName,
+    projectConfigurations,
+    projectName,
+    projectGraph,
+    sourceRoot: userOptions.sourceRoot || projectJson.sourceRoot || _chunkXCSSYTCUjs.joinPaths.call(void 0, projectRoot, "src"),
+    minify: userOptions.minify || !userOptions.debug,
+    verbose: userOptions.verbose || _chunk36FMHXUDjs.isVerbose.call(void 0, ) || userOptions.debug === true,
+    includeSrc: userOptions.includeSrc === true,
+    metafile: userOptions.metafile !== false,
+    generatePackageJson: userOptions.generatePackageJson !== false,
+    clean: userOptions.clean !== false,
+    emitOnAll: userOptions.emitOnAll === true,
+    dts: userOptions.emitTypes === true ? {
+      transformer: "oxc"
+    } : userOptions.emitTypes,
+    bundleDts: userOptions.emitTypes,
+    assets: _nullishCoalesce(userOptions.assets, () => ( [])),
+    shims: userOptions.injectShims !== true,
+    bundle: userOptions.bundle !== false,
+    watch: userOptions.watch === true,
+    define: {
+      STORM_FORMAT: JSON.stringify(options.format || "cjs"),
+      ...options.format === "cjs" && options.injectShims ? {
+        "import.meta.url": "importMetaUrl"
+      } : {},
+      ...Object.keys(env || {}).reduce((res, key) => {
+        const value = JSON.stringify(env[key]);
+        return {
+          ...res,
+          [`process.env.${key}`]: value,
+          [`import.meta.env.${key}`]: value
+        };
+      }, {}),
+      ...options.define
+    }
+  };
+  stopwatch();
+  return result;
+}, "resolveOptions");
+async function generatePackageJson(options) {
+  if (options.generatePackageJson !== false && await _node.hfs.isFile(_chunkXCSSYTCUjs.joinPaths.call(void 0, options.projectRoot, "package.json"))) {
+    _chunk36FMHXUDjs.writeDebug.call(void 0, "  \u270D\uFE0F   Writing package.json file", options.config);
+    const stopwatch = _chunk36FMHXUDjs.getStopwatch.call(void 0, "Write package.json file");
+    const packageJsonPath = _chunkXCSSYTCUjs.joinPaths.call(void 0, options.projectRoot, "project.json");
+    if (!await _node.hfs.isFile(packageJsonPath)) {
+      throw new Error("Cannot find package.json configuration");
+    }
+    let packageJson = await _node.hfs.json(_chunkXCSSYTCUjs.joinPaths.call(void 0, options.config.workspaceRoot, options.projectRoot, "package.json"));
+    if (!packageJson) {
+      throw new Error("Cannot find package.json configuration file");
+    }
+    packageJson = await _chunkCT7IVPJYjs.addPackageDependencies.call(void 0, options.config.workspaceRoot, options.projectRoot, options.projectName, packageJson);
+    packageJson = await _chunkCT7IVPJYjs.addWorkspacePackageJsonFields.call(void 0, options.config, options.projectRoot, options.sourceRoot, options.projectName, false, packageJson);
+    packageJson.exports ??= {};
+    packageJson.exports["./package.json"] ??= "./package.json";
+    packageJson.exports["."] ??= _chunkCT7IVPJYjs.addPackageJsonExport.call(void 0, "index", packageJson.type, options.sourceRoot);
+    let entryPoints = [
+      {
+        in: "./src/index.ts",
+        out: "./src/index.ts"
+      }
+    ];
+    if (options.entryPoints) {
+      if (Array.isArray(options.entryPoints)) {
+        entryPoints = options.entryPoints.map((entryPoint) => typeof entryPoint === "string" ? {
+          in: entryPoint,
+          out: entryPoint
+        } : entryPoint);
+      }
+      for (const entryPoint of entryPoints) {
+        const split = entryPoint.out.split(".");
+        split.pop();
+        const entry = split.join(".").replaceAll("\\", "/");
+        packageJson.exports[`./${entry}`] ??= _chunkCT7IVPJYjs.addPackageJsonExport.call(void 0, entry, packageJson.type, options.sourceRoot);
+      }
+    }
+    packageJson.main = packageJson.type === "commonjs" ? "./dist/index.js" : "./dist/index.cjs";
+    packageJson.module = packageJson.type === "module" ? "./dist/index.js" : "./dist/index.mjs";
+    packageJson.types = "./dist/index.d.ts";
+    packageJson.exports = Object.keys(packageJson.exports).reduce((ret, key) => {
+      if (key.endsWith("/index") && !ret[key.replace("/index", "")]) {
+        ret[key.replace("/index", "")] = packageJson.exports[key];
+      }
+      return ret;
+    }, packageJson.exports);
+    await _devkit.writeJsonFile.call(void 0, _chunkXCSSYTCUjs.joinPaths.call(void 0, options.outdir, "package.json"), packageJson);
+    stopwatch();
+  }
+  return options;
+}
+_chunk3GQAWCBQjs.__name.call(void 0, generatePackageJson, "generatePackageJson");
+async function executeTSDown(options) {
+  _chunk36FMHXUDjs.writeDebug.call(void 0, `  \u{1F680}  Running ${options.name} build`, options.config);
+  const stopwatch = _chunk36FMHXUDjs.getStopwatch.call(void 0, `${options.name} build`);
+  await _tsdown.build.call(void 0, {
+    ...options,
+    entry: options.entryPoints,
+    outDir: options.outdir,
+    config: false
+  });
+  stopwatch();
+  return options;
+}
+_chunk3GQAWCBQjs.__name.call(void 0, executeTSDown, "executeTSDown");
+async function copyBuildAssets(options) {
+  _chunk36FMHXUDjs.writeDebug.call(void 0, `  \u{1F4CB}  Copying asset files to output directory: ${options.outdir}`, options.config);
+  const stopwatch = _chunk36FMHXUDjs.getStopwatch.call(void 0, `${options.name} asset copy`);
+  await _chunkCT7IVPJYjs.copyAssets.call(void 0, options.config, _nullishCoalesce(options.assets, () => ( [])), options.outdir, options.projectRoot, options.projectName, options.sourceRoot, true, false);
+  stopwatch();
+  return options;
+}
+_chunk3GQAWCBQjs.__name.call(void 0, copyBuildAssets, "copyBuildAssets");
+async function reportResults(options) {
+  _chunk36FMHXUDjs.writeSuccess.call(void 0, `  \u{1F4E6}  The ${options.name} build completed successfully`, options.config);
+}
+_chunk3GQAWCBQjs.__name.call(void 0, reportResults, "reportResults");
+async function cleanOutputPath(options) {
+  if (options.clean !== false && options.outdir) {
+    await clean(options.name, options.outdir, options.config);
+  }
+  return options;
+}
+_chunk3GQAWCBQjs.__name.call(void 0, cleanOutputPath, "cleanOutputPath");
+async function build(options) {
+  _chunk36FMHXUDjs.writeDebug.call(void 0, `  \u26A1   Executing Storm TSDown pipeline`);
+  const stopwatch = _chunk36FMHXUDjs.getStopwatch.call(void 0, "TSDown pipeline");
+  try {
+    const opts = Array.isArray(options) ? options : [
+      options
+    ];
+    if (opts.length === 0) {
+      throw new Error("No build options were provided");
+    }
+    const resolved = await Promise.all(opts.map(async (opt) => await resolveOptions(opt)));
+    if (resolved.length > 0) {
+      await cleanOutputPath(resolved[0]);
+      await generatePackageJson(resolved[0]);
+      await Promise.all(resolved.map(async (opt) => {
+        await executeTSDown(opt);
+        await copyBuildAssets(opt);
+        await reportResults(opt);
+      }));
+    } else {
+      _chunk36FMHXUDjs.writeWarning.call(void 0, "  \u{1F6A7}   No options were passed to TSBuild. Please check the parameters passed to the `build` function.");
+    }
+    _chunk36FMHXUDjs.writeSuccess.call(void 0, "  \u{1F3C1}  TSDown pipeline build completed successfully");
+  } catch (error) {
+    _chunk36FMHXUDjs.writeFatal.call(void 0, "  \u274C  Fatal errors occurred during the build that could not be recovered from. The build process has been terminated.");
+    throw error;
+  } finally {
+    stopwatch();
+  }
+}
+_chunk3GQAWCBQjs.__name.call(void 0, build, "build");
+
+// src/executors/tsdown/executor.ts
+async function tsdownExecutorFn(options, context, config) {
+  _chunk36FMHXUDjs.writeInfo.call(void 0, "\u{1F4E6}  Running Storm TSDown build executor on the workspace", config);
+  if (!_optionalChain([context, 'access', _3 => _3.projectsConfigurations, 'optionalAccess', _4 => _4.projects]) || !context.projectName || !context.projectsConfigurations.projects[context.projectName] || !_optionalChain([context, 'access', _5 => _5.projectsConfigurations, 'access', _6 => _6.projects, 'access', _7 => _7[context.projectName], 'optionalAccess', _8 => _8.root])) {
+    throw new Error("The Build process failed because the context is not valid. Please run this command from a workspace.");
+  }
+  await build({
+    ...options,
+    projectRoot: _optionalChain([context, 'access', _9 => _9.projectsConfigurations, 'access', _10 => _10.projects, 'optionalAccess', _11 => _11[context.projectName], 'access', _12 => _12.root]),
+    projectName: context.projectName,
+    sourceRoot: _optionalChain([context, 'access', _13 => _13.projectsConfigurations, 'access', _14 => _14.projects, 'optionalAccess', _15 => _15[context.projectName], 'optionalAccess', _16 => _16.sourceRoot]),
+    format: options.format,
+    platform: options.platform
+  });
+  return {
+    success: true
+  };
+}
+_chunk3GQAWCBQjs.__name.call(void 0, tsdownExecutorFn, "tsdownExecutorFn");
+var executor_default = _chunkMSENNRAYjs.withRunExecutor.call(void 0, "Storm TSDown build executor", tsdownExecutorFn, {
+  skipReadingConfig: false,
+  hooks: {
+    applyDefaultOptions: /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, async (options, config) => {
+      options.entry ??= [
+        "src/index.ts"
+      ];
+      options.outputPath ??= "dist/{projectRoot}";
+      options.tsconfig ??= "{projectRoot}/tsconfig.json";
+      return options;
+    }, "applyDefaultOptions")
+  }
+});
+
+
+
+
+exports.tsdownExecutorFn = tsdownExecutorFn; exports.executor_default = executor_default;