svelte-lang/dist/i18n/index.js

svelte-lang is an i18n library for Svelte that simplifies multilingual support. It offers a straightforward API for managing translations, supports parameterized strings, and integrates with Svelte stores for reactive language handling. Features include a

import { persisted } from 'svelte-persisted-store';
import { writable, derived, get } from 'svelte/store';
export function p(name) {
    return { type: 'param', name };
}
export function t(strings, ...values) {
    return { strings, values };
}
const inlineParameterRegex = /\(({.*})\)$/;
export function setupI18n(translations, defaultLanguage, options) {
    const language = options?.languagePersisted
        ? persisted('svelte-lang', defaultLanguage)
        : writable(defaultLanguage);
    const supportedLanguages = Object.keys(translations);
    // Derived translation function
    const tFunction = derived(language, ($language) => {
        return function (key, params) {
            const currentTranslations = translations[$language];
            const inlineParametersMatcher = inlineParameterRegex.exec(key);
            if (inlineParametersMatcher && inlineParametersMatcher.length === 2) {
                try {
                    console.debug(`[svelte-lang] Found inline parameter: ${key}`);
                    console.debug(`[svelte-lang] Inline parameter: ${inlineParametersMatcher[1]}`);
                    const inlineParameters = JSON.parse(inlineParametersMatcher[1]);
                    key = key.replace(inlineParameterRegex, '');
                    params = { ...inlineParameters, params };
                }
                catch (error) {
                    console.error(`[svelte-lang] Failed to parse inline parameter: ${key}`);
                }
            }
            const translation = currentTranslations[key];
            if (!translation) {
                console.warn(`[svelte-lang] Missing translation for key "${String(key)}" in language "${String($language)}"`);
                return `{${String(key)}}`;
            }
            const { strings, values } = translation;
            let result = '';
            for (let i = 0; i < strings.length; i++) {
                result += strings[i];
                if (i < values.length) {
                    const value = values[i];
                    if (value.type === 'param') {
                        const paramValue = params?.[value.name];
                        if (paramValue !== undefined) {
                            result += paramValue;
                        }
                        else {
                            result += `$${value.name}`;
                            console.warn(`[svelte-lang] Missing parameter "${value.name}" for key "${String(key)}"`);
                        }
                    }
                    else {
                        result += value;
                    }
                }
            }
            return result;
        };
    });
    const tUnsafe = derived(tFunction, (tFunction) => {
        return (key, params) => tFunction(key, params);
    });
    const initLanguage = (lang) => {
        language.set(lang);
    };
    return { t: tFunction, language, supportedLanguages, tUnsafe, initLanguage };
}