@storm-software/esbuild 0.4.1 → 0.14.2

package/dist/{chunk-KVBDKVBU.cjs → chunk-VZBOWHCM.cjs}

@@ -1,10 +1,13 @@
 "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(); } }
 
 
-var _chunkWGEGR3DFcjs = require('./chunk-WGEGR3DF.cjs');
+var _chunkVBINBV4Zcjs = require('./chunk-VBINBV4Z.cjs');
+
+
+
+var _chunkBGYQAVKQcjs = require('./chunk-BGYQAVKQ.cjs');
 
 // src/plugins/deps-check.ts
-var _configtools = require('@storm-software/config-tools');
 var _module = require('module');
 var _path = require('path'); var _path2 = _interopRequireDefault(_path);
 var unusedIgnore = [
@@ -36,11 +39,11 @@ var missingIgnore = [
   "@prisma/client",
   "ts-toolbelt"
 ];
-var depsCheckPlugin = /* @__PURE__ */ _chunkWGEGR3DFcjs.__name.call(void 0, (bundle) => ({
+var depsCheckPlugin = /* @__PURE__ */ _chunkBGYQAVKQcjs.__name.call(void 0, (bundle) => ({
   name: "storm:deps-check",
   setup(build) {
     const pkgJsonPath = _path2.default.join(process.cwd(), "package.json");
-    const pkgContents = _chunkWGEGR3DFcjs.__require.call(void 0, pkgJsonPath);
+    const pkgContents = _chunkBGYQAVKQcjs.__require.call(void 0, pkgJsonPath);
     const regDependencies = Object.keys(_nullishCoalesce(pkgContents["dependencies"], () => ( {})));
     const devDependencies = Object.keys(_nullishCoalesce(pkgContents["devDependencies"], () => ( {})));
     const peerDependencies = Object.keys(_nullishCoalesce(pkgContents["peerDependencies"], () => ( {})));
@@ -83,8 +86,8 @@ var depsCheckPlugin = /* @__PURE__ */ _chunkWGEGR3DFcjs.__name.call(void 0, (bun
       const filteredMissingDeps = missingDependencies.filter((dep) => {
         return !missingIgnore.some((pattern) => dep.match(pattern)) && !peerDependencies.includes(dep);
       });
-      _configtools.writeWarning.call(void 0, `Unused Dependencies: ${JSON.stringify(filteredUnusedDeps)}`);
-      _configtools.writeError.call(void 0, `Missing Dependencies: ${JSON.stringify(filteredMissingDeps)}`);
+      _chunkVBINBV4Zcjs.writeWarning.call(void 0, `Unused Dependencies: ${JSON.stringify(filteredUnusedDeps)}`);
+      _chunkVBINBV4Zcjs.writeError.call(void 0, `Missing Dependencies: ${JSON.stringify(filteredMissingDeps)}`);
       if (filteredMissingDeps.length > 0) {
         throw new Error(`Missing dependencies detected - please install them:
 ${JSON.stringify(filteredMissingDeps)}
@@ -97,4 +100,3 @@ ${JSON.stringify(filteredMissingDeps)}
 
 
 exports.depsCheckPlugin = depsCheckPlugin;
-//# sourceMappingURL=chunk-KVBDKVBU.cjs.map

package/dist/chunk-WRBUO7H6.cjs

@@ -0,0 +1,23 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkBGYQAVKQcjs = require('./chunk-BGYQAVKQ.cjs');
+
+// src/plugins/node-protocol.ts
+var nodeProtocolPlugin = /* @__PURE__ */ _chunkBGYQAVKQcjs.__name.call(void 0, (options, resolvedOptions) => {
+  const nodeProtocol = "node:";
+  return {
+    name: "node-protocol-plugin",
+    setup({ onResolve }) {
+      onResolve({
+        filter: /^node:/
+      }, ({ path }) => ({
+        path: path.slice(nodeProtocol.length),
+        external: true
+      }));
+    }
+  };
+}, "nodeProtocolPlugin");
+
+
+
+exports.nodeProtocolPlugin = nodeProtocolPlugin;

package/dist/chunk-WYMD6YG2.cjs

@@ -0,0 +1,582 @@
+"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(); } } 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 _chunkTP5EOMRDcjs = require('./chunk-TP5EOMRD.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunk5I2MGPRNcjs = require('./chunk-5I2MGPRN.cjs');
+
+
+var _chunkVZBOWHCMcjs = require('./chunk-VZBOWHCM.cjs');
+
+
+
+
+
+
+
+
+
+var _chunkVBINBV4Zcjs = require('./chunk-VBINBV4Z.cjs');
+
+
+var _chunkLVWQSCJMcjs = require('./chunk-LVWQSCJM.cjs');
+
+
+var _chunkBGYQAVKQcjs = require('./chunk-BGYQAVKQ.cjs');
+
+// src/build.ts
+var _node = require('@humanfs/node');
+var _devkit = require('@nx/devkit');
+var _chokidar = require('chokidar');
+var _defu = require('defu'); var _defu2 = _interopRequireDefault(_defu);
+var _estoolkit = require('es-toolkit');
+var _compat = require('es-toolkit/compat');
+var _esbuild = require('esbuild'); var esbuild = _interopRequireWildcard(_esbuild);
+var _globby = require('globby');
+var _findworkspaceroot = require('nx/src/utils/find-workspace-root');
+
+// src/base/renderer-engine.ts
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+var _sourcemap = require('source-map');
+
+// src/utilities/output-file.ts
+var _fs = require('fs'); var _fs2 = _interopRequireDefault(_fs);
+
+var outputFile = /* @__PURE__ */ _chunkBGYQAVKQcjs.__name.call(void 0, async (filepath, data, options) => {
+  await _fs2.default.promises.mkdir(_path2.default.dirname(filepath), {
+    recursive: true
+  });
+  await _fs2.default.promises.writeFile(filepath, data, options);
+}, "outputFile");
+
+// src/base/renderer-engine.ts
+var parseSourceMap = /* @__PURE__ */ _chunkBGYQAVKQcjs.__name.call(void 0, (map2) => {
+  return typeof map2 === "string" ? JSON.parse(map2) : map2;
+}, "parseSourceMap");
+var isJS = /* @__PURE__ */ _chunkBGYQAVKQcjs.__name.call(void 0, (path3) => /\.(js|mjs|cjs)$/.test(path3), "isJS");
+var isCSS = /* @__PURE__ */ _chunkBGYQAVKQcjs.__name.call(void 0, (path3) => /\.css$/.test(path3), "isCSS");
+var getSourcemapComment = /* @__PURE__ */ _chunkBGYQAVKQcjs.__name.call(void 0, (inline, map2, filepath, isCssFile) => {
+  if (!map2) return "";
+  const prefix = isCssFile ? "/*" : "//";
+  const suffix = isCssFile ? " */" : "";
+  const url = inline ? `data:application/json;base64,${Buffer.from(typeof map2 === "string" ? map2 : JSON.stringify(map2)).toString("base64")}` : `${_path2.default.basename(filepath)}.map`;
+  return `${prefix}# sourceMappingURL=${url}${suffix}`;
+}, "getSourcemapComment");
+var RendererEngine = class {
+  static {
+    _chunkBGYQAVKQcjs.__name.call(void 0, this, "RendererEngine");
+  }
+  #renderers;
+  #options;
+  constructor(renderers) {
+    this.#renderers = renderers;
+  }
+  setOptions(options) {
+    this.#options = options;
+  }
+  getOptions() {
+    if (!this.#options) {
+      throw new Error(`Renderer options is not set`);
+    }
+    return this.#options;
+  }
+  modifyEsbuildOptions(options) {
+    for (const renderer of this.#renderers) {
+      if (renderer.esbuildOptions) {
+        renderer.esbuildOptions.call(this.getOptions(), options);
+      }
+    }
+  }
+  async buildStarted() {
+    for (const renderer of this.#renderers) {
+      if (renderer.buildStart) {
+        await renderer.buildStart.call(this.getOptions());
+      }
+    }
+  }
+  async buildFinished({ outputFiles, metafile }) {
+    const files = outputFiles.filter((file) => !file.path.endsWith(".map")).map((file) => {
+      if (isJS(file.path) || isCSS(file.path)) {
+        let relativePath = _path2.default.relative(this.getOptions().config.workspaceRoot, file.path);
+        if (!relativePath.startsWith("\\\\?\\")) {
+          relativePath = relativePath.replace(/\\/g, "/");
+        }
+        const meta = _optionalChain([metafile, 'optionalAccess', _2 => _2.outputs, 'access', _3 => _3[relativePath]]);
+        return {
+          type: "chunk",
+          path: file.path,
+          code: file.text,
+          map: _optionalChain([outputFiles, 'access', _4 => _4.find, 'call', _5 => _5((f) => f.path === `${file.path}.map`), 'optionalAccess', _6 => _6.text]),
+          entryPoint: _optionalChain([meta, 'optionalAccess', _7 => _7.entryPoint]),
+          exports: _optionalChain([meta, 'optionalAccess', _8 => _8.exports]),
+          imports: _optionalChain([meta, 'optionalAccess', _9 => _9.imports])
+        };
+      } else {
+        return {
+          type: "asset",
+          path: file.path,
+          contents: file.contents
+        };
+      }
+    });
+    const writtenFiles = [];
+    await Promise.all(files.map(async (info) => {
+      for (const renderer of this.#renderers) {
+        if (info.type === "chunk" && renderer.renderChunk) {
+          const result = await renderer.renderChunk.call(this.getOptions(), info.code, info);
+          if (result) {
+            info.code = result.code;
+            if (result.map) {
+              const originalConsumer = await new (0, _sourcemap.SourceMapConsumer)(parseSourceMap(info.map));
+              const newConsumer = await new (0, _sourcemap.SourceMapConsumer)(parseSourceMap(result.map));
+              const generator = _sourcemap.SourceMapGenerator.fromSourceMap(newConsumer);
+              generator.applySourceMap(originalConsumer, info.path);
+              info.map = generator.toJSON();
+              originalConsumer.destroy();
+              newConsumer.destroy();
+            }
+          }
+        }
+      }
+      const inlineSourceMap = this.#options.sourcemap === "inline";
+      const contents = info.type === "chunk" ? info.code + getSourcemapComment(inlineSourceMap, info.map, info.path, isCSS(info.path)) : info.contents;
+      await outputFile(info.path, contents, {
+        mode: info.type === "chunk" ? info.mode : void 0
+      });
+      writtenFiles.push({
+        get name() {
+          return _path2.default.relative(process.cwd(), info.path);
+        },
+        get size() {
+          return contents.length;
+        }
+      });
+      if (info.type === "chunk" && info.map && !inlineSourceMap) {
+        const map2 = typeof info.map === "string" ? JSON.parse(info.map) : info.map;
+        const outPath = `${info.path}.map`;
+        const contents2 = JSON.stringify(map2);
+        await outputFile(outPath, contents2);
+        writtenFiles.push({
+          get name() {
+            return _path2.default.relative(process.cwd(), outPath);
+          },
+          get size() {
+            return contents2.length;
+          }
+        });
+      }
+    }));
+    for (const renderer of this.#renderers) {
+      if (renderer.buildEnd) {
+        await renderer.buildEnd.call(this.getOptions(), {
+          writtenFiles
+        });
+      }
+    }
+  }
+};
+
+// src/renderers/shebang.ts
+var shebangRenderer = {
+  name: "shebang",
+  renderChunk(_, __, info) {
+    if (info.type === "chunk" && /\.(cjs|js|mjs)$/.test(info.path) && info.code.startsWith("#!")) {
+      info.mode = 493;
+    }
+  }
+};
+
+// src/utilities/helpers.ts
+function handleSync(fn) {
+  try {
+    return fn();
+  } catch (error_) {
+    return error_;
+  }
+}
+_chunkBGYQAVKQcjs.__name.call(void 0, handleSync, "handleSync");
+async function handleAsync(fn) {
+  try {
+    return await fn();
+  } catch (error_) {
+    return error_;
+  }
+}
+_chunkBGYQAVKQcjs.__name.call(void 0, handleAsync, "handleAsync");
+var handle = handleSync;
+handle.async = handleAsync;
+var skip = Symbol("skip");
+function transduceSync(list, transformer) {
+  const transduced = [];
+  for (const [i, element_] of list.entries()) {
+    const transformed = transformer(element_, i);
+    if (transformed !== skip) {
+      transduced[transduced.length] = transformed;
+    }
+  }
+  return transduced;
+}
+_chunkBGYQAVKQcjs.__name.call(void 0, transduceSync, "transduceSync");
+async function transduceAsync(list, transformer) {
+  const transduced = [];
+  await Promise.all(list.entries().map(async ([i, element_]) => {
+    const transformed = await transformer(element_, i);
+    if (transformed !== skip) {
+      transduced[transduced.length] = transformed;
+    }
+  }));
+  return transduced;
+}
+_chunkBGYQAVKQcjs.__name.call(void 0, transduceAsync, "transduceAsync");
+var Filter = /* @__PURE__ */ _chunkBGYQAVKQcjs.__name.call(void 0, (filter) => (item) => {
+  return filter(item) ? item : skip;
+}, "Filter");
+var Mapper = /* @__PURE__ */ _chunkBGYQAVKQcjs.__name.call(void 0, (mapper) => (item) => {
+  return mapper(item);
+}, "Mapper");
+var transduce = transduceSync;
+transduce.async = transduceAsync;
+function pipeSync(fn, ...fns) {
+  return (...args) => {
+    let result = fn(...args);
+    for (let i = 0; result !== skip && i < fns.length; ++i) {
+      result = _optionalChain([fns, 'access', _10 => _10[i], 'optionalCall', _11 => _11(result)]);
+    }
+    return result;
+  };
+}
+_chunkBGYQAVKQcjs.__name.call(void 0, pipeSync, "pipeSync");
+function pipeAsync(fn, ...fns) {
+  return async (...args) => {
+    let result = await fn(...args);
+    for (let i = 0; result !== skip && i < fns.length; ++i) {
+      result = await _optionalChain([fns, 'access', _12 => _12[i], 'optionalCall', _13 => _13(result)]);
+    }
+    return result;
+  };
+}
+_chunkBGYQAVKQcjs.__name.call(void 0, pipeAsync, "pipeAsync");
+var pipe = pipeSync;
+pipe.async = pipeAsync;
+
+// src/build.ts
+var resolveOptions = /* @__PURE__ */ _chunkBGYQAVKQcjs.__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 _chunk5I2MGPRNcjs.loadStormConfig.call(void 0, workspaceRoot.dir);
+  _chunkVBINBV4Zcjs.writeDebug.call(void 0, "  \u2699\uFE0F   Resolving build options", config);
+  const stopwatch = _chunkVBINBV4Zcjs.getStopwatch.call(void 0, "Build options resolution");
+  const projectGraph = await _devkit.createProjectGraphAsync.call(void 0, {
+    exitOnError: true
+  });
+  const projectJsonPath = _chunkLVWQSCJMcjs.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', _14 => _14.projects, 'optionalAccess', _15 => _15[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, _chunk5I2MGPRNcjs.DEFAULT_BUILD_OPTIONS);
+  options.name ??= `${projectName}-${options.format}`;
+  options.target ??= _chunk5I2MGPRNcjs.DEFAULT_TARGET;
+  const packageJsonPath = _chunkLVWQSCJMcjs.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 packageJson = await _node.hfs.json(packageJsonPath);
+  const outExtension = _chunk5I2MGPRNcjs.getOutputExtensionMap.call(void 0, options, packageJson.type);
+  const env = _chunk5I2MGPRNcjs.getEnv.call(void 0, "esbuild", options);
+  const result = {
+    ...options,
+    config,
+    mainFields: options.platform === "node" ? [
+      "module",
+      "main"
+    ] : [
+      "browser",
+      "module",
+      "main"
+    ],
+    resolveExtensions: [
+      ".ts",
+      ".js",
+      ".node"
+    ],
+    ...userOptions,
+    tsconfig: _chunkLVWQSCJMcjs.joinPaths.call(void 0, projectRoot, userOptions.tsconfig ? userOptions.tsconfig.replace(projectRoot, "") : "tsconfig.json"),
+    format: options.format || "cjs",
+    entryPoints: await _chunk5I2MGPRNcjs.getEntryPoints.call(void 0, config, projectRoot, projectJson.sourceRoot, userOptions.entry || [
+      "./src/index.ts"
+    ], userOptions.emitOnAll),
+    outdir: userOptions.outputPath || _chunkLVWQSCJMcjs.joinPaths.call(void 0, "dist", projectRoot),
+    plugins: [],
+    name: userOptions.name || projectName,
+    projectConfigurations,
+    projectName,
+    projectGraph,
+    sourceRoot: userOptions.sourceRoot || projectJson.sourceRoot || _chunkLVWQSCJMcjs.joinPaths.call(void 0, projectRoot, "src"),
+    minify: userOptions.minify || !userOptions.debug,
+    verbose: userOptions.verbose || _chunkVBINBV4Zcjs.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,
+    assets: _nullishCoalesce(userOptions.assets, () => ( [])),
+    injectShims: userOptions.injectShims !== true,
+    bundle: userOptions.bundle !== false,
+    keepNames: true,
+    watch: userOptions.watch === true,
+    outExtension,
+    footer: userOptions.footer,
+    banner: {
+      js: options.banner || _chunk5I2MGPRNcjs.DEFAULT_COMPILED_BANNER,
+      css: options.banner || _chunk5I2MGPRNcjs.DEFAULT_COMPILED_BANNER
+    },
+    splitting: options.format === "iife" ? false : typeof options.splitting === "boolean" ? options.splitting : options.format === "esm",
+    treeShaking: options.format === "esm",
+    env,
+    define: {
+      STORM_FORMAT: JSON.stringify(options.format || "cjs"),
+      ...options.format === "cjs" && options.injectShims ? {
+        "import.meta.url": "importMetaUrl"
+      } : {},
+      ...options.define,
+      ...Object.keys(env || {}).reduce((res, key) => {
+        const value = JSON.stringify(env[key]);
+        return {
+          ...res,
+          [`process.env.${key}`]: value,
+          [`import.meta.env.${key}`]: value
+        };
+      }, {})
+    },
+    inject: [
+      options.format === "cjs" && options.injectShims ? _chunkLVWQSCJMcjs.joinPaths.call(void 0, __dirname, "../assets/cjs_shims.js") : "",
+      options.format === "esm" && options.injectShims && options.platform === "node" ? _chunkLVWQSCJMcjs.joinPaths.call(void 0, __dirname, "../assets/esm_shims.js") : "",
+      ..._nullishCoalesce(options.inject, () => ( []))
+    ].filter(Boolean)
+  };
+  result.plugins = _nullishCoalesce(userOptions.plugins, () => ( _chunk5I2MGPRNcjs.getDefaultBuildPlugins.call(void 0, userOptions, result)));
+  stopwatch();
+  return result;
+}, "resolveOptions");
+async function generatePackageJson(context2) {
+  if (context2.options.generatePackageJson !== false && await _node.hfs.isFile(_chunkLVWQSCJMcjs.joinPaths.call(void 0, context2.options.projectRoot, "package.json"))) {
+    _chunkVBINBV4Zcjs.writeDebug.call(void 0, "  \u270D\uFE0F   Writing package.json file", context2.options.config);
+    const stopwatch = _chunkVBINBV4Zcjs.getStopwatch.call(void 0, "Write package.json file");
+    const packageJsonPath = _chunkLVWQSCJMcjs.joinPaths.call(void 0, context2.options.projectRoot, "project.json");
+    if (!await _node.hfs.isFile(packageJsonPath)) {
+      throw new Error("Cannot find package.json configuration");
+    }
+    let packageJson = await _node.hfs.json(_chunkLVWQSCJMcjs.joinPaths.call(void 0, context2.options.config.workspaceRoot, context2.options.projectRoot, "package.json"));
+    if (!packageJson) {
+      throw new Error("Cannot find package.json configuration file");
+    }
+    packageJson = await _chunk5I2MGPRNcjs.addPackageDependencies.call(void 0, context2.options.config.workspaceRoot, context2.options.projectRoot, context2.options.projectName, packageJson);
+    packageJson = await _chunk5I2MGPRNcjs.addWorkspacePackageJsonFields.call(void 0, context2.options.config, context2.options.projectRoot, context2.options.sourceRoot, context2.options.projectName, false, packageJson);
+    packageJson.exports ??= {};
+    packageJson.exports["./package.json"] ??= "./package.json";
+    packageJson.exports["."] ??= _chunk5I2MGPRNcjs.addPackageJsonExport.call(void 0, "index", packageJson.type, context2.options.sourceRoot);
+    let entryPoints = [
+      {
+        in: "./src/index.ts",
+        out: "./src/index.ts"
+      }
+    ];
+    if (context2.options.entryPoints) {
+      if (Array.isArray(context2.options.entryPoints)) {
+        entryPoints = context2.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}`] ??= _chunk5I2MGPRNcjs.addPackageJsonExport.call(void 0, entry, packageJson.type, context2.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, _chunkLVWQSCJMcjs.joinPaths.call(void 0, context2.options.outdir, "package.json"), packageJson);
+    stopwatch();
+  }
+  return context2;
+}
+_chunkBGYQAVKQcjs.__name.call(void 0, generatePackageJson, "generatePackageJson");
+async function createOptions(options) {
+  return _estoolkit.flatten.call(void 0, await Promise.all(_compat.map.call(void 0, options, (opt) => [
+    // we defer it so that we don't trigger glob immediately
+    () => resolveOptions(opt)
+  ])));
+}
+_chunkBGYQAVKQcjs.__name.call(void 0, createOptions, "createOptions");
+async function generateContext(getOptions) {
+  const options = await getOptions();
+  const rendererEngine = new RendererEngine([
+    shebangRenderer,
+    ...options.renderers || []
+  ]);
+  return {
+    options,
+    rendererEngine
+  };
+}
+_chunkBGYQAVKQcjs.__name.call(void 0, generateContext, "generateContext");
+async function executeEsBuild(context2) {
+  _chunkVBINBV4Zcjs.writeDebug.call(void 0, `  \u{1F680}  Running ${context2.options.name} build`, context2.options.config);
+  const stopwatch = _chunkVBINBV4Zcjs.getStopwatch.call(void 0, `${context2.options.name} build`);
+  if (process.env.WATCH === "true") {
+    const ctx = await esbuild.context(context2.options);
+    watch(ctx, context2.options);
+  }
+  const result = await esbuild.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));
+  }
+  stopwatch();
+  return context2;
+}
+_chunkBGYQAVKQcjs.__name.call(void 0, executeEsBuild, "executeEsBuild");
+async function copyBuildAssets(context2) {
+  if (_optionalChain([context2, 'access', _16 => _16.result, 'optionalAccess', _17 => _17.errors, 'access', _18 => _18.length]) === 0) {
+    _chunkVBINBV4Zcjs.writeDebug.call(void 0, `  \u{1F4CB}  Copying asset files to output directory: ${context2.options.outdir}`, context2.options.config);
+    const stopwatch = _chunkVBINBV4Zcjs.getStopwatch.call(void 0, `${context2.options.name} asset copy`);
+    await _chunk5I2MGPRNcjs.copyAssets.call(void 0, context2.options.config, _nullishCoalesce(context2.options.assets, () => ( [])), context2.options.outdir, context2.options.projectRoot, context2.options.projectName, context2.options.sourceRoot, true, false);
+    stopwatch();
+  }
+  return context2;
+}
+_chunkBGYQAVKQcjs.__name.call(void 0, copyBuildAssets, "copyBuildAssets");
+async function reportResults(context2) {
+  if (_optionalChain([context2, 'access', _19 => _19.result, 'optionalAccess', _20 => _20.errors, 'access', _21 => _21.length]) === 0) {
+    if (context2.result.warnings.length > 0) {
+      _chunkVBINBV4Zcjs.writeWarning.call(void 0, `  \u{1F6A7}  The following warnings occurred during the build: ${context2.result.warnings.map((warning) => warning.text).join("\n")}`, context2.options.config);
+    }
+    _chunkVBINBV4Zcjs.writeSuccess.call(void 0, `  \u{1F4E6}  The ${context2.options.name} build completed successfully`, context2.options.config);
+  }
+}
+_chunkBGYQAVKQcjs.__name.call(void 0, reportResults, "reportResults");
+async function dependencyCheck(options) {
+  if (process.env.DEV === "true") {
+    return void 0;
+  }
+  if (process.env.CI && !process.env.BUILDKITE) {
+    return void 0;
+  }
+  const buildPromise = esbuild.build({
+    entryPoints: _globby.globbySync.call(void 0, "**/*.{j,t}s", {
+      // We don't check dependencies in ecosystem tests because tests are isolated from the build.
+      ignore: [
+        "./src/__tests__/**/*",
+        "./tests/e2e/**/*",
+        "./dist/**/*"
+      ],
+      gitignore: true
+    }),
+    logLevel: "silent",
+    bundle: true,
+    write: false,
+    outdir: "out",
+    plugins: [
+      _chunkVZBOWHCMcjs.depsCheckPlugin.call(void 0, options.bundle)
+    ]
+  });
+  await buildPromise.catch(() => {
+  });
+  return void 0;
+}
+_chunkBGYQAVKQcjs.__name.call(void 0, dependencyCheck, "dependencyCheck");
+async function cleanOutputPath(context2) {
+  if (context2.options.clean !== false && context2.options.outdir) {
+    await _chunkTP5EOMRDcjs.clean.call(void 0, context2.options.name, context2.options.outdir, context2.options.config);
+  }
+  return context2;
+}
+_chunkBGYQAVKQcjs.__name.call(void 0, cleanOutputPath, "cleanOutputPath");
+async function build2(options) {
+  _chunkVBINBV4Zcjs.writeDebug.call(void 0, `  \u26A1   Executing Storm ESBuild pipeline`);
+  const stopwatch = _chunkVBINBV4Zcjs.getStopwatch.call(void 0, "ESBuild pipeline");
+  try {
+    const opts = Array.isArray(options) ? options : [
+      options
+    ];
+    if (opts.length === 0) {
+      throw new Error("No build options were provided");
+    }
+    void transduce.async(opts, dependencyCheck);
+    await transduce.async(await createOptions(opts), pipe.async(generateContext, cleanOutputPath, generatePackageJson, executeEsBuild, copyBuildAssets, reportResults));
+    _chunkVBINBV4Zcjs.writeSuccess.call(void 0, "  \u{1F3C1}  ESBuild pipeline build completed successfully");
+  } catch (error) {
+    _chunkVBINBV4Zcjs.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();
+  }
+}
+_chunkBGYQAVKQcjs.__name.call(void 0, build2, "build");
+var watch = /* @__PURE__ */ _chunkBGYQAVKQcjs.__name.call(void 0, (context2, options) => {
+  if (!options.watch) {
+    return context2;
+  }
+  const config = {
+    ignoreInitial: true,
+    useFsEvents: true,
+    ignored: [
+      "./src/__tests__/**/*",
+      "./package.json"
+    ]
+  };
+  const changeWatcher = _chokidar.watch.call(void 0, [
+    "./src/**/*"
+  ], config);
+  const fastRebuild = _estoolkit.debounce.call(void 0, async () => {
+    const timeBefore = Date.now();
+    const rebuildResult = await handle.async(() => {
+      return context2.rebuild();
+    });
+    if (rebuildResult instanceof Error) {
+      _chunkVBINBV4Zcjs.writeError.call(void 0, rebuildResult.message);
+    }
+    _chunkVBINBV4Zcjs.writeTrace.call(void 0, `${Date.now() - timeBefore}ms [${_nullishCoalesce(options.name, () => ( ""))}]`);
+  }, 10);
+  changeWatcher.on("change", fastRebuild);
+  return void 0;
+}, "watch");
+
+
+
+
+
+
+
+
+
+exports.handle = handle; exports.skip = skip; exports.Filter = Filter; exports.Mapper = Mapper; exports.transduce = transduce; exports.pipe = pipe; exports.build = build2;

package/dist/{chunk-437F3SFI.js → chunk-YNQ45EAM.js}

@@ -1,13 +1,17 @@
+import {
+  __name
+} from "./chunk-3GQAWCBQ.js";
+
 // src/plugins/esm-split-code-to-cjs.ts
 import * as esbuild from "esbuild";
-var esmSplitCodeToCjsPlugin = {
+var esmSplitCodeToCjsPlugin = /* @__PURE__ */ __name((options, resolvedOptions) => ({
   name: "storm:esm-split-code-to-cjs",
   setup(build2) {
     build2.onEnd(async (result) => {
       const outFiles = Object.keys(result.metafile?.outputs ?? {});
       const jsFiles = outFiles.filter((f) => f.endsWith("js"));
       await esbuild.build({
-        outdir: build2.initialOptions.outdir,
+        outdir: resolvedOptions.outdir,
         entryPoints: jsFiles,
         allowOverwrite: true,
         format: "cjs",
@@ -16,9 +20,8 @@ var esmSplitCodeToCjsPlugin = {
       });
     });
   }
-};
+}), "esmSplitCodeToCjsPlugin");
 
 export {
   esmSplitCodeToCjsPlugin
 };
-//# sourceMappingURL=chunk-437F3SFI.js.map