gemi 0.53.0 → 0.54.1

package/dist/chunks/{ThemeProvider-CTX9LOFC.js → ThemeProvider-Bk1eZymb.js}

@@ -2252,6 +2252,184 @@ async function readSettledRoutePayload(response) {
 	return envelope;
 }
 //#endregion
+//#region i18n/dictionaryRegistry.ts
+/**
+* Parked on `globalThis` rather than in module scope, because this module gets
+* bundled more than once and the copies have to agree.
+*
+* gemi ships `gemi/client` from one Vite lib build and `gemi/dictionary` from a
+* separate Bun build, an SSR view graph externalizes some gemi subpaths and
+* bundles others, and a dictionary imported by both a view and a controller is
+* evaluated on both sides. Every one of those splits would otherwise produce a
+* second registry: views would register into one Map while the view router
+* preloaded and snapshotted from another, and the hydration payload would come
+* out empty. Module identity is not something this can depend on; a global key
+* is.
+*/
+var GLOBAL_KEY = "__GEMI_DICTIONARY_REGISTRY__";
+var state = globalThis[GLOBAL_KEY] ??= {
+	registry: /* @__PURE__ */ new Map(),
+	resolved: /* @__PURE__ */ new Map(),
+	inFlight: /* @__PURE__ */ new Map(),
+	degraded: /* @__PURE__ */ new Map(),
+	order: [],
+	warmed: /* @__PURE__ */ new Map(),
+	activeLocale: null
+};
+var { registry, resolved, inFlight, degraded, order, warmed } = state;
+function cacheKey(id, locale) {
+	return `${id}\0${locale}`;
+}
+function registerDictionary(entry) {
+	if (registry.has(entry.id)) return;
+	registry.set(entry.id, entry);
+	order.push(entry.id);
+}
+/** A marker for "everything registered so far", for `preloadDictionaries`. */
+function dictionaryRegistrationMark() {
+	return order.length;
+}
+function getResolved(id, locale) {
+	return resolved.get(id)?.get(locale);
+}
+function putResolved(id, locale, strings) {
+	let byLocale = resolved.get(id);
+	if (!byLocale) {
+		byLocale = /* @__PURE__ */ new Map();
+		resolved.set(id, byLocale);
+	}
+	byLocale.set(locale, strings);
+}
+/**
+* Load one dictionary's locale, de-duplicating concurrent callers. Returns the
+* strings directly (not a promise) when they are already resolved, so the hook
+* can take a synchronous path without a microtask hop.
+*/
+function loadDictionary(id, locale) {
+	const already = getResolved(id, locale);
+	if (already) return already;
+	const key = cacheKey(id, locale);
+	const pending = inFlight.get(key);
+	if (pending) return pending;
+	const entry = registry.get(id);
+	if (!entry) throw new Error(`Unknown dictionary "${id}". A dictionary must be created with defineDictionary() and its module must have been evaluated before it is read.`);
+	const result = entry.load(locale);
+	if (!(result instanceof Promise)) {
+		putResolved(id, locale, result);
+		return result;
+	}
+	const promise = result.then((strings) => {
+		putResolved(id, locale, strings);
+		inFlight.delete(key);
+		return strings;
+	}, (err) => {
+		inFlight.delete(key);
+		throw err;
+	});
+	inFlight.set(key, promise);
+	return promise;
+}
+/**
+* The same load, but as something safe to hand React's `use()`.
+*
+* A rejecting promise passed to `use()` rethrows during render, which unmounts
+* the whole route into its error boundary — or, before the shell is ready,
+* fails the server render outright. A missing locale chunk is a routine event
+* (a browser holding stale HTML after a rolling deploy requests a hashed
+* filename that no longer exists), and the deprecated `useTranslator` degraded
+* every i18n failure to rendering the raw key. This keeps that behaviour: the
+* returned promise resolves to no strings, and the per-key lookup in
+* `useDictionary` then logs and falls back to the key.
+*
+* The degraded promise is cached because `use()` requires a stable reference —
+* a fresh `.then()` per render would suspend forever. It is only consulted
+* after `getResolved` misses, so a later successful load supersedes it without
+* needing to be evicted.
+*/
+function loadDictionaryForRender(id, locale) {
+	const already = getResolved(id, locale);
+	if (already) return already;
+	const key = cacheKey(id, locale);
+	const cached = degraded.get(key);
+	if (cached) return cached;
+	const result = loadDictionary(id, locale);
+	if (!(result instanceof Promise)) return result;
+	const safe = result.then((strings) => strings, (err) => {
+		console.error(`Failed to load dictionary ${id} for locale ${locale}; rendering keys instead.`, err);
+		return EMPTY_STRINGS;
+	});
+	degraded.set(key, safe);
+	return safe;
+}
+var EMPTY_STRINGS = {};
+/**
+* Warm dictionaries for `locale`, so a subsequent render reads them
+* synchronously instead of suspending.
+*
+* With a `mark` — the value taken *before* importing a view module — only that
+* view's newly announced dictionaries are loaded. That is the client's use: it
+* knows exactly which chunk just arrived.
+*
+* Without one, it resumes from where this locale last got to. The server calls
+* it per request and has no mark to give (view modules were imported long
+* before the request arrived), so a plain scan from zero would walk every
+* dictionary in the app on every request — re-deriving the per-request cost this
+* whole change exists to remove, just with a smaller constant.
+*
+* An empty `locale` means the app configured none, and each dictionary is warmed
+* under its own source language — the same key `useDictionary` will ask for, so
+* the warmed entry is the one the render actually reads.
+*
+* Failures are swallowed: a dictionary that cannot load should surface at the
+* component that actually reads it, where the error names the key, rather than
+* take down an unrelated navigation.
+*/
+async function preloadDictionaries(locale, mark) {
+	const from = mark ?? warmed.get(locale) ?? 0;
+	const ids = order.slice(from);
+	if (ids.length === 0) return;
+	const settled = await Promise.all(ids.map(async (id) => {
+		try {
+			await loadDictionary(id, localeFor(id, locale));
+			return true;
+		} catch {
+			return false;
+		}
+	}));
+	if (mark === void 0) {
+		const firstFailure = settled.indexOf(false);
+		const reached = firstFailure === -1 ? ids.length : firstFailure;
+		warmed.set(locale, Math.max(warmed.get(locale) ?? 0, from + reached));
+	}
+}
+/**
+* Which locale a given dictionary should be warmed under.
+*
+* `useDictionary` falls back to the dictionary's own source language when the
+* app has no locale configured, so the preload has to make the same choice or
+* it caches under a key no render ever reads — warming `""`, then suspending on
+* `"en-US"` a moment later.
+*/
+function localeFor(id, locale) {
+	if (locale) return locale;
+	return registry.get(id)?.locales[0] ?? locale;
+}
+function setActiveLocale(locale) {
+	if (locale) state.activeLocale = locale;
+}
+function getActiveLocale() {
+	return state.activeLocale;
+}
+if (typeof window !== "undefined") {
+	const w = window;
+	const adopt = ([id, locale, strings]) => {
+		putResolved(id, locale, strings);
+	};
+	const buffered = Array.isArray(w.__GEMI_DICT__) ? w.__GEMI_DICT__ : [];
+	w.__GEMI_DICT__ = { push: adopt };
+	for (const entry of buffered) adopt(entry);
+}
+//#endregion
 //#region client/helpers/flattenComponentTree.ts
 function flattenComponentTree(componentTree) {
 	let out = [];
@@ -2273,13 +2451,18 @@ var viewModuleListeners = /* @__PURE__ */ new Set();
 function loadViewModule(name) {
 	const loader = typeof window !== "undefined" ? window.loaders?.[name] : void 0;
 	if (!loader) return Promise.resolve(null);
-	return Promise.resolve(loader()).then((mod) => {
+	const mark = dictionaryRegistrationMark();
+	return Promise.resolve(loader()).then(async (mod) => {
 		const isNew = !viewModules.has(name);
 		viewModules.set(name, mod);
 		if (isNew) for (const listener of viewModuleListeners) listener();
+		await preloadDictionaries(currentLocale(), mark);
 		return mod;
 	});
 }
+function currentLocale() {
+	return getActiveLocale() ?? (typeof window !== "undefined" ? window.__GEMI_DATA__?.i18n?.currentLocale ?? "" : "");
+}
 function subscribeViewModules(listener) {
 	viewModuleListeners.add(listener);
 	return () => {
@@ -2713,6 +2896,6 @@ function useTheme() {
 	return context;
 }
 //#endregion
-export { toVariantKey as A, useLocation as C, useParams as D, createMemoryHistory as E, DEFAULT_STALE_TIME as F, QueryError as I, Subject as L, QueryConfigContext as M, QueryManagerContext as N, RouteStateContext as O, QueryManagerProvider as P, ServerDataProvider as S, Action as T, useSearchParams as _, m as a, I18nProvider as b, ClientRouterContext as c, ComponentsProvider as d, loadViewModule as f, useRoute as g, routeDataUrl as h, WebSocketContextProvider as i, applyParams as j, RouteStateProvider as k, ClientRouterProvider as l, readRoutePayload as m, useTheme as n, RouteTransitionProvider as o, subscribeViewModules as p, WebSocketContext as r, useRouteTransition as s, ThemeProvider as t, ComponentsContext as u, useNavigate as v, ProgressManager as w, ServerDataContext as x, I18nContext as y };
+export { createMemoryHistory as A, QueryError as B, I18nContext as C, useLocation as D, ServerDataProvider as E, applyParams as F, QueryConfigContext as I, QueryManagerContext as L, RouteStateContext as M, RouteStateProvider as N, ProgressManager as O, toVariantKey as P, QueryManagerProvider as R, useNavigate as S, ServerDataContext as T, Subject as V, setActiveLocale as _, m as a, useRoute as b, ClientRouterContext as c, ComponentsProvider as d, loadViewModule as f, registerDictionary as g, loadDictionaryForRender as h, WebSocketContextProvider as i, useParams as j, Action as k, ClientRouterProvider as l, loadDictionary as m, useTheme as n, RouteTransitionProvider as o, subscribeViewModules as p, WebSocketContext as r, useRouteTransition as s, ThemeProvider as t, ComponentsContext as u, readRoutePayload as v, I18nProvider as w, useSearchParams as x, routeDataUrl as y, DEFAULT_STALE_TIME as z };
 
-//# sourceMappingURL=ThemeProvider-CTX9LOFC.js.map
+//# sourceMappingURL=ThemeProvider-Bk1eZymb.js.map