@modern-js/plugin-i18n 2.69.7 → 3.0.0-alpha.1

package/dist/esm/runtime/hooks.js

@@ -0,0 +1,146 @@
+import { isBrowser } from "@modern-js/runtime";
+import { useEffect, useRef } from "react";
+import { cacheUserLanguage } from "./i18n/detection";
+import { buildLocalizedUrl, detectLanguageFromPath, getEntryPath, getPathname, shouldIgnoreRedirect, useRouterHooks } from "./utils";
+function createMinimalI18nInstance(language) {
+    const minimalInstance = {
+        language,
+        isInitialized: false,
+        init: ()=>Promise.resolve(void 0),
+        use: ()=>{},
+        createInstance: ()=>minimalInstance,
+        services: {}
+    };
+    return minimalInstance;
+}
+function createContextValue(lang, i18nInstance, entryName, languages, localePathRedirect, ignoreRedirectRoutes, setLang) {
+    const instance = i18nInstance || createMinimalI18nInstance(lang);
+    return {
+        language: lang,
+        i18nInstance: instance,
+        entryName,
+        languages,
+        localePathRedirect,
+        ignoreRedirectRoutes,
+        updateLanguage: setLang
+    };
+}
+function useSdkResourcesLoader(i18nInstance, setForceUpdate) {
+    useEffect(()=>{
+        if (!i18nInstance || !isBrowser()) return;
+        const handleSdkResourcesLoaded = (event)=>{
+            const customEvent = event;
+            const { language, namespace } = customEvent.detail;
+            const triggerUpdate = (retryCount = 0)=>{
+                const store = i18nInstance.store;
+                const hasResource = store?.data?.[language]?.[namespace];
+                if (hasResource || retryCount >= 10) {
+                    if (store?.data?.[language]?.[namespace]) {
+                        if ('function' == typeof store.emit) store.emit('added', language, namespace);
+                    }
+                    if ('function' == typeof i18nInstance.emit) {
+                        i18nInstance.emit('loaded', {
+                            language,
+                            namespace
+                        });
+                        i18nInstance.emit('loaded', language, namespace);
+                    }
+                    if ('function' == typeof i18nInstance.reloadResources) i18nInstance.reloadResources(language, namespace).then(()=>{
+                        if ('function' == typeof i18nInstance.emit) i18nInstance.emit('loaded', {
+                            language,
+                            namespace
+                        });
+                        setForceUpdate((prev)=>prev + 1);
+                    }).catch(()=>{});
+                    if ('function' == typeof i18nInstance.emit) i18nInstance.emit('languageChanged', language);
+                    setForceUpdate((prev)=>prev + 1);
+                } else setTimeout(()=>triggerUpdate(retryCount + 1), 10);
+            };
+            triggerUpdate();
+        };
+        window.addEventListener('i18n-sdk-resources-loaded', handleSdkResourcesLoaded);
+        return ()=>{
+            window.removeEventListener('i18n-sdk-resources-loaded', handleSdkResourcesLoaded);
+        };
+    }, [
+        i18nInstance,
+        setForceUpdate
+    ]);
+}
+function useClientSideRedirect(i18nInstance, localePathRedirect, languages, fallbackLanguage, ignoreRedirectRoutes) {
+    const hasRedirectedRef = useRef(false);
+    const { navigate, location, hasRouter } = useRouterHooks();
+    useEffect(()=>{
+        if ('browser' !== process.env.MODERN_TARGET) return;
+        if (!localePathRedirect || !i18nInstance) return;
+        try {
+            const ssrData = window._SSR_DATA;
+            if (ssrData) return;
+        } catch  {}
+        if (hasRedirectedRef.current) return;
+        if (!i18nInstance.isInitialized) return;
+        const currentPathname = hasRouter && location ? location.pathname : window.location.pathname;
+        const currentSearch = hasRouter && location ? location.search : window.location.search;
+        const currentHash = hasRouter && location ? location.hash : window.location.hash;
+        const entryPath = getEntryPath();
+        const relativePath = currentPathname.replace(entryPath, '');
+        if (shouldIgnoreRedirect(relativePath, languages, ignoreRedirectRoutes)) return;
+        const pathDetection = detectLanguageFromPath(currentPathname, languages, localePathRedirect);
+        if (pathDetection.detected) return;
+        const targetLanguage = i18nInstance.language || fallbackLanguage || languages[0] || 'en';
+        const newPath = buildLocalizedUrl(relativePath, targetLanguage, languages);
+        const newUrl = entryPath + newPath + currentSearch + currentHash;
+        if (newUrl !== currentPathname + currentSearch + currentHash) {
+            hasRedirectedRef.current = true;
+            if (hasRouter && navigate && location) navigate(newUrl, {
+                replace: true
+            });
+            else window.location.replace(newUrl);
+        }
+    }, [
+        navigate,
+        location,
+        hasRouter,
+        localePathRedirect,
+        i18nInstance,
+        languages,
+        fallbackLanguage,
+        ignoreRedirectRoutes
+    ]);
+}
+function useLanguageSync(i18nInstance, localePathRedirect, languages, runtimeContextRef, prevLangRef, setLang) {
+    useEffect(()=>{
+        if (!i18nInstance) return;
+        if (localePathRedirect) {
+            const currentPathname = getPathname(runtimeContextRef.current);
+            const pathDetection = detectLanguageFromPath(currentPathname, languages, localePathRedirect);
+            if (pathDetection.detected && pathDetection.language) {
+                const currentLang = pathDetection.language;
+                if (currentLang !== prevLangRef.current) {
+                    prevLangRef.current = currentLang;
+                    setLang(currentLang);
+                    i18nInstance.setLang?.(currentLang);
+                    i18nInstance.changeLanguage?.(currentLang);
+                    if (isBrowser()) {
+                        const detectionOptions = i18nInstance.options?.detection;
+                        cacheUserLanguage(i18nInstance, currentLang, detectionOptions);
+                    }
+                }
+            }
+        } else {
+            const instanceLang = i18nInstance.language;
+            if (instanceLang && instanceLang !== prevLangRef.current) {
+                prevLangRef.current = instanceLang;
+                setLang(instanceLang);
+            }
+        }
+    }, [
+        i18nInstance,
+        localePathRedirect,
+        languages,
+        runtimeContextRef,
+        prevLangRef,
+        setLang
+    ]);
+}
+export { createContextValue, useClientSideRedirect, useLanguageSync, useSdkResourcesLoader };

package/dist/esm/runtime/i18n/backend/config.js

@@ -0,0 +1,5 @@
+import { deepMerge } from "../../../shared/deepMerge";
+function mergeBackendOptions(defaultOptions, cliOptions = {}, userOptions) {
+    return deepMerge(deepMerge(defaultOptions, cliOptions), userOptions ?? {});
+}
+export { mergeBackendOptions };

package/dist/esm/runtime/i18n/backend/defaults.js

@@ -0,0 +1,19 @@
+const DEFAULT_I18NEXT_BACKEND_OPTIONS = {
+    loadPath: '/locales/{{lng}}/{{ns}}.json',
+    addPath: '/locales/{{lng}}/{{ns}}.json'
+};
+function convertPath(path) {
+    if (!path) return path;
+    if (path.startsWith('/')) return `${window.__assetPrefix__ || ''}${path}`;
+    return path;
+}
+function convertBackendOptions(options) {
+    if (!options) return options;
+    const converted = {
+        ...options
+    };
+    if (converted.loadPath) converted.loadPath = convertPath(converted.loadPath);
+    if (converted.addPath) converted.addPath = convertPath(converted.addPath);
+    return converted;
+}
+export { DEFAULT_I18NEXT_BACKEND_OPTIONS, convertBackendOptions };

package/dist/esm/runtime/i18n/backend/defaults.node.js

@@ -0,0 +1,19 @@
+const DEFAULT_I18NEXT_BACKEND_OPTIONS = {
+    loadPath: './locales/{{lng}}/{{ns}}.json',
+    addPath: './locales/{{lng}}/{{ns}}.json'
+};
+function convertPath(path) {
+    if (!path) return path;
+    if (path.startsWith('/')) return `.${path}`;
+    return path;
+}
+function convertBackendOptions(options) {
+    if (!options) return options;
+    const converted = {
+        ...options
+    };
+    if (converted.loadPath) converted.loadPath = convertPath(converted.loadPath);
+    if (converted.addPath) converted.addPath = convertPath(converted.addPath);
+    return converted;
+}
+export { DEFAULT_I18NEXT_BACKEND_OPTIONS, convertBackendOptions };

package/dist/esm/runtime/i18n/backend/index.js

@@ -0,0 +1,74 @@
+import { mergeBackendOptions } from "./config";
+import { DEFAULT_I18NEXT_BACKEND_OPTIONS, convertBackendOptions } from "./defaults";
+function hasSdkFunction(backend, userInitOptions) {
+    return 'function' == typeof userInitOptions?.backend?.sdk || !!backend?.enabled && !!backend?.sdk && 'function' == typeof backend.sdk;
+}
+function hasLoadPath(backend, userInitOptions) {
+    const userLoadPath = userInitOptions?.backend?.loadPath ?? backend?.loadPath;
+    const isExplicit = !!userLoadPath && '' !== userLoadPath;
+    const hasPath = isExplicit || !!backend?.enabled && void 0 === userLoadPath;
+    return {
+        hasPath,
+        isExplicit
+    };
+}
+function ensureDefaultLoadPath(merged, backend, isExplicitLoadPath = false) {
+    if (backend?.enabled && !isExplicitLoadPath && !merged.loadPath) {
+        merged.loadPath = DEFAULT_I18NEXT_BACKEND_OPTIONS.loadPath;
+        merged.addPath = DEFAULT_I18NEXT_BACKEND_OPTIONS.addPath;
+    }
+}
+function getFinalLoadPath(mergedOptions, backend, userInitOptions) {
+    return mergedOptions?.loadPath || userInitOptions?.backend?.loadPath || (backend?.enabled ? DEFAULT_I18NEXT_BACKEND_OPTIONS.loadPath : void 0);
+}
+function getFinalSdk(mergedOptions, backend, userInitOptions) {
+    return mergedOptions?.sdk || userInitOptions?.backend?.sdk || (backend?.sdk && 'function' == typeof backend.sdk ? backend.sdk : void 0);
+}
+function buildChainedBackendConfig(backend, userInitOptions) {
+    const merged = mergeBackendOptions(DEFAULT_I18NEXT_BACKEND_OPTIONS, backend, userInitOptions?.backend);
+    const { isExplicit } = hasLoadPath(backend, userInitOptions);
+    ensureDefaultLoadPath(merged, backend, isExplicit);
+    const mergedOptions = convertBackendOptions(merged);
+    const finalLoadPath = getFinalLoadPath(mergedOptions, backend, userInitOptions);
+    const finalSdk = getFinalSdk(mergedOptions, backend, userInitOptions);
+    const chainedBackendOptions = [
+        {
+            loadPath: finalLoadPath,
+            addPath: mergedOptions?.addPath || DEFAULT_I18NEXT_BACKEND_OPTIONS.addPath
+        },
+        {
+            sdk: finalSdk
+        }
+    ];
+    return {
+        ...mergedOptions,
+        loadPath: finalLoadPath,
+        sdk: finalSdk,
+        cacheHitMode: mergedOptions?.cacheHitMode || backend?.cacheHitMode || userInitOptions?.backend?.cacheHitMode || 'refreshAndUpdateStore',
+        _useChainedBackend: true,
+        _chainedBackendConfig: {
+            backendOptions: chainedBackendOptions
+        }
+    };
+}
+function buildSdkOnlyBackendConfig(backend, userInitOptions) {
+    const merged = mergeBackendOptions({}, backend, userInitOptions?.backend);
+    return convertBackendOptions(merged) || {};
+}
+function buildHttpFsBackendConfig(backend, userInitOptions) {
+    if (!backend?.enabled && !userInitOptions?.backend) return;
+    const mergedBackend = backend?.enabled ? mergeBackendOptions(DEFAULT_I18NEXT_BACKEND_OPTIONS, backend, userInitOptions?.backend) : userInitOptions?.backend;
+    if (mergedBackend) {
+        const { isExplicit } = hasLoadPath(backend, userInitOptions);
+        ensureDefaultLoadPath(mergedBackend, backend, isExplicit);
+    }
+    return convertBackendOptions(mergedBackend) || {};
+}
+const backend_mergeBackendOptions = (backend, userInitOptions)=>{
+    const sdkFunction = hasSdkFunction(backend, userInitOptions);
+    const { hasPath } = hasLoadPath(backend, userInitOptions);
+    if (hasPath && sdkFunction) return buildChainedBackendConfig(backend, userInitOptions);
+    if (sdkFunction) return buildSdkOnlyBackendConfig(backend, userInitOptions);
+    return buildHttpFsBackendConfig(backend, userInitOptions);
+};
+export { backend_mergeBackendOptions as mergeBackendOptions };

package/dist/esm/runtime/i18n/backend/middleware.common.js

@@ -0,0 +1,61 @@
+import i18next_chained_backend from "i18next-chained-backend";
+import { getActualI18nextInstance } from "../instance";
+import { SdkBackend } from "./sdk-backend";
+function checkBackendConfig(backend) {
+    const hasSdk = backend?.sdk && 'function' == typeof backend.sdk;
+    const hasLoadPath = !!backend?.loadPath;
+    const useChained = backend?._useChainedBackend;
+    return {
+        hasSdk,
+        hasLoadPath,
+        useChained
+    };
+}
+function buildChainedBackendConfig(backend, BackendWithSave) {
+    const cacheHitMode = backend.cacheHitMode || 'refreshAndUpdateStore';
+    if (backend._chainedBackendConfig) return {
+        backends: [
+            BackendWithSave,
+            SdkBackend
+        ],
+        backendOptions: backend._chainedBackendConfig.backendOptions,
+        cacheHitMode
+    };
+    return {
+        backends: [
+            BackendWithSave,
+            SdkBackend
+        ],
+        backendOptions: [
+            {
+                loadPath: backend.loadPath,
+                addPath: backend.addPath
+            },
+            {
+                sdk: backend.sdk
+            }
+        ],
+        cacheHitMode
+    };
+}
+function setupChainedBackend(i18nInstance, backend, BackendWithSave) {
+    i18nInstance.use(i18next_chained_backend);
+    const actualInstance = getActualI18nextInstance(i18nInstance);
+    if (actualInstance?.options) actualInstance.options.backend = buildChainedBackendConfig(backend, BackendWithSave);
+    if (i18nInstance.options) i18nInstance.options.backend = buildChainedBackendConfig(backend, BackendWithSave);
+}
+function cleanBackendConfig(backend) {
+    const { _useChainedBackend, _chainedBackendConfig, ...cleanBackend } = backend;
+    return cleanBackend;
+}
+function useI18nextBackendCommon(i18nInstance, BackendWithSave, BackendBase, backend) {
+    if (!backend) return i18nInstance.use(BackendBase);
+    const { hasSdk, hasLoadPath, useChained } = checkBackendConfig(backend);
+    if (useChained || hasLoadPath && hasSdk) return void setupChainedBackend(i18nInstance, backend, BackendWithSave);
+    if (hasSdk) return i18nInstance.use(SdkBackend);
+    const actualInstance = getActualI18nextInstance(i18nInstance);
+    if (actualInstance?.options) actualInstance.options.backend = cleanBackendConfig(backend);
+    if (i18nInstance.options) i18nInstance.options.backend = cleanBackendConfig(backend);
+    return i18nInstance.use(BackendBase);
+}
+export { useI18nextBackendCommon };

package/dist/esm/runtime/i18n/backend/middleware.js

@@ -0,0 +1,7 @@
+import i18next_http_backend from "i18next-http-backend";
+import { useI18nextBackendCommon } from "./middleware.common.js";
+class HttpBackendWithSave extends i18next_http_backend {
+    save(_language, _namespace, _data) {}
+}
+const useI18nextBackend = (i18nInstance, backend)=>useI18nextBackendCommon(i18nInstance, HttpBackendWithSave, i18next_http_backend, backend);
+export { HttpBackendWithSave, useI18nextBackend };

package/dist/esm/runtime/i18n/backend/middleware.node.js

@@ -0,0 +1,8 @@
+import i18next_fs_backend from "i18next-fs-backend";
+import { useI18nextBackendCommon } from "./middleware.common.js";
+class FsBackendWithSave extends i18next_fs_backend {
+    save(_language, _namespace, _data) {}
+}
+const HttpBackendWithSave = FsBackendWithSave;
+const useI18nextBackend = (i18nInstance, backend)=>useI18nextBackendCommon(i18nInstance, FsBackendWithSave, i18next_fs_backend, backend);
+export { FsBackendWithSave, HttpBackendWithSave, useI18nextBackend };

package/dist/esm/runtime/i18n/backend/sdk-backend.js

@@ -0,0 +1,137 @@
+class SdkBackend {
+    init(services, backendOptions, _i18nextOptions) {
+        this.services = services;
+        this.sdk = backendOptions?.sdk;
+        if (!this.sdk) throw new Error('SdkBackend requires an SDK function to be provided in backend options');
+    }
+    read(language, namespace, callback) {
+        if (!this.sdk) {
+            console.error('[i18n] SdkBackend.read - SDK function not initialized');
+            callback(new Error('SDK function not initialized'), null);
+            return;
+        }
+        const cached = this.allResourcesCache ? this.extractFromCache(language, namespace) : null;
+        if (null !== cached) {
+            const mergedData = this.mergeWithExistingResources(language, namespace, cached);
+            callback(null, mergedData);
+            return;
+        }
+        const cacheKey = this.getCacheKey(language, namespace);
+        const existingPromise = this.loadingPromises.get(cacheKey);
+        if (existingPromise) return void this.handlePromise(existingPromise, language, namespace, callback, false);
+        this.loadResource(language, namespace, callback);
+    }
+    create(_languages, _namespace, _key, _fallbackValue) {}
+    isLoading(language, namespace) {
+        return this.loadingPromises.has(this.getCacheKey(language, namespace));
+    }
+    getLoadingResources() {
+        const loading = [];
+        for (const key of this.loadingPromises.keys()){
+            const [language, namespace] = key.split(':');
+            if (language && namespace) loading.push({
+                language,
+                namespace
+            });
+        }
+        return loading;
+    }
+    hasLoadingResources() {
+        return this.loadingPromises.size > 0;
+    }
+    getCacheKey(language, namespace) {
+        return `${language}:${namespace}`;
+    }
+    loadResource(language, namespace, callback) {
+        try {
+            const result = this.callSdk(language, namespace);
+            const loadPromise = result instanceof Promise ? result : Promise.resolve(result);
+            const cacheKey = this.getCacheKey(language, namespace);
+            this.loadingPromises.set(cacheKey, loadPromise);
+            this.handlePromise(loadPromise, language, namespace, callback, true);
+        } catch (error) {
+            callback(this.normalizeError(error), null);
+        }
+    }
+    handlePromise(promise, language, namespace, callback, shouldUpdateCache) {
+        const cacheKey = this.getCacheKey(language, namespace);
+        promise.then((data)=>{
+            const formattedData = this.formatResources(data, language, namespace);
+            const mergedData = this.mergeWithExistingResources(language, namespace, formattedData);
+            if (shouldUpdateCache) {
+                this.updateCache(language, namespace, mergedData);
+                this.loadingPromises.delete(cacheKey);
+            }
+            callback(null, mergedData);
+            this.triggerI18nextUpdate(language, namespace);
+        }).catch((error)=>{
+            if (shouldUpdateCache) this.loadingPromises.delete(cacheKey);
+            callback(this.normalizeError(error), null);
+        });
+    }
+    normalizeError(error) {
+        return error instanceof Error ? error : new Error(String(error));
+    }
+    callSdk(language, namespace) {
+        if (!this.sdk) throw new Error('SDK function not initialized');
+        const options = {
+            lng: language,
+            ns: namespace
+        };
+        return this.sdk(options);
+    }
+    extractFromCache(language, namespace) {
+        if (!this.allResourcesCache) return null;
+        const langData = this.allResourcesCache[language];
+        if (!this.isObject(langData)) return null;
+        const nsData = langData[namespace];
+        if (!this.isObject(nsData)) return null;
+        return nsData;
+    }
+    updateCache(language, namespace, data) {
+        if (!this.allResourcesCache) this.allResourcesCache = {};
+        if (!this.allResourcesCache[language]) this.allResourcesCache[language] = {};
+        if (this.isObject(data)) this.allResourcesCache[language][namespace] = data;
+    }
+    formatResources(data, language, namespace) {
+        if (!this.isObject(data)) return {};
+        const dataObj = data;
+        const langData = dataObj[language];
+        if (this.isObject(langData)) {
+            const nsData = langData[namespace];
+            if (this.isObject(nsData)) return nsData;
+        }
+        const hasLanguageKeys = Object.keys(dataObj).some((key)=>this.isObject(dataObj[key]));
+        if (!hasLanguageKeys) return dataObj;
+        return {};
+    }
+    isObject(value) {
+        return null !== value && 'object' == typeof value;
+    }
+    mergeWithExistingResources(language, namespace, sdkData) {
+        const store = this.services?.resourceStore || this.services?.store;
+        const existingData = store?.data?.[language]?.[namespace] || {};
+        return {
+            ...existingData,
+            ...sdkData
+        };
+    }
+    triggerI18nextUpdate(language, namespace) {
+        if ("u" > typeof window) {
+            const event = new CustomEvent('i18n-sdk-resources-loaded', {
+                detail: {
+                    language,
+                    namespace
+                }
+            });
+            window.dispatchEvent(event);
+        }
+    }
+    constructor(_services, _options){
+        this.type = 'backend';
+        this.allResourcesCache = null;
+        this.loadingPromises = new Map();
+    }
+}
+SdkBackend.type = 'backend';
+export { SdkBackend };

package/dist/esm/runtime/i18n/detection/config.js

@@ -0,0 +1,26 @@
+import { deepMerge } from "../../../shared/deepMerge.js";
+const DEFAULT_I18NEXT_DETECTION_OPTIONS = {
+    caches: [
+        'cookie',
+        'localStorage'
+    ],
+    order: [
+        'querystring',
+        'cookie',
+        'localStorage',
+        'header',
+        'navigator',
+        'htmlTag',
+        'path',
+        'subdomain'
+    ],
+    cookieMinutes: 525600,
+    lookupQuerystring: 'lng',
+    lookupCookie: 'i18next',
+    lookupLocalStorage: 'i18nextLng',
+    lookupHeader: 'accept-language'
+};
+function mergeDetectionOptions(cliOptions, userOptions, defaultOptions = DEFAULT_I18NEXT_DETECTION_OPTIONS) {
+    return deepMerge(deepMerge(defaultOptions, cliOptions ?? {}), userOptions ?? {});
+}
+export { DEFAULT_I18NEXT_DETECTION_OPTIONS, mergeDetectionOptions };