vite 6.0.0-beta.0 → 6.0.0-beta.10

package/README.md

@@ -11,10 +11,10 @@
 
 Vite (French word for "fast", pronounced `/vit/`) is a new breed of frontend build tool that significantly improves the frontend development experience. It consists of two major parts:
 
-- A dev server that serves your source files over [native ES modules](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Modules), with [rich built-in features](https://vitejs.dev/guide/features.html) and astonishingly fast [Hot Module Replacement (HMR)](https://vitejs.dev/guide/features.html#hot-module-replacement).
+- A dev server that serves your source files over [native ES modules](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Modules), with [rich built-in features](https://vite.dev/guide/features.html) and astonishingly fast [Hot Module Replacement (HMR)](https://vite.dev/guide/features.html#hot-module-replacement).
 
-- A [build command](https://vitejs.dev/guide/build.html) that bundles your code with [Rollup](https://rollupjs.org), pre-configured to output highly optimized static assets for production.
+- A [build command](https://vite.dev/guide/build.html) that bundles your code with [Rollup](https://rollupjs.org), pre-configured to output highly optimized static assets for production.
 
-In addition, Vite is highly extensible via its [Plugin API](https://vitejs.dev/guide/api-plugin.html) and [JavaScript API](https://vitejs.dev/guide/api-javascript.html) with full typing support.
+In addition, Vite is highly extensible via its [Plugin API](https://vite.dev/guide/api-plugin.html) and [JavaScript API](https://vite.dev/guide/api-javascript.html) with full typing support.
 
-[Read the Docs to Learn More](https://vitejs.dev).
+[Read the Docs to Learn More](https://vite.dev).

package/bin/vite.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import { performance } from 'node:perf_hooks'
+import module from 'node:module'
 
 if (!import.meta.url.includes('node_modules')) {
   try {
@@ -41,6 +42,10 @@ if (debugIndex > 0) {
 }
 
 function start() {
+  try {
+    // eslint-disable-next-line n/no-unsupported-features/node-builtins -- it is supported in Node 22.8.0+ and only called if it exists
+    module.enableCompileCache?.()
+  } catch {}
   return import('../dist/node/cli.js')
 }
 

package/client.d.ts

@@ -247,6 +247,16 @@ declare module '*?inline' {
   export default src
 }
 
+declare module '*?no-inline' {
+  const src: string
+  export default src
+}
+
+declare module '*?url&inline' {
+  const src: string
+  export default src
+}
+
 declare interface VitePreloadErrorEvent extends Event {
   payload: Error
 }

package/dist/client/client.mjs

@@ -94,9 +94,7 @@ class HMRContext {
     removeFromMap(this.newListeners);
   }
   send(event, data) {
-    this.hmrClient.messenger.send(
-      JSON.stringify({ type: "custom", event, data })
-    );
+    this.hmrClient.send({ type: "custom", event, data });
   }
   acceptDeps(deps, callback = () => {
   }) {
@@ -111,25 +109,10 @@ class HMRContext {
     this.hmrClient.hotModulesMap.set(this.ownerPath, mod);
   }
 }
-class HMRMessenger {
-  constructor(connection) {
-    this.connection = connection;
-    this.queue = [];
-  }
-  send(message) {
-    this.queue.push(message);
-    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();
@@ -139,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);
@@ -147,6 +129,9 @@ class HMRClient {
       await Promise.allSettled(cbs.map((cb) => cb(data)));
     }
   }
+  send(payload) {
+    this.transport.send(payload);
+  }
   clear() {
     this.hotModulesMap.clear();
     this.disposeMap.clear();
@@ -157,7 +142,7 @@ class HMRClient {
   }
   // After an HMR update, some modules are no longer imported on the page
   // but they may have left behind side effects that need to be cleaned up
-  // (.e.g style injections)
+  // (e.g. style injections)
   async prunePaths(paths) {
     await Promise.all(
       paths.map((path) => {
@@ -228,6 +213,255 @@ 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) {
+  return Object.assign(new Error(e.message || "Unknown invoke error"), e);
+}
+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(reviveInvokeError(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);
+        });
+      }
+      return await promise;
+    }
+  };
+};
+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) {
@@ -503,68 +737,67 @@ 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://vitejs.dev/config/server-options.html#server-hmr .`
-        );
-      });
-      socket.addEventListener(
-        "open",
-        () => {
-          console.info(
-            "[vite] Direct websocket connection fallback. Check out https://vitejs.dev/config/server-options.html#server-hmr to remove the previous connection error."
-          );
-        },
-        { once: true }
-      );
+Check out your Vite / network configuration and https://vite.dev/config/server-options.html#server-hmr .`
+                );
+              }
+            }
+            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://vitejs.dev");
+  const url = new URL(pathname, "http://vite.dev");
   url.searchParams.delete("direct");
   return url.pathname + url.search;
 }
@@ -588,10 +821,7 @@ const hmrClient = new HMRClient(
     error: (err) => console.error("[vite]", err),
     debug: (...msg) => console.debug("[vite]", ...msg)
   },
-  {
-    isReady: () => socket && socket.readyState === 1,
-    send: (message) => socket.send(message)
-  },
+  transport,
   async function importUpdatedModule({
     acceptedPath,
     timestamp,
@@ -614,16 +844,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);
@@ -673,6 +898,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":
@@ -710,6 +943,8 @@ ${err.stack}`
       }
       break;
     }
+    case "ping":
+      break;
     default: {
       const check = payload;
       return check;
@@ -731,23 +966,27 @@ function clearErrorOverlay() {
 function hasErrorOverlay() {
   return document.querySelectorAll(overlayId).length;
 }
-async function waitForSuccessfulPing(socketProtocol2, hostAndPath, ms = 1e3) {
-  const pingHostProtocol = socketProtocol2 === "wss" ? "https" : "http";
-  const ping = async () => {
-    try {
-      await fetch(`${pingHostProtocol}://${hostAndPath}`, {
-        mode: "no-cors",
-        headers: {
-          // Custom headers won't be included in a request with no-cors so (ab)use one of the
-          // safelisted headers to identify the ping request
-          Accept: "text/x-vite-ping"
-        }
-      });
-      return true;
-    } catch {
-    }
-    return false;
-  };
+async function waitForSuccessfulPing(socketUrl, ms = 1e3) {
+  async function ping() {
+    const socket = new WebSocket(socketUrl, "vite-ping");
+    return new Promise((resolve) => {
+      function onOpen() {
+        resolve(true);
+        close();
+      }
+      function onError() {
+        resolve(false);
+        close();
+      }
+      function close() {
+        socket.removeEventListener("open", onOpen);
+        socket.removeEventListener("error", onError);
+        socket.close();
+      }
+      socket.addEventListener("open", onOpen);
+      socket.addEventListener("error", onError);
+    });
+  }
   if (await ping()) {
     return;
   }
@@ -824,7 +1063,7 @@ function injectQuery(url, queryToInject) {
     return url;
   }
   const pathname = url.replace(/[?#].*$/, "");
-  const { search, hash } = new URL(url, "http://vitejs.dev");
+  const { search, hash } = new URL(url, "http://vite.dev");
   return `${pathname}?${queryToInject}${search ? `&` + search.slice(1) : ""}${hash || ""}`;
 }
 

package/dist/node/chunks/{dep-IQS-Za7F.js → dep-3RmXg9uo.js}

@@ -1,11 +1,3 @@
-import { fileURLToPath as __cjs_fileURLToPath } from 'node:url';
-import { dirname as __cjs_dirname } from 'node:path';
-import { createRequire as __cjs_createRequire } from 'node:module';
-
-const __filename = __cjs_fileURLToPath(import.meta.url);
-const __dirname = __cjs_dirname(__filename);
-const require = __cjs_createRequire(import.meta.url);
-const __require = require;
 var openParentheses = "(".charCodeAt(0);
 var closeParentheses = ")".charCodeAt(0);
 var singleQuote = "'".charCodeAt(0);