gemi 0.74.1 → 0.76.0

package/dist/chunks/{ThemeProvider-D9v0VAbY.js → ThemeProvider-BiNFL6l7.js}

@@ -32,24 +32,72 @@ var Subject = class {
 * An HTTP failure from a query endpoint, in a shape an error boundary can
 * work with. `resolveVariant` used to store the parsed response body as the
 * error; boundaries expect an `Error`, so the body moves to a field.
+*
+* `body` is `null` when the error response was not JSON (a proxy's HTML 502
+* page, a CDN's 404). `retryAfter` is the response's `Retry-After` header in
+* ms, when it sent one — background retries wait that long.
 */
 var QueryError = class extends Error {
 	path;
 	variantKey;
 	status;
 	body;
-	constructor(path, variantKey, status, body) {
+	retryAfter;
+	constructor(path, variantKey, status, body, retryAfter) {
 		super(typeof body?.message === "string" ? body.message : `Request to /api${path} failed with status ${status}`);
 		this.path = path;
 		this.variantKey = variantKey;
 		this.status = status;
 		this.body = body;
+		this.retryAfter = retryAfter;
 		this.name = "QueryError";
 	}
 };
+var DEFAULT_RETRY_BASE_DELAY = 1e3;
+var MAX_RETRY_DELAY = 3e4;
+/**
+* A failure that another attempt might fix: no answer at all (offline, a
+* dropped connection), a 2xx body that failed to parse, 408, 429 or any 5xx.
+* Every other status — 400, 401, 403, 404, 410, 422, … — says the request
+* itself is the problem, so sending it again gets the same answer.
+*/
+function isRetryableQueryError(error) {
+	if (error instanceof QueryError) return error.status === 408 || error.status === 429 || error.status >= 500;
+	return error != null;
+}
+function shouldRetryQuery(failureCount, error, retry = 3) {
+	if (typeof retry === "function") return retry(failureCount, error);
+	if (retry === false || !isRetryableQueryError(error)) return false;
+	if (retry === true) return true;
+	return failureCount <= retry;
+}
+/**
+* `baseDelay * 2^(failureCount - 1)`, capped at 30s: 1s, 2s, 4s, … by default.
+* A `Retry-After` the server sent (a 429 or 503) is honoured as is.
+*/
+function retryDelayFor(failureCount, error, retryDelay, baseDelay = DEFAULT_RETRY_BASE_DELAY) {
+	if (error instanceof QueryError && error.retryAfter !== void 0) return error.retryAfter;
+	if (typeof retryDelay === "function") return retryDelay(failureCount, error);
+	if (typeof retryDelay === "number") return retryDelay;
+	return Math.min(baseDelay * 2 ** Math.max(0, failureCount - 1), Math.max(MAX_RETRY_DELAY, baseDelay));
+}
+/**
+* A `Retry-After` header value in ms: delta-seconds or an HTTP date.
+* `undefined` when absent or unreadable.
+*/
+function parseRetryAfter(value, now = Date.now()) {
+	if (value == null) return void 0;
+	const trimmed = value.trim();
+	if (trimmed === "") return void 0;
+	if (/^\d+$/.test(trimmed)) return Number(trimmed) * 1e3;
+	const date = Date.parse(trimmed);
+	if (Number.isNaN(date)) return void 0;
+	return Math.max(0, date - now);
+}
 //#endregion
 //#region client/QueryResource.ts
 var DEFAULT_STALE_TIME = 5e3;
+var MAX_TIMEOUT = 2 ** 31 - 1;
 var QueryResource = class {
 	store;
 	staleVariants = /* @__PURE__ */ new Set();
@@ -77,6 +125,18 @@ var QueryResource = class {
 	* the wire at once.
 	*/
 	watchers = /* @__PURE__ */ new Map();
+	/**
+	* Consecutive failed fetches per variant. A background retry adds to the
+	* count; any other fetch that fails starts it again at 1, and a success
+	* clears it. `useQuery`'s retry policy reads it to decide whether to go
+	* again and how long to wait.
+	*/
+	failures = /* @__PURE__ */ new Map();
+	/**
+	* At most one scheduled retry per variant, however many mounted readers
+	* render it — each of them sees the same failure and asks for one.
+	*/
+	retryTimers = /* @__PURE__ */ new Map();
 	constructor(key, initialState) {
 		this.key = key;
 		this.store = new Subject(/* @__PURE__ */ new Map());
@@ -108,6 +168,8 @@ var QueryResource = class {
 			});
 			this.staleVariants.delete(variantKey);
 			this.lastFetchRecord.set(variantKey, now);
+			this.failures.delete(variantKey);
+			this.cancelRetry(variantKey);
 			this.settle(variantKey);
 			changed = true;
 		}
@@ -255,9 +317,53 @@ var QueryResource = class {
 			released = true;
 			const count = (this.watchers.get(variantKey) ?? 1) - 1;
 			if (count > 0) this.watchers.set(variantKey, count);
-			else this.watchers.delete(variantKey);
+			else {
+				this.watchers.delete(variantKey);
+				this.cancelRetry(variantKey);
+			}
 		};
 	}
+	/** How many fetches of this variant have failed in a row (0 after a success). */
+	failureCount(variantKey) {
+		return this.failures.get(variantKey) ?? 0;
+	}
+	/**
+	* Retry a failed variant after `delay` ms. A no-op while a retry is already
+	* scheduled or a request is on the wire. When the timer fires, the retry
+	* only goes out if the variant still sits on an error and is still
+	* rendered by someone.
+	*/
+	scheduleRetry(variantKey, delay) {
+		if (typeof window === "undefined") return;
+		if (this.retryTimers.has(variantKey) || this.inflight.has(variantKey)) return;
+		const timer = setTimeout(() => {
+			this.retryTimers.delete(variantKey);
+			if (!this.watchers.has(variantKey)) return;
+			if (this.inflight.has(variantKey)) return;
+			const state = this.peek(variantKey);
+			if (!state?.error || state.loading) return;
+			this.resolveVariant(variantKey, state.hasData, true, true);
+		}, Math.min(Math.max(0, delay || 0), MAX_TIMEOUT));
+		this.retryTimers.set(variantKey, timer);
+	}
+	cancelRetry(variantKey) {
+		const timer = this.retryTimers.get(variantKey);
+		if (timer !== void 0) {
+			clearTimeout(timer);
+			this.retryTimers.delete(variantKey);
+		}
+	}
+	/**
+	* Refetch a failed variant now, silently — the browser came back online.
+	* Starts a fresh run of failures, so the retry policy applies in full again.
+	*/
+	retryNow(variantKey) {
+		if (typeof window === "undefined") return;
+		if (this.inflight.has(variantKey)) return;
+		const state = this.peek(variantKey);
+		if (!state?.error || state.loading) return;
+		this.resolveVariant(variantKey, true);
+	}
 	/** Every variant key this resource holds state for, in insertion order. */
 	variantKeys() {
 		return [...this.store.getValue().keys()];
@@ -312,9 +418,13 @@ var QueryResource = class {
 	refetch(variantKey) {
 		this.resolveVariant(variantKey, false, false);
 	}
-	async resolveVariant(variantKey, silent = false, cache = true) {
+	async resolveVariant(variantKey, silent = false, cache = true, isRetry = false) {
 		if (typeof window === "undefined") return;
+		this.cancelRetry(variantKey);
 		this.inflight.add(variantKey);
+		const recordFailure = () => {
+			this.failures.set(variantKey, isRetry ? (this.failures.get(variantKey) ?? 0) + 1 : 1);
+		};
 		try {
 			const store = this.store.getValue();
 			const previousState = store.get(variantKey);
@@ -330,9 +440,15 @@ var QueryResource = class {
 			const fullUrl = [this.key, variantKey].filter((s) => s.length).join("?");
 			try {
 				response = await fetch(`/api${fullUrl}`, { cache: cache && !this.staleVariants.has(variantKey) ? "default" : "reload" });
-				data = await response.json();
+				try {
+					data = await response.json();
+				} catch (parseError) {
+					if (response.ok) throw parseError;
+					data = null;
+				}
 			} catch (error) {
 				console.error(`Error fetching url /api${fullUrl}`, error);
+				recordFailure();
 				this.store.next(store.set(variantKey, {
 					loading: false,
 					data: previousState?.data,
@@ -352,13 +468,17 @@ var QueryResource = class {
 				}));
 				this.staleVariants.delete(variantKey);
 				this.lastFetchRecord.set(variantKey, Date.now());
-			} else this.store.next(store.set(variantKey, {
-				loading: false,
-				data: previousState?.data,
-				hasData: previousState?.hasData ?? false,
-				error: new QueryError(this.key, variantKey, response.status, data),
-				version: previousState?.version
-			}));
+				this.failures.delete(variantKey);
+			} else {
+				recordFailure();
+				this.store.next(store.set(variantKey, {
+					loading: false,
+					data: previousState?.data,
+					hasData: previousState?.hasData ?? false,
+					error: new QueryError(this.key, variantKey, response.status, data, parseRetryAfter(response.headers?.get?.("retry-after"))),
+					version: previousState?.version
+				}));
+			}
 		} finally {
 			this.inflight.delete(variantKey);
 			this.settle(variantKey);
@@ -381,15 +501,32 @@ var APP_WIDE_QUERY_CONFIG_KEYS = [
 	"suspense",
 	"staleTime",
 	"keepPreviousData",
+	"retry",
+	"retryDelay",
 	"retryIntervalOnError",
 	"refreshInterval",
 	"revalidateOnFocus",
 	"focusThrottleInterval"
 ];
+var USER_QUERY_CONFIG_KEYS = [
+	"staleTime",
+	"retry",
+	"retryDelay",
+	"revalidateOnFocus",
+	"focusThrottleInterval",
+	"refreshInterval"
+];
+/** Copy the listed keys whose value is defined. */
+function pickDefined(source, keys) {
+	const picked = {};
+	if (!source) return picked;
+	for (const key of keys) if (source[key] !== void 0) picked[key] = source[key];
+	return picked;
+}
 function pickAppWideQueryConfig(queryConfig) {
 	if (!queryConfig) return null;
-	const picked = {};
-	for (const key of APP_WIDE_QUERY_CONFIG_KEYS) if (queryConfig[key] !== void 0) picked[key] = queryConfig[key];
+	const picked = pickDefined(queryConfig, APP_WIDE_QUERY_CONFIG_KEYS);
+	if (queryConfig.user) picked.user = pickDefined(queryConfig.user, USER_QUERY_CONFIG_KEYS);
 	return picked;
 }
 var QueryManagerContext = createContext({
@@ -3109,6 +3246,6 @@ function useTheme() {
 	return context;
 }
 //#endregion
-export { isAbsoluteUrl as A, QueryError as B, useNavigate as C, ServerDataProvider as D, ServerDataContext as E, applyParams as F, QueryConfigContext as I, QueryManagerContext as L, Action as M, createMemoryHistory as N, useLocation as O, toVariantKey as P, QueryManagerProvider as R, useSearchParams as S, I18nProvider as T, Subject as V, registerDictionary as _, m as a, routeDataUrl as b, ClientRouterContext as c, ComponentsProvider as d, initialViewModulesReady as f, loadDictionaryForRender as g, loadDictionary as h, WebSocketContextProvider as i, ProgressManager as j, domainUrl as k, ClientRouterProvider as l, subscribeViewModules as m, useTheme as n, RouteTransitionProvider as o, loadViewModule as p, WebSocketContext as r, useRouteTransition as s, ThemeProvider as t, ComponentsContext as u, setActiveLocale as v, I18nContext as w, useRoute as x, readRoutePayload as y, DEFAULT_STALE_TIME as z };
+export { isAbsoluteUrl as A, pickDefined as B, useNavigate as C, ServerDataProvider as D, ServerDataContext as E, applyParams as F, QueryError as G, isRetryableQueryError as H, QueryConfigContext as I, Subject as K, QueryManagerContext as L, Action as M, createMemoryHistory as N, useLocation as O, toVariantKey as P, QueryManagerProvider as R, useSearchParams as S, I18nProvider as T, retryDelayFor as U, DEFAULT_STALE_TIME as V, shouldRetryQuery as W, registerDictionary as _, m as a, routeDataUrl as b, ClientRouterContext as c, ComponentsProvider as d, initialViewModulesReady as f, loadDictionaryForRender as g, loadDictionary as h, WebSocketContextProvider as i, ProgressManager as j, domainUrl as k, ClientRouterProvider as l, subscribeViewModules as m, useTheme as n, RouteTransitionProvider as o, loadViewModule as p, WebSocketContext as r, useRouteTransition as s, ThemeProvider as t, ComponentsContext as u, setActiveLocale as v, I18nContext as w, useRoute as x, readRoutePayload as y, USER_QUERY_CONFIG_KEYS as z };
 
-//# sourceMappingURL=ThemeProvider-D9v0VAbY.js.map
+//# sourceMappingURL=ThemeProvider-BiNFL6l7.js.map