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

package/dist/cjs/runtime/context.js

@@ -122,6 +122,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 +162,7 @@ const useModernI18n = ()=>{
     return {
         language: currentLanguage,
         changeLanguage,
+        t,
         i18nInstance,
         supportedLanguages: languages || [],
         localisedUrls,

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

@@ -89,6 +89,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 +129,7 @@ const useModernI18n = ()=>{
     return {
         language: currentLanguage,
         changeLanguage,
+        t,
         i18nInstance,
         supportedLanguages: languages || [],
         localisedUrls,

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

@@ -90,6 +90,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 +130,7 @@ const useModernI18n = ()=>{
     return {
         language: currentLanguage,
         changeLanguage,
+        t,
         i18nInstance,
         supportedLanguages: languages || [],
         localisedUrls,

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.4",
   "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/plugin": "npm:@bleedingdev/modern-js-plugin@3.4.0-ultramodern.4",
+    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.4.0-ultramodern.4",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.4.0-ultramodern.4",
+    "@modern-js/server-runtime": "npm:@bleedingdev/modern-js-server-runtime@3.4.0-ultramodern.4",
+    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.4.0-ultramodern.4",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.4.0-ultramodern.4"
   },
   "peerDependencies": {
-    "@modern-js/runtime": "3.4.0-ultramodern.2",
+    "@modern-js/runtime": "3.4.0-ultramodern.4",
     "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.4",
+    "@modern-js/runtime": "npm:@bleedingdev/modern-js-runtime@3.4.0-ultramodern.4"
   },
   "sideEffects": false,
   "publishConfig": {

package/src/runtime/context.tsx

@@ -53,6 +53,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 +251,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 +322,7 @@ export const useModernI18n = (): UseModernI18nReturn => {
   return {
     language: currentLanguage,
     changeLanguage,
+    t,
     i18nInstance,
     supportedLanguages: languages || [],
     localisedUrls,

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/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);
+  });
 });