@bleedingdev/modern-js-plugin-i18n 3.2.0-ultramodern.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-present Modern.js
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,32 @@
+<p align="center">
+  <a href="https://modernjs.dev" target="blank"><img src="https://lf3-static.bytednsdoc.com/obj/eden-cn/ylaelkeh7nuhfnuhf/modernjs-cover.png" width="300" alt="Modern.js Logo" /></a>
+</p>
+
+<h1 align="center">Modern.js</h1>
+
+<p align="center">
+  A Progressive React Framework for modern web development.
+</p>
+
+## Getting Started
+
+Please follow [Quick Start](https://modernjs.dev/en/guides/get-started/quick-start) to get started with Modern.js.
+
+## Documentation
+
+- [English Documentation](https://modernjs.dev/en/)
+- [中文文档](https://modernjs.dev)
+
+## Contributing
+
+Please read the [Contributing Guide](https://github.com/web-infra-dev/modern.js/blob/main/CONTRIBUTING.md).
+
+## License
+
+Modern.js is [MIT licensed](https://github.com/web-infra-dev/modern.js/blob/main/LICENSE).
+
+## Credist
+
+Thanks to:
+
+- [@loadable/webpack-plugin](https://github.com/gregberge/loadable-components) to create a webpack plugin prepare for loadable usage in ssr.

package/dist/cjs/cli/index.js

@@ -0,0 +1,154 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    default: ()=>cli,
+    i18nPlugin: ()=>i18nPlugin
+});
+const server_core_namespaceObject = require("@modern-js/server-core");
+const external_fs_namespaceObject = require("fs");
+var external_fs_default = /*#__PURE__*/ __webpack_require__.n(external_fs_namespaceObject);
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const utils_js_namespaceObject = require("../shared/utils.js");
+function hasJsonFiles(dirPath) {
+    try {
+        if (!external_fs_default().existsSync(dirPath) || !external_fs_default().statSync(dirPath).isDirectory()) return false;
+        const entries = external_fs_default().readdirSync(dirPath);
+        for (const entry of entries){
+            const entryPath = external_path_default().join(dirPath, entry);
+            const stat = external_fs_default().statSync(entryPath);
+            if (stat.isFile() && entry.endsWith('.json')) return true;
+            if (stat.isDirectory()) {
+                if (hasJsonFiles(entryPath)) return true;
+            }
+        }
+        return false;
+    } catch  {
+        return false;
+    }
+}
+function detectLocalesDirectory(appDirectory, normalizedConfig) {
+    const rootLocalesPath = external_path_default().join(appDirectory, 'locales');
+    if (hasJsonFiles(rootLocalesPath)) return true;
+    const configPublicPath = external_path_default().join(appDirectory, 'config', 'public', 'locales');
+    if (hasJsonFiles(configPublicPath)) return true;
+    const publicDir = normalizedConfig?.server?.publicDir;
+    if (publicDir) {
+        const publicDirPath = Array.isArray(publicDir) ? publicDir[0] : publicDir;
+        const localesPath = external_path_default().isAbsolute(publicDirPath) ? external_path_default().join(publicDirPath, 'locales') : external_path_default().join(appDirectory, publicDirPath, 'locales');
+        if (hasJsonFiles(localesPath)) return true;
+    }
+    return false;
+}
+const i18nPlugin = (options = {})=>({
+        name: '@modern-js/plugin-i18n',
+        setup: (api)=>{
+            const { localeDetection, backend, transformRuntimeConfig, customPlugin, ...restOptions } = options;
+            api._internalRuntimePlugins(({ entrypoint, plugins })=>{
+                const localeDetectionOptions = localeDetection ? (0, utils_js_namespaceObject.getLocaleDetectionOptions)(entrypoint.entryName, localeDetection) : void 0;
+                let backendOptions;
+                const { appDirectory } = api.getAppContext();
+                const normalizedConfig = api.getNormalizedConfig();
+                if (backend) {
+                    const entryBackendOptions = (0, utils_js_namespaceObject.getBackendOptions)(entrypoint.entryName, backend);
+                    if (entryBackendOptions?.enabled === false) backendOptions = entryBackendOptions;
+                    else if (entryBackendOptions?.loadPath || entryBackendOptions?.addPath) backendOptions = {
+                        ...entryBackendOptions,
+                        enabled: true
+                    };
+                    else if (entryBackendOptions?.enabled !== true) {
+                        const hasLocales = detectLocalesDirectory(appDirectory, normalizedConfig);
+                        backendOptions = hasLocales ? {
+                            ...entryBackendOptions,
+                            enabled: true
+                        } : entryBackendOptions;
+                    } else backendOptions = entryBackendOptions;
+                } else {
+                    const hasLocales = detectLocalesDirectory(appDirectory, normalizedConfig);
+                    if (hasLocales) backendOptions = (0, utils_js_namespaceObject.getBackendOptions)(entrypoint.entryName, {
+                        enabled: true
+                    });
+                }
+                const { metaName } = api.getAppContext();
+                let extendedConfig = restOptions;
+                if (transformRuntimeConfig) extendedConfig = transformRuntimeConfig(restOptions, entrypoint);
+                const config = {
+                    entryName: entrypoint.entryName,
+                    localeDetection: localeDetectionOptions,
+                    backend: backendOptions,
+                    ...extendedConfig
+                };
+                plugins.push({
+                    name: customPlugin?.runtime?.name || 'i18n',
+                    path: customPlugin?.runtime?.path || `@${metaName}/plugin-i18n/runtime`,
+                    config
+                });
+                return {
+                    entrypoint,
+                    plugins
+                };
+            });
+            api._internalServerPlugins(({ plugins })=>{
+                const { serverRoutes, metaName } = api.getAppContext();
+                const normalizedConfig = api.getNormalizedConfig();
+                let staticRoutePrefixes = [];
+                if (serverRoutes && Array.isArray(serverRoutes)) staticRoutePrefixes = serverRoutes.filter((route)=>!route.entryName && route.entryPath.startsWith('public')).map((route)=>route.urlPath).filter(Boolean);
+                const publicDirPrefixes = (0, server_core_namespaceObject.getPublicDirRoutePrefixes)(normalizedConfig?.server?.publicDir);
+                publicDirPrefixes.forEach((prefix)=>{
+                    if (!staticRoutePrefixes.includes(prefix)) staticRoutePrefixes.push(prefix);
+                });
+                plugins.push({
+                    name: customPlugin?.server?.name || `@${metaName}/plugin-i18n/server`,
+                    options: {
+                        localeDetection,
+                        staticRoutePrefixes
+                    }
+                });
+                return {
+                    plugins
+                };
+            });
+        }
+    });
+const cli = i18nPlugin;
+exports["default"] = __webpack_exports__["default"];
+exports.i18nPlugin = __webpack_exports__.i18nPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "default",
+    "i18nPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/I18nLink.js

@@ -0,0 +1,68 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    I18nLink: ()=>I18nLink,
+    default: ()=>runtime_I18nLink
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const router_namespaceObject = require("@modern-js/runtime/router");
+const external_context_js_namespaceObject = require("./context.js");
+const external_utils_js_namespaceObject = require("./utils.js");
+const useRouterHooks = ()=>{
+    const inRouter = (0, router_namespaceObject.useInRouterContext)();
+    return {
+        Link: inRouter ? router_namespaceObject.Link : null,
+        params: inRouter ? (0, router_namespaceObject.useParams)() : {},
+        hasRouter: inRouter
+    };
+};
+const I18nLink = ({ to, children, ...props })=>{
+    const { Link, params, hasRouter } = useRouterHooks();
+    const { language, supportedLanguages } = (0, external_context_js_namespaceObject.useModernI18n)();
+    const currentLang = language;
+    const localizedTo = (0, external_utils_js_namespaceObject.buildLocalizedUrl)(to, currentLang, supportedLanguages);
+    if ('development' === process.env.NODE_ENV && hasRouter && !params.lang) console.warn("I18nLink is being used outside of a :lang dynamic route context. This may cause unexpected behavior. Please ensure I18nLink is used within a route that has a :lang parameter.");
+    if (!hasRouter || !Link) return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("a", {
+        href: localizedTo,
+        ...props,
+        children: children
+    });
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(Link, {
+        to: localizedTo,
+        ...props,
+        children: children
+    });
+};
+const runtime_I18nLink = I18nLink;
+exports.I18nLink = __webpack_exports__.I18nLink;
+exports["default"] = __webpack_exports__["default"];
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "I18nLink",
+    "default"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/context.js

@@ -0,0 +1,142 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    ModernI18nProvider: ()=>ModernI18nProvider,
+    useModernI18n: ()=>useModernI18n
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const runtime_namespaceObject = require("@modern-js/runtime");
+const external_react_namespaceObject = require("react");
+const index_js_namespaceObject = require("./i18n/detection/index.js");
+const external_utils_js_namespaceObject = require("./utils.js");
+const ModernI18nContext = /*#__PURE__*/ (0, external_react_namespaceObject.createContext)(null);
+const ModernI18nProvider = ({ children, value })=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(ModernI18nContext.Provider, {
+        value: value,
+        children: children
+    });
+const useModernI18n = ()=>{
+    const context = (0, external_react_namespaceObject.useContext)(ModernI18nContext);
+    if (!context) throw new Error('useModernI18n must be used within a ModernI18nProvider');
+    const { language: contextLanguage, i18nInstance, languages, localePathRedirect, ignoreRedirectRoutes, updateLanguage } = context;
+    const { navigate, location, hasRouter } = (0, external_utils_js_namespaceObject.useRouterHooks)();
+    const currentLanguage = contextLanguage;
+    const changeLanguage = (0, external_react_namespaceObject.useCallback)(async (newLang)=>{
+        try {
+            if (!newLang || 'string' != typeof newLang) throw new Error('Language must be a non-empty string');
+            await i18nInstance?.setLang?.(newLang);
+            await i18nInstance?.changeLanguage?.(newLang);
+            if ((0, runtime_namespaceObject.isBrowser)()) {
+                const detectionOptions = i18nInstance.options?.detection;
+                (0, index_js_namespaceObject.cacheUserLanguage)(i18nInstance, newLang, detectionOptions);
+            }
+            if (localePathRedirect && (0, runtime_namespaceObject.isBrowser)() && hasRouter && navigate && location) {
+                const currentPath = location.pathname;
+                const entryPath = (0, external_utils_js_namespaceObject.getEntryPath)();
+                const relativePath = currentPath.replace(entryPath, '');
+                const pathLanguage = (0, external_utils_js_namespaceObject.detectLanguageFromPath)(currentPath, languages || [], localePathRedirect);
+                if (pathLanguage.detected && pathLanguage.language === newLang) return;
+                if (!(0, external_utils_js_namespaceObject.shouldIgnoreRedirect)(relativePath, languages || [], ignoreRedirectRoutes)) {
+                    const newPath = (0, external_utils_js_namespaceObject.buildLocalizedUrl)(relativePath, newLang, languages || []);
+                    const newUrl = entryPath + newPath + location.search + location.hash;
+                    await navigate(newUrl, {
+                        replace: true
+                    });
+                }
+            } else if (localePathRedirect && (0, runtime_namespaceObject.isBrowser)() && !hasRouter) {
+                const currentPath = window.location.pathname;
+                const entryPath = (0, external_utils_js_namespaceObject.getEntryPath)();
+                const relativePath = currentPath.replace(entryPath, '');
+                const pathLanguage = (0, external_utils_js_namespaceObject.detectLanguageFromPath)(currentPath, languages || [], localePathRedirect);
+                if (pathLanguage.detected && pathLanguage.language === newLang) return;
+                if (!(0, external_utils_js_namespaceObject.shouldIgnoreRedirect)(relativePath, languages || [], ignoreRedirectRoutes)) {
+                    const newPath = (0, external_utils_js_namespaceObject.buildLocalizedUrl)(relativePath, newLang, languages || []);
+                    const newUrl = entryPath + newPath + window.location.search + window.location.hash;
+                    window.history.pushState(null, '', newUrl);
+                }
+            }
+            if (updateLanguage) updateLanguage(newLang);
+        } catch (error) {
+            console.error('Failed to change language:', error);
+            throw error;
+        }
+    }, [
+        i18nInstance,
+        updateLanguage,
+        localePathRedirect,
+        ignoreRedirectRoutes,
+        languages,
+        hasRouter,
+        navigate,
+        location
+    ]);
+    const isLanguageSupported = (0, external_react_namespaceObject.useCallback)((lang)=>languages?.includes(lang) || false, [
+        languages
+    ]);
+    const isResourcesReady = (0, external_react_namespaceObject.useMemo)(()=>{
+        if (!i18nInstance?.isInitialized) return false;
+        const backend = i18nInstance?.services?.backend;
+        if (backend && 'function' == typeof backend.isLoading) {
+            const loadingResources = backend.getLoadingResources();
+            const isCurrentLanguageLoading = loadingResources.some(({ language })=>language === currentLanguage);
+            if (isCurrentLanguageLoading) return false;
+        }
+        const store = i18nInstance.store;
+        if (!store?.data) return false;
+        const langData = store.data[currentLanguage];
+        if (!langData || 'object' != typeof langData) return false;
+        const options = i18nInstance.options;
+        const namespaces = options?.ns || options?.defaultNS || [
+            'translation'
+        ];
+        const requiredNamespaces = Array.isArray(namespaces) ? namespaces : [
+            namespaces
+        ];
+        return requiredNamespaces.every((ns)=>{
+            const nsData = langData[ns];
+            return nsData && 'object' == typeof nsData && Object.keys(nsData).length > 0;
+        });
+    }, [
+        currentLanguage,
+        i18nInstance
+    ]);
+    return {
+        language: currentLanguage,
+        changeLanguage,
+        i18nInstance,
+        supportedLanguages: languages || [],
+        isLanguageSupported,
+        isResourcesReady
+    };
+};
+exports.ModernI18nProvider = __webpack_exports__.ModernI18nProvider;
+exports.useModernI18n = __webpack_exports__.useModernI18n;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ModernI18nProvider",
+    "useModernI18n"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/hooks.js

@@ -0,0 +1,194 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createContextValue: ()=>createContextValue,
+    useClientSideRedirect: ()=>useClientSideRedirect,
+    useLanguageSync: ()=>useLanguageSync,
+    useSdkResourcesLoader: ()=>useSdkResourcesLoader
+});
+const runtime_namespaceObject = require("@modern-js/runtime");
+const external_react_namespaceObject = require("react");
+const sdk_event_js_namespaceObject = require("./i18n/backend/sdk-event.js");
+const index_js_namespaceObject = require("./i18n/detection/index.js");
+const external_utils_js_namespaceObject = require("./utils.js");
+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) {
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        if (!i18nInstance || !(0, runtime_namespaceObject.isBrowser)()) return;
+        const backendId = (0, sdk_event_js_namespaceObject.getI18nSdkBackendId)(i18nInstance.services?.resourceStore) || (0, sdk_event_js_namespaceObject.getI18nSdkBackendId)(i18nInstance.services?.store) || (0, sdk_event_js_namespaceObject.getI18nSdkBackendId)(i18nInstance.store);
+        if (!backendId) return;
+        const handleSdkResourcesLoaded = (event)=>{
+            const customEvent = event;
+            const { language, namespace, backendId: eventBackendId } = customEvent.detail || {};
+            if (!language || !namespace) return;
+            if (eventBackendId && eventBackendId !== backendId) return;
+            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(sdk_event_js_namespaceObject.I18N_SDK_RESOURCES_LOADED_EVENT, handleSdkResourcesLoaded);
+        return ()=>{
+            window.removeEventListener(sdk_event_js_namespaceObject.I18N_SDK_RESOURCES_LOADED_EVENT, handleSdkResourcesLoaded);
+        };
+    }, [
+        i18nInstance,
+        setForceUpdate
+    ]);
+}
+function useClientSideRedirect(i18nInstance, localePathRedirect, languages, fallbackLanguage, ignoreRedirectRoutes) {
+    const hasRedirectedRef = (0, external_react_namespaceObject.useRef)(false);
+    const { navigate, location, hasRouter } = (0, external_utils_js_namespaceObject.useRouterHooks)();
+    (0, external_react_namespaceObject.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 = (0, external_utils_js_namespaceObject.getEntryPath)();
+        const relativePath = currentPathname.replace(entryPath, '');
+        if ((0, external_utils_js_namespaceObject.shouldIgnoreRedirect)(relativePath, languages, ignoreRedirectRoutes)) return;
+        const pathDetection = (0, external_utils_js_namespaceObject.detectLanguageFromPath)(currentPathname, languages, localePathRedirect);
+        if (pathDetection.detected) return;
+        const targetLanguage = i18nInstance.language || fallbackLanguage || languages[0] || 'en';
+        const newPath = (0, external_utils_js_namespaceObject.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) {
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        if (!i18nInstance) return;
+        if (localePathRedirect) {
+            const currentPathname = (0, external_utils_js_namespaceObject.getPathname)(runtimeContextRef.current);
+            const pathDetection = (0, external_utils_js_namespaceObject.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 ((0, runtime_namespaceObject.isBrowser)()) {
+                        const detectionOptions = i18nInstance.options?.detection;
+                        (0, index_js_namespaceObject.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
+    ]);
+}
+exports.createContextValue = __webpack_exports__.createContextValue;
+exports.useClientSideRedirect = __webpack_exports__.useClientSideRedirect;
+exports.useLanguageSync = __webpack_exports__.useLanguageSync;
+exports.useSdkResourcesLoader = __webpack_exports__.useSdkResourcesLoader;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createContextValue",
+    "useClientSideRedirect",
+    "useLanguageSync",
+    "useSdkResourcesLoader"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,39 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    mergeBackendOptions: ()=>mergeBackendOptions
+});
+const deepMerge_js_namespaceObject = require("../../../shared/deepMerge.js");
+function mergeBackendOptions(defaultOptions, cliOptions = {}, userOptions) {
+    return (0, deepMerge_js_namespaceObject.deepMerge)((0, deepMerge_js_namespaceObject.deepMerge)(defaultOptions, cliOptions), userOptions ?? {});
+}
+exports.mergeBackendOptions = __webpack_exports__.mergeBackendOptions;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "mergeBackendOptions"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});