@sveltekit-i18n/base 1.3.7 → 3.0.0-next.0

package/dist/utils.js

@@ -0,0 +1,237 @@
+import { logError, logger } from './logger.js';
+// Safe own-property read. Translation keys like `toString`, `constructor` or
+// `__proto__` would otherwise resolve to inherited `Object.prototype` members
+// instead of being treated as missing translations.
+export const hasOwn = (obj, key) => obj != null && Object.prototype.hasOwnProperty.call(obj, key);
+// 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);
+// The fail-soft paths return placeholder strings (`''`, the key itself) even
+// for a parser with a non-string output — hence the `as unknown as O` casts.
+export const translate = ({ parser, key, params, translations, locale, fallbackLocale, ...rest }) => {
+    if (!key) {
+        logger.warn(`No translation key provided ('${locale}' locale). Skipping translation...`);
+        return '';
+    }
+    if (!locale) {
+        logger.warn(`No locale provided for '${key}' key. Skipping translation...`);
+        return '';
+    }
+    const localeTranslations = read(translations, locale);
+    let text = read(localeTranslations, 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);
+    }
+    if (text === undefined) {
+        logger.debug(`No translation provided for '${key}' key in fallback '${fallbackLocale}'.`);
+        if (hasOwn(rest, 'fallbackValue')) {
+            return rest.fallbackValue;
+        }
+        logger.warn(`No translation nor fallback found for '${key}' .`);
+    }
+    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.
+        logger.debug(`No parser configured. Returning raw value for '${key}' key.`);
+        // Mirror the missing-translation contract: fall back to the key itself.
+        if (text === undefined)
+            return key;
+        return text;
+    }
+    // A key schema narrows the rest params to one key's payload — still a `P`,
+    // but no longer provably so once the tuple has been rebuilt.
+    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.
+const LOCALE_CACHE_LIMIT = 1000;
+const sanitizedLocaleCache = new Map();
+// Insertion order is the eviction order, so reinserting on a hit makes it
+// least-recently-used: a flood of visitor-supplied locales evicts itself
+// rather than the app's own.
+const recallSanitizedLocale = (locale) => {
+    const cached = sanitizedLocaleCache.get(locale);
+    if (cached === undefined)
+        return undefined;
+    sanitizedLocaleCache.delete(locale);
+    sanitizedLocaleCache.set(locale, cached);
+    return cached;
+};
+const rememberSanitizedLocale = (locale, sanitized) => {
+    if (sanitizedLocaleCache.size >= LOCALE_CACHE_LIMIT) {
+        sanitizedLocaleCache.delete(sanitizedLocaleCache.keys().next().value);
+    }
+    sanitizedLocaleCache.set(locale, sanitized);
+};
+const mapLocales = (transform) => (...locales) => {
+    if (!locales.length)
+        return [];
+    return locales.filter((locale) => !!locale).map(transform);
+};
+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;
+        if (cacheable)
+            rememberSanitizedLocale(locale, current);
+    }
+    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.
+        logger.warn(`'${locale}' locale is non-standard.`);
+    }
+    return current;
+});
+// 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
+// empty-handed one degrades to the locale as authored.
+export const sanitizerFactory = (sanitize = true) => {
+    if (typeof sanitize === 'function') {
+        return mapLocales((locale) => {
+            const input = `${locale}`;
+            try {
+                const transformed = sanitize(input);
+                if (transformed)
+                    return `${transformed}`;
+                logger.warn(`'sanitizeLocales' returned no locale for '${input}'.`);
+            }
+            catch (error) {
+                logError(`'sanitizeLocales' failed for '${input}' locale.`, error);
+            }
+            return input;
+        });
+    }
+    if (!sanitize)
+        return mapLocales((locale) => `${locale}`);
+    return sanitizeLocales;
+};
+// Every other locale-keyed surface (`locale`, `fallbackLocale`, loader data,
+// the loaded-key bookkeeping) is sanitized, so a table handed in under a raw
+// locale would be unreachable. Merged rather than replaced: two spellings of
+// one locale are one entry.
+export const sanitizeTranslationLocales = (input, sanitize) => (Object.keys(input).reduce((acc, locale) => {
+    const [sanitized = locale] = sanitize(locale);
+    return { ...acc, [sanitized]: { ...read(acc, sanitized), ...read(input, locale) } };
+}, {}));
+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.
+        const output = Object.create(null);
+        let hasEntries = false;
+        const walk = (node, prefix) => {
+            Object.keys(node).forEach((key) => {
+                const value = node[key];
+                const outputKey = prefix ? `${prefix}.${key}` : `${key}`;
+                if (value && typeof value === 'object' && !(preserveArrays && Array.isArray(value))) {
+                    walk(value, outputKey);
+                }
+                else {
+                    output[outputKey] = toDotNotation(value, preserveArrays);
+                    hasEntries = true;
+                }
+            });
+        };
+        walk(input, parentKey);
+        if (hasEntries) {
+            return { ...output };
+        }
+        return null;
+    }
+    return input;
+};
+// Loader properties are consumer code — an accessor may throw. Materialized
+// once at the config boundary, so a single unreadable loader costs only itself
+// instead of taking down every locale-keyed read downstream.
+export const resolveLoaders = (input = []) => (input.reduce((acc, descriptor) => {
+    try {
+        const { key, locale, loader, routes } = descriptor;
+        return [...acc, { key, locale, loader, routes }];
+    }
+    catch (error) {
+        logError('Skipping a loader that cannot be read.', error);
+        return acc;
+    }
+}, []));
+const isMergeable = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
+// Data reaching a namespace that already holds some — route-scoped chunks of
+// one namespace, a later load, a second `addTranslations` — contributes to it
+// instead of replacing it. Plain objects merge branch by branch; anything else
+// is a leaf, and a leaf collision has no merge to perform, so the incoming
+// value is kept. Only callers for which a collision means an authoring mistake
+// pass `onConflict`.
+export const mergeTranslations = (target, source, path, onConflict) => {
+    if (!isMergeable(target) || !isMergeable(source)) {
+        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 reportLoaderConflict = (path) => {
+    logger.warn(`Conflicting translations for '${path}'. Keeping the value of the last loader.`);
+};
+export const serialize = (input) => {
+    return input.reduce((acc, { key, data, locale }) => {
+        if (!data)
+            return acc;
+        // The locale is already sanitized — loaders are normalized before the fetch.
+        const namespaces = read(acc, locale);
+        return ({
+            ...acc,
+            [locale]: {
+                ...namespaces,
+                [key]: hasOwn(namespaces, key) ? mergeTranslations(read(namespaces, key), data, `${key}`, reportLoaderConflict) : data,
+            },
+        });
+    }, {});
+};
+export const fetchTranslations = async (loaders, route) => {
+    const response = await Promise.all(loaders.map(async ({ loader, ...rest }) => {
+        let data;
+        try {
+            data = await loader({ locale: rest.locale, route });
+        }
+        catch (error) {
+            logError(`Failed to load translation. Verify your '${rest.locale}' > '${rest.key}' Loader.`, error);
+        }
+        return { loader, ...rest, data };
+    }));
+    return serialize(response);
+};
+// `test` advances `lastIndex` on a `g`/`y` pattern, so a route object reused
+// across navigations would match only every other time — and writing to the
+// consumer's own pattern is not ours to do, least of all when it is frozen.
+const withoutMatchState = (input) => (input instanceof RegExp && (input.global || input.sticky)
+    ? new RegExp(input.source, input.flags)
+    : input);
+export const testRoute = (route) => (input) => {
+    try {
+        if (typeof input === 'string')
+            return input === route;
+        return withoutMatchState(input).test(route);
+    }
+    catch (error) {
+        logError('Invalid route config!', error);
+    }
+    return false;
+};

package/package.json

@@ -1,32 +1,37 @@
 {
   "name": "@sveltekit-i18n/base",
-  "version": "1.3.7",
+  "version": "3.0.0-next.0",
   "description": "Base functionality of sveltekit-i18n library with a support for external message parsers.",
   "type": "module",
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "require": "./dist/index.cjs",
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "types": "./dist/index.d.ts",
+      "svelte": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./utils": {
+      "types": "./dist/exports/utils.d.ts",
+      "svelte": "./dist/exports/utils.js",
+      "default": "./dist/exports/utils.js"
     },
     "./package.json": "./package.json"
   },
   "scripts": {
-    "dev": "tsup --watch",
-    "test": "npx cross-env NODE_OPTIONS=--experimental-vm-modules jest",
-    "build": "tsup",
+    "dev": "svelte-package -i src -o dist -w",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "pretest": "npm run build && npm run typecheck",
+    "test": "vitest run",
+    "pretest:dist": "npm run build",
+    "test:dist": "vitest run --config vitest.dist.config.ts",
+    "build": "svelte-package -i src -o dist",
     "prepublishOnly": "npm run build",
-    "lint": "eslint --fix --ext .ts,.js --ignore-path .gitignore ."
+    "lint": "eslint --fix .",
+    "prepare": "simple-git-hooks"
   },
   "files": [
     "dist"
   ],
-  "pre-commit": [
-    "lint"
-  ],
   "repository": {
     "type": "git",
     "url": "git+ssh://git@github.com/sveltekit-i18n/base.git"
@@ -46,20 +51,30 @@
     "url": "https://github.com/sveltekit-i18n/lib/issues"
   },
   "homepage": "https://github.com/sveltekit-i18n/base#readme",
+  "engines": {
+    "node": ">=22"
+  },
   "peerDependencies": {
-    "svelte": ">=3.49.0"
+    "svelte": ">=5"
   },
   "devDependencies": {
-    "@types/jest": "^29.5.2",
-    "@typescript-eslint/eslint-plugin": "^6.0.0",
-    "@typescript-eslint/parser": "^6.0.0",
-    "eslint": "^8.4.1",
-    "eslint-config-airbnb-typescript": "^17.1.0",
-    "eslint-plugin-import": "^2.25.3",
-    "jest": "^29.6.0",
-    "pre-commit": "^1.2.2",
-    "ts-jest": "^29.1.1",
-    "tsup": "^7.1.0",
-    "typescript": "^5.1.6"
+    "@eslint/js": "^10.0.1",
+    "@stylistic/eslint-plugin": "^5.10.0",
+    "@sveltejs/package": "^2.5.8",
+    "@sveltejs/vite-plugin-svelte": "^7.3.0",
+    "@types/node": "^26.2.0",
+    "esbuild": "^0.28.2",
+    "eslint": "^10.8.1",
+    "eslint-plugin-import-x": "^4.17.1",
+    "globals": "^17.11.0",
+    "simple-git-hooks": "^2.13.1",
+    "svelte": "^5.56.9",
+    "typescript": "^5.1.6",
+    "typescript-eslint": "^8.67.0",
+    "vitest": "^4.1.10"
+  },
+  "svelte": "./dist/index.js",
+  "simple-git-hooks": {
+    "pre-commit": "npm run lint"
   }
 }

package/dist/index.cjs

@@ -1 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var H=Object.defineProperty,q=Object.defineProperties;var B=Object.getOwnPropertyDescriptors;var x=Object.getOwnPropertySymbols;var K=Object.prototype.hasOwnProperty,A=Object.prototype.propertyIsEnumerable;var N=(s,t,e)=>t in s?H(s,t,{enumerable:!0,configurable:!0,writable:!0,value:e}):s[t]=e,l=(s,t)=>{for(var e in t||(t={}))K.call(t,e)&&N(s,e,t[e]);if(x)for(var e of x(t))A.call(t,e)&&N(s,e,t[e]);return s},f=(s,t)=>q(s,B(t));var L=(s,t)=>{var e={};for(var a in s)K.call(s,a)&&t.indexOf(a)<0&&(e[a]=s[a]);if(s!=null&&x)for(var a of x(s))t.indexOf(a)<0&&A.call(s,a)&&(e[a]=s[a]);return e};var _store = require('svelte/store');var C=["error","warn","debug"],$=({logger:s=console,level:t=C[1],prefix:e="[i18n]: "})=>C.reduce((a,r,i)=>f(l({},a),{[r]:o=>C.indexOf(t)>=i&&s[r](`${e}${o}`)}),{}),c=$({}),V=s=>{c=s};var z=n=>{var d=n,{parser:s,key:t,params:e,translations:a,locale:r,fallbackLocale:i}=d,o=L(d,["parser","key","params","translations","locale","fallbackLocale"]);if(!t)return c.warn(`No translation key provided ('${r}' locale). Skipping translation...`),"";if(!r)return c.warn(`No locale provided for '${t}' key. Skipping translation...`),"";let u=(a[r]||{})[t];if(i&&u===void 0&&(c.debug(`No translation provided for '${t}' key in locale '${r}'. Trying fallback '${i}'`),u=(a[i]||{})[t]),u===void 0){if(c.debug(`No translation provided for '${t}' key in fallback '${i}'.`),o.hasOwnProperty("fallbackValue"))return o.fallbackValue;c.warn(`No translation nor fallback found for '${t}' .`)}return s.parse(u,e,r,t)},h=(...s)=>s.length?s.filter(t=>!!t).map(t=>{let e=`${t}`.toLowerCase();try{let[a]=Intl.Collator.supportedLocalesOf(t);if(!a)throw new Error;e=a}catch(a){c.warn(`'${t}' locale is non-standard.`)}return e}):[],w=(s,t,e)=>{if(t&&Array.isArray(s))return s.map(a=>w(a,t));if(s&&typeof s=="object"){let a=Object.keys(s).reduce((r,i)=>{let o=s[i],n=e?`${e}.${i}`:`${i}`;return o&&typeof o=="object"&&!(t&&Array.isArray(o))?l(l({},r),w(o,t,n)):f(l({},r),{[n]:w(o,t)})},{});return Object.keys(a).length?a:null}return s},G=s=>s.reduce((t,{key:e,data:a,locale:r})=>{if(!a)return t;let[i]=h(r),o=f(l({},t[i]||{}),{[e]:a});return f(l({},t),{[i]:o})},{}),E=async s=>{try{let t=await Promise.all(s.map(r=>{var i=r,{loader:e}=i,a=L(i,["loader"]);return new Promise(async o=>{let n;try{n=await e()}catch(d){c.error(`Failed to load translation. Verify your '${a.locale}' > '${a.key}' Loader.`),c.error(d)}o(f(l({loader:e},a),{data:n}))})}));return G(t)}catch(t){c.error(t)}return{}},W=s=>t=>{try{if(typeof t=="string")return t===s;if(typeof t=="object")return t.test(s)}catch(e){c.error("Invalid route config!")}return!1},F=(s,t)=>{let e=!0;try{e=Object.keys(s).filter(a=>s[a]!==void 0).every(a=>s[a]===t[a])}catch(a){}return e};var D=1e3*60*60*24,O= exports.default =class{constructor(t){this.cachedAt=0;this.loadedKeys={};this.currentRoute=_store.writable.call(void 0, );this.config=_store.writable.call(void 0, );this.isLoading=_store.writable.call(void 0, !1);this.promises=new Set;this.loading={subscribe:this.isLoading.subscribe,toPromise:(t,e)=>{let{fallbackLocale:a}=_store.get.call(void 0, this.config),r=Array.from(this.promises).filter(i=>{let o=F({locale:h(t)[0],route:e},i);return a&&(o=o||F({locale:h(a)[0],route:e},i)),o}).map(({promise:i})=>i);return Promise.all(r)},get:()=>_store.get.call(void 0, this.isLoading)};this.privateRawTranslations=_store.writable.call(void 0, {});this.rawTranslations={subscribe:this.privateRawTranslations.subscribe,get:()=>_store.get.call(void 0, this.rawTranslations)};this.privateTranslations=_store.writable.call(void 0, {});this.translations={subscribe:this.privateTranslations.subscribe,get:()=>_store.get.call(void 0, this.translations)};this.locales=f(l({},_store.derived.call(void 0, [this.config,this.privateTranslations],([t,e])=>{if(!t)return[];let{loaders:a=[]}=t,r=a.map(({locale:o})=>o),i=Object.keys(e).map(o=>o);return Array.from(new Set([...h(...r),...h(...i)]))},[])),{get:()=>_store.get.call(void 0, this.locales)});this.internalLocale=_store.writable.call(void 0, );this.loaderTrigger=_store.derived.call(void 0, [this.internalLocale,this.currentRoute],([t,e],a)=>{var r,i;t!==void 0&&e!==void 0&&!(t===((r=_store.get.call(void 0, this.loaderTrigger))==null?void 0:r[0])&&e===((i=_store.get.call(void 0, this.loaderTrigger))==null?void 0:i[1]))&&(c.debug("Triggering translation load..."),a([t,e]))},[]);this.localeHelper=_store.writable.call(void 0, );this.locale={subscribe:this.localeHelper.subscribe,forceSet:this.localeHelper.set,set:this.internalLocale.set,update:this.internalLocale.update,get:()=>_store.get.call(void 0, this.locale)};this.initialized=_store.derived.call(void 0, [this.locale,this.currentRoute,this.privateTranslations],([t,e,a],r)=>{_store.get.call(void 0, this.initialized)||r(t!==void 0&&e!==void 0&&!!Object.keys(a).length)});this.translation=_store.derived.call(void 0, [this.privateTranslations,this.locale,this.isLoading],([t,e,a],r)=>{let i=t[e];i&&Object.keys(i).length&&!a&&r(i)},{});this.t=f(l({},_store.derived.call(void 0, [this.config,this.translation],r=>{var[i]=r,o=i,{parser:t,fallbackLocale:e}=o,a=L(o,["parser","fallbackLocale"]);return(n,...d)=>z(l({parser:t,key:n,params:d,translations:this.translations.get(),locale:this.locale.get(),fallbackLocale:e},a.hasOwnProperty("fallbackValue")?{fallbackValue:a.fallbackValue}:{}))})),{get:(t,...e)=>_store.get.call(void 0, this.t)(t,...e)});this.l=f(l({},_store.derived.call(void 0, [this.config,this.translations],i=>{var[o,...n]=i,d=o,{parser:t,fallbackLocale:e}=d,a=L(d,["parser","fallbackLocale"]),[r]=n;return(u,b,...k)=>z(l({parser:t,key:b,params:k,translations:r,locale:u,fallbackLocale:e},a.hasOwnProperty("fallbackValue")?{fallbackValue:a.fallbackValue}:{}))})),{get:(t,e,...a)=>_store.get.call(void 0, this.l)(t,e,...a)});this.getLocale=t=>{let{fallbackLocale:e}=_store.get.call(void 0, this.config)||{},a=t||e;if(!a)return;let r=this.locales.get();return r.find(o=>h(a).includes(o))||r.find(o=>h(e).includes(o))};this.setLocale=t=>{if(t&&t!==_store.get.call(void 0, this.internalLocale))return c.debug(`Setting '${t}' locale.`),this.internalLocale.set(t),this.loading.toPromise(t,_store.get.call(void 0, this.currentRoute))};this.setRoute=t=>{if(t!==_store.get.call(void 0, this.currentRoute)){c.debug(`Setting '${t}' route.`),this.currentRoute.set(t);let e=_store.get.call(void 0, this.internalLocale);return this.loading.toPromise(e,t)}};this.loadConfig=async t=>{await this.configLoader(t)};this.getTranslationProps=async(t=this.locale.get(),e=_store.get.call(void 0, this.currentRoute))=>{let a=_store.get.call(void 0, this.config);if(!a||!t)return[];let r=this.translations.get(),{loaders:i,fallbackLocale:o="",cache:n=D}=a||{},d=Number.isNaN(+n)?D:+n;this.cachedAt?Date.now()>d+this.cachedAt&&(c.debug("Refreshing cache."),this.loadedKeys={},this.cachedAt=0):(c.debug("Setting cache timestamp."),this.cachedAt=Date.now());let[u,b]=h(t,o),k=r[u],I=r[b],R=(i||[]).map(j=>{var T=j,{locale:p}=T,y=L(T,["locale"]);return f(l({},y),{locale:h(p)[0]})}).filter(({routes:p})=>!p||(p||[]).some(W(e))).filter(({key:p,locale:y})=>y===u&&(!k||!(this.loadedKeys[u]||[]).includes(p))||o&&y===b&&(!I||!(this.loadedKeys[b]||[]).includes(p)));if(R.length){this.isLoading.set(!0),c.debug("Fetching translations...");let p=await E(R);this.isLoading.set(!1);let y=Object.keys(p).reduce((T,P)=>f(l({},T),{[P]:Object.keys(p[P])}),{}),j=R.filter(({key:T,locale:P})=>(y[P]||[]).some(S=>`${S}`.startsWith(T))).reduce((T,{key:P,locale:S})=>f(l({},T),{[S]:[...T[S]||[],P]}),{});return[p,j]}return[]};this.addTranslations=(t,e)=>{if(!t)return;let a=_store.get.call(void 0, this.config),{preprocess:r}=a||{};c.debug("Adding translations...");let i=Object.keys(t||{});this.privateRawTranslations.update(o=>i.reduce((n,d)=>f(l({},n),{[d]:l(l({},n[d]||{}),t[d])}),o)),this.privateTranslations.update(o=>i.reduce((n,d)=>{let u=!0,b=t[d];return typeof r=="function"&&(b=r(b)),(typeof r=="function"||r==="none")&&(u=!1),f(l({},n),{[d]:l(l({},n[d]||{}),u?w(b,r==="preserveArrays"):b)})},o)),i.forEach(o=>{let n=Object.keys(t[o]).map(d=>`${d}`.split(".")[0]);e&&(n=e[o]),this.loadedKeys[o]=Array.from(new Set([...this.loadedKeys[o]||[],...n||[]]))})};this.loader=async([t,e])=>{let a=this.getLocale(t)||void 0;c.debug(`Adding loader promise for '${a}' locale and '${e}' route.`);let r=(async()=>{let i=await this.getTranslationProps(a,e);i.length&&this.addTranslations(...i)})();this.promises.add({locale:a,route:e,promise:r}),r.then(()=>{a&&this.locale.get()!==a&&this.locale.forceSet(a)})};this.loadTranslations=(t,e=_store.get.call(void 0, this.currentRoute)||"")=>{let a=this.getLocale(t);if(a)return this.setRoute(e),this.setLocale(a),this.loading.toPromise(a,e)};this.loaderTrigger.subscribe(this.loader),this.isLoading.subscribe(async e=>{e&&this.promises.size&&(await this.loading.toPromise(),this.promises.clear(),c.debug("Loader promises have been purged."))}),t&&this.loadConfig(t)}async configLoader(t){if(!t)return c.error("No config provided!");let n=t,{initLocale:e,fallbackLocale:a,translations:r,log:i}=n,o=L(n,["initLocale","fallbackLocale","translations","log"]);i&&V($(i)),[e]=h(e),[a]=h(a),c.debug("Setting config."),this.config.set(l({initLocale:e,fallbackLocale:a,translations:r},o)),r&&this.addTranslations(r),e&&await this.loadTranslations(e)}};exports.default = O;