@tramvai/module-i18n 6.79.10

package/lib/shared/service.es.js

@@ -0,0 +1,164 @@
+import { parse } from '@tinkoff/url';
+import { RedirectFoundError, makeErrorSilent } from '@tinkoff/errors';
+import { I18nStore } from './store.es.js';
+
+class I18nServiceImpl {
+    store;
+    config;
+    cookieManager;
+    router;
+    requestManager;
+    log;
+    constructor(deps) {
+        this.store = deps.store;
+        this.config = deps.config;
+        this.cookieManager = deps.cookieManager;
+        this.router = deps.router;
+        this.requestManager = deps.requestManager;
+        this.log = deps.logger('i18n');
+    }
+    getLanguage() {
+        const state = this.store.getState(I18nStore);
+        return state.language;
+    }
+    getAvailableLanguages() {
+        const state = this.store.getState(I18nStore);
+        return state.availableLanguages;
+    }
+    // eslint-disable-next-line max-statements
+    async switchLanguage(language) {
+        const availableLanguages = this.getAvailableLanguages();
+        if (!availableLanguages.includes(language)) {
+            // TODO: is throwing an error is a best solution?
+            throw new Error(`Language "${language}" is not available. Available languages: ${availableLanguages.join(', ')}`);
+        }
+        this.log.info(`Switch language to "${language}"`);
+        const { cookieName, routingStrategy, updateStrategy } = this.config;
+        this.cookieManager.set({
+            name: cookieName,
+            value: language,
+            // TODO valid params!
+        });
+        const currentUrl = this.router.getCurrentUrl() ?? this.requestManager.getUrl();
+        const parsedUrl = typeof currentUrl === 'string' ? parse(currentUrl) : currentUrl;
+        const currentLanguage = this.getLanguage();
+        const languageFromUrl = this.getLanguageFromUrl(parsedUrl);
+        const hasLanguagePrefix = typeof languageFromUrl === 'string';
+        const targetUrl = hasLanguagePrefix
+            ? this.addLanguageToUrl(this.removeLanguageFromUrl(parsedUrl), language)
+            : this.addLanguageToUrl(parsedUrl, language);
+        const redirectError = new RedirectFoundError({
+            nextUrl: `${targetUrl.pathname}${targetUrl.search}${targetUrl.hash}`,
+            httpStatus: 301,
+        });
+        makeErrorSilent(redirectError);
+        /**
+         * 'none' - no action needed, language is already set and url is correct
+         * 'reload' - url is correct, reload the page to apply language change
+         * 'navigate' - need to update url, navigate to the new URL with/without language prefix
+         */
+        let action = 'none';
+        if (hasLanguagePrefix && languageFromUrl !== language) {
+            action = 'navigate';
+        }
+        else if (currentLanguage !== language) {
+            if (routingStrategy === 'no_prefix') {
+                action = 'reload';
+            }
+            else {
+                action = 'navigate';
+            }
+        }
+        switch (action) {
+            case 'none': {
+                return;
+            }
+            case 'reload': {
+                if (updateStrategy === 'reload') {
+                    if (typeof window !== 'undefined') {
+                        window.location.reload();
+                        return new Promise(() => { });
+                    }
+                    throw redirectError;
+                }
+                else {
+                    if (typeof window !== 'undefined') {
+                        return this.router.navigate({
+                            url: targetUrl.href,
+                            replace: true,
+                        });
+                    }
+                    throw redirectError;
+                }
+            }
+            case 'navigate': {
+                if (updateStrategy === 'reload') {
+                    if (typeof window !== 'undefined') {
+                        window.location.href = targetUrl.href;
+                        return new Promise(() => { });
+                    }
+                    throw redirectError;
+                }
+                else {
+                    if (typeof window !== 'undefined') {
+                        return this.router.navigate({
+                            url: targetUrl.href,
+                        });
+                    }
+                    throw redirectError;
+                }
+            }
+        }
+    }
+    getLanguageFromUrl(url) {
+        const parsedUrl = typeof url === 'string' ? parse(url) : url;
+        const { routingStrategy } = this.config;
+        const availableLanguages = this.getAvailableLanguages();
+        const [firstSegment] = parsedUrl.pathname.split('/').filter(Boolean);
+        const isLanguagePrefix = availableLanguages.includes(firstSegment);
+        switch (routingStrategy) {
+            case 'no_prefix':
+                // No prefix strategy, language is not in URL
+                return null;
+            case 'prefix':
+                // Prefix strategy, first segment should be always a language
+                return isLanguagePrefix ? firstSegment : null;
+            case 'prefix_and_default':
+                // Prefix and default strategy, first segment can be a language, or default language if it not matches
+                return isLanguagePrefix ? firstSegment : this.config.defaultLanguage;
+            case 'prefix_except_default':
+                // Prefix except default strategy, first segment can be a language, but can't match default language
+                if (isLanguagePrefix) {
+                    return firstSegment === this.config.defaultLanguage ? null : firstSegment;
+                }
+                return this.config.defaultLanguage;
+        }
+    }
+    removeLanguageFromUrl(url) {
+        const parsedUrl = typeof url === 'string' ? parse(url) : url;
+        const languageFromUrl = this.getLanguageFromUrl(parsedUrl);
+        const hasLanguagePrefix = typeof languageFromUrl === 'string';
+        if (!hasLanguagePrefix) {
+            return parsedUrl;
+        }
+        return parse(`${parsedUrl.origin}${parsedUrl.pathname.replace(`/${languageFromUrl}`, '')}${parsedUrl.search}${parsedUrl.hash}`);
+    }
+    addLanguageToUrl(url, lang) {
+        const { routingStrategy } = this.config;
+        const parsedUrl = typeof url === 'string' ? parse(url) : url;
+        const languageFromUrl = this.getLanguageFromUrl(parsedUrl);
+        const hasLanguagePrefix = typeof languageFromUrl === 'string';
+        // If the URL already has a language prefix that matches the requested language, return it as is
+        // or if routing strategy is 'no_prefix', return it as is
+        // or 'prefix_except_default' or 'prefix_and_default' and the language is default, return it as is
+        if ((hasLanguagePrefix && languageFromUrl === lang) ||
+            routingStrategy === 'no_prefix' ||
+            (routingStrategy === 'prefix_except_default' && lang === this.config.defaultLanguage) ||
+            (routingStrategy === 'prefix_and_default' && lang === this.config.defaultLanguage)) {
+            return parsedUrl;
+        }
+        return parse(`${parsedUrl.origin}/${lang}${parsedUrl.pathname}${parsedUrl.search}${parsedUrl.hash}`);
+    }
+}
+
+export { I18nServiceImpl };

package/lib/shared/service.js

@@ -0,0 +1,168 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var url = require('@tinkoff/url');
+var errors = require('@tinkoff/errors');
+var store = require('./store.js');
+
+class I18nServiceImpl {
+    store;
+    config;
+    cookieManager;
+    router;
+    requestManager;
+    log;
+    constructor(deps) {
+        this.store = deps.store;
+        this.config = deps.config;
+        this.cookieManager = deps.cookieManager;
+        this.router = deps.router;
+        this.requestManager = deps.requestManager;
+        this.log = deps.logger('i18n');
+    }
+    getLanguage() {
+        const state = this.store.getState(store.I18nStore);
+        return state.language;
+    }
+    getAvailableLanguages() {
+        const state = this.store.getState(store.I18nStore);
+        return state.availableLanguages;
+    }
+    // eslint-disable-next-line max-statements
+    async switchLanguage(language) {
+        const availableLanguages = this.getAvailableLanguages();
+        if (!availableLanguages.includes(language)) {
+            // TODO: is throwing an error is a best solution?
+            throw new Error(`Language "${language}" is not available. Available languages: ${availableLanguages.join(', ')}`);
+        }
+        this.log.info(`Switch language to "${language}"`);
+        const { cookieName, routingStrategy, updateStrategy } = this.config;
+        this.cookieManager.set({
+            name: cookieName,
+            value: language,
+            // TODO valid params!
+        });
+        const currentUrl = this.router.getCurrentUrl() ?? this.requestManager.getUrl();
+        const parsedUrl = typeof currentUrl === 'string' ? url.parse(currentUrl) : currentUrl;
+        const currentLanguage = this.getLanguage();
+        const languageFromUrl = this.getLanguageFromUrl(parsedUrl);
+        const hasLanguagePrefix = typeof languageFromUrl === 'string';
+        const targetUrl = hasLanguagePrefix
+            ? this.addLanguageToUrl(this.removeLanguageFromUrl(parsedUrl), language)
+            : this.addLanguageToUrl(parsedUrl, language);
+        const redirectError = new errors.RedirectFoundError({
+            nextUrl: `${targetUrl.pathname}${targetUrl.search}${targetUrl.hash}`,
+            httpStatus: 301,
+        });
+        errors.makeErrorSilent(redirectError);
+        /**
+         * 'none' - no action needed, language is already set and url is correct
+         * 'reload' - url is correct, reload the page to apply language change
+         * 'navigate' - need to update url, navigate to the new URL with/without language prefix
+         */
+        let action = 'none';
+        if (hasLanguagePrefix && languageFromUrl !== language) {
+            action = 'navigate';
+        }
+        else if (currentLanguage !== language) {
+            if (routingStrategy === 'no_prefix') {
+                action = 'reload';
+            }
+            else {
+                action = 'navigate';
+            }
+        }
+        switch (action) {
+            case 'none': {
+                return;
+            }
+            case 'reload': {
+                if (updateStrategy === 'reload') {
+                    if (typeof window !== 'undefined') {
+                        window.location.reload();
+                        return new Promise(() => { });
+                    }
+                    throw redirectError;
+                }
+                else {
+                    if (typeof window !== 'undefined') {
+                        return this.router.navigate({
+                            url: targetUrl.href,
+                            replace: true,
+                        });
+                    }
+                    throw redirectError;
+                }
+            }
+            case 'navigate': {
+                if (updateStrategy === 'reload') {
+                    if (typeof window !== 'undefined') {
+                        window.location.href = targetUrl.href;
+                        return new Promise(() => { });
+                    }
+                    throw redirectError;
+                }
+                else {
+                    if (typeof window !== 'undefined') {
+                        return this.router.navigate({
+                            url: targetUrl.href,
+                        });
+                    }
+                    throw redirectError;
+                }
+            }
+        }
+    }
+    getLanguageFromUrl(url$1) {
+        const parsedUrl = typeof url$1 === 'string' ? url.parse(url$1) : url$1;
+        const { routingStrategy } = this.config;
+        const availableLanguages = this.getAvailableLanguages();
+        const [firstSegment] = parsedUrl.pathname.split('/').filter(Boolean);
+        const isLanguagePrefix = availableLanguages.includes(firstSegment);
+        switch (routingStrategy) {
+            case 'no_prefix':
+                // No prefix strategy, language is not in URL
+                return null;
+            case 'prefix':
+                // Prefix strategy, first segment should be always a language
+                return isLanguagePrefix ? firstSegment : null;
+            case 'prefix_and_default':
+                // Prefix and default strategy, first segment can be a language, or default language if it not matches
+                return isLanguagePrefix ? firstSegment : this.config.defaultLanguage;
+            case 'prefix_except_default':
+                // Prefix except default strategy, first segment can be a language, but can't match default language
+                if (isLanguagePrefix) {
+                    return firstSegment === this.config.defaultLanguage ? null : firstSegment;
+                }
+                return this.config.defaultLanguage;
+        }
+    }
+    removeLanguageFromUrl(url$1) {
+        const parsedUrl = typeof url$1 === 'string' ? url.parse(url$1) : url$1;
+        const languageFromUrl = this.getLanguageFromUrl(parsedUrl);
+        const hasLanguagePrefix = typeof languageFromUrl === 'string';
+        if (!hasLanguagePrefix) {
+            return parsedUrl;
+        }
+        return url.parse(`${parsedUrl.origin}${parsedUrl.pathname.replace(`/${languageFromUrl}`, '')}${parsedUrl.search}${parsedUrl.hash}`);
+    }
+    addLanguageToUrl(url$1, lang) {
+        const { routingStrategy } = this.config;
+        const parsedUrl = typeof url$1 === 'string' ? url.parse(url$1) : url$1;
+        const languageFromUrl = this.getLanguageFromUrl(parsedUrl);
+        const hasLanguagePrefix = typeof languageFromUrl === 'string';
+        // If the URL already has a language prefix that matches the requested language, return it as is
+        // or if routing strategy is 'no_prefix', return it as is
+        // or 'prefix_except_default' or 'prefix_and_default' and the language is default, return it as is
+        if ((hasLanguagePrefix && languageFromUrl === lang) ||
+            routingStrategy === 'no_prefix' ||
+            (routingStrategy === 'prefix_except_default' && lang === this.config.defaultLanguage) ||
+            (routingStrategy === 'prefix_and_default' && lang === this.config.defaultLanguage)) {
+            return parsedUrl;
+        }
+        return url.parse(`${parsedUrl.origin}/${lang}${parsedUrl.pathname}${parsedUrl.search}${parsedUrl.hash}`);
+    }
+}
+
+exports.I18nServiceImpl = I18nServiceImpl;

package/lib/shared/store.browser.js

@@ -0,0 +1,20 @@
+import { createEvent, createReducer } from '@tramvai/state';
+
+const setLanguage = createEvent('i18n:setLanguage');
+const setAvailableLanguages = createEvent('i18n:setAvailableLanguages');
+const initialState = {
+    language: 'ru',
+    source: 'default',
+    availableLanguages: [],
+};
+const I18nStore = createReducer('tramvai_i18n', initialState)
+    .on(setLanguage, (state, language) => ({
+    ...state,
+    ...language,
+}))
+    .on(setAvailableLanguages, (state, availableLanguages) => ({
+    ...state,
+    availableLanguages,
+}));
+
+export { I18nStore, setAvailableLanguages, setLanguage };

package/lib/shared/store.d.ts

@@ -0,0 +1,22 @@
+import type { Language } from '../types';
+export interface I18nStoreState {
+    /**
+     * Current active language
+     */
+    language: Language;
+    /**
+     * Current language source
+     */
+    source: string;
+    /**
+     * Available languages whitelist
+     */
+    availableLanguages: Language[];
+}
+export declare const setLanguage: import("@tramvai/types-actions-state-context").EventCreator1<{
+    language: Language;
+    source: string;
+}>;
+export declare const setAvailableLanguages: import("@tramvai/types-actions-state-context").EventCreator1<string[]>;
+export declare const I18nStore: import("@tramvai/state").Reducer<I18nStoreState, "tramvai_i18n", never>;
+//# sourceMappingURL=store.d.ts.map

package/lib/shared/store.es.js

@@ -0,0 +1,20 @@
+import { createEvent, createReducer } from '@tramvai/state';
+
+const setLanguage = createEvent('i18n:setLanguage');
+const setAvailableLanguages = createEvent('i18n:setAvailableLanguages');
+const initialState = {
+    language: 'ru',
+    source: 'default',
+    availableLanguages: [],
+};
+const I18nStore = createReducer('tramvai_i18n', initialState)
+    .on(setLanguage, (state, language) => ({
+    ...state,
+    ...language,
+}))
+    .on(setAvailableLanguages, (state, availableLanguages) => ({
+    ...state,
+    availableLanguages,
+}));
+
+export { I18nStore, setAvailableLanguages, setLanguage };

package/lib/shared/store.js

@@ -0,0 +1,26 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var state = require('@tramvai/state');
+
+const setLanguage = state.createEvent('i18n:setLanguage');
+const setAvailableLanguages = state.createEvent('i18n:setAvailableLanguages');
+const initialState = {
+    language: 'ru',
+    source: 'default',
+    availableLanguages: [],
+};
+const I18nStore = state.createReducer('tramvai_i18n', initialState)
+    .on(setLanguage, (state, language) => ({
+    ...state,
+    ...language,
+}))
+    .on(setAvailableLanguages, (state, availableLanguages) => ({
+    ...state,
+    availableLanguages,
+}));
+
+exports.I18nStore = I18nStore;
+exports.setAvailableLanguages = setAvailableLanguages;
+exports.setLanguage = setLanguage;

package/lib/tokens.browser.js

@@ -0,0 +1,9 @@
+import { createToken, Scope } from '@tramvai/core';
+
+const I18N_CONFIGURATION_TOKEN = createToken('tramvai i18n configuration', { scope: Scope.SINGLETON });
+const I18N_TOKEN = createToken('tramvai i18n service');
+const I18N_RESOLVE_LANGUAGE_TOKEN = createToken('tramvai i18n resolve language');
+const I18N_RESOLVE_LANGUAGE_SOURCE_TOKEN = createToken('tramvai i18n resolve language source', { multi: true });
+const I18N_RESOLVE_AVAILABLE_LANGUAGES_TOKEN = createToken('tramvai i18n resolve available languages');
+
+export { I18N_CONFIGURATION_TOKEN, I18N_RESOLVE_AVAILABLE_LANGUAGES_TOKEN, I18N_RESOLVE_LANGUAGE_SOURCE_TOKEN, I18N_RESOLVE_LANGUAGE_TOKEN, I18N_TOKEN };

package/lib/tokens.d.ts

@@ -0,0 +1,24 @@
+import type { I18nConfiguration, I18nService, Language } from './types';
+export declare const I18N_CONFIGURATION_TOKEN: I18nConfiguration & {
+    __type?: "base token" | undefined;
+};
+export declare const I18N_TOKEN: I18nService & {
+    __type?: "base token" | undefined;
+};
+export declare const I18N_RESOLVE_LANGUAGE_TOKEN: (() => Promise<{
+    language: Language;
+    source: string;
+}>) & {
+    __type?: "base token" | undefined;
+};
+export declare const I18N_RESOLVE_LANGUAGE_SOURCE_TOKEN: {
+    name: string;
+    priority: number;
+    resolve: () => Promise<Language | undefined>;
+} & {
+    __type?: "multi token" | undefined;
+};
+export declare const I18N_RESOLVE_AVAILABLE_LANGUAGES_TOKEN: (() => Promise<Language[]>) & {
+    __type?: "base token" | undefined;
+};
+//# sourceMappingURL=tokens.d.ts.map

package/lib/tokens.es.js

@@ -0,0 +1,9 @@
+import { createToken, Scope } from '@tramvai/core';
+
+const I18N_CONFIGURATION_TOKEN = createToken('tramvai i18n configuration', { scope: Scope.SINGLETON });
+const I18N_TOKEN = createToken('tramvai i18n service');
+const I18N_RESOLVE_LANGUAGE_TOKEN = createToken('tramvai i18n resolve language');
+const I18N_RESOLVE_LANGUAGE_SOURCE_TOKEN = createToken('tramvai i18n resolve language source', { multi: true });
+const I18N_RESOLVE_AVAILABLE_LANGUAGES_TOKEN = createToken('tramvai i18n resolve available languages');
+
+export { I18N_CONFIGURATION_TOKEN, I18N_RESOLVE_AVAILABLE_LANGUAGES_TOKEN, I18N_RESOLVE_LANGUAGE_SOURCE_TOKEN, I18N_RESOLVE_LANGUAGE_TOKEN, I18N_TOKEN };

package/lib/tokens.js

@@ -0,0 +1,17 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var core = require('@tramvai/core');
+
+const I18N_CONFIGURATION_TOKEN = core.createToken('tramvai i18n configuration', { scope: core.Scope.SINGLETON });
+const I18N_TOKEN = core.createToken('tramvai i18n service');
+const I18N_RESOLVE_LANGUAGE_TOKEN = core.createToken('tramvai i18n resolve language');
+const I18N_RESOLVE_LANGUAGE_SOURCE_TOKEN = core.createToken('tramvai i18n resolve language source', { multi: true });
+const I18N_RESOLVE_AVAILABLE_LANGUAGES_TOKEN = core.createToken('tramvai i18n resolve available languages');
+
+exports.I18N_CONFIGURATION_TOKEN = I18N_CONFIGURATION_TOKEN;
+exports.I18N_RESOLVE_AVAILABLE_LANGUAGES_TOKEN = I18N_RESOLVE_AVAILABLE_LANGUAGES_TOKEN;
+exports.I18N_RESOLVE_LANGUAGE_SOURCE_TOKEN = I18N_RESOLVE_LANGUAGE_SOURCE_TOKEN;
+exports.I18N_RESOLVE_LANGUAGE_TOKEN = I18N_RESOLVE_LANGUAGE_TOKEN;
+exports.I18N_TOKEN = I18N_TOKEN;

package/lib/types.d.ts

@@ -0,0 +1,72 @@
+import { Url } from '@tinkoff/url';
+/**
+ * Language code in ISO 639-1 format (e.g., 'en', 'ru', 'zh')
+ */
+export type Language = string;
+/**
+ * Routing strategy for internationalization
+ * @reference https://i18n.nuxtjs.org/docs/guide#strategies
+ */
+export type I18nRoutingStrategy = 'no_prefix' | 'prefix_except_default' | 'prefix' | 'prefix_and_default';
+/**
+ * Strategy for updating the language in the application
+ */
+export type I18nLanguageUpdateStrategy = 'reload' | 'update';
+/**
+ * Configuration for the i18n module
+ */
+export interface I18nConfiguration {
+    /**
+     * Default language to use if language cannot be determined
+     * @default 'ru'
+     */
+    defaultLanguage: Language;
+    /**
+     * Routing strategy for handling language in URLs
+     * @default 'prefix_except_default'
+     */
+    routingStrategy?: I18nRoutingStrategy;
+    /**
+     * Routing strategy for handling language in URLs
+     * @default 'reload'
+     */
+    updateStrategy?: I18nLanguageUpdateStrategy;
+    /**
+     * Static list of available languages whitelist. If not provided, only defaultLanguage will be available.
+     * Can be overridden by providing I18N_AVAILABLE_LANGUAGES_TOKEN
+     */
+    availableLanguages?: Language[];
+    /**
+     * Cookie name for storing selected language
+     * @default 'tramvai_locale'
+     */
+    cookieName?: string;
+    /**
+     * Command line stage when language and available languages resolution should happen
+     * @default 'customerStart'
+     */
+    resolveLanguagesCommandLineStage?: 'customerStart' | 'resolveUserDeps';
+    /**
+     * Whether to enable automatic redirect when detected language doesn't match URL language
+     * Only applies to prefix-based strategies
+     * @default true
+     */
+    enableAutoRedirect?: boolean;
+}
+export interface I18nService {
+    getLanguage(): Language;
+    getAvailableLanguages(): Language[];
+    /**
+     * @description
+     * Returns the language from the `url` if available and match current i18n routing strategy, otherwise returns null.
+     */
+    getLanguageFromUrl(url: string | Url): Language | null;
+    /**
+     * @description
+     * Navigates to the URL with the specified language prefix and saves the new language to the store and locale cookie
+     */
+    switchLanguage(language: Language): Promise<void>;
+    removeLanguageFromUrl(url: string | Url): Url;
+    addLanguageToUrl(url: string | Url, language: Language): Url;
+}
+//# sourceMappingURL=types.d.ts.map

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@tramvai/module-i18n",
+  "version": "6.79.10",
+  "description": "Internationalization (i18n) module for Tramvai",
+  "main": "lib/server.js",
+  "module": "lib/server.es.js",
+  "browser": "lib/browser.js",
+  "typings": "lib/server.d.ts",
+  "files": [
+    "lib"
+  ],
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/tramvaijs/tramvai.git"
+  },
+  "scripts": {
+    "build": "tramvai-build --forPublish --preserveModules",
+    "watch": "tsc -w"
+  },
+  "dependencies": {
+    "@tinkoff/errors": "0.7.3",
+    "@tinkoff/url": "0.12.3",
+    "@tramvai/module-client-hints": "6.79.10",
+    "@tramvai/tokens-common": "6.79.10",
+    "@tramvai/tokens-cookie": "6.79.10",
+    "@tramvai/tokens-render": "6.79.10",
+    "@tramvai/tokens-router": "6.79.10"
+  },
+  "peerDependencies": {
+    "@tinkoff/dippy": "0.12.7",
+    "@tinkoff/logger": "^0.10.507",
+    "@tramvai/core": "6.79.10",
+    "@tramvai/react": "6.79.10",
+    "@tramvai/state": "6.79.10",
+    "tslib": "^2.4.0"
+  },
+  "license": "Apache-2.0"
+}