@primate/core 0.4.5 → 0.5.0

package/lib/private/i18n/index/client.js

@@ -0,0 +1,152 @@
+import DEFAULT_PERSIST_MODE from "#i18n/constant/DEFAULT_PERSIST_MODE";
+import PERSIST_HEADER from "#i18n/constant/PERSIST_HEADER";
+import PERSIST_METHOD from "#i18n/constant/PERSIST_METHOD";
+import PERSIST_STORAGE_KEY from "#i18n/constant/PERSIST_STORAGE_KEY";
+import format from "#i18n/format";
+import Formatter from "#i18n/Formatter";
+import resolve from "#i18n/resolve";
+import sInternal from "#i18n/symbol/internal";
+import validate from "#i18n/validate";
+import sConfig from "#symbol/config";
+export default function i18n(config) {
+    const catalogs = config.locales;
+    for (const [locale, catalog] of Object.entries(catalogs)) {
+        validate(catalog, locale);
+    }
+    const default_catalog = catalogs[config.defaultLocale];
+    let active_locale = config.defaultLocale;
+    const currency = config.currency ?? "USD";
+    const formatter = new Formatter(active_locale);
+    // reactive core
+    let version = 0;
+    const subscribers = new Set();
+    const touch = () => {
+        for (const subscriber of subscribers) {
+            try {
+                subscriber();
+            }
+            catch {
+                // ignore
+            }
+        }
+    };
+    let persist_fn;
+    let loading = null;
+    const listeners = new Set();
+    const notify = (locale) => {
+        for (const fn of listeners)
+            fn(locale);
+    };
+    function apply(locale, options = {}) {
+        const { emit = false, persist = false } = options;
+        if (locale === active_locale)
+            return;
+        active_locale = locale;
+        formatter.locale = locale;
+        version++;
+        if (emit)
+            notify(locale);
+        if (persist && persist_fn) {
+            const run = async (l) => { await persist_fn(l); };
+            loading = run(locale)
+                .catch(e => { console.warn("[i18n]: persist failed", e); })
+                .finally(() => {
+                loading = null;
+                version++;
+                notify(active_locale);
+            });
+        }
+    }
+    const set = (locale) => apply(locale, {
+        emit: true, persist: true,
+    });
+    const init = (locale) => apply(locale);
+    const mode = config.persist ?? DEFAULT_PERSIST_MODE;
+    if (mode === "cookie") {
+        persist_fn = async (locale) => {
+            const res = await fetch("/", {
+                method: PERSIST_METHOD, headers: { [PERSIST_HEADER]: locale },
+            });
+            if (!res.ok)
+                throw new Error(`[i18n] persist failed: ${res.status}`);
+        };
+    }
+    else if (mode === "localStorage") {
+        persist_fn = (locale) => {
+            try {
+                localStorage.setItem(PERSIST_STORAGE_KEY, locale);
+            }
+            catch { } // ignore
+        };
+    }
+    else if (mode === "sessionStorage") {
+        persist_fn = (locale) => {
+            try {
+                sessionStorage.setItem(PERSIST_STORAGE_KEY, locale);
+            }
+            catch { } // ignore
+        };
+    } // no persistence
+    function storage_restore() {
+        const mode = config.persist ?? DEFAULT_PERSIST_MODE;
+        if (mode === "localStorage" || mode === "sessionStorage") {
+            try {
+                const store = mode === "localStorage" ? localStorage : sessionStorage;
+                const saved = store.getItem(PERSIST_STORAGE_KEY);
+                if (saved && saved in catalogs) {
+                    set(saved);
+                }
+            }
+            catch { } //
+        }
+    }
+    function t(...args) {
+        touch(); // reactive read
+        const [key, params] = args;
+        const translated = resolve(catalogs[active_locale], key) ??
+            resolve(default_catalog, key) ??
+            String(key);
+        if (typeof translated === "string") {
+            return format(translated, params ?? {}, currency, formatter);
+        }
+        return translated;
+    }
+    const api = t;
+    api.onChange = (fn) => {
+        listeners.add(fn);
+        try {
+            fn(active_locale);
+        }
+        catch { } // ignore
+        return () => { listeners.delete(fn); };
+    };
+    api.locale = {
+        get: () => { touch(); return active_locale; },
+        set,
+    };
+    Object.defineProperty(api, "loading", {
+        get: () => { touch(); return loading !== null; },
+    });
+    Object.defineProperty(api, sConfig, {
+        get: () => config,
+    });
+    Object.defineProperty(api, sInternal, {
+        value: {
+            init,
+            wait: () => loading ?? Promise.resolve(),
+            depend(fn) {
+                subscribers.add(fn);
+                return () => subscribers.delete(fn);
+            },
+            get version() { return version; },
+            touch,
+            restore: storage_restore,
+        },
+    });
+    // svelte-style store interface
+    api.subscribe = (run) => {
+        return api.onChange(() => run(api));
+    };
+    return api;
+}
+//# sourceMappingURL=client.js.map