@sveltekit-i18n/base 3.1.2 → 3.3.0

package/dist/kit/define.svelte.js

@@ -3,7 +3,7 @@ import { BROWSER } from '#kit-env';
 import { serverHalf } from '#kit-server';
 import { I18n } from '../I18n.svelte.js';
 import { logError, loggerFactory, setLogger } from '../logger.js';
-import { configLocales, matchLocale, sanitizerFactory, textDirection } from '../utils.js';
+import { configLocales, matchLocale, paramsSignature, resolveLoaders, routeParams, sanitizerFactory, textDirection, withoutBasePath } from '../utils.js';
 // Registry-wide, so two copies of this package meet: the context key, and the
 // key of the pass the universal branch hands `use()` in `data`.
 const KEY = Symbol.for('@sveltekit-i18n/base/kit');
@@ -28,21 +28,23 @@ export const defineI18n = (config, options = {}) => {
     let defaults = [];
     // Resolved on first use, never at import, and once: resolving the loaders
     // and sanitizing reports what is wrong with them.
-    const locales = () => {
+    const resolved = () => {
         if (configured)
             return configured;
         if (config.log)
             setLogger(loggerFactory(config.log));
         try {
-            configured = configLocales(config);
+            const loaders = resolveLoaders(config.loaders, config.sanitizeLocales);
+            configured = { locales: configLocales(config, loaders), handOver: !loaders.some(({ cache }) => cache === false), loaders };
         }
         catch {
             // The instance reports a malformed config itself.
-            configured = [];
+            configured = { locales: [], handOver: false, loaders: [] };
         }
         defaults = [sanitized(config.initLocale), sanitized(config.fallbackLocale)];
         return configured;
     };
+    const locales = () => resolved().locales;
     let reported = false;
     const preferred = (event) => {
         try {
@@ -78,54 +80,120 @@ export const defineI18n = (config, options = {}) => {
         if (chosen !== undefined)
             return { locale: chosen, preferred: true };
         return {
-            locale: [ranges, ...defaults].reduce((found, candidate) => found ?? matchLocale(candidate, available), undefined),
+            // Last, the first locale served: a config that serves one never renders
+            // a page without a locale.
+            locale: [ranges, ...defaults].reduce((found, candidate) => found ?? matchLocale(candidate, available), undefined) ?? available[0],
             preferred: false,
         };
     };
-    const server = serverHalf({ create, negotiate, locales, basePath: config.basePath });
+    const server = serverHalf({ create, negotiate, locales, basePath: config.basePath, handOver: () => resolved().handOver });
     // Browser only: the tab's instance, the server's answer at the last commit,
-    // and the locale that commit is switching to with the one it switches from,
-    // which only `use()` writes. A server keeps nothing between requests.
-    const tab = { committed: false };
-    // The locale the tab shows once the wiring's own switch lands: that switch
-    // is no client change, while a locale that moved from where it started is.
-    const heading = (i18n) => {
-        const active = untrack(() => i18n.locale);
-        return tab.switching && tab.switching.from === active ? tab.switching.to : active;
+    // the switch under way, what the last commit waits on, how many commits
+    // there were, which only `use()` writes, and the tables the pass that built
+    // the instance left when it activated it without a hand-off for a config
+    // with a `cache: false` loader, until the first commit reads them. None of
+    // it lives in `data`, which the app may hold in deep state. A server keeps
+    // nothing between requests.
+    const tab = { commits: 0 };
+    // The wiring's own switch, while the locale has not moved from where it
+    // started: that switch is no client change, while a locale that moved is.
+    const underway = (i18n) => (tab.switching?.from === untrack(() => i18n.locale) ? tab.switching : undefined);
+    // The locale the tab shows once the wiring's own switch lands.
+    const heading = (i18n) => underway(i18n)?.to ?? untrack(() => i18n.locale);
+    // The records an activation of `locale` on `route` leaves once every loader
+    // it selects delivered, in `loaders` order as `snapshot()` lists them, or
+    // `undefined` when none of them has `cache: false`, so the commit runs
+    // nothing again, or one of them has no id, whose record no snapshot shows.
+    const records = (locale, route) => {
+        const selected = resolved().loaders.flatMap((loader) => {
+            const params = loader.locale === locale || loader.locale === defaults[1] ? routeParams(loader.routes, route) : undefined;
+            return params ? [{ id: loader.id, signature: paramsSignature(params), cache: loader.cache }] : [];
+        });
+        if (!selected.some(({ cache }) => cache === false))
+            return undefined;
+        const listed = selected.flatMap(({ id, signature }) => (id === null ? [] : [signature ? { id, signature } : { id }]));
+        return listed.length === selected.length ? listed : undefined;
+    };
+    // Whether an instance still stands where the activation of `locale` on
+    // `route` left it, with `tables`: nothing loading or landed since, its
+    // records whole and every loader delivered, which a failed loader, another
+    // load, a reconfiguration and an invalidation of what it loaded each undo.
+    const stands = (i18n, locale, route, tables) => untrack(() => {
+        if (i18n.loading || i18n.locale !== locale || i18n.rawTranslations !== tables)
+            return false;
+        const path = withoutBasePath(route, config.basePath);
+        const expected = records(locale, path);
+        if (!expected)
+            return false;
+        const envelope = i18n.snapshot({ records: true });
+        return envelope.route === path && JSON.stringify(envelope.records) === JSON.stringify(expected);
+    });
+    const fallBack = (commit, switching) => {
+        const lapse = { commit, switching };
+        tab.lapse = lapse;
+        void Promise.all([switching.landed, ...switching.stays]).then((outcomes) => { lapse.outcomes = outcomes; });
+    };
+    // The answer of the last commit. Once its switch and every stay committed
+    // while that switch was under way settled, a failure that left the tab
+    // short of the locale switched to leaves the answer to the next commit:
+    // short, as long as the tab has not shown that locale since the switch
+    // started, whoever's call landed it. A switch to the locale it started from
+    // fell short unless a call landed.
+    const answered = (i18n) => {
+        const { lapse } = tab;
+        if (!lapse?.outcomes || lapse.commit !== tab.commits || lapse.outcomes.every(Boolean))
+            return tab.answer;
+        const { outcomes, switching } = lapse;
+        const { from, to, previous } = switching;
+        if (untrack(() => i18n.locale) === to)
+            switching.reached = true;
+        return (from === to ? !outcomes.some(Boolean) : !switching.reached) ? previous : tab.answer;
     };
     const universalLoad = async (event) => {
         const route = event.url.pathname;
         const payload = event.data?.i18n;
+        // A page render's own instance: the server branch loaded it for this very
+        // payload, which SvelteKit hands over as it was returned.
+        const rendered = BROWSER ? undefined : server.take(payload);
         const fresh = !BROWSER || !tab.i18n;
-        const i18n = fresh ? create() : tab.i18n;
+        const i18n = rendered ?? (fresh ? create() : tab.i18n);
         const surface = fresh ? pipe(i18n) : tab.surface;
-        const seen = heading(i18n);
+        const via = underway(i18n);
+        const seen = via?.to ?? untrack(() => i18n.locale);
         // A live server sends the tables on a page render only, so a later pass
         // that carries them read a prerendered file, whose locale was negotiated
         // at build time, without the visitor: it counts only when the build's
         // `preferredLocale` gave it. Node and Deno define `navigator.languages`
         // too, from the server's own environment.
         const prerendered = !fresh && payload?.translations;
-        const answer = prerendered
-            ? (payload.preferred ? payload.locale : tab.answer)
+        const follows = Boolean(prerendered && !payload.preferred);
+        const answer = follows
+            ? answered(i18n)
             : payload ? payload.locale : negotiate(event, BROWSER ? navigator.languages : undefined).locale;
         if (BROWSER)
             Object.assign(tab, { i18n, surface });
+        let preloaded;
         if (fresh) {
-            if (payload?.translations)
+            if (!rendered && payload?.translations)
                 i18n.hydrate({ ...payload, translations: payload.translations });
             // No preload runs before the first navigation completes, so the pass
             // that builds the instance may activate it.
             await (answer ? i18n.loadTranslations(answer, route) : i18n.setRoute(route));
         }
         else {
-            // Warm only: this pass may be a preload, which must not change what is
-            // shown. The commit switches to a changed answer, or else stays.
-            const target = (answer !== tab.answer ? answer : undefined) ?? heading(i18n);
+            // The request of a navigation that may never commit, a hover's
+            // included: it activates nothing, and its token lets the commit show
+            // what it fetched. The commit switches to a changed answer, or else
+            // stays.
+            const target = (answer !== answered(i18n) ? answer : undefined) ?? heading(i18n);
             if (target)
-                await i18n.loadTranslations(target, route, { activate: false });
+                preloaded = await i18n.preload(target, route);
         }
-        const pass = { i18n, surface, locale: answer, route, seen };
+        // Unless a hand-off holds it back, the commit would run a loader with
+        // `cache: false` again for the very request this pass activated.
+        if (BROWSER && fresh && !payload?.translations && !resolved().handOver)
+            tab.activated = untrack(() => i18n.rawTranslations);
+        const pass = { i18n, surface, locale: answer, follows, route, seen, via, preloaded };
         return { ...event.data, i18n: surface, [KEY]: pass };
     };
     const load = ((event) => (isServerEvent(event) ? server.load(event) : universalLoad(event)));
@@ -143,34 +211,68 @@ export const defineI18n = (config, options = {}) => {
             const pass = passOf(data());
             if (!pass)
                 return;
-            if (!tab.committed || (pass.locale !== tab.answer && heading(pass.i18n) === pass.seen)) {
-                const { locale } = pass;
+            const first = !tab.commits;
+            const { activated } = tab;
+            // Read by the first commit alone: the tables would outlive their
+            // replacement for the life of the tab.
+            tab.activated = undefined;
+            tab.answer = answered(pass.i18n);
+            const commit = ++tab.commits;
+            const now = heading(pass.i18n);
+            // A switch that failed before this commit may have headed nowhere: its
+            // undo puts back the locale it started from or the one the tab was
+            // heading for, unless a later call landed the one it headed for.
+            const current = now === pass.seen || (pass.via?.failed === true && (now === pass.via.from || now === pass.via.back));
+            // A pass that takes the tab's answer never switches.
+            const locale = pass.follows ? tab.answer : pass.locale;
+            if (first || (locale !== tab.answer && current)) {
                 const previous = tab.answer;
-                tab.committed = true;
                 tab.answer = locale;
                 if (locale !== undefined) {
-                    const switching = { from: untrack(() => pass.i18n.locale), to: locale };
-                    const done = () => {
-                        if (tab.switching === switching)
-                            tab.switching = undefined;
+                    // The pass that built the instance activated it for this request:
+                    // while it stands there, that activation is the commit's.
+                    const taken = first && activated !== undefined && stands(pass.i18n, locale, pass.route, activated);
+                    const switching = {
+                        from: untrack(() => pass.i18n.locale),
+                        back: now,
+                        to: locale,
+                        previous,
+                        failed: false,
+                        stays: [],
+                        reached: false,
+                        landed: (taken ? Promise.resolve() : pass.i18n.loadTranslations(locale, pass.route, { preloaded: pass.preloaded })).then(() => true, () => {
+                            switching.failed = true;
+                            return false;
+                        }),
                     };
                     tab.switching = switching;
-                    // A switch that failed, and that no later call landed either, leaves
-                    // the answer to the next commit.
-                    pass.i18n.loadTranslations(locale, pass.route).then(done, () => {
-                        done();
-                        if (tab.answer === locale && untrack(() => pass.i18n.locale) !== locale)
-                            tab.answer = previous;
+                    void switching.landed.then(() => {
+                        if (tab.switching === switching)
+                            tab.switching = undefined;
                     });
+                    fallBack(commit, switching);
                     return;
                 }
             }
-            void pass.i18n.setRoute(pass.route);
+            // A stay committed while what the previous commit waits on is under way
+            // carries it on, unless the locale moved from where the switch started.
+            const { lapse } = tab;
+            const switching = lapse && !lapse.outcomes && lapse.commit === commit - 1 && lapse.switching.from === untrack(() => pass.i18n.locale)
+                ? lapse.switching
+                : undefined;
+            const stayed = pass.i18n.setRoute(pass.route, { preloaded: pass.preloaded }).then(() => true, () => false);
+            if (!switching)
+                return;
+            switching.stays = [...switching.stays, stayed];
+            fallBack(commit, switching);
         });
         $effect(() => {
             const { locale } = i18n;
             if (!locale)
                 return;
+            const switching = tab.lapse?.switching;
+            if (switching?.to === locale)
+                switching.reached = true;
             document.documentElement.lang = locale;
             document.documentElement.dir = textDirection(locale);
         });

package/dist/kit/internal.d.ts

@@ -12,10 +12,18 @@ export type Shared = {
     /** The locales the config serves. */
     locales: () => string[];
     basePath: string | undefined;
+    /**
+     * Whether the universal branch of a page render may take over the instance
+     * the server branch loaded: not while a loader has `cache: false`, which only
+     * a hand-off holds back for the rest of the render.
+     */
+    handOver: () => boolean;
 };
 export type ServerHalf = {
     handle: Kit.T['handle'];
     load: (event: Kit.ServerLoadEvent) => Promise<{
         i18n: Kit.Payload;
     }>;
+    /** The instance a page render loaded for `payload`, handed out once. */
+    take: (payload: Kit.Payload | undefined) => I18n | undefined;
 };

package/dist/kit/server.browser.js

@@ -3,4 +3,4 @@ const serverOnly = () => {
 };
 // What `#kit-server` resolves to under the `browser` condition: the browser
 // bundle carries this instead of the server half.
-export const serverHalf = () => ({ handle: serverOnly, load: serverOnly });
+export const serverHalf = () => ({ handle: serverOnly, load: serverOnly, take: serverOnly });

package/dist/kit/server.d.ts

@@ -1,2 +1,2 @@
 import type { ServerHalf, Shared } from './internal.js';
-export declare const serverHalf: ({ create, negotiate, locales, basePath }: Shared) => ServerHalf;
+export declare const serverHalf: ({ create, negotiate, locales, basePath, handOver }: Shared) => ServerHalf;

package/dist/kit/server.js

@@ -1,7 +1,11 @@
 import { logger } from '../logger.js';
 import { matchLocale, routePrefix, textDirection, withoutBasePath } from '../utils.js';
-export const serverHalf = ({ create, negotiate, locales, basePath }) => {
+export const serverHalf = ({ create, negotiate, locales, basePath, handOver }) => {
     const answer = (event) => negotiate(event, event.request.headers.get('accept-language'));
+    // The instance each page render loaded, under the payload it returned:
+    // SvelteKit hands that very object to the universal load of the same
+    // request.
+    const built = new WeakMap();
     let warned = false;
     // A base path SvelteKit strips and `basePath` does not keeps every
     // route-scoped loader from matching, silently. Here, on the server only, so
@@ -66,7 +70,18 @@ export const serverHalf = ({ create, negotiate, locales, basePath }) => {
                 return { i18n: { locale, route: withoutBasePath(route, basePath) } };
             const i18n = create();
             await (locale ? i18n.loadTranslations(locale, route) : i18n.setRoute(route));
-            return { i18n: { ...i18n.snapshot({ records: true }), ...(preferred ? { preferred: true } : {}) } };
+            const payload = { ...i18n.snapshot({ records: true }), ...(preferred ? { preferred: true } : {}) };
+            if (handOver())
+                built.set(payload, i18n);
+            return { i18n: payload };
+        },
+        // Once, so a payload an app keeps and returns again shares no instance.
+        take: (payload) => {
+            if (!payload)
+                return undefined;
+            const i18n = built.get(payload);
+            built.delete(payload);
+            return i18n;
         },
     };
 };

package/dist/types.d.ts

@@ -70,7 +70,7 @@ export declare namespace Config {
     export type SanitizeLocales = boolean | ((locale: Locale) => Locale);
     export type T<P extends Parser.Params = Parser.Params, O = Parser.Output, S = any> = {
         /**
-         * You can use loaders to define your asyncronous translation load. All loaded data are stored so loader is triggered only once – in case there is no previous version of the translation. It can get triggered again when the params its `routes` capture change, once the `config.cache` window elapses, or after `invalidate()` is called. A loader with `cache: false` runs on every load trigger that selects it.
+         * You can use loaders to define your asyncronous translation load. All loaded data are stored so loader is triggered only once – in case there is no previous version of the translation. It can get triggered again when the params its `routes` capture change, once the `config.cache` window elapses, or after `invalidate()` is called. A loader with `cache: false` runs on every load trigger that selects it, except a call handed the token of a `preload()` that ran it.
          */
         loaders?: readonly Loader.LoaderModule[];
         /**
@@ -83,7 +83,7 @@ export declare namespace Config {
          */
         translations?: Translations.T;
         /**
-         * If you set this property, translations will be initialized immediately using this locale. `defineI18n()` from `/kit` loads nothing for it: there it is a negotiation candidate. Leave it out of a config whose instance you `hydrate()` by hand – its load starts in the constructor, before the hand-off can be applied.
+         * The initial locale. With `defineI18n()` from `/kit`, the locale a visitor gets when neither `preferredLocale` nor what the visitor's browser asks for (`Accept-Language`, or `navigator.languages` without a server `load`) names a locale the config serves; it loads only when negotiation picks it, and without it, or when it matches no locale served, `fallbackLocale` and then the first locale served take that role. With `new I18n(config)`, the constructor loads it right away – leave it out of a config whose instance you `hydrate()` by hand, since its load starts before the hand-off can be applied.
          */
         initLocale?: InitLocale;
         /**
@@ -163,7 +163,7 @@ export declare namespace Config {
          */
         basePath?: string;
         /**
-         * Time in milliseconds the loaded translations stay fresh for. Once a locale's translations are older, the next activating load trigger (`setLocale()`, `setRoute()`, `loadTranslations()`) runs its loaders again; a warm load – `loadTranslations(…, { activate: false })` or `loadNamespace()` – fills the tables without evaluating the window. By default, loaded translations never expire – call `invalidate()` (or set a finite `cache`) when your translation source can change at runtime, e.g. a CMS. A loader with `cache: false` is outside the window.
+         * Time in milliseconds the loaded translations stay fresh for. Once a locale's translations are older, the next activating load trigger (`setLocale()`, `setRoute()`, `loadTranslations()`) or `preload()` runs its loaders again; a warm load – `loadTranslations(…, { activate: false })` or `loadNamespace()` – fills the tables without evaluating the window, and a call handed a `preload()`'s token leaves it to that preload. By default, loaded translations never expire – call `invalidate()` (or set a finite `cache`) when your translation source can change at runtime, e.g. a CMS. A loader with `cache: false` is outside the window.
          *
          * @default Number.POSITIVE_INFINITY
          *
@@ -192,6 +192,7 @@ export declare namespace Config {
     export {};
 }
 declare const operator: unique symbol;
+declare const preloaded: unique symbol;
 export declare namespace Extension {
     type Input = any;
     type Output = any;
@@ -316,7 +317,7 @@ export declare namespace Loader {
         */
         routes?: readonly Route[];
         /**
-        * Set to `false` when the loader's source does the caching – a SvelteKit remote `query`, an SWR layer, an HTTP cache. The core then keeps no freshness of its own for it: it runs on every load trigger that selects it, its data is applied each time like any refetch, and `config.cache` does not apply to it – refreshing the source is the app's business. Data hydrated from a snapshot still holds it back for the pass it arrived with, until an activating trigger asks for another locale or route; `invalidate()` ends that hand-off and discards a fetch of it in flight. Only `false` is accepted.
+        * Set to `false` when the loader's source does the caching – a SvelteKit remote `query`, an SWR layer, an HTTP cache. The core then keeps no freshness of its own for it: it runs on every load trigger that selects it – unless a fetch of it for the same params and route is in flight, which it shares – its data is applied each time like any refetch, and `config.cache` does not apply to it – refreshing the source is the app's business. A call handed a `preload()`'s token shows what the preload fetched instead of running it again; what the preload shared from a fetch already in flight is shown, then fetched again. Data hydrated from a snapshot still holds it back for the pass it arrived with, until an activating trigger asks for another locale or route, or a `preload()` runs; `invalidate()` ends that hand-off and discards a fetch of it in flight. Only `false` is accepted.
         */
         cache?: false;
     };
@@ -364,6 +365,17 @@ export declare namespace Loader {
          */
         id: string | null;
     };
+    /**
+     * What `preload()` resolves to: a token for the next activating call of the
+     * same locale and route, which takes it as `{ preloaded }` and shows what the
+     * preload fetched instead of fetching it again. It serves one call, of the
+     * instance that made it: the first activating call that reads it spends it,
+     * whether or not it serves that call. Hold it by reference: it carries no
+     * data, and a copy is no token.
+     */
+    export type Preloaded = {
+        readonly [preloaded]: true;
+    };
     /**
      * Loads translation data. Receives the load context (`locale`, `namespace`, `route`, `params`) –
      * loaders that don't need it can simply take no parameters.
@@ -564,6 +576,13 @@ export declare namespace Schema {
     /** The keys a schema allows; any string when there is no schema. */
     export type Key<S> = [S] extends [never] ? string : keyof S & string;
     type IsAny<T> = 0 extends 1 & T ? true : false;
+    /**
+     * `keyof S`, read once per schema. TypeScript rebuilds `keyof` of an object
+     * type over every key each time it reads it, and a plain alias of it too;
+     * the instantiation of a conditional type is cached per type argument, so
+     * each call reads the keys this computed once.
+     */
+    type Keys<S> = [S] extends [unknown] ? keyof S : never;
     /**
      * What satisfies every key in `K` — see `Params`. The fold runs over the
      * KEYS, so each key's own payload reaches the intersection whole; folding
@@ -573,8 +592,21 @@ export declare namespace Schema {
      * empty union stays `never`: no member means no payload, not an
      * unconstrained one.
      */
-    type BoxedPayload<S, K extends string> = K extends keyof S ? [Exclude<S[K], undefined>] extends [never] ? never : (payload: Exclude<S[K], undefined>) => void : never;
-    type PayloadOf<S, K extends string> = [BoxedPayload<S, K>] extends [never] ? never : BoxedPayload<S, K> extends (payload: infer V) => void ? V : never;
+    type BoxedPayload<S, K extends string> = K extends Keys<S> ? [Exclude<S[K], undefined>] extends [never] ? never : (payload: Exclude<S[K], undefined>) => void : never;
+    /** Whether a key in `K` marks its payload optional; `boolean` when only some do. */
+    type OptionalOf<S, K extends string> = K extends Keys<S> ? (undefined extends S[K] ? true : false) : never;
+    /**
+     * The payloads fold into their intersection by inference: `V` stands as the
+     * parameter in the false branch of a conditional deferred on `V` itself, so
+     * a union of functions contributes each parameter as a contravariant
+     * candidate, and those combine into their intersection. Once `V` is
+     * inferred, that conditional reads `unknown` or `never`, so the union is
+     * never related to the intersection itself. Matched against a function over
+     * the intersection instead, the union would relate the intersection to each
+     * payload, which for a key outside the schema, typed over every key, costs
+     * time about cubic in their number.
+     */
+    type PayloadOf<S, K extends string> = [BoxedPayload<S, K>] extends [never] ? never : BoxedPayload<S, K> extends (infer V extends unknown ? unknown : (payload: infer V) => void) ? V : never;
     /**
      * The parser's own params minus the payload slot the schema takes over. A
      * params tuple that is unknown or open-ended contributes no trailing slots –
@@ -594,7 +626,7 @@ export declare namespace Schema {
      * A union of keys takes the INTERSECTION of their payloads, since one call
      * has to satisfy every key it might be.
      */
-    export type Params<S, K extends string, P extends Parser.Params> = [S] extends [never] ? P : [K] extends [keyof S] ? Payload<P, PayloadOf<S, K>, undefined extends S[K & keyof S] ? true : false> : P;
+    export type Params<S, K extends string, P extends Parser.Params> = [S] extends [never] ? P : [K] extends [Keys<S>] ? Payload<P, PayloadOf<S, K>, OptionalOf<S, K>> : P;
     export {};
 }
 export declare namespace Snapshot {

package/dist/utils.d.ts

@@ -1,15 +1,7 @@
 import type { Config, DotNotation, Translations, Loader, Parser } from './types.js';
 export declare const hasOwn: (obj: any, key: PropertyKey) => boolean;
 export declare const read: <T = any>(obj: any, key: PropertyKey) => T | undefined;
-export declare const translate: <P extends Parser.Params = Parser.Params, O = Parser.Output>({ parser, key, params, translations, locale, fallbackLocale, ...rest }: {
-    parser: Parser.T<P, O>;
-    key: string;
-    params: Parser.Params;
-    translations: Translations.SerializedTranslations;
-    locale: Translations.Locales[number] | undefined;
-    fallbackLocale?: Config.FallbackLocale;
-    fallbackValue?: Config.FallbackValue;
-}) => Translations.Translated<O>;
+export declare const translate: <P extends Parser.Params = Parser.Params, O = Parser.Output>(config: Pick<Config.T<P, O>, "parser" | "fallbackLocale" | "fallbackValue"> | undefined, locale: Translations.Locales[number] | undefined, key: string, params: Parser.Params, table: DotNotation.Input, fallbackTable: DotNotation.Input) => Translations.Translated<O>;
 type Sanitizer = (...locales: any[]) => Config.Locale[];
 export declare const sanitizeLocales: Sanitizer;
 export declare const sanitizerFactory: (sanitize?: Config.SanitizeLocales) => Sanitizer;
@@ -50,6 +42,8 @@ export declare const withoutBasePath: (route: string, basePath: string | undefin
  * absorbs a prefix. No regex runs on the pathname.
  */
 export declare const routePrefix: (pathname: string, routeId: string | null) => string | undefined;
+/** Whether `config.preprocess` is the built-in dot notation. */
+export declare const dotNotates: (preprocess: Config.T["preprocess"]) => boolean;
 export declare const toDotNotation: DotNotation.T;
 export declare const unique: <V>(values: readonly V[]) => V[];
 export declare const resolveLoaders: (input?: readonly Loader.LoaderModule[], sanitizeLocales?: Config.SanitizeLocales) => Loader.Resolved[];
@@ -63,11 +57,12 @@ export declare const serialize: (input: Array<Loader.Resolved & {
 /** The locales the loaders serve, then the ones the tables hold. */
 export declare const servedLocales: (loaders: readonly Loader.Resolved[], tables: Translations.SerializedTranslations) => Config.Locale[];
 /**
- * The locales a config serves, sanitized as an instance built from it
- * sanitizes them. Resolving the loaders logs what is wrong with them, so a
- * caller runs this once per config.
+ * The locales a config serves, from its loaders as `resolveLoaders` resolved
+ * them, sanitized as an instance built from it sanitizes them. Resolving the
+ * loaders logs what is wrong with them, so a caller resolves them once per
+ * config.
  */
-export declare const configLocales: ({ loaders, translations, sanitizeLocales: strategy }: Pick<Config.T, "loaders" | "translations" | "sanitizeLocales">) => Config.Locale[];
+export declare const configLocales: ({ translations, sanitizeLocales: strategy }: Pick<Config.T, "translations" | "sanitizeLocales">, loaders: readonly Loader.Resolved[]) => Config.Locale[];
 /** A loader selected for a load, with the params its route yielded. */
 export type LoadRequest = {
     loader: Loader.Resolved;