vite 5.0.4 → 5.0.6

package/LICENSE.md

@@ -579,6 +579,28 @@ License: MIT
 By: Rich Harris
 Repository: rollup/plugins
 
+> The MIT License (MIT)
+> 
+> Copyright (c) 2019 RollupJS Plugin Contributors (https://github.com/rollup/plugins/graphs/contributors)
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.
+
 ---------------------------------------
 
 ## acorn

package/client.d.ts

@@ -128,11 +128,14 @@ declare module '*.aac' {
   const src: string
   export default src
 }
-
 declare module '*.opus' {
   const src: string
   export default src
 }
+declare module '*.mov' {
+  const src: string
+  export default src
+}
 
 // fonts
 declare module '*.woff' {

package/dist/client/client.mjs

@@ -1,5 +1,187 @@
 import '@vite/env';
 
+class HMRContext {
+    constructor(ownerPath, hmrClient, connection) {
+        this.ownerPath = ownerPath;
+        this.hmrClient = hmrClient;
+        this.connection = connection;
+        if (!hmrClient.dataMap.has(ownerPath)) {
+            hmrClient.dataMap.set(ownerPath, {});
+        }
+        // when a file is hot updated, a new context is created
+        // clear its stale callbacks
+        const mod = hmrClient.hotModulesMap.get(ownerPath);
+        if (mod) {
+            mod.callbacks = [];
+        }
+        // clear stale custom event listeners
+        const staleListeners = hmrClient.ctxToListenersMap.get(ownerPath);
+        if (staleListeners) {
+            for (const [event, staleFns] of staleListeners) {
+                const listeners = hmrClient.customListenersMap.get(event);
+                if (listeners) {
+                    hmrClient.customListenersMap.set(event, listeners.filter((l) => !staleFns.includes(l)));
+                }
+            }
+        }
+        this.newListeners = new Map();
+        hmrClient.ctxToListenersMap.set(ownerPath, this.newListeners);
+    }
+    get data() {
+        return this.hmrClient.dataMap.get(this.ownerPath);
+    }
+    accept(deps, callback) {
+        if (typeof deps === 'function' || !deps) {
+            // self-accept: hot.accept(() => {})
+            this.acceptDeps([this.ownerPath], ([mod]) => deps === null || deps === void 0 ? void 0 : deps(mod));
+        }
+        else if (typeof deps === 'string') {
+            // explicit deps
+            this.acceptDeps([deps], ([mod]) => callback === null || callback === void 0 ? void 0 : callback(mod));
+        }
+        else if (Array.isArray(deps)) {
+            this.acceptDeps(deps, callback);
+        }
+        else {
+            throw new Error(`invalid hot.accept() usage.`);
+        }
+    }
+    // export names (first arg) are irrelevant on the client side, they're
+    // extracted in the server for propagation
+    acceptExports(_, callback) {
+        this.acceptDeps([this.ownerPath], ([mod]) => callback === null || callback === void 0 ? void 0 : callback(mod));
+    }
+    dispose(cb) {
+        this.hmrClient.disposeMap.set(this.ownerPath, cb);
+    }
+    prune(cb) {
+        this.hmrClient.pruneMap.set(this.ownerPath, cb);
+    }
+    // Kept for backward compatibility (#11036)
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    decline() { }
+    invalidate(message) {
+        this.hmrClient.notifyListeners('vite:invalidate', {
+            path: this.ownerPath,
+            message,
+        });
+        this.send('vite:invalidate', { path: this.ownerPath, message });
+        this.hmrClient.logger.debug(`[vite] invalidate ${this.ownerPath}${message ? `: ${message}` : ''}`);
+    }
+    on(event, cb) {
+        const addToMap = (map) => {
+            const existing = map.get(event) || [];
+            existing.push(cb);
+            map.set(event, existing);
+        };
+        addToMap(this.hmrClient.customListenersMap);
+        addToMap(this.newListeners);
+    }
+    off(event, cb) {
+        const removeFromMap = (map) => {
+            const existing = map.get(event);
+            if (existing === undefined) {
+                return;
+            }
+            const pruned = existing.filter((l) => l !== cb);
+            if (pruned.length === 0) {
+                map.delete(event);
+                return;
+            }
+            map.set(event, pruned);
+        };
+        removeFromMap(this.hmrClient.customListenersMap);
+        removeFromMap(this.newListeners);
+    }
+    send(event, data) {
+        this.connection.addBuffer(JSON.stringify({ type: 'custom', event, data }));
+        this.connection.send();
+    }
+    acceptDeps(deps, callback = () => { }) {
+        const mod = this.hmrClient.hotModulesMap.get(this.ownerPath) || {
+            id: this.ownerPath,
+            callbacks: [],
+        };
+        mod.callbacks.push({
+            deps,
+            fn: callback,
+        });
+        this.hmrClient.hotModulesMap.set(this.ownerPath, mod);
+    }
+}
+class HMRClient {
+    constructor(logger, 
+    // this allows up to implement reloading via different methods depending on the environment
+    importUpdatedModule) {
+        this.logger = logger;
+        this.importUpdatedModule = importUpdatedModule;
+        this.hotModulesMap = new Map();
+        this.disposeMap = new Map();
+        this.pruneMap = new Map();
+        this.dataMap = new Map();
+        this.customListenersMap = new Map();
+        this.ctxToListenersMap = new Map();
+    }
+    async notifyListeners(event, data) {
+        const cbs = this.customListenersMap.get(event);
+        if (cbs) {
+            await Promise.allSettled(cbs.map((cb) => cb(data)));
+        }
+    }
+    // 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)
+    // TODO Trigger their dispose callbacks.
+    prunePaths(paths) {
+        paths.forEach((path) => {
+            const fn = this.pruneMap.get(path);
+            if (fn) {
+                fn(this.dataMap.get(path));
+            }
+        });
+    }
+    warnFailedUpdate(err, path) {
+        if (!err.message.includes('fetch')) {
+            this.logger.error(err);
+        }
+        this.logger.error(`[hmr] Failed to reload ${path}. ` +
+            `This could be due to syntax errors or importing non-existent ` +
+            `modules. (see errors above)`);
+    }
+    async fetchUpdate(update) {
+        const { path, acceptedPath } = update;
+        const mod = this.hotModulesMap.get(path);
+        if (!mod) {
+            // In a code-splitting project,
+            // it is common that the hot-updating module is not loaded yet.
+            // https://github.com/vitejs/vite/issues/721
+            return;
+        }
+        let fetchedModule;
+        const isSelfUpdate = path === acceptedPath;
+        // determine the qualified callbacks before we re-import the modules
+        const qualifiedCallbacks = mod.callbacks.filter(({ deps }) => deps.includes(acceptedPath));
+        if (isSelfUpdate || qualifiedCallbacks.length > 0) {
+            const disposer = this.disposeMap.get(acceptedPath);
+            if (disposer)
+                await disposer(this.dataMap.get(acceptedPath));
+            try {
+                fetchedModule = await this.importUpdatedModule(update);
+            }
+            catch (e) {
+                this.warnFailedUpdate(e, acceptedPath);
+            }
+        }
+        return () => {
+            for (const { deps, fn } of qualifiedCallbacks) {
+                fn(deps.map((dep) => (dep === acceptedPath ? fetchedModule : undefined)));
+            }
+            const loggedPath = isSelfUpdate ? path : `${acceptedPath} via ${path}`;
+            this.logger.debug(`[vite] hot updated: ${loggedPath}`);
+        };
+    }
+}
+
 const hmrConfigName = __HMR_CONFIG_NAME__;
 const base$1 = __BASE__ || '/';
 // set :host styles to make playwright detect the element as visible
@@ -305,14 +487,6 @@ function setupWebSocket(protocol, hostAndPath, onCloseWithoutOpen) {
     });
     return socket;
 }
-function warnFailedFetch(err, path) {
-    if (!err.message.match('fetch')) {
-        console.error(err);
-    }
-    console.error(`[hmr] Failed to reload ${path}. ` +
-        `This could be due to syntax errors or importing non-existent ` +
-        `modules. (see errors above)`);
-}
 function cleanUrl(pathname) {
     const url = new URL(pathname, location.toString());
     url.searchParams.delete('direct');
@@ -333,6 +507,14 @@ const debounceReload = (time) => {
     };
 };
 const pageReload = debounceReload(50);
+const hmrClient = new HMRClient(console, async function importUpdatedModule({ acceptedPath, timestamp, explicitImportRequired, }) {
+    const [acceptedPathWithoutQuery, query] = acceptedPath.split(`?`);
+    return await import(
+    /* @vite-ignore */
+    base +
+        acceptedPathWithoutQuery.slice(1) +
+        `?${explicitImportRequired ? 'import&' : ''}t=${timestamp}${query ? `&${query}` : ''}`);
+});
 async function handleMessage(payload) {
     switch (payload.type) {
         case 'connected':
@@ -362,7 +544,7 @@ async function handleMessage(payload) {
             }
             await Promise.all(payload.updates.map(async (update) => {
                 if (update.type === 'js-update') {
-                    return queueUpdate(fetchUpdate(update));
+                    return queueUpdate(hmrClient.fetchUpdate(update));
                 }
                 // css-update
                 // this is only sent when a css file referenced with <link> is updated
@@ -421,16 +603,7 @@ async function handleMessage(payload) {
             break;
         case 'prune':
             notifyListeners('vite:beforePrune', payload);
-            // 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)
-            // TODO Trigger their dispose callbacks.
-            payload.paths.forEach((path) => {
-                const fn = pruneMap.get(path);
-                if (fn) {
-                    fn(dataMap.get(path));
-                }
-            });
+            hmrClient.prunePaths(payload.paths);
             break;
         case 'error': {
             notifyListeners('vite:error', payload);
@@ -450,10 +623,7 @@ async function handleMessage(payload) {
     }
 }
 function notifyListeners(event, data) {
-    const cbs = customListenersMap.get(event);
-    if (cbs) {
-        cbs.forEach((cb) => cb(data));
-    }
+    hmrClient.notifyListeners(event, data);
 }
 const enableOverlay = __HMR_ENABLE_OVERLAY__;
 function createErrorOverlay(err) {
@@ -580,161 +750,21 @@ function removeStyle(id) {
         sheetsMap.delete(id);
     }
 }
-async function fetchUpdate({ path, acceptedPath, timestamp, explicitImportRequired, }) {
-    const mod = hotModulesMap.get(path);
-    if (!mod) {
-        // In a code-splitting project,
-        // it is common that the hot-updating module is not loaded yet.
-        // https://github.com/vitejs/vite/issues/721
-        return;
-    }
-    let fetchedModule;
-    const isSelfUpdate = path === acceptedPath;
-    // determine the qualified callbacks before we re-import the modules
-    const qualifiedCallbacks = mod.callbacks.filter(({ deps }) => deps.includes(acceptedPath));
-    if (isSelfUpdate || qualifiedCallbacks.length > 0) {
-        const disposer = disposeMap.get(acceptedPath);
-        if (disposer)
-            await disposer(dataMap.get(acceptedPath));
-        const [acceptedPathWithoutQuery, query] = acceptedPath.split(`?`);
-        try {
-            fetchedModule = await import(
-            /* @vite-ignore */
-            base +
-                acceptedPathWithoutQuery.slice(1) +
-                `?${explicitImportRequired ? 'import&' : ''}t=${timestamp}${query ? `&${query}` : ''}`);
-        }
-        catch (e) {
-            warnFailedFetch(e, acceptedPath);
-        }
-    }
-    return () => {
-        for (const { deps, fn } of qualifiedCallbacks) {
-            fn(deps.map((dep) => (dep === acceptedPath ? fetchedModule : undefined)));
-        }
-        const loggedPath = isSelfUpdate ? path : `${acceptedPath} via ${path}`;
-        console.debug(`[vite] hot updated: ${loggedPath}`);
-    };
-}
 function sendMessageBuffer() {
     if (socket.readyState === 1) {
         messageBuffer.forEach((msg) => socket.send(msg));
         messageBuffer.length = 0;
     }
 }
-const hotModulesMap = new Map();
-const disposeMap = new Map();
-const pruneMap = new Map();
-const dataMap = new Map();
-const customListenersMap = new Map();
-const ctxToListenersMap = new Map();
 function createHotContext(ownerPath) {
-    if (!dataMap.has(ownerPath)) {
-        dataMap.set(ownerPath, {});
-    }
-    // when a file is hot updated, a new context is created
-    // clear its stale callbacks
-    const mod = hotModulesMap.get(ownerPath);
-    if (mod) {
-        mod.callbacks = [];
-    }
-    // clear stale custom event listeners
-    const staleListeners = ctxToListenersMap.get(ownerPath);
-    if (staleListeners) {
-        for (const [event, staleFns] of staleListeners) {
-            const listeners = customListenersMap.get(event);
-            if (listeners) {
-                customListenersMap.set(event, listeners.filter((l) => !staleFns.includes(l)));
-            }
-        }
-    }
-    const newListeners = new Map();
-    ctxToListenersMap.set(ownerPath, newListeners);
-    function acceptDeps(deps, callback = () => { }) {
-        const mod = hotModulesMap.get(ownerPath) || {
-            id: ownerPath,
-            callbacks: [],
-        };
-        mod.callbacks.push({
-            deps,
-            fn: callback,
-        });
-        hotModulesMap.set(ownerPath, mod);
-    }
-    const hot = {
-        get data() {
-            return dataMap.get(ownerPath);
-        },
-        accept(deps, callback) {
-            if (typeof deps === 'function' || !deps) {
-                // self-accept: hot.accept(() => {})
-                acceptDeps([ownerPath], ([mod]) => deps === null || deps === void 0 ? void 0 : deps(mod));
-            }
-            else if (typeof deps === 'string') {
-                // explicit deps
-                acceptDeps([deps], ([mod]) => callback === null || callback === void 0 ? void 0 : callback(mod));
-            }
-            else if (Array.isArray(deps)) {
-                acceptDeps(deps, callback);
-            }
-            else {
-                throw new Error(`invalid hot.accept() usage.`);
-            }
+    return new HMRContext(ownerPath, hmrClient, {
+        addBuffer(message) {
+            messageBuffer.push(message);
         },
-        // export names (first arg) are irrelevant on the client side, they're
-        // extracted in the server for propagation
-        acceptExports(_, callback) {
-            acceptDeps([ownerPath], ([mod]) => callback === null || callback === void 0 ? void 0 : callback(mod));
-        },
-        dispose(cb) {
-            disposeMap.set(ownerPath, cb);
-        },
-        prune(cb) {
-            pruneMap.set(ownerPath, cb);
-        },
-        // Kept for backward compatibility (#11036)
-        // @ts-expect-error untyped
-        // eslint-disable-next-line @typescript-eslint/no-empty-function
-        decline() { },
-        // tell the server to re-perform hmr propagation from this module as root
-        invalidate(message) {
-            notifyListeners('vite:invalidate', { path: ownerPath, message });
-            this.send('vite:invalidate', { path: ownerPath, message });
-            console.debug(`[vite] invalidate ${ownerPath}${message ? `: ${message}` : ''}`);
-        },
-        // custom events
-        on(event, cb) {
-            const addToMap = (map) => {
-                const existing = map.get(event) || [];
-                existing.push(cb);
-                map.set(event, existing);
-            };
-            addToMap(customListenersMap);
-            addToMap(newListeners);
-        },
-        // remove a custom event
-        off(event, cb) {
-            const removeFromMap = (map) => {
-                const existing = map.get(event);
-                if (existing === undefined) {
-                    return;
-                }
-                const pruned = existing.filter((l) => l !== cb);
-                if (pruned.length === 0) {
-                    map.delete(event);
-                    return;
-                }
-                map.set(event, pruned);
-            };
-            removeFromMap(customListenersMap);
-            removeFromMap(newListeners);
-        },
-        send(event, data) {
-            messageBuffer.push(JSON.stringify({ type: 'custom', event, data }));
+        send() {
             sendMessageBuffer();
         },
-    };
-    return hot;
+    });
 }
 /**
  * urls here are dynamic import() urls that couldn't be statically analyzed