@storm-software/workspace-tools 1.266.9 → 1.267.0

package/dist/chunk-LUR7U35A.mjs

@@ -0,0 +1,653 @@
+import {
+  withRunExecutor
+} from "./chunk-2TEC7IFE.mjs";
+import {
+  getStopwatch,
+  getWorkspaceConfig,
+  writeDebug,
+  writeError,
+  writeFatal,
+  writeInfo,
+  writeSuccess,
+  writeTrace,
+  writeWarning
+} from "./chunk-IZHZKPHV.mjs";
+import {
+  findWorkspaceRoot
+} from "./chunk-WDFR6LVR.mjs";
+import {
+  joinPaths
+} from "./chunk-5I7ULQZF.mjs";
+import {
+  __name,
+  __require
+} from "./chunk-N7GSKHH2.mjs";
+
+// ../esbuild/src/build.ts
+import { createProjectGraphAsync, readProjectsConfigurationFromProjectGraph as readProjectsConfigurationFromProjectGraph2, writeJsonFile } from "@nx/devkit";
+
+// ../build-tools/src/config.ts
+var DEFAULT_COMPILED_BANNER = `/*****************************************
+*
+*      \u26A1 Built by Storm Software
+*
+*****************************************/
+`;
+var DEFAULT_ENVIRONMENT = "production";
+var DEFAULT_TARGET = "esnext";
+var DEFAULT_ORGANIZATION = "storm-software";
+
+// ../build-tools/src/plugins/swc.ts
+import { transform } from "@swc/core";
+
+// ../build-tools/src/plugins/ts-resolve.ts
+import fs from "node:fs";
+import { builtinModules } from "node:module";
+import path from "node:path";
+import _resolve from "resolve";
+
+// ../build-tools/src/plugins/type-definitions.ts
+import { stripIndents } from "@nx/devkit";
+import { relative } from "path";
+
+// ../build-tools/src/utilities/copy-assets.ts
+import { CopyAssetsHandler } from "@nx/js/src/utils/assets/copy-assets-handler";
+import { glob } from "glob";
+import { readFile, writeFile } from "node:fs/promises";
+var copyAssets = /* @__PURE__ */ __name(async (config, assets, outputPath, projectRoot, sourceRoot, generatePackageJson2 = true, includeSrc = false, banner, footer) => {
+  const pendingAssets = Array.from(assets ?? []);
+  pendingAssets.push({
+    input: projectRoot,
+    glob: "*.md",
+    output: "."
+  });
+  pendingAssets.push({
+    input: ".",
+    glob: "LICENSE",
+    output: "."
+  });
+  if (generatePackageJson2 === false) {
+    pendingAssets.push({
+      input: projectRoot,
+      glob: "package.json",
+      output: "."
+    });
+  }
+  if (includeSrc === true) {
+    pendingAssets.push({
+      input: sourceRoot,
+      glob: "**/{*.ts,*.tsx,*.js,*.jsx}",
+      output: "src/"
+    });
+  }
+  writeTrace(`\u{1F4DD}  Copying the following assets to the output directory:
+${pendingAssets.map((pendingAsset) => typeof pendingAsset === "string" ? ` - ${pendingAsset} -> ${outputPath}` : `  - ${pendingAsset.input}/${pendingAsset.glob} -> ${joinPaths(outputPath, pendingAsset.output)}`).join("\n")}`, config);
+  const assetHandler = new CopyAssetsHandler({
+    projectDir: projectRoot,
+    rootDir: config.workspaceRoot,
+    outputDir: outputPath,
+    assets: pendingAssets
+  });
+  await assetHandler.processAllAssetsOnce();
+  if (includeSrc === true) {
+    writeDebug(`\u{1F4DD}  Adding banner and writing source files: ${joinPaths(outputPath, "src")}`, config);
+    const files = await glob([
+      joinPaths(config.workspaceRoot, outputPath, "src/**/*.ts"),
+      joinPaths(config.workspaceRoot, outputPath, "src/**/*.tsx"),
+      joinPaths(config.workspaceRoot, outputPath, "src/**/*.js"),
+      joinPaths(config.workspaceRoot, outputPath, "src/**/*.jsx")
+    ]);
+    await Promise.allSettled(files.map(async (file) => writeFile(file, `${banner && typeof banner === "string" ? banner.startsWith("//") ? banner : `// ${banner}` : ""}
+
+${await readFile(file, "utf8")}
+
+${footer && typeof footer === "string" ? footer.startsWith("//") ? footer : `// ${footer}` : ""}`)));
+  }
+}, "copyAssets");
+
+// ../build-tools/src/utilities/generate-package-json.ts
+import { calculateProjectBuildableDependencies } from "@nx/js/src/utils/buildable-libs-utils";
+import { Glob } from "glob";
+import { existsSync, readFileSync } from "node:fs";
+import { readFile as readFile2 } from "node:fs/promises";
+import { readCachedProjectGraph, readProjectsConfigurationFromProjectGraph } from "nx/src/project-graph/project-graph";
+var addPackageDependencies = /* @__PURE__ */ __name(async (workspaceRoot, projectRoot, projectName, packageJson) => {
+  const projectGraph = readCachedProjectGraph();
+  const projectDependencies = calculateProjectBuildableDependencies(void 0, projectGraph, workspaceRoot, projectName, process.env.NX_TASK_TARGET_TARGET || "build", process.env.NX_TASK_TARGET_CONFIGURATION || "production", true);
+  const localPackages = [];
+  for (const project of projectDependencies.dependencies.filter((dep) => dep.node.type === "lib" && dep.node.data?.root !== projectRoot && dep.node.data?.root !== workspaceRoot)) {
+    const projectNode = project.node;
+    if (projectNode.data.root) {
+      const projectPackageJsonPath = joinPaths(workspaceRoot, projectNode.data.root, "package.json");
+      if (existsSync(projectPackageJsonPath)) {
+        const projectPackageJsonContent = await readFile2(projectPackageJsonPath, "utf8");
+        const projectPackageJson = JSON.parse(projectPackageJsonContent);
+        if (projectPackageJson.private !== true) {
+          localPackages.push(projectPackageJson);
+        }
+      }
+    }
+  }
+  if (localPackages.length > 0) {
+    writeTrace(`\u{1F4E6}  Adding local packages to package.json: ${localPackages.map((p) => p.name).join(", ")}`);
+    const projectJsonFile = await readFile2(joinPaths(projectRoot, "project.json"), "utf8");
+    const projectJson = JSON.parse(projectJsonFile);
+    const projectName2 = projectJson.name;
+    const projectConfigurations = readProjectsConfigurationFromProjectGraph(projectGraph);
+    if (!projectConfigurations?.projects?.[projectName2]) {
+      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 implicitDependencies = projectConfigurations.projects?.[projectName2].implicitDependencies?.reduce((ret, dep) => {
+      if (projectConfigurations.projects?.[dep]) {
+        const depPackageJsonPath = joinPaths(workspaceRoot, projectConfigurations.projects[dep].root, "package.json");
+        if (existsSync(depPackageJsonPath)) {
+          const depPackageJsonContent = readFileSync(depPackageJsonPath, "utf8");
+          const depPackageJson = JSON.parse(depPackageJsonContent);
+          if (depPackageJson.private !== true && !ret.includes(depPackageJson.name)) {
+            ret.push(depPackageJson.name);
+          }
+        }
+      }
+      return ret;
+    }, []);
+    packageJson.dependencies = localPackages.reduce((ret, localPackage) => {
+      if (!ret[localPackage.name] && !implicitDependencies?.includes(localPackage.name) && packageJson.devDependencies?.[localPackage.name] === void 0) {
+        ret[localPackage.name] = `^${localPackage.version || "0.0.1"}`;
+      }
+      return ret;
+    }, packageJson.dependencies ?? {});
+    packageJson.devDependencies = localPackages.reduce((ret, localPackage) => {
+      if (!ret[localPackage.name] && implicitDependencies?.includes(localPackage.name) && packageJson.dependencies?.[localPackage.name] === void 0) {
+        ret[localPackage.name] = `^${localPackage.version || "0.0.1"}`;
+      }
+      return ret;
+    }, packageJson.devDependencies ?? {});
+  } else {
+    writeTrace("\u{1F4E6}  No local packages dependencies to add to package.json");
+  }
+  return packageJson;
+}, "addPackageDependencies");
+var addWorkspacePackageJsonFields = /* @__PURE__ */ __name(async (workspaceConfig, projectRoot, sourceRoot, projectName, includeSrc = false, packageJson) => {
+  const workspaceRoot = workspaceConfig.workspaceRoot ? workspaceConfig.workspaceRoot : findWorkspaceRoot();
+  const workspacePackageJsonContent = await readFile2(joinPaths(workspaceRoot, "package.json"), "utf8");
+  const workspacePackageJson = JSON.parse(workspacePackageJsonContent);
+  packageJson.type ??= "module";
+  packageJson.sideEffects ??= false;
+  if (includeSrc === true) {
+    let distSrc = sourceRoot.replace(projectRoot, "");
+    if (distSrc.startsWith("/")) {
+      distSrc = distSrc.substring(1);
+    }
+    packageJson.source ??= `${joinPaths(distSrc, "index.ts").replaceAll("\\", "/")}`;
+  }
+  packageJson.files ??= [
+    "dist/**/*"
+  ];
+  if (includeSrc === true && !packageJson.files.includes("src")) {
+    packageJson.files.push("src/**/*");
+  }
+  packageJson.publishConfig ??= {
+    access: "public"
+  };
+  packageJson.description ??= workspacePackageJson.description;
+  packageJson.homepage ??= workspacePackageJson.homepage;
+  packageJson.bugs ??= workspacePackageJson.bugs;
+  packageJson.license ??= workspacePackageJson.license;
+  packageJson.keywords ??= workspacePackageJson.keywords;
+  packageJson.funding ??= workspacePackageJson.funding;
+  packageJson.author ??= workspacePackageJson.author;
+  packageJson.maintainers ??= workspacePackageJson.maintainers;
+  if (!packageJson.maintainers && packageJson.author) {
+    packageJson.maintainers = [
+      packageJson.author
+    ];
+  }
+  packageJson.contributors ??= workspacePackageJson.contributors;
+  if (!packageJson.contributors && packageJson.author) {
+    packageJson.contributors = [
+      packageJson.author
+    ];
+  }
+  packageJson.repository ??= workspacePackageJson.repository;
+  packageJson.repository.directory ??= projectRoot ? projectRoot : joinPaths("packages", projectName);
+  return packageJson;
+}, "addWorkspacePackageJsonFields");
+
+// ../build-tools/src/utilities/get-entry-points.ts
+import { glob as glob2 } from "glob";
+
+// ../build-tools/src/utilities/get-env.ts
+var getEnv = /* @__PURE__ */ __name((builder, options) => {
+  return {
+    STORM_BUILD: builder,
+    STORM_ORG: options.orgName || DEFAULT_ORGANIZATION,
+    STORM_NAME: options.name,
+    STORM_MODE: options.mode || DEFAULT_ENVIRONMENT,
+    STORM_PLATFORM: options.platform,
+    STORM_FORMAT: JSON.stringify(options.format),
+    STORM_TARGET: JSON.stringify(options.target),
+    ...options.env
+  };
+}, "getEnv");
+
+// ../build-tools/src/utilities/read-nx-config.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { readFile as readFile3 } from "node:fs/promises";
+
+// ../build-tools/src/utilities/task-graph.ts
+import { createTaskGraph, mapTargetDefaultsToDependencies } from "nx/src/tasks-runner/create-task-graph";
+
+// ../esbuild/src/build.ts
+import { watch as createWatcher } from "chokidar";
+import defu from "defu";
+import { debounce } from "es-toolkit";
+import * as esbuild from "esbuild";
+import { globbySync } from "globby";
+import { existsSync as existsSync3 } from "node:fs";
+import hf from "node:fs/promises";
+import { findWorkspaceRoot as findWorkspaceRoot2 } from "nx/src/utils/find-workspace-root";
+import { build as tsup } from "tsup";
+
+// ../esbuild/src/clean.ts
+import { rm } from "node:fs/promises";
+async function cleanDirectories(directory) {
+  await rm(directory, {
+    recursive: true,
+    force: true
+  });
+}
+__name(cleanDirectories, "cleanDirectories");
+
+// ../esbuild/src/config.ts
+var DEFAULT_BUILD_OPTIONS = {
+  assets: [],
+  platform: "node",
+  target: [
+    "esnext"
+  ],
+  format: "esm",
+  tsconfig: "tsconfig.json",
+  mode: "production",
+  generatePackageJson: true,
+  includeSrc: false,
+  keepNames: true,
+  metafile: false,
+  treeshake: true,
+  shims: false,
+  watch: false,
+  bundle: true,
+  loader: {
+    ".aac": "file",
+    ".css": "file",
+    ".eot": "file",
+    ".flac": "file",
+    ".gif": "file",
+    ".jpeg": "file",
+    ".jpg": "file",
+    ".mp3": "file",
+    ".mp4": "file",
+    ".ogg": "file",
+    ".otf": "file",
+    ".png": "file",
+    ".svg": "file",
+    ".ttf": "file",
+    ".wav": "file",
+    ".webm": "file",
+    ".webp": "file",
+    ".woff": "file",
+    ".woff2": "file"
+  },
+  banner: {
+    js: DEFAULT_COMPILED_BANNER,
+    css: DEFAULT_COMPILED_BANNER
+  }
+};
+
+// ../esbuild/src/plugins/deps-check.ts
+import { builtinModules as builtinModules2 } from "node:module";
+import path2 from "node:path";
+var unusedIgnore = [
+  // these are our dev dependencies
+  /@types\/.*?/,
+  /@typescript-eslint.*?/,
+  /eslint.*?/,
+  "esbuild",
+  "husky",
+  "is-ci",
+  "lint-staged",
+  "prettier",
+  "typescript",
+  "ts-node",
+  "ts-jest",
+  "@swc/core",
+  "@swc/jest",
+  "jest",
+  // these are missing 3rd party deps
+  "spdx-exceptions",
+  "spdx-license-ids",
+  // type-only, so it is not detected
+  "ts-toolbelt",
+  // these are indirectly used by build
+  "buffer"
+];
+var missingIgnore = [
+  ".prisma",
+  "@prisma/client",
+  "ts-toolbelt"
+];
+var depsCheckPlugin = /* @__PURE__ */ __name((bundle) => ({
+  name: "storm:deps-check",
+  setup(build3) {
+    const pkgJsonPath = path2.join(process.cwd(), "package.json");
+    const pkgContents = __require(pkgJsonPath);
+    const regDependencies = Object.keys(pkgContents["dependencies"] ?? {});
+    const devDependencies = Object.keys(pkgContents["devDependencies"] ?? {});
+    const peerDependencies = Object.keys(pkgContents["peerDependencies"] ?? {});
+    const dependencies = [
+      ...regDependencies,
+      ...bundle ? devDependencies : []
+    ];
+    const collectedDependencies = /* @__PURE__ */ new Set();
+    const onlyPackages = /^[^./](?!:)|^\.[^./]|^\.\.[^/]/;
+    build3.onResolve({
+      filter: onlyPackages
+    }, (args) => {
+      if (args.importer.includes(process.cwd())) {
+        if (args.path[0] === "@") {
+          const [org, pkg] = args.path.split("/");
+          collectedDependencies.add(`${org}/${pkg}`);
+        } else {
+          const [pkg] = args.path.split("/");
+          collectedDependencies.add(pkg);
+        }
+      }
+      return {
+        external: true
+      };
+    });
+    build3.onEnd(() => {
+      const unusedDependencies = [
+        ...dependencies
+      ].filter((dep) => {
+        return !collectedDependencies.has(dep) || builtinModules2.includes(dep);
+      });
+      const missingDependencies = [
+        ...collectedDependencies
+      ].filter((dep) => {
+        return !dependencies.includes(dep) && !builtinModules2.includes(dep);
+      });
+      const filteredUnusedDeps = unusedDependencies.filter((dep) => {
+        return !unusedIgnore.some((pattern) => dep.match(pattern));
+      });
+      const filteredMissingDeps = missingDependencies.filter((dep) => {
+        return !missingIgnore.some((pattern) => dep.match(pattern)) && !peerDependencies.includes(dep);
+      });
+      writeWarning(`Unused Dependencies: ${JSON.stringify(filteredUnusedDeps)}`);
+      writeError(`Missing Dependencies: ${JSON.stringify(filteredMissingDeps)}`);
+      if (filteredMissingDeps.length > 0) {
+        throw new Error(`Missing dependencies detected - please install them:
+${JSON.stringify(filteredMissingDeps)}
+`);
+      }
+    });
+  }
+}), "depsCheckPlugin");
+
+// ../esbuild/src/build.ts
+async function resolveContext(userOptions) {
+  const projectRoot = userOptions.projectRoot;
+  const workspaceRoot = findWorkspaceRoot2(projectRoot);
+  if (!workspaceRoot) {
+    throw new Error("Cannot find Nx workspace root");
+  }
+  const workspaceConfig = await getWorkspaceConfig(true, {
+    workspaceRoot: workspaceRoot.dir
+  });
+  writeDebug("  \u2699\uFE0F   Resolving build options", workspaceConfig);
+  const stopwatch = getStopwatch("Build options resolution");
+  const projectGraph = await createProjectGraphAsync({
+    exitOnError: true
+  });
+  const projectJsonPath = joinPaths(workspaceRoot.dir, projectRoot, "project.json");
+  if (!existsSync3(projectJsonPath)) {
+    throw new Error("Cannot find project.json configuration");
+  }
+  const projectJsonFile = await hf.readFile(projectJsonPath, "utf8");
+  const projectJson = JSON.parse(projectJsonFile);
+  const projectName = projectJson.name || userOptions.name;
+  const projectConfigurations = readProjectsConfigurationFromProjectGraph2(projectGraph);
+  if (!projectConfigurations?.projects?.[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 = defu(userOptions, DEFAULT_BUILD_OPTIONS);
+  options.name ??= `${projectName}-${options.format}`;
+  options.target ??= DEFAULT_TARGET;
+  const packageJsonPath = joinPaths(workspaceRoot.dir, options.projectRoot, "package.json");
+  if (!existsSync3(packageJsonPath)) {
+    throw new Error("Cannot find package.json configuration");
+  }
+  const env = getEnv("esbuild", options);
+  const resolvedOptions = {
+    ...options,
+    tsconfig: joinPaths(projectRoot, userOptions.tsconfig ? userOptions.tsconfig.replace(projectRoot, "") : "tsconfig.json"),
+    distDir: "dist",
+    name: projectName,
+    metafile: userOptions.mode === "development",
+    ...userOptions,
+    clean: false,
+    target: userOptions.target || options.target,
+    splitting: options.format === "iife" ? false : options.treeshake === void 0 ? options.splitting : true,
+    env,
+    define: {
+      STORM_FORMAT: JSON.stringify(options.format),
+      ...options.define,
+      ...Object.keys(env || {}).reduce((res, key) => {
+        const value = JSON.stringify(env[key]);
+        const safeKey = key.replaceAll("(", "").replaceAll(")", "");
+        return {
+          ...res,
+          [`process.env.${safeKey}`]: value,
+          [`import.meta.env.${safeKey}`]: value
+        };
+      }, {})
+    }
+  };
+  stopwatch();
+  return {
+    options: resolvedOptions,
+    clean: userOptions.clean !== false,
+    workspaceConfig,
+    projectConfigurations,
+    projectName,
+    projectGraph,
+    sourceRoot: resolvedOptions.sourceRoot || projectJson.sourceRoot || joinPaths(resolvedOptions.projectRoot, "src"),
+    outputPath: resolvedOptions.outputPath || joinPaths(workspaceConfig.workspaceRoot, "dist", resolvedOptions.projectRoot),
+    minify: resolvedOptions.minify || resolvedOptions.mode === "production"
+  };
+}
+__name(resolveContext, "resolveContext");
+async function generatePackageJson(context) {
+  if (context.options.generatePackageJson !== false && existsSync3(joinPaths(context.options.projectRoot, "package.json"))) {
+    writeDebug("  \u270D\uFE0F   Writing package.json file", context.workspaceConfig);
+    const stopwatch = getStopwatch("Write package.json file");
+    const packageJsonPath = joinPaths(context.options.projectRoot, "project.json");
+    if (!existsSync3(packageJsonPath)) {
+      throw new Error("Cannot find package.json configuration");
+    }
+    const packageJsonFile = await hf.readFile(joinPaths(context.workspaceConfig.workspaceRoot, context.options.projectRoot, "package.json"), "utf8");
+    let packageJson = JSON.parse(packageJsonFile);
+    if (!packageJson) {
+      throw new Error("Cannot find package.json configuration file");
+    }
+    packageJson = await addPackageDependencies(context.workspaceConfig.workspaceRoot, context.options.projectRoot, context.projectName, packageJson);
+    packageJson = await addWorkspacePackageJsonFields(context.workspaceConfig, context.options.projectRoot, context.sourceRoot, context.projectName, false, packageJson);
+    if (context.options.entry) {
+      packageJson.exports ??= {};
+      packageJson.exports["./package.json"] ??= "./package.json";
+      packageJson.exports["."] ??= `.${context.options.distDir ? `/${context.options.distDir}` : ""}/index.js`;
+      const entryPoints = Array.isArray(context.options.entry) ? context.options.entry : Object.keys(context.options.entry);
+      for (const entryPoint of entryPoints) {
+        if (context.options.entry[entryPoint]) {
+          const entry = context.options.entry[entryPoint].replaceAll("\\", "/").replaceAll(/^(\.\/)*/g, "").replace(/\.([cm])?[jt]s(x)?$/g, "");
+          packageJson.exports[`./${entry}`] ??= `.${context.options.distDir ? `/${context.options.distDir}` : ""}/${entry}.js`;
+        }
+      }
+      if (context.options.format === "esm") {
+        packageJson.module = packageJson.type === "module" ? `.${context.options.distDir ? `/${context.options.distDir}` : ""}/index.js` : `.${context.options.distDir ? `/${context.options.distDir}` : ""}/index.mjs`;
+      } else {
+        packageJson.main = packageJson.type === "commonjs" ? `.${context.options.distDir ? `/${context.options.distDir}` : ""}/index.js` : `.${context.options.distDir ? `/${context.options.distDir}` : ""}/index.cjs`;
+      }
+      packageJson.types = `.${context.options.distDir ? `/${context.options.distDir}` : ""}/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 writeJsonFile(joinPaths(context.outputPath, "package.json"), packageJson);
+    stopwatch();
+  }
+  return context;
+}
+__name(generatePackageJson, "generatePackageJson");
+async function executeTsup(context) {
+  writeDebug(`  \u{1F680}  Running ${context.options.name} build`, context.workspaceConfig);
+  const stopwatch = getStopwatch(`${context.options.name} build`);
+  await tsup({
+    ...context.options,
+    outDir: context.outputPath,
+    workspaceConfig: context.workspaceConfig
+  });
+  stopwatch();
+  return context;
+}
+__name(executeTsup, "executeTsup");
+async function copyBuildAssets(context) {
+  if (context.result?.errors.length === 0) {
+    writeDebug(`  \u{1F4CB}  Copying asset files to output directory: ${context.outputPath}`, context.workspaceConfig);
+    const stopwatch = getStopwatch(`${context.options.name} asset copy`);
+    await copyAssets(context.workspaceConfig, context.options.assets ?? [], context.outputPath, context.options.projectRoot, context.sourceRoot, true, false);
+    stopwatch();
+  }
+  return context;
+}
+__name(copyBuildAssets, "copyBuildAssets");
+async function reportResults(context) {
+  if (context.result?.errors.length === 0) {
+    if (context.result.warnings.length > 0) {
+      writeWarning(`  \u{1F6A7}  The following warnings occurred during the build: ${context.result.warnings.map((warning) => warning.text).join("\n")}`, context.workspaceConfig);
+    }
+    writeSuccess(`  \u{1F4E6}  The ${context.options.name} build completed successfully`, context.workspaceConfig);
+  } else if (context.result?.errors && context.result?.errors.length > 0) {
+    writeError(`  \u274C  The ${context.options.name} build failed with the following errors: ${context.result.errors.map((error) => error.text).join("\n")}`, context.workspaceConfig);
+    throw new Error(`The ${context.options.name} build failed with the following errors: ${context.result.errors.map((error) => error.text).join("\n")}`);
+  }
+}
+__name(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: globbySync("**/*.{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: [
+      depsCheckPlugin(options.bundle)
+    ]
+  });
+  await buildPromise.catch(() => {
+  });
+  return void 0;
+}
+__name(dependencyCheck, "dependencyCheck");
+async function cleanOutputPath(context) {
+  if (context.clean !== false && context.outputPath) {
+    writeDebug(` \u{1F9F9}  Cleaning ${context.options.name} output path: ${context.outputPath}`, context.workspaceConfig);
+    const stopwatch = getStopwatch(`${context.options.name} output clean`);
+    await cleanDirectories(context.outputPath);
+    stopwatch();
+  }
+  return context;
+}
+__name(cleanOutputPath, "cleanOutputPath");
+async function build2(options) {
+  writeDebug(`  \u26A1   Executing Storm ESBuild pipeline`);
+  const stopwatch = getStopwatch("ESBuild pipeline");
+  try {
+    const opts = Array.isArray(options) ? options : [
+      options
+    ];
+    if (opts.length === 0) {
+      throw new Error("No build options were provided");
+    }
+    const context = await resolveContext(options);
+    await cleanOutputPath(context);
+    await Promise.all([
+      dependencyCheck(context.options),
+      generatePackageJson(context),
+      copyBuildAssets(context),
+      executeTsup(context)
+    ]);
+    await reportResults(context);
+    writeSuccess("  \u{1F3C1}  ESBuild pipeline build completed successfully");
+  } catch (error) {
+    writeFatal("Fatal errors that the build process could not recover from have occured. The build process has been terminated.");
+    throw error;
+  } finally {
+    stopwatch();
+  }
+}
+__name(build2, "build");
+
+// src/executors/esbuild/executor.ts
+async function esbuildExecutorFn(options, context, config) {
+  writeInfo("\u{1F4E6}  Running Storm ESBuild executor on the workspace", config);
+  if (!context.projectsConfigurations?.projects || !context.projectName || !context.projectsConfigurations.projects[context.projectName] || !context.projectsConfigurations.projects[context.projectName]?.root) {
+    throw new Error("The Build process failed because the context is not valid. Please run this command from a workspace.");
+  }
+  await build2({
+    ...options,
+    projectRoot: context.projectsConfigurations.projects?.[context.projectName].root,
+    name: context.projectName,
+    sourceRoot: context.projectsConfigurations.projects?.[context.projectName]?.sourceRoot,
+    format: options.format,
+    platform: options.format
+  });
+  return {
+    success: true
+  };
+}
+__name(esbuildExecutorFn, "esbuildExecutorFn");
+var executor_default = withRunExecutor("Storm ESBuild build", esbuildExecutorFn, {
+  skipReadingConfig: false,
+  hooks: {
+    applyDefaultOptions: /* @__PURE__ */ __name(async (options, config) => {
+      options.entry ??= [
+        "src/index.ts"
+      ];
+      options.outputPath ??= "dist/{projectRoot}";
+      options.tsconfig ??= "{projectRoot}/tsconfig.json";
+      return options;
+    }, "applyDefaultOptions")
+  }
+});
+
+export {
+  esbuildExecutorFn,
+  executor_default
+};

package/dist/{chunk-QDLQJ3QS.mjs → chunk-MFSIJSBW.mjs}

@@ -1,13 +1,13 @@
 import {
   buildCargoCommand,
   cargoCommand
-} from "./chunk-2RRVYK6E.mjs";
+} from "./chunk-GNFQ5PGW.mjs";
 import {
   withRunExecutor
-} from "./chunk-5AVEZVE5.mjs";
+} from "./chunk-2TEC7IFE.mjs";
 import {
   __name
-} from "./chunk-VGSUCQ2S.mjs";
+} from "./chunk-N7GSKHH2.mjs";
 
 // src/executors/cargo-build/executor.ts
 async function cargoBuildExecutor(options, context) {

package/dist/{chunk-L6BH2OLB.mjs → chunk-MIVNJALE.mjs}

@@ -1,6 +1,6 @@
 import {
   __name
-} from "./chunk-VGSUCQ2S.mjs";
+} from "./chunk-N7GSKHH2.mjs";
 
 // src/utils/typia-transform.ts
 import transform from "typia/lib/transform";

package/dist/{chunk-XRZPNGM5.mjs → chunk-N4QRXJLZ.mjs}

@@ -1,9 +1,9 @@
 import {
   findWorkspaceRoot
-} from "./chunk-VFXWLOY7.mjs";
+} from "./chunk-WDFR6LVR.mjs";
 import {
   __name
-} from "./chunk-VGSUCQ2S.mjs";
+} from "./chunk-N7GSKHH2.mjs";
 
 // src/utils/get-project-configurations.ts
 import { retrieveProjectConfigurationsWithoutPluginInference } from "nx/src/project-graph/utils/retrieve-workspace-files";