gemi 0.53.0 → 0.54.0

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,6 +1540,164 @@ 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) => {
 	try {
@@ -1587,6 +1766,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