@hot-updater/console 1.0.0-rc.20 → 1.0.0-rc.21

package/.output/server/_libs/@tanstack/react-router-ssr-query+[...].mjs

@@ -1,121 +1,164 @@
 import { i as __toESM } from "../../_runtime.mjs";
 import { mt as require_react, pt as require_jsx_runtime } from "../@base-ui/react+[...].mjs";
-import { a as dehydrate } from "../tanstack__query-core.mjs";
+import { g as isRedirect } from "./react-router+[...].mjs";
 import { i as QueryClientProvider } from "../tanstack__react-query.mjs";
-import "./react-router+[...].mjs";
-//#region ../../node_modules/.pnpm/@tanstack+router-ssr-query-core@1.169.1_@tanstack+query-core@5.101.0_@tanstack+router-core@1.171.13/node_modules/@tanstack/router-ssr-query-core/dist/esm/index.js
+import { a as dehydrateQuery, o as hydrate } from "../tanstack__query-core.mjs";
+//#region ../../node_modules/.pnpm/@tanstack+router-ssr-query-core@1.169.3_@tanstack+query-core@5.104.0_@tanstack+router-core@1.171.34/node_modules/@tanstack/router-ssr-query-core/dist/esm/index.js
 var import_react = /* @__PURE__ */ __toESM(require_react(), 1);
+var shouldDehydrateAllQueries = () => true;
 function setupCoreRouterSsrQueryIntegration({ router, queryClient, dehydrateOptions, hydrateOptions, handleRedirects = true }) {
-	router.options.hydrate;
-	const ogDehydrate = router.options.dehydrate;
 	{
-		const sentQueries = /* @__PURE__ */ new Set();
-		const queryStream = createPushableStream();
-		let unsubscribe = void 0;
-		let cleanupRegistered = false;
-		let tornDown = false;
-		const teardown = () => {
-			if (tornDown) return;
-			tornDown = true;
-			try {
-				unsubscribe?.();
-			} catch {}
-			unsubscribe = void 0;
-			try {
-				if (!queryStream.isClosed()) queryStream.close();
-			} catch {}
+		const originalDehydrate = router.options.dehydrate;
+		let streamState;
+		let cleanedUp = false;
+		const finalizeQueryStream = (failure) => {
+			const state = streamState;
+			streamState = void 0;
+			if (!state) return;
+			state.unsubscribe();
 			try {
-				queryClient.cancelQueries();
+				if (failure) state.controller.error(failure.error);
+				else state.controller.close();
 			} catch {}
-			try {
-				queryClient.clear();
-			} catch {}
-			sentQueries.clear();
 		};
-		const registerCleanup = (serverSsr = router.serverSsr) => {
-			if (cleanupRegistered) return;
-			if (!serverSsr) return;
-			serverSsr.onCleanup(teardown);
-			cleanupRegistered = true;
+		const teardown = () => {
+			cleanedUp = true;
+			finalizeQueryStream();
+			queryClient.clear();
 		};
 		router.serverSsrLifecycle = {
 			...router.serverSsrLifecycle,
-			onServerSsrAttach: [...router.serverSsrLifecycle?.onServerSsrAttach ?? [], registerCleanup]
+			onServerSsrAttach: [...router.serverSsrLifecycle?.onServerSsrAttach ?? [], (serverSsr) => serverSsr.onCleanup(teardown)]
 		};
 		router.options.dehydrate = async () => {
-			router.serverSsr.onRenderFinished(() => {
-				if (!queryStream.isClosed()) queryStream.close();
-				unsubscribe?.();
-				unsubscribe = void 0;
-			});
-			const dehydratedRouter = {
-				...await ogDehydrate?.(),
-				queryStream: queryStream.stream
-			};
-			const dehydratedQueryClient = dehydrate(queryClient, dehydrateOptions);
-			if (dehydratedQueryClient.queries.length > 0) {
-				dehydratedQueryClient.queries.forEach((query) => {
-					sentQueries.add(query.queryHash);
-				});
-				dehydratedRouter.dehydratedQueryClient = dehydratedQueryClient;
-			}
-			return dehydratedRouter;
-		};
-		const ogClientOptions = queryClient.getDefaultOptions();
-		queryClient.setDefaultOptions({
-			...ogClientOptions,
-			dehydrate: {
-				shouldDehydrateQuery: () => true,
-				...ogClientOptions.dehydrate
+			let originalDehydrated;
+			try {
+				originalDehydrated = await originalDehydrate?.();
+			} finally {
+				if (cleanedUp) queryClient.clear();
 			}
-		});
-		unsubscribe = queryClient.getQueryCache().subscribe((event) => {
-			if (!router.serverSsr?.isDehydrated()) return;
-			if (sentQueries.has(event.query.queryHash)) return;
-			if (!event.query.promise) return;
-			if (queryStream.isClosed()) {
-				console.warn(`tried to stream query ${event.query.queryHash} after stream was already closed`);
-				return;
+			if (cleanedUp) return;
+			const currentDehydrateOptions = queryClient.getDefaultOptions().dehydrate;
+			const shouldDehydrateQuery = dehydrateOptions?.shouldDehydrateQuery ?? currentDehydrateOptions?.shouldDehydrateQuery ?? shouldDehydrateAllQueries;
+			const serializeData = dehydrateOptions?.serializeData ?? currentDehydrateOptions?.serializeData;
+			const shouldRedactErrors = dehydrateOptions?.shouldRedactErrors ?? currentDehydrateOptions?.shouldRedactErrors;
+			const initialQueries = new Array();
+			const sentQueries = /* @__PURE__ */ new Set();
+			for (const query of queryClient.getQueryCache().getAll()) if (shouldDehydrateQuery(query)) {
+				initialQueries.push(dehydrateQuery(query, serializeData, shouldRedactErrors));
+				sentQueries.add(query.queryHash);
 			}
-			const dehydratedQuery = dehydrate(queryClient, {
-				...dehydrateOptions,
-				shouldDehydrateQuery: (query) => {
-					if (query.queryHash !== event.query.queryHash) return false;
-					return (ogClientOptions.dehydrate?.shouldDehydrateQuery?.(query) ?? true) && (dehydrateOptions?.shouldDehydrateQuery?.(query) ?? true);
+			let controller;
+			const stream = new ReadableStream({ start(value) {
+				controller = value;
+			} });
+			const flushPendingQueries = () => {
+				const state = streamState;
+				const queries = state?.pendingQueries;
+				if (!state || !queries) return;
+				state.pendingQueries = void 0;
+				const dehydratedQueries = new Array();
+				for (const query of queries.values()) {
+					if (state.sentQueries.has(query.queryHash) || !shouldDehydrateQuery(query)) continue;
+					dehydratedQueries.push(dehydrateQuery(query, serializeData, shouldRedactErrors));
+					state.sentQueries.add(query.queryHash);
+				}
+				if (dehydratedQueries.length > 0) state.controller.enqueue(dehydratedQueries);
+			};
+			const unsubscribe = queryClient.getQueryCache().subscribe((event) => {
+				const state = streamState;
+				if (!state) return;
+				if (state.sentQueries.has(event.query.queryHash) || !event.query.promise) return;
+				if (!state.pendingQueries) {
+					state.pendingQueries = /* @__PURE__ */ new Map();
+					queueMicrotask(() => {
+						try {
+							flushPendingQueries();
+						} catch (error) {
+							finalizeQueryStream({ error });
+						}
+					});
 				}
+				state.pendingQueries.set(event.query.queryHash, event.query);
 			});
-			if (dehydratedQuery.queries.length === 0) return;
-			sentQueries.add(event.query.queryHash);
-			queryStream.enqueue(dehydratedQuery);
-		});
+			streamState = {
+				controller,
+				sentQueries,
+				unsubscribe
+			};
+			const finishRendering = () => {
+				try {
+					flushPendingQueries();
+				} catch (error) {
+					finalizeQueryStream({ error });
+					return;
+				}
+				finalizeQueryStream();
+			};
+			router.serverSsr.onRenderFinished(finishRendering);
+			return {
+				...originalDehydrated,
+				query: {
+					...initialQueries.length > 0 && { initial: initialQueries },
+					stream
+				}
+			};
+		};
+		return;
 	}
-}
-function createPushableStream() {
-	let controllerRef;
-	const stream = new ReadableStream({ start(controller) {
-		controllerRef = controller;
-	} });
-	let _isClosed = false;
-	return {
-		stream,
-		enqueue: (chunk) => {
-			if (!_isClosed) controllerRef.enqueue(chunk);
-		},
-		close: () => {
-			if (_isClosed) return;
-			controllerRef.close();
-			_isClosed = true;
-		},
-		isClosed: () => _isClosed,
-		error: (err) => {
-			if (_isClosed) return;
-			_isClosed = true;
-			controllerRef.error(err);
+	const originalHydrate = router.options.hydrate;
+	router.options.hydrate = async (dehydrated) => {
+		const query = dehydrated.query;
+		try {
+			await originalHydrate?.(dehydrated);
+			if (query.initial) hydrate(queryClient, { queries: query.initial }, hydrateOptions);
+		} catch (error) {
+			query.stream.cancel(error).catch(() => {});
+			throw error;
 		}
+		const reader = query.stream.getReader();
+		(async () => {
+			try {
+				for (;;) {
+					const { done, value } = await reader.read();
+					if (done) return;
+					hydrate(queryClient, { queries: value }, hydrateOptions);
+				}
+			} catch (error) {
+				console.error("Error reading query stream:", error);
+				reader.cancel(error).catch(() => {});
+			} finally {
+				reader.releaseLock();
+			}
+		})();
 	};
+	if (handleRedirects) {
+		const originalMutationCacheConfig = queryClient.getMutationCache().config;
+		queryClient.getMutationCache().config = {
+			...originalMutationCacheConfig,
+			onError: (error, ...rest) => {
+				if (isRedirect(error)) {
+					error.options._fromLocation = router.stores.location.get();
+					return router.navigate(router.resolveRedirect(error).options);
+				}
+				return originalMutationCacheConfig.onError?.(error, ...rest);
+			}
+		};
+		const originalQueryCacheConfig = queryClient.getQueryCache().config;
+		queryClient.getQueryCache().config = {
+			...originalQueryCacheConfig,
+			onError: (error, ...rest) => {
+				if (isRedirect(error)) {
+					error.options._fromLocation = router.stores.location.get();
+					return router.navigate(router.resolveRedirect(error).options);
+				}
+				return originalQueryCacheConfig.onError?.(error, ...rest);
+			}
+		};
+	}
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@tanstack+react-router-ssr-query@1.167.1_@tanstack+query-core@5.101.0_@tanstack+react-q_97558905e4162372eb254bbf2e57137e/node_modules/@tanstack/react-router-ssr-query/dist/esm/index.js
+//#region ../../node_modules/.pnpm/@tanstack+react-router-ssr-query@1.167.3_@tanstack+query-core@5.104.0_@tanstack+react-q_1bead130580f43d4c91409744e4c5a0e/node_modules/@tanstack/react-router-ssr-query/dist/esm/index.js
 var import_jsx_runtime = require_jsx_runtime();
 function setupRouterSsrQueryIntegration(opts) {
 	setupCoreRouterSsrQueryIntegration(opts);

package/.output/server/_libs/tanstack__history.mjs

@@ -1,7 +1,25 @@
-//#region ../../node_modules/.pnpm/@tanstack+history@1.162.0/node_modules/@tanstack/history/dist/esm/index.js
+//#region ../../node_modules/.pnpm/@tanstack+history@1.162.4/node_modules/@tanstack/history/dist/esm/index.js
 var stateIndexKey = "__TSR_index";
 var popStateEvent = "popstate";
 var beforeUnloadEvent = "beforeunload";
+/**
+* Turn protocol-relative inputs such as "//evil.example" into paths
+* such as "/evil.example", keeping navigation on the current origin.
+*
+* For HTTP(S) URLs, WHATWG parsing ignores leading C0 controls and spaces,
+* removes tabs/newlines, and treats backslashes as slashes, so inputs like
+* "/\evil.example" also need normalization. This only allocates when those
+* rules would make the input protocol-relative.
+*/
+var protocolRelativePrefix = /^[\x00-\x20]*(?:[\\/][\t\n\r]*){2,}/;
+function normalizeProtocolRelative(url) {
+	const match = protocolRelativePrefix.exec(url);
+	return match ? "/" + url.slice(match[0].length) : url;
+}
+function normalizeHref(href) {
+	if (/[\x00-\x1f\x7f]/.test(href)) href = href.replace(/[\x00-\x1f\x7f]/g, (character) => "	\n\r".includes(character) ? "" : encodeURIComponent(character));
+	return normalizeProtocolRelative(href);
+}
 function createHistory(opts) {
 	let location = opts.getLocation();
 	const subscribers = /* @__PURE__ */ new Set();
@@ -81,7 +99,7 @@ function createHistory(opts) {
 		go: (index, navigateOpts) => {
 			tryNavigation({
 				task: () => {
-					opts.go(index);
+					opts.go(index, navigateOpts?.ignoreBlocker ?? false);
 					handleIndexChange({
 						type: "GO",
 						index
@@ -124,11 +142,11 @@ function createHistory(opts) {
 		},
 		flush: () => opts.flush?.(),
 		destroy: () => opts.destroy?.(),
-		notify
+		notify,
+		_getBlockers: () => opts.getBlockers?.() ?? []
 	};
 }
 function assignKeyAndIndex(index, state) {
-	if (!state) state = {};
 	const key = createRandomKey();
 	return {
 		...state,
@@ -160,7 +178,7 @@ function createBrowserHistory(opts) {
 	let blockers = [];
 	const _getBlockers = () => blockers;
 	const _setBlockers = (newBlockers) => blockers = newBlockers;
-	const createHref = opts?.createHref ?? ((path) => path);
+	const createHref = (path) => normalizeHref(opts?.createHref ? opts.createHref(path) : path);
 	const parseLocation = opts?.parseLocation ?? (() => parseHref(`${win.location.pathname}${win.location.search}${win.location.hash}`, win.history.state));
 	if (!win.history.state?.__TSR_key && !win.history.state?.key) {
 		const addedKey = createRandomKey();
@@ -178,32 +196,32 @@ function createBrowserHistory(opts) {
 	let ignoreNextBeforeUnload = false;
 	const getLocation = () => currentLocation;
 	let next;
-	let scheduled;
 	const flush = () => {
 		if (!next) return;
 		history._ignoreSubscribers = true;
-		(next.isPush ? win.history.pushState : win.history.replaceState)(next.state, "", next.href);
+		(next[2] ? win.history.pushState : win.history.replaceState)(next[1], "", next[0]);
 		history._ignoreSubscribers = false;
 		next = void 0;
-		scheduled = void 0;
 		rollbackLocation = void 0;
 	};
-	const queueHistoryAction = (type, destHref, state) => {
-		const href = createHref(destHref);
-		if (!scheduled) rollbackLocation = currentLocation;
+	const queueHistoryAction = (isPush, destHref, state) => {
+		const href = opts?.createHref ? createHref(destHref) : void 0;
+		const hasPendingAction = !!next;
+		if (!hasPendingAction) rollbackLocation = currentLocation;
 		currentLocation = parseHref(destHref, state);
-		next = {
-			href,
+		next = [
+			href ?? currentLocation.href,
 			state,
-			isPush: next?.isPush || type === "push"
-		};
-		if (!scheduled) scheduled = Promise.resolve().then(() => flush());
+			next?.[2] || isPush
+		];
+		if (!hasPendingAction) queueMicrotask(() => flush());
 	};
 	const onPushPop = (type) => {
 		currentLocation = parseLocation();
 		history.notify({ type });
 	};
 	const onPushPopEvent = async () => {
+		ignoreNextBeforeUnload = false;
 		if (ignoreNextPop) {
 			ignoreNextPop = false;
 			return;
@@ -229,7 +247,7 @@ function createBrowserHistory(opts) {
 					action
 				})) {
 					ignoreNextPop = true;
-					win.history.go(1);
+					win.history.go(-delta);
 					history.notify(notify);
 					return;
 				}
@@ -264,20 +282,28 @@ function createBrowserHistory(opts) {
 	const history = createHistory({
 		getLocation,
 		getLength: () => win.history.length,
-		pushState: (href, state) => queueHistoryAction("push", href, state),
-		replaceState: (href, state) => queueHistoryAction("replace", href, state),
+		pushState: (href, state) => queueHistoryAction(true, href, state),
+		replaceState: (href, state) => queueHistoryAction(false, href, state),
 		back: (ignoreBlocker) => {
-			if (ignoreBlocker) skipBlockerNextPop = true;
-			ignoreNextBeforeUnload = true;
+			if (ignoreBlocker) {
+				skipBlockerNextPop = true;
+				ignoreNextBeforeUnload = true;
+			}
 			return win.history.back();
 		},
 		forward: (ignoreBlocker) => {
-			if (ignoreBlocker) skipBlockerNextPop = true;
-			ignoreNextBeforeUnload = true;
+			if (ignoreBlocker) {
+				skipBlockerNextPop = true;
+				ignoreNextBeforeUnload = true;
+			}
 			win.history.forward();
 		},
-		go: (n) => {
+		go: (n, ignoreBlocker) => {
 			nextPopIsGo = true;
+			if (ignoreBlocker) {
+				skipBlockerNextPop = true;
+				ignoreNextBeforeUnload = true;
+			}
 			win.history.go(n);
 		},
 		createHref: (href) => createHref(href),
@@ -295,6 +321,13 @@ function createBrowserHistory(opts) {
 		setBlockers: _setBlockers,
 		notifyOnIndexChange: false
 	});
+	history._ignoreNextBeforeUnload = (href) => {
+		ignoreNextBeforeUnload = false;
+		try {
+			href = new URL(href, win.document.baseURI).href;
+			ignoreNextBeforeUnload = /^https?:/.test(href) && (!href.includes("#") || href.split("#")[0] !== win.location.href.split("#")[0]);
+		} catch {}
+	};
 	win.addEventListener(beforeUnloadEvent, onBeforeUnload, { capture: true });
 	win.addEventListener(popStateEvent, onPushPopEvent);
 	win.history.pushState = function(...args) {
@@ -309,34 +342,28 @@ function createBrowserHistory(opts) {
 	};
 	return history;
 }
-/**
-* Sanitize a path to prevent open redirect vulnerabilities.
-* Removes control characters and collapses leading double slashes.
-*/
-function sanitizePath(path) {
-	let sanitized = path.replace(/[\x00-\x1f\x7f]/g, "");
-	if (sanitized.startsWith("//")) sanitized = "/" + sanitized.replace(/^\/+/, "");
-	return sanitized;
-}
 function parseHref(href, state) {
-	const sanitizedHref = sanitizePath(href);
+	const sanitizedHref = normalizeHref(href);
 	const hashIndex = sanitizedHref.indexOf("#");
 	const searchIndex = sanitizedHref.indexOf("?");
-	const addedKey = createRandomKey();
+	if (!state) {
+		const key = createRandomKey();
+		state = {
+			[stateIndexKey]: 0,
+			key,
+			__TSR_key: key
+		};
+	}
 	return {
 		href: sanitizedHref,
 		pathname: sanitizedHref.substring(0, hashIndex > 0 ? searchIndex > 0 ? Math.min(hashIndex, searchIndex) : hashIndex : searchIndex > 0 ? searchIndex : sanitizedHref.length),
 		hash: hashIndex > -1 ? sanitizedHref.substring(hashIndex) : "",
 		search: searchIndex > -1 ? sanitizedHref.slice(searchIndex, hashIndex === -1 ? void 0 : hashIndex) : "",
-		state: state || {
-			[stateIndexKey]: 0,
-			key: addedKey,
-			__TSR_key: addedKey
-		}
+		state
 	};
 }
 function createRandomKey() {
 	return (Math.random() + 1).toString(36).substring(7);
 }
 //#endregion
-export { parseHref as n, createBrowserHistory as t };
+export { normalizeProtocolRelative as n, parseHref as r, createBrowserHistory as t };