@tramvai/module-i18n 6.79.10

package/lib/shared/providers.js

@@ -0,0 +1,339 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var core = require('@tramvai/core');
+var tokensCommon = require('@tramvai/tokens-common');
+var tokensCookie = require('@tramvai/tokens-cookie');
+var tokensRouter = require('@tramvai/tokens-router');
+var moduleClientHints = require('@tramvai/module-client-hints');
+var tokensRender = require('@tramvai/tokens-render');
+var tokens = require('../tokens.js');
+var store = require('./store.js');
+var service = require('./service.js');
+var config = require('./config.js');
+var constants = require('./constants.js');
+
+const sharedProviders = [
+    core.provide({
+        provide: tokens.I18N_CONFIGURATION_TOKEN,
+        useValue: config.defaultConfiguration,
+    }),
+    core.provide({
+        provide: tokensCommon.COMBINE_REDUCERS,
+        useValue: [store.I18nStore],
+    }),
+    core.provide({
+        provide: tokens.I18N_RESOLVE_AVAILABLE_LANGUAGES_TOKEN,
+        useFactory: ({ config }) => {
+            // TODO: sync with state from server if SSR?
+            return async () => config.availableLanguages ?? [config.defaultLanguage];
+        },
+        deps: {
+            config: tokens.I18N_CONFIGURATION_TOKEN,
+        },
+    }),
+    core.provide({
+        provide: tokens.I18N_TOKEN,
+        useClass: service.I18nServiceImpl,
+        deps: {
+            store: tokensCommon.STORE_TOKEN,
+            config: tokens.I18N_CONFIGURATION_TOKEN,
+            cookieManager: tokensCookie.COOKIE_MANAGER_TOKEN,
+            router: tokensRouter.ROUTER_TOKEN,
+            requestManager: tokensCommon.REQUEST_MANAGER_TOKEN,
+            logger: tokensCommon.LOGGER_TOKEN,
+        },
+    }),
+    // Language from cookie has higher priority
+    core.provide({
+        provide: tokens.I18N_RESOLVE_LANGUAGE_SOURCE_TOKEN,
+        useFactory: ({ cookieManager, config }) => {
+            return {
+                name: 'cookie',
+                priority: constants.LanguageSourcePriority.Cookie,
+                resolve: async () => {
+                    const valueFromCookie = cookieManager.get(config.cookieName);
+                    if (typeof valueFromCookie === 'string') {
+                        return valueFromCookie;
+                    }
+                },
+            };
+        },
+        deps: {
+            cookieManager: tokensCookie.COOKIE_MANAGER_TOKEN,
+            config: tokens.I18N_CONFIGURATION_TOKEN,
+        },
+    }),
+    // Then, check user preferences (Accept-Language or navigator.languages)
+    core.provide({
+        provide: tokens.I18N_RESOLVE_LANGUAGE_SOURCE_TOKEN,
+        useFactory: ({ i18n, userLanguage }) => {
+            return {
+                name: 'accept-language',
+                priority: constants.LanguageSourcePriority.AcceptLanguage,
+                resolve: async () => {
+                    const availableLanguages = i18n.getAvailableLanguages();
+                    for (let i = 0; i < userLanguage.length; i++) {
+                        const lang = userLanguage[i];
+                        // Try exact match first, because userLanguage already sorted by priority
+                        if (availableLanguages.includes(lang)) {
+                            return lang;
+                        }
+                    }
+                },
+            };
+        },
+        deps: {
+            i18n: tokens.I18N_TOKEN,
+            userLanguage: moduleClientHints.USER_LANGUAGE_TOKEN,
+        },
+    }),
+    // Then, check language from URL (if prefix strategy is used, defined under the hood)
+    core.provide({
+        provide: tokens.I18N_RESOLVE_LANGUAGE_SOURCE_TOKEN,
+        useFactory: ({ router, requestManager, i18n }) => {
+            return {
+                name: 'url',
+                priority: constants.LanguageSourcePriority.Url,
+                resolve: async () => {
+                    const currentUrl = router.getCurrentUrl() ?? requestManager.getParsedUrl();
+                    const valueFromUrl = i18n.getLanguageFromUrl(currentUrl);
+                    const availableLanguages = i18n.getAvailableLanguages();
+                    if (typeof valueFromUrl === 'string' && availableLanguages.includes(valueFromUrl)) {
+                        return valueFromUrl;
+                    }
+                },
+            };
+        },
+        deps: {
+            router: tokensRouter.ROUTER_TOKEN,
+            requestManager: tokensCommon.REQUEST_MANAGER_TOKEN,
+            i18n: tokens.I18N_TOKEN,
+        },
+    }),
+    // As a last resort, return default language
+    core.provide({
+        provide: tokens.I18N_RESOLVE_LANGUAGE_SOURCE_TOKEN,
+        useFactory: ({ config }) => {
+            return {
+                name: 'default',
+                priority: constants.LanguageSourcePriority.Default,
+                resolve: async () => {
+                    return config.defaultLanguage;
+                },
+            };
+        },
+        deps: {
+            config: tokens.I18N_CONFIGURATION_TOKEN,
+        },
+    }),
+    core.provide({
+        provide: tokens.I18N_RESOLVE_LANGUAGE_TOKEN,
+        useFactory: ({ store: store$1, envManager, resolveSources }) => {
+            return async () => {
+                // At client-side, for SSR mode, we can resolve language from server state
+                if (typeof window !== 'undefined' &&
+                    envManager.get('TRAMVAI_FORCE_CLIENT_SIDE_RENDERING') !== 'true') {
+                    const { language, source } = store$1.getState(store.I18nStore);
+                    return { language, source };
+                }
+                const sources = [...resolveSources].sort(({ priority: a }, { priority: b }) => b - a);
+                for (const source of sources) {
+                    const language = await source.resolve();
+                    if (typeof language === 'string') {
+                        return {
+                            language: language,
+                            source: source.name,
+                        };
+                    }
+                }
+                // Impossible case, because we always have default source
+                throw Error('No language could be resolved from any sources');
+            };
+        },
+        deps: {
+            store: tokensCommon.STORE_TOKEN,
+            envManager: tokensCommon.ENV_MANAGER_TOKEN,
+            resolveSources: tokens.I18N_RESOLVE_LANGUAGE_SOURCE_TOKEN,
+        },
+    }),
+    core.provide({
+        provide: core.commandLineListTokens.init,
+        useFactory: ({ di, config, logger }) => {
+            const log = logger('i18n');
+            return function registerI18nResolveLanguagesCommands() {
+                di.register({
+                    provide: config.resolveLanguagesCommandLineStage
+                        ? core.commandLineListTokens[config.resolveLanguagesCommandLineStage]
+                        : core.commandLineListTokens.customerStart,
+                    useFactory: ({ store: store$1, resolveAvailableLanguages, resolveLanguage, cookieManager, router, requestManager, i18n, }) => {
+                        return async function resolveLanguagesFn() {
+                            // Resolve available languages first, so we can use them to validate current language
+                            const availableLanguages = await resolveAvailableLanguages();
+                            log.info(`Resolved available languages: ${availableLanguages}`);
+                            store$1.dispatch(store.setAvailableLanguages(availableLanguages));
+                            const language = await resolveLanguage();
+                            log.info(`Resolved language: "${language.language}" from "${language.source}" source`);
+                            store$1.dispatch(store.setLanguage(language));
+                            if (!cookieManager.get(config.cookieName)) {
+                                log.info(`${config.cookieName} cookie is not found, save resolved "${language.language}" language to cookie`);
+                                cookieManager.set({
+                                    name: config.cookieName,
+                                    value: language.language,
+                                    // TODO valid params!
+                                });
+                            }
+                            const currentUrl = router.getCurrentUrl() ?? requestManager.getParsedUrl();
+                            const languageFromUrl = i18n.getLanguageFromUrl(currentUrl);
+                            if (typeof languageFromUrl === 'string' && languageFromUrl !== language.language) {
+                                log.info(`Language "${languageFromUrl}" from current url "${currentUrl}" is not matched to resolved language "${language.language}"`);
+                                if (config.enableAutoRedirect) {
+                                    log.info(`Sync resolved language with url because 'config.enableAutoRedirect' is enabled`);
+                                    await i18n.switchLanguage(language.language);
+                                }
+                            }
+                        };
+                    },
+                    deps: {
+                        store: tokensCommon.STORE_TOKEN,
+                        resolveAvailableLanguages: tokens.I18N_RESOLVE_AVAILABLE_LANGUAGES_TOKEN,
+                        resolveLanguage: tokens.I18N_RESOLVE_LANGUAGE_TOKEN,
+                        cookieManager: tokensCookie.COOKIE_MANAGER_TOKEN,
+                        i18n: tokens.I18N_TOKEN,
+                        router: tokensRouter.ROUTER_TOKEN,
+                        requestManager: tokensCommon.REQUEST_MANAGER_TOKEN,
+                    },
+                });
+            };
+        },
+        deps: {
+            di: core.DI_TOKEN,
+            config: tokens.I18N_CONFIGURATION_TOKEN,
+            logger: tokensCommon.LOGGER_TOKEN,
+        },
+    }),
+    // Router guard to sync language prefix in URL with current language
+    core.provide({
+        provide: tokensRouter.ROUTER_GUARD_TOKEN,
+        useFactory: ({ logger, i18n, config, cookieManager }) => {
+            const log = logger('i18n');
+            return async ({ url, to }) => {
+                if (typeof window !== 'undefined' && url && to) {
+                    // i18n store will be updated after navigation, so we need to use cookie to get current language
+                    const language = cookieManager.get(config.cookieName);
+                    const languageFromUrl = i18n.getLanguageFromUrl(url.href);
+                    if (typeof languageFromUrl === 'string' && languageFromUrl !== language) {
+                        log.info(`Language "${languageFromUrl}" from target url "${url.pathname}" is not matched to current language "${language}"`);
+                        if (config.enableAutoRedirect) {
+                            log.info(`Force navigate to url with correct language prefix because 'config.enableAutoRedirect' is enabled`);
+                            const hasLanguagePrefix = typeof languageFromUrl === 'string';
+                            const targetUrl = hasLanguagePrefix
+                                ? i18n.addLanguageToUrl(i18n.removeLanguageFromUrl(url), language)
+                                : i18n.addLanguageToUrl(url, language);
+                            return `${targetUrl.pathname}${targetUrl.search}${targetUrl.hash}`;
+                        }
+                    }
+                }
+            };
+        },
+        deps: {
+            logger: tokensCommon.LOGGER_TOKEN,
+            i18n: tokens.I18N_TOKEN,
+            config: tokens.I18N_CONFIGURATION_TOKEN,
+            cookieManager: tokensCookie.COOKIE_MANAGER_TOKEN,
+        },
+    }),
+    core.provide({
+        provide: tokensRouter.ROUTER_PLUGIN,
+        useFactory: ({ config, di, store: store$1 }) => {
+            return {
+                apply(router) {
+                    if (config.updateStrategy === 'update') {
+                        router.syncHooks.get('change').tap('i18n', (_, { navigation }) => {
+                            // Resolve from DI to avoid circular dependency
+                            const i18n = di.get(tokens.I18N_TOKEN);
+                            if (navigation.to?.params?.__lang) {
+                                const currentLang = i18n.getLanguage();
+                                const nextLang = navigation.to.params.__lang;
+                                if (currentLang !== nextLang) {
+                                    store$1.dispatch(store.setLanguage({
+                                        language: navigation.to.params.__lang,
+                                        source: 'user-interaction',
+                                    }));
+                                }
+                            }
+                        });
+                    }
+                    router.internalHooks['router:resolve-route'].wrap((_, args, next) => {
+                        // Resolve from DI to avoid circular dependency
+                        const i18n = di.get(tokens.I18N_TOKEN);
+                        const [navigation, options] = args;
+                        if (navigation.url) {
+                            const languageFromUrl = i18n.getLanguageFromUrl(navigation.url);
+                            const hasLanguagePrefix = typeof languageFromUrl === 'string';
+                            if (hasLanguagePrefix) {
+                                // If language is in URL, we need to remove it to resolve the same route for all languages
+                                const urlWithoutPrefix = i18n.removeLanguageFromUrl(navigation.url);
+                                const route = next([{ ...navigation, url: urlWithoutPrefix }, options]);
+                                if (route) {
+                                    // If route is resolved, we need to save actual url and information about language for logs and debugging
+                                    route.actualPath = navigation.url.pathname;
+                                    route.params.__lang = languageFromUrl;
+                                }
+                                return route;
+                            }
+                            if (config.routingStrategy === 'prefix') {
+                                // If routing strategy is prefix, we need to send 404 for all urls without language prefix
+                                return;
+                            }
+                        }
+                        return next(args);
+                    });
+                },
+            };
+        },
+        deps: {
+            config: tokens.I18N_CONFIGURATION_TOKEN,
+            di: core.DI_TOKEN,
+            store: tokensCommon.STORE_TOKEN,
+        },
+    }),
+    core.provide({
+        provide: tokensRender.HTML_ATTRS,
+        useFactory: ({ i18n }) => {
+            return {
+                target: 'html',
+                attrs: {
+                    lang: i18n.getLanguage(),
+                },
+            };
+        },
+        deps: {
+            i18n: tokens.I18N_TOKEN,
+        },
+    }),
+    core.provide({
+        provide: tokensRender.RENDER_SLOTS,
+        multi: true,
+        useFactory: ({ i18n, requestManager }) => {
+            const parsedUrl = requestManager.getParsedUrl();
+            const url = `${parsedUrl.origin}${parsedUrl.pathname}`;
+            // TODO: dynamic list of available languages for specific route to generate alternate links
+            // TODO: `x-default` link?
+            return [
+                {
+                    type: tokensRender.ResourceType.asIs,
+                    slot: tokensRender.ResourceSlot.HEAD_META,
+                    payload: `<link rel="alternate" hreflang="${i18n.getLanguage()}" href="${url}" />`,
+                },
+            ];
+        },
+        deps: {
+            i18n: tokens.I18N_TOKEN,
+            requestManager: tokensCommon.REQUEST_MANAGER_TOKEN,
+        },
+    }),
+];
+
+exports.sharedProviders = sharedProviders;

package/lib/shared/service.browser.js

@@ -0,0 +1,164 @@
+import { parse } from '@tinkoff/url';
+import { RedirectFoundError, makeErrorSilent } from '@tinkoff/errors';
+import { I18nStore } from './store.browser.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.d.ts

@@ -0,0 +1,32 @@
+import type { COOKIE_MANAGER_TOKEN } from '@tramvai/tokens-cookie';
+import { ExtractDependencyType } from '@tinkoff/dippy';
+import { LOGGER_TOKEN, REQUEST_MANAGER_TOKEN, STORE_TOKEN } from '@tramvai/tokens-common';
+import { ROUTER_TOKEN } from '@tramvai/tokens-router';
+import { Url } from '@tinkoff/url';
+import type { I18nService, Language } from '../types';
+import { I18N_CONFIGURATION_TOKEN } from '../tokens';
+type Deps = {
+    store: ExtractDependencyType<typeof STORE_TOKEN>;
+    config: ExtractDependencyType<typeof I18N_CONFIGURATION_TOKEN>;
+    cookieManager: ExtractDependencyType<typeof COOKIE_MANAGER_TOKEN>;
+    router: ExtractDependencyType<typeof ROUTER_TOKEN>;
+    requestManager: ExtractDependencyType<typeof REQUEST_MANAGER_TOKEN>;
+    logger: ExtractDependencyType<typeof LOGGER_TOKEN>;
+};
+export declare class I18nServiceImpl implements I18nService {
+    private store;
+    private config;
+    private cookieManager;
+    private router;
+    private requestManager;
+    private log;
+    constructor(deps: Deps);
+    getLanguage(): Language;
+    getAvailableLanguages(): Language[];
+    switchLanguage(language: Language): Promise<void>;
+    getLanguageFromUrl(url: string | Url): Language | null;
+    removeLanguageFromUrl(url: string | Url): Url;
+    addLanguageToUrl(url: string | Url, lang: Language): Url;
+}
+export {};
+//# sourceMappingURL=service.d.ts.map