@storm-software/esbuild 0.4.1 → 0.14.2

package/dist/{chunk-KJ7ZHAFS.js → chunk-KOK4WCHS.js}

@@ -1,15 +1,40 @@
+import {
+  writeError
+} from "./chunk-HQGUIF4U.js";
+import {
+  joinPaths
+} from "./chunk-7MDMXJ5V.js";
 import {
   __name,
   __require
-} from "./chunk-WCQVDF3K.js";
+} from "./chunk-3GQAWCBQ.js";
 
 // src/plugins/tsc.ts
 import { hfs } from "@humanfs/node";
 import { Extractor, ExtractorConfig } from "@microsoft/api-extractor";
-import { loadStormConfig, run, writeError } from "@storm-software/config-tools";
-import path from "node:path";
-function bundleTypeDefinitions(filename, outfile, externals) {
-  const { dependencies, peerDependencies, devDependencies } = __require(`${process.cwd()}/package.json`);
+
+// ../config-tools/src/utilities/run.ts
+import { exec, execSync } from "node:child_process";
+var LARGE_BUFFER = 1024 * 1e6;
+var run = /* @__PURE__ */ __name((config, command, cwd = config.workspaceRoot ?? process.cwd(), stdio = "inherit", env = process.env) => {
+  return execSync(command, {
+    cwd,
+    env: {
+      ...process.env,
+      ...env,
+      CLICOLOR: "true",
+      FORCE_COLOR: "true"
+    },
+    windowsHide: true,
+    stdio,
+    maxBuffer: LARGE_BUFFER,
+    killSignal: "SIGTERM"
+  });
+}, "run");
+
+// src/plugins/tsc.ts
+function bundleTypeDefinitions(filename, outfile, externals, options) {
+  const { dependencies, peerDependencies, devDependencies } = __require(joinPaths(options.projectRoot, "package.json"));
   const dependenciesKeys = Object.keys(dependencies ?? {}).flatMap((p) => [
     p,
     getTypeDependencyPackageName(p)
@@ -31,11 +56,11 @@ function bundleTypeDefinitions(filename, outfile, externals) {
   const bundledPackages = includeDeps.filter((dep) => !excludeDeps.has(dep));
   const extractorConfig = ExtractorConfig.prepare({
     configObject: {
-      projectFolder: process.cwd(),
+      projectFolder: options.projectRoot,
       mainEntryPointFilePath: filename,
       bundledPackages,
       compiler: {
-        tsconfigFilePath: path.join(process.cwd(), "tsconfig.build.json"),
+        tsconfigFilePath: options.tsconfig,
         overrideTsconfig: {
           compilerOptions: {
             paths: {}
@@ -45,13 +70,13 @@ function bundleTypeDefinitions(filename, outfile, externals) {
       },
       dtsRollup: {
         enabled: true,
-        untrimmedFilePath: path.join(process.cwd(), `${outfile}.d.ts`)
+        untrimmedFilePath: joinPaths(options.outdir, `${outfile}.d.ts`)
       },
       tsdocMetadata: {
         enabled: false
       }
     },
-    packageJsonFullPath: path.join(process.cwd(), "package.json"),
+    packageJsonFullPath: joinPaths(options.projectRoot, "package.json"),
     configObjectFullPath: void 0
   });
   const extractorResult = Extractor.invoke(extractorConfig, {
@@ -64,34 +89,34 @@ function bundleTypeDefinitions(filename, outfile, externals) {
   }
 }
 __name(bundleTypeDefinitions, "bundleTypeDefinitions");
-var tscPlugin = /* @__PURE__ */ __name((emitTypes) => ({
-  name: "tscPlugin",
+var tscPlugin = /* @__PURE__ */ __name((options, resolvedOptions) => ({
+  name: "storm:tsc",
   setup(build) {
-    const options = build.initialOptions;
-    if (emitTypes === false) return;
+    if (options.emitTypes === false) {
+      return;
+    }
     build.onStart(async () => {
-      const config = await loadStormConfig();
       if (process.env.WATCH !== "true" && process.env.DEV !== "true") {
-        await run(config, `pnpm exec tsc --project ${options.tsconfig} --paths null`, config.workspaceRoot);
+        await run(resolvedOptions.config, `pnpm exec tsc --project ${resolvedOptions.tsconfig}`, resolvedOptions.config.workspaceRoot);
       }
-      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$/, "");
+      if (resolvedOptions.bundle && resolvedOptions.entryPoints && resolvedOptions.entryPoints.length > 0 && resolvedOptions.entryPoints[0] && resolvedOptions.entryPoints[0].endsWith(".ts")) {
+        const sourceRoot = resolvedOptions.sourceRoot.replaceAll(resolvedOptions.projectRoot, "");
+        const typeOutDir = resolvedOptions.outdir;
+        const entryPoint = resolvedOptions.entryPoints[0].replace(sourceRoot, "").replace(/\.ts$/, "");
+        const bundlePath = joinPaths(resolvedOptions.outdir, entryPoint);
         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`;
+        if (await hfs.isFile(joinPaths(resolvedOptions.config.workspaceRoot, typeOutDir, `${entryPoint}.d.ts`))) {
+          dtsPath = joinPaths(resolvedOptions.config.workspaceRoot, typeOutDir, `${entryPoint}.d.ts`);
+        } else if (await hfs.isFile(joinPaths(resolvedOptions.config.workspaceRoot, typeOutDir, `${entryPoint.replace(/^src\//, "")}.d.ts`))) {
+          dtsPath = joinPaths(resolvedOptions.config.workspaceRoot, typeOutDir, `${entryPoint.replace(/^src\//, "")}.d.ts`);
         }
-        const ext = options.format === "esm" ? "d.mts" : "d.ts";
+        const ext = resolvedOptions.outExtension.dts || resolvedOptions.format === "esm" ? "d.mts" : "d.ts";
         if (process.env.WATCH !== "true" && process.env.DEV !== "true") {
-          bundleTypeDefinitions(dtsPath, bundlePath, options.external ?? []);
+          bundleTypeDefinitions(dtsPath, bundlePath, resolvedOptions.external ?? [], resolvedOptions);
           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}'`);
+          await hfs.write(`${bundlePath}.${ext}`, `export * from './${entryPoint}'`);
         }
       }
     });
@@ -109,4 +134,3 @@ __name(getTypeDependencyPackageName, "getTypeDependencyPackageName");
 export {
   tscPlugin
 };
-//# sourceMappingURL=chunk-KJ7ZHAFS.js.map

package/dist/chunk-LVWQSCJM.cjs

@@ -0,0 +1,26 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkBGYQAVKQcjs = require('./chunk-BGYQAVKQ.cjs');
+
+// ../config-tools/src/utilities/correct-paths.ts
+var _devkit = require('@nx/devkit');
+var correctPaths = /* @__PURE__ */ _chunkBGYQAVKQcjs.__name.call(void 0, (path) => {
+  if (!path) {
+    return "";
+  }
+  if (!path.toUpperCase().startsWith("C:") && path.includes("\\")) {
+    path = `C:${path}`;
+  }
+  return path.replaceAll("\\", "/");
+}, "correctPaths");
+var joinPaths = /* @__PURE__ */ _chunkBGYQAVKQcjs.__name.call(void 0, (...paths) => {
+  if (!paths || paths.length === 0) {
+    return "";
+  }
+  return correctPaths(_devkit.joinPathFragments.call(void 0, ...paths.map((path) => correctPaths(path))));
+}, "joinPaths");
+
+
+
+
+exports.correctPaths = correctPaths; exports.joinPaths = joinPaths;

package/dist/chunk-LYDEMC26.js

@@ -0,0 +1,23 @@
+import {
+  __name
+} from "./chunk-3GQAWCBQ.js";
+
+// src/plugins/node-protocol.ts
+var nodeProtocolPlugin = /* @__PURE__ */ __name((options, resolvedOptions) => {
+  const nodeProtocol = "node:";
+  return {
+    name: "node-protocol-plugin",
+    setup({ onResolve }) {
+      onResolve({
+        filter: /^node:/
+      }, ({ path }) => ({
+        path: path.slice(nodeProtocol.length),
+        external: true
+      }));
+    }
+  };
+}, "nodeProtocolPlugin");
+
+export {
+  nodeProtocolPlugin
+};