@worthy-ventures/metaglotta-runtime 1.0.0

package/README.md

@@ -0,0 +1,44 @@
+# @worthy-ventures/metaglotta-runtime
+
+The Metaglotta translation runtime. No framework, no DOM, no plugins.
+
+```ts
+import { Metaglotta } from '@worthy-ventures/metaglotta-runtime';
+
+const i18n = Metaglotta({
+    language: 'el',
+    fallbackLanguage: 'en',
+    defaultNs: 'common',
+    ns: ['common', 'login'],
+    fallbackNs: ['common'],
+    backend: { prefix: 'https://cdn.example/langs/lis' },
+});
+
+await i18n.run();
+i18n.t('greeting', { name: 'Ada' });
+```
+
+## What it does
+
+Holds translations per language and namespace, fetches the ones it needs as
+`{prefix}/{namespace}/{language}.json`, falls back through namespaces and then languages when
+a key is missing, formats ICU, and emits an event when any of that changes.
+
+## What it does not do
+
+In-context editing. That needs every rendered string traced back to its key, which means
+wrapping each one and watching the DOM - a different job, wanted only while authoring. The
+authoring build runs on `@worthy-ventures/metaglotta-ngx/authoring` instead.
+
+## Behaviours worth knowing
+
+- **A miss echoes the key.** `t('nope')` returns `'nope'`, so a missing string is visible on
+  the page. Pass `orEmpty: true` for `''` instead - which is what the Angular pipe does.
+- **Namespace before language.** The lookup exhausts each namespace across every fallback
+  language before trying the next namespace. A key present in both `login/en` and `common/el`
+  resolves to `login/en` when you asked for `login`.
+- **A missing ICU parameter renders `'invalid'`.** Not the raw string, and not an empty one.
+- **A file that fails to load costs its namespace, not the load.** The record is remembered as
+  empty so it is not re-requested by every component on the page; the failure is reported on
+  the `error` event and to the console. Pass `backend.fallbackOnFail: false` to fail the whole
+  load instead.

package/dist/backend.d.ts

@@ -0,0 +1,19 @@
+import type { BackendOptions, RecordDescriptor, TranslationsInput } from './types.js';
+/**
+ * Carries which record failed, because the url alone does not say it.
+ *
+ * The caller decides whether one unreadable file costs a namespace or the whole load, and it
+ * cannot decide that without knowing which namespace it was.
+ */
+export declare class RecordLoadError extends Error {
+    readonly descriptor: RecordDescriptor;
+    readonly url: string;
+    readonly cause: unknown;
+    constructor(descriptor: RecordDescriptor, url: string, cause: unknown);
+}
+export type Backend = {
+    load: (descriptor: RecordDescriptor) => Promise<TranslationsInput | undefined>;
+    /** Whether a failed record is survivable. Read by the caller, not here. */
+    fallbackOnFail: boolean;
+};
+export declare function createBackend(options: BackendOptions): Backend;

package/dist/backend.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecordLoadError = void 0;
+exports.createBackend = createBackend;
+/**
+ * Loading one `{namespace}/{language}.json` from wherever the translations are published.
+ *
+ * Deliberately not a plugin. There is exactly one backend in these applications - a
+ * CloudFront prefix - and a plugin system for a single implementation is machinery with
+ * nothing to choose between.
+ */
+const defaultGetPath = ({ namespace, language, prefix }) => {
+    const base = prefix.replace(/\/+$/, '');
+    return namespace ? `${base}/${namespace}/${language}.json` : `${base}/${language}.json`;
+};
+/**
+ * Carries which record failed, because the url alone does not say it.
+ *
+ * The caller decides whether one unreadable file costs a namespace or the whole load, and it
+ * cannot decide that without knowing which namespace it was.
+ */
+class RecordLoadError extends Error {
+    constructor(descriptor, url, cause) {
+        super(`Metaglotta: could not load ${descriptor.namespace || '(default)'}/${descriptor.language} from ${url}`);
+        this.descriptor = descriptor;
+        this.url = url;
+        this.cause = cause;
+        this.name = 'RecordLoadError';
+    }
+}
+exports.RecordLoadError = RecordLoadError;
+function createBackend(options) {
+    const prefix = options.prefix ?? '/i18n';
+    const getPath = options.getPath ?? defaultGetPath;
+    const getData = options.getData ?? ((response) => response.json());
+    const headers = { Accept: 'application/json', ...options.headers };
+    const fetchFn = options.fetch ?? ((input, init) => fetch(input, init));
+    return {
+        fallbackOnFail: options.fallbackOnFail !== false,
+        async load(descriptor) {
+            const url = getPath({ ...descriptor, prefix });
+            try {
+                const response = await withTimeout(() => fetchFn(url, { headers }), options.timeout, url);
+                if (!response.ok)
+                    throw new Error(`responded ${response.status}`);
+                return (await getData(response, descriptor));
+            }
+            catch (error) {
+                throw new RecordLoadError(descriptor, url, error);
+            }
+        },
+    };
+}
+/**
+ * A fetch that gives up.
+ *
+ * Without this a hung connection holds the initial load open for as long as the browser's own
+ * timeout, which is minutes - and an application that awaits run() waits with it.
+ */
+async function withTimeout(run, ms, url) {
+    if (ms === undefined)
+        return run();
+    let timer;
+    try {
+        return await Promise.race([
+            run(),
+            new Promise((_, reject) => {
+                timer = setTimeout(() => reject(new Error(`timed out after ${ms}ms: ${url}`)), ms);
+            }),
+        ]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+//# sourceMappingURL=backend.js.map

package/dist/backend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"backend.js","sourceRoot":"","sources":["../src/backend.ts"],"names":[],"mappings":";;;AAsCA,sCAoBC;AAxDD;;;;;;GAMG;AAEH,MAAM,cAAc,GAAY,CAAC,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE;IAChE,MAAM,IAAI,GAAG,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;IACxC,OAAO,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,IAAI,SAAS,IAAI,QAAQ,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,IAAI,QAAQ,OAAO,CAAC;AAC5F,CAAC,CAAC;AAEF;;;;;GAKG;AACH,MAAa,eAAgB,SAAQ,KAAK;IACtC,YACa,UAA4B,EAC5B,GAAW,EACX,KAAc;QAEvB,KAAK,CAAC,8BAA8B,UAAU,CAAC,SAAS,IAAI,WAAW,IAAI,UAAU,CAAC,QAAQ,SAAS,GAAG,EAAE,CAAC,CAAC;QAJrG,eAAU,GAAV,UAAU,CAAkB;QAC5B,QAAG,GAAH,GAAG,CAAQ;QACX,UAAK,GAAL,KAAK,CAAS;QAGvB,IAAI,CAAC,IAAI,GAAG,iBAAiB,CAAC;IAClC,CAAC;CACJ;AATD,0CASC;AAQD,SAAgB,aAAa,CAAC,OAAuB;IACjD,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,IAAI,OAAO,CAAC;IACzC,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,IAAI,cAAc,CAAC;IAClD,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,IAAI,CAAC,CAAC,QAAkB,EAAE,EAAE,CAAC,QAAQ,CAAC,IAAI,EAAsB,CAAC,CAAC;IACjG,MAAM,OAAO,GAAG,EAAE,MAAM,EAAE,kBAAkB,EAAE,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;IACnE,MAAM,OAAO,GAAG,OAAO,CAAC,KAAK,IAAI,CAAC,CAAC,KAAwB,EAAE,IAAkB,EAAE,EAAE,CAAC,KAAK,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC;IAExG,OAAO;QACH,cAAc,EAAE,OAAO,CAAC,cAAc,KAAK,KAAK;QAChD,KAAK,CAAC,IAAI,CAAC,UAA4B;YACnC,MAAM,GAAG,GAAG,OAAO,CAAC,EAAE,GAAG,UAAU,EAAE,MAAM,EAAE,CAAC,CAAC;YAC/C,IAAI,CAAC;gBACD,MAAM,QAAQ,GAAG,MAAM,WAAW,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;gBAC1F,IAAI,CAAC,QAAQ,CAAC,EAAE;oBAAE,MAAM,IAAI,KAAK,CAAC,aAAa,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;gBAClE,OAAO,CAAC,MAAM,OAAO,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAsB,CAAC;YACtE,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACb,MAAM,IAAI,eAAe,CAAC,UAAU,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;YACtD,CAAC;QACL,CAAC;KACJ,CAAC;AACN,CAAC;AAED;;;;;GAKG;AACH,KAAK,UAAU,WAAW,CAAC,GAA4B,EAAE,EAAsB,EAAE,GAAW;IACxF,IAAI,EAAE,KAAK,SAAS;QAAE,OAAO,GAAG,EAAE,CAAC;IAEnC,IAAI,KAAgD,CAAC;IACrD,IAAI,CAAC;QACD,OAAO,MAAM,OAAO,CAAC,IAAI,CAAC;YACtB,GAAG,EAAE;YACL,IAAI,OAAO,CAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE;gBAC7B,KAAK,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,mBAAmB,EAAE,OAAO,GAAG,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;YACvF,CAAC,CAAC;SACL,CAAC,CAAC;IACP,CAAC;YAAS,CAAC;QACP,IAAI,KAAK;YAAE,YAAY,CAAC,KAAK,CAAC,CAAC;IACnC,CAAC;AACL,CAAC"}

package/dist/cache.d.ts

@@ -0,0 +1,36 @@
+import type { RecordDescriptor, TranslationsInput, TranslationsRecord } from './types.js';
+/**
+ * Translations, keyed by language and namespace.
+ *
+ * Flat on the way in. A file may nest - `{ "menu": { "save": "Save" } }` - and callers ask
+ * for `menu.save`, so the nesting is resolved once at load rather than walked on every
+ * lookup. Empty values are dropped rather than stored: a null in the file means the string
+ * has no translation, and storing it would stop the language fallback from ever running.
+ */
+export declare function flatten(data: TranslationsInput, prefix?: string): TranslationsRecord;
+/** `en` for the default namespace, `en:login` otherwise - the shape staticData is keyed by. */
+export declare function recordKey({ language, namespace }: RecordDescriptor): string;
+export declare function createCache(): {
+    has(descriptor: RecordDescriptor): boolean;
+    set(descriptor: RecordDescriptor, data: TranslationsInput): void;
+    /**
+     * The first stored value, trying every namespace against every language.
+     *
+     * Namespace is the OUTER loop, and that is not arbitrary: a key present in both the
+     * asked-for namespace's fallback language and a fallback namespace's primary
+     * language resolves to the former. Reversing the loops changes which translation the
+     * page shows, silently, and only for keys that exist in two namespaces.
+     *
+     * WHERE it was found comes back with it. A template that names no namespace still
+     * resolves to a real one, and anything that wants to edit the string afterwards needs
+     * that name rather than the nothing the caller asked with.
+     */
+    find(namespaces: string[], languages: string[], key: string): {
+        value: string;
+        namespace: string;
+    } | undefined;
+    /** In-memory only, for a page whose text was just edited elsewhere. */
+    write(descriptor: RecordDescriptor, key: string, value: string): boolean;
+    clear(): void;
+};
+export type Cache = ReturnType<typeof createCache>;

package/dist/cache.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flatten = flatten;
+exports.recordKey = recordKey;
+exports.createCache = createCache;
+/**
+ * Translations, keyed by language and namespace.
+ *
+ * Flat on the way in. A file may nest - `{ "menu": { "save": "Save" } }` - and callers ask
+ * for `menu.save`, so the nesting is resolved once at load rather than walked on every
+ * lookup. Empty values are dropped rather than stored: a null in the file means the string
+ * has no translation, and storing it would stop the language fallback from ever running.
+ */
+function flatten(data, prefix = '') {
+    const flat = {};
+    for (const [key, value] of Object.entries(data)) {
+        if (value === undefined || value === null)
+            continue;
+        const path = prefix ? `${prefix}.${key}` : key;
+        if (typeof value === 'object') {
+            Object.assign(flat, flatten(value, path));
+        }
+        else {
+            flat[path] = String(value);
+        }
+    }
+    return flat;
+}
+/** `en` for the default namespace, `en:login` otherwise - the shape staticData is keyed by. */
+function recordKey({ language, namespace }) {
+    return namespace ? `${language}:${namespace}` : language;
+}
+function createCache() {
+    const records = new Map();
+    return {
+        has(descriptor) {
+            return records.has(recordKey(descriptor));
+        },
+        set(descriptor, data) {
+            records.set(recordKey(descriptor), flatten(data));
+        },
+        /**
+         * The first stored value, trying every namespace against every language.
+         *
+         * Namespace is the OUTER loop, and that is not arbitrary: a key present in both the
+         * asked-for namespace's fallback language and a fallback namespace's primary
+         * language resolves to the former. Reversing the loops changes which translation the
+         * page shows, silently, and only for keys that exist in two namespaces.
+         *
+         * WHERE it was found comes back with it. A template that names no namespace still
+         * resolves to a real one, and anything that wants to edit the string afterwards needs
+         * that name rather than the nothing the caller asked with.
+         */
+        find(namespaces, languages, key) {
+            for (const namespace of namespaces) {
+                for (const language of languages) {
+                    const value = records.get(recordKey({ language, namespace }))?.[key];
+                    if (value !== undefined)
+                        return { value, namespace };
+                }
+            }
+            return undefined;
+        },
+        /** In-memory only, for a page whose text was just edited elsewhere. */
+        write(descriptor, key, value) {
+            const record = records.get(recordKey(descriptor));
+            if (!record)
+                return false;
+            record[key] = value;
+            return true;
+        },
+        clear() {
+            records.clear();
+        },
+    };
+}
+//# sourceMappingURL=cache.js.map

package/dist/cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.js","sourceRoot":"","sources":["../src/cache.ts"],"names":[],"mappings":";;AAUA,0BAcC;AAGD,8BAEC;AAED,kCA8CC;AA3ED;;;;;;;GAOG;AACH,SAAgB,OAAO,CAAC,IAAuB,EAAE,MAAM,GAAG,EAAE;IACxD,MAAM,IAAI,GAAuB,EAAE,CAAC;IAEpC,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;QAC9C,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI;YAAE,SAAS;QACpD,MAAM,IAAI,GAAG,MAAM,CAAC,CAAC,CAAC,GAAG,MAAM,IAAI,GAAG,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC;QAC/C,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;YAC5B,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC;QAC9C,CAAC;aAAM,CAAC;YACJ,IAAI,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;QAC/B,CAAC;IACL,CAAC;IAED,OAAO,IAAI,CAAC;AAChB,CAAC;AAED,+FAA+F;AAC/F,SAAgB,SAAS,CAAC,EAAE,QAAQ,EAAE,SAAS,EAAoB;IAC/D,OAAO,SAAS,CAAC,CAAC,CAAC,GAAG,QAAQ,IAAI,SAAS,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC;AAC7D,CAAC;AAED,SAAgB,WAAW;IACvB,MAAM,OAAO,GAAG,IAAI,GAAG,EAA8B,CAAC;IAEtD,OAAO;QACH,GAAG,CAAC,UAA4B;YAC5B,OAAO,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC;QAC9C,CAAC;QAED,GAAG,CAAC,UAA4B,EAAE,IAAuB;YACrD,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;QACtD,CAAC;QAED;;;;;;;;;;;WAWG;QACH,IAAI,CAAC,UAAoB,EAAE,SAAmB,EAAE,GAAW;YACvD,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;gBACjC,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE,CAAC;oBAC/B,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;oBACrE,IAAI,KAAK,KAAK,SAAS;wBAAE,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC;gBACzD,CAAC;YACL,CAAC;YACD,OAAO,SAAS,CAAC;QACrB,CAAC;QAED,uEAAuE;QACvE,KAAK,CAAC,UAA4B,EAAE,GAAW,EAAE,KAAa;YAC1D,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC;YAClD,IAAI,CAAC,MAAM;gBAAE,OAAO,KAAK,CAAC;YAC1B,MAAM,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;YACpB,OAAO,IAAI,CAAC;QAChB,CAAC;QAED,KAAK;YACD,OAAO,CAAC,KAAK,EAAE,CAAC;QACpB,CAAC;KACJ,CAAC;AACN,CAAC"}

package/dist/events.d.ts

@@ -0,0 +1,6 @@
+import type { EventName, Subscription } from './types.js';
+export declare function createEvents(): {
+    on(name: EventName | "update", handler: (event: never) => void): Subscription;
+    emit(name: EventName, value: unknown): void;
+};
+export type Events = ReturnType<typeof createEvents>;

package/dist/events.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEvents = createEvents;
+/**
+ * Which events mean "what is on screen may now be wrong".
+ *
+ * Cache writes are batched. A load writes one record per (language, namespace), and emitting
+ * an update for each would re-translate the page six times for one load, so they are queued
+ * and flushed on the next tick. A language change is not batched: it is a single event and
+ * the page should not wait a tick to reflect it. An error is not an update at all - nothing
+ * on screen changed because a file failed to load.
+ */
+const FEEDS_UPDATE = {
+    language: 'now',
+    initialLoad: 'now',
+    cache: 'batched',
+};
+function createEvents() {
+    const handlers = new Map();
+    let queued = [];
+    let flushScheduled = false;
+    function listeners(name) {
+        const existing = handlers.get(name);
+        if (existing)
+            return existing;
+        const created = [];
+        handlers.set(name, created);
+        return created;
+    }
+    function deliver(name, payload) {
+        // Copied before iterating: a handler that unsubscribes itself would otherwise make
+        // the loop skip the handler after it.
+        for (const handler of [...listeners(name)])
+            handler(payload);
+    }
+    function flush() {
+        flushScheduled = false;
+        if (!queued.length)
+            return;
+        const batch = queued;
+        queued = [];
+        deliver('update', batch);
+    }
+    return {
+        on(name, handler) {
+            const list = listeners(name);
+            list.push(handler);
+            return {
+                unsubscribe() {
+                    const at = list.indexOf(handler);
+                    if (at >= 0)
+                        list.splice(at, 1);
+                },
+            };
+        },
+        emit(name, value) {
+            const event = { type: name, value };
+            deliver(name, event);
+            const update = FEEDS_UPDATE[name];
+            if (!update)
+                return;
+            queued.push(event);
+            if (update === 'now') {
+                flush();
+                return;
+            }
+            if (!flushScheduled) {
+                flushScheduled = true;
+                setTimeout(flush, 0);
+            }
+        },
+    };
+}
+//# sourceMappingURL=events.js.map

package/dist/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.js","sourceRoot":"","sources":["../src/events.ts"],"names":[],"mappings":";;AAiBA,oCAyDC;AAxED;;;;;;;;GAQG;AACH,MAAM,YAAY,GAAkD;IAChE,QAAQ,EAAE,KAAK;IACf,WAAW,EAAE,KAAK;IAClB,KAAK,EAAE,SAAS;CACnB,CAAC;AAEF,SAAgB,YAAY;IACxB,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAsC,CAAC;IAC/D,IAAI,MAAM,GAAgB,EAAE,CAAC;IAC7B,IAAI,cAAc,GAAG,KAAK,CAAC;IAE3B,SAAS,SAAS,CAAC,IAAY;QAC3B,MAAM,QAAQ,GAAG,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACpC,IAAI,QAAQ;YAAE,OAAO,QAAQ,CAAC;QAC9B,MAAM,OAAO,GAA+B,EAAE,CAAC;QAC/C,QAAQ,CAAC,GAAG,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;QAC5B,OAAO,OAAO,CAAC;IACnB,CAAC;IAED,SAAS,OAAO,CAAC,IAAY,EAAE,OAAgB;QAC3C,mFAAmF;QACnF,sCAAsC;QACtC,KAAK,MAAM,OAAO,IAAI,CAAC,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;YAAG,OAAoC,CAAC,OAAO,CAAC,CAAC;IAC/F,CAAC;IAED,SAAS,KAAK;QACV,cAAc,GAAG,KAAK,CAAC;QACvB,IAAI,CAAC,MAAM,CAAC,MAAM;YAAE,OAAO;QAC3B,MAAM,KAAK,GAAG,MAAM,CAAC;QACrB,MAAM,GAAG,EAAE,CAAC;QACZ,OAAO,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;IAC7B,CAAC;IAED,OAAO;QACH,EAAE,CAAC,IAA0B,EAAE,OAA+B;YAC1D,MAAM,IAAI,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;YAC7B,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YACnB,OAAO;gBACH,WAAW;oBACP,MAAM,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;oBACjC,IAAI,EAAE,IAAI,CAAC;wBAAE,IAAI,CAAC,MAAM,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;gBACpC,CAAC;aACJ,CAAC;QACN,CAAC;QAED,IAAI,CAAC,IAAe,EAAE,KAAc;YAChC,MAAM,KAAK,GAAc,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC;YAC/C,OAAO,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;YAErB,MAAM,MAAM,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC;YAClC,IAAI,CAAC,MAAM;gBAAE,OAAO;YAEpB,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACnB,IAAI,MAAM,KAAK,KAAK,EAAE,CAAC;gBACnB,KAAK,EAAE,CAAC;gBACR,OAAO;YACX,CAAC;YACD,IAAI,CAAC,cAAc,EAAE,CAAC;gBAClB,cAAc,GAAG,IAAI,CAAC;gBACtB,UAAU,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;YACzB,CAAC;QACL,CAAC;KACJ,CAAC;AACN,CAAC"}

package/dist/format.d.ts

@@ -0,0 +1,9 @@
+import type { FormatFn, TranslateParams } from './types.js';
+export declare function formatIcu({ translation, language, params }: {
+    translation: string;
+    language: string;
+    params?: TranslateParams;
+}): string;
+/** Test seam: the cache is a module global by design, and lives as long as the page. */
+export declare function forgetCompiled(): void;
+export declare function resolveFormat(format: 'icu' | 'none' | FormatFn | undefined): FormatFn;

package/dist/format.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatIcu = formatIcu;
+exports.forgetCompiled = forgetCompiled;
+exports.resolveFormat = resolveFormat;
+/**
+ * The NAMED import, not the default one.
+ *
+ * intl-messageformat ships CommonJS with an ESM wrapper, and under Node's ESM interop the
+ * default export resolves to the whole module namespace rather than to the class - so
+ * `new IntlMessageFormat(...)` throws "is not a constructor", and every string with a
+ * placeholder in it renders as the format-error text. Bundlers and jest both take the
+ * CommonJS path, where the default DOES work, so nothing catches this until it is running
+ * somewhere real. The named export is the class in both.
+ */
+const intl_messageformat_1 = require("intl-messageformat");
+/**
+ * ICU MessageFormat, over FormatJS directly rather than through a wrapper.
+ *
+ * Compiled formatters are cached by (language, message). Parsing an ICU message is the
+ * expensive half, and the message text is what varies least: the same string is formatted
+ * once per render of every component that shows it, with different parameters each time.
+ */
+const compiled = new Map();
+/**
+ * Strings that cannot mean anything but themselves.
+ *
+ * Most translations are plain text, and running the parser over them is pure cost. Only two
+ * characters can make a string non-literal: `{` opens a placeholder, and `'` is ICU's escape
+ * character - `'{'` renders a literal brace and `''` renders one apostrophe, so `It''s` would
+ * render wrongly if this shortcut took it. `#` is special only inside a plural, which needs a
+ * `{` to open.
+ */
+const LITERAL = /^[^{']*$/;
+function formatIcu({ translation, language, params }) {
+    if (LITERAL.test(translation))
+        return translation;
+    const cacheKey = `${language} ${translation}`;
+    let formatter = compiled.get(cacheKey);
+    if (!formatter) {
+        formatter = new intl_messageformat_1.IntlMessageFormat(translation, language);
+        compiled.set(cacheKey, formatter);
+    }
+    const formatted = formatter.format(params);
+    // format() returns an array for messages with rich-text tags. Nothing here uses those,
+    // but joining beats rendering "[object Object]" if one ever appears.
+    return Array.isArray(formatted) ? formatted.join('') : String(formatted);
+}
+/** Test seam: the cache is a module global by design, and lives as long as the page. */
+function forgetCompiled() {
+    compiled.clear();
+}
+function resolveFormat(format) {
+    if (typeof format === 'function')
+        return format;
+    if (format === 'none')
+        return ({ translation }) => translation;
+    return formatIcu;
+}
+//# sourceMappingURL=format.js.map

package/dist/format.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.js","sourceRoot":"","sources":["../src/format.ts"],"names":[],"mappings":";;AAiCA,8BAcC;AAGD,wCAEC;AAED,sCAIC;AA1DD;;;;;;;;;GASG;AACH,2DAAuD;AAGvD;;;;;;GAMG;AACH,MAAM,QAAQ,GAAG,IAAI,GAAG,EAA6B,CAAC;AAEtD;;;;;;;;GAQG;AACH,MAAM,OAAO,GAAG,UAAU,CAAC;AAE3B,SAAgB,SAAS,CAAC,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,EAAuE;IAC5H,IAAI,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC;QAAE,OAAO,WAAW,CAAC;IAElD,MAAM,QAAQ,GAAG,GAAG,QAAQ,IAAI,WAAW,EAAE,CAAC;IAC9C,IAAI,SAAS,GAAG,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IACvC,IAAI,CAAC,SAAS,EAAE,CAAC;QACb,SAAS,GAAG,IAAI,sCAAiB,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC;QACzD,QAAQ,CAAC,GAAG,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;IACtC,CAAC;IAED,MAAM,SAAS,GAAG,SAAS,CAAC,MAAM,CAAC,MAAqD,CAAC,CAAC;IAC1F,uFAAuF;IACvF,qEAAqE;IACrE,OAAO,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;AAC7E,CAAC;AAED,wFAAwF;AACxF,SAAgB,cAAc;IAC1B,QAAQ,CAAC,KAAK,EAAE,CAAC;AACrB,CAAC;AAED,SAAgB,aAAa,CAAC,MAA6C;IACvE,IAAI,OAAO,MAAM,KAAK,UAAU;QAAE,OAAO,MAAM,CAAC;IAChD,IAAI,MAAM,KAAK,MAAM;QAAE,OAAO,CAAC,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC,WAAW,CAAC;IAC/D,OAAO,SAAS,CAAC;AACrB,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { Metaglotta } from './instance.js';
+export type { I18nInstance } from './instance.js';
+export { RecordLoadError } from './backend.js';
+export { getTranslateProps, asList, unique } from './props.js';
+export { flatten, recordKey } from './cache.js';
+export { formatIcu, forgetCompiled, resolveFormat } from './format.js';
+export type { BackendOptions, EventName, FormatFn, GetPath, I18nEvent, LanguageFallback, MetaglottaOptions, NamespaceFallback, RecordDescriptor, Subscription, TranslateParams, TranslateProps, DecorateFn, TranslateOptions, TranslateFn, TranslationsInput, TranslationsRecord, } from './types.js';

package/dist/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveFormat = exports.forgetCompiled = exports.formatIcu = exports.recordKey = exports.flatten = exports.unique = exports.asList = exports.getTranslateProps = exports.RecordLoadError = exports.Metaglotta = void 0;
+var instance_js_1 = require("./instance.js");
+Object.defineProperty(exports, "Metaglotta", { enumerable: true, get: function () { return instance_js_1.Metaglotta; } });
+var backend_js_1 = require("./backend.js");
+Object.defineProperty(exports, "RecordLoadError", { enumerable: true, get: function () { return backend_js_1.RecordLoadError; } });
+var props_js_1 = require("./props.js");
+Object.defineProperty(exports, "getTranslateProps", { enumerable: true, get: function () { return props_js_1.getTranslateProps; } });
+Object.defineProperty(exports, "asList", { enumerable: true, get: function () { return props_js_1.asList; } });
+Object.defineProperty(exports, "unique", { enumerable: true, get: function () { return props_js_1.unique; } });
+var cache_js_1 = require("./cache.js");
+Object.defineProperty(exports, "flatten", { enumerable: true, get: function () { return cache_js_1.flatten; } });
+Object.defineProperty(exports, "recordKey", { enumerable: true, get: function () { return cache_js_1.recordKey; } });
+var format_js_1 = require("./format.js");
+Object.defineProperty(exports, "formatIcu", { enumerable: true, get: function () { return format_js_1.formatIcu; } });
+Object.defineProperty(exports, "forgetCompiled", { enumerable: true, get: function () { return format_js_1.forgetCompiled; } });
+Object.defineProperty(exports, "resolveFormat", { enumerable: true, get: function () { return format_js_1.resolveFormat; } });
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,6CAA2C;AAAlC,yGAAA,UAAU,OAAA;AAEnB,2CAA+C;AAAtC,6GAAA,eAAe,OAAA;AACxB,uCAA+D;AAAtD,6GAAA,iBAAiB,OAAA;AAAE,kGAAA,MAAM,OAAA;AAAE,kGAAA,MAAM,OAAA;AAC1C,uCAAgD;AAAvC,mGAAA,OAAO,OAAA;AAAE,qGAAA,SAAS,OAAA;AAC3B,yCAAuE;AAA9D,sGAAA,SAAS,OAAA;AAAE,2GAAA,cAAc,OAAA;AAAE,0GAAA,aAAa,OAAA"}

package/dist/instance.d.ts

@@ -0,0 +1,38 @@
+import { RecordLoadError } from './backend.js';
+import type { EventName, MetaglottaOptions, NamespaceFallback, Subscription, TranslateProps } from './types.js';
+/**
+ * What both runtimes provide, and all the Angular layer asks for.
+ *
+ * Eight methods. That number is the whole reason this package could be written at all: the
+ * dependency being replaced is nineteen thousand lines, but the part anything here actually
+ * calls is this - measured by counting call sites, not by reading a feature list.
+ */
+export type I18nInstance = {
+    t: (keyOrProps: string | TranslateProps, ...rest: unknown[]) => string;
+    on: (event: EventName | 'update', handler: (event: never) => void) => Subscription;
+    run: () => Promise<void>;
+    stop: () => void;
+    getLanguage: () => string | undefined;
+    changeLanguage: (language: string) => Promise<void>;
+    addActiveNs: (ns?: NamespaceFallback, forget?: boolean) => Promise<void>;
+    removeActiveNs: (ns?: NamespaceFallback) => void;
+    /** In-memory only, and only where the record is loaded. Returns whether it took. */
+    changeTranslation: (descriptor: {
+        language?: string;
+        namespace?: string;
+    }, key: string, value: string) => boolean;
+};
+/**
+ * The Metaglotta translation runtime.
+ *
+ * Everything the eleven applications do in production: hold translations per language and
+ * namespace, fetch the ones they need from the CDN, fall back through namespaces and
+ * languages when a key is missing, format ICU, and say when any of that changed.
+ *
+ * What it deliberately does not do is in-context editing. That needs the page's rendered text
+ * traced back to its key, which means wrapping every string and watching the DOM - a
+ * different job, only wanted while authoring, and it stays where it is until it is rewritten
+ * too. Both runtimes satisfy I18nInstance, so a bootstrap picks one per environment.
+ */
+export declare function Metaglotta(options: MetaglottaOptions): I18nInstance;
+export { RecordLoadError };