@sveltekit-i18n/base 3.1.0-next.1 → 3.1.0-next.3

package/README.md

@@ -228,11 +228,11 @@ A named capture group in a `RegExp` route is a load parameter: its match reaches
   locale: 'en',
   namespace: 'article',
   routes: [/^\/article\/(?<articleId>[^/]+)/],
-  loader: async ({ locale, params }) => (await fetch(`/api/articles/${params.articleId}/i18n/${locale}`)).json(),
+  loader: async ({ locale, params }) => (await fetch(`${API_ORIGIN}/api/articles/${params.articleId}/i18n/${locale}`)).json(),
 }
 ```
 
-See [route params](./docs/README.md#route-params) for the rules.
+`API_ORIGIN` stands for an origin such as `https://api.example.com`: a loader runs on the server too, where `fetch` takes only an absolute URL. See [route params](./docs/README.md#route-params) for the rules.
 
 A loader whose source does the caching itself — a SvelteKit remote `query`, an SWR layer, an HTTP cache — sets `cache: false`. It then runs on every load trigger that selects it, and `config.cache` does not apply to it; only a hydrated snapshot holds it back, for the locale and route it was rendered for. See [the loader's `cache`](./docs/README.md#cache-optional).
 
@@ -312,18 +312,29 @@ preprocess: 'full' // 'full' | 'preserveArrays' | 'none' | custom function
 
 ### `schema`
 
-A map of translation key to the payload its message expects (`never` for a message that takes none). Supplying it types `t`/`l` — keys autocomplete, an unknown key is a type error, and the payload argument is checked. Only its type is read, so the value can stay empty at runtime:
+A map of translation key to the payload its message expects (`never` for a message that takes none). It types `t`/`l` — keys autocomplete, an unknown key is a type error, and the payload argument is checked. Register it once for the app, in a global script, and every instance whose config states no `schema` is typed by it:
 
 ```typescript
-type TranslationSchema = {
+// src/i18n-schema.d.ts — no top-level import or export
+interface TranslationSchema {
   'common.greeting': { name: string };
   'common.farewell': never;
-};
+}
 
+declare namespace SvelteKitI18n {
+  interface Register {
+    schema: TranslationSchema;
+  }
+}
+```
+
+Or state it per instance — only its type is read, so the value can stay empty at runtime, and a stated schema wins over the registry:
+
+```typescript
 const i18n = new I18n({ ...config, schema: {} as TranslationSchema });
 ```
 
-Hand-write it for a small set of messages, or point the slot at a generated artifact — [@sveltekit-i18n/typegen](https://github.com/sveltekit-i18n/typegen), a separate package, generates one. A schema whose keys are not a closed set is ignored, and keys stay plain strings. See [`schema`](./docs/README.md#schema) for the full rules.
+Hand-write it for a small set of messages, or generate it — [@sveltekit-i18n/typegen](https://github.com/sveltekit-i18n/typegen), a separate package, generates one. A schema whose keys are not a closed set (`schema: {}`) types nothing and keeps the registry out, so keys stay plain strings. A library never registers. The registry needs base 3.1 or newer. See [`schema`](./docs/README.md#schema) for the full rules.
 
 ### `cache`
 

package/dist/I18n.svelte.js

@@ -45,7 +45,7 @@ class I18nCore {
     // What each source last put into a namespace, so a loader whose params
     // changed can replace its own part and leave its siblings' in place. Kept
     // apart from the records: invalidation drops those, not what is displayed,
-    // and a reconfiguration hands them on to the loaders with the same id.
+    // and a reconfiguration hands them on to the same loaders of the new config.
     #deliveries = new Map();
     #externalTranslations = {};
     // The params signature the next trigger asks each loader for:
@@ -561,18 +561,31 @@ class I18nCore {
     }
     /**
      * Gives each delivery of the previous config to the loader of the new one
-     * with the same id, so its params can still replace it. What no loader can
-     * take over is kept as data supplied without a loader, so a namespace rebuilt
-     * later keeps it rather than losing it.
+     * with the same id, or else to the one loader that runs the same function
+     * for the same locale and namespace when no other delivery came from that
+     * function there: a `{ ...config, … }` hands its loaders over as they were,
+     * whatever became of their routes. Its params can then still replace it.
+     * What no loader can take over is kept as data supplied without a loader, so
+     * a namespace rebuilt later keeps it rather than losing it.
      */
     #handOnDeliveries(loaders) {
-        const takers = new Map(loaders.flatMap((loader) => (loader.id === null ? [] : [[loader.id, loader]])));
+        const byId = new Map(loaders.flatMap((loader) => (loader.id === null ? [] : [[loader.id, loader]])));
         const deliveries = Array.from(this.#deliveries.values());
-        const orphaned = deliveries.filter(({ loader }) => loader.id === null || !takers.has(loader.id));
-        this.#deliveries = new Map(deliveries.flatMap((delivery) => {
-            const taker = delivery.loader.id === null ? undefined : takers.get(delivery.loader.id);
-            return taker ? [[taker, { ...delivery, loader: taker }]] : [];
+        const byIdTaken = new Map(deliveries.flatMap((delivery) => {
+            const taker = delivery.loader.id === null ? undefined : byId.get(delivery.loader.id);
+            return taker ? [[delivery, taker]] : [];
         }));
+        const free = loaders.filter((loader) => !Array.from(byIdTaken.values()).includes(loader));
+        const rest = deliveries.filter((delivery) => !byIdTaken.has(delivery));
+        const runsAs = (a) => (b) => a.loader === b.loader && a.locale === b.locale && a.namespace === b.namespace;
+        const byFunction = rest.flatMap((delivery) => {
+            const [only, ...more] = free.filter(runsAs(delivery.loader));
+            const alone = rest.filter((other) => runsAs(delivery.loader)(other.loader)).length === 1;
+            return only && !more.length && alone ? [[delivery, only]] : [];
+        });
+        const takers = new Map([...byIdTaken, ...byFunction]);
+        const orphaned = deliveries.filter((delivery) => !takers.has(delivery));
+        this.#deliveries = new Map(Array.from(takers, ([delivery, taker]) => [taker, { ...delivery, loader: taker }]));
         this.#keepExternal(serialize(orphaned.map(({ loader, data }) => ({ ...loader, data }))));
     }
     /**

package/dist/kit/types.d.ts

@@ -53,9 +53,10 @@ export declare namespace Kit {
          * locale matches is skipped; a custom `sanitizeLocales` is applied to it
          * first. It runs on every navigation and every
          * preload, so it must be pure: it reads the event and writes nothing.
-         * With a server load it runs on the server only: a navigation to a
-         * prerendered page takes the locale it gave at build time, and otherwise
-         * keeps the tab's.
+         * With a server load it runs in the browser only on a root error page
+         * rendered without the server's data (an unknown URL a static host answers
+         * with its fallback page): a navigation to a prerendered page takes the
+         * locale it gave at build time, and otherwise keeps the tab's.
          *
          * @example
          * preferredLocale: (event) => event.cookies?.get('lang')

package/dist/types.d.ts

@@ -129,21 +129,21 @@ export declare namespace Config {
         parser: Parser.T<P, O>;
         /**
          * A key schema — a map of translation key to the payload its message
-         * expects (`never` for a message without parameters). Supplying it types
-         * `t`/`l`: keys autocomplete and a wrong payload is a type error. Only its
-         * TYPE is read, so a generated artifact may export a value that is empty
-         * at runtime — as long as that value is TYPED, e.g.
-         * `export const schema = {} as TranslationSchema`. A schema whose keys are not a
-         * closed set (an open index signature, or no keys at all) is ignored and
-         * keys stay plain strings. Read at construction time only: a later
-         * `loadConfig()` cannot retype the instance, and an extension typed by a
-         * fixed return type erases the instance's type parameters, while one
-         * typed by an `Extension.Operator` (`Extension.Generic`) keeps them.
+         * expects (`never` for a message without parameters). It types `t`/`l`:
+         * keys autocomplete and a wrong payload is a type error. Left out, the
+         * schema the app registers in `SvelteKitI18n.Register` types the
+         * instance; stated, it wins over the registry. Only its TYPE is read, so
+         * the value may be empty at runtime — as long as it is TYPED, e.g.
+         * `{} as TranslationSchema`. A schema whose keys are not a closed set (an
+         * open index signature, or no keys at all, as in `schema: {}`) types
+         * nothing and keeps the registry out: keys stay plain strings. Read at
+         * construction time only: a later `loadConfig()` cannot retype the
+         * instance, and an extension typed by a fixed return type erases the
+         * instance's type parameters, while one typed by an `Extension.Operator`
+         * (`Extension.Generic`) keeps them.
          *
          * @example
-         * import { schema } from './generated/i18n-schema.js';
-         *
-         * const i18n = new I18n({ ...config, schema });
+         * const i18n = new I18n({ ...config, schema: {} as TranslationSchema });
          */
         schema?: S;
         /**
@@ -510,6 +510,19 @@ export declare namespace Parser {
      */
     type ExtractParamsFactory<O = unknown> = (options?: O) => ExtractParams;
 }
+declare global {
+    namespace SvelteKitI18n {
+        /**
+         * The app's type registry, filled by a generated global script
+         * (`interface Register { schema: TranslationSchema }`). Its `schema` types
+         * every instance whose config states none. Every copy of the core declares
+         * it empty, and a library never registers: the registry covers the whole
+         * program.
+         */
+        interface Register {
+        }
+    }
+}
 export declare namespace Schema {
     /**
      * A schema types calls only when its keys form a specific, closed set. An
@@ -518,10 +531,25 @@ export declare namespace Schema {
      * they degrade to no schema at all.
      */
     type HasClosedKeys<S> = [keyof S & string] extends [never] ? false : string extends keyof S ? false : true;
-    /** The key schema carried by a config; `never` when there is none to use. */
-    export type FromConfig<C> = C extends {
-        schema?: infer S extends object;
-    } ? (HasClosedKeys<S> extends true ? S : never) : never;
+    /** `S` when its keys are a closed set, `never` otherwise. A union schema is taken whole. */
+    type Closed<S> = [S] extends [object] ? (HasClosedKeys<S> extends true ? S : never) : never;
+    /** What a config's `schema` slot holds; `unknown` when it is absent or typed `any`. */
+    type Slot<C> = C extends {
+        schema?: infer S;
+    } ? S : unknown;
+    /** The key schema `SvelteKitI18n.Register` carries; `never` when it carries none to use. */
+    export type Registered = SvelteKitI18n.Register extends {
+        schema: infer S;
+    } ? Closed<S> : never;
+    /**
+     * The key schema a config types its instance with; `never` when there is
+     * none to use. A slot the config states decides — a closed schema is that
+     * schema, one without a closed key set (`{}`) opts out to plain string keys
+     * — while an absent slot, or one typed `any` (a plain `Config.T`
+     * annotation), reads the registry. A union of configs yields the union of
+     * their schemas.
+     */
+    export type FromConfig<C> = C extends unknown ? (unknown extends Slot<C> ? Registered : Closed<Slot<C>>) : never;
     /**
      * The key schema an instance was built with; `never` when it carries none.
      * The counterpart of `FromConfig` for code handed a constructed surface

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltekit-i18n/base",
-  "version": "3.1.0-next.1",
+  "version": "3.1.0-next.3",
   "description": "Base functionality of sveltekit-i18n library with a support for external message parsers.",
   "type": "module",
   "types": "./dist/index.d.ts",