vite 8.2.0 → 8.2.2

package/LICENSE.md

@@ -1256,7 +1256,7 @@ Repository: https://github.com/lydell/js-tokens
 
 > The MIT License (MIT)
 > 
-> Copyright (c) 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023, 2024 Simon Lydell
+> Copyright (c) 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023, 2024, 2025 Simon Lydell
 > 
 > Permission is hereby granted, free of charge, to any person obtaining a copy
 > of this software and associated documentation files (the "Software"), to deal

package/dist/client/bundledDevClient.mjs

@@ -8,7 +8,40 @@ let nanoid = (size = 21) => {
 	return id;
 };
 //#endregion
-//#region \0@oxc-project+runtime@0.140.0/helpers/esm/typeof.js
+//#region ../../node_modules/.pnpm/rolldown@1.2.4/node_modules/rolldown/dist/experimental-runtime-base.mjs
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["module.exports"] : __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+//#endregion
+//#region \0@oxc-project+runtime@0.144.0/helpers/esm/typeof.js
 function _typeof(o) {
 	"@babel/helpers - typeof";
 	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
@@ -18,7 +51,7 @@ function _typeof(o) {
 	}, _typeof(o);
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.140.0/helpers/esm/toPrimitive.js
+//#region \0@oxc-project+runtime@0.144.0/helpers/esm/toPrimitive.js
 function toPrimitive(t, r) {
 	if ("object" != _typeof(t) || !t) return t;
 	var e = t[Symbol.toPrimitive];
@@ -30,13 +63,13 @@ function toPrimitive(t, r) {
 	return ("string" === r ? String : Number)(t);
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.140.0/helpers/esm/toPropertyKey.js
+//#region \0@oxc-project+runtime@0.144.0/helpers/esm/toPropertyKey.js
 function toPropertyKey(t) {
 	var i = toPrimitive(t, "string");
 	return "symbol" == _typeof(i) ? i : i + "";
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.140.0/helpers/esm/defineProperty.js
+//#region \0@oxc-project+runtime@0.144.0/helpers/esm/defineProperty.js
 function _defineProperty(e, r, t) {
 	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
 		value: t,
@@ -46,6 +79,283 @@ function _defineProperty(e, r, t) {
 	}) : e[r] = t, e;
 }
 //#endregion
+//#region ../../node_modules/.pnpm/rolldown@1.2.4/node_modules/rolldown/dist/experimental-runtime.mjs
+var Module = class {
+	/**
+	* @param {string} id
+	*/
+	constructor(id) {
+		_defineProperty(
+			this,
+			/**
+			* @type {{ exports: any }}
+			*/
+			"exportsHolder",
+			{ exports: null }
+		);
+		_defineProperty(
+			this,
+			/**
+			* @type {string}
+			*/
+			"id",
+			void 0
+		);
+		this.id = id;
+	}
+	get exports() {
+		return this.exportsHolder.exports;
+	}
+};
+/**
+* Compiler-emitted module-graph delta — pure topology (static + dynamic edges).
+* `ids[0, localCount)` are the modules this payload carries; `ids[localCount, …)` are foreign edge targets.
+* `edges[i]` / `dynamicEdges[i]` are the static / dynamic-`import()` out-edges of `ids[i]`.
+* @typedef {{ ids: string[], localCount: number, edges: number[][], dynamicEdges?: number[][] }} ModuleGraphDelta
+* @typedef {{ createModuleHotContext(moduleId: string): any, onModuleCacheRemoval(moduleId: string): void }} DevRuntimeHooks
+*/
+var MissingFactoryError = class extends Error {
+	/**
+	* @param {string} id
+	*/
+	constructor(id) {
+		super(`No factory registered for module ${id}`);
+		this.id = id;
+	}
+};
+var DevRuntime = class {
+	/**
+	* @param {string} clientId
+	*/
+	constructor(clientId) {
+		_defineProperty(
+			this,
+			/**
+			* Client ID generated at runtime initialization, used for lazy compilation requests.
+			* @type {string}
+			*/
+			"clientId",
+			void 0
+		);
+		_defineProperty(
+			this,
+			/**
+			* Static import edges from `registerGraph` — entries persist across `removeModuleCache`
+			* and change only by replacement from a newer payload (last write wins).
+			* @type {Map<string, { edges: string[] }>}
+			*/
+			"staticImports",
+			/* @__PURE__ */ new Map()
+		);
+		_defineProperty(
+			this,
+			/**
+			* Reverse index over the static imports.
+			* @type {Map<string, Set<string>>}
+			*/
+			"importers",
+			/* @__PURE__ */ new Map()
+		);
+		_defineProperty(
+			this,
+			/**
+			* Dynamic `import()` edges from `registerGraph`, keyed by importer — mirror of
+			* `staticImports` for the dynamic reverse index.
+			* @type {Map<string, { edges: string[] }>}
+			*/
+			"dynamicImports",
+			/* @__PURE__ */ new Map()
+		);
+		_defineProperty(
+			this,
+			/**
+			* Reverse index over the dynamic imports.
+			* @type {Map<string, Set<string>>}
+			*/
+			"dynamicImporters",
+			/* @__PURE__ */ new Map()
+		);
+		_defineProperty(
+			this,
+			/**
+			* The module cache. Membership means "this module's side effects ran in this tab" —
+			* registration is emitted ahead of every module body, and nothing un-registers on
+			* unwind, so a factory that throws mid-body stays registered. A `Map` rather than a
+			* plain object: HMR eviction deletes entries, and a `delete` on an object drops V8
+			* into dictionary mode, taxing every later lookup on the hottest read path.
+			* @type {Map<string, Module>}
+			*/
+			"moduleCache",
+			/* @__PURE__ */ new Map()
+		);
+		_defineProperty(
+			this,
+			/**
+			* Re-runnable factories from HMR patches and lazy chunks. The initial bundle stays
+			* scope-hoisted and contributes none.
+			* @type {Map<string, { kind: 'esm' | 'cjs', fn: (id: string) => void }>}
+			*/
+			"factories",
+			/* @__PURE__ */ new Map()
+		);
+		_defineProperty(
+			this,
+			/**
+			* Installed by the dev client at boot. The runtime is a store + executor and makes
+			* no HMR decisions; accepting, disposing, and reloading live behind these hooks.
+			* @type {DevRuntimeHooks | null}
+			*/
+			"hooks",
+			null
+		);
+		_defineProperty(
+			this,
+			/** @internal */
+			"__toESM",
+			__toESM
+		);
+		_defineProperty(
+			this,
+			/** @internal */
+			"__toCommonJS",
+			__toCommonJS
+		);
+		_defineProperty(
+			this,
+			/** @internal */
+			"__exportAll",
+			__exportAll
+		);
+		_defineProperty(
+			this,
+			/**
+			* @param {boolean} [isNodeMode]
+			* @returns {(mod: any) => any}
+			* @internal
+			*/
+			"__toDynamicImportESM",
+			(isNodeMode) => (mod) => __toESM(mod.default, isNodeMode)
+		);
+		_defineProperty(
+			this,
+			/** @internal */
+			"__reExport",
+			__reExport
+		);
+		this.clientId = clientId;
+	}
+	/**
+	* @param {ModuleGraphDelta} delta
+	*/
+	registerGraph(delta) {
+		for (let i = 0; i < delta.localCount; i++) {
+			const id = delta.ids[i];
+			const edges = delta.edges[i].map((j) => delta.ids[j]);
+			for (const target of this.staticImports.get(id)?.edges ?? []) this.importers.get(target)?.delete(id);
+			for (const target of edges) {
+				let importerSet = this.importers.get(target);
+				if (!importerSet) {
+					importerSet = /* @__PURE__ */ new Set();
+					this.importers.set(target, importerSet);
+				}
+				importerSet.add(id);
+			}
+			this.staticImports.set(id, { edges });
+			const dynamicEdges = (delta.dynamicEdges?.[i] ?? []).map((j) => delta.ids[j]);
+			for (const target of this.dynamicImports.get(id)?.edges ?? []) this.dynamicImporters.get(target)?.delete(id);
+			for (const target of dynamicEdges) {
+				let importerSet = this.dynamicImporters.get(target);
+				if (!importerSet) {
+					importerSet = /* @__PURE__ */ new Set();
+					this.dynamicImporters.set(target, importerSet);
+				}
+				importerSet.add(id);
+			}
+			this.dynamicImports.set(id, { edges: dynamicEdges });
+		}
+	}
+	/**
+	* @param {string} id
+	* @param {'esm' | 'cjs'} kind
+	* @param {(id: string) => void} fn
+	*/
+	registerFactory(id, kind, fn) {
+		this.factories.set(id, {
+			kind,
+			fn
+		});
+	}
+	/**
+	* @param {string} id
+	* @param {{ exports: any }} exportsHolder
+	*/
+	registerModule(id, exportsHolder) {
+		const module = new Module(id);
+		module.exportsHolder = exportsHolder;
+		this.moduleCache.set(id, module);
+	}
+	/**
+	* @param {string} id
+	* @returns {string[]}
+	*/
+	getImporters(id) {
+		const dynamic = this.dynamicImporters.get(id);
+		if (!dynamic || dynamic.size === 0) return [...this.importers.get(id) ?? []];
+		return [.../* @__PURE__ */ new Set([...this.importers.get(id) ?? [], ...dynamic])];
+	}
+	/**
+	* @param {string} id
+	*/
+	isExecuted(id) {
+		return this.moduleCache.has(id);
+	}
+	/**
+	* @param {string} id
+	*/
+	hasFactory(id) {
+		return this.factories.has(id);
+	}
+	/**
+	* Module-cache delete only — static imports and factories persist. Removal is what
+	* re-arms a cache-gated factory for `initModule`.
+	* @param {string} id
+	*/
+	removeModuleCache(id) {
+		this.moduleCache.delete(id);
+		this.hooks?.onModuleCacheRemoval(id);
+	}
+	/**
+	* The one re-execution gate: registered → return the live exports; otherwise run the
+	* mapped factory (which registers itself first, then runs the body).
+	* @param {string} id
+	*/
+	initModule(id) {
+		if (this.moduleCache.has(id)) return this.loadExports(id);
+		const factory = this.factories.get(id);
+		if (!factory) throw new MissingFactoryError(id);
+		factory.fn(id);
+		return this.loadExports(id);
+	}
+	/**
+	* @param {string} id
+	*/
+	loadExports(id) {
+		const module = this.moduleCache.get(id);
+		if (module) return module.exportsHolder.exports;
+		else {
+			console.warn(`Module ${id} not found`);
+			return {};
+		}
+	}
+	/**
+	* @param {string} moduleId
+	*/
+	createModuleHotContext(moduleId) {
+		if (this.hooks) return this.hooks.createModuleHotContext(moduleId);
+		throw new Error("createModuleHotContext requires installed hooks or an override");
+	}
+};
+//#endregion
 //#region src/shared/hmr.ts
 var HMRContext = class {
 	constructor(hmrClient, ownerPath) {
@@ -275,7 +585,11 @@ var BundledDevHMRClient = class extends HMRClient {
 			reason: `update propagated back to ${firstInvalidatedBy}, which already called \`import.meta.hot.invalidate()\``
 		};
 		if (this.isSelfAccepted(id)) {
-			boundaries.push([id, id]);
+			boundaries.push({
+				boundary: id,
+				acceptedVia: id,
+				isWithinCircularImport: this.isNodeWithinCircularImports(id, stack)
+			});
 			return;
 		}
 		const parents = this.runtime.getImporters(id).filter((p) => this.runtime.isExecuted(p));
@@ -284,17 +598,52 @@ var BundledDevHMRClient = class extends HMRClient {
 			reason: `no hmr boundary found for module \`${id}\``
 		};
 		for (const parent of parents) {
+			const subChain = [...stack, parent];
 			if (this.acceptsDep(parent, id)) {
-				boundaries.push([parent, id]);
+				boundaries.push({
+					boundary: parent,
+					acceptedVia: id,
+					isWithinCircularImport: this.isNodeWithinCircularImports(parent, subChain)
+				});
 				continue;
 			}
-			if (stack.includes(parent)) return {
-				type: "full-reload",
-				reason: `circular import chain between \`${id}\` and \`${parent}\``
-			};
-			const fullReload = this.bubble(parent, [...stack, parent], updateSet, boundaries, firstInvalidatedBy, traversedModules);
-			if (fullReload) return fullReload;
+			if (!stack.includes(parent)) {
+				const fullReload = this.bubble(parent, subChain, updateSet, boundaries, firstInvalidatedBy, traversedModules);
+				if (fullReload) return fullReload;
+			}
+		}
+	}
+	/**
+	* Check importers recursively if it's an import loop. An accepted module within
+	* an import loop cannot recover its execution order and should be reloaded.
+	*
+	* @param node The node that accepts HMR and is a boundary
+	* @param nodeChain The chain of nodes/imports that lead to the node.
+	*   (The last node in the chain imports the `node` parameter)
+	* @param currentChain The current chain tracked from the `node` parameter
+	* @param traversedModules The set of modules that have traversed
+	*/
+	isNodeWithinCircularImports(node, nodeChain, currentChain = [node], traversedModules = /* @__PURE__ */ new Set()) {
+		if (traversedModules.has(node)) return false;
+		traversedModules.add(node);
+		for (const importer of this.runtime.getImporters(node)) {
+			if (importer === node) continue;
+			const importerIndex = nodeChain.indexOf(importer);
+			if (importerIndex > -1) {
+				const importChain = [
+					importer,
+					...[...currentChain].reverse(),
+					...nodeChain.slice(importerIndex, -1).reverse()
+				];
+				this.logger.debug(`circular imports detected: ${importChain.join(" -> ")}`);
+				return true;
+			}
+			if (!currentChain.includes(importer)) {
+				const result = this.isNodeWithinCircularImports(importer, nodeChain, currentChain.concat(importer), traversedModules);
+				if (result) return result;
+			}
 		}
+		return false;
 	}
 	handlePush(payload) {
 		this.applyQueue = this.applyQueue.then(() => this.applyPush(payload)).catch((err) => {
@@ -364,15 +713,25 @@ var BundledDevHMRClient = class extends HMRClient {
 			this.requestFullReload(`no factory for module \`${id}\``);
 			return;
 		}
-		const applies = update.boundaries.map(([boundary, acceptedVia]) => ({
+		const applies = update.boundaries.map(({ boundary, acceptedVia, isWithinCircularImport }) => ({
 			boundary,
 			acceptedVia,
+			isWithinCircularImport,
 			callbacks: this.hotModulesMap.get(boundary)?.callbacks.filter((c) => c.deps.includes(acceptedVia)) ?? []
 		}));
 		for (const id of update.updateSet) this.runtime.removeModuleCache(id);
-		for (const { boundary, acceptedVia, callbacks } of applies) {
-			this.runtime.initModule(acceptedVia);
-			const fresh = this.runtime.loadExports(acceptedVia);
+		for (const { boundary, acceptedVia, isWithinCircularImport, callbacks } of applies) {
+			let fresh;
+			try {
+				this.runtime.initModule(acceptedVia);
+				fresh = this.runtime.loadExports(acceptedVia);
+			} catch (err) {
+				if (isWithinCircularImport) {
+					this.requestFullReload(`${acceptedVia} failed to apply HMR as it's within a circular import. Reloading page to reset the execution order.`);
+					return;
+				}
+				throw err;
+			}
 			try {
 				this.currentFirstInvalidatedBy = firstInvalidatedBy;
 				for (const { deps, fn } of callbacks) fn(deps.map((dep) => dep === acceptedVia ? fresh : void 0));
@@ -385,11 +744,12 @@ var BundledDevHMRClient = class extends HMRClient {
 	toUpdatePayload(boundaries, firstInvalidatedBy) {
 		return {
 			type: "update",
-			updates: boundaries.map(([boundary, acceptedVia]) => ({
+			updates: boundaries.map(({ boundary, acceptedVia, isWithinCircularImport }) => ({
 				type: "js-update",
 				path: boundary,
 				acceptedPath: acceptedVia,
 				timestamp: Date.now(),
+				isWithinCircularImport,
 				firstInvalidatedBy
 			}))
 		};
@@ -572,13 +932,17 @@ const normalizeModuleRunnerTransport = (transport) => {
 		} } : {},
 		async send(data) {
 			if (!invokeableTransport.send) return;
-			if (!isConnected) if (connectingPromise) await connectingPromise;
-			else throw new SendBeforeConnectError("send was called before connect");
+			if (!isConnected) {
+				if (connectingPromise) await connectingPromise;
+				else throw new SendBeforeConnectError("send was called before connect");
+			}
 			await invokeableTransport.send(data);
 		},
 		async invoke(name, data) {
-			if (!isConnected) if (connectingPromise) await connectingPromise;
-			else throw new SendBeforeConnectError("invoke was called before connect");
+			if (!isConnected) {
+				if (connectingPromise) await connectingPromise;
+				else throw new SendBeforeConnectError("invoke was called before connect");
+			}
 			return invokeableTransport.invoke(name, data);
 		}
 	};
@@ -1199,12 +1563,14 @@ async function handleMessage(payload) {
 		case "full-reload":
 			if (payload.ifFallback && !globalThis.__vite_is_fallback_page__) break;
 			await activeHmrClient.notifyListeners("vite:beforeFullReload", payload);
-			if (hasDocument) if (payload.path && payload.path.endsWith(".html")) {
-				const pagePath = decodeURI(location.pathname);
-				const payloadPath = base + payload.path.slice(1);
-				if (pagePath === payloadPath || payload.path === "/index.html" || pagePath.endsWith("/") && pagePath + "index.html" === payloadPath) pageReload();
-				return;
-			} else pageReload();
+			if (hasDocument) {
+				if (payload.path && payload.path.endsWith(".html")) {
+					const pagePath = decodeURI(location.pathname);
+					const payloadPath = base + payload.path.slice(1);
+					if (pagePath === payloadPath || payload.path === "/index.html" || pagePath.endsWith("/") && pagePath + "index.html" === payloadPath) pageReload();
+					return;
+				} else pageReload();
+			}
 			break;
 		case "prune":
 			await activeHmrClient.notifyListeners("vite:beforePrune", payload);

package/dist/client/client.mjs

@@ -1,5 +1,5 @@
 import "@vite/env";
-//#region \0@oxc-project+runtime@0.140.0/helpers/esm/typeof.js
+//#region \0@oxc-project+runtime@0.144.0/helpers/esm/typeof.js
 function _typeof(o) {
 	"@babel/helpers - typeof";
 	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
@@ -9,7 +9,7 @@ function _typeof(o) {
 	}, _typeof(o);
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.140.0/helpers/esm/toPrimitive.js
+//#region \0@oxc-project+runtime@0.144.0/helpers/esm/toPrimitive.js
 function toPrimitive(t, r) {
 	if ("object" != _typeof(t) || !t) return t;
 	var e = t[Symbol.toPrimitive];
@@ -21,13 +21,13 @@ function toPrimitive(t, r) {
 	return ("string" === r ? String : Number)(t);
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.140.0/helpers/esm/toPropertyKey.js
+//#region \0@oxc-project+runtime@0.144.0/helpers/esm/toPropertyKey.js
 function toPropertyKey(t) {
 	var i = toPrimitive(t, "string");
 	return "symbol" == _typeof(i) ? i : i + "";
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.140.0/helpers/esm/defineProperty.js
+//#region \0@oxc-project+runtime@0.144.0/helpers/esm/defineProperty.js
 function _defineProperty(e, r, t) {
 	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
 		value: t,
@@ -384,13 +384,17 @@ const normalizeModuleRunnerTransport = (transport) => {
 		} } : {},
 		async send(data) {
 			if (!invokeableTransport.send) return;
-			if (!isConnected) if (connectingPromise) await connectingPromise;
-			else throw new SendBeforeConnectError("send was called before connect");
+			if (!isConnected) {
+				if (connectingPromise) await connectingPromise;
+				else throw new SendBeforeConnectError("send was called before connect");
+			}
 			await invokeableTransport.send(data);
 		},
 		async invoke(name, data) {
-			if (!isConnected) if (connectingPromise) await connectingPromise;
-			else throw new SendBeforeConnectError("invoke was called before connect");
+			if (!isConnected) {
+				if (connectingPromise) await connectingPromise;
+				else throw new SendBeforeConnectError("invoke was called before connect");
+			}
 			return invokeableTransport.invoke(name, data);
 		}
 	};
@@ -1008,12 +1012,14 @@ async function handleMessage(payload) {
 		case "full-reload":
 			if (payload.ifFallback && !globalThis.__vite_is_fallback_page__) break;
 			await activeHmrClient.notifyListeners("vite:beforeFullReload", payload);
-			if (hasDocument) if (payload.path && payload.path.endsWith(".html")) {
-				const pagePath = decodeURI(location.pathname);
-				const payloadPath = base + payload.path.slice(1);
-				if (pagePath === payloadPath || payload.path === "/index.html" || pagePath.endsWith("/") && pagePath + "index.html" === payloadPath) pageReload();
-				return;
-			} else pageReload();
+			if (hasDocument) {
+				if (payload.path && payload.path.endsWith(".html")) {
+					const pagePath = decodeURI(location.pathname);
+					const payloadPath = base + payload.path.slice(1);
+					if (pagePath === payloadPath || payload.path === "/index.html" || pagePath.endsWith("/") && pagePath + "index.html" === payloadPath) pageReload();
+					return;
+				} else pageReload();
+			}
 			break;
 		case "prune":
 			await activeHmrClient.notifyListeners("vite:beforePrune", payload);