@bleedingdev/modern-js-plugin-i18n 3.5.0-ultramodern.5 → 3.5.0-ultramodern.75

package/dist/cjs/cli/index.js

@@ -64,7 +64,8 @@ const i18nPlugin = (options = {})=>({
                     backend: backendOptions,
                     ...extendedConfig
                 };
-                const runtimePluginPath = customPlugin?.runtime?.path || (false === config.reactI18next ? `@${metaName}/plugin-i18n/runtime/no-react-i18next` : `@${metaName}/plugin-i18n/runtime`);
+                const { reactI18next } = extendedConfig;
+                const runtimePluginPath = customPlugin?.runtime?.path || (false === reactI18next ? `@${metaName}/plugin-i18n/runtime/no-react-i18next` : `@${metaName}/plugin-i18n/runtime`);
                 plugins.push({
                     name: customPlugin?.runtime?.name || 'i18n',
                     path: runtimePluginPath,

package/dist/cjs/cli/locales.js

@@ -40,19 +40,19 @@ __webpack_require__.d(__webpack_exports__, {
     applyDetectedBackendPaths: ()=>applyDetectedBackendPaths,
     detectLocalesDirectory: ()=>detectLocalesDirectory
 });
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
 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 LOCALES_RESOURCE_PATTERN = '{{lng}}/{{ns}}.json';
 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);
+        if (!external_node_fs_default().existsSync(dirPath) || !external_node_fs_default().statSync(dirPath).isDirectory()) return false;
+        const entries = external_node_fs_default().readdirSync(dirPath);
         for (const entry of entries){
-            const entryPath = external_path_default().join(dirPath, entry);
-            const stat = external_fs_default().statSync(entryPath);
+            const entryPath = external_node_path_default().join(dirPath, entry);
+            const stat = external_node_fs_default().statSync(entryPath);
             if (stat.isFile() && entry.endsWith('.json')) return true;
             if (stat.isDirectory() && hasJsonFiles(entryPath)) return true;
         }
@@ -62,7 +62,7 @@ function hasJsonFiles(dirPath) {
     }
 }
 function toPosixPath(filePath) {
-    return filePath.split(external_path_default().sep).join(external_path_default().posix.sep);
+    return filePath.split(external_node_path_default().sep).join(external_node_path_default().posix.sep);
 }
 function getPublicDirOutputPath(publicDir) {
     return (0, server_core_namespaceObject.normalizePublicDirPath)(publicDir);
@@ -89,20 +89,20 @@ function detectLocalesDirectory(appDirectory, normalizedConfig) {
     const publicDirPrefixes = (0, server_core_namespaceObject.getPublicDirRoutePrefixes)(normalizedConfig?.server?.publicDir);
     for(let index = 0; index < publicDirs.length; index++){
         const publicDir = publicDirs[index];
-        if (external_path_default().isAbsolute(publicDir)) continue;
-        const publicDirPath = external_path_default().join(appDirectory, publicDir);
+        if (external_node_path_default().isAbsolute(publicDir)) continue;
+        const publicDirPath = external_node_path_default().join(appDirectory, publicDir);
         const publicDirPrefix = publicDirPrefixes[index] || `/${(0, server_core_namespaceObject.normalizePublicDirPath)(publicDir)}`;
         const publicDirOutputPath = getPublicDirOutputPath(publicDir);
-        if ('locales' === external_path_default().basename((0, server_core_namespaceObject.normalizePublicDirPath)(publicDir)) && hasJsonFiles(publicDirPath)) return buildDetectedLocalesDirectory(publicDirPrefix, `./${publicDirOutputPath}`);
-        const localesPath = external_path_default().join(publicDirPath, 'locales');
+        if ('locales' === external_node_path_default().basename((0, server_core_namespaceObject.normalizePublicDirPath)(publicDir)) && hasJsonFiles(publicDirPath)) return buildDetectedLocalesDirectory(publicDirPrefix, `./${publicDirOutputPath}`);
+        const localesPath = external_node_path_default().join(publicDirPath, 'locales');
         if (hasJsonFiles(localesPath)) return buildDetectedLocalesDirectory(`${publicDirPrefix}/locales`, `./${publicDirOutputPath}/locales`);
     }
-    const configPublicPath = external_path_default().join(appDirectory, 'config', 'public', 'locales');
+    const configPublicPath = external_node_path_default().join(appDirectory, 'config', 'public', 'locales');
     if (hasJsonFiles(configPublicPath)) return buildDetectedLocalesDirectory('/locales', './public/locales', [
         './config/public/locales',
         './public/locales'
     ]);
-    const rootLocalesPath = external_path_default().join(appDirectory, 'locales');
+    const rootLocalesPath = external_node_path_default().join(appDirectory, 'locales');
     if (hasJsonFiles(rootLocalesPath)) return buildDetectedLocalesDirectory('/locales', './locales');
 }
 function applyDetectedBackendPaths(backendOptions, detectedLocales) {

package/dist/cjs/runtime/Link.js

@@ -30,97 +30,16 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     Link: ()=>Link,
     default: ()=>runtime_Link,
-    interpolateRouteParams: ()=>interpolateRouteParams
+    interpolateRouteParams: ()=>external_linkHelpers_js_namespaceObject.interpolateRouteParams
 });
 const jsx_runtime_namespaceObject = require("react/jsx-runtime");
 const external_react_namespaceObject = require("react");
 const external_context_js_namespaceObject = require("./context.js");
+const external_linkHelpers_js_namespaceObject = require("./linkHelpers.js");
 const external_localizedPaths_js_namespaceObject = require("./localizedPaths.js");
 const external_routerAdapter_js_namespaceObject = require("./routerAdapter.js");
 const external_utils_js_namespaceObject = require("./utils.js");
 const EXTERNAL_TARGET_RE = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
-const warnedTargets = new Set();
-const warnOnce = (key, message)=>{
-    if ('development' !== process.env.NODE_ENV || warnedTargets.has(key)) return;
-    warnedTargets.add(key);
-    console.warn(message);
-};
-const interpolateRouteParams = (pathname, params)=>{
-    if (!/[$:*{]/.test(pathname)) return pathname;
-    const resolveParam = (name)=>{
-        const value = params?.[name];
-        return void 0 === value ? void 0 : String(value);
-    };
-    const segments = pathname.split('/').map((segment)=>{
-        if (!segment) return segment;
-        if (segment.startsWith('{-$') && segment.endsWith('}')) {
-            const value = resolveParam(segment.slice(3, -1));
-            return void 0 === value ? null : encodeURIComponent(value);
-        }
-        if ('$' === segment || '*' === segment) {
-            const value = resolveParam('_splat') ?? resolveParam('*');
-            return void 0 === value ? null : value.split('/').map(encodeURIComponent).join('/');
-        }
-        if (segment.startsWith('$')) {
-            const value = resolveParam(segment.slice(1));
-            if (void 0 === value) {
-                warnOnce(`missing-param:${pathname}:${segment}`, `[plugin-i18n] <Link to="${pathname}"> is missing required param "${segment.slice(1)}".`);
-                return segment;
-            }
-            return encodeURIComponent(value);
-        }
-        if (segment.startsWith(':')) {
-            const optional = segment.endsWith('?');
-            const name = segment.slice(1, optional ? -1 : void 0);
-            const value = resolveParam(name);
-            if (void 0 === value) {
-                if (optional) return null;
-                warnOnce(`missing-param:${pathname}:${segment}`, `[plugin-i18n] <Link to="${pathname}"> is missing required param "${name}".`);
-                return segment;
-            }
-            return encodeURIComponent(value);
-        }
-        return segment;
-    }).filter((segment)=>null !== segment);
-    return segments.join('/') || '/';
-};
-const normalizeSearch = (search, searchFromTo)=>{
-    if (search && 'object' == typeof search) {
-        const entries = Object.entries(search).filter(([, value])=>null != value);
-        const searchObject = Object.fromEntries(entries.map(([key, value])=>[
-                key,
-                String(value)
-            ]));
-        const params = new URLSearchParams(searchObject);
-        const serialized = params.toString();
-        return {
-            searchString: serialized ? `?${serialized}` : '',
-            searchObject
-        };
-    }
-    const raw = 'string' == typeof search && search ? search : searchFromTo;
-    if (!raw) return {
-        searchString: '',
-        searchObject: void 0
-    };
-    const searchString = raw.startsWith('?') ? raw : `?${raw}`;
-    const searchObject = {};
-    new URLSearchParams(searchString).forEach((value, key)=>{
-        searchObject[key] = value;
-    });
-    return {
-        searchString,
-        searchObject
-    };
-};
-const splitActiveProps = (active, activeProps)=>{
-    if (!active || !activeProps) return {};
-    return activeProps;
-};
-const mergeClassNames = (...values)=>{
-    const classNames = values.filter((value)=>'string' == typeof value && value.length > 0);
-    return classNames.length > 0 ? classNames.join(' ') : void 0;
-};
 const Link = (props)=>{
     const { to, params, children, hash: hashProp, search: searchProp, hashScrollIntoView, activeOptions, activeProps, prefetch, preload, ...rest } = props;
     const adapter = (0, external_routerAdapter_js_namespaceObject.useI18nRouterAdapter)();
@@ -134,12 +53,12 @@ const Link = (props)=>{
     const target = (0, external_react_namespaceObject.useMemo)(()=>{
         if (isExternal || isBareHash) return null;
         const { pathname, search: searchFromTo, hash: hashFromTo } = (0, external_utils_js_namespaceObject.splitUrlTarget)(to);
-        const interpolated = interpolateRouteParams(pathname || '/', params);
+        const interpolated = (0, external_linkHelpers_js_namespaceObject.interpolateRouteParams)(pathname || '/', params);
         const firstSegment = interpolated.split('/').filter(Boolean)[0];
-        if (firstSegment && supportedLanguages.includes(firstSegment)) warnOnce(`lang-prefix:${to}`, `[plugin-i18n] <Link to="${to}"> starts with a language prefix. Write language-agnostic canonical paths; the Link localizes them automatically.`);
+        if (firstSegment && supportedLanguages.includes(firstSegment)) (0, external_linkHelpers_js_namespaceObject.warnOnce)(`lang-prefix:${to}`, `[plugin-i18n] <Link to="${to}"> starts with a language prefix. Write language-agnostic canonical paths; the Link localizes them automatically.`);
         const localizedPathname = (0, external_utils_js_namespaceObject.buildLocalizedUrl)(interpolated, language, supportedLanguages, localisedUrls);
         const hash = hashProp ?? (hashFromTo ? hashFromTo.slice(1) : '');
-        const { searchString, searchObject } = normalizeSearch(searchProp, searchFromTo);
+        const { searchString, searchObject } = (0, external_linkHelpers_js_namespaceObject.normalizeSearch)(searchProp, searchFromTo);
         return {
             canonicalPathname: interpolated,
             localizedPathname,
@@ -174,7 +93,7 @@ const Link = (props)=>{
         supportedLanguages,
         localisedUrls
     ]);
-    const resolvedActiveProps = splitActiveProps(isActive, activeProps);
+    const resolvedActiveProps = (0, external_linkHelpers_js_namespaceObject.splitActiveProps)(isActive, activeProps);
     const activeAttributes = isActive ? {
         'data-status': 'active',
         'aria-current': rest['aria-current'] ?? resolvedActiveProps['aria-current'] ?? 'page'
@@ -196,7 +115,7 @@ const Link = (props)=>{
             ...anchorProps,
             ...activeRest,
             ...activeAttributes,
-            className: mergeClassNames(rest.className, activeClassName),
+            className: (0, external_linkHelpers_js_namespaceObject.mergeClassNames)(rest.className, activeClassName),
             style: {
                 ...rest.style,
                 ...activeStyle
@@ -205,7 +124,7 @@ const Link = (props)=>{
         });
     }
     const { className: activeClassName, style: activeStyle, ...activeRest } = resolvedActiveProps;
-    const mergedClassName = mergeClassNames(rest.className, activeClassName);
+    const mergedClassName = (0, external_linkHelpers_js_namespaceObject.mergeClassNames)(rest.className, activeClassName);
     const mergedStyle = {
         ...rest.style,
         ...activeStyle

package/dist/cjs/runtime/context.js

@@ -28,15 +28,15 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
+    FederatedI18nBoundary: ()=>FederatedI18nBoundary,
     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_contextHelpers_js_namespaceObject = require("./contextHelpers.js");
+const instance_js_namespaceObject = require("./i18n/instance.js");
 const external_routerAdapter_js_namespaceObject = require("./routerAdapter.js");
-const external_utils_js_namespaceObject = require("./utils.js");
 const modernI18nContextKey = Symbol.for('@modern-js/plugin-i18n/runtime/ModernI18nContext');
 const getModernI18nContext = ()=>{
     const globalStore = globalThis;
@@ -48,76 +48,87 @@ const ModernI18nProvider = ({ children, value })=>/*#__PURE__*/ (0, jsx_runtime_
         value: value,
         children: children
     });
+const FederatedI18nBoundary = ({ children, defaultNamespace, fallbackLanguage, resources, supportedLanguages })=>{
+    const parent = (0, external_react_namespaceObject.useContext)(ModernI18nContext);
+    if (!parent) throw new Error('FederatedI18nBoundary must be used within ModernI18nProvider');
+    const languages = supportedLanguages ?? parent.languages ?? Object.keys(resources);
+    const scopedInstance = (0, external_react_namespaceObject.useMemo)(()=>{
+        const parentInstance = (0, instance_js_namespaceObject.getActualI18nextInstance)(parent.i18nInstance);
+        const clone = parentInstance.cloneInstance?.({
+            defaultNS: defaultNamespace,
+            fallbackLng: fallbackLanguage ?? languages[0] ?? parent.language,
+            forkResourceStore: true,
+            initImmediate: false,
+            lng: parent.language,
+            ns: [
+                defaultNamespace
+            ],
+            resources,
+            supportedLngs: languages
+        });
+        if (!clone) throw new Error('FederatedI18nBoundary requires an i18n instance with cloneInstance support');
+        const resourceStore = clone.store;
+        const parentResourceStore = parentInstance.store;
+        const sharesNestedResourceState = Object.entries(resourceStore?.data ?? {}).some(([language, namespaces])=>{
+            const parentNamespaces = parentResourceStore?.data?.[language];
+            return namespaces === parentNamespaces || Object.entries(namespaces).some(([namespace, resource])=>null !== resource && 'object' == typeof resource && resource === parentNamespaces?.[namespace]);
+        });
+        if (clone === parentInstance || resourceStore === parentResourceStore || resourceStore?.data === parentResourceStore?.data || sharesNestedResourceState) throw new Error('FederatedI18nBoundary cloneInstance did not isolate the host resource store');
+        if (!resourceStore?.addResourceBundle || !clone.removeResourceBundle || !resourceStore.data) throw new Error('FederatedI18nBoundary requires an isolated mutable i18n resource store');
+        for (const [language, namespaces] of Object.entries(resourceStore.data))for (const namespace of Object.keys(namespaces))clone.removeResourceBundle(language, namespace);
+        for (const [language, namespaces] of Object.entries(resources))for (const [namespace, resource] of Object.entries(namespaces))resourceStore.addResourceBundle(language, namespace, resource, true, true);
+        return clone;
+    }, [
+        defaultNamespace,
+        fallbackLanguage,
+        languages,
+        parent.i18nInstance,
+        parent.language,
+        resources
+    ]);
+    const value = (0, external_react_namespaceObject.useMemo)(()=>({
+            ...parent,
+            i18nInstance: scopedInstance,
+            language: parent.language,
+            languages
+        }), [
+        languages,
+        parent,
+        scopedInstance
+    ]);
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(ModernI18nProvider, {
+        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, localisedUrls, updateLanguage } = context;
+    if (!context) throw new Error('useModernI18n must be used within ModernI18nProvider');
+    const { language: contextLanguage, i18nInstance, languages, localePathRedirect, ignoreRedirectRoutes, localisedUrls, updateLanguage, synchronizeLanguage } = context;
     const { navigate, location, hasRouter } = (0, external_routerAdapter_js_namespaceObject.useI18nRouterAdapter)();
-    const pathLanguage = (0, external_react_namespaceObject.useMemo)(()=>{
-        if (!localePathRedirect || !location?.pathname) return;
-        const detected = (0, external_utils_js_namespaceObject.detectLanguageFromPath)(location.pathname, languages || [], localePathRedirect);
-        return detected.detected ? detected.language : void 0;
-    }, [
+    const pathLanguage = (0, external_react_namespaceObject.useMemo)(()=>(0, external_contextHelpers_js_namespaceObject.getPathLanguage)(location?.pathname, languages, localePathRedirect), [
         languages,
         localePathRedirect,
         location?.pathname
     ]);
-    const currentLanguage = pathLanguage || contextLanguage;
     (0, external_react_namespaceObject.useEffect)(()=>{
-        if (!pathLanguage || pathLanguage === contextLanguage) return;
-        updateLanguage?.(pathLanguage);
-        i18nInstance?.setLang?.(pathLanguage);
-        i18nInstance?.changeLanguage?.(pathLanguage);
-        if ((0, runtime_namespaceObject.isBrowser)()) {
-            const detectionOptions = i18nInstance.options?.detection;
-            (0, index_js_namespaceObject.cacheUserLanguage)(i18nInstance, pathLanguage, detectionOptions);
-        }
+        if (pathLanguage) synchronizeLanguage?.(pathLanguage);
     }, [
-        contextLanguage,
-        i18nInstance,
         pathLanguage,
-        updateLanguage
+        synchronizeLanguage
     ]);
-    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 || [], localisedUrls);
-                    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 || [], localisedUrls);
-                    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;
-        }
-    }, [
+    const currentLanguage = contextLanguage;
+    const changeLanguage = (0, external_react_namespaceObject.useCallback)((newLang)=>(0, external_contextHelpers_js_namespaceObject.changeModernI18nLanguage)(newLang, {
+            i18nInstance,
+            updateLanguage,
+            localePathRedirect,
+            ignoreRedirectRoutes,
+            localisedUrls,
+            languages,
+            hasRouter,
+            navigate,
+            location
+        }), [
         i18nInstance,
         updateLanguage,
         localePathRedirect,
@@ -128,40 +139,14 @@ const useModernI18n = ()=>{
         navigate,
         location
     ]);
-    const t = (0, external_react_namespaceObject.useCallback)((key, ...args)=>{
-        if ('function' != typeof i18nInstance.t) throw new Error('i18nInstance.t is required');
-        return i18nInstance.t(key, ...args);
-    }, [
+    const t = (0, external_react_namespaceObject.useCallback)((key, ...args)=>(0, external_contextHelpers_js_namespaceObject.translateI18n)(i18nInstance, key, ...args), [
         currentLanguage,
         i18nInstance
     ]);
-    const isLanguageSupported = (0, external_react_namespaceObject.useCallback)((lang)=>languages?.includes(lang) || false, [
+    const isLanguageSupported = (0, external_react_namespaceObject.useCallback)((lang)=>(0, external_contextHelpers_js_namespaceObject.isI18nLanguageSupported)(languages, lang), [
         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;
-        });
-    }, [
+    const isResourcesReady = (0, external_react_namespaceObject.useMemo)(()=>(0, external_contextHelpers_js_namespaceObject.isI18nResourcesReady)(i18nInstance, currentLanguage), [
         currentLanguage,
         i18nInstance
     ]);
@@ -176,9 +161,11 @@ const useModernI18n = ()=>{
         isResourcesReady
     };
 };
+exports.FederatedI18nBoundary = __webpack_exports__.FederatedI18nBoundary;
 exports.ModernI18nProvider = __webpack_exports__.ModernI18nProvider;
 exports.useModernI18n = __webpack_exports__.useModernI18n;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "FederatedI18nBoundary",
     "ModernI18nProvider",
     "useModernI18n"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];

package/dist/cjs/runtime/contextHelpers.js

@@ -0,0 +1,143 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __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__, {
+    cacheI18nLanguage: ()=>cacheI18nLanguage,
+    changeI18nInstanceLanguage: ()=>changeI18nInstanceLanguage,
+    changeModernI18nLanguage: ()=>changeModernI18nLanguage,
+    getPathLanguage: ()=>getPathLanguage,
+    isI18nLanguageSupported: ()=>isI18nLanguageSupported,
+    isI18nResourcesReady: ()=>isI18nResourcesReady,
+    translateI18n: ()=>translateI18n
+});
+const runtime_namespaceObject = require("@modern-js/runtime");
+const index_js_namespaceObject = require("./i18n/detection/index.js");
+const external_utils_js_namespaceObject = require("./utils.js");
+function getPathLanguage(pathname, languages, localePathRedirect) {
+    if (!localePathRedirect || !pathname) return;
+    const detected = (0, external_utils_js_namespaceObject.detectLanguageFromPath)(pathname, languages || [], localePathRedirect);
+    return detected.detected ? detected.language : void 0;
+}
+function cacheI18nLanguage(i18nInstance, language) {
+    if ((0, runtime_namespaceObject.isBrowser)()) {
+        const detectionOptions = i18nInstance.options?.detection;
+        (0, index_js_namespaceObject.cacheUserLanguage)(i18nInstance, language, detectionOptions);
+    }
+}
+async function changeI18nInstanceLanguage(i18nInstance, language) {
+    if (i18nInstance.setLang) await i18nInstance.setLang(language);
+    else await i18nInstance.changeLanguage?.(language);
+}
+async function changeModernI18nLanguage(newLang, options) {
+    const { i18nInstance, updateLanguage, localePathRedirect, ignoreRedirectRoutes, localisedUrls, languages, hasRouter, navigate, location } = options;
+    try {
+        if (!newLang || 'string' != typeof newLang) throw new Error('Language must be non-empty string');
+        await changeI18nInstanceLanguage(i18nInstance, newLang);
+        cacheI18nLanguage(i18nInstance, newLang);
+        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 void updateLanguage?.(newLang);
+            if (!(0, external_utils_js_namespaceObject.shouldIgnoreRedirect)(relativePath, languages || [], ignoreRedirectRoutes)) {
+                const newPath = (0, external_utils_js_namespaceObject.buildLocalizedUrl)(relativePath, newLang, languages || [], localisedUrls);
+                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 void updateLanguage?.(newLang);
+            if (!(0, external_utils_js_namespaceObject.shouldIgnoreRedirect)(relativePath, languages || [], ignoreRedirectRoutes)) {
+                const newPath = (0, external_utils_js_namespaceObject.buildLocalizedUrl)(relativePath, newLang, languages || [], localisedUrls);
+                const newUrl = entryPath + newPath + window.location.search + window.location.hash;
+                window.history.pushState(null, '', newUrl);
+            }
+        }
+        if (updateLanguage) updateLanguage(newLang);
+    } catch (error) {
+        console.error('Failed change language:', error);
+        throw error;
+    }
+}
+function translateI18n(i18nInstance, key, ...args) {
+    if ('function' != typeof i18nInstance.t) throw new Error('i18nInstance.t required');
+    return i18nInstance.t(key, ...args);
+}
+function isI18nLanguageSupported(languages, lang) {
+    return languages?.includes(lang) || false;
+}
+function isI18nResourcesReady(i18nInstance, currentLanguage) {
+    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;
+    });
+}
+exports.cacheI18nLanguage = __webpack_exports__.cacheI18nLanguage;
+exports.changeI18nInstanceLanguage = __webpack_exports__.changeI18nInstanceLanguage;
+exports.changeModernI18nLanguage = __webpack_exports__.changeModernI18nLanguage;
+exports.getPathLanguage = __webpack_exports__.getPathLanguage;
+exports.isI18nLanguageSupported = __webpack_exports__.isI18nLanguageSupported;
+exports.isI18nResourcesReady = __webpack_exports__.isI18nResourcesReady;
+exports.translateI18n = __webpack_exports__.translateI18n;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "cacheI18nLanguage",
+    "changeI18nInstanceLanguage",
+    "changeModernI18nLanguage",
+    "getPathLanguage",
+    "isI18nLanguageSupported",
+    "isI18nResourcesReady",
+    "translateI18n"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});