@storm-software/esbuild 0.0.1 → 0.1.0

package/README.md

@@ -40,9 +40,10 @@ This package is part of the <b>⚡Storm-Ops</b> monorepo. The Storm-Ops packages
 
 <!-- START doctoc -->
 <!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
+
 ## Table of Contents
 
-- [Storm Prettier Package](#storm-prettier-package)
+- [Storm ESBuild Package](#storm-esbuild-package)
   - [Installing](#installing)
   - [Building](#building)
   - [Running unit tests](#running-unit-tests)
@@ -63,23 +64,23 @@ This package is part of the <b>⚡Storm-Ops</b> monorepo. The Storm-Ops packages
 
 <!-- END header -->
 
-# Storm Prettier Package
+# Storm ESBuild Package
 
-This package contains the Prettier configuration for Storm Software projects.
+This package contains the ESBuild configuration for Storm Software projects.
 
 ## Installing
 
 Using [pnpm](http://pnpm.io):
 
 ```bash
-pnpm add -D @storm-software/prettier
+pnpm add -D @storm-software/esbuild
 ```
 
 <details>
   <summary>Using npm</summary>
 
 ```bash
-npm install -D @storm-software/prettier
+npm install -D @storm-software/esbuild
 ```
 
 </details>
@@ -88,18 +89,18 @@ npm install -D @storm-software/prettier
   <summary>Using yarn</summary>
 
 ```bash
-yarn add -D @storm-software/prettier
+yarn add -D @storm-software/esbuild
 ```
 
 </details>
 
 ## Building
 
-Run `nx build prettier` to build the library.
+Run `nx build esbuild` to build the library.
 
 ## Running unit tests
 
-Run `nx test prettier` to execute the unit tests via [Jest](https://jestjs.io).
+Run `nx test esbuild` to execute the unit tests via [Jest](https://jestjs.io).
 
 <!-- START footer -->
 <!-- prettier-ignore-start -->

package/dist/build.cjs

@@ -0,0 +1,14 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunk5S2XTAF2cjs = require('./chunk-5S2XTAF2.cjs');
+require('./chunk-DCWECOOS.cjs');
+require('./chunk-WLHWKRZB.cjs');
+require('./chunk-A6CGWMV7.cjs');
+require('./chunk-NVGEXPTG.cjs');
+require('./chunk-MTKAAECG.cjs');
+require('./chunk-RJQ3LCGJ.cjs');
+require('./chunk-3C3PXJUM.cjs');
+require('./chunk-BGYQAVKQ.cjs');
+
+
+exports.build = _chunk5S2XTAF2cjs.build;

package/dist/build.d.cts

@@ -0,0 +1,14 @@
+import * as esbuild from 'esbuild';
+import { ESBuildOptions, ESBuildResolvedOptions } from './types.cjs';
+import '@nx/devkit';
+import 'nx/src/utils/find-workspace-root';
+
+/**
+ * Execution pipeline that applies a set of actions
+ *
+ * @param options - the build options
+ * @returns the build result
+ */
+declare function build(options: ESBuildOptions[]): Promise<(readonly [ESBuildResolvedOptions, esbuild.BuildResult<any>])[]>;
+
+export { build };

package/dist/build.d.ts

@@ -0,0 +1,14 @@
+import * as esbuild from 'esbuild';
+import { ESBuildOptions, ESBuildResolvedOptions } from './types.js';
+import '@nx/devkit';
+import 'nx/src/utils/find-workspace-root';
+
+/**
+ * Execution pipeline that applies a set of actions
+ *
+ * @param options - the build options
+ * @returns the build result
+ */
+declare function build(options: ESBuildOptions[]): Promise<(readonly [ESBuildResolvedOptions, esbuild.BuildResult<any>])[]>;
+
+export { build };

package/dist/build.js

@@ -0,0 +1,14 @@
+import {
+  build
+} from "./chunk-YGD5JBOH.js";
+import "./chunk-RKSGVSXZ.js";
+import "./chunk-4TW4ZA3I.js";
+import "./chunk-5JHKW6MG.js";
+import "./chunk-ELGZJRET.js";
+import "./chunk-PCGRI6Z6.js";
+import "./chunk-YIAZ64WG.js";
+import "./chunk-LVDPGHWK.js";
+import "./chunk-3GQAWCBQ.js";
+export {
+  build
+};

package/dist/chunk-3C3PXJUM.cjs

@@ -0,0 +1,28 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkBGYQAVKQcjs = require('./chunk-BGYQAVKQ.cjs');
+
+// src/plugins/fix-imports.ts
+var fixImportsPlugin = {
+  name: "storm:fix-imports",
+  setup(build) {
+    build.onResolve({
+      filter: /^spdx-exceptions/
+    }, () => {
+      return {
+        path: _chunkBGYQAVKQcjs.__require.resolve("spdx-exceptions")
+      };
+    });
+    build.onResolve({
+      filter: /^spdx-license-ids/
+    }, () => {
+      return {
+        path: _chunkBGYQAVKQcjs.__require.resolve("spdx-license-ids")
+      };
+    });
+  }
+};
+
+
+
+exports.fixImportsPlugin = fixImportsPlugin;

package/dist/chunk-3GQAWCBQ.js

@@ -0,0 +1,13 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+export {
+  __name,
+  __require
+};

package/dist/chunk-4TW4ZA3I.js

@@ -0,0 +1,52 @@
+import {
+  __name,
+  __require
+} from "./chunk-3GQAWCBQ.js";
+
+// src/plugins/resolve-paths.ts
+import path from "node:path";
+function resolvePathsConfig(options, cwd) {
+  if (options?.compilerOptions?.paths) {
+    const paths = Object.entries(options.compilerOptions.paths);
+    const resolvedPaths = paths.map(([key, paths2]) => {
+      return [
+        key,
+        paths2.map((v) => path.resolve(cwd, v))
+      ];
+    });
+    return Object.fromEntries(resolvedPaths);
+  }
+  if (options.extends) {
+    const extendsPath = path.resolve(cwd, options.extends);
+    const extendsDir = path.dirname(extendsPath);
+    const extendsConfig = __require(extendsPath);
+    return resolvePathsConfig(extendsConfig, extendsDir);
+  }
+  return [];
+}
+__name(resolvePathsConfig, "resolvePathsConfig");
+var resolvePathsPlugin = {
+  name: "storm:resolve-paths",
+  setup(build) {
+    const parentTsConfig = __require(`${process.cwd()}/${build.initialOptions.tsconfig}`);
+    const resolvedTsPaths = resolvePathsConfig(parentTsConfig, process.cwd());
+    const packagesRegex = new RegExp(`^(${Object.keys(resolvedTsPaths).join("|")})$`);
+    build.onResolve({
+      filter: packagesRegex
+    }, (args) => {
+      if (build.initialOptions.external?.includes(args.path)) {
+        return {
+          path: args.path,
+          external: true
+        };
+      }
+      return {
+        path: `${resolvedTsPaths[args.path][0]}/index.ts`
+      };
+    });
+  }
+};
+
+export {
+  resolvePathsPlugin
+};

package/dist/chunk-5JHKW6MG.js

@@ -0,0 +1,126 @@
+import {
+  writeLog
+} from "./chunk-YIAZ64WG.js";
+import {
+  __name,
+  __require
+} from "./chunk-3GQAWCBQ.js";
+
+// src/plugins/tsc.ts
+import { hfs } from "@humanfs/node";
+import { Extractor, ExtractorConfig } from "@microsoft/api-extractor";
+import path from "node:path";
+
+// src/utilities/run.ts
+import { execaCommand } from "execa";
+function run(command) {
+  return execaCommand(command, {
+    preferLocal: true,
+    shell: true,
+    stdio: "inherit"
+  });
+}
+__name(run, "run");
+
+// src/plugins/tsc.ts
+function bundleTypeDefinitions(filename, outfile, externals) {
+  const { dependencies, peerDependencies, devDependencies } = __require(`${process.cwd()}/package.json`);
+  const dependenciesKeys = Object.keys(dependencies ?? {}).flatMap((p) => [
+    p,
+    getTypeDependencyPackageName(p)
+  ]);
+  const peerDependenciesKeys = Object.keys(peerDependencies ?? {}).flatMap((p) => [
+    p,
+    getTypeDependencyPackageName(p)
+  ]);
+  const devDependenciesKeys = Object.keys(devDependencies ?? {}).flatMap((p) => [
+    p,
+    getTypeDependencyPackageName(p)
+  ]);
+  const includeDeps = devDependenciesKeys;
+  const excludeDeps = /* @__PURE__ */ new Set([
+    ...dependenciesKeys,
+    ...peerDependenciesKeys,
+    ...externals
+  ]);
+  const bundledPackages = includeDeps.filter((dep) => !excludeDeps.has(dep));
+  const extractorConfig = ExtractorConfig.prepare({
+    configObject: {
+      projectFolder: process.cwd(),
+      mainEntryPointFilePath: filename,
+      bundledPackages,
+      compiler: {
+        tsconfigFilePath: path.join(process.cwd(), "tsconfig.build.json"),
+        overrideTsconfig: {
+          compilerOptions: {
+            paths: {}
+            // bug with api extract + paths
+          }
+        }
+      },
+      dtsRollup: {
+        enabled: true,
+        untrimmedFilePath: path.join(process.cwd(), `${outfile}.d.ts`)
+      },
+      tsdocMetadata: {
+        enabled: false
+      }
+    },
+    packageJsonFullPath: path.join(process.cwd(), "package.json"),
+    configObjectFullPath: void 0
+  });
+  const extractorResult = Extractor.invoke(extractorConfig, {
+    showVerboseMessages: true,
+    localBuild: true
+  });
+  if (extractorResult.succeeded === false) {
+    writeLog("error", `API Extractor completed with ${extractorResult.errorCount} ${extractorResult.errorCount === 1 ? "error" : "errors"}`);
+    throw new Error("API Extractor completed with errors");
+  }
+}
+__name(bundleTypeDefinitions, "bundleTypeDefinitions");
+var tscPlugin = /* @__PURE__ */ __name((emitTypes) => ({
+  name: "tscPlugin",
+  setup(build) {
+    const options = build.initialOptions;
+    if (emitTypes === false) return;
+    build.onStart(async () => {
+      if (process.env.WATCH !== "true" && process.env.DEV !== "true") {
+        await run(`tsc --project ${options.tsconfig} --paths null`);
+      }
+      if (options.bundle && options.outfile && options.entryPoints?.[0].endsWith(".ts")) {
+        const tsconfig = __require(`${process.cwd()}/${options.tsconfig}`);
+        const typeOutDir = tsconfig?.compilerOptions?.outDir ?? ".";
+        const entryPoint = options.entryPoints?.[0].replace(/\.ts$/, "");
+        const bundlePath = options.outfile.replace(/\.m?js$/, "");
+        let dtsPath;
+        if (await hfs.isFile(`${process.cwd()}/${typeOutDir}/${entryPoint}.d.ts`)) {
+          dtsPath = `${process.cwd()}/${typeOutDir}/${entryPoint}.d.ts`;
+        } else if (await hfs.isFile(`${process.cwd()}/${typeOutDir}/${entryPoint.replace(/^src\//, "")}.d.ts`)) {
+          dtsPath = `${process.cwd()}/${typeOutDir}/${entryPoint.replace(/^src\//, "")}.d.ts`;
+        }
+        const ext = options.format === "esm" ? "d.mts" : "d.ts";
+        if (process.env.WATCH !== "true" && process.env.DEV !== "true") {
+          bundleTypeDefinitions(dtsPath, bundlePath, options.external ?? []);
+          const dtsContents = await hfs.text(`${bundlePath}.d.ts`);
+          await hfs.write(`${bundlePath}.${ext}`, dtsContents);
+        } else {
+          await hfs.write(`${bundlePath}.${ext}`, `export * from '${process.cwd()}/${entryPoint}'`);
+        }
+      }
+    });
+  }
+}), "tscPlugin");
+function getTypeDependencyPackageName(npmPackage) {
+  if (npmPackage.startsWith("@")) {
+    const [scope, name] = npmPackage.split("/");
+    return `@types/${scope?.slice(1)}__${name}`;
+  }
+  return `@types/${npmPackage}`;
+}
+__name(getTypeDependencyPackageName, "getTypeDependencyPackageName");
+
+export {
+  run,
+  tscPlugin
+};

package/dist/chunk-5S2XTAF2.cjs

@@ -0,0 +1,337 @@
+"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 _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 _chunkDCWECOOScjs = require('./chunk-DCWECOOS.cjs');
+
+
+var _chunkWLHWKRZBcjs = require('./chunk-WLHWKRZB.cjs');
+
+
+var _chunkA6CGWMV7cjs = require('./chunk-A6CGWMV7.cjs');
+
+
+var _chunkNVGEXPTGcjs = require('./chunk-NVGEXPTG.cjs');
+
+
+var _chunkMTKAAECGcjs = require('./chunk-MTKAAECG.cjs');
+
+
+var _chunkRJQ3LCGJcjs = require('./chunk-RJQ3LCGJ.cjs');
+
+
+var _chunk3C3PXJUMcjs = require('./chunk-3C3PXJUM.cjs');
+
+
+var _chunkBGYQAVKQcjs = require('./chunk-BGYQAVKQ.cjs');
+
+// src/build.ts
+var _node = require('@humanfs/node');
+var _devkit = require('@nx/devkit');
+var _buildablelibsutils = require('@nx/js/src/utils/buildable-libs-utils');
+var _chokidar = require('chokidar');
+var _estoolkit = require('es-toolkit');
+var _compat = require('es-toolkit/compat');
+var _esbuild = require('esbuild'); var esbuild = _interopRequireWildcard(_esbuild);
+var _globby = require('globby');
+var _fs = require('fs');
+var _findworkspaceroot = require('nx/src/utils/find-workspace-root');
+
+// 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', _ => _[i], 'optionalCall', _2 => _2(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', _3 => _3[i], 'optionalCall', _4 => _4(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 (options) => {
+  const projectRoot = options.projectRoot;
+  const workspaceRoot = _findworkspaceroot.findWorkspaceRoot.call(void 0, projectRoot);
+  if (!workspaceRoot) {
+    throw new Error("Cannot find Nx workspace root");
+  }
+  const nxJsonPath = _devkit.joinPathFragments.call(void 0, workspaceRoot.dir, "nx.json");
+  if (!await _node.hfs.isFile(nxJsonPath)) {
+    throw new Error("Cannot find Nx workspace configuration");
+  }
+  const projectGraph = await _devkit.createProjectGraphAsync.call(void 0, {
+    exitOnError: true
+  });
+  const projectJsonPath = _devkit.joinPathFragments.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', _5 => _5.projects, 'optionalAccess', _6 => _6[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.");
+  }
+  return {
+    ..._chunkNVGEXPTGcjs.DEFAULT_BUILD_OPTIONS,
+    format: "cjs",
+    outExtension: {
+      ".js": ".js"
+    },
+    resolveExtensions: [
+      ".ts",
+      ".js",
+      ".node"
+    ],
+    entryPoints: _globby.globbySync.call(void 0, "./src/**/*.{j,t}s", {
+      ignore: [
+        "./src/__tests__/**/*"
+      ]
+    }),
+    mainFields: [
+      "module",
+      "main"
+    ],
+    ...options,
+    outdir: options.outdir || _devkit.joinPathFragments.call(void 0, workspaceRoot.dir, "dist", projectRoot),
+    plugins: [
+      ..._nullishCoalesce(options.plugins, () => ( [])),
+      _chunkWLHWKRZBcjs.resolvePathsPlugin,
+      _chunk3C3PXJUMcjs.fixImportsPlugin,
+      _chunkA6CGWMV7cjs.tscPlugin.call(void 0, options.emitTypes),
+      _chunkDCWECOOScjs.onErrorPlugin
+    ],
+    external: [
+      ..._nullishCoalesce(options.external, () => ( []))
+    ],
+    name: `${options.name || projectName}-${options.format || "cjs"}`,
+    projectConfigurations,
+    projectName,
+    projectGraph,
+    workspaceRoot
+  };
+}, "resolveOptions");
+var generatePackageJson = /* @__PURE__ */ _chunkBGYQAVKQcjs.__name.call(void 0, async (options) => {
+  const nxJsonPath = _devkit.joinPathFragments.call(void 0, options.workspaceRoot.dir, "nx.json");
+  if (!await _node.hfs.isFile(nxJsonPath)) {
+    throw new Error("Cannot find Nx workspace configuration");
+  }
+  const projectJsonPath = _devkit.joinPathFragments.call(void 0, options.workspaceRoot.dir, options.projectRoot, "project.json");
+  if (!await _node.hfs.isFile(projectJsonPath)) {
+    throw new Error("Cannot find project.json configuration");
+  }
+  if (!_optionalChain([options, 'access', _7 => _7.projectConfigurations, 'optionalAccess', _8 => _8.projects, 'optionalAccess', _9 => _9[options.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 packageJsonPath = _devkit.joinPathFragments.call(void 0, options.projectRoot, "project.json");
+  if (!await _node.hfs.isFile(packageJsonPath)) {
+    throw new Error("Cannot find package.json configuration");
+  }
+  const packageJson = await _node.hfs.json(_devkit.joinPathFragments.call(void 0, options.workspaceRoot.dir, options.projectRoot, "package.json"));
+  const projectDependencies = _buildablelibsutils.calculateProjectBuildableDependencies.call(void 0, void 0, options.projectGraph, options.workspaceRoot.dir, options.projectName, process.env.NX_TASK_TARGET_TARGET || "build", process.env.NX_TASK_TARGET_CONFIGURATION || "production", true);
+  const localPackages = projectDependencies.dependencies.filter((dep) => dep.node.type === "lib" && dep.node.data.root !== options.projectRoot && dep.node.data.root !== options.workspaceRoot.dir).reduce((ret, project) => {
+    const projectNode = project.node;
+    if (projectNode.data.root) {
+      const projectPackageJsonPath = _devkit.joinPathFragments.call(void 0, options.workspaceRoot.dir, projectNode.data.root, "package.json");
+      if (_fs.existsSync.call(void 0, projectPackageJsonPath)) {
+        const projectPackageJson = _devkit.readJsonFile.call(void 0, projectPackageJsonPath);
+        if (projectPackageJson.private !== false) {
+          ret.push(projectPackageJson);
+        }
+      }
+    }
+    return ret;
+  }, []);
+  if (localPackages.length > 0) {
+    _chunkRJQ3LCGJcjs.writeLog.call(void 0, "trace", `\u{1F4E6}  Adding local packages to package.json: ${localPackages.map((p) => p.name).join(", ")}`);
+    packageJson.peerDependencies = localPackages.reduce((ret, localPackage) => {
+      if (!ret[localPackage.name]) {
+        ret[localPackage.name] = `>=${localPackage.version || "0.0.1"}`;
+      }
+      return ret;
+    }, _nullishCoalesce(packageJson.peerDependencies, () => ( {})));
+    packageJson.peerDependenciesMeta = localPackages.reduce((ret, localPackage) => {
+      if (!ret[localPackage.name]) {
+        ret[localPackage.name] = {
+          optional: false
+        };
+      }
+      return ret;
+    }, _nullishCoalesce(packageJson.peerDependenciesMeta, () => ( {})));
+    packageJson.devDependencies = localPackages.reduce((ret, localPackage) => {
+      if (!ret[localPackage.name]) {
+        ret[localPackage.name] = localPackage.version || "0.0.1";
+      }
+      return ret;
+    }, _nullishCoalesce(packageJson.peerDependencies, () => ( {})));
+  } else {
+    _chunkRJQ3LCGJcjs.writeLog.call(void 0, "trace", "\u{1F4E6}  No local packages dependencies to add to package.json");
+  }
+  packageJson.main = "./dist/index.cjs";
+  packageJson.module = "./dist/index.mjs";
+  packageJson.types = "./dist/index.d.ts";
+  await _devkit.writeJsonFile.call(void 0, _devkit.joinPathFragments.call(void 0, options.outdir, "package.json"), packageJson);
+  return options;
+}, "generatePackageJson");
+async function createOptions(options) {
+  return _estoolkit.flatten.call(void 0, await Promise.all(_compat.map.call(void 0, options, (options2) => [
+    // we defer it so that we don't trigger glob immediately
+    () => resolveOptions(options2)
+  ])));
+}
+_chunkBGYQAVKQcjs.__name.call(void 0, createOptions, "createOptions");
+async function computeOptions(options) {
+  return options();
+}
+_chunkBGYQAVKQcjs.__name.call(void 0, computeOptions, "computeOptions");
+async function executeEsBuild(options) {
+  if (process.env.WATCH === "true") {
+    const context2 = await esbuild.context(_estoolkit.omit.call(void 0, options, [
+      "name",
+      "emitTypes",
+      "emitMetafile"
+    ]));
+    watch(context2, options);
+  }
+  const build3 = await esbuild.build(_estoolkit.omit.call(void 0, options, [
+    "name",
+    "emitTypes",
+    "emitMetafile"
+  ]));
+  if (build3.metafile && options.emitMetafile) {
+    const metafilePath = `${options.outdir}/${options.name}.meta.json`;
+    await _node.hfs.write(metafilePath, JSON.stringify(build3.metafile));
+  }
+  return [
+    options,
+    build3
+  ];
+}
+_chunkBGYQAVKQcjs.__name.call(void 0, executeEsBuild, "executeEsBuild");
+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: [
+      _chunkMTKAAECGcjs.depsCheckPlugin.call(void 0, options.bundle)
+    ]
+  });
+  await buildPromise.catch(() => {
+  });
+  return void 0;
+}
+_chunkBGYQAVKQcjs.__name.call(void 0, dependencyCheck, "dependencyCheck");
+async function build2(options) {
+  void transduce.async(options, dependencyCheck);
+  return transduce.async(await createOptions(options), pipe.async(computeOptions, generatePackageJson, executeEsBuild));
+}
+_chunkBGYQAVKQcjs.__name.call(void 0, build2, "build");
+var watch = /* @__PURE__ */ _chunkBGYQAVKQcjs.__name.call(void 0, (context2, options) => {
+  if (process.env.WATCH !== "true") 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) {
+      _chunkRJQ3LCGJcjs.writeLog.call(void 0, "error", rebuildResult.message);
+    }
+    _chunkRJQ3LCGJcjs.writeLog.call(void 0, "log", `${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;