gemi 0.53.0 → 0.54.1

package/dist/client/index.js

@@ -1,5 +1,5 @@
-import { A as toVariantKey, C as useLocation, D as useParams, F as DEFAULT_STALE_TIME, I as QueryError, L as Subject, M as QueryConfigContext, N as QueryManagerContext, O as RouteStateContext, P as QueryManagerProvider, S as ServerDataProvider, T as Action, _ as useSearchParams, a as m, b as I18nProvider, c as ClientRouterContext, d as ComponentsProvider, f as loadViewModule, g as useRoute, h as routeDataUrl, i as WebSocketContextProvider, j as applyParams$1, k as RouteStateProvider, l as ClientRouterProvider, m as readRoutePayload, n as useTheme, o as RouteTransitionProvider, p as subscribeViewModules, r as WebSocketContext, s as useRouteTransition, t as ThemeProvider, u as ComponentsContext, v as useNavigate, x as ServerDataContext, y as I18nContext } from "../chunks/ThemeProvider-CTX9LOFC.js";
-import { Fragment, StrictMode, Suspense, createContext, createElement, isValidElement, memo, useCallback, useContext, useDeferredValue, useEffect, useMemo, useRef, useState, useSyncExternalStore, useTransition } from "react";
+import { B as QueryError, C as I18nContext, D as useLocation, E as ServerDataProvider, F as applyParams$1, I as QueryConfigContext, L as QueryManagerContext, M as RouteStateContext, N as RouteStateProvider, P as toVariantKey, R as QueryManagerProvider, S as useNavigate, T as ServerDataContext, V as Subject, _ as setActiveLocale, a as m, b as useRoute, c as ClientRouterContext, d as ComponentsProvider, f as loadViewModule, g as registerDictionary, h as loadDictionaryForRender, i as WebSocketContextProvider, j as useParams, k as Action, l as ClientRouterProvider, m as loadDictionary, n as useTheme, o as RouteTransitionProvider, p as subscribeViewModules, r as WebSocketContext, s as useRouteTransition, t as ThemeProvider, u as ComponentsContext, v as readRoutePayload, w as I18nProvider, x as useSearchParams, y as routeDataUrl, z as DEFAULT_STALE_TIME } from "../chunks/ThemeProvider-Bk1eZymb.js";
+import { Fragment, StrictMode, Suspense, createContext, createElement, isValidElement, 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";
 //#region client/ServerQueryContext.tsx
@@ -1332,17 +1332,30 @@ function create(RootLayout, { componentTree, loaders, routeManifest, router, i18
 	}) }));
 }
 //#endregion
+//#region client/DictionarySinkContext.ts
+/**
+* The SSR-only collector `useDictionary` reports into. `null` in the browser,
+* where nothing needs collecting — the strings are already there.
+*
+* Mirrors `ServerQueryContext`: a server-supplied per-request object handed to
+* the tree by `createRoot`.
+*/
+var DictionarySinkContext = createContext(null);
+//#endregion
 //#region client/createRoot.tsx
 function createRoot(RootLayout, options = {}) {
 	return (props) => /* @__PURE__ */ jsx(ServerDataProvider, {
 		value: props.data,
 		children: /* @__PURE__ */ jsx(ServerQueryContext.Provider, {
 			value: props.serverQueries ?? null,
-			children: /* @__PURE__ */ jsx(ClientRouter, {
-				RootLayout,
-				viewImportMap: props.viewImportMap,
-				viewModules: props.viewModules,
-				queryConfig: options.queryConfig
+			children: /* @__PURE__ */ jsx(DictionarySinkContext.Provider, {
+				value: props.dictionarySink ?? null,
+				children: /* @__PURE__ */ jsx(ClientRouter, {
+					RootLayout,
+					viewImportMap: props.viewImportMap,
+					viewModules: props.viewModules,
+					queryConfig: options.queryConfig
+				})
 			})
 		})
 	});
@@ -1501,6 +1514,14 @@ function parseTranslation(template, params) {
 }
 //#endregion
 //#region client/useTranslator.ts
+/**
+* @deprecated Use `useDictionary(dict)` with a `defineDictionary` dictionary
+* declared next to the component. This resolves a dictionary by name through
+* the global `I18nDictionary` interface, which needs a `gemi.d.ts`
+* declaration, a central `app/i18n/index.ts`, and a hand-maintained `prefetch`
+* map naming every route's dictionaries — and it ships whatever that map says
+* whether the page reads it or not. Still supported; see `docs/i18n.md`.
+*/
 function useTranslator(component) {
 	const { i18n } = useRouteData();
 	function parse(key, ...args) {
@@ -1519,27 +1540,217 @@ function useTranslator(component) {
 	return parse;
 }
 //#endregion
+//#region client/useDictionary.ts
+/**
+* Read a dictionary declared with `defineDictionary`, next to the component
+* that uses it.
+*
+* ```tsx
+* const t = useDictionary(homeDict);
+* t("title", { name });
+* ```
+*
+* Keys and interpolation params come straight from the literal — there is no
+* name string to keep in sync and no `gemi.d.ts` augmentation.
+*
+* Normally this resolves without suspending: the server seeds the strings it
+* rendered with into the hydration payload, and the router warms a view's
+* dictionaries while it is already loading that view's chunks. It falls back to
+* suspending on the locale's chunk when neither happened — a dictionary inside
+* a `lazy()` subtree, or the first render after a locale switch.
+*
+* Replaces `useTranslator`, which is deprecated.
+*/
+function useDictionary(dictionary) {
+	const { i18n } = useRouteData();
+	const sink = useContext(DictionarySinkContext);
+	const locale = i18n?.currentLocale ?? dictionary.locales[0];
+	setActiveLocale(locale);
+	const pending = dictionary.loadForRender(locale);
+	const strings = pending instanceof Promise ? use(pending) : pending;
+	sink?.use(dictionary.id, locale, strings);
+	function parse(key, ...args) {
+		const template = strings[key];
+		if (typeof template !== "string") {
+			console.error(`Unresolved translation key:${key} locale:${locale} dictionary:${dictionary.id}`);
+			return key;
+		}
+		const [params = {}] = args;
+		return parseTranslation(template, params);
+	}
+	parse.jsx = (key, ...args) => {
+		return parse(key, ...args);
+	};
+	return parse;
+}
+//#endregion
+//#region i18n/dictionaryShape.ts
+/**
+* Locales the dictionary declares, source language first.
+*
+* The order is meaningful: the first locale is the source language, and a key
+* missing from some other locale falls back along this list.
+*
+* `sourceLocale` pins that choice. Without it the source language is whichever
+* locale is seen first while walking the literal, which makes it an emergent
+* property of key order — adding a key at the top of a dictionary whose other
+* keys happen to lack `en-US` would silently re-point every fallback in it. Any
+* dictionary that is not uniformly translated should say which locale it is
+* authored in.
+*/
+function dictionaryLocales(translations, sourceLocale) {
+	const locales = [];
+	const seen = /* @__PURE__ */ new Set();
+	if (sourceLocale) {
+		seen.add(sourceLocale);
+		locales.push(sourceLocale);
+	}
+	for (const byLocale of Object.values(translations)) for (const locale of Object.keys(byLocale)) if (!seen.has(locale)) {
+		seen.add(locale);
+		locales.push(locale);
+	}
+	return locales;
+}
+/**
+* Flatten one locale out of a dictionary.
+*
+* A key with no string for `locale` falls back along the declared locale order
+* rather than vanishing, so a half-translated dictionary degrades one string at
+* a time instead of rendering the whole component as raw keys.
+*/
+function localeStrings(translations, locale, fallbackOrder = dictionaryLocales(translations)) {
+	const out = {};
+	for (const [key, byLocale] of Object.entries(translations)) {
+		let value = byLocale?.[locale];
+		if (typeof value !== "string") for (const candidate of fallbackOrder) {
+			const fallback = byLocale?.[candidate];
+			if (typeof fallback === "string") {
+				value = fallback;
+				break;
+			}
+		}
+		if (typeof value === "string") out[key] = value;
+	}
+	return out;
+}
+/**
+* Canonical serialization — key order in the source file must not change the
+* id, or an innocuous reordering would break the payload/registry match.
+*/
+function canonicalizeDictionary(translations) {
+	return `{${Object.keys(translations).sort().map((key) => {
+		const byLocale = translations[key] ?? {};
+		const inner = Object.keys(byLocale).sort().map((l) => JSON.stringify([l, byLocale[l]])).join(",");
+		return `${JSON.stringify(key)}:[${inner}]`;
+	}).join(",")}}`;
+}
+/**
+* FNV-1a, run twice with different offsets for a 64-bit-wide id. No crypto
+* import, and it has to work identically in the browser bundle, under Bun on
+* the server, and inside the Vite plugin.
+*/
+function dictionaryId(translations) {
+	const input = canonicalizeDictionary(translations);
+	let a = 2166136261;
+	let b = 16777619;
+	for (let i = 0; i < input.length; i++) {
+		const c = input.charCodeAt(i);
+		a = Math.imul(a ^ c, 16777619);
+		b = Math.imul(b ^ c, 2166136261);
+	}
+	const hex = (n) => (n >>> 0).toString(16).padStart(8, "0");
+	return `d_${hex(a)}${hex(b)}`;
+}
+//#endregion
+//#region i18n/defineDictionary.ts
+function defineDictionary(translations, options = {}) {
+	const locales = dictionaryLocales(translations, options.sourceLocale);
+	return createHandle(dictionaryId(translations), locales, (locale) => localeStrings(translations, locale, locales));
+}
+function createHandle(id, locales, load) {
+	const entry = {
+		id,
+		locales,
+		load
+	};
+	registerDictionary(entry);
+	const ensure = () => registerDictionary(entry);
+	return {
+		id,
+		locales,
+		load: (locale) => {
+			ensure();
+			return loadDictionary(id, locale);
+		},
+		loadForRender: (locale) => {
+			ensure();
+			return loadDictionaryForRender(id, locale);
+		},
+		get: (locale) => {
+			ensure();
+			const strings = loadDictionary(id, locale);
+			if (strings instanceof Promise) {
+				strings.catch(() => {});
+				return;
+			}
+			return strings;
+		}
+	};
+}
+//#endregion
 //#region client/useLocale.ts
-var setCookie = async (locale) => {
+var LOCALE_COOKIE = "i18n-locale";
+var LOCALE_COOKIE_MAX_AGE = 3600 * 24 * 365;
+/**
+* The active locale lives in two places: the URL segment `setLocale` navigates
+* to, and the `i18n-locale` cookie the server falls back to when the URL has no
+* segment — which is exactly the case for the default locale. Both have to be in
+* place *before* the navigation asks for route data, or `Translator.detectLocale`
+* answers the request with a redirect back to the locale the cookie still names.
+*
+* Hence a synchronous `document.cookie` write rather than an awaited one. The
+* previous implementation awaited `cookieStore.set()` and hung the navigation off
+* its `.then()`; that promise is reported to never settle on iOS Safari, so the
+* `.then()` never ran and changing the language became a silent no-op — no
+* rejection, nothing for an error reporter to pick up. A synchronous write cannot
+* hang and cannot fail asynchronously, so nothing is left to gate navigation on.
+*/
+function persistLocale(locale) {
+	if (typeof document === "undefined") return;
 	try {
-		return await globalThis.cookieStore.set("i18n-locale", locale);
-	} catch (err) {
-		return await fetch(`/api/__gemi__/services/i18n/set-locale/${locale}`);
-	}
-};
+		document.cookie = [
+			`${LOCALE_COOKIE}=${encodeURIComponent(locale)}`,
+			`Max-Age=${LOCALE_COOKIE_MAX_AGE}`,
+			"SameSite=Strict",
+			"Path=/"
+		].join("; ");
+	} catch {}
+}
+/**
+* `onLocaleChange` is a server-side hook, so it takes a request to fire it. The
+* switch must not wait on that round trip, nor be cancelled by one that fails —
+* including one that fails *synchronously*: `fetch` is absent in some old
+* WebViews, and an unguarded call would throw before the navigation ran, which
+* is the same silent no-op this hook exists to prevent through another door.
+*/
+function notifyLocaleChange(locale) {
+	try {
+		fetch(`/api/__gemi__/services/i18n/set-locale/${encodeURIComponent(locale)}`).catch(() => {});
+	} catch {}
+}
 function useLocale() {
 	const { i18n } = useRouteData();
 	const { pathname, search } = useLocation();
 	const { replace } = useNavigate();
 	const params = useParams();
 	const setLocale = async (locale) => {
+		persistLocale(locale);
+		notifyLocaleChange(locale);
 		const urlSearchParams = new URLSearchParams(search);
-		setCookie(locale).then(() => {
-			replace(pathname, {
-				locale,
-				search: Object.fromEntries(urlSearchParams.entries()),
-				params
-			});
+		await replace(pathname, {
+			locale,
+			search: Object.fromEntries(urlSearchParams.entries()),
+			params
 		});
 	};
 	return [i18n.currentLocale, setLocale];
@@ -1587,6 +1798,6 @@ function useAppIdMissmatch() {
 	return current !== next;
 }
 //#endregion
-export { Form, FormError, FormFieldContainer, Head, Image, Link, OpenGraphImage, QueryError, QueryManagerProvider, Redirect, ValidationErrors, create, createRoot, init, useAppIdMissmatch, useBreadcrumbs, useBroadcast, useDelete, useForgotPassword, useFormData, useFormStatus, useIsNavigationPending, useLocale, useLocation, useMutate, useMutation, useMutationStatus, useNavigate, useNavigationProgress, useParams, usePatch, usePost, usePrefetch, usePut, useQuery, useResetPassword, useRoute, useRouteTransition, useSearchParams, useSignIn, useSignOut, useSignUp, useSubscription, useTheme, useTranslator, useUpload, useUser };
+export { Form, FormError, FormFieldContainer, Head, Image, Link, OpenGraphImage, QueryError, QueryManagerProvider, Redirect, ValidationErrors, create, createRoot, defineDictionary, init, useAppIdMissmatch, useBreadcrumbs, useBroadcast, useDelete, useDictionary, useForgotPassword, useFormData, useFormStatus, useIsNavigationPending, useLocale, useLocation, useMutate, useMutation, useMutationStatus, useNavigate, useNavigationProgress, useParams, usePatch, usePost, usePrefetch, usePut, useQuery, useResetPassword, useRoute, useRouteTransition, useSearchParams, useSignIn, useSignOut, useSignUp, useSubscription, useTheme, useTranslator, useUpload, useUser };
 
 //# sourceMappingURL=index.js.map