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

package/dist/I18n.svelte.d.ts

@@ -113,9 +113,10 @@ declare class I18nCore<ParserParams extends Parser.Params = any, ParserOutput =
      * records name each loader, so a namespace fed by several loaders is handed
      * over too, and so is one a loader delivered for route params while its
      * record says so — not a namespace with both, whose data the client could
-     * not split between them. What was seeded into the namespace of a loader
-     * whose routes capture params travels apart as `seeds`, so it outlives new
-     * params there, and reaches the client where the namespace is left out.
+     * not split between them. What was seeded into the namespace of a recorded
+     * loader, or of one whose routes capture params, travels apart as `seeds`,
+     * so it outlives the loader's next fetch there, and reaches the client
+     * where the namespace is left out.
      */
     snapshot: {
         (options?: {

package/dist/I18n.svelte.js

@@ -413,9 +413,10 @@ class I18nCore {
      * records name each loader, so a namespace fed by several loaders is handed
      * over too, and so is one a loader delivered for route params while its
      * record says so — not a namespace with both, whose data the client could
-     * not split between them. What was seeded into the namespace of a loader
-     * whose routes capture params travels apart as `seeds`, so it outlives new
-     * params there, and reaches the client where the namespace is left out.
+     * not split between them. What was seeded into the namespace of a recorded
+     * loader, or of one whose routes capture params, travels apart as `seeds`,
+     * so it outlives the loader's next fetch there, and reaches the client
+     * where the namespace is left out.
      */
     snapshot = ((options) => {
         const withRecords = options?.records === true;
@@ -472,11 +473,12 @@ class I18nCore {
                 return [];
             return [signature ? { id, signature } : { id }];
         });
-        // Where params can change, the client takes a recorded namespace whole as
-        // its loader's delivery and loads one left out itself, so what was seeded
-        // into it travels apart: the seed has to outlive the delivery new params
-        // replace there as it does here.
-        const seeds = omitProtoKeys(this.#externalOf(loaders.filter(({ locale, routes }) => omitted.has(locale) && locale !== '__proto__' && capturesParams(routes))));
+        // The client takes a recorded namespace whole as its loader's delivery,
+        // and loads one left out where params can change itself, so what was
+        // seeded into either travels apart: the seed has to outlive the delivery
+        // the next fetch replaces there as it does here.
+        const recorded = new Set(records.map(({ id }) => id));
+        const seeds = omitProtoKeys(this.#externalOf(loaders.filter(({ id, locale, routes }) => omitted.has(locale) && locale !== '__proto__' && (capturesParams(routes) || (id !== null && recorded.has(id))))));
         return {
             translations,
             records,
@@ -585,34 +587,40 @@ class I18nCore {
         });
         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.#deliveries = new Map(deliveries.flatMap((delivery) => {
+            const taker = takers.get(delivery);
+            return taker ? [[taker, { ...delivery, loader: taker }]] : [];
+        }));
         this.#keepExternal(serialize(orphaned.map(({ loader, data }) => ({ ...loader, data }))));
     }
     /**
-     * Applies what loaders delivered and records them as loaded. A loader whose
-     * params changed replaces the part of its namespace it delivered before:
-     * the namespace is rebuilt from the data supplied without a loader and from
-     * what each of its loaders last delivered, so no key of the previous params
-     * survives and a sibling's part stays in place. The preprocessed table of a
+     * Applies what loaders delivered and records them as loaded. A loader that
+     * delivered before, for the same params or for others, replaces the part of
+     * its namespace it delivered then: the namespace is rebuilt from the data
+     * supplied without a loader and from what each of its loaders last
+     * delivered, so no key its source dropped survives and a sibling's part
+     * stays in place. The preprocessed table of a
      * locale that lost data is derived again from the raw one, since a custom
      * `preprocess` may have renamed the keys that would have to go. Both tables
      * are computed before anything is written, so a `preprocess` that throws
      * records no loader and the next trigger fetches it again.
      */
-    #applyDeliveries(deliveries) {
+    #applyDeliveries(applied) {
+        const { loaders = [] } = this.#config ?? {};
+        // One load, however its deliveries were gathered: a preload claimed with
+        // it comes first, yet the loader declared later still wins.
+        const deliveries = [...applied].sort((a, b) => loaders.indexOf(a.loader) - loaders.indexOf(b.loader));
         const replaced = deliveries
-            .filter(({ loader, signature }) => {
-            const previous = this.#deliveries.get(loader);
-            return previous !== undefined && previous.signature !== signature;
-        })
+            .filter(({ loader }) => this.#deliveries.has(loader))
             .map(({ loader }) => loader);
-        const delivered = new Map(deliveries.map((delivery) => [delivery.loader, delivery]));
+        const delivered = new Set(deliveries.map(({ loader }) => loader));
         const isReplaced = ({ locale, namespace }) => replaced.some((loader) => loader.locale === locale && loader.namespace === namespace);
-        const { loaders = [] } = this.#config ?? {};
-        const rebuilt = loaders
-            .filter(isReplaced)
-            .map((loader) => delivered.get(loader) ?? this.#deliveries.get(loader))
-            .filter((delivery) => delivery !== undefined);
+        // In the order they were delivered, so across loads the data delivered
+        // last wins, as it does where nothing is rebuilt.
+        const rebuilt = [
+            ...Array.from(this.#deliveries.values()).filter(({ loader }) => isReplaced(loader) && !delivered.has(loader)),
+            ...deliveries.filter(({ loader }) => isReplaced(loader)),
+        ];
         const raw = replaced.reduce((acc, { locale, namespace }) => ({
             ...acc,
             [locale]: Object.fromEntries(Object.entries(read(acc, locale) ?? {}).filter(([key]) => !isNamespaceKey(key, namespace))),
@@ -672,7 +680,7 @@ class I18nCore {
      * that change later replace it; the rest is kept as data supplied without a
      * loader and, like a seed, records no namespace — the hand-off says which loaders it
      * covers, and anything else loads again rather than going missing. `seeds`
-     * is what was seeded where params can change, displayed and kept as a seed
+     * is what was seeded into those namespaces, displayed and kept as a seed
      * so that it outlives a delivery. A record naming no loader of this config
      * is dropped, and its loader runs again.
      */
@@ -705,6 +713,8 @@ class I18nCore {
     }
     /** Records `delivery` as its loader's; what was parked for its params is older. */
     #record(delivery) {
+        // Deleted first, so the map keeps the order the deliveries arrived in.
+        this.#deliveries.delete(delivery.loader);
         this.#deliveries.set(delivery.loader, delivery);
         this.#loaderRecords.set(delivery.loader, delivery.signature);
         if (this.#parked.get(delivery.loader)?.signature === delivery.signature)

package/dist/types.d.ts

@@ -628,10 +628,11 @@ export declare namespace Snapshot {
          */
         records?: LoadRecord[];
         /**
-         * What was seeded into the namespace of a loader whose routes capture
-         * params – repeated where `translations` carries the namespace, and
-         * carried where the payload leaves it out, so that it outlives the
-         * delivery new params replace. Read with `records` only.
+         * What was seeded into the namespace of a recorded loader or of one whose
+         * routes capture params – repeated where `translations` carries the
+         * namespace, and carried where the payload leaves it out, so that it
+         * outlives the delivery the loader's next fetch replaces. Read with
+         * `records` only.
          */
         seeds?: Translations.SerializedTranslations;
         /** The active locale. */

package/package.json

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