@storm-software/workspace-tools 1.228.1 → 1.229.0

package/dist/chunk-RKOOM5R5.js

@@ -0,0 +1,509 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await 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');
+
+// ../unbuild/src/build.ts
+var _node = require('@humanfs/node');
+var _devkit = require('@nx/devkit');
+var _js = require('@nx/js');
+var _buildablelibsutils = require('@nx/js/src/utils/buildable-libs-utils');
+var _defu = require('defu'); var _defu2 = _interopRequireDefault(_defu);
+var _path = require('path');
+var _findworkspaceroot = require('nx/src/utils/find-workspace-root');
+var _unbuild = require('unbuild');
+
+// ../unbuild/src/clean.ts
+
+async function clean(name = "Unbuild", 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");
+
+// ../unbuild/src/plugins/analyze.ts
+var formatBytes = /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, (bytes) => {
+  if (bytes === 0) return "0 Byte";
+  const k = 1e3;
+  const dm = 3;
+  const sizes = [
+    "Bytes",
+    "KB",
+    "MB",
+    "GB"
+  ];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / k ** i).toFixed(dm))} ${sizes[i]}`;
+}, "formatBytes");
+var analyzePlugin = /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, (options, resolvedOptions) => {
+  return {
+    name: "storm:analyzer",
+    renderChunk(source, chunk) {
+      const sourceBytes = formatBytes(source.length);
+      const fileName = chunk.fileName;
+      _chunk36FMHXUDjs.writeInfo.call(void 0, ` - ${fileName} ${sourceBytes}`, resolvedOptions.config);
+    }
+  };
+}, "analyzePlugin");
+
+// ../unbuild/src/plugins/on-error.ts
+var onErrorPlugin = /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, (options, resolvedOptions) => ({
+  name: "storm:on-error",
+  buildEnd(error) {
+    if (error) {
+      _chunk36FMHXUDjs.writeError.call(void 0, `The following errors occurred during the build:
+${error ? error.message : "Unknown build error"}
+
+    `, resolvedOptions.config);
+      throw new Error("Storm unbuild process failed with errors.");
+    }
+  },
+  renderError(error) {
+    _chunk36FMHXUDjs.writeError.call(void 0, `The following errors occurred during the build:
+${error ? error.message : "Unknown build error"}
+
+  `, resolvedOptions.config);
+    throw new Error("Storm unbuild process failed with errors.");
+  }
+}), "onErrorPlugin");
+
+// ../unbuild/src/plugins/swc.ts
+var swcPlugin = /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, (options, resolvedOptions) => {
+  const { transform } = _chunk3GQAWCBQjs.__require.call(void 0, "@swc/core");
+  return {
+    name: "storm:swc",
+    transform(code, filename) {
+      return transform(code, {
+        filename,
+        jsc: {
+          transform: {
+            react: {
+              runtime: "automatic"
+            }
+          }
+        }
+      });
+    }
+  };
+}, "swcPlugin");
+
+// ../unbuild/src/plugins/tsc.ts
+
+
+var _compilerhelperdependency = require('@nx/js/src/utils/compiler-helper-dependency');
+var _rollupplugintypescript2 = require('rollup-plugin-typescript2'); var _rollupplugintypescript22 = _interopRequireDefault(_rollupplugintypescript2);
+
+// ../unbuild/src/utilities/helpers.ts
+
+
+
+var _url = require('url');
+var _typescript = require('typescript'); var _typescript2 = _interopRequireDefault(_typescript);
+async function loadConfig(configPath) {
+  if (!/\.(js|mjs)$/.test(_path.extname.call(void 0, configPath))) {
+    throw new Error("Unsupported config file format");
+  }
+  return Promise.resolve().then(() => _interopRequireWildcard(require(_url.pathToFileURL.call(void 0, configPath).toString()))).then((config) => config.default);
+}
+_chunk3GQAWCBQjs.__name.call(void 0, loadConfig, "loadConfig");
+async function createTsCompilerOptions(config, tsConfigPath, projectRoot, dependencies) {
+  const tsConfigFile = _typescript2.default.readConfigFile(_devkit.joinPathFragments.call(void 0, config.workspaceRoot, projectRoot, tsConfigPath), _typescript2.default.sys.readFile);
+  const tsConfig = _typescript2.default.parseJsonConfigFileContent(tsConfigFile.config, _typescript2.default.sys, _path.dirname.call(void 0, _devkit.joinPathFragments.call(void 0, config.workspaceRoot, projectRoot, tsConfigPath)));
+  const compilerOptions = {
+    rootDir: projectRoot,
+    declaration: true,
+    paths: _buildablelibsutils.computeCompilerOptionsPaths.call(void 0, tsConfig, _nullishCoalesce(dependencies, () => ( [])))
+  };
+  _chunk36FMHXUDjs.writeTrace.call(void 0, compilerOptions, config);
+  return compilerOptions;
+}
+_chunk3GQAWCBQjs.__name.call(void 0, createTsCompilerOptions, "createTsCompilerOptions");
+
+// ../unbuild/src/plugins/tsc.ts
+var tscPlugin = /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, async (options, resolvedOptions) => {
+  const projectGraph = await _devkit.createProjectGraphAsync.call(void 0, {
+    exitOnError: true
+  });
+  const result = _buildablelibsutils.calculateProjectBuildableDependencies.call(void 0, void 0, projectGraph, resolvedOptions.config.workspaceRoot, resolvedOptions.projectName, process.env.NX_TASK_TARGET_TARGET || "build", process.env.NX_TASK_TARGET_CONFIGURATION || "production", true);
+  let dependencies = result.dependencies;
+  const tsLibDependency = _compilerhelperdependency.getHelperDependency.call(void 0, _compilerhelperdependency.HelperDependency.tsc, resolvedOptions.tsconfig, dependencies, projectGraph, true);
+  if (tsLibDependency) {
+    dependencies = dependencies.filter((deps) => deps.name !== tsLibDependency.name);
+    dependencies.push(tsLibDependency);
+  }
+  return _rollupplugintypescript22.default.call(void 0, {
+    check: options.emitTypes !== false,
+    tsconfig: resolvedOptions.tsconfig,
+    tsconfigOverride: {
+      compilerOptions: await createTsCompilerOptions(resolvedOptions.config, resolvedOptions.tsconfig, resolvedOptions.projectRoot, dependencies)
+    }
+  });
+}, "tscPlugin");
+
+// ../unbuild/src/plugins/type-definitions.ts
+
+var typeDefinitions = /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, (options, resolvedOptions) => ({
+  name: "storm:dts-bundle",
+  async generateBundle(_opts, bundle) {
+    for (const file of Object.values(bundle)) {
+      if (file.type === "asset" || !file.isEntry || file.facadeModuleId == null) {
+        continue;
+      }
+      const hasDefaultExport = file.exports.includes("default");
+      const entrySourceFileName = _path.relative.call(void 0, options.projectRoot, file.facadeModuleId);
+      const entrySourceDtsName = entrySourceFileName.replace(/\.[cm]?[jt]sx?$/, "");
+      const dtsFileName = file.fileName.replace(/\.[cm]?js$/, ".d.ts");
+      const relativeSourceDtsName = JSON.stringify("./" + entrySourceDtsName);
+      const dtsFileSource = hasDefaultExport ? `
+export * from ${relativeSourceDtsName};
+export { default } from ${relativeSourceDtsName};
+            ` : `export * from ${relativeSourceDtsName};
+`;
+      this.emitFile({
+        type: "asset",
+        fileName: dtsFileName,
+        source: dtsFileSource
+      });
+    }
+  }
+}), "typeDefinitions");
+
+// ../unbuild/src/config.ts
+var getDefaultBuildPlugins = /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, async (options, resolvedOptions) => Promise.all([
+  analyzePlugin(options, resolvedOptions),
+  swcPlugin(options, resolvedOptions),
+  typeDefinitions(options, resolvedOptions),
+  tscPlugin(options, resolvedOptions),
+  onErrorPlugin(options, resolvedOptions)
+].map((plugin) => Promise.resolve(plugin))), "getDefaultBuildPlugins");
+
+// ../unbuild/src/build.ts
+async function resolveOptions(options) {
+  const projectRoot = options.projectRoot;
+  if (!projectRoot) {
+    throw new Error("Cannot find project root");
+  }
+  const outputPath = options.outputPath || _chunkXCSSYTCUjs.joinPaths.call(void 0, "dist", projectRoot);
+  const workspaceRoot = _findworkspaceroot.findWorkspaceRoot.call(void 0, projectRoot);
+  if (!workspaceRoot) {
+    throw new Error("Cannot find 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");
+  if (options.configPath) {
+    const configFile = await loadConfig(options.configPath);
+    if (configFile) {
+      options = _defu2.default.call(void 0, options, configFile);
+    }
+  }
+  const projectGraph = await _devkit.createProjectGraphAsync.call(void 0, {
+    exitOnError: true
+  });
+  const projectJsonPath = _chunkXCSSYTCUjs.joinPaths.call(void 0, config.workspaceRoot, 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 packageJsonPath = _chunkXCSSYTCUjs.joinPaths.call(void 0, workspaceRoot.dir, projectRoot, "package.json");
+  if (!await _node.hfs.isFile(packageJsonPath)) {
+    throw new Error("Cannot find package.json configuration");
+  }
+  const packageJson = await _node.hfs.json(packageJsonPath);
+  let tsconfig = options.tsconfig;
+  if (!tsconfig) {
+    tsconfig = _chunkXCSSYTCUjs.joinPaths.call(void 0, workspaceRoot.dir, projectRoot, "tsconfig.json");
+  }
+  if (!await _node.hfs.isFile(tsconfig)) {
+    throw new Error("Cannot find tsconfig.json configuration");
+  }
+  let sourceRoot = projectJson.sourceRoot;
+  if (!sourceRoot) {
+    sourceRoot = _chunkXCSSYTCUjs.joinPaths.call(void 0, projectRoot, "src");
+  }
+  if (!await _node.hfs.isDirectory(sourceRoot)) {
+    throw new Error("Cannot find sourceRoot directory");
+  }
+  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 result = _buildablelibsutils.calculateProjectBuildableDependencies.call(void 0, void 0, projectGraph, workspaceRoot.dir, projectName, process.env.NX_TASK_TARGET_TARGET || "build", process.env.NX_TASK_TARGET_CONFIGURATION || "production", true);
+  let dependencies = result.dependencies;
+  const tsLibDependency = _js.getHelperDependency.call(void 0, _js.HelperDependency.tsc, tsconfig, dependencies, projectGraph, true);
+  if (tsLibDependency) {
+    dependencies = dependencies.filter((deps) => deps.name !== tsLibDependency.name);
+    dependencies.push(tsLibDependency);
+  }
+  const resolvedOptions = {
+    name: projectName,
+    config,
+    projectRoot,
+    sourceRoot,
+    projectName,
+    tsconfig,
+    clean: false,
+    entries: [
+      {
+        builder: "mkdist",
+        input: `.${sourceRoot.replace(projectRoot, "")}`,
+        outDir: _chunkXCSSYTCUjs.joinPaths.call(void 0, _path.relative.call(void 0, _chunkXCSSYTCUjs.joinPaths.call(void 0, config.workspaceRoot, projectRoot), config.workspaceRoot).replaceAll("\\", "/"), outputPath, "dist").replaceAll("\\", "/"),
+        declaration: options.emitTypes !== false,
+        format: "esm"
+      },
+      {
+        builder: "mkdist",
+        input: `.${sourceRoot.replace(projectRoot, "")}`,
+        outDir: _chunkXCSSYTCUjs.joinPaths.call(void 0, _path.relative.call(void 0, _chunkXCSSYTCUjs.joinPaths.call(void 0, config.workspaceRoot, projectRoot), config.workspaceRoot).replaceAll("\\", "/"), outputPath, "dist").replaceAll("\\", "/"),
+        declaration: options.emitTypes !== false,
+        format: "cjs",
+        ext: "cjs"
+      }
+    ],
+    declaration: options.emitTypes !== false ? "compatible" : false,
+    failOnWarn: false,
+    sourcemap: _nullishCoalesce(options.sourcemap, () => ( !!options.debug)),
+    outDir: outputPath,
+    parallel: true,
+    stub: false,
+    stubOptions: {
+      jiti: {}
+    },
+    externals: _nullishCoalesce(options.external, () => ( [])),
+    dependencies: [],
+    peerDependencies: [],
+    devDependencies: [],
+    hooks: {},
+    alias: {},
+    replace: {},
+    rollup: {
+      replace: {},
+      alias: {},
+      json: {},
+      commonjs: {
+        sourceMap: _nullishCoalesce(options.sourcemap, () => ( true))
+      },
+      emitCJS: true,
+      cjsBridge: true,
+      dts: {
+        respectExternal: true,
+        tsconfig
+      },
+      output: {
+        banner: options.banner || `
+//      \u26A1 Built by Storm Software
+  `,
+        footer: options.footer
+      },
+      resolve: {
+        preferBuiltins: true,
+        extensions: [
+          ".cjs",
+          ".mjs",
+          ".js",
+          ".jsx",
+          ".ts",
+          ".tsx",
+          ".json"
+        ]
+      },
+      esbuild: {
+        minify: !!options.minify,
+        splitting: options.splitting !== false,
+        treeShaking: options.treeShaking !== false,
+        color: true,
+        logLevel: config.logLevel === _chunk36FMHXUDjs.LogLevelLabel.FATAL ? _chunk36FMHXUDjs.LogLevelLabel.ERROR : _chunk36FMHXUDjs.isVerbose.call(void 0, ) ? "verbose" : config.logLevel
+      }
+    }
+  };
+  dependencies = dependencies.filter((dep) => dep.node.type === "npm" || dep.node.type === "lib" || dep.node.type === "app");
+  if (dependencies.length > 0) {
+    resolvedOptions.dependencies = dependencies.map((dep) => dep.name);
+  }
+  if (packageJson.devDependencies) {
+    resolvedOptions.devDependencies = Object.keys(packageJson.devDependencies);
+  }
+  if (packageJson.peerDependencies) {
+    resolvedOptions.peerDependencies = Object.keys(packageJson.peerDependencies);
+  }
+  if (options.rollup) {
+    let rollup = {};
+    if (typeof options.rollup === "string") {
+      const rollupFile = await loadConfig(options.rollup);
+      if (rollupFile) {
+        rollup = rollupFile;
+      }
+    } else {
+      rollup = options.rollup;
+    }
+    resolvedOptions.rollup = _defu2.default.call(void 0, _nullishCoalesce(resolvedOptions.rollup, () => ( {})), rollup);
+  }
+  resolvedOptions.hooks = {
+    "rollup:options": /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, async (ctx, opts) => {
+      opts.plugins = await _asyncNullishCoalesce(options.plugins, async () => ( await getDefaultBuildPlugins(options, resolvedOptions)));
+    }, "rollup:options")
+  };
+  stopwatch();
+  return resolvedOptions;
+}
+_chunk3GQAWCBQjs.__name.call(void 0, resolveOptions, "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 = await _chunkCT7IVPJYjs.addPackageJsonExports.call(void 0, options.sourceRoot, packageJson);
+    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 executeUnbuild(options) {
+  _chunk36FMHXUDjs.writeDebug.call(void 0, `  \u{1F680}  Running ${options.name} (${options.projectRoot}) build`, options.config);
+  const stopwatch = _chunk36FMHXUDjs.getStopwatch.call(void 0, `${options.name} (${options.projectRoot}) build`);
+  try {
+    await _unbuild.build.call(void 0, options.projectRoot, false, {
+      ...options,
+      rootDir: options.projectRoot
+    });
+  } finally {
+    stopwatch();
+  }
+  return options;
+}
+_chunk3GQAWCBQjs.__name.call(void 0, executeUnbuild, "executeUnbuild");
+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, options.generatePackageJson, options.includeSrc);
+  stopwatch();
+  return options;
+}
+_chunk3GQAWCBQjs.__name.call(void 0, copyBuildAssets, "copyBuildAssets");
+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 Unbuild pipeline`);
+  const stopwatch = _chunk36FMHXUDjs.getStopwatch.call(void 0, "Unbuild pipeline");
+  try {
+    const resolvedOptions = await resolveOptions(options);
+    await cleanOutputPath(resolvedOptions);
+    await generatePackageJson(resolvedOptions);
+    await executeUnbuild(resolvedOptions);
+    await copyBuildAssets(resolvedOptions);
+    _chunk36FMHXUDjs.writeSuccess.call(void 0, `  \u{1F3C1}  The ${resolvedOptions.name} build completed successfully`, resolvedOptions.config);
+  } 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/unbuild/executor.ts
+
+async function unbuildExecutorFn(options, context, config) {
+  _chunk36FMHXUDjs.writeInfo.call(void 0, "\u{1F4E6}  Running Storm Unbuild 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(_defu.defu.call(void 0, {
+    ...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]),
+    platform: options.platform,
+    name: context.projectName
+  }, {
+    stubOptions: {
+      jiti: {
+        cache: "node_modules/.cache/storm"
+      }
+    },
+    rollup: {
+      emitCJS: true,
+      watch: false,
+      cjsBridge: false,
+      dts: {
+        respectExternal: true
+      },
+      replace: {},
+      alias: {},
+      resolve: {},
+      json: {},
+      commonjs: {},
+      esbuild: {
+        target: options.target,
+        format: "esm",
+        platform: options.platform,
+        minify: options.minify,
+        treeShaking: options.treeShaking
+      }
+    }
+  }));
+  return {
+    success: true
+  };
+}
+_chunk3GQAWCBQjs.__name.call(void 0, unbuildExecutorFn, "unbuildExecutorFn");
+var executor_default = _chunkMSENNRAYjs.withRunExecutor.call(void 0, "TypeScript Unbuild build", unbuildExecutorFn, {
+  skipReadingConfig: false,
+  hooks: {
+    applyDefaultOptions: /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, async (options, config) => {
+      options.entry ??= [
+        "{sourceRoot}"
+      ];
+      options.outputPath ??= "dist/{projectRoot}";
+      options.tsconfig ??= "{projectRoot}/tsconfig.json";
+      return options;
+    }, "applyDefaultOptions")
+  }
+});
+
+
+
+
+exports.unbuildExecutorFn = unbuildExecutorFn; exports.executor_default = executor_default;