@lovable.dev/vite-tanstack-config 2.12.1 → 2.13.0

package/dist/hmr-gate.cjs

@@ -0,0 +1,329 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let node_crypto = require("node:crypto");
+let node_fs = require("node:fs");
+//#region src/hmr-gate/index.ts
+const statusCorsOriginRe = /^(?:https:\/\/(?:[^/]+\.)?lovable\.dev|https?:\/\/(?:(?:[^/:]+\.)?localhost|127\.0\.0\.1|\[::1\]))(?::\d+)?$/;
+function requestPathname(req) {
+	const url = req.url ?? "";
+	const queryStart = url.indexOf("?");
+	return queryStart === -1 ? url : url.slice(0, queryStart);
+}
+function gateStatusHeaders(req) {
+	const origin = req.headers.origin;
+	const headers = {
+		"Content-Type": "application/json",
+		Vary: "Origin"
+	};
+	if (typeof origin === "string" && statusCorsOriginRe.test(origin)) headers["Access-Control-Allow-Origin"] = origin;
+	return headers;
+}
+const DEV_SERVER_MODE_EVENT = "lovable:dev-server-mode";
+const EDIT_FREE_RELOAD_MARKER = "edit-free";
+/** Host-controlled default for `fullReload`; an explicit option still wins. */
+const FULL_RELOAD_ENV_VAR = "LOVABLE_HMR_FULL_RELOAD";
+function hmrGatePlugin(options = {}) {
+	const fullReload = options.fullReload ?? process.env["LOVABLE_HMR_FULL_RELOAD"] !== "false";
+	const gatedEvents = new Set(options.events ?? [
+		"change",
+		"add",
+		"unlink"
+	]);
+	const passthroughPatterns = options.passthrough ?? [];
+	const pending = /* @__PURE__ */ new Map();
+	const lastFlushedHashes = /* @__PURE__ */ new Map();
+	let originalEmit = null;
+	let server = null;
+	let transportMode = false;
+	let swallowedUpdates = 0;
+	let heldReload = false;
+	let passthroughReloads = 0;
+	const wrappedSends = [];
+	const drainMs = options.drainMs ?? 1500;
+	const maxHoldMs = options.maxHoldMs ?? 24e4;
+	const startupGraceMs = options.startupGraceMs ?? 5e3;
+	let startupGraceUntil = 0;
+	const patchPathRe = /^\/hmr_patch_\d+\.js(\?|$)/;
+	const parked = [];
+	let drainUntil = 0;
+	let restartTimer = null;
+	let reloadNeededListener = null;
+	const bufferedReloadNeeded = /* @__PURE__ */ new Map();
+	const pendingReplay = /* @__PURE__ */ new Map();
+	let reloadFailOpenTimer = null;
+	function replayBufferedReloadNeeded() {
+		if (reloadNeededListener === null || bufferedReloadNeeded.size === 0) return;
+		const entries = Array.from(bufferedReloadNeeded.entries());
+		bufferedReloadNeeded.clear();
+		for (const [client, payload] of entries) reloadNeededListener(payload, client);
+	}
+	function releaseParked() {
+		const count = parked.length;
+		for (const entry of parked.splice(0)) entry.release();
+		return count;
+	}
+	function initialBuildPending() {
+		const bundled = server?.environments?.client?.bundledDev;
+		return bundled !== void 0 && bundled.initialBuildCompleted !== true;
+	}
+	function gateSendTarget(target) {
+		const original = target.send.bind(target);
+		wrappedSends.push({
+			target,
+			original
+		});
+		target.send = (...args) => {
+			const frame = args[0];
+			const type = frame?.type;
+			if (type === "update") {
+				swallowedUpdates++;
+				return;
+			}
+			if (type === "full-reload") {
+				if (frame?.ifFallback === true || frame?.lovable?.hmrGate === EDIT_FREE_RELOAD_MARKER || Date.now() < startupGraceUntil || initialBuildPending()) {
+					passthroughReloads++;
+					return original(...args);
+				}
+				heldReload = true;
+				return;
+			}
+			return original(...args);
+		};
+	}
+	function fileContentHash(filePath) {
+		try {
+			return (0, node_crypto.createHash)("sha1").update((0, node_fs.readFileSync)(filePath)).digest("hex");
+		} catch {
+			return null;
+		}
+	}
+	function isPassthrough(filePath) {
+		if (typeof filePath !== "string") return true;
+		if (filePath.includes("node_modules/.vite")) return true;
+		return passthroughPatterns.some((p) => filePath.includes(p));
+	}
+	return {
+		name: "hmr-gate",
+		apply: "serve",
+		configResolved(config) {
+			transportMode = config.experimental?.bundledDev === true;
+		},
+		configureServer(srv) {
+			server = srv;
+			srv.ws.on?.("connection", (socket) => {
+				try {
+					socket.send(JSON.stringify({
+						type: "custom",
+						event: DEV_SERVER_MODE_EVENT,
+						data: { mode: transportMode ? "bundled" : "classic" }
+					}));
+				} catch {}
+			});
+			if (transportMode) {
+				const startedAtMs = Date.now();
+				startupGraceUntil = startedAtMs + startupGraceMs;
+				const ws = srv.ws;
+				const hot = srv.environments?.client?.hot;
+				const target = typeof ws?.send === "function" ? ws : hot;
+				if (target && typeof target.send === "function") gateSendTarget(target);
+				const hotChannel = hot;
+				if (hotChannel && typeof hotChannel.on === "function") {
+					const originalOn = hotChannel.on.bind(hotChannel);
+					hotChannel.on = (event, listener) => {
+						if (event !== "vite:bundled-dev:reload-needed") return originalOn(event, listener);
+						reloadNeededListener = listener;
+						originalOn(event, (payload, client) => {
+							if (Date.now() < startupGraceUntil || initialBuildPending()) return listener(payload, client);
+							bufferedReloadNeeded.set(client, payload);
+							if (reloadFailOpenTimer === null) {
+								reloadFailOpenTimer = setTimeout(() => {
+									reloadFailOpenTimer = null;
+									replayBufferedReloadNeeded();
+								}, maxHoldMs);
+								reloadFailOpenTimer.unref?.();
+							}
+						});
+					};
+				}
+				srv.middlewares.use((req, _res, next) => {
+					if (req.method === "GET" && patchPathRe.test(req.url ?? "") && Date.now() >= drainUntil) {
+						let released = false;
+						const release = () => {
+							if (released) return;
+							released = true;
+							clearTimeout(timer);
+							const index = parked.indexOf(entry);
+							if (index !== -1) parked.splice(index, 1);
+							next();
+						};
+						const timer = setTimeout(release, maxHoldMs);
+						timer.unref?.();
+						const entry = { release };
+						parked.push(entry);
+						return;
+					}
+					next();
+				});
+				srv.middlewares.use((req, res, next) => {
+					if (req.method !== "POST" || requestPathname(req) !== "/__hmr_flush") return next();
+					const priorDrainUntil = drainUntil;
+					const released = releaseParked();
+					drainUntil = Date.now() + drainMs;
+					const updates = swallowedUpdates;
+					swallowedUpdates = 0;
+					const broadcastHeld = heldReload;
+					heldReload = false;
+					const reload = broadcastHeld || bufferedReloadNeeded.size > 0;
+					let flushRestarts = false;
+					if (reload) {
+						const releaseDelayMs = Math.max(released > 0 ? drainMs : 0, priorDrainUntil - Date.now(), 0);
+						const restart = srv.restart;
+						if (restartTimer !== null) clearTimeout(restartTimer);
+						if (reloadFailOpenTimer !== null) {
+							clearTimeout(reloadFailOpenTimer);
+							reloadFailOpenTimer = null;
+						}
+						if (!broadcastHeld && bufferedReloadNeeded.size > 0 && reloadNeededListener !== null) {
+							for (const [client, payload] of bufferedReloadNeeded) pendingReplay.set(client, payload);
+							bufferedReloadNeeded.clear();
+							restartTimer = setTimeout(() => {
+								restartTimer = null;
+								const entries = Array.from(pendingReplay.entries());
+								pendingReplay.clear();
+								for (const [client, payload] of entries) reloadNeededListener?.(payload, client);
+							}, releaseDelayMs);
+							restartTimer.unref?.();
+						} else if (typeof restart === "function") {
+							flushRestarts = true;
+							bufferedReloadNeeded.clear();
+							pendingReplay.clear();
+							restartTimer = setTimeout(() => {
+								restartTimer = null;
+								restart.call(srv).catch(() => {
+									if (wrappedSends.length > 0) wrappedSends[0].original({ type: "full-reload" });
+								});
+							}, releaseDelayMs);
+							restartTimer.unref?.();
+						} else if (wrappedSends.length > 0) {
+							bufferedReloadNeeded.clear();
+							pendingReplay.clear();
+							wrappedSends[0].original({ type: "full-reload" });
+						}
+					}
+					const body = JSON.stringify({
+						flushed: [],
+						count: released + updates,
+						released,
+						reload,
+						restartsOnReload: flushRestarts,
+						mode: "transport-patch-hold"
+					});
+					res.writeHead(200, { "Content-Type": "application/json" });
+					res.end(body);
+				});
+				srv.middlewares.use((req, res, next) => {
+					if (req.method !== "GET" || requestPathname(req) !== "/__hmr_gate") return next();
+					const body = JSON.stringify({
+						enabled: true,
+						pending: {},
+						count: parked.length + swallowedUpdates + (heldReload || bufferedReloadNeeded.size > 0 ? 1 : 0),
+						heldReload: heldReload || bufferedReloadNeeded.size > 0,
+						restartsOnReload: reloadNeededListener === null || heldReload,
+						startedAt: startedAtMs,
+						passthroughReloads,
+						mode: "transport-patch-hold"
+					});
+					res.writeHead(200, gateStatusHeaders(req));
+					res.end(body);
+				});
+				return;
+			}
+			const _emit = srv.watcher.emit.bind(srv.watcher);
+			originalEmit = _emit;
+			srv.watcher.emit = ((event, ...args) => {
+				if (typeof event === "string" && gatedEvents.has(event) && !isPassthrough(args[0])) {
+					const filePath = args[0];
+					if (event === "change" || event === "add") {
+						const hash = fileContentHash(filePath);
+						if (hash !== null && hash === lastFlushedHashes.get(filePath)) {
+							pending.delete(filePath);
+							return false;
+						}
+					}
+					let events = pending.get(filePath);
+					if (!events) {
+						events = /* @__PURE__ */ new Set();
+						pending.set(filePath, events);
+					}
+					events.add(event);
+					return false;
+				}
+				return _emit(event, ...args);
+			});
+			srv.middlewares.use((req, res, next) => {
+				if (req.method !== "POST" || requestPathname(req) !== "/__hmr_flush") return next();
+				const entries = Array.from(pending.entries());
+				pending.clear();
+				for (const [f] of entries) srv.moduleGraph.onFileChange(f);
+				if (entries.length > 0) {
+					for (const [f, events] of entries) {
+						for (const event of events) _emit(event, f);
+						const hash = fileContentHash(f);
+						if (hash === null) lastFlushedHashes.delete(f);
+						else lastFlushedHashes.set(f, hash);
+					}
+					if (fullReload) srv.ws.send({ type: "full-reload" });
+				}
+				const files = entries.map(([f]) => f);
+				const body = JSON.stringify({
+					flushed: files,
+					count: entries.length,
+					mode: fullReload ? "full-reload" : "granular"
+				});
+				res.writeHead(200, { "Content-Type": "application/json" });
+				res.end(body);
+			});
+			srv.middlewares.use((req, res, next) => {
+				if (req.method !== "GET" || requestPathname(req) !== "/__hmr_gate") return next();
+				const serialized = {};
+				for (const [f, events] of pending) serialized[f] = Array.from(events);
+				const body = JSON.stringify({
+					enabled: true,
+					pending: serialized,
+					count: pending.size,
+					mode: fullReload ? "full-reload" : "granular"
+				});
+				res.writeHead(200, gateStatusHeaders(req));
+				res.end(body);
+			});
+		},
+		closeWatcher() {
+			if (server && originalEmit) server.watcher.emit = originalEmit;
+			for (const { target, original } of wrappedSends) target.send = original;
+			wrappedSends.length = 0;
+			if (restartTimer !== null) {
+				clearTimeout(restartTimer);
+				restartTimer = null;
+			}
+			releaseParked();
+			if (reloadFailOpenTimer !== null) {
+				clearTimeout(reloadFailOpenTimer);
+				reloadFailOpenTimer = null;
+			}
+			bufferedReloadNeeded.clear();
+			pendingReplay.clear();
+			reloadNeededListener = null;
+			swallowedUpdates = 0;
+			heldReload = false;
+			passthroughReloads = 0;
+			drainUntil = 0;
+			pending.clear();
+			lastFlushedHashes.clear();
+			server = null;
+			originalEmit = null;
+		}
+	};
+}
+//#endregion
+exports.DEV_SERVER_MODE_EVENT = DEV_SERVER_MODE_EVENT;
+exports.FULL_RELOAD_ENV_VAR = FULL_RELOAD_ENV_VAR;
+exports.hmrGatePlugin = hmrGatePlugin;

package/dist/hmr-gate.d.cts

@@ -0,0 +1,27 @@
+import { Plugin } from "vite";
+//#region src/hmr-gate/index.d.ts
+declare const DEV_SERVER_MODE_EVENT = "lovable:dev-server-mode";
+/** Host-controlled default for `fullReload`; an explicit option still wins. */
+declare const FULL_RELOAD_ENV_VAR = "LOVABLE_HMR_FULL_RELOAD";
+interface HmrGateOptions {
+  /** Use full-reload (default) vs granular per-module HMR. Unset reads
+   * `LOVABLE_HMR_FULL_RELOAD`, where only "false" selects granular. */
+  fullReload?: boolean;
+  /** Bundled dev only: ms the gate stays open after a flush so the client's
+   * queued patch fetches drain. Default 1500. */
+  drainMs?: number;
+  /** Bundled dev only: max ms a patch response is parked before it
+   * fail-opens. Default 240000. */
+  maxHoldMs?: number;
+  /** Bundled dev only: ms after server start during which full-reload frames
+   * (Vite's restart resync) pass through live. Default 5000. */
+  startupGraceMs?: number;
+  /** Watcher events to intercept. Default: all three — a freeze must catch adds and
+   * deletes, not just content changes (e.g. atomic writes / synced files surface as add/unlink). */
+  events?: ("change" | "add" | "unlink")[];
+  /** File path substrings that bypass the gate (always emitted immediately). */
+  passthrough?: string[];
+}
+declare function hmrGatePlugin(options?: HmrGateOptions): Plugin;
+//#endregion
+export { DEV_SERVER_MODE_EVENT, FULL_RELOAD_ENV_VAR, HmrGateOptions, hmrGatePlugin };

package/dist/hmr-gate.d.ts

@@ -0,0 +1,27 @@
+import { Plugin } from "vite";
+//#region src/hmr-gate/index.d.ts
+declare const DEV_SERVER_MODE_EVENT = "lovable:dev-server-mode";
+/** Host-controlled default for `fullReload`; an explicit option still wins. */
+declare const FULL_RELOAD_ENV_VAR = "LOVABLE_HMR_FULL_RELOAD";
+interface HmrGateOptions {
+  /** Use full-reload (default) vs granular per-module HMR. Unset reads
+   * `LOVABLE_HMR_FULL_RELOAD`, where only "false" selects granular. */
+  fullReload?: boolean;
+  /** Bundled dev only: ms the gate stays open after a flush so the client's
+   * queued patch fetches drain. Default 1500. */
+  drainMs?: number;
+  /** Bundled dev only: max ms a patch response is parked before it
+   * fail-opens. Default 240000. */
+  maxHoldMs?: number;
+  /** Bundled dev only: ms after server start during which full-reload frames
+   * (Vite's restart resync) pass through live. Default 5000. */
+  startupGraceMs?: number;
+  /** Watcher events to intercept. Default: all three — a freeze must catch adds and
+   * deletes, not just content changes (e.g. atomic writes / synced files surface as add/unlink). */
+  events?: ("change" | "add" | "unlink")[];
+  /** File path substrings that bypass the gate (always emitted immediately). */
+  passthrough?: string[];
+}
+declare function hmrGatePlugin(options?: HmrGateOptions): Plugin;
+//#endregion
+export { DEV_SERVER_MODE_EVENT, FULL_RELOAD_ENV_VAR, HmrGateOptions, hmrGatePlugin };