@bleedingdev/modern-js-plugin-i18n 3.4.0-ultramodern.2 → 3.4.0-ultramodern.20

package/dist/cjs/runtime/context.js

@@ -37,7 +37,13 @@ const external_react_namespaceObject = require("react");
 const index_js_namespaceObject = require("./i18n/detection/index.js");
 const external_routerAdapter_js_namespaceObject = require("./routerAdapter.js");
 const external_utils_js_namespaceObject = require("./utils.js");
-const ModernI18nContext = /*#__PURE__*/ (0, external_react_namespaceObject.createContext)(null);
+const modernI18nContextKey = Symbol.for('@modern-js/plugin-i18n/runtime/ModernI18nContext');
+const getModernI18nContext = ()=>{
+    const globalStore = globalThis;
+    globalStore[modernI18nContextKey] ??= /*#__PURE__*/ (0, external_react_namespaceObject.createContext)(null);
+    return globalStore[modernI18nContextKey];
+};
+const ModernI18nContext = getModernI18nContext();
 const ModernI18nProvider = ({ children, value })=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(ModernI18nContext.Provider, {
         value: value,
         children: children
@@ -122,6 +128,13 @@ 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);
+    }, [
+        currentLanguage,
+        i18nInstance
+    ]);
     const isLanguageSupported = (0, external_react_namespaceObject.useCallback)((lang)=>languages?.includes(lang) || false, [
         languages
     ]);
@@ -155,6 +168,7 @@ const useModernI18n = ()=>{
     return {
         language: currentLanguage,
         changeLanguage,
+        t,
         i18nInstance,
         supportedLanguages: languages || [],
         localisedUrls,

package/dist/cjs/runtime/core.js

@@ -48,16 +48,28 @@ const external_context_js_namespaceObject = require("./context.js");
 const external_hooks_js_namespaceObject = require("./hooks.js");
 const index_js_namespaceObject = require("./i18n/index.js");
 const backend_index_js_namespaceObject = require("./i18n/backend/index.js");
-const middleware_js_namespaceObject = require("./i18n/backend/middleware.js");
 const detection_index_js_namespaceObject = require("./i18n/detection/index.js");
-const detection_middleware_js_namespaceObject = require("./i18n/detection/middleware.js");
+const middleware_js_namespaceObject = require("./i18n/detection/middleware.js");
 const instance_js_namespaceObject = require("./i18n/instance.js");
-const utils_js_namespaceObject = require("./i18n/utils.js");
 const external_utils_js_namespaceObject = require("./utils.js");
 require("./types.js");
 const external_I18nLink_js_namespaceObject = require("./I18nLink.js");
 const external_Link_js_namespaceObject = require("./Link.js");
 const external_localizedPaths_js_namespaceObject = require("./localizedPaths.js");
+let i18nLifecycleHelpersPromise;
+function loadI18nLifecycleHelpers() {
+    i18nLifecycleHelpersPromise ??= Promise.all([
+        import("./i18n/backend/middleware.js"),
+        import("./i18n/utils.js")
+    ]).then(([backendMiddleware, utils])=>({
+            useI18nextBackend: backendMiddleware.useI18nextBackend,
+            changeI18nLanguage: utils.changeI18nLanguage,
+            ensureLanguageMatch: utils.ensureLanguageMatch,
+            initializeI18nInstance: utils.initializeI18nInstance,
+            setupClonedInstance: utils.setupClonedInstance
+        }));
+    return i18nLifecycleHelpersPromise;
+}
 const createI18nPlugin = (loadReactI18nextIntegration)=>(options)=>({
             name: '@modern-js/plugin-i18n',
             setup: (api)=>{
@@ -71,6 +83,7 @@ const createI18nPlugin = (loadReactI18nextIntegration)=>(options)=>({
                     return loadReactI18nextIntegration?.() ?? null;
                 };
                 api.onBeforeRender(async (context)=>{
+                    const { useI18nextBackend, changeI18nLanguage, ensureLanguageMatch, initializeI18nInstance, setupClonedInstance } = await loadI18nLifecycleHelpers();
                     let i18nInstance = await (0, index_js_namespaceObject.getI18nInstance)(userI18nInstance);
                     const { i18n: otherConfig } = api.getRuntimeConfig();
                     const { initOptions: otherInitOptions } = otherConfig || {};
@@ -79,11 +92,11 @@ const createI18nPlugin = (loadReactI18nextIntegration)=>(options)=>({
                     I18nextProvider = reactI18nextIntegration?.I18nextProvider ?? null;
                     if (reactI18nextIntegration?.initReactI18next) i18nInstance.use(reactI18nextIntegration.initReactI18next);
                     const pathname = (0, external_utils_js_namespaceObject.getPathname)(context);
-                    if (i18nextDetector) (0, detection_middleware_js_namespaceObject.useI18nextLanguageDetector)(i18nInstance);
+                    if (i18nextDetector) (0, middleware_js_namespaceObject.useI18nextLanguageDetector)(i18nInstance);
                     const mergedDetection = (0, detection_index_js_namespaceObject.mergeDetectionOptions)(i18nextDetector, detection, localePathRedirect, userInitOptions);
                     const mergedBackend = (0, backend_index_js_namespaceObject.mergeBackendOptions)(backend, userInitOptions);
                     const hasSdkConfig = 'function' == typeof userInitOptions?.backend?.sdk || mergedBackend?.sdk && 'function' == typeof mergedBackend.sdk;
-                    if (mergedBackend && (backendEnabled || hasSdkConfig)) (0, middleware_js_namespaceObject.useI18nextBackend)(i18nInstance, mergedBackend);
+                    if (mergedBackend && (backendEnabled || hasSdkConfig)) useI18nextBackend(i18nInstance, mergedBackend);
                     const { finalLanguage } = await (0, detection_index_js_namespaceObject.detectLanguageWithPriority)(i18nInstance, {
                         languages,
                         fallbackLanguage,
@@ -95,17 +108,17 @@ const createI18nPlugin = (loadReactI18nextIntegration)=>(options)=>({
                         pathname,
                         ssrContext: context.ssrContext
                     });
-                    await (0, utils_js_namespaceObject.initializeI18nInstance)(i18nInstance, finalLanguage, fallbackLanguage, languages, mergedDetection, mergedBackend, userInitOptions);
+                    await initializeI18nInstance(i18nInstance, finalLanguage, fallbackLanguage, languages, mergedDetection, mergedBackend, userInitOptions);
                     if (!(0, runtime_namespaceObject.isBrowser)() && i18nInstance.cloneInstance) {
                         i18nInstance = i18nInstance.cloneInstance();
-                        await (0, utils_js_namespaceObject.setupClonedInstance)(i18nInstance, finalLanguage, fallbackLanguage, languages, backendEnabled, backend, i18nextDetector, detection, localePathRedirect, userInitOptions);
+                        await setupClonedInstance(i18nInstance, finalLanguage, fallbackLanguage, languages, backendEnabled, backend, i18nextDetector, detection, localePathRedirect, userInitOptions);
                     }
-                    if (localePathRedirect) await (0, utils_js_namespaceObject.ensureLanguageMatch)(i18nInstance, finalLanguage);
+                    if (localePathRedirect) await ensureLanguageMatch(i18nInstance, finalLanguage);
                     if (!(0, runtime_namespaceObject.isBrowser)()) (0, detection_index_js_namespaceObject.exportServerLngToWindow)(context, finalLanguage);
                     context.i18nInstance = i18nInstance;
                     latestI18nInstance = i18nInstance;
                     context.changeLanguage = async (newLang)=>{
-                        await (0, utils_js_namespaceObject.changeI18nLanguage)(i18nInstance, newLang, {
+                        await changeI18nLanguage(i18nInstance, newLang, {
                             detectionOptions: mergedDetection
                         });
                     };

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

@@ -39,22 +39,40 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     FsBackendWithSave: ()=>FsBackendWithSave,
     HttpBackendWithSave: ()=>HttpBackendWithSave,
+    resolveFsBackendConstructor: ()=>resolveFsBackendConstructor,
     useI18nextBackend: ()=>useI18nextBackend
 });
-const cjs_namespaceObject = require("i18next-fs-backend/cjs");
-var cjs_default = /*#__PURE__*/ __webpack_require__.n(cjs_namespaceObject);
+const external_i18next_fs_backend_namespaceObject = require("i18next-fs-backend");
+var external_i18next_fs_backend_default = /*#__PURE__*/ __webpack_require__.n(external_i18next_fs_backend_namespaceObject);
 const external_middleware_common_js_namespaceObject = require("./middleware.common.js");
-class FsBackendWithSave extends cjs_default() {
+const resolveFsBackendConstructor = (backendModule)=>{
+    const nestedDefault = backendModule?.default?.default;
+    const nestedModuleExports = backendModule?.default?.['module.exports'];
+    const candidates = [
+        backendModule,
+        backendModule?.default,
+        backendModule?.['module.exports'],
+        nestedDefault,
+        nestedModuleExports
+    ];
+    const Backend = candidates.find((candidate)=>'function' == typeof candidate);
+    if (!Backend) throw new Error('Failed to resolve i18next-fs-backend constructor for the i18n Node backend.');
+    return Backend;
+};
+const middleware_node_Backend = resolveFsBackendConstructor(external_i18next_fs_backend_default());
+class FsBackendWithSave extends middleware_node_Backend {
     save(_language, _namespace, _data) {}
 }
 const HttpBackendWithSave = FsBackendWithSave;
-const useI18nextBackend = (i18nInstance, backend)=>(0, external_middleware_common_js_namespaceObject.useI18nextBackendCommon)(i18nInstance, FsBackendWithSave, cjs_default(), backend);
+const useI18nextBackend = (i18nInstance, backend)=>(0, external_middleware_common_js_namespaceObject.useI18nextBackendCommon)(i18nInstance, FsBackendWithSave, middleware_node_Backend, backend);
 exports.FsBackendWithSave = __webpack_exports__.FsBackendWithSave;
 exports.HttpBackendWithSave = __webpack_exports__.HttpBackendWithSave;
+exports.resolveFsBackendConstructor = __webpack_exports__.resolveFsBackendConstructor;
 exports.useI18nextBackend = __webpack_exports__.useI18nextBackend;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "FsBackendWithSave",
     "HttpBackendWithSave",
+    "resolveFsBackendConstructor",
     "useI18nextBackend"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

package/dist/esm/runtime/context.mjs

@@ -4,7 +4,13 @@ import { createContext, useCallback, useContext, useEffect, useMemo } from "reac
 import { cacheUserLanguage } from "./i18n/detection/index.mjs";
 import { useI18nRouterAdapter } from "./routerAdapter.mjs";
 import { buildLocalizedUrl, detectLanguageFromPath, getEntryPath, shouldIgnoreRedirect } from "./utils.mjs";
-const ModernI18nContext = /*#__PURE__*/ createContext(null);
+const modernI18nContextKey = Symbol.for('@modern-js/plugin-i18n/runtime/ModernI18nContext');
+const getModernI18nContext = ()=>{
+    const globalStore = globalThis;
+    globalStore[modernI18nContextKey] ??= /*#__PURE__*/ createContext(null);
+    return globalStore[modernI18nContextKey];
+};
+const ModernI18nContext = getModernI18nContext();
 const ModernI18nProvider = ({ children, value })=>/*#__PURE__*/ jsx(ModernI18nContext.Provider, {
         value: value,
         children: children
@@ -89,6 +95,13 @@ const useModernI18n = ()=>{
         navigate,
         location
     ]);
+    const t = useCallback((key, ...args)=>{
+        if ('function' != typeof i18nInstance.t) throw new Error('i18nInstance.t is required');
+        return i18nInstance.t(key, ...args);
+    }, [
+        currentLanguage,
+        i18nInstance
+    ]);
     const isLanguageSupported = useCallback((lang)=>languages?.includes(lang) || false, [
         languages
     ]);
@@ -122,6 +135,7 @@ const useModernI18n = ()=>{
     return {
         language: currentLanguage,
         changeLanguage,
+        t,
         i18nInstance,
         supportedLanguages: languages || [],
         localisedUrls,

package/dist/esm/runtime/core.mjs

@@ -7,13 +7,25 @@ import { ModernI18nProvider, useModernI18n } from "./context.mjs";
 import { createContextValue, useClientSideRedirect, useLanguageSync, useSdkResourcesLoader } from "./hooks.mjs";
 import { getI18nInstance } from "./i18n/index.mjs";
 import { mergeBackendOptions } from "./i18n/backend/index.mjs";
-import { useI18nextBackend } from "./i18n/backend/middleware.mjs";
 import { detectLanguageWithPriority, exportServerLngToWindow, mergeDetectionOptions } from "./i18n/detection/index.mjs";
 import { useI18nextLanguageDetector } from "./i18n/detection/middleware.mjs";
 import { getI18nextInstanceForProvider } from "./i18n/instance.mjs";
-import { changeI18nLanguage, ensureLanguageMatch, initializeI18nInstance, setupClonedInstance } from "./i18n/utils.mjs";
 import { buildLocalizedUrl, getPathname, splitUrlTarget } from "./utils.mjs";
 import "./types.mjs";
+let i18nLifecycleHelpersPromise;
+function loadI18nLifecycleHelpers() {
+    i18nLifecycleHelpersPromise ??= Promise.all([
+        import("./i18n/backend/middleware.mjs"),
+        import("./i18n/utils.mjs")
+    ]).then(([backendMiddleware, utils])=>({
+            useI18nextBackend: backendMiddleware.useI18nextBackend,
+            changeI18nLanguage: utils.changeI18nLanguage,
+            ensureLanguageMatch: utils.ensureLanguageMatch,
+            initializeI18nInstance: utils.initializeI18nInstance,
+            setupClonedInstance: utils.setupClonedInstance
+        }));
+    return i18nLifecycleHelpersPromise;
+}
 const createI18nPlugin = (loadReactI18nextIntegration)=>(options)=>({
             name: '@modern-js/plugin-i18n',
             setup: (api)=>{
@@ -27,6 +39,7 @@ const createI18nPlugin = (loadReactI18nextIntegration)=>(options)=>({
                     return loadReactI18nextIntegration?.() ?? null;
                 };
                 api.onBeforeRender(async (context)=>{
+                    const { useI18nextBackend, changeI18nLanguage, ensureLanguageMatch, initializeI18nInstance, setupClonedInstance } = await loadI18nLifecycleHelpers();
                     let i18nInstance = await getI18nInstance(userI18nInstance);
                     const { i18n: otherConfig } = api.getRuntimeConfig();
                     const { initOptions: otherInitOptions } = otherConfig || {};

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

@@ -1,8 +1,23 @@
-import cjs from "i18next-fs-backend/cjs";
+import i18next_fs_backend from "i18next-fs-backend";
 import { useI18nextBackendCommon } from "./middleware.common.mjs";
-class FsBackendWithSave extends cjs {
+const resolveFsBackendConstructor = (backendModule)=>{
+    const nestedDefault = backendModule?.default?.default;
+    const nestedModuleExports = backendModule?.default?.['module.exports'];
+    const candidates = [
+        backendModule,
+        backendModule?.default,
+        backendModule?.['module.exports'],
+        nestedDefault,
+        nestedModuleExports
+    ];
+    const Backend = candidates.find((candidate)=>'function' == typeof candidate);
+    if (!Backend) throw new Error('Failed to resolve i18next-fs-backend constructor for the i18n Node backend.');
+    return Backend;
+};
+const middleware_node_Backend = resolveFsBackendConstructor(i18next_fs_backend);
+class FsBackendWithSave extends middleware_node_Backend {
     save(_language, _namespace, _data) {}
 }
 const HttpBackendWithSave = FsBackendWithSave;
-const useI18nextBackend = (i18nInstance, backend)=>useI18nextBackendCommon(i18nInstance, FsBackendWithSave, cjs, backend);
-export { FsBackendWithSave, HttpBackendWithSave, useI18nextBackend };
+const useI18nextBackend = (i18nInstance, backend)=>useI18nextBackendCommon(i18nInstance, FsBackendWithSave, middleware_node_Backend, backend);
+export { FsBackendWithSave, HttpBackendWithSave, resolveFsBackendConstructor, useI18nextBackend };

package/dist/esm-node/runtime/context.mjs

@@ -5,7 +5,13 @@ import { createContext, useCallback, useContext, useEffect, useMemo } from "reac
 import { cacheUserLanguage } from "./i18n/detection/index.mjs";
 import { useI18nRouterAdapter } from "./routerAdapter.mjs";
 import { buildLocalizedUrl, detectLanguageFromPath, getEntryPath, shouldIgnoreRedirect } from "./utils.mjs";
-const ModernI18nContext = /*#__PURE__*/ createContext(null);
+const modernI18nContextKey = Symbol.for('@modern-js/plugin-i18n/runtime/ModernI18nContext');
+const getModernI18nContext = ()=>{
+    const globalStore = globalThis;
+    globalStore[modernI18nContextKey] ??= /*#__PURE__*/ createContext(null);
+    return globalStore[modernI18nContextKey];
+};
+const ModernI18nContext = getModernI18nContext();
 const ModernI18nProvider = ({ children, value })=>/*#__PURE__*/ jsx(ModernI18nContext.Provider, {
         value: value,
         children: children
@@ -90,6 +96,13 @@ const useModernI18n = ()=>{
         navigate,
         location
     ]);
+    const t = useCallback((key, ...args)=>{
+        if ('function' != typeof i18nInstance.t) throw new Error('i18nInstance.t is required');
+        return i18nInstance.t(key, ...args);
+    }, [
+        currentLanguage,
+        i18nInstance
+    ]);
     const isLanguageSupported = useCallback((lang)=>languages?.includes(lang) || false, [
         languages
     ]);
@@ -123,6 +136,7 @@ const useModernI18n = ()=>{
     return {
         language: currentLanguage,
         changeLanguage,
+        t,
         i18nInstance,
         supportedLanguages: languages || [],
         localisedUrls,

package/dist/esm-node/runtime/core.mjs

@@ -8,13 +8,25 @@ import { ModernI18nProvider, useModernI18n } from "./context.mjs";
 import { createContextValue, useClientSideRedirect, useLanguageSync, useSdkResourcesLoader } from "./hooks.mjs";
 import { getI18nInstance } from "./i18n/index.mjs";
 import { mergeBackendOptions } from "./i18n/backend/index.mjs";
-import { useI18nextBackend } from "./i18n/backend/middleware.mjs";
 import { detectLanguageWithPriority, exportServerLngToWindow, mergeDetectionOptions } from "./i18n/detection/index.mjs";
 import { useI18nextLanguageDetector } from "./i18n/detection/middleware.mjs";
 import { getI18nextInstanceForProvider } from "./i18n/instance.mjs";
-import { changeI18nLanguage, ensureLanguageMatch, initializeI18nInstance, setupClonedInstance } from "./i18n/utils.mjs";
 import { buildLocalizedUrl, getPathname, splitUrlTarget } from "./utils.mjs";
 import "./types.mjs";
+let i18nLifecycleHelpersPromise;
+function loadI18nLifecycleHelpers() {
+    i18nLifecycleHelpersPromise ??= Promise.all([
+        import("./i18n/backend/middleware.mjs"),
+        import("./i18n/utils.mjs")
+    ]).then(([backendMiddleware, utils])=>({
+            useI18nextBackend: backendMiddleware.useI18nextBackend,
+            changeI18nLanguage: utils.changeI18nLanguage,
+            ensureLanguageMatch: utils.ensureLanguageMatch,
+            initializeI18nInstance: utils.initializeI18nInstance,
+            setupClonedInstance: utils.setupClonedInstance
+        }));
+    return i18nLifecycleHelpersPromise;
+}
 const createI18nPlugin = (loadReactI18nextIntegration)=>(options)=>({
             name: '@modern-js/plugin-i18n',
             setup: (api)=>{
@@ -28,6 +40,7 @@ const createI18nPlugin = (loadReactI18nextIntegration)=>(options)=>({
                     return loadReactI18nextIntegration?.() ?? null;
                 };
                 api.onBeforeRender(async (context)=>{
+                    const { useI18nextBackend, changeI18nLanguage, ensureLanguageMatch, initializeI18nInstance, setupClonedInstance } = await loadI18nLifecycleHelpers();
                     let i18nInstance = await getI18nInstance(userI18nInstance);
                     const { i18n: otherConfig } = api.getRuntimeConfig();
                     const { initOptions: otherInitOptions } = otherConfig || {};

package/dist/esm-node/runtime/i18n/backend/middleware.node.mjs

@@ -1,9 +1,24 @@
 import "node:module";
-import cjs from "i18next-fs-backend/cjs";
+import i18next_fs_backend from "i18next-fs-backend";
 import { useI18nextBackendCommon } from "./middleware.common.mjs";
-class FsBackendWithSave extends cjs {
+const resolveFsBackendConstructor = (backendModule)=>{
+    const nestedDefault = backendModule?.default?.default;
+    const nestedModuleExports = backendModule?.default?.['module.exports'];
+    const candidates = [
+        backendModule,
+        backendModule?.default,
+        backendModule?.['module.exports'],
+        nestedDefault,
+        nestedModuleExports
+    ];
+    const Backend = candidates.find((candidate)=>'function' == typeof candidate);
+    if (!Backend) throw new Error('Failed to resolve i18next-fs-backend constructor for the i18n Node backend.');
+    return Backend;
+};
+const middleware_node_Backend = resolveFsBackendConstructor(i18next_fs_backend);
+class FsBackendWithSave extends middleware_node_Backend {
     save(_language, _namespace, _data) {}
 }
 const HttpBackendWithSave = FsBackendWithSave;
-const useI18nextBackend = (i18nInstance, backend)=>useI18nextBackendCommon(i18nInstance, FsBackendWithSave, cjs, backend);
-export { FsBackendWithSave, HttpBackendWithSave, useI18nextBackend };
+const useI18nextBackend = (i18nInstance, backend)=>useI18nextBackendCommon(i18nInstance, FsBackendWithSave, middleware_node_Backend, backend);
+export { FsBackendWithSave, HttpBackendWithSave, resolveFsBackendConstructor, useI18nextBackend };

package/dist/types/runtime/context.d.ts

@@ -19,6 +19,7 @@ export declare const ModernI18nProvider: FC<ModernI18nProviderProps>;
 export interface UseModernI18nReturn {
     language: string;
     changeLanguage: (newLang: string) => Promise<void>;
+    t: (key: string | string[], ...args: any[]) => string;
     i18nInstance: I18nInstance;
     supportedLanguages: string[];
     localisedUrls?: LocalisedUrlsOption;

package/dist/types/runtime/i18n/backend/middleware.node.d.ts

@@ -1,6 +1,8 @@
-import Backend from 'i18next-fs-backend/cjs';
 import type { ExtendedBackendOptions } from '../../../shared/type';
 import type { I18nInstance } from '../instance';
+type BackendConstructor = new (...args: any[]) => any;
+export declare const resolveFsBackendConstructor: (backendModule: unknown) => BackendConstructor;
+declare const Backend: BackendConstructor;
 /**
  * Wrapper for FS backend to add a no-op save method
  * This is required for i18next-chained-backend to trigger refresh logic
@@ -11,3 +13,4 @@ export declare class FsBackendWithSave extends Backend {
 }
 export declare const HttpBackendWithSave: typeof FsBackendWithSave;
 export declare const useI18nextBackend: (i18nInstance: I18nInstance, backend?: ExtendedBackendOptions) => void;
+export {};

package/package.json

@@ -17,7 +17,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "3.4.0-ultramodern.2",
+  "version": "3.4.0-ultramodern.20",
   "engines": {
     "node": ">=20"
   },
@@ -97,15 +97,15 @@
     "i18next-fs-backend": "^2.6.6",
     "i18next-http-backend": "^4.0.0",
     "i18next-http-middleware": "^3.9.7",
-    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.4.0-ultramodern.2",
-    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.4.0-ultramodern.2",
-    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.4.0-ultramodern.2",
-    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.4.0-ultramodern.2",
-    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.4.0-ultramodern.2",
-    "@modern-js/server-runtime": "npm:@bleedingdev/modern-js-server-runtime@3.4.0-ultramodern.2"
+    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.4.0-ultramodern.20",
+    "@modern-js/server-runtime": "npm:@bleedingdev/modern-js-server-runtime@3.4.0-ultramodern.20",
+    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.4.0-ultramodern.20",
+    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.4.0-ultramodern.20",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.4.0-ultramodern.20",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.4.0-ultramodern.20"
   },
   "peerDependencies": {
-    "@modern-js/runtime": "3.4.0-ultramodern.2",
+    "@modern-js/runtime": "3.4.0-ultramodern.20",
     "i18next": ">=26.3.1",
     "react": "^19.2.7",
     "react-dom": "^19.2.7",
@@ -129,8 +129,8 @@
     "react-i18next": "17.0.8",
     "ts-node": "^10.9.2",
     "typescript": "^6.0.3",
-    "@modern-js/app-tools": "npm:@bleedingdev/modern-js-app-tools@3.4.0-ultramodern.2",
-    "@modern-js/runtime": "npm:@bleedingdev/modern-js-runtime@3.4.0-ultramodern.2"
+    "@modern-js/app-tools": "npm:@bleedingdev/modern-js-app-tools@3.4.0-ultramodern.20",
+    "@modern-js/runtime": "npm:@bleedingdev/modern-js-runtime@3.4.0-ultramodern.20"
   },
   "sideEffects": false,
   "publishConfig": {

package/src/runtime/context.tsx

@@ -32,7 +32,24 @@ export interface ModernI18nContextValue {
   updateLanguage?: (newLang: string) => void;
 }
 
-const ModernI18nContext = createContext<ModernI18nContextValue | null>(null);
+const modernI18nContextKey = Symbol.for(
+  '@modern-js/plugin-i18n/runtime/ModernI18nContext',
+);
+
+type ModernI18nGlobal = typeof globalThis & {
+  [key: symbol]:
+    | ReturnType<typeof createContext<ModernI18nContextValue | null>>
+    | undefined;
+};
+
+const getModernI18nContext = () => {
+  const globalStore = globalThis as ModernI18nGlobal;
+  globalStore[modernI18nContextKey] ??=
+    createContext<ModernI18nContextValue | null>(null);
+  return globalStore[modernI18nContextKey];
+};
+
+const ModernI18nContext = getModernI18nContext();
 
 export interface ModernI18nProviderProps {
   children: ReactNode;
@@ -53,6 +70,7 @@ export const ModernI18nProvider: FC<ModernI18nProviderProps> = ({
 export interface UseModernI18nReturn {
   language: string;
   changeLanguage: (newLang: string) => Promise<void>;
+  t: (key: string | string[], ...args: any[]) => string;
   i18nInstance: I18nInstance;
   supportedLanguages: string[];
   localisedUrls?: LocalisedUrlsOption;
@@ -250,6 +268,17 @@ export const useModernI18n = (): UseModernI18nReturn => {
     ],
   );
 
+  const t = useCallback(
+    (key: string | string[], ...args: any[]) => {
+      if (typeof i18nInstance.t !== 'function') {
+        throw new Error('i18nInstance.t is required');
+      }
+
+      return i18nInstance.t(key, ...args) as string;
+    },
+    [currentLanguage, i18nInstance],
+  );
+
   // Helper function to check if a language is supported
   const isLanguageSupported = useCallback(
     (lang: string) => {
@@ -310,6 +339,7 @@ export const useModernI18n = (): UseModernI18nReturn => {
   return {
     language: currentLanguage,
     changeLanguage,
+    t,
     i18nInstance,
     supportedLanguages: languages || [],
     localisedUrls,

package/src/runtime/core.tsx

@@ -22,7 +22,6 @@ import {
 import type { I18nInitOptions, I18nInstance } from './i18n';
 import { getI18nInstance } from './i18n';
 import { mergeBackendOptions } from './i18n/backend';
-import { useI18nextBackend } from './i18n/backend/middleware';
 import {
   detectLanguageWithPriority,
   exportServerLngToWindow,
@@ -30,18 +29,37 @@ import {
 } from './i18n/detection';
 import { useI18nextLanguageDetector } from './i18n/detection/middleware';
 import { getI18nextInstanceForProvider } from './i18n/instance';
-import {
-  changeI18nLanguage,
-  ensureLanguageMatch,
-  initializeI18nInstance,
-  setupClonedInstance,
-} from './i18n/utils';
 import { getPathname } from './utils';
 import './types';
 
 export type { I18nSdkLoader, I18nSdkLoadOptions } from '../shared/type';
 export type { Resources } from './i18n/instance';
 
+type I18nLifecycleHelpers = {
+  useI18nextBackend: typeof import('./i18n/backend/middleware')['useI18nextBackend'];
+  changeI18nLanguage: typeof import('./i18n/utils')['changeI18nLanguage'];
+  ensureLanguageMatch: typeof import('./i18n/utils')['ensureLanguageMatch'];
+  initializeI18nInstance: typeof import('./i18n/utils')['initializeI18nInstance'];
+  setupClonedInstance: typeof import('./i18n/utils')['setupClonedInstance'];
+};
+
+let i18nLifecycleHelpersPromise: Promise<I18nLifecycleHelpers> | undefined;
+
+function loadI18nLifecycleHelpers(): Promise<I18nLifecycleHelpers> {
+  i18nLifecycleHelpersPromise ??= Promise.all([
+    import('./i18n/backend/middleware'),
+    import('./i18n/utils'),
+  ]).then(([backendMiddleware, utils]) => ({
+    useI18nextBackend: backendMiddleware.useI18nextBackend,
+    changeI18nLanguage: utils.changeI18nLanguage,
+    ensureLanguageMatch: utils.ensureLanguageMatch,
+    initializeI18nInstance: utils.initializeI18nInstance,
+    setupClonedInstance: utils.setupClonedInstance,
+  }));
+
+  return i18nLifecycleHelpersPromise;
+}
+
 export interface I18nPluginOptions {
   entryName?: string;
   localeDetection?: BaseLocaleDetectionOptions;
@@ -104,6 +122,13 @@ export const createI18nPlugin =
       };
 
       api.onBeforeRender(async context => {
+        const {
+          useI18nextBackend,
+          changeI18nLanguage,
+          ensureLanguageMatch,
+          initializeI18nInstance,
+          setupClonedInstance,
+        } = await loadI18nLifecycleHelpers();
         let i18nInstance = await getI18nInstance(userI18nInstance);
         const { i18n: otherConfig } = api.getRuntimeConfig();
         const { initOptions: otherInitOptions } = otherConfig || {};

package/src/runtime/i18n/backend/middleware.node.ts

@@ -1,8 +1,38 @@
-import Backend from 'i18next-fs-backend/cjs';
+import FsBackendModule from 'i18next-fs-backend';
 import type { ExtendedBackendOptions } from '../../../shared/type';
 import type { I18nInstance } from '../instance';
 import { useI18nextBackendCommon } from './middleware.common';
 
+type BackendConstructor = new (...args: any[]) => any;
+
+export const resolveFsBackendConstructor = (
+  backendModule: unknown,
+): BackendConstructor => {
+  const nestedDefault = (backendModule as { default?: { default?: unknown } })
+    ?.default?.default;
+  const nestedModuleExports = (
+    backendModule as { default?: { 'module.exports'?: unknown } }
+  )?.default?.['module.exports'];
+  const candidates = [
+    backendModule,
+    (backendModule as { default?: unknown })?.default,
+    (backendModule as { 'module.exports'?: unknown })?.['module.exports'],
+    nestedDefault,
+    nestedModuleExports,
+  ];
+  const Backend = candidates.find(candidate => typeof candidate === 'function');
+
+  if (!Backend) {
+    throw new Error(
+      'Failed to resolve i18next-fs-backend constructor for the i18n Node backend.',
+    );
+  }
+
+  return Backend as BackendConstructor;
+};
+
+const Backend = resolveFsBackendConstructor(FsBackendModule);
+
 /**
  * Wrapper for FS backend to add a no-op save method
  * This is required for i18next-chained-backend to trigger refresh logic

package/tests/i18nUtils.test.ts

@@ -4,6 +4,10 @@ import {
   DEFAULT_I18NEXT_BACKEND_OPTIONS as NODE_DEFAULT_I18NEXT_BACKEND_OPTIONS,
   resolveDefaultLocalesDir,
 } from '../src/runtime/i18n/backend/defaults.node';
+import {
+  FsBackendWithSave,
+  resolveFsBackendConstructor,
+} from '../src/runtime/i18n/backend/middleware.node';
 import { initializeI18nInstance } from '../src/runtime/i18n/utils';
 
 function createBackendI18nInstance(): I18nInstance {
@@ -20,6 +24,36 @@ function createBackendI18nInstance(): I18nInstance {
 }
 
 describe('i18n runtime utils', () => {
+  test('normalizes node fs backend CJS and ESM namespace shapes', () => {
+    class FakeBackend {}
+
+    expect(resolveFsBackendConstructor(FakeBackend)).toBe(FakeBackend);
+    expect(resolveFsBackendConstructor({ default: FakeBackend })).toBe(
+      FakeBackend,
+    );
+    expect(resolveFsBackendConstructor({ 'module.exports': FakeBackend })).toBe(
+      FakeBackend,
+    );
+    expect(
+      resolveFsBackendConstructor({ default: { default: FakeBackend } }),
+    ).toBe(FakeBackend);
+    expect(
+      resolveFsBackendConstructor({
+        default: { 'module.exports': FakeBackend },
+      }),
+    ).toBe(FakeBackend);
+  });
+
+  test('node fs backend wrapper extends a resolved constructor', () => {
+    const backend = new FsBackendWithSave({}, {}, {}) as {
+      type?: string;
+      save: (language: string, namespace: string, data: unknown) => void;
+    };
+
+    expect(backend.type).toBe('backend');
+    expect(() => backend.save('en', 'translation', {})).not.toThrow();
+  });
+
   test('node fs backend defaults follow the detected locales directory', () => {
     // The default must match whichever conventional root exists at runtime
     // (./locales first, then ./config/public/locales), mirroring the CLI

package/tests/reactI18nextRuntimeBoundary.test.ts

@@ -19,6 +19,24 @@ describe('react-i18next runtime boundary', () => {
     expect(core).not.toContain("import('react-i18next')");
   });
 
+  test('keeps the runtime plugin factory entry synchronous for federation', () => {
+    const core = readRuntimeSource('core.tsx');
+
+    expect(core).not.toContain("from './i18n/backend/middleware'");
+    expect(core).not.toContain("from './i18n/utils'");
+    expect(core).toContain("import('./i18n/backend/middleware')");
+    expect(core).toContain("import('./i18n/utils')");
+  });
+
+  test('keeps the Modern i18n context stable across federated runtime copies', () => {
+    const context = readRuntimeSource('context.tsx');
+
+    expect(context).toContain(
+      "Symbol.for(\n  '@modern-js/plugin-i18n/runtime/ModernI18nContext'",
+    );
+    expect(context).toContain('globalStore[modernI18nContextKey] ??=');
+  });
+
   test('keeps the default runtime entry wired to react-i18next integration', () => {
     const defaultEntry = readRuntimeSource('index.tsx');
 

package/tests/routerAdapter.test.tsx

@@ -5,7 +5,7 @@ import {
 } from '@modern-js/runtime/context';
 import type React from 'react';
 import type { ComponentType, PropsWithChildren } from 'react';
-import { act } from 'react';
+import { act, useState } from 'react';
 import { createRoot, type Root } from 'react-dom/client';
 import { i18nPlugin } from '../src/runtime';
 import { ModernI18nProvider, useModernI18n } from '../src/runtime/context';
@@ -453,4 +453,61 @@ describe('i18n router adapter', () => {
       replace: true,
     });
   });
+
+  test('exposes a language-scoped t function for rendered copy', async () => {
+    const i18nInstance = createI18nInstance('en');
+    i18nInstance.t = (key: string) => `${i18nInstance.language}:${key}`;
+    const renderTranslations: Array<(key: string) => string> = [];
+    let setProviderLanguage: ((language: string) => void) | undefined;
+
+    const StatefulI18nProvider = ({ children }: PropsWithChildren) => {
+      const [language, setLanguage] = useState('en');
+      setProviderLanguage = setLanguage;
+
+      return (
+        <ModernI18nProvider
+          value={{
+            language,
+            i18nInstance,
+            languages: ['en', 'cs'],
+            localePathRedirect: true,
+            localisedUrls,
+            updateLanguage: setLanguage,
+          }}
+        >
+          {children}
+        </ModernI18nProvider>
+      );
+    };
+
+    const Harness = () => {
+      const { t } = useModernI18n();
+      renderTranslations.push(t);
+      return <span data-testid="translation">{t('key')}</span>;
+    };
+
+    rendered = await renderWithRuntime(
+      <StatefulI18nProvider>
+        <Harness />
+      </StatefulI18nProvider>,
+      createReactRouterRuntimeContext({ navigate: rstest.fn() }),
+    );
+
+    expect(
+      rendered.container.querySelector('[data-testid="translation"]')
+        ?.textContent,
+    ).toBe('en:key');
+    const initialT = renderTranslations.at(-1);
+
+    await act(async () => {
+      i18nInstance.language = 'cs';
+      setProviderLanguage?.('cs');
+    });
+
+    expect(
+      rendered.container.querySelector('[data-testid="translation"]')
+        ?.textContent,
+    ).toBe('cs:key');
+    expect(renderTranslations.at(-1)).not.toBe(initialT);
+  });
 });