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

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

@@ -1,121 +1,164 @@
-import { r as __toESM } from "../../_runtime.mjs";
-import { J as require_react, q as require_jsx_runtime } from "../@base-ui/react+[...].mjs";
-import "./react-router+[...].mjs";
-import { a as dehydrate } from "../tanstack__query-core.mjs";
-import { r as QueryClientProvider } from "../tanstack__react-query.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 { i as __toESM } from "../../_runtime.mjs";
+import { mt as require_react, pt as require_jsx_runtime } from "../@base-ui/react+[...].mjs";
+import { g as isRedirect } from "./react-router+[...].mjs";
+import { i as QueryClientProvider } from "../tanstack__react-query.mjs";
+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/d3-array.mjs

@@ -0,0 +1,231 @@
+//#region ../../node_modules/.pnpm/d3-array@3.2.4/node_modules/d3-array/src/ascending.js
+function ascending(a, b) {
+	return a == null || b == null ? NaN : a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/d3-array@3.2.4/node_modules/d3-array/src/descending.js
+function descending(a, b) {
+	return a == null || b == null ? NaN : b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/d3-array@3.2.4/node_modules/d3-array/src/bisector.js
+function bisector(f) {
+	let compare1, compare2, delta;
+	if (f.length !== 2) {
+		compare1 = ascending;
+		compare2 = (d, x) => ascending(f(d), x);
+		delta = (d, x) => f(d) - x;
+	} else {
+		compare1 = f === ascending || f === descending ? f : zero;
+		compare2 = f;
+		delta = f;
+	}
+	function left(a, x, lo = 0, hi = a.length) {
+		if (lo < hi) {
+			if (compare1(x, x) !== 0) return hi;
+			do {
+				const mid = lo + hi >>> 1;
+				if (compare2(a[mid], x) < 0) lo = mid + 1;
+				else hi = mid;
+			} while (lo < hi);
+		}
+		return lo;
+	}
+	function right(a, x, lo = 0, hi = a.length) {
+		if (lo < hi) {
+			if (compare1(x, x) !== 0) return hi;
+			do {
+				const mid = lo + hi >>> 1;
+				if (compare2(a[mid], x) <= 0) lo = mid + 1;
+				else hi = mid;
+			} while (lo < hi);
+		}
+		return lo;
+	}
+	function center(a, x, lo = 0, hi = a.length) {
+		const i = left(a, x, lo, hi - 1);
+		return i > lo && delta(a[i - 1], x) > -delta(a[i], x) ? i - 1 : i;
+	}
+	return {
+		left,
+		center,
+		right
+	};
+}
+function zero() {
+	return 0;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/d3-array@3.2.4/node_modules/d3-array/src/number.js
+function number(x) {
+	return x === null ? NaN : +x;
+}
+function* numbers(values, valueof) {
+	if (valueof === void 0) {
+		for (let value of values) if (value != null && (value = +value) >= value) yield value;
+	} else {
+		let index = -1;
+		for (let value of values) if ((value = valueof(value, ++index, values)) != null && (value = +value) >= value) yield value;
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/d3-array@3.2.4/node_modules/d3-array/src/bisect.js
+var ascendingBisect = bisector(ascending);
+var bisectRight = ascendingBisect.right;
+ascendingBisect.left;
+bisector(number).center;
+//#endregion
+//#region ../../node_modules/.pnpm/d3-array@3.2.4/node_modules/d3-array/src/sort.js
+function compareDefined(compare = ascending) {
+	if (compare === ascending) return ascendingDefined;
+	if (typeof compare !== "function") throw new TypeError("compare is not a function");
+	return (a, b) => {
+		const x = compare(a, b);
+		if (x || x === 0) return x;
+		return (compare(b, b) === 0) - (compare(a, a) === 0);
+	};
+}
+function ascendingDefined(a, b) {
+	return (a == null || !(a >= a)) - (b == null || !(b >= b)) || (a < b ? -1 : a > b ? 1 : 0);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/d3-array@3.2.4/node_modules/d3-array/src/ticks.js
+var e10 = Math.sqrt(50), e5 = Math.sqrt(10), e2 = Math.sqrt(2);
+function tickSpec(start, stop, count) {
+	const step = (stop - start) / Math.max(0, count), power = Math.floor(Math.log10(step)), error = step / Math.pow(10, power), factor = error >= e10 ? 10 : error >= e5 ? 5 : error >= e2 ? 2 : 1;
+	let i1, i2, inc;
+	if (power < 0) {
+		inc = Math.pow(10, -power) / factor;
+		i1 = Math.round(start * inc);
+		i2 = Math.round(stop * inc);
+		if (i1 / inc < start) ++i1;
+		if (i2 / inc > stop) --i2;
+		inc = -inc;
+	} else {
+		inc = Math.pow(10, power) * factor;
+		i1 = Math.round(start / inc);
+		i2 = Math.round(stop / inc);
+		if (i1 * inc < start) ++i1;
+		if (i2 * inc > stop) --i2;
+	}
+	if (i2 < i1 && .5 <= count && count < 2) return tickSpec(start, stop, count * 2);
+	return [
+		i1,
+		i2,
+		inc
+	];
+}
+function ticks(start, stop, count) {
+	stop = +stop, start = +start, count = +count;
+	if (!(count > 0)) return [];
+	if (start === stop) return [start];
+	const reverse = stop < start, [i1, i2, inc] = reverse ? tickSpec(stop, start, count) : tickSpec(start, stop, count);
+	if (!(i2 >= i1)) return [];
+	const n = i2 - i1 + 1, ticks = new Array(n);
+	if (reverse) if (inc < 0) for (let i = 0; i < n; ++i) ticks[i] = (i2 - i) / -inc;
+	else for (let i = 0; i < n; ++i) ticks[i] = (i2 - i) * inc;
+	else if (inc < 0) for (let i = 0; i < n; ++i) ticks[i] = (i1 + i) / -inc;
+	else for (let i = 0; i < n; ++i) ticks[i] = (i1 + i) * inc;
+	return ticks;
+}
+function tickIncrement(start, stop, count) {
+	stop = +stop, start = +start, count = +count;
+	return tickSpec(start, stop, count)[2];
+}
+function tickStep(start, stop, count) {
+	stop = +stop, start = +start, count = +count;
+	const reverse = stop < start, inc = reverse ? tickIncrement(stop, start, count) : tickIncrement(start, stop, count);
+	return (reverse ? -1 : 1) * (inc < 0 ? 1 / -inc : inc);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/d3-array@3.2.4/node_modules/d3-array/src/max.js
+function max(values, valueof) {
+	let max;
+	if (valueof === void 0) {
+		for (const value of values) if (value != null && (max < value || max === void 0 && value >= value)) max = value;
+	} else {
+		let index = -1;
+		for (let value of values) if ((value = valueof(value, ++index, values)) != null && (max < value || max === void 0 && value >= value)) max = value;
+	}
+	return max;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/d3-array@3.2.4/node_modules/d3-array/src/min.js
+function min(values, valueof) {
+	let min;
+	if (valueof === void 0) {
+		for (const value of values) if (value != null && (min > value || min === void 0 && value >= value)) min = value;
+	} else {
+		let index = -1;
+		for (let value of values) if ((value = valueof(value, ++index, values)) != null && (min > value || min === void 0 && value >= value)) min = value;
+	}
+	return min;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/d3-array@3.2.4/node_modules/d3-array/src/quickselect.js
+function quickselect(array, k, left = 0, right = Infinity, compare) {
+	k = Math.floor(k);
+	left = Math.floor(Math.max(0, left));
+	right = Math.floor(Math.min(array.length - 1, right));
+	if (!(left <= k && k <= right)) return array;
+	compare = compare === void 0 ? ascendingDefined : compareDefined(compare);
+	while (right > left) {
+		if (right - left > 600) {
+			const n = right - left + 1;
+			const m = k - left + 1;
+			const z = Math.log(n);
+			const s = .5 * Math.exp(2 * z / 3);
+			const sd = .5 * Math.sqrt(z * s * (n - s) / n) * (m - n / 2 < 0 ? -1 : 1);
+			const newLeft = Math.max(left, Math.floor(k - m * s / n + sd));
+			const newRight = Math.min(right, Math.floor(k + (n - m) * s / n + sd));
+			quickselect(array, k, newLeft, newRight, compare);
+		}
+		const t = array[k];
+		let i = left;
+		let j = right;
+		swap(array, left, k);
+		if (compare(array[right], t) > 0) swap(array, left, right);
+		while (i < j) {
+			swap(array, i, j), ++i, --j;
+			while (compare(array[i], t) < 0) ++i;
+			while (compare(array[j], t) > 0) --j;
+		}
+		if (compare(array[left], t) === 0) swap(array, left, j);
+		else ++j, swap(array, j, right);
+		if (j <= k) left = j + 1;
+		if (k <= j) right = j - 1;
+	}
+	return array;
+}
+function swap(array, i, j) {
+	const t = array[i];
+	array[i] = array[j];
+	array[j] = t;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/d3-array@3.2.4/node_modules/d3-array/src/quantile.js
+function quantile(values, p, valueof) {
+	values = Float64Array.from(numbers(values, valueof));
+	if (!(n = values.length) || isNaN(p = +p)) return;
+	if (p <= 0 || n < 2) return min(values);
+	if (p >= 1) return max(values);
+	var n, i = (n - 1) * p, i0 = Math.floor(i), value0 = max(quickselect(values, i0).subarray(0, i0 + 1));
+	return value0 + (min(values.subarray(i0 + 1)) - value0) * (i - i0);
+}
+function quantileSorted(values, p, valueof = number) {
+	if (!(n = values.length) || isNaN(p = +p)) return;
+	if (p <= 0 || n < 2) return +valueof(values[0], 0, values);
+	if (p >= 1) return +valueof(values[n - 1], n - 1, values);
+	var n, i = (n - 1) * p, i0 = Math.floor(i), value0 = +valueof(values[i0], i0, values);
+	return value0 + (+valueof(values[i0 + 1], i0 + 1, values) - value0) * (i - i0);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/d3-array@3.2.4/node_modules/d3-array/src/range.js
+function range(start, stop, step) {
+	start = +start, stop = +stop, step = (n = arguments.length) < 2 ? (stop = start, start = 0, 1) : n < 3 ? 1 : +step;
+	var i = -1, n = Math.max(0, Math.ceil((stop - start) / step)) | 0, range = new Array(n);
+	while (++i < n) range[i] = start + i * step;
+	return range;
+}
+//#endregion
+export { tickStep as a, bisector as c, tickIncrement as i, ascending as l, quantile as n, ticks as o, quantileSorted as r, bisectRight as s, range as t };