mi-intl 0.6.3

package/types/i18n.d.ts

@@ -0,0 +1,120 @@
+export function reduceSupportedLangs(lng: string, supportedLngs: string[], browserLngs?: string[]): string[];
+export class I18n {
+    /**
+     * @param {I18nOptions} options
+     */
+    constructor(options: I18nOptions);
+    options: {
+        version: string;
+        ns: string[];
+        localesPath: string;
+        useLabel: boolean;
+        log?: {
+            debug?: Function;
+            error?: Function;
+        };
+        cookie: {
+            name?: string;
+            path?: string;
+            sameSite?: string;
+            maxAge?: number;
+            domain?: string;
+            expires?: string | Date;
+            secure?: boolean;
+        } | {
+            name: string;
+            path: string;
+        };
+    };
+    /** default namespace */
+    defaultNs: string;
+    /** fallback language */
+    fallbackLng: string;
+    /** selected language for translation, must be part of supportedLngs */
+    lng: string;
+    /** supported languages with translations */
+    supportedLngs: string[];
+    /** user assigned language with variant */
+    userLng: string | undefined;
+    /** available resources (if any) */
+    resources: {
+        [lng: string]: {
+            [ns: string]: {
+                [label: string]: string;
+            };
+        };
+    };
+    /**
+     * translation function
+     * @param {string} label
+     * @param {object} values
+     * @returns {string}
+     */
+    t(label: string, values?: object): string;
+    /**
+     * get all supported languages
+     * @returns {string[]}
+     */
+    getLanguages(): string[];
+    /**
+     * get the user selected (cookie) or browser language
+     * @returns {string}
+     */
+    getUserLanguage(): string;
+    /**
+     * reset user selected language by deleting language cookie
+     */
+    resetUserLanguage(): void;
+    /**
+     * @protected
+     * @returns {[cookieLng:string, browserLng:string]}
+     */
+    protected _getSettings(): [cookieLng: string, browserLng: string];
+    /**
+     * @protected
+     * set language cookie using cookie options
+     */
+    protected _setCookie(): void;
+    /**
+     * @protected
+     * @param {string} [lng]
+     * @returns {string[]}
+     */
+    protected _setLanguage(lng?: string): string[];
+    /**
+     * changes the language
+     * @param {string} [lng]
+     * @return {Promise<void>}
+     */
+    changeLanguage(lng?: string): Promise<void>;
+    /**
+     * @param {string} ns
+     * @return {Promise<void>}
+     */
+    changeNamespace(ns: string): Promise<void>;
+    /**
+     * @param {string[]} lngs
+     * @param {string[]} [ns]
+     * @return {Promise<(LoadResponse|undefined|void)[]>}
+     */
+    loadLanguages(lngs?: string[], ns?: string[]): Promise<(LoadResponse | undefined | void)[]>;
+    /**
+     * @protected
+     * @param {{
+     *  lng: string
+     *  ns: string
+     * }} param0
+     * @return {Promise<undefined|LoadResponse>}
+     */
+    protected _load({ lng, ns }: {
+        lng: string;
+        ns: string;
+    }): Promise<undefined | LoadResponse>;
+}
+export type I18nOptions = import("./types.js").I18nOptions;
+export type LoadResponse = {
+    ok: boolean;
+    status: number;
+    lng: string;
+    ns: string;
+};

package/types/index.d.ts

@@ -0,0 +1,7 @@
+export { I18n } from "./i18n.js";
+export { MiIntlMessage } from "./intl-message.js";
+export { IntlConsumer } from "./intl-consumer.js";
+export type I18nOptions = import("./types.js").I18nOptions;
+export type IntlContext = import("./types.js").IntlContext;
+export { cookieParse, cookieSerialize } from "./cookie.js";
+export { MiIntlProvider, INTL_CONTEXT } from "./intl-provider.js";

package/types/intl-consumer.d.ts

@@ -0,0 +1,13 @@
+/** @typedef {import('mi-element').MiElement} MiElement */
+/**
+ * ContextConsumer subscribing to MiIntlProvider context
+ */
+export class IntlConsumer extends ContextConsumer<any> {
+    /**
+     * @param {MiElement} miElement
+     * @param {boolean} [subscribe=true]
+     */
+    constructor(miElement: MiElement, subscribe?: boolean);
+}
+export type MiElement = import("mi-element").MiElement;
+import { ContextConsumer } from 'mi-element';

package/types/intl-message.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Connects IntlConsumer to MiIntlProvider context
+ * @example
+ * ```js
+ * import { define } from 'mi-element'
+ * import { MiIntlMessage } from 'mi-intl'
+ *
+ * define('mi-message',
+ *   class extends MiIntlMessage {
+ *     static get attributes() {
+ *       return { label: String, value: String }
+ *     }
+ *     update() {
+ *       this.renderRoot.textContent = this.t(this.label, this.value)
+ *     }
+ *   }
+ * )
+ * ```
+ */
+export class MiIntlMessage extends MiElement {
+    t(label: any, value: any): any;
+    #private;
+}
+import { MiElement } from 'mi-element';

package/types/intl-provider.d.ts

@@ -0,0 +1,50 @@
+/** @typedef {import('./types.js').I18nOptions} I18nOptions */
+/** @typedef {import('./types.js').IntlContext} IntlContext */
+export const INTL_CONTEXT: "mi-intl";
+export class MiIntlProvider extends MiElement {
+    static get attributes(): {
+        /** translation version */
+        version: string;
+        /** pre-selected language */
+        lng: StringConstructor;
+        /** default namespace */
+        defaultNs: string;
+        /** used namespaces, comma separated */
+        ns: string;
+        /** supported languages, comma separated */
+        supportedLngs: string;
+        /** path for loading resources */
+        localesPath: string;
+        /** use translation label */
+        useLabel: BooleanConstructor;
+        /** debugging support */
+        debug: boolean;
+    };
+    static get properties(): {
+        loading: boolean;
+    };
+    static template: string;
+    /**
+     * @param {I18nOptions} options
+     */
+    set options(options: I18nOptions);
+    i18n: I18n | undefined;
+    /**
+     * @protected
+     * @returns {IntlContext}
+     */
+    protected _contextValue(): IntlContext;
+    /**
+     * @param {string} [lng]
+     * @returns {Promise<void>}
+     */
+    changeLanguage(lng?: string): Promise<void>;
+    loading: boolean | undefined;
+    provider: ContextProvider<import("./types.js").IntlContext> | undefined;
+    update(): void;
+}
+export type I18nOptions = import("./types.js").I18nOptions;
+export type IntlContext = import("./types.js").IntlContext;
+import { MiElement } from 'mi-element';
+import { I18n } from './i18n.js';
+import { ContextProvider } from 'mi-element';

package/types/types.d.ts

@@ -0,0 +1,90 @@
+export interface I18nOptions {
+    /**
+     * list of supported languages with translations
+     */
+    supportedLngs: string[];
+    /**
+     * version info
+     */
+    version?: string;
+    /**
+     * selected language
+     */
+    lng?: string;
+    /**
+     * fallback language; Must be part of supportedLngs;
+     * Default is first supported language from `supportedLngs`
+     */
+    fallbackLng?: string;
+    /**
+     * supported namespaces; all required namespaces for required translations
+     * must be named to load all namespaces when changing languages
+     * @default ['translations']
+     */
+    ns?: string[];
+    /**
+     * default namespace
+     * @default 'translations'
+     */
+    defaultNs?: string;
+    /**
+     * path for resources e.g. '/locales/{lng}/{ns}.json'
+     * @default '/locales/{lng}/{ns}.json?v={version}'
+     */
+    localesPath?: string;
+    /**
+     * use t(label) for translation
+     * @default false
+     */
+    useLabel?: boolean;
+    /**
+     * debugging support
+     * @default false
+     */
+    debug?: boolean;
+    /**
+     * logger e.g. `{ debug: console.debug, error: console.error }`
+     */
+    log?: {
+        debug?: Function;
+        error?: Function;
+    };
+    /**
+     * resources object
+     */
+    resources?: {
+        [lng: string]: {
+            [ns: string]: {
+                [label: string]: string;
+            };
+        };
+    };
+    /**
+     * language cookie
+     */
+    cookie?: {
+        /** @default "lc" */
+        name?: string;
+        /** @default "/" */
+        path?: string;
+        /** @default "Strict" */
+        sameSite?: string;
+        /** */
+        maxAge?: number;
+        domain?: string;
+        expires?: string | Date;
+        secure?: boolean;
+    };
+}
+export interface IntlContext {
+    /** translation function */
+    t: (label: string, values?: any) => string;
+    /** current selected language */
+    lng: string;
+    /** list all available translation languages */
+    getLanguages: () => string[];
+    /** change the current language */
+    changeLanguage: (lng: string) => Promise<void>;
+    /** language is loading */
+    loading: boolean;
+}