gemi 0.129.0 → 0.130.0

package/dist/chunks/{ThemeProvider-DaX0eyqs.js → ThemeProvider-gWqXjGh-.js}

@@ -178,18 +178,7 @@ var QueryResource = class {
 			const current = store.get(variantKey);
 			if (current?.loading) continue;
 			if (current?.hasData && current.data === data) continue;
-			store.set(variantKey, {
-				loading: false,
-				data,
-				hasData: true,
-				error: null,
-				version: now
-			});
-			this.staleVariants.delete(variantKey);
-			this.lastFetchRecord.set(variantKey, now);
-			this.failures.delete(variantKey);
-			this.cancelRetry(variantKey);
-			this.settle(variantKey);
+			this.fill(store, variantKey, data, now);
 			changed = true;
 		}
 		if (changed) this.store.next(store);
@@ -463,30 +452,18 @@ var QueryResource = class {
 		}));
 		this.resolveVariant(variantKey, false, false);
 	}
-	/**
-	* Write data the server just produced (a mutation's answer) into a
-	* variant, with no refetch: unlike `mutate`, the value is not a guess to
-	* reconcile. The variant counts as freshly fetched, so its `staleTime`
-	* starts again, and a GET already on the wire for it is dropped when it
-	* lands, since it may carry the data from before the write. A reader
-	* suspended on the variant wakes up with it (#897).
-	*/
-	set(variantKey, data) {
-		this.dropHttpCache(variantKey);
-		const now = Date.now();
-		this.markApplied(variantKey);
-		this.staleVariants.delete(variantKey);
-		this.lastFetchRecord.set(variantKey, now);
-		this.failures.delete(variantKey);
-		this.cancelRetry(variantKey);
-		const store = this.store.getValue();
-		this.store.next(store.set(variantKey, {
+	fill(store, variantKey, data, now) {
+		store.set(variantKey, {
 			loading: false,
 			data,
 			hasData: true,
 			error: null,
 			version: now
-		}));
+		});
+		this.staleVariants.delete(variantKey);
+		this.lastFetchRecord.set(variantKey, now);
+		this.failures.delete(variantKey);
+		this.cancelRetry(variantKey);
 		this.settle(variantKey);
 	}
 	refetch(variantKey) {
@@ -752,44 +729,65 @@ function toVariantKey(search) {
 	return searchParams.toString();
 }
 //#endregion
-//#region client/realtime/loader.ts
-/** `pattern` and its params, canonical: two hooks on one channel share a `sub`. */
-function channelKey(pattern, params) {
-	const sorted = Object.keys(params).sort().map((key) => [key, String(params[key])]);
-	return `${pattern}\u0000${JSON.stringify(sorted)}`;
+//#region client/lazyModule.ts
+/**
+* What a lazy `import()` resolved to, or a thrown error when it is missing.
+* Vite's preload helper resolves the `import()` to `undefined` instead of
+* rejecting when a `vite:preloadError` listener handled the failure (`init`'s
+* chunk-load recovery does, as it starts a reload): treated as a failed load.
+*/
+function loadedModule(module) {
+	if (!module) throw new Error("[gemi] A lazily loaded chunk is unavailable.");
+	return module;
 }
-var configured = {};
-var instance = null;
-var loading = null;
+/**
+* The module, loading it if it is not there yet. Callers while it loads share
+* one load, so their callbacks run in call order. A failed load is not kept:
+* the next call runs `import()` again.
+*/
+function loadLazy(lazy) {
+	if (lazy.current) return Promise.resolve(lazy.current);
+	return lazy.loading ??= lazy.load().then((module) => {
+		lazy.loading = null;
+		return lazy.current = loadedModule(module);
+	}, (error) => {
+		lazy.loading = null;
+		throw error;
+	});
+}
+//#endregion
+//#region client/realtime/loader.ts
+/**
+* The tab's client, once loaded and created (`tabClient` in
+* `./RealtimeClient` creates it), and the options it is created with.
+*/
+var realtime = {
+	client: null,
+	options: {}
+};
 /**
 * Sets the socket options (`init({ realtime })` calls it). Takes effect on
 * the next connection.
 */
 function configureRealtime(options = {}) {
-	configured = {
-		...configured,
-		...options
-	};
-	instance?.configure(configured);
+	Object.assign(realtime.options, options);
+	realtime.client?.configure(realtime.options);
 }
 /** The tab's client if it is already loaded, else `null`. Never loads it. */
 function loadedRealtimeClient() {
-	return instance;
+	return realtime.client;
 }
+var loading = null;
+/** The lazily loaded client. Replaceable in tests, to simulate a failed load. */
+var lazyModules = { client: () => import("./RealtimeClient-DsWbFRC7.js") };
 /**
-* What a lazy `import()` resolved to, or a thrown error when it is missing.
-* Vite's preload helper resolves the `import()` to `undefined` instead of
-* rejecting when a `vite:preloadError` listener handled the failure (`init`'s
-* chunk-load recovery does, as it starts a reload): treated as a failed load.
+* `./live`, loaded by the first live query. `<Page>` in `gemi/testing` sets
+* `current` up front, so a live query on a provided socket subscribes during
+* its effect, as it did before the module was split out.
 */
-function loadedModule(module) {
-	if (!module) throw new Error("[gemi] A lazily loaded chunk is unavailable.");
-	return module;
-}
-/** The lazily loaded modules. Replaceable in tests, to simulate a failed load. */
-var lazyModules = {
-	client: () => import("./RealtimeClient-CqGve6h8.js"),
-	live: () => import("./live-DIUDdLrA.js").then((n) => n.t)
+var liveModule = {
+	current: null,
+	load: () => import("./live-CUdMhXHL.js").then((n) => n.n)
 };
 /**
 * The tab's client, loading its module and creating it on first use. `null`
@@ -800,41 +798,29 @@ var lazyModules = {
 */
 function loadRealtimeClient() {
 	if (typeof window === "undefined") return null;
-	if (instance) return Promise.resolve(instance);
-	loading ??= lazyModules.client().then((module) => instance ??= new (loadedModule(module)).RealtimeClient(configured)).catch((error) => {
+	if (realtime.client) return Promise.resolve(realtime.client);
+	loading ??= lazyModules.client().then((module) => loadedModule(module).tabClient()).catch((error) => {
 		loading = null;
 		throw error;
 	});
 	return loading;
 }
-var liveModule = null;
-/**
-* Makes `./live` available without loading it: `<Page>` in `gemi/testing`
-* passes it, so a live query on a provided socket subscribes during its
-* effect, as it did before the module was split out.
-*/
-function provideLiveModule(module) {
-	liveModule = module;
-}
 /**
 * Follows `useQuery`'s `live` channel until the returned function is called.
-* `./live` and the socket client are loaded on first use, so `useQuery`
-* carries only this; once both are loaded later queries subscribe at once.
-* `setOpen` reports `false` until the channel is open.
+* `./live` loads on first use and does the rest, loading the socket client
+* in turn, so `useQuery` carries only this. `setOpen` reports `false` until
+* the channel is open.
 */
 function followLive(provided, live, resource, setOpen) {
-	let cancelled = false;
-	let stop = null;
-	const start = (module, socket) => {
-		liveModule = module;
-		if (!cancelled && socket) stop = module.subscribeLive(socket, live, resource, setOpen);
+	let stop;
+	const start = (module) => {
+		if (stop === void 0) stop = module.followLive(provided, live, resource, setOpen);
 	};
-	const socket = provided ?? instance;
-	if (liveModule && socket) start(liveModule, socket);
-	else Promise.all([liveModule ?? lazyModules.live(), socket ?? loadRealtimeClient()]).then(([module, socket]) => start(loadedModule(module), socket)).catch(() => {});
+	if (liveModule.current) start(liveModule.current);
+	else loadLazy(liveModule).then(start).catch(() => {});
 	return () => {
-		cancelled = true;
 		stop?.();
+		stop = null;
 		setOpen(false);
 	};
 }
@@ -844,14 +830,7 @@ function followLive(provided, live, resource, setOpen) {
 * Never loads or creates the client.
 */
 function reconnectRealtime() {
-	instance?.reconnect();
-}
-/**
-* The open socket's id, for the `X-Gemi-Socket` header, or `null`. Never
-* loads or creates the client.
-*/
-function currentSocketId() {
-	return instance?.socketId ?? null;
+	realtime.client?.reconnect();
 }
 //#endregion
 //#region client/realtime/RealtimeContext.ts
@@ -3473,7 +3452,7 @@ function useChannelSubscription(pattern, params, handlers, enabled) {
 		};
 	}, [
 		provided,
-		pattern === null ? null : channelKey(pattern, params),
+		pattern === null ? null : JSON.stringify([pattern, params]),
 		active
 	]);
 	if (typeof window === "undefined") return active ? CLOSED : IDLE;
@@ -3629,6 +3608,6 @@ function useTheme() {
 	return context;
 }
 //#endregion
-export { DEFAULT_STALE_TIME as $, ServerDataContext as A, configureRealtime as B, readRoutePayload as C, useNavigate as D, useSearchParams as E, ProgressManager as F, reconnectRealtime as G, followLive as H, Action as I, QueryConfigContext as J, toVariantKey as K, createMemoryHistory as L, useLocation as M, domainUrl as N, I18nContext as O, isAbsoluteUrl as P, pickDefined as Q, RealtimeContext as R, setActiveLocale as S, useRoute as T, loadedModule as U, currentSocketId as V, provideLiveModule as W, QueryManagerProvider as X, QueryManagerContext as Y, USER_QUERY_CONFIG_KEYS as Z, isChunkLoadError as _, useRouteTransition as a, Subject as at, loadDictionaryForRender as b, ClientRouterContext as c, ComponentsProvider as d, isRetryableQueryError as et, initialViewModulesReady as f, configureChunkLoadRecovery as g, CHUNK_RELOAD_MARKER as h, RouteTransitionProvider as i, QueryError as it, ServerDataProvider as j, I18nProvider as k, ClientRouterProvider as l, subscribeViewModules as m, useTheme as n, retryDelayFor as nt, useChannelSubscription as o, loadViewModule as p, applyParams as q, m as r, shouldRetryQuery as rt, useCoalesced as s, ThemeProvider as t, parseRetryAfter as tt, ComponentsContext as u, recoverFromChunkLoadError as v, routeDataUrl as w, registerDictionary as x, loadDictionary as y, channelKey as z };
+export { DEFAULT_STALE_TIME as $, ServerDataContext as A, followLive as B, readRoutePayload as C, useNavigate as D, useSearchParams as E, ProgressManager as F, loadedModule as G, realtime as H, Action as I, QueryConfigContext as J, toVariantKey as K, createMemoryHistory as L, useLocation as M, domainUrl as N, I18nContext as O, isAbsoluteUrl as P, pickDefined as Q, RealtimeContext as R, setActiveLocale as S, useRoute as T, reconnectRealtime as U, liveModule as V, loadLazy as W, QueryManagerProvider as X, QueryManagerContext as Y, USER_QUERY_CONFIG_KEYS as Z, isChunkLoadError as _, useRouteTransition as a, Subject as at, loadDictionaryForRender as b, ClientRouterContext as c, ComponentsProvider as d, isRetryableQueryError as et, initialViewModulesReady as f, configureChunkLoadRecovery as g, CHUNK_RELOAD_MARKER as h, RouteTransitionProvider as i, QueryError as it, ServerDataProvider as j, I18nProvider as k, ClientRouterProvider as l, subscribeViewModules as m, useTheme as n, retryDelayFor as nt, useChannelSubscription as o, loadViewModule as p, applyParams as q, m as r, shouldRetryQuery as rt, useCoalesced as s, ThemeProvider as t, parseRetryAfter as tt, ComponentsContext as u, recoverFromChunkLoadError as v, routeDataUrl as w, registerDictionary as x, loadDictionary as y, configureRealtime as z };
 
-//# sourceMappingURL=ThemeProvider-DaX0eyqs.js.map
+//# sourceMappingURL=ThemeProvider-gWqXjGh-.js.map