@sveltekit-i18n/base 3.2.0 → 3.3.1

package/dist/utils.js

@@ -6,7 +6,7 @@ export const hasOwn = (obj, key) => obj != null && Object.prototype.hasOwnProper
 // Own-property read: returns the value only when `key` is the object's own
 // property, otherwise undefined. Centralizes the prototype-safe table lookup.
 export const read = (obj, key) => (hasOwn(obj, key) ? obj[key] : undefined);
-export const translate = ({ parser, key, params, translations, locale, fallbackLocale, ...rest }) => {
+export const translate = (config, locale, key, params, table, fallbackTable) => {
     if (!key) {
         logger.warn(`No translation key provided ('${locale}' locale). Skipping translation...`);
         return '';
@@ -15,23 +15,23 @@ export const translate = ({ parser, key, params, translations, locale, fallbackL
         logger.warn(`No locale provided for '${key}' key. Skipping translation...`);
         return '';
     }
-    const localeTranslations = read(translations, locale);
-    let text = read(localeTranslations, key);
+    const fallbackLocale = config?.fallbackLocale;
+    let text = read(table, key);
     if (fallbackLocale && text === undefined) {
         logger.debug(`No translation provided for '${key}' key in locale '${locale}'. Trying fallback '${fallbackLocale}'`);
-        const fallbackTranslations = read(translations, fallbackLocale);
-        text = read(fallbackTranslations, key);
+        text = read(fallbackTable, key);
     }
     if (text === undefined) {
         logger.debug(`No translation provided for '${key}' key in fallback '${fallbackLocale}'.`);
-        if (hasOwn(rest, 'fallbackValue')) {
-            return rest.fallbackValue;
+        if (hasOwn(config, 'fallbackValue')) {
+            return config?.fallbackValue;
         }
         logger.warn(`No translation nor fallback found for '${key}' .`);
         // There is nothing to interpolate, so no parser is asked to. Echoing the
         // key is what makes a missing translation visible instead of blank.
         return key;
     }
+    const parser = config?.parser;
     if (!parser || typeof parser.parse !== 'function') {
         // Reached on every call while no parser is set (e.g. before config loads),
         // so keep it at debug to avoid flooding logs on the render path.
@@ -43,7 +43,10 @@ export const translate = ({ parser, key, params, translations, locale, fallbackL
     return parser.parse(text, params, locale, key);
 };
 // `Intl.Collator.supportedLocalesOf` is comparatively expensive and locales
-// repeat constantly — per loader on every load trigger, per lookup.
+// repeat constantly — per loader on every load trigger, per lookup. A locale
+// Intl rejects is remembered too: its data is fixed for the life of the realm,
+// as the remembered hits already assume. It is still reported on every call,
+// so the warning reaches whichever logger and level is installed at the time.
 const LOCALE_CACHE_LIMIT = 1000;
 const sanitizedLocaleCache = new Map();
 // Insertion order is the eviction order, so reinserting on a hit makes it
@@ -68,30 +71,27 @@ const mapLocales = (transform) => (...locales) => {
         return [];
     return locales.filter((locale) => !!locale).map(transform);
 };
+const sanitizeLocale = (locale) => {
+    try {
+        const [sanitized] = Intl.Collator.supportedLocalesOf(locale);
+        if (sanitized)
+            return { locale: sanitized };
+    }
+    catch { /* reported as non-standard */ }
+    return { locale: `${locale}`.toLowerCase(), nonStandard: true };
+};
 export const sanitizeLocales = mapLocales((locale) => {
     // Only a string is a faithful key for itself.
     const cacheable = typeof locale === 'string';
-    if (cacheable) {
-        const cached = recallSanitizedLocale(locale);
-        if (cached !== undefined)
-            return cached;
-    }
-    let current = `${locale}`.toLowerCase();
-    try {
-        const [sanitized] = Intl.Collator.supportedLocalesOf(locale);
-        if (!sanitized)
-            throw new Error();
-        current = sanitized;
+    let sanitized = cacheable ? recallSanitizedLocale(locale) : undefined;
+    if (!sanitized) {
+        sanitized = sanitizeLocale(locale);
         if (cacheable)
-            rememberSanitizedLocale(locale, current);
+            rememberSanitizedLocale(locale, sanitized);
     }
-    catch {
-        // Deliberately not remembered: a locale Intl does not know yet can
-        // recover, and the warning stays tied to the call rather than to
-        // whichever logger was installed first.
+    if (sanitized.nonStandard)
         logger.warn(`'${locale}' locale is non-standard.`);
-    }
-    return current;
+    return sanitized.locale;
 });
 // The normalization `config.sanitizeLocales` asks for. A custom transform is
 // consumer code and every table is keyed by what it returns, so a throwing or
@@ -366,14 +366,17 @@ export const routePrefix = (pathname, routeId) => {
     const at = [...segments.keys(), segments.length].find((skip) => fits(skip, 0));
     return at === undefined ? undefined : raw.slice(0, at).map((segment) => `/${segment}`).join('');
 };
+/** Whether `config.preprocess` is the built-in dot notation. */
+export const dotNotates = (preprocess) => typeof preprocess !== 'function' && preprocess !== 'none';
 export const toDotNotation = (input, preserveArrays, parentKey) => {
     if (preserveArrays && Array.isArray(input)) {
         return input.map((v) => toDotNotation(v, preserveArrays));
     }
     if (input && typeof input === 'object') {
         // Mutated in place (rebuilding per key is quadratic) into a null-prototype
-        // object, then spread once on the way out — a literal '__proto__' key stays
-        // an own property instead of reaching the prototype setter.
+        // object, then given `Object.prototype` once the last key is written — a
+        // spread would copy every key, and a literal '__proto__' key stays an own
+        // property either way instead of reaching the prototype setter.
         const output = Object.create(null);
         let hasEntries = false;
         const walk = (node, prefix) => {
@@ -391,7 +394,7 @@ export const toDotNotation = (input, preserveArrays, parentKey) => {
         };
         walk(input, parentKey);
         if (hasEntries) {
-            return { ...output };
+            return Object.setPrototypeOf(output, Object.prototype);
         }
         return null;
     }
@@ -410,14 +413,24 @@ const describeRoute = (route) => {
 };
 // The content itself rather than a hash of it: equality stays exact, and the
 // string repeats what a serialized payload already carries, so it compresses
-// with it.
-const loaderId = ({ locale, namespace, routes }) => JSON.stringify(routes ? [locale, namespace, routes.map(describeRoute)] : [locale, namespace]);
+// with it. The pairs of one descriptor share its `routes`, so each list is
+// described once per resolution rather than once per pair.
+const loaderId = ({ locale, namespace, routes }, describe) => JSON.stringify(routes ? [locale, namespace, describe(routes)] : [locale, namespace]);
 // A name shared by two loaders would hand one's records to the other, so
 // neither keeps it.
 const withIds = (loaders) => {
+    const described = new Map();
+    const describe = (routes) => {
+        const known = described.get(routes);
+        if (known !== undefined)
+            return known;
+        const description = routes.map(describeRoute);
+        described.set(routes, description);
+        return description;
+    };
     const ids = loaders.map((loader) => {
         try {
-            return loaderId(loader);
+            return loaderId(loader, describe);
         }
         catch (error) {
             logError('Cannot derive an id for a loader.', error);
@@ -442,7 +455,8 @@ const withIds = (loaders) => {
 const reportedDeprecations = new WeakSet();
 export const resolveLoaders = (input = [], sanitizeLocales = true) => {
     const sanitize = sanitizerFactory(sanitizeLocales);
-    return withIds(input.reduce((acc, descriptor) => {
+    const resolved = [];
+    input.forEach((descriptor) => {
         try {
             const { namespace, key, locale, loader, routes, cache } = descriptor;
             if (key !== undefined && !reportedDeprecations.has(descriptor)) {
@@ -456,24 +470,23 @@ export const resolveLoaders = (input = [], sanitizeLocales = true) => {
             const locales = unique(sanitize(...asList(locale).filter((name) => name != null)));
             if (!namespaces.length || !locales.length) {
                 logger.warn('Skipping a loader that names no locale or no namespace.');
-                return acc;
+                return;
             }
-            return [
-                ...acc,
-                ...locales.flatMap((pairLocale) => namespaces.map((pairNamespace) => ({
+            locales.forEach((pairLocale) => namespaces.forEach((pairNamespace) => {
+                resolved.push({
                     namespace: pairNamespace,
                     locale: pairLocale,
                     loader,
                     routes,
                     ...(cache === false ? { cache } : {}),
-                }))),
-            ];
+                });
+            }));
         }
         catch (error) {
             logError('Skipping a loader that cannot be read.', error);
-            return acc;
         }
-    }, []));
+    });
+    return withIds(resolved);
 };
 const isMergeable = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
 // Data reaching a namespace that already holds some — route-scoped chunks of
@@ -487,10 +500,19 @@ export const mergeTranslations = (target, source, path, onConflict) => {
         onConflict?.(path);
         return source;
     }
-    return Object.keys(source).reduce((acc, key) => ({
-        ...acc,
-        [key]: hasOwn(acc, key) ? mergeTranslations(read(acc, key), read(source, key), `${path}.${key}`, onConflict) : read(source, key),
-    }), target);
+    const keys = Object.keys(source);
+    if (!keys.length) {
+        return target;
+    }
+    // Mutated in place (rebuilding per key is quadratic) into a null-prototype
+    // copy of `target`, then given `Object.prototype` once the last key is
+    // written — a literal '__proto__' key stays an own property instead of
+    // reaching the prototype setter.
+    const output = Object.assign(Object.create(null), target);
+    keys.forEach((key) => {
+        output[key] = hasOwn(output, key) ? mergeTranslations(read(output, key), read(source, key), `${path}.${key}`, onConflict) : read(source, key);
+    });
+    return Object.setPrototypeOf(output, Object.prototype);
 };
 // What of `target` still shows once `source` is merged over it: the branches
 // both hold as objects keep what `source` leaves out, and anything else it
@@ -498,12 +520,12 @@ export const mergeTranslations = (target, source, path, onConflict) => {
 export const maskTranslations = (target, source) => {
     if (!isMergeable(target) || !isMergeable(source))
         return undefined;
-    return Object.keys(target).reduce((acc, key) => {
+    return Object.fromEntries(Object.keys(target).flatMap((key) => {
         if (!hasOwn(source, key))
-            return { ...acc, [key]: read(target, key) };
+            return [[key, read(target, key)]];
         const masked = maskTranslations(read(target, key), read(source, key));
-        return masked === undefined ? acc : { ...acc, [key]: masked };
-    }, {});
+        return masked === undefined ? [] : [[key, masked]];
+    }));
 };
 // What of `target`, dot-notated under `prefix`, still shows once `keys` are
 // dot-notated beside it: a leaf whose key is among them is gone. A key spelled
@@ -526,7 +548,7 @@ export const maskOutputKeys = (target, keys, prefix, preserveArrays = false) =>
         if (Array.isArray(target) && entries.every(([key], index) => key === `${index}`))
             return entries.map(([, value]) => value);
     }
-    return entries.reduce((acc, [key, value]) => ({ ...acc, [key]: value }), {});
+    return Object.fromEntries(entries);
 };
 const isPlainObject = (value) => {
     if (!value || typeof value !== 'object')
@@ -534,21 +556,27 @@ const isPlainObject = (value) => {
     const proto = Object.getPrototypeOf(value);
     return proto === Object.prototype || proto === null;
 };
-// devalue, which SvelteKit serializes load data with, refuses an object with
-// an own '__proto__' key. Branches without one are returned as they are.
-export const omitProtoKeys = (value) => {
+const holdsProtoKey = (value) => (Array.isArray(value)
+    ? value.some(holdsProtoKey)
+    : isPlainObject(value) && Object.keys(value).some((key) => key === '__proto__' || holdsProtoKey(value[key])));
+const withoutProtoKeys = (value) => {
     if (Array.isArray(value)) {
-        const items = value.map(omitProtoKeys);
-        return items.some((item, i) => item !== value[i]) ? items : value;
+        const items = value.map(withoutProtoKeys);
+        return items.some((item, i) => !Object.is(item, value[i])) ? items : value;
     }
     if (!isPlainObject(value))
         return value;
     const keys = Object.keys(value);
-    const entries = keys.filter((key) => key !== '__proto__').map((key) => [key, omitProtoKeys(value[key])]);
-    if (entries.length === keys.length && entries.every(([key, item]) => item === value[key]))
+    const entries = keys.filter((key) => key !== '__proto__').map((key) => [key, withoutProtoKeys(value[key])]);
+    if (entries.length === keys.length && entries.every(([key, item]) => Object.is(item, value[key])))
         return value;
-    return entries.reduce((acc, [key, item]) => ({ ...acc, [key]: item }), {});
+    return Object.fromEntries(entries);
 };
+// devalue, which SvelteKit serializes load data with, refuses an object with
+// an own '__proto__' key. Branches without one are returned as they are. A
+// snapshot runs this over every table, so a scan that copies nothing decides
+// first whether there is anything to leave out.
+export const omitProtoKeys = (value) => (holdsProtoKey(value) ? withoutProtoKeys(value) : value);
 const reportLoaderConflict = (path) => {
     logger.warn(`Conflicting translations for '${path}'. Keeping the value of the last loader.`);
 };
@@ -573,11 +601,12 @@ export const servedLocales = (loaders, tables) => unique([
     ...Object.keys(tables),
 ]);
 /**
- * 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 const configLocales = ({ loaders, translations, sanitizeLocales: strategy }) => servedLocales(resolveLoaders(loaders, strategy), translations ? sanitizeTranslationLocales(translations, sanitizerFactory(strategy)) : {});
+export const configLocales = ({ translations, sanitizeLocales: strategy }, loaders) => servedLocales(loaders, translations ? sanitizeTranslationLocales(translations, sanitizerFactory(strategy)) : {});
 /** A loader as a message names it. `String`, since interpolating a Symbol namespace throws. */
 export const loaderName = ({ locale, namespace }) => `'${locale}' > '${String(namespace)}'`;
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltekit-i18n/base",
-  "version": "3.2.0",
+  "version": "3.3.1",
   "description": "Base functionality of sveltekit-i18n library with a support for external message parsers.",
   "type": "module",
   "types": "./dist/index.d.ts",
@@ -34,7 +34,7 @@
   },
   "scripts": {
     "dev": "svelte-package -i src -o dist -w",
-    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "typecheck": "tsc --noEmit -p tsconfig.json && tsc --noEmit -p bench",
     "pretest": "npm run build && npm run typecheck",
     "test": "vitest run",
     "pretest:dist": "npm run build",
@@ -42,6 +42,7 @@
     "build": "svelte-package -i src -o dist",
     "prepublishOnly": "npm run build",
     "lint": "eslint --fix .",
+    "bench": "node bench/run.ts",
     "prepare": "simple-git-hooks"
   },
   "files": [