esbuild 0.9.3 → 0.9.7

package/install.js

@@ -1,11 +1,26 @@
-var __assign = Object.assign;
+var __defProp = Object.defineProperty;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, {enumerable: true, configurable: true, writable: true, value}) : obj[key] = value;
+var __assign = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
 const fs = require("fs");
 const os = require("os");
 const path = require("path");
 const zlib = require("zlib");
 const https = require("https");
 const child_process = require("child_process");
-const version = "0.9.3";
+const version = "0.9.7";
 const binPath = path.join(__dirname, "bin", "esbuild");
 async function installBinaryFromPackage(name, fromPath, toPath) {
   const cachePath = getCachePath(name);
@@ -175,7 +190,8 @@ function installDirectly(name) {
     fs.copyFileSync(process.env.ESBUILD_BINARY_PATH, binPath);
     validateBinaryVersion(binPath);
   } else {
-    installBinaryFromPackage(name, "bin/esbuild", binPath).catch((e) => setImmediate(() => {
+    const tempBinPath = binPath + "__";
+    installBinaryFromPackage(name, "bin/esbuild", tempBinPath).then(() => fs.renameSync(tempBinPath, binPath)).catch((e) => setImmediate(() => {
       throw e;
     }));
   }
@@ -214,8 +230,9 @@ const knownWindowsPackages = {
   "win32 x64 LE": "esbuild-windows-64"
 };
 const knownUnixlikePackages = {
-  "darwin x64 LE": "esbuild-darwin-64",
+  "android arm64 LE": "esbuild-android-arm64",
   "darwin arm64 LE": "esbuild-darwin-arm64",
+  "darwin x64 LE": "esbuild-darwin-64",
   "freebsd arm64 LE": "esbuild-freebsd-arm64",
   "freebsd x64 LE": "esbuild-freebsd-64",
   "linux arm LE": "esbuild-linux-arm",

package/lib/main.d.ts

@@ -49,6 +49,7 @@ export interface BuildOptions extends CommonOptions {
   tsconfig?: string;
   outExtension?: { [ext: string]: string };
   publicPath?: string;
+  entryNames?: string;
   chunkNames?: string;
   assetNames?: string;
   inject?: string[];
@@ -181,6 +182,7 @@ export interface Plugin {
 }
 
 export interface PluginBuild {
+  initialOptions: BuildOptions;
   onResolve(options: OnResolveOptions, callback: (args: OnResolveArgs) =>
     (OnResolveResult | null | undefined | Promise<OnResolveResult | null | undefined>)): void;
   onLoad(options: OnLoadOptions, callback: (args: OnLoadArgs) =>

package/lib/main.js

@@ -322,6 +322,7 @@ function flagsForBuildOptions(callName, options, isTTY2, logLevelDefault, writeD
   let loader = getFlag(options, keys, "loader", mustBeObject);
   let outExtension = getFlag(options, keys, "outExtension", mustBeObject);
   let publicPath = getFlag(options, keys, "publicPath", mustBeString);
+  let entryNames = getFlag(options, keys, "entryNames", mustBeString);
   let chunkNames = getFlag(options, keys, "chunkNames", mustBeString);
   let assetNames = getFlag(options, keys, "assetNames", mustBeString);
   let inject = getFlag(options, keys, "inject", mustBeArray);
@@ -332,7 +333,7 @@ function flagsForBuildOptions(callName, options, isTTY2, logLevelDefault, writeD
   let stdin = getFlag(options, keys, "stdin", mustBeObject);
   let write = (_a = getFlag(options, keys, "write", mustBeBoolean)) != null ? _a : writeDefault;
   let incremental = getFlag(options, keys, "incremental", mustBeBoolean) === true;
-  let plugins = getFlag(options, keys, "plugins", mustBeArray);
+  keys.plugins = true;
   checkForInvalidFlags(options, keys, `in ${callName}() call`);
   if (sourcemap)
     flags.push(`--sourcemap${sourcemap === true ? "" : `=${sourcemap}`}`);
@@ -377,6 +378,8 @@ function flagsForBuildOptions(callName, options, isTTY2, logLevelDefault, writeD
   }
   if (publicPath)
     flags.push(`--public-path=${publicPath}`);
+  if (entryNames)
+    flags.push(`--entry-names=${entryNames}`);
   if (chunkNames)
     flags.push(`--chunk-names=${chunkNames}`);
   if (assetNames)
@@ -468,7 +471,6 @@ function flagsForBuildOptions(callName, options, isTTY2, logLevelDefault, writeD
   return {
     flags,
     write,
-    plugins,
     stdinContents,
     stdinResolveDir,
     absWorkingDir,
@@ -638,8 +640,8 @@ function createChannel(streamIn) {
     if (isFirstPacket) {
       isFirstPacket = false;
       let binaryVersion = String.fromCharCode(...bytes);
-      if (binaryVersion !== "0.9.3") {
-        throw new Error(`Cannot start service: Host version "${"0.9.3"}" does not match binary version ${JSON.stringify(binaryVersion)}`);
+      if (binaryVersion !== "0.9.7") {
+        throw new Error(`Cannot start service: Host version "${"0.9.7"}" does not match binary version ${JSON.stringify(binaryVersion)}`);
       }
       return;
     }
@@ -655,14 +657,15 @@ function createChannel(streamIn) {
         callback(null, packet.value);
     }
   };
-  let handlePlugins = (plugins, request, buildKey, stash) => {
+  let handlePlugins = (initialOptions, plugins, buildKey, stash) => {
     if (streamIn.isSync)
       throw new Error("Cannot use plugins in synchronous API calls");
     let onResolveCallbacks = {};
     let onLoadCallbacks = {};
     let nextCallbackID = 0;
     let i = 0;
-    request.plugins = [];
+    let requestPlugins = [];
+    plugins = [...plugins];
     for (let item of plugins) {
       let keys = {};
       if (typeof item !== "object")
@@ -681,6 +684,7 @@ function createChannel(streamIn) {
       };
       i++;
       setup({
+        initialOptions,
         onResolve(options, callback2) {
           let registeredText = `This error came from the "onResolve" callback registered here`;
           let registeredNote = extractCallerV8(new Error(registeredText), streamIn, "onResolve");
@@ -708,22 +712,22 @@ function createChannel(streamIn) {
           plugin.onLoad.push({id, filter: filter.source, namespace: namespace || ""});
         }
       });
-      request.plugins.push(plugin);
+      requestPlugins.push(plugin);
     }
-    const callback = async (request2) => {
-      switch (request2.command) {
+    const callback = async (request) => {
+      switch (request.command) {
         case "resolve": {
           let response = {}, name, callback2, note;
-          for (let id of request2.ids) {
+          for (let id of request.ids) {
             try {
               ({name, callback: callback2, note} = onResolveCallbacks[id]);
               let result = await callback2({
-                path: request2.path,
-                importer: request2.importer,
-                namespace: request2.namespace,
-                resolveDir: request2.resolveDir,
-                kind: request2.kind,
-                pluginData: stash.load(request2.pluginData)
+                path: request.path,
+                importer: request.importer,
+                namespace: request.namespace,
+                resolveDir: request.resolveDir,
+                kind: request.kind,
+                pluginData: stash.load(request.pluginData)
               });
               if (result != null) {
                 if (typeof result !== "object")
@@ -755,20 +759,20 @@ function createChannel(streamIn) {
                 break;
               }
             } catch (e) {
-              return {id, errors: [extractErrorMessageV8(e, streamIn, stash, note)]};
+              return {id, errors: [extractErrorMessageV8(e, streamIn, stash, note && note())]};
             }
           }
           return response;
         }
         case "load": {
           let response = {}, name, callback2, note;
-          for (let id of request2.ids) {
+          for (let id of request.ids) {
             try {
               ({name, callback: callback2, note} = onLoadCallbacks[id]);
               let result = await callback2({
-                path: request2.path,
-                namespace: request2.namespace,
-                pluginData: stash.load(request2.pluginData)
+                path: request.path,
+                namespace: request.namespace,
+                pluginData: stash.load(request.pluginData)
               });
               if (result != null) {
                 if (typeof result !== "object")
@@ -802,17 +806,17 @@ function createChannel(streamIn) {
                 break;
               }
             } catch (e) {
-              return {id, errors: [extractErrorMessageV8(e, streamIn, stash, note)]};
+              return {id, errors: [extractErrorMessageV8(e, streamIn, stash, note && note())]};
             }
           }
           return response;
         }
         default:
-          throw new Error(`Invalid command: ` + request2.command);
+          throw new Error(`Invalid command: ` + request.command);
       }
     };
     let refCount = 0;
-    return {
+    return [requestPlugins, {
       ref() {
         if (++refCount === 1)
           pluginCallbacks.set(buildKey, callback);
@@ -821,7 +825,7 @@ function createChannel(streamIn) {
         if (--refCount === 0)
           pluginCallbacks.delete(buildKey);
       }
-    };
+    }];
   };
   let buildServeData = (refs, options, request) => {
     let keys = {};
@@ -885,10 +889,22 @@ function createChannel(streamIn) {
         try {
           let key = nextBuildKey++;
           let writeDefault = !streamIn.isBrowser;
+          let plugins;
+          let requestPlugins;
+          if (typeof options === "object") {
+            let value = options.plugins;
+            if (value !== void 0) {
+              if (!Array.isArray(value))
+                throw new Error(`"plugins" must be an array`);
+              plugins = value;
+            }
+          }
+          if (plugins && plugins.length > 0) {
+            [requestPlugins, pluginRefs] = handlePlugins(options, plugins, key, details);
+          }
           let {
             flags,
             write,
-            plugins,
             stdinContents,
             stdinResolveDir,
             absWorkingDir,
@@ -908,9 +924,9 @@ function createChannel(streamIn) {
             nodePaths,
             hasOnRebuild: !!(watch && watch.onRebuild)
           };
+          if (requestPlugins)
+            request.plugins = requestPlugins;
           let serve2 = serveOptions && buildServeData(refs, serveOptions, request);
-          if (plugins && plugins.length > 0)
-            pluginRefs = handlePlugins(plugins, request, key, details);
           let rebuild;
           let stop;
           let buildResponseToResult = (response, callback2) => {
@@ -1117,15 +1133,23 @@ function createObjectStash() {
   };
 }
 function extractCallerV8(e, streamIn, ident) {
-  try {
-    let lines = (e.stack + "").split("\n");
-    lines.splice(1, 1);
-    let location = parseStackLinesV8(streamIn, lines, ident);
-    if (location) {
-      return {text: e.message, location};
+  let note;
+  let tried = false;
+  return () => {
+    if (tried)
+      return note;
+    tried = true;
+    try {
+      let lines = (e.stack + "").split("\n");
+      lines.splice(1, 1);
+      let location = parseStackLinesV8(streamIn, lines, ident);
+      if (location) {
+        note = {text: e.message, location};
+        return note;
+      }
+    } catch (e2) {
     }
-  } catch (e2) {
-  }
+  };
 }
 function extractErrorMessageV8(e, streamIn, stash, note) {
   let text = "Internal error";
@@ -1161,7 +1185,12 @@ function parseStackLinesV8(streamIn, lines, ident) {
         }
         match = /^(\S+):(\d+):(\d+)$/.exec(line);
         if (match) {
-          let contents = streamIn.readFileSync(match[1], "utf8");
+          let contents;
+          try {
+            contents = streamIn.readFileSync(match[1], "utf8");
+          } catch (e) {
+            break;
+          }
           let lineText = contents.split(/\r\n|\r|\n|\u2028|\u2029/)[+match[2] - 1] || "";
           let column = +match[3] - 1;
           let length = lineText.slice(column, column + ident.length) === ident ? ident.length : 0;
@@ -1277,6 +1306,13 @@ var path = require("path");
 var fs = require("fs");
 var os = require("os");
 var tty = require("tty");
+var worker_threads;
+if (process.env.ESBUILD_WORKER_THREADS) {
+  try {
+    worker_threads = require("worker_threads");
+  } catch (e) {
+  }
+}
 var esbuildCommandAndArgs = () => {
   if (process.env.ESBUILD_BINARY_PATH) {
     return [path.resolve(process.env.ESBUILD_BINARY_PATH), []];
@@ -1294,13 +1330,18 @@ var esbuildCommandAndArgs = () => {
   return [path.join(__dirname, "..", "bin", "esbuild"), []];
 };
 var isTTY = () => tty.isatty(2);
-var version = "0.9.3";
+var version = "0.9.7";
 var build = (options) => ensureServiceIsRunning().build(options);
 var serve = (serveOptions, buildOptions) => ensureServiceIsRunning().serve(serveOptions, buildOptions);
 var transform = (input, options) => ensureServiceIsRunning().transform(input, options);
 var buildSync = (options) => {
+  if (worker_threads) {
+    if (!workerThreadService)
+      workerThreadService = startWorkerThreadService(worker_threads);
+    return workerThreadService.buildSync(options);
+  }
   let result;
-  runServiceSync((service) => service.buildOrServe("buildSync", null, null, options, isTTY(), process.cwd(), (err, res) => {
+  runServiceSync((service) => service.buildOrServe("buildSync", null, null, options, isTTY(), defaultWD, (err, res) => {
     if (err)
       throw err;
     result = res;
@@ -1308,6 +1349,11 @@ var buildSync = (options) => {
   return result;
 };
 var transformSync = (input, options) => {
+  if (worker_threads) {
+    if (!workerThreadService)
+      workerThreadService = startWorkerThreadService(worker_threads);
+    return workerThreadService.transformSync(input, options);
+  }
   let result;
   runServiceSync((service) => service.transform("transformSync", null, input, options || {}, isTTY(), {
     readFile(tempFile, callback) {
@@ -1347,21 +1393,20 @@ var initialize = (options) => {
     throw new Error(`The "worker" option only works in the browser`);
   if (initializeWasCalled)
     throw new Error('Cannot call "initialize" more than once');
+  ensureServiceIsRunning();
   initializeWasCalled = true;
   return Promise.resolve();
 };
 var defaultWD = process.cwd();
 var longLivedService;
 var ensureServiceIsRunning = () => {
-  if (!longLivedService)
-    longLivedService = startRunningService();
-  return longLivedService;
-};
-var startRunningService = () => {
+  if (longLivedService)
+    return longLivedService;
   let [command, args] = esbuildCommandAndArgs();
-  let child = child_process.spawn(command, args.concat(`--service=${"0.9.3"}`, "--ping"), {
+  let child = child_process.spawn(command, args.concat(`--service=${"0.9.7"}`, "--ping"), {
     windowsHide: true,
-    stdio: ["pipe", "pipe", "inherit"]
+    stdio: ["pipe", "pipe", "inherit"],
+    cwd: defaultWD
   });
   let {readFromStdout, afterClose, service} = createChannel({
     writeToStdin(bytes) {
@@ -1393,7 +1438,7 @@ var startRunningService = () => {
         child.unref();
     }
   };
-  return {
+  longLivedService = {
     build: (options) => {
       return new Promise((resolve, reject) => {
         service.buildOrServe("build", refs, null, options, isTTY(), defaultWD, (err, res) => {
@@ -1442,6 +1487,7 @@ var startRunningService = () => {
       }, (err, res) => err ? reject(err) : resolve(res)));
     }
   };
+  return longLivedService;
 };
 var runServiceSync = (callback) => {
   let [command, args] = esbuildCommandAndArgs();
@@ -1456,8 +1502,8 @@ var runServiceSync = (callback) => {
     isBrowser: false
   });
   callback(service);
-  let stdout = child_process.execFileSync(command, args.concat(`--service=${"0.9.3"}`), {
-    cwd: process.cwd(),
+  let stdout = child_process.execFileSync(command, args.concat(`--service=${"0.9.7"}`), {
+    cwd: defaultWD,
     windowsHide: true,
     input: stdin,
     maxBuffer: +process.env.ESBUILD_MAX_BUFFER || 16 * 1024 * 1024
@@ -1468,6 +1514,99 @@ var runServiceSync = (callback) => {
 var randomFileName = () => {
   return path.join(os.tmpdir(), `esbuild-${crypto.randomBytes(32).toString("hex")}`);
 };
+var workerThreadService = null;
+var startWorkerThreadService = (worker_threads2) => {
+  let {port1: mainPort, port2: workerPort} = new worker_threads2.MessageChannel();
+  let worker = new worker_threads2.Worker(__filename, {
+    workerData: {workerPort, defaultWD},
+    transferList: [workerPort],
+    execArgv: []
+  });
+  let nextID = 0;
+  let wasStopped = false;
+  let validateBuildSyncOptions = (options) => {
+    if (!options)
+      return;
+    let plugins = options.plugins;
+    let incremental = options.incremental;
+    if (plugins && plugins.length > 0)
+      throw new Error(`Cannot use plugins in synchronous API calls`);
+    if (incremental)
+      throw new Error(`Cannot use "incremental" with a synchronous build`);
+  };
+  let applyProperties = (object, properties) => {
+    for (let key in properties) {
+      object[key] = properties[key];
+    }
+  };
+  let runCallSync = (command, args) => {
+    if (wasStopped)
+      throw new Error("The service was stopped");
+    let id = nextID++;
+    let sharedBuffer = new SharedArrayBuffer(8);
+    let sharedBufferView = new Int32Array(sharedBuffer);
+    let msg = {sharedBuffer, id, command, args};
+    worker.postMessage(msg);
+    let status = Atomics.wait(sharedBufferView, 0, 0);
+    if (status !== "ok" && status !== "not-equal")
+      throw new Error("Internal error: Atomics.wait() failed: " + status);
+    let {message: {id: id2, resolve, reject, properties}} = worker_threads2.receiveMessageOnPort(mainPort);
+    if (id !== id2)
+      throw new Error(`Internal error: Expected id ${id} but got id ${id2}`);
+    if (reject) {
+      applyProperties(reject, properties);
+      throw reject;
+    }
+    return resolve;
+  };
+  worker.unref();
+  return {
+    buildSync(options) {
+      validateBuildSyncOptions(options);
+      return runCallSync("build", [options]);
+    },
+    transformSync(input, options) {
+      return runCallSync("transform", [input, options]);
+    }
+  };
+};
+var startSyncServiceWorker = () => {
+  let workerPort = worker_threads.workerData.workerPort;
+  let parentPort = worker_threads.parentPort;
+  let service = ensureServiceIsRunning();
+  defaultWD = worker_threads.workerData.defaultWD;
+  let extractProperties = (object) => {
+    let properties = {};
+    if (object && typeof object === "object") {
+      for (let key in object) {
+        properties[key] = object[key];
+      }
+    }
+    return properties;
+  };
+  parentPort.on("message", (msg) => {
+    (async () => {
+      let {sharedBuffer, id, command, args} = msg;
+      let sharedBufferView = new Int32Array(sharedBuffer);
+      try {
+        if (command === "build") {
+          workerPort.postMessage({id, resolve: await service.build(args[0])});
+        } else if (command === "transform") {
+          workerPort.postMessage({id, resolve: await service.transform(args[0], args[1])});
+        } else {
+          throw new Error(`Invalid command: ${command}`);
+        }
+      } catch (reject) {
+        workerPort.postMessage({id, reject, properties: extractProperties(reject)});
+      }
+      Atomics.add(sharedBufferView, 0, 1);
+      Atomics.notify(sharedBufferView, 0, Infinity);
+    })();
+  });
+};
+if (worker_threads && !worker_threads.isMainThread) {
+  startSyncServiceWorker();
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   build,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "esbuild",
-  "version": "0.9.3",
+  "version": "0.9.7",
   "description": "An extremely fast JavaScript bundler and minifier.",
   "repository": "https://github.com/evanw/esbuild",
   "scripts": {