vite 6.0.0-beta.8 → 6.0.0

package/dist/node/module-runner.js

@@ -1,7 +1,7 @@
 const VALID_ID_PREFIX = "/@id/", NULL_BYTE_PLACEHOLDER = "__x00__";
 let SOURCEMAPPING_URL = "sourceMa";
 SOURCEMAPPING_URL += "ppingURL";
-const isWindows = typeof process < "u" && process.platform === "win32";
+const ERR_OUTDATED_OPTIMIZED_DEP = "ERR_OUTDATED_OPTIMIZED_DEP", isWindows = typeof process < "u" && process.platform === "win32";
 function unwrapId(id) {
   return id.startsWith(VALID_ID_PREFIX) ? id.slice(VALID_ID_PREFIX.length).replace(NULL_BYTE_PLACEHOLDER, "\0") : id;
 }
@@ -27,6 +27,12 @@ function getAsyncFunctionDeclarationPaddingLineCount() {
   }
   return asyncFunctionDeclarationPaddingLineCount;
 }
+function promiseWithResolvers() {
+  let resolve2, reject;
+  return { promise: new Promise((_resolve, _reject) => {
+    resolve2 = _resolve, reject = _reject;
+  }), resolve: resolve2, reject };
+}
 const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
 function normalizeWindowsPath(input = "") {
   return input && input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
@@ -326,7 +332,12 @@ class EvaluatedModules {
     this.idToModuleMap.clear(), this.fileToModulesMap.clear(), this.urlToIdModuleMap.clear();
   }
 }
-const prefixedBuiltins = /* @__PURE__ */ new Set(["node:test", "node:sqlite"]);
+const prefixedBuiltins = /* @__PURE__ */ new Set([
+  "node:sea",
+  "node:sqlite",
+  "node:test",
+  "node:test/reporters"
+]);
 function normalizeModuleId(file) {
   return prefixedBuiltins.has(file) ? file : slash(file).replace(/^\/@fs\//, isWindows ? "" : "/").replace(/^node:/, "").replace(/^\/+/, "/").replace(/^file:\//, "/");
 }
@@ -408,7 +419,7 @@ class HMRContext {
     removeFromMap(this.hmrClient.customListenersMap), removeFromMap(this.newListeners);
   }
   send(event, data) {
-    this.hmrClient.messenger.send({ type: "custom", event, data });
+    this.hmrClient.send({ type: "custom", event, data });
   }
   acceptDeps(deps, callback = () => {
   }) {
@@ -422,21 +433,9 @@ class HMRContext {
     }), this.hmrClient.hotModulesMap.set(this.ownerPath, mod);
   }
 }
-class HMRMessenger {
-  constructor(connection) {
-    this.connection = connection;
-  }
-  queue = [];
-  send(payload) {
-    this.queue.push(payload), this.flush();
-  }
-  flush() {
-    this.connection.isReady() && (this.queue.forEach((msg) => this.connection.send(msg)), this.queue = []);
-  }
-}
 class HMRClient {
-  constructor(logger, connection, importUpdatedModule) {
-    this.logger = logger, this.importUpdatedModule = importUpdatedModule, this.messenger = new HMRMessenger(connection);
+  constructor(logger, transport, importUpdatedModule) {
+    this.logger = logger, this.transport = transport, this.importUpdatedModule = importUpdatedModule;
   }
   hotModulesMap = /* @__PURE__ */ new Map();
   disposeMap = /* @__PURE__ */ new Map();
@@ -444,11 +443,15 @@ class HMRClient {
   dataMap = /* @__PURE__ */ new Map();
   customListenersMap = /* @__PURE__ */ new Map();
   ctxToListenersMap = /* @__PURE__ */ new Map();
-  messenger;
   async notifyListeners(event, data) {
     const cbs = this.customListenersMap.get(event);
     cbs && await Promise.allSettled(cbs.map((cb) => cb(data)));
   }
+  send(payload) {
+    this.transport.send(payload).catch((err) => {
+      this.logger.error(err);
+    });
+  }
   clear() {
     this.hotModulesMap.clear(), this.disposeMap.clear(), this.pruneMap.clear(), this.dataMap.clear(), this.customListenersMap.clear(), this.ctxToListenersMap.clear();
   }
@@ -528,7 +531,194 @@ const {${missingBindings.join(", ")}} = pkg;
     }
   }
 }
-const ssrModuleExportsKey = "__vite_ssr_exports__", ssrImportKey = "__vite_ssr_import__", ssrDynamicImportKey = "__vite_ssr_dynamic_import__", ssrExportAllKey = "__vite_ssr_exportAll__", ssrImportMetaKey = "__vite_ssr_import_meta__", noop = () => {
+let urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict", nanoid = (size = 21) => {
+  let id = "", i = size;
+  for (; i--; )
+    id += urlAlphabet[Math.random() * 64 | 0];
+  return id;
+};
+function reviveInvokeError(e) {
+  const error = new Error(e.message || "Unknown invoke error");
+  return Object.assign(error, e, {
+    // pass the whole error instead of just the stacktrace
+    // so that it gets formatted nicely with console.log
+    runnerError: new Error("RunnerError")
+  }), error;
+}
+const createInvokeableTransport = (transport) => {
+  if (transport.invoke)
+    return {
+      ...transport,
+      async invoke(name, data) {
+        const result = await transport.invoke({
+          type: "custom",
+          event: "vite:invoke",
+          data: {
+            id: "send",
+            name,
+            data
+          }
+        });
+        if ("e" in result)
+          throw reviveInvokeError(result.e);
+        return result.r;
+      }
+    };
+  if (!transport.send || !transport.connect)
+    throw new Error(
+      "transport must implement send and connect when invoke is not implemented"
+    );
+  const rpcPromises = /* @__PURE__ */ new Map();
+  return {
+    ...transport,
+    connect({ onMessage, onDisconnection }) {
+      return transport.connect({
+        onMessage(payload) {
+          if (payload.type === "custom" && payload.event === "vite:invoke") {
+            const data = payload.data;
+            if (data.id.startsWith("response:")) {
+              const invokeId = data.id.slice(9), promise = rpcPromises.get(invokeId);
+              if (!promise) return;
+              promise.timeoutId && clearTimeout(promise.timeoutId), rpcPromises.delete(invokeId);
+              const { e, r } = data.data;
+              e ? promise.reject(e) : promise.resolve(r);
+              return;
+            }
+          }
+          onMessage(payload);
+        },
+        onDisconnection
+      });
+    },
+    disconnect() {
+      return rpcPromises.forEach((promise) => {
+        promise.reject(
+          new Error(
+            `transport was disconnected, cannot call ${JSON.stringify(promise.name)}`
+          )
+        );
+      }), rpcPromises.clear(), transport.disconnect?.();
+    },
+    send(data) {
+      return transport.send(data);
+    },
+    async invoke(name, data) {
+      const promiseId = nanoid(), wrappedData = {
+        type: "custom",
+        event: "vite:invoke",
+        data: {
+          name,
+          id: `send:${promiseId}`,
+          data
+        }
+      }, sendPromise = transport.send(wrappedData), { promise, resolve: resolve2, reject } = promiseWithResolvers(), timeout = transport.timeout ?? 6e4;
+      let timeoutId;
+      timeout > 0 && (timeoutId = setTimeout(() => {
+        rpcPromises.delete(promiseId), reject(
+          new Error(
+            `transport invoke timed out after ${timeout}ms (data: ${JSON.stringify(wrappedData)})`
+          )
+        );
+      }, timeout), timeoutId?.unref?.()), rpcPromises.set(promiseId, { resolve: resolve2, reject, name, timeoutId }), sendPromise && sendPromise.catch((err) => {
+        clearTimeout(timeoutId), rpcPromises.delete(promiseId), reject(err);
+      });
+      try {
+        return await promise;
+      } catch (err) {
+        throw reviveInvokeError(err);
+      }
+    }
+  };
+}, normalizeModuleRunnerTransport = (transport) => {
+  const invokeableTransport = createInvokeableTransport(transport);
+  let isConnected = !invokeableTransport.connect, connectingPromise;
+  return {
+    ...transport,
+    ...invokeableTransport.connect ? {
+      async connect(onMessage) {
+        if (isConnected) return;
+        if (connectingPromise) {
+          await connectingPromise;
+          return;
+        }
+        const maybePromise = invokeableTransport.connect({
+          onMessage: onMessage ?? (() => {
+          }),
+          onDisconnection() {
+            isConnected = !1;
+          }
+        });
+        maybePromise && (connectingPromise = maybePromise, await connectingPromise, connectingPromise = void 0), isConnected = !0;
+      }
+    } : {},
+    ...invokeableTransport.disconnect ? {
+      async disconnect() {
+        isConnected && (connectingPromise && await connectingPromise, isConnected = !1, await invokeableTransport.disconnect());
+      }
+    } : {},
+    async send(data) {
+      if (invokeableTransport.send) {
+        if (!isConnected)
+          if (connectingPromise)
+            await connectingPromise;
+          else
+            throw new Error("send was called before connect");
+        await invokeableTransport.send(data);
+      }
+    },
+    async invoke(name, data) {
+      if (!isConnected)
+        if (connectingPromise)
+          await connectingPromise;
+        else
+          throw new Error("invoke was called before connect");
+      return invokeableTransport.invoke(name, data);
+    }
+  };
+}, createWebSocketModuleRunnerTransport = (options) => {
+  const pingInterval = options.pingInterval ?? 3e4;
+  let ws, pingIntervalId;
+  return {
+    async connect({ onMessage, onDisconnection }) {
+      const socket = options.createConnection();
+      socket.addEventListener("message", async ({ data }) => {
+        onMessage(JSON.parse(data));
+      });
+      let isOpened = socket.readyState === socket.OPEN;
+      isOpened || await new Promise((resolve2, reject) => {
+        socket.addEventListener(
+          "open",
+          () => {
+            isOpened = !0, resolve2();
+          },
+          { once: !0 }
+        ), socket.addEventListener("close", async () => {
+          if (!isOpened) {
+            reject(new Error("WebSocket closed without opened."));
+            return;
+          }
+          onMessage({
+            type: "custom",
+            event: "vite:ws:disconnect",
+            data: { webSocket: socket }
+          }), onDisconnection();
+        });
+      }), onMessage({
+        type: "custom",
+        event: "vite:ws:connect",
+        data: { webSocket: socket }
+      }), ws = socket, pingIntervalId = setInterval(() => {
+        socket.readyState === socket.OPEN && socket.send(JSON.stringify({ type: "ping" }));
+      }, pingInterval);
+    },
+    disconnect() {
+      clearInterval(pingIntervalId), ws?.close();
+    },
+    send(data) {
+      ws.send(JSON.stringify(data));
+    }
+  };
+}, ssrModuleExportsKey = "__vite_ssr_exports__", ssrImportKey = "__vite_ssr_import__", ssrDynamicImportKey = "__vite_ssr_dynamic_import__", ssrExportAllKey = "__vite_ssr_exportAll__", ssrImportMetaKey = "__vite_ssr_import_meta__", noop = () => {
 }, silentConsole = {
   debug: noop,
   error: noop
@@ -545,7 +735,7 @@ async function handleHotPayload(runner, payload) {
   if (!(!hmrClient || runner.isClosed()))
     switch (payload.type) {
       case "connected":
-        hmrClient.logger.debug("connected."), hmrClient.messenger.flush();
+        hmrClient.logger.debug("connected.");
         break;
       case "update":
         await hmrClient.notifyListeners("vite:beforeUpdate", payload), await Promise.all(
@@ -568,7 +758,15 @@ async function handleHotPayload(runner, payload) {
         if (!clearEntrypointUrls.size) break;
         hmrClient.logger.debug("program reload"), await hmrClient.notifyListeners("vite:beforeFullReload", payload), runner.evaluatedModules.clear();
         for (const url of clearEntrypointUrls)
-          await runner.import(url);
+          try {
+            await runner.import(url);
+          } catch (err) {
+            err.code !== ERR_OUTDATED_OPTIMIZED_DEP && hmrClient.logger.error(
+              `An error happened during full reload
+${err.message}
+${err.stack}`
+            );
+          }
         break;
       }
       case "prune":
@@ -584,6 +782,8 @@ ${err.stack}`
         );
         break;
       }
+      case "ping":
+        break;
       default:
         return payload;
     }
@@ -847,15 +1047,47 @@ function enableSourceMapSupport(runner) {
     typeof runner.options.sourcemapInterceptor == "object" ? runner.options.sourcemapInterceptor : void 0
   );
 }
+class ESModulesEvaluator {
+  startOffset = getAsyncFunctionDeclarationPaddingLineCount();
+  async runInlinedModule(context, code) {
+    await new AsyncFunction(
+      ssrModuleExportsKey,
+      ssrImportMetaKey,
+      ssrImportKey,
+      ssrDynamicImportKey,
+      ssrExportAllKey,
+      // source map should already be inlined by Vite
+      '"use strict";' + code
+    )(
+      context[ssrModuleExportsKey],
+      context[ssrImportMetaKey],
+      context[ssrImportKey],
+      context[ssrDynamicImportKey],
+      context[ssrExportAllKey]
+    ), Object.seal(context[ssrModuleExportsKey]);
+  }
+  runExternalModule(filepath) {
+    return import(filepath);
+  }
+}
 class ModuleRunner {
-  constructor(options, evaluator, debug) {
+  constructor(options, evaluator = new ESModulesEvaluator(), debug) {
     this.options = options, this.evaluator = evaluator, this.debug = debug;
     const root = this.options.root;
-    this.root = root[root.length - 1] === "/" ? root : `${root}/`, this.evaluatedModules = options.evaluatedModules ?? new EvaluatedModules(), this.transport = options.transport, typeof options.hmr == "object" && (this.hmrClient = new HMRClient(
-      options.hmr.logger === !1 ? silentConsole : options.hmr.logger || hmrLogger,
-      options.hmr.connection,
-      ({ acceptedPath }) => this.import(acceptedPath)
-    ), options.hmr.connection.onUpdate(createHMRHandler(this))), options.sourcemapInterceptor !== !1 && (this.resetSourceMapSupport = enableSourceMapSupport(this));
+    if (this.root = root[root.length - 1] === "/" ? root : `${root}/`, this.evaluatedModules = options.evaluatedModules ?? new EvaluatedModules(), this.transport = normalizeModuleRunnerTransport(options.transport), options.hmr !== !1) {
+      const optionsHmr = options.hmr ?? !0, resolvedHmrLogger = optionsHmr === !0 || optionsHmr.logger === void 0 ? hmrLogger : optionsHmr.logger === !1 ? silentConsole : optionsHmr.logger;
+      if (this.hmrClient = new HMRClient(
+        resolvedHmrLogger,
+        this.transport,
+        ({ acceptedPath }) => this.import(acceptedPath)
+      ), !this.transport.connect)
+        throw new Error(
+          "HMR is not supported by this runner transport, but `hmr` option was set to true"
+        );
+      this.transport.connect(createHMRHandler(this));
+    } else
+      this.transport.connect?.();
+    options.sourcemapInterceptor !== !1 && (this.resetSourceMapSupport = enableSourceMapSupport(this));
   }
   evaluatedModules;
   hmrClient;
@@ -889,7 +1121,7 @@ class ModuleRunner {
    * This method doesn't stop the HMR connection.
    */
   async close() {
-    this.resetSourceMapSupport?.(), this.clearCache(), this.hmrClient = void 0, this.closed = !0;
+    this.resetSourceMapSupport?.(), this.clearCache(), this.hmrClient = void 0, this.closed = !0, await this.transport.disconnect?.();
   }
   /**
    * Returns `true` if the runtime has been closed by calling `close()` method.
@@ -965,10 +1197,14 @@ ${getStack()}`
     this.debug?.("[module runner] fetching", url);
     const isCached = !!(typeof cachedModule == "object" && cachedModule.meta), fetchedModule = (
       // fast return for established externalized pattern
-      url.startsWith("data:") ? { externalize: url, type: "builtin" } : await this.transport.fetchModule(url, importer, {
-        cached: isCached,
-        startOffset: this.evaluator.startOffset
-      })
+      url.startsWith("data:") ? { externalize: url, type: "builtin" } : await this.transport.invoke("fetchModule", [
+        url,
+        importer,
+        {
+          cached: isCached,
+          startOffset: this.evaluator.startOffset
+        }
+      ])
     );
     if ("cache" in fetchedModule) {
       if (!cachedModule || !cachedModule.meta)
@@ -1057,72 +1293,11 @@ function exportAll(exports, sourceModule) {
         }
   }
 }
-class ESModulesEvaluator {
-  startOffset = getAsyncFunctionDeclarationPaddingLineCount();
-  async runInlinedModule(context, code) {
-    await new AsyncFunction(
-      ssrModuleExportsKey,
-      ssrImportMetaKey,
-      ssrImportKey,
-      ssrDynamicImportKey,
-      ssrExportAllKey,
-      // source map should already be inlined by Vite
-      '"use strict";' + code
-    )(
-      context[ssrModuleExportsKey],
-      context[ssrImportMetaKey],
-      context[ssrImportKey],
-      context[ssrDynamicImportKey],
-      context[ssrExportAllKey]
-    ), Object.seal(context[ssrModuleExportsKey]);
-  }
-  runExternalModule(filepath) {
-    return import(filepath);
-  }
-}
-let urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict", nanoid = (size = 21) => {
-  let id = "", i = size;
-  for (; i--; )
-    id += urlAlphabet[Math.random() * 64 | 0];
-  return id;
-};
-class RemoteRunnerTransport {
-  constructor(options) {
-    this.options = options, this.options.onMessage(async (data) => {
-      if (typeof data != "object" || !data || !data.__v) return;
-      const promise = this.rpcPromises.get(data.i);
-      promise && (promise.timeoutId && clearTimeout(promise.timeoutId), this.rpcPromises.delete(data.i), data.e ? promise.reject(data.e) : promise.resolve(data.r));
-    });
-  }
-  rpcPromises = /* @__PURE__ */ new Map();
-  resolve(method, ...args) {
-    const promiseId = nanoid();
-    return this.options.send({
-      __v: !0,
-      m: method,
-      a: args,
-      i: promiseId
-    }), new Promise((resolve2, reject) => {
-      const timeout = this.options.timeout ?? 6e4;
-      let timeoutId;
-      timeout > 0 && (timeoutId = setTimeout(() => {
-        this.rpcPromises.delete(promiseId), reject(
-          new Error(
-            `${method}(${args.map((arg) => JSON.stringify(arg)).join(", ")}) timed out after ${timeout}ms`
-          )
-        );
-      }, timeout), timeoutId?.unref?.()), this.rpcPromises.set(promiseId, { resolve: resolve2, reject, timeoutId });
-    });
-  }
-  fetchModule(id, importer) {
-    return this.resolve("fetchModule", id, importer);
-  }
-}
 export {
   ESModulesEvaluator,
   EvaluatedModules,
   ModuleRunner,
-  RemoteRunnerTransport,
+  createWebSocketModuleRunnerTransport,
   ssrDynamicImportKey,
   ssrExportAllKey,
   ssrImportKey,