@byline/i18n 2.6.0

package/dist/admin/index.d.ts

@@ -0,0 +1,44 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+import enJson from './en.json';
+import type { LocaleCode, NamespaceTranslations, TranslationBundle } from '../types.js';
+declare const en: NamespaceTranslations;
+declare const fr: NamespaceTranslations;
+/** Locale codes for which a bundled translation ships in-package. */
+export declare const bundledLocales: readonly LocaleCode[];
+/** Re-exported as typed consts for plugin authors who want the literal-key autocomplete. */
+export { en, fr };
+export type AdminNamespaceTranslations = typeof enJson;
+export interface AdminTranslationsOptions {
+    /**
+     * Locale codes to include in the returned bundle. Each must appear in
+     * `bundledLocales` — unknown codes throw at config time. Defaults to
+     * `['en']` when omitted, which is always available.
+     */
+    locales?: readonly LocaleCode[];
+}
+/**
+ * Build a `TranslationBundle` carrying the `byline-admin` namespace for
+ * each requested locale. Compose with plugin / extension bundles via
+ * `mergeTranslations(...)` in the host's `admin.config.ts`.
+ *
+ * @example
+ * ```ts
+ * import { adminTranslations } from '@byline/i18n/admin'
+ *
+ * defineClientConfig({
+ *   i18n: {
+ *     interface: { defaultLocale: 'en', locales: ['en', 'fr'] },
+ *     translations: adminTranslations({ locales: ['en', 'fr'] }),
+ *   },
+ * })
+ * ```
+ *
+ * @throws when a requested code is not in `bundledLocales`.
+ */
+export declare function adminTranslations(options?: AdminTranslationsOptions): TranslationBundle;

package/dist/admin/index.js

@@ -0,0 +1,27 @@
+import { mergeTranslations } from "../merge.js";
+import en from "./en.js";
+import fr from "./fr.js";
+const admin_en = en;
+const admin_fr = fr;
+const BUNDLES = {
+    en: admin_en,
+    fr: admin_fr
+};
+const bundledLocales = Object.freeze(Object.keys(BUNDLES));
+function adminTranslations(options = {}) {
+    const locales = options.locales ?? [
+        'en'
+    ];
+    const partials = [];
+    for (const locale of locales){
+        const bundle = BUNDLES[locale];
+        if (null == bundle) throw new Error(`[adminTranslations] no bundled translation for locale '${locale}'. Available: [${bundledLocales.join(', ')}]. To add a locale, drop a new JSON file in @byline/i18n/src/admin/.`);
+        partials.push({
+            [locale]: {
+                'byline-admin': bundle
+            }
+        });
+    }
+    return mergeTranslations(...partials);
+}
+export { adminTranslations, admin_en as en, admin_fr as fr, bundledLocales };

package/dist/formatter.d.ts

@@ -0,0 +1,40 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+import type { LocaleCode, MessageKey, Namespace, TranslationBundle, TranslationValues } from './types.js';
+export interface FormatterOptions {
+    bundle: TranslationBundle;
+    /** The locale to look up first. */
+    activeLocale: LocaleCode;
+    /** Last-resort lookup before falling back to the raw key. */
+    defaultLocale: LocaleCode;
+    /**
+     * Invoked once per `(locale, namespace, key)` triple when step 1
+     * misses but step 2 hits. Used by the React provider to emit
+     * `console.warn` lines in development. Pass `undefined` to suppress.
+     */
+    onMissing?: (event: MissingTranslationEvent) => void;
+}
+export interface MissingTranslationEvent {
+    activeLocale: LocaleCode;
+    namespace: Namespace;
+    key: MessageKey;
+    /** Whether the default-locale lookup also missed. */
+    fellThroughToKey: boolean;
+}
+export interface Formatter {
+    /**
+     * Format a message for `namespace.key` with `values`. Always returns
+     * a string. ICU error paths (malformed message, missing required
+     * argument) fall through to the raw key rather than throwing — the
+     * admin shell should never crash because of a translation bug.
+     */
+    t(namespace: Namespace, key: MessageKey, values?: TranslationValues): string;
+    readonly activeLocale: LocaleCode;
+    readonly defaultLocale: LocaleCode;
+}
+export declare function createFormatter(options: FormatterOptions): Formatter;

package/dist/formatter.js

@@ -0,0 +1,65 @@
+import { IntlMessageFormat } from "intl-messageformat";
+function createFormatter(options) {
+    const { bundle, activeLocale, defaultLocale, onMissing } = options;
+    const formatterCache = new Map();
+    const missingReported = new Set();
+    function lookupMessage(locale, namespace, key) {
+        return bundle[locale]?.[namespace]?.[key];
+    }
+    function getFormatter(locale, namespace, key) {
+        const cacheKey = `${locale}\0${namespace}\0${key}`;
+        const cached = formatterCache.get(cacheKey);
+        if (void 0 !== cached) return cached;
+        const message = lookupMessage(locale, namespace, key);
+        if (null == message) {
+            formatterCache.set(cacheKey, null);
+            return null;
+        }
+        try {
+            const formatter = new IntlMessageFormat(message, locale);
+            formatterCache.set(cacheKey, formatter);
+            return formatter;
+        } catch  {
+            formatterCache.set(cacheKey, null);
+            return null;
+        }
+    }
+    function reportMissing(namespace, key, fellThroughToKey) {
+        if (null == onMissing) return;
+        const reportKey = `${activeLocale}\0${namespace}\0${key}\0${fellThroughToKey ? '1' : '0'}`;
+        if (missingReported.has(reportKey)) return;
+        missingReported.add(reportKey);
+        onMissing({
+            activeLocale,
+            namespace,
+            key,
+            fellThroughToKey
+        });
+    }
+    return {
+        activeLocale,
+        defaultLocale,
+        t (namespace, key, values) {
+            const activeFormatter = getFormatter(activeLocale, namespace, key);
+            if (null != activeFormatter) return formatSafe(activeFormatter, values, key);
+            if (defaultLocale !== activeLocale) {
+                const defaultFormatter = getFormatter(defaultLocale, namespace, key);
+                if (null != defaultFormatter) {
+                    reportMissing(namespace, key, false);
+                    return formatSafe(defaultFormatter, values, key);
+                }
+            }
+            reportMissing(namespace, key, true);
+            return key;
+        }
+    };
+}
+function formatSafe(formatter, values, fallbackKey) {
+    try {
+        const out = formatter.format(values);
+        return 'string' == typeof out ? out : fallbackKey;
+    } catch  {
+        return fallbackKey;
+    }
+}
+export { createFormatter };

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+/**
+ * `@byline/i18n` — admin interface translation primitives.
+ *
+ * Root entry: pure, React-free, safe to import from server contexts
+ * (loaders, server fns, Workers). Carries the type definitions, the
+ * `mergeTranslations` registry helper, the ICU formatter, and the
+ * locale-resolution cascade.
+ *
+ * The React surface (`<I18nProvider>`, `useTranslation`,
+ * `<LanguageMenu>`) lives at `@byline/i18n/react` — single barrel,
+ * single React Context identity, to sidestep the Vite `optimizeDeps`
+ * trap that has bitten this codebase before (see `@byline/ui`'s
+ * `react.ts` comment).
+ *
+ * Admin bundles (`adminTranslations(...)`, the English bundle) live
+ * at `@byline/i18n/admin`.
+ *
+ * See `docs/I18N.md` for the architecture.
+ */
+export { createFormatter } from './formatter.js';
+export { mergeTranslations } from './merge.js';
+export { resolveInterfaceLocale } from './resolve.js';
+export type { Formatter, FormatterOptions, MissingTranslationEvent, } from './formatter.js';
+export type { MergeOptions, TranslationCollision } from './merge.js';
+export type { ResolveInterfaceLocaleOptions } from './resolve.js';
+export type { LocaleCode, LocaleDefinition, MessageKey, Namespace, NamespaceTranslations, TranslationBundle, TranslationValues, } from './types.js';

package/dist/index.js

@@ -0,0 +1,3 @@
+export { createFormatter } from "./formatter.js";
+export { mergeTranslations } from "./merge.js";
+export { resolveInterfaceLocale } from "./resolve.js";

package/dist/merge.d.ts

@@ -0,0 +1,39 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+/**
+ * Merge any number of `TranslationBundle`s into a single immutable
+ * registry. Last writer wins at the `(locale, namespace, key)` grain;
+ * collisions are reported via the optional `onCollision` callback
+ * (called once per replaced key) so callers can wire dev-mode warnings.
+ *
+ * Associative and deterministic — `merge(a, merge(b, c))` produces the
+ * same result as `merge(merge(a, b), c)`. Empty / undefined inputs are
+ * accepted and produce identity behaviour, so callers don't need
+ * conditional branching when a locale bundle is absent.
+ */
+import type { LocaleCode, MessageKey, Namespace, TranslationBundle } from './types.js';
+export interface MergeOptions {
+    /**
+     * Invoked once per collision (where a later bundle overrides an
+     * earlier bundle's value). Pure side effect — used by callers to
+     * emit `console.warn` lines in development. Production hosts can
+     * pass `undefined` to suppress.
+     */
+    onCollision?: (collision: TranslationCollision) => void;
+}
+export interface TranslationCollision {
+    locale: LocaleCode;
+    namespace: Namespace;
+    key: MessageKey;
+    /** The value that was already present and is being overwritten. */
+    previousValue: string;
+    /** The value that replaces it. */
+    nextValue: string;
+}
+export declare function mergeTranslations(...bundles: Array<TranslationBundle | undefined>): TranslationBundle;
+export declare function mergeTranslations(options: MergeOptions, ...bundles: Array<TranslationBundle | undefined>): TranslationBundle;

package/dist/merge.js

@@ -0,0 +1,58 @@
+function mergeTranslations(first, ...rest) {
+    let options = {};
+    let bundles;
+    if (isMergeOptions(first)) {
+        options = first;
+        bundles = rest;
+    } else bundles = [
+        first,
+        ...rest
+    ];
+    const out = {};
+    for (const bundle of bundles)if (null != bundle) for (const locale of Object.keys(bundle)){
+        const localeBundle = bundle[locale];
+        if (null == localeBundle) continue;
+        let targetLocale = out[locale];
+        if (null == targetLocale) {
+            targetLocale = {};
+            out[locale] = targetLocale;
+        }
+        for (const namespace of Object.keys(localeBundle)){
+            const namespaceBundle = localeBundle[namespace];
+            if (null == namespaceBundle) continue;
+            let targetNs = targetLocale[namespace];
+            if (null == targetNs) {
+                targetNs = {};
+                targetLocale[namespace] = targetNs;
+            }
+            for (const key of Object.keys(namespaceBundle)){
+                const nextValue = namespaceBundle[key];
+                if (null == nextValue) continue;
+                const previousValue = targetNs[key];
+                if (void 0 !== previousValue && previousValue !== nextValue) options.onCollision?.({
+                    locale,
+                    namespace,
+                    key,
+                    previousValue,
+                    nextValue
+                });
+                targetNs[key] = nextValue;
+            }
+        }
+    }
+    return freezeBundle(out);
+}
+function isMergeOptions(value) {
+    if (null == value || 'object' != typeof value) return false;
+    const obj = value;
+    return 'function' == typeof obj.onCollision;
+}
+function freezeBundle(bundle) {
+    for (const locale of Object.keys(bundle)){
+        const localeBundle = bundle[locale];
+        for (const namespace of Object.keys(localeBundle))Object.freeze(localeBundle[namespace]);
+        Object.freeze(localeBundle);
+    }
+    return Object.freeze(bundle);
+}
+export { mergeTranslations };

package/dist/react/i18n-context.d.ts

@@ -0,0 +1,29 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+import type { Formatter } from '../formatter.js';
+import type { LocaleCode, LocaleDefinition, TranslationBundle } from '../types.js';
+export interface I18nContextValue {
+    formatter: Formatter;
+    bundle: TranslationBundle;
+    activeLocale: LocaleCode;
+    defaultLocale: LocaleCode;
+    /**
+     * Permitted locale set with native names. `<LanguageMenu>` renders
+     * one row per entry; the resolver in the root package just needs the
+     * codes (`localeDefinitions.map(d => d.code)`).
+     */
+    localeDefinitions: readonly LocaleDefinition[];
+    /**
+     * Imperative locale change. Provided by the host adapter — typically
+     * calls a server fn that updates the user's stored preference and
+     * the cookie, then re-renders the provider with the new locale.
+     * When undefined the language switcher renders disabled.
+     */
+    setLocale?: (next: LocaleCode) => void | Promise<void>;
+}
+export declare const I18nContext: import("react").Context<I18nContextValue | null>;

package/dist/react/i18n-context.js

@@ -0,0 +1,3 @@
+import { createContext } from "react";
+const I18nContext = createContext(null);
+export { I18nContext };

package/dist/react/i18n-provider.d.ts

@@ -0,0 +1,31 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+import { type ReactNode } from 'react';
+import { type MissingTranslationEvent } from '../formatter.js';
+import type { LocaleCode, LocaleDefinition, TranslationBundle } from '../types.js';
+export interface I18nProviderProps {
+    bundle: TranslationBundle;
+    activeLocale: LocaleCode;
+    defaultLocale: LocaleCode;
+    /** Permitted locale set with native names — drives `<LanguageMenu>`. */
+    localeDefinitions: readonly LocaleDefinition[];
+    /**
+     * Optional handler the host wires to its language-switcher server fn.
+     * Receives the new locale; expected to persist it and trigger a re-
+     * render with the updated `activeLocale` prop.
+     */
+    setLocale?: (next: LocaleCode) => void | Promise<void>;
+    /**
+     * Override the dev-time `console.warn` on missing translations.
+     * Defaults to a one-shot warn per `(locale, namespace, key)` triple
+     * when `process.env.NODE_ENV !== 'production'`.
+     */
+    onMissing?: (event: MissingTranslationEvent) => void;
+    children: ReactNode;
+}
+export declare function I18nProvider({ bundle, activeLocale, defaultLocale, localeDefinitions, setLocale, onMissing, children, }: I18nProviderProps): import("react").JSX.Element;

package/dist/react/i18n-provider.js

@@ -0,0 +1,38 @@
+import { jsx } from "react/jsx-runtime";
+import { useMemo } from "react";
+import { createFormatter } from "../formatter.js";
+import { I18nContext } from "./i18n-context.js";
+function I18nProvider({ bundle, activeLocale, defaultLocale, localeDefinitions, setLocale, onMissing, children }) {
+    const value = useMemo(()=>{
+        const onMissingResolved = onMissing ?? ('production' !== process.env.NODE_ENV ? defaultMissingWarner : void 0);
+        return {
+            formatter: createFormatter({
+                bundle,
+                activeLocale,
+                defaultLocale,
+                onMissing: onMissingResolved
+            }),
+            bundle,
+            activeLocale,
+            defaultLocale,
+            localeDefinitions,
+            setLocale
+        };
+    }, [
+        bundle,
+        activeLocale,
+        defaultLocale,
+        localeDefinitions,
+        setLocale,
+        onMissing
+    ]);
+    return /*#__PURE__*/ jsx(I18nContext.Provider, {
+        value: value,
+        children: children
+    });
+}
+function defaultMissingWarner(event) {
+    if (event.fellThroughToKey) console.warn(`[@byline/i18n] missing translation: ${event.activeLocale}.${event.namespace}.${event.key} — also missing in default locale; rendered raw key.`);
+    else console.warn(`[@byline/i18n] missing translation: ${event.activeLocale}.${event.namespace}.${event.key} — using default-locale fallback.`);
+}
+export { I18nProvider };

package/dist/react/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+/**
+ * Single React-side barrel. Provider + hook + language switcher all
+ * share one React Context identity by virtue of living behind this
+ * single subpath export — splitting across more subpaths would risk
+ * Vite `optimizeDeps` pre-bundling each subpath into a private copy of
+ * the Context module, breaking provider/consumer identity (see the
+ * `@byline/ui/src/react.ts` comment for the same trap in another
+ * package).
+ */
+export { I18nContext } from './i18n-context.js';
+export { I18nProvider } from './i18n-provider.js';
+export { LanguageMenu } from './language-menu.js';
+export { useTranslation } from './use-translation.js';
+export type { I18nContextValue } from './i18n-context.js';
+export type { I18nProviderProps } from './i18n-provider.js';
+export type { LanguageMenuProps } from './language-menu.js';
+export type { UseTranslationReturn } from './use-translation.js';

package/dist/react/index.js

@@ -0,0 +1,4 @@
+export { I18nContext } from "./i18n-context.js";
+export { I18nProvider } from "./i18n-provider.js";
+export { LanguageMenu } from "./language-menu.js";
+export { useTranslation } from "./use-translation.js";

package/dist/react/language-menu.d.ts

@@ -0,0 +1,15 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+export interface LanguageMenuProps {
+    className?: string;
+    /** Tailwind / CSS class applied to the icon + label colour. */
+    color?: string;
+    /** Render the menu disabled (loading, no `setLocale`, etc.). */
+    disabled?: boolean;
+}
+export declare function LanguageMenu({ className, color, disabled }: LanguageMenuProps): import("react").JSX.Element | null;

package/dist/react/language-menu.js

@@ -0,0 +1,78 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useContext, useState } from "react";
+import { CheckIcon, Dropdown, GlobeIcon } from "@byline/ui/react";
+import classnames from "classnames";
+import { I18nContext } from "./i18n-context.js";
+function LanguageMenu({ className, color, disabled }) {
+    const context = useContext(I18nContext);
+    const [busy, setBusy] = useState(false);
+    if (null == context) throw new Error('[@byline/i18n] <LanguageMenu> must be used inside <I18nProvider>. Mount the provider in your admin shell root.');
+    const { activeLocale, localeDefinitions, setLocale } = context;
+    if (localeDefinitions.length < 2) return null;
+    const active = localeDefinitions.find((d)=>d.code === activeLocale);
+    const isDisabled = disabled || null == setLocale || busy;
+    const handleSelect = async (next)=>{
+        if (next === activeLocale || null == setLocale || busy) return;
+        setBusy(true);
+        try {
+            await setLocale(next);
+        } finally{
+            setBusy(false);
+        }
+    };
+    return /*#__PURE__*/ jsx("div", {
+        className: className,
+        children: /*#__PURE__*/ jsxs(Dropdown.Root, {
+            modal: false,
+            children: [
+                /*#__PURE__*/ jsxs(Dropdown.Trigger, {
+                    render: /*#__PURE__*/ jsx("button", {
+                        type: "button",
+                        "aria-label": active?.nativeName ?? activeLocale,
+                        disabled: isDisabled,
+                        className: "component--byline-language-menu rounded flex items-center justify-between gap-1 outline-none disabled:opacity-50"
+                    }),
+                    children: [
+                        /*#__PURE__*/ jsx(GlobeIcon, {
+                            svgClassName: color
+                        }),
+                        /*#__PURE__*/ jsx("span", {
+                            className: classnames(color, 'hidden sm:inline mr-[4px]'),
+                            children: active?.nativeName ?? activeLocale
+                        })
+                    ]
+                }),
+                /*#__PURE__*/ jsx(Dropdown.Portal, {
+                    children: /*#__PURE__*/ jsx(Dropdown.Content, {
+                        align: "center",
+                        sideOffset: 10,
+                        className: classnames('z-40 rounded radix-side-bottom:animate-slide-down radix-side-top:animate-slide-up', 'w-32 px-1.5 py-1 shadow-md', 'bg-white dark:bg-canvas-800 border dark:border-canvas-700 shadow'),
+                        children: localeDefinitions.map((def)=>{
+                            const isActive = def.code === activeLocale;
+                            return /*#__PURE__*/ jsx(Dropdown.Item, {
+                                onClick: ()=>handleSelect(def.code),
+                                children: /*#__PURE__*/ jsxs("div", {
+                                    className: "flex",
+                                    children: [
+                                        /*#__PURE__*/ jsx("span", {
+                                            className: "inline-block w-[22px]",
+                                            children: isActive && /*#__PURE__*/ jsx(CheckIcon, {
+                                                width: "18px",
+                                                height: "18px"
+                                            })
+                                        }),
+                                        /*#__PURE__*/ jsx("span", {
+                                            className: "text-left inline-block w-full flex-1 self-start text-black dark:text-gray-300",
+                                            children: def.nativeName
+                                        })
+                                    ]
+                                })
+                            }, def.code);
+                        })
+                    })
+                })
+            ]
+        })
+    });
+}
+export { LanguageMenu };

package/dist/react/use-translation.d.ts

@@ -0,0 +1,24 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+import type { LocaleCode, MessageKey, Namespace, TranslationValues } from '../types.js';
+export interface UseTranslationReturn {
+    /** Format `namespace.key` against the provider's active locale. */
+    t: (key: MessageKey, values?: TranslationValues) => string;
+    /** The active locale — useful for `<html lang>` and direction logic. */
+    locale: LocaleCode;
+}
+/**
+ * Bind to a single namespace for the lifetime of the component. The
+ * returned `t` resolves keys against the active locale with default-
+ * locale fallback baked in (see `createFormatter` for the cascade).
+ *
+ * Throws if called outside `<I18nProvider>` — the loud failure is
+ * deliberate. A silently-broken admin shell with raw keys on screen
+ * is harder to notice than a thrown error during development.
+ */
+export declare function useTranslation(namespace: Namespace): UseTranslationReturn;

package/dist/react/use-translation.js

@@ -0,0 +1,16 @@
+import { useContext, useMemo } from "react";
+import { I18nContext } from "./i18n-context.js";
+function useTranslation(namespace) {
+    const context = useContext(I18nContext);
+    if (null == context) throw new Error('[@byline/i18n] useTranslation must be used inside <I18nProvider>. Mount the provider in your admin shell root.');
+    const { formatter, activeLocale } = context;
+    return useMemo(()=>({
+            t: (key, values)=>formatter.t(namespace, key, values),
+            locale: activeLocale
+        }), [
+        formatter,
+        namespace,
+        activeLocale
+    ]);
+}
+export { useTranslation };

package/dist/resolve.d.ts

@@ -0,0 +1,21 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+import type { LocaleCode } from './types.js';
+export interface ResolveInterfaceLocaleOptions {
+    /** Permitted locale set — from `i18n.interface.locales`. */
+    locales: readonly LocaleCode[];
+    /** Last-resort fallback — from `i18n.interface.defaultLocale`. */
+    defaultLocale: LocaleCode;
+    /** `admin_users.preferred_locale` for the authenticated request, if any. */
+    preferred?: LocaleCode | null;
+    /** Value of the `byline_admin_lng` cookie. */
+    cookie?: string | null;
+    /** Raw `Accept-Language` request header. */
+    acceptLanguage?: string | null;
+}
+export declare function resolveInterfaceLocale(options: ResolveInterfaceLocaleOptions): LocaleCode;

package/dist/resolve.js

@@ -0,0 +1,28 @@
+import { match } from "@formatjs/intl-localematcher";
+import negotiator_0 from "negotiator";
+function resolveInterfaceLocale(options) {
+    const { locales, defaultLocale, preferred, cookie, acceptLanguage } = options;
+    if (null != preferred && locales.includes(preferred)) return preferred;
+    if (null != cookie && locales.includes(cookie)) return cookie;
+    if (null != acceptLanguage && acceptLanguage.length > 0) {
+        const matched = negotiateAcceptLanguage(acceptLanguage, locales, defaultLocale);
+        if (null != matched) return matched;
+    }
+    return defaultLocale;
+}
+function negotiateAcceptLanguage(header, locales, defaultLocale) {
+    try {
+        const negotiator = new negotiator_0({
+            headers: {
+                'accept-language': header
+            }
+        });
+        const requested = negotiator.languages();
+        if (0 === requested.length) return null;
+        const matched = match(requested, locales, defaultLocale);
+        return locales.includes(matched) ? matched : null;
+    } catch  {
+        return null;
+    }
+}
+export { resolveInterfaceLocale };