gemi 0.129.0 → 0.131.0

package/dist/client/index.js

@@ -1,5 +1,6 @@
-import { $ as DEFAULT_STALE_TIME, A as ServerDataContext, B as configureRealtime, C as readRoutePayload, D as useNavigate, E as useSearchParams, G as reconnectRealtime, H as followLive, I as Action, J as QueryConfigContext, K as toVariantKey, M as useLocation, N as domainUrl, O as I18nContext, P as isAbsoluteUrl, Q as pickDefined, R as RealtimeContext, S as setActiveLocale, T as useRoute, U as loadedModule, V as currentSocketId, X as QueryManagerProvider, Y as QueryManagerContext, Z as USER_QUERY_CONFIG_KEYS, _ as isChunkLoadError, a as useRouteTransition, at as Subject, b as loadDictionaryForRender, c as ClientRouterContext, d as ComponentsProvider, et as isRetryableQueryError, f as initialViewModulesReady, g as configureChunkLoadRecovery, h as CHUNK_RELOAD_MARKER, i as RouteTransitionProvider, it as QueryError, j as ServerDataProvider, k as I18nProvider, l as ClientRouterProvider, m as subscribeViewModules, n as useTheme, nt as retryDelayFor, o as useChannelSubscription, p as loadViewModule, q as applyParams$1, r as m, rt as shouldRetryQuery, s as useCoalesced, t as ThemeProvider, tt as parseRetryAfter, u as ComponentsContext, v as recoverFromChunkLoadError, w as routeDataUrl, x as registerDictionary, y as loadDictionary } from "../chunks/ThemeProvider-DaX0eyqs.js";
+import { $ as DEFAULT_STALE_TIME, A as ServerDataContext, B as followLive, C as readRoutePayload, D as useNavigate, E as useSearchParams, G as loadedModule, H as realtime, I as Action, J as QueryConfigContext, K as toVariantKey, M as useLocation, N as domainUrl, O as I18nContext, P as isAbsoluteUrl, Q as pickDefined, R as RealtimeContext, S as setActiveLocale, T as useRoute, U as reconnectRealtime, W as loadLazy, X as QueryManagerProvider, Y as QueryManagerContext, Z as USER_QUERY_CONFIG_KEYS, _ as isChunkLoadError, a as useRouteTransition, at as Subject, b as loadDictionaryForRender, c as ClientRouterContext, d as ComponentsProvider, et as isRetryableQueryError, f as initialViewModulesReady, g as configureChunkLoadRecovery, h as CHUNK_RELOAD_MARKER, i as RouteTransitionProvider, it as QueryError, j as ServerDataProvider, k as I18nProvider, l as ClientRouterProvider, m as subscribeViewModules, n as useTheme, nt as retryDelayFor, o as useChannelSubscription, p as loadViewModule, q as applyParams$1, r as m, rt as shouldRetryQuery, s as useCoalesced, t as ThemeProvider, u as ComponentsContext, v as recoverFromChunkLoadError, w as routeDataUrl, x as registerDictionary, y as loadDictionary, z as configureRealtime } from "../chunks/ThemeProvider-gWqXjGh-.js";
 import { n as RouteStateContext, r as RouteStateProvider, t as useParams } from "../chunks/useParams-BN3XXfmG.js";
+import { a as isNetworkError, c as isPermissionError, d as isValidationError, f as mutationErrorField, h as mutationErrorList, i as isHttpError, l as isRateLimitError, m as mutationErrorKind, n as isCsrfError, o as isNotFoundError, p as mutationErrorFromBody, r as isFormError, s as isObject, t as isAuthenticationError, u as isServerError } from "../chunks/MutationError-DuKqBW8o.js";
 import { Fragment, StrictMode, Suspense, createContext, createElement, isValidElement, lazy, memo, use, useCallback, useContext, useDeferredValue, useEffect, useMemo, useRef, useState, useSyncExternalStore, useTransition } from "react";
 import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
 import { createRoot as createRoot$1, hydrateRoot } from "react-dom/client";
@@ -535,221 +536,6 @@ function useInfiniteQuery(url, options, config) {
 	};
 }
 //#endregion
-//#region http/refusal.ts
-/**
-* The kind a status stands for, for a refusal that does not name one: an app's
-* own `RequestBreakerError`, or an older server's `{ message }`. Any other 4xx
-* is a `form_error`, a message about this request for `<FormError>` to show.
-*/
-function refusalKindForStatus(status) {
-	if (status === 401) return "authentication";
-	if (status === 403) return "permission";
-	if (status === 404) return "not_found";
-	if (status === 416) return "range_not_satisfiable";
-	if (status === 429) return "rate_limit";
-	if (status >= 500) return "server_error";
-	return "form_error";
-}
-//#endregion
-//#region client/MutationError.ts
-var LEGACY_MESSAGES = {
-	"Authentication error": "authentication",
-	"Not authorized": "authorization",
-	"Insufficient permissions": "permission",
-	"Invalid CSRF token": "csrf",
-	"Internal Server Error": "server_error",
-	Forbidden: "permission",
-	"Not found": "not_found",
-	"Rate limit exceeded": "rate_limit"
-};
-function isObject(error) {
-	return typeof error === "object" && error !== null;
-}
-function legacyKind(message, status) {
-	return LEGACY_MESSAGES[message] ?? (status === 401 ? "authorization" : refusalKindForStatus(status));
-}
-/**
-* The `MutationError` a non-2xx response's parsed body stands for.
-*
-* gemi's own error bodies are `{ error }`, and the value under `error` is what
-* is handed over. An app's body without one —
-* `HttpResponse.json({ message: "Taken" }, { status: 409 })` — is handed over
-* whole. A body with no content (`null`) becomes a refusal naming the status.
-*
-* What is handed over carries `status`, and a `kind` when it has a `message`:
-* a bare string, which servers before 0.88 sent for most refusals, becomes
-* `{ kind, message, status }`, and so does a `{ message }` without a kind.
-*
-* @internal
-*/
-function mutationErrorFromBody(body, status) {
-	const error = isObject(body) && "error" in body && body.error != null ? body.error : body;
-	if (error == null) return {
-		kind: refusalKindForStatus(status),
-		message: `Request failed with status ${status}`,
-		status
-	};
-	if (typeof error === "string") return {
-		kind: legacyKind(error, status),
-		message: error,
-		status
-	};
-	if (!isObject(error) || error instanceof Error) return error;
-	const withStatus = {
-		...error,
-		status: typeof error.status === "number" ? error.status : status
-	};
-	if (typeof error.kind !== "string" && typeof error.message === "string") return {
-		...withStatus,
-		kind: refusalKindForStatus(withStatus.status)
-	};
-	return withStatus;
-}
-function kindOf(error) {
-	if (typeof error === "string") return LEGACY_MESSAGES[error];
-	if (!isObject(error) || error instanceof Error) return void 0;
-	if (typeof error.kind === "string") return error.kind;
-	if (typeof error.status === "number") return refusalKindForStatus(error.status);
-	return typeof error.message === "string" ? LEGACY_MESSAGES[error.message] : void 0;
-}
-/** Field messages, as `<ValidationErrors>` renders them. */
-function isValidationError(error) {
-	return isObject(error) && error.kind === "validation_error";
-}
-/** A form-level message, as `<FormError>` renders it. */
-function isFormError(error) {
-	return isObject(error) && error.kind === "form_error";
-}
-/** No signed-in user: `AuthenticationError` (401). */
-function isAuthenticationError(error) {
-	return kindOf(error) === "authentication";
-}
-/**
-* A signed-in user who may not do this: `InsufficientPermissionsError` (403),
-* `AuthorizationError` (401) or a policy denial (403), whatever message it was
-* thrown with.
-*/
-function isPermissionError(error) {
-	const kind = kindOf(error);
-	return kind === "permission" || kind === "authorization";
-}
-/** The CSRF cookie is missing or stale (403). A reload fixes it. */
-function isCsrfError(error) {
-	return kindOf(error) === "csrf";
-}
-/** A missing record, file or route (404). */
-function isNotFoundError(error) {
-	return kindOf(error) === "not_found";
-}
-/**
-* `RateLimitMiddleware` or `RateLimiter.enforce` refused the request (429).
-* `retryAfter` (ms) says when to try again, when the server sent it.
-*/
-function isRateLimitError(error) {
-	return kindOf(error) === "rate_limit";
-}
-/**
-* The server failed (a 500, under `gemi dev` too), or answered something that
-* is not JSON.
-*/
-function isServerError(error) {
-	return kindOf(error) === "server_error" || error instanceof SyntaxError;
-}
-/** The request got no answer: offline, DNS, CORS, a dropped connection. */
-function isNetworkError(error) {
-	return error instanceof TypeError;
-}
-/**
-* Which of the guards above `error` passes, for a `switch` over all of them.
-* `"unknown"` is everything else: a 416, an error body of the app's own shape.
-*/
-function mutationErrorKind(error) {
-	if (isValidationError(error)) return "validation";
-	if (isFormError(error)) return "form";
-	if (isAuthenticationError(error)) return "authentication";
-	if (isPermissionError(error)) return "permission";
-	if (isCsrfError(error)) return "csrf";
-	if (isNotFoundError(error)) return "not_found";
-	if (isRateLimitError(error)) return "rate_limit";
-	if (isServerError(error)) return "server";
-	if (isNetworkError(error)) return "network";
-	return "unknown";
-}
-/**
-* An error answered with `status`: a route's typed error from
-* `HttpResponse.error(status, body)` / `httpError`, narrowed to the members
-* of `error`'s type with that status.
-*
-* ```ts
-* onError: (error) => {
-*   if (isHttpError(error, 410)) toast(error.message);
-* }
-* ```
-*
-* At run time it checks the status alone, so gemi's own refusals with the
-* same status (a 404 `not_found`, a 429 `rate_limit`) pass it too; pick a
-* status gemi does not use for its own errors, or check `kind` after it.
-*/
-function isHttpError(error, status) {
-	return isObject(error) && !(error instanceof Error) && error.status === status;
-}
-var FALLBACK_MESSAGE = "Something went wrong. Try again.";
-function unwrapQueryError(error) {
-	if (error instanceof Error && error.name === "QueryError" && "body" in error) {
-		const { body, status } = error;
-		return body == null ? error : mutationErrorFromBody(body, status);
-	}
-	return error;
-}
-/**
-* `error.list(fallback)` for any value: an error kept from a mutation, a
-* `useQuery` `QueryError` (its body is read), or anything else.
-*/
-function mutationErrorList(error, fallback = FALLBACK_MESSAGE) {
-	const value = unwrapQueryError(error);
-	if (isValidationError(value)) {
-		const messages = Object.values(value.messages ?? {}).flat().filter((message) => typeof message === "string" && message !== "");
-		return messages.length > 0 ? messages : [fallback];
-	}
-	if (isObject(value) && !(value instanceof Error) && value.kind !== "server_error" && typeof value.message === "string" && value.message !== "") return [value.message];
-	return [fallback];
-}
-/**
-* `error.field(name)` for any value: a validation error's messages for
-* `name` (a `QueryError`'s body is read), `[]` for anything else.
-*/
-function mutationErrorField(error, name) {
-	const value = unwrapQueryError(error);
-	if (!isValidationError(value)) return [];
-	const messages = value.messages?.[name];
-	return Array.isArray(messages) ? [...messages] : [];
-}
-/**
-* Puts `list` and `field` on an error the hooks hand over, as non-enumerable
-* properties, so `toEqual`, a spread and `JSON.stringify` see the same object
-* as before. A key the error already has is left alone; a primitive or a
-* frozen value is returned as it is.
-*
-* @internal
-*/
-function withMutationErrorHelpers(error) {
-	if (!isObject(error) || !Object.isExtensible(error)) return error;
-	const helpers = {
-		list: (fallback) => mutationErrorList(error, fallback),
-		field: (name) => mutationErrorField(error, name)
-	};
-	for (const key of ["list", "field"]) {
-		if (key in error) continue;
-		Object.defineProperty(error, key, {
-			value: helpers[key],
-			configurable: true,
-			writable: true,
-			enumerable: false
-		});
-	}
-	return error;
-}
-//#endregion
 //#region services/broadcast/socketHeader.ts
 /**
 * The request header a client sends its socket id in, for `toOthers`.
@@ -760,67 +546,26 @@ function withMutationErrorHelpers(error) {
 */
 var SOCKET_ID_HEADER = "x-gemi-socket";
 //#endregion
-//#region client/useSetQueryData.ts
-/**
-* Write into every variant `target` names. `next` is the value to write, or
-* a function of the cached value; a function skips a variant with nothing
-* cached. A value seeds a single variant that is not cached yet; a predicate
-* only ever reaches variants that are.
-*/
-function writeQueryData(getResource, routeParams, target, next) {
-	const { path, params = {}, search = {} } = target;
-	const resource = getResource(applyParams$1(String(path), {
-		...routeParams,
-		...params
-	}));
-	const write = (variantKey) => {
-		if ("value" in next) {
-			resource.set(variantKey, next.value);
-			return;
-		}
-		const state = resource.peek(variantKey);
-		if (!state?.hasData) return;
-		resource.set(variantKey, next.update(state.data));
-	};
-	if (typeof search === "function") {
-		for (const variantKey of resource.variantKeys()) {
-			if (!resource.peek(variantKey)?.hasData) continue;
-			if (search(new URLSearchParams(variantKey))) write(variantKey);
-		}
-		return;
-	}
-	write(toVariantKey(search));
-}
-/**
-* Write a mutation's `updates` with its answer.
-*/
-function applyQueryUpdates(getResource, routeParams, updates, answer) {
-	for (const update of updates ?? []) {
-		const { data } = update;
-		writeQueryData(getResource, routeParams, update, data ? { update: (current) => data(answer, current) } : { value: answer });
-	}
-}
+//#region client/mutationModules.ts
 /**
-* Returns a function that writes into any query's cache by path, with no
-* refetch: for data the server already answered with. `useMutate` is the
-* optimistic counterpart, which refetches to reconcile.
-*
-* ```ts
-* const setQueryData = useSetQueryData();
-* setQueryData({ path: "/pages/:pageId/assets", params: { pageId } }, assets);
-* setQueryData({ path: "/todos", search: () => true }, (todos) => todos.slice(1));
-* ```
+* `./mutationExtras`, which a page only needs once it mutates: loaded when the
+* first mutation hook, or `useSetQueryData()`, mounts (#915), so no route's
+* entry chunk carries it. By the time a request settles it is normally there;
+* one that settles first waits for it.
 *
-* A value replaces the variant's data, and seeds it when nothing is cached
-* yet. A function updates what is cached and skips a variant with nothing
-* cached. A predicate `search` reaches every cached variant it accepts.
+* Keep this module out of `gemi/testing`'s imports. Shared with that entry, it
+* moves into the chunk both entries import, and there an app's bundler can
+* emit `./mutationExtras` even for an app that never mutates, which splits the
+* app's entry chunk ("needs no chunk besides the entry to start" in
+* `packaging.test.ts`).
 */
-function useSetQueryData() {
-	const { getResource } = useContext(QueryManagerContext);
-	const routeParams = useParams();
-	return useCallback(function setQueryData(target, next) {
-		writeQueryData(getResource, routeParams, target, typeof next === "function" ? { update: next } : { value: next });
-	}, [getResource, routeParams]);
+var mutationExtras = {
+	current: null,
+	load: () => import("../chunks/mutationExtras-CtY-X9m7.js")
+};
+/** Starts loading `./mutationExtras`: the hooks' mount effect. */
+function preloadMutationExtras() {
+	loadLazy(mutationExtras).catch(() => {});
 }
 //#endregion
 //#region client/useMutation.ts
@@ -855,6 +600,7 @@ function useMutation(method, url, ...args) {
 		...config
 	};
 	const parallel = options.concurrency === "parallel";
+	useEffect(preloadMutationExtras, []);
 	async function trigger(input, call = {}) {
 		const controller = new AbortController();
 		abortController.current = controller;
@@ -897,24 +643,26 @@ function useMutation(method, url, ...args) {
 		if (input instanceof FormData) body = input;
 		else if (typeof input === "undefined") body = formData.current;
 		else if (input) body = JSON.stringify(input);
+		const socketId = realtime.client?.socketId;
 		try {
 			const response = await fetch(`/api${finalUrl}`, {
 				method,
 				headers: {
 					...contentType,
-					...socketIdHeader()
+					...socketId ? { [SOCKET_ID_HEADER]: socketId } : {}
 				},
 				...body ? { body } : {},
 				signal: controller.signal
 			});
 			const data = await response.json();
+			const error = response.ok ? null : await withErrorHelpers(mutationErrorFromBody(data, response.status));
+			const extras = response.ok && options.updates ? await loadOrNull() : null;
 			if (isSuperseded()) {
 				settle((prev) => prev, true);
 				return;
 			}
 			resetFormData();
 			if (!response.ok) {
-				const error = withMutationErrorHelpers(mutationErrorFromBody(data, response.status));
 				settle((prev) => ({
 					data: prev.data,
 					error
@@ -924,7 +672,7 @@ function useMutation(method, url, ...args) {
 				return;
 			}
 			clearPrefetchCache?.();
-			applyQueryUpdates(getResource, _params, options.updates, data);
+			extras?.applyQueryUpdates(getResource, _params, options.updates, data);
 			options.onSuccess(data);
 			call.onSuccess?.(data);
 			settle(() => ({
@@ -932,7 +680,8 @@ function useMutation(method, url, ...args) {
 				error: null
 			}));
 			return data;
-		} catch (error) {
+		} catch (thrown) {
+			const error = await withErrorHelpers(thrown);
 			if (isSuperseded()) {
 				settle((prev) => prev, true);
 				return;
@@ -942,12 +691,11 @@ function useMutation(method, url, ...args) {
 				settle((prev) => prev);
 				return;
 			}
-			const failure = withMutationErrorHelpers(error);
-			options.onError(failure);
-			call.onError?.(failure);
+			options.onError(error);
+			call.onError?.(error);
 			settle((prev) => ({
 				data: parallel ? prev.data : null,
-				error: failure
+				error
 			}));
 		}
 	}
@@ -995,6 +743,7 @@ function useUpload(url, ...args) {
 	const { getResource } = useContext(QueryManagerContext);
 	const abortRef = useRef(null);
 	const [inputs = {}, options = defaultOptions] = args ?? [];
+	useEffect(preloadMutationExtras, []);
 	const cancel = () => {
 		const abort = abortRef.current;
 		if (!abort) return;
@@ -1064,20 +813,22 @@ function useUpload(url, ...args) {
 				try {
 					error = mutationErrorFromBody(JSON.parse(outcome.body), outcome.status);
 				} catch {}
+				const failure = await withErrorHelpers(error);
 				setState("error");
-				options?.onError?.(withMutationErrorHelpers(error));
+				options?.onError?.(failure);
 				return;
 			}
 			const json = JSON.parse(outcome.body);
 			clearPrefetchCache?.();
-			applyQueryUpdates(getResource, _params, options?.updates, json);
+			if (options.updates) (await loadOrNull())?.applyQueryUpdates(getResource, _params, options.updates, json);
 			options?.onSuccess?.(json);
 			setState("done");
 			return json;
 		} catch (error) {
 			release();
+			const failure = await withErrorHelpers(error);
 			setState("error");
-			options?.onError?.(withMutationErrorHelpers(error));
+			options?.onError?.(failure);
 			return;
 		}
 	};
@@ -1088,13 +839,17 @@ function useUpload(url, ...args) {
 		cancel
 	};
 }
-/**
-* `X-Gemi-Socket` with this tab's broadcast socket id, while one is open, so
-* a controller's `Broadcast.toOthers(req)` skips the tab that made the change.
-*/
-function socketIdHeader() {
-	const id = currentSocketId();
-	return id ? { [SOCKET_ID_HEADER]: id } : {};
+function loadOrNull() {
+	return loadLazy(mutationExtras).catch(() => null);
+}
+async function withErrorHelpers(error) {
+	const extras = await loadOrNull();
+	if (extras) return extras.withMutationErrorHelpers(error);
+	if (isObject(error) && Object.isExtensible(error) && !("list" in error)) Object.defineProperties(error, {
+		list: { value: (fallback = "Something went wrong. Try again.") => [fallback] },
+		field: { value: () => [] }
+	});
+	return error;
 }
 //#endregion
 //#region client/useMutate.ts
@@ -1142,6 +897,10 @@ function useMutate() {
 }
 //#endregion
 //#region client/fetchFile.ts
+var request = {
+	current: null,
+	load: () => import("../chunks/fetchFileRequest-BSrgYnAy.js")
+};
 /**
 * Downloads a file route's body as a `Blob`.
 *
@@ -1156,62 +915,52 @@ function useMutate() {
 * `retryAfter`), the error `useQuery` throws, so `mutationErrorList(error)`
 * reads its message. A network failure rejects with the browser's `TypeError`,
 * an abort with its `AbortError`.
+*
+* The request code loads on the first call (#915), so a route that never
+* downloads a file carries none of it; a failed load rejects as a network
+* failure does.
 */
 async function fetchBlob(path, ...args) {
-	const response = await request(path, args[0]);
-	return {
-		blob: await response.blob(),
-		filename: filenameOf(response),
-		response
-	};
+	return (await loadLazy(request)).fetchFile(path, args[0], "blob");
 }
 /** `fetchBlob`, with the body read as text. */
 async function fetchText(path, ...args) {
-	const response = await request(path, args[0]);
-	return {
-		text: await response.text(),
-		filename: filenameOf(response),
-		response
-	};
-}
-async function request(path, options = {}) {
-	const { params = {}, search, signal, init } = options;
-	const url = applyParams$1(path, params);
-	const query = searchString(search);
-	const response = await fetch(`/api${url}${query ? `?${query}` : ""}`, {
-		...init,
-		method: "GET",
-		signal
-	});
-	if (!response.ok) {
-		const body = await response.json().catch(() => null);
-		throw new QueryError(url, query, response.status, body, parseRetryAfter(response.headers.get("retry-after")));
-	}
-	return response;
-}
-function searchString(search) {
-	if (!search) return "";
-	if (search instanceof URLSearchParams) return search.toString();
-	const params = new URLSearchParams();
-	for (const [key, value] of Object.entries(search)) if (value !== null && value !== void 0) params.append(key, String(value));
-	return params.toString();
+	return (await loadLazy(request)).fetchFile(path, args[0], "text");
 }
+//#endregion
+//#region client/useSetQueryData.ts
 /**
-* The file name in a `Content-Disposition` header: the RFC 5987
-* `filename*=UTF-8''...` form when present and decodable, else `filename`.
+* Returns a function that writes into any query's cache by path, with no
+* refetch: for data the server already answered with. `useMutate` is the
+* optimistic counterpart, which refetches to reconcile.
 *
-* @internal Exported for tests.
+* ```ts
+* const setQueryData = useSetQueryData();
+* setQueryData({ path: "/pages/:pageId/assets", params: { pageId } }, assets);
+* setQueryData({ path: "/todos", search: () => true }, (todos) => todos.slice(1));
+* ```
+*
+* A value replaces the variant's data, and seeds it when nothing is cached
+* yet. A function updates what is cached and skips a variant with nothing
+* cached. A predicate `search` reaches every cached variant it accepts.
+*
+* The code behind the writes is loaded when the hook mounts. A call made
+* before it has arrived (during the first render, say) is written once it
+* has, in order.
 */
-function filenameOf(response) {
-	const header = response.headers.get("content-disposition");
-	if (!header) return null;
-	const extended = /filename\*\s*=\s*([^']*)'[^']*'([^;]+)/i.exec(header);
-	if (extended) try {
-		return decodeURIComponent(extended[2].trim());
-	} catch {}
-	const plain = /filename\s*=\s*(?:"((?:[^"\\]|\\.)*)"|([^;]+))/i.exec(header);
-	if (!plain) return null;
-	return (plain[1] !== void 0 ? plain[1].replace(/\\(.)/g, "$1") : plain[2].trim()) || null;
+function useSetQueryData() {
+	const { getResource } = useContext(QueryManagerContext);
+	const routeParams = useParams();
+	useEffect(preloadMutationExtras, []);
+	return useCallback(function setQueryData(target, next) {
+		const write = typeof next === "function" ? { update: next } : { value: next };
+		const writes = mutationExtras.current;
+		if (writes) {
+			writes.writeQueryData(getResource, routeParams, target, write);
+			return;
+		}
+		loadLazy(mutationExtras).then((loaded) => loaded.writeQueryData(getResource, routeParams, target, write)).catch(() => {});
+	}, [getResource, routeParams]);
 }
 //#endregion
 //#region client/useSubscription.ts