@modernice/vue-i18n-modules/dist/extension.d.ts

"Message modules" extension for vue-i18n

import { Composer } from 'vue-i18n';
import { ConcatKeys, Tail, TranslateParams } from './internal';
import { ModuleLoader, ModuleName, ModuleT } from './types';
/**
 * A vue-i18n extension that provides namespaced lazy message loading.
 */
export type Extension = ReturnType<typeof createExtension>;
/**
 * TranslateFn is a function that takes a module name, a key, and optional
 * arguments, and returns a translated message as a string. It uses vue-i18n's
 * `t` function to perform the translation.
 */
export type TranslateFn = <Name extends ModuleName>(module: Name, key: ConcatKeys<ModuleT<Name>>, ...args: Partial<Tail<TranslateParams<Composer>>>) => string;
/**
 * Options for creating the {@link Extension | extension}.
 */
export interface Options {
    /**
     * The vue-i18n {@link Composer} instance, as returned by {@link useI18n}.
     */
    i18n: Composer;
    /**
     * Module loader to use.
     */
    loader: ModuleLoader;
    /**
     * Namespace to use when adding messages to the vue-i18n instance.
     *
     * @default '__modules'
     */
    namespace?: string;
    /**
     * Enable debugging logs.
     */
    debug?: boolean;
}
/**
 * Creates the {@link Extension | extension} for namespaced messages.
 */
export declare function createExtension(options: Options): {
    i18n: import('vue').ComputedRef<Composer<{}, {}, {}, string, never, string>>;
    namespace: import('vue').ComputedRef<string>;
    loadModule: (name: ModuleName, opts?: {
        /**
         * If provided, the module is loaded for all given locales.
         * Otherwise, the module is loaded for the currently active locale.
         */
        locales?: string[];
    }) => Promise<void>;
    moduleLoaded: (name: ModuleName, locale?: string) => boolean;
    moduleNamespace: <Name extends ModuleName, Key extends ConcatKeys<ModuleT<Name>>>(module: Name, key: Key) => `${string}.${Name}.${Key}`;
    localize: (locale: string | string[], options?: {
        /**
         * The source locale. Only messages that were loaded for this locale will
         * be loaded for the provided target locale(s).
         *
         * If not provided, the currently active locale is used.
         */
        from?: string;
    }) => Promise<void>;
    translate: TranslateFn;
    t: TranslateFn;
    debugLog: (message: string) => void;
};