vite 6.0.0-beta.8 → 6.0.0

package/dist/client/client.mjs

@@ -94,7 +94,7 @@ class HMRContext {
     removeFromMap(this.newListeners);
   }
   send(event, data) {
-    this.hmrClient.messenger.send({ type: "custom", event, data });
+    this.hmrClient.send({ type: "custom", event, data });
   }
   acceptDeps(deps, callback = () => {
   }) {
@@ -109,25 +109,10 @@ class HMRContext {
     this.hmrClient.hotModulesMap.set(this.ownerPath, mod);
   }
 }
-class HMRMessenger {
-  constructor(connection) {
-    this.connection = connection;
-    this.queue = [];
-  }
-  send(payload) {
-    this.queue.push(payload);
-    this.flush();
-  }
-  flush() {
-    if (this.connection.isReady()) {
-      this.queue.forEach((msg) => this.connection.send(msg));
-      this.queue = [];
-    }
-  }
-}
 class HMRClient {
-  constructor(logger, connection, importUpdatedModule) {
+  constructor(logger, transport, importUpdatedModule) {
     this.logger = logger;
+    this.transport = transport;
     this.importUpdatedModule = importUpdatedModule;
     this.hotModulesMap = /* @__PURE__ */ new Map();
     this.disposeMap = /* @__PURE__ */ new Map();
@@ -137,7 +122,6 @@ class HMRClient {
     this.ctxToListenersMap = /* @__PURE__ */ new Map();
     this.updateQueue = [];
     this.pendingUpdateQueue = false;
-    this.messenger = new HMRMessenger(connection);
   }
   async notifyListeners(event, data) {
     const cbs = this.customListenersMap.get(event);
@@ -145,6 +129,11 @@ class HMRClient {
       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();
@@ -226,6 +215,265 @@ class HMRClient {
   }
 }
 
+let urlAlphabet =
+  'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict';
+let nanoid = (size = 21) => {
+  let id = '';
+  let i = size;
+  while (i--) {
+    id += urlAlphabet[(Math.random() * 64) | 0];
+  }
+  return id
+};
+
+typeof process !== "undefined" && process.platform === "win32";
+function promiseWithResolvers() {
+  let resolve;
+  let reject;
+  const promise = new Promise((_resolve, _reject) => {
+    resolve = _resolve;
+    reject = _reject;
+  });
+  return { promise, resolve, reject };
+}
+
+function reviveInvokeError(e) {
+  const error = new Error(e.message || "Unknown invoke error");
+  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")
+  });
+  return 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("response:".length);
+              const promise = rpcPromises.get(invokeId);
+              if (!promise) return;
+              if (promise.timeoutId) clearTimeout(promise.timeoutId);
+              rpcPromises.delete(invokeId);
+              const { e, r } = data.data;
+              if (e) {
+                promise.reject(e);
+              } else {
+                promise.resolve(r);
+              }
+              return;
+            }
+          }
+          onMessage(payload);
+        },
+        onDisconnection
+      });
+    },
+    disconnect() {
+      rpcPromises.forEach((promise) => {
+        promise.reject(
+          new Error(
+            `transport was disconnected, cannot call ${JSON.stringify(promise.name)}`
+          )
+        );
+      });
+      rpcPromises.clear();
+      return transport.disconnect?.();
+    },
+    send(data) {
+      return transport.send(data);
+    },
+    async invoke(name, data) {
+      const promiseId = nanoid();
+      const wrappedData = {
+        type: "custom",
+        event: "vite:invoke",
+        data: {
+          name,
+          id: `send:${promiseId}`,
+          data
+        }
+      };
+      const sendPromise = transport.send(wrappedData);
+      const { promise, resolve, reject } = promiseWithResolvers();
+      const timeout = transport.timeout ?? 6e4;
+      let timeoutId;
+      if (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, reject, name, timeoutId });
+      if (sendPromise) {
+        sendPromise.catch((err) => {
+          clearTimeout(timeoutId);
+          rpcPromises.delete(promiseId);
+          reject(err);
+        });
+      }
+      try {
+        return await promise;
+      } catch (err) {
+        throw reviveInvokeError(err);
+      }
+    }
+  };
+};
+const normalizeModuleRunnerTransport = (transport) => {
+  const invokeableTransport = createInvokeableTransport(transport);
+  let isConnected = !invokeableTransport.connect;
+  let connectingPromise;
+  return {
+    ...transport,
+    ...invokeableTransport.connect ? {
+      async connect(onMessage) {
+        if (isConnected) return;
+        if (connectingPromise) {
+          await connectingPromise;
+          return;
+        }
+        const maybePromise = invokeableTransport.connect({
+          onMessage: onMessage ?? (() => {
+          }),
+          onDisconnection() {
+            isConnected = false;
+          }
+        });
+        if (maybePromise) {
+          connectingPromise = maybePromise;
+          await connectingPromise;
+          connectingPromise = void 0;
+        }
+        isConnected = true;
+      }
+    } : {},
+    ...invokeableTransport.disconnect ? {
+      async disconnect() {
+        if (!isConnected) return;
+        if (connectingPromise) {
+          await connectingPromise;
+        }
+        isConnected = false;
+        await invokeableTransport.disconnect();
+      }
+    } : {},
+    async send(data) {
+      if (!invokeableTransport.send) return;
+      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);
+    }
+  };
+};
+const createWebSocketModuleRunnerTransport = (options) => {
+  const pingInterval = options.pingInterval ?? 3e4;
+  let ws;
+  let 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;
+      if (!isOpened) {
+        await new Promise((resolve, reject) => {
+          socket.addEventListener(
+            "open",
+            () => {
+              isOpened = true;
+              resolve();
+            },
+            { once: true }
+          );
+          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(() => {
+        if (socket.readyState === socket.OPEN) {
+          socket.send(JSON.stringify({ type: "ping" }));
+        }
+      }, pingInterval);
+    },
+    disconnect() {
+      clearInterval(pingIntervalId);
+      ws?.close();
+    },
+    send(data) {
+      ws.send(JSON.stringify(data));
+    }
+  };
+};
+
 const hmrConfigName = __HMR_CONFIG_NAME__;
 const base$1 = __BASE__ || "/";
 function h(e, attrs = {}, ...children) {
@@ -501,65 +749,64 @@ const hmrPort = __HMR_PORT__;
 const socketHost = `${__HMR_HOSTNAME__ || importMetaUrl.hostname}:${hmrPort || importMetaUrl.port}${__HMR_BASE__}`;
 const directSocketHost = __HMR_DIRECT_TARGET__;
 const base = __BASE__ || "/";
-let socket;
-try {
-  let fallback;
-  if (!hmrPort) {
-    fallback = () => {
-      socket = setupWebSocket(socketProtocol, directSocketHost, () => {
-        const currentScriptHostURL = new URL(import.meta.url);
-        const currentScriptHost = currentScriptHostURL.host + currentScriptHostURL.pathname.replace(/@vite\/client$/, "");
-        console.error(
-          `[vite] failed to connect to websocket.
+const hmrTimeout = __HMR_TIMEOUT__;
+const transport = normalizeModuleRunnerTransport(
+  (() => {
+    let wsTransport = createWebSocketModuleRunnerTransport({
+      createConnection: () => new WebSocket(`${socketProtocol}://${socketHost}`, "vite-hmr"),
+      pingInterval: hmrTimeout
+    });
+    return {
+      async connect(handlers) {
+        try {
+          await wsTransport.connect(handlers);
+        } catch (e) {
+          if (!hmrPort) {
+            wsTransport = createWebSocketModuleRunnerTransport({
+              createConnection: () => new WebSocket(
+                `${socketProtocol}://${directSocketHost}`,
+                "vite-hmr"
+              ),
+              pingInterval: hmrTimeout
+            });
+            try {
+              await wsTransport.connect(handlers);
+              console.info(
+                "[vite] Direct websocket connection fallback. Check out https://vite.dev/config/server-options.html#server-hmr to remove the previous connection error."
+              );
+            } catch (e2) {
+              if (e2 instanceof Error && e2.message.includes("WebSocket closed without opened.")) {
+                const currentScriptHostURL = new URL(import.meta.url);
+                const currentScriptHost = currentScriptHostURL.host + currentScriptHostURL.pathname.replace(/@vite\/client$/, "");
+                console.error(
+                  `[vite] failed to connect to websocket.
 your current setup:
   (browser) ${currentScriptHost} <--[HTTP]--> ${serverHost} (server)
   (browser) ${socketHost} <--[WebSocket (failing)]--> ${directSocketHost} (server)
 Check out your Vite / network configuration and https://vite.dev/config/server-options.html#server-hmr .`
-        );
-      });
-      socket.addEventListener(
-        "open",
-        () => {
-          console.info(
-            "[vite] Direct websocket connection fallback. Check out https://vite.dev/config/server-options.html#server-hmr to remove the previous connection error."
-          );
-        },
-        { once: true }
-      );
+                );
+              }
+            }
+            return;
+          }
+          console.error(`[vite] failed to connect to websocket (${e}). `);
+          throw e;
+        }
+      },
+      async disconnect() {
+        await wsTransport.disconnect();
+      },
+      send(data) {
+        wsTransport.send(data);
+      }
     };
-  }
-  socket = setupWebSocket(socketProtocol, socketHost, fallback);
-} catch (error) {
-  console.error(`[vite] failed to connect to websocket (${error}). `);
-}
-function setupWebSocket(protocol, hostAndPath, onCloseWithoutOpen) {
-  const socket2 = new WebSocket(`${protocol}://${hostAndPath}`, "vite-hmr");
-  let isOpened = false;
-  socket2.addEventListener(
-    "open",
-    () => {
-      isOpened = true;
-      notifyListeners("vite:ws:connect", { webSocket: socket2 });
-    },
-    { once: true }
-  );
-  socket2.addEventListener("message", async ({ data }) => {
-    handleMessage(JSON.parse(data));
-  });
-  socket2.addEventListener("close", async ({ wasClean }) => {
-    if (wasClean) return;
-    if (!isOpened && onCloseWithoutOpen) {
-      onCloseWithoutOpen();
-      return;
-    }
-    notifyListeners("vite:ws:disconnect", { webSocket: socket2 });
-    if (hasDocument) {
-      console.log(`[vite] server connection lost. Polling for restart...`);
-      await waitForSuccessfulPing(protocol, hostAndPath);
-      location.reload();
-    }
+  })()
+);
+let willUnload = false;
+if (typeof window !== "undefined") {
+  window.addEventListener("beforeunload", () => {
+    willUnload = true;
   });
-  return socket2;
 }
 function cleanUrl(pathname) {
   const url = new URL(pathname, "http://vite.dev");
@@ -586,10 +833,7 @@ const hmrClient = new HMRClient(
     error: (err) => console.error("[vite]", err),
     debug: (...msg) => console.debug("[vite]", ...msg)
   },
-  {
-    isReady: () => socket && socket.readyState === 1,
-    send: (payload) => socket.send(JSON.stringify(payload))
-  },
+  transport,
   async function importUpdatedModule({
     acceptedPath,
     timestamp,
@@ -612,16 +856,11 @@ const hmrClient = new HMRClient(
     return await importPromise;
   }
 );
+transport.connect(handleMessage);
 async function handleMessage(payload) {
   switch (payload.type) {
     case "connected":
       console.debug(`[vite] connected.`);
-      hmrClient.messenger.flush();
-      setInterval(() => {
-        if (socket.readyState === socket.OPEN) {
-          socket.send('{"type":"ping"}');
-        }
-      }, __HMR_TIMEOUT__);
       break;
     case "update":
       notifyListeners("vite:beforeUpdate", payload);
@@ -671,6 +910,14 @@ async function handleMessage(payload) {
       break;
     case "custom": {
       notifyListeners(payload.event, payload.data);
+      if (payload.event === "vite:ws:disconnect") {
+        if (hasDocument && !willUnload) {
+          console.log(`[vite] server connection lost. Polling for restart...`);
+          const socket = payload.data.webSocket;
+          await waitForSuccessfulPing(socket.url);
+          location.reload();
+        }
+      }
       break;
     }
     case "full-reload":
@@ -708,6 +955,8 @@ ${err.stack}`
       }
       break;
     }
+    case "ping":
+      break;
     default: {
       const check = payload;
       return check;
@@ -721,7 +970,11 @@ const enableOverlay = __HMR_ENABLE_OVERLAY__;
 const hasDocument = "document" in globalThis;
 function createErrorOverlay(err) {
   clearErrorOverlay();
-  document.body.appendChild(new ErrorOverlay(err));
+  const { customElements } = globalThis;
+  if (customElements) {
+    const ErrorOverlayConstructor = customElements.get(overlayId);
+    document.body.appendChild(new ErrorOverlayConstructor(err));
+  }
 }
 function clearErrorOverlay() {
   document.querySelectorAll(overlayId).forEach((n) => n.close());
@@ -729,12 +982,9 @@ function clearErrorOverlay() {
 function hasErrorOverlay() {
   return document.querySelectorAll(overlayId).length;
 }
-async function waitForSuccessfulPing(socketProtocol2, hostAndPath, ms = 1e3) {
+async function waitForSuccessfulPing(socketUrl, ms = 1e3) {
   async function ping() {
-    const socket2 = new WebSocket(
-      `${socketProtocol2}://${hostAndPath}`,
-      "vite-ping"
-    );
+    const socket = new WebSocket(socketUrl, "vite-ping");
     return new Promise((resolve) => {
       function onOpen() {
         resolve(true);
@@ -745,12 +995,12 @@ async function waitForSuccessfulPing(socketProtocol2, hostAndPath, ms = 1e3) {
         close();
       }
       function close() {
-        socket2.removeEventListener("open", onOpen);
-        socket2.removeEventListener("error", onError);
-        socket2.close();
+        socket.removeEventListener("open", onOpen);
+        socket.removeEventListener("error", onError);
+        socket.close();
       }
-      socket2.addEventListener("open", onOpen);
-      socket2.addEventListener("error", onError);
+      socket.addEventListener("open", onOpen);
+      socket.addEventListener("error", onError);
     });
   }
   if (await ping()) {