@bleedingdev/modern-js-plugin-i18n 3.4.0-ultramodern.0 → 3.4.0-ultramodern.10

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

@@ -1,143 +1,8 @@
 import "node:module";
-import { Fragment, jsx, jsxs } from "react/jsx-runtime";
-import { RuntimeContext, isBrowser } from "@modern-js/runtime";
-import { Helmet } from "@modern-js/runtime/head";
-import { merge } from "@modern-js/runtime-utils/merge";
-import { useContext, useEffect, useMemo, useRef, useState } from "react";
-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";
-const i18nPlugin = (options)=>({
-        name: '@modern-js/plugin-i18n',
-        setup: (api)=>{
-            const { entryName, i18nInstance: userI18nInstance, initOptions, localeDetection, backend, htmlLangAttr = false, reactI18next = true } = options;
-            const { localePathRedirect = false, i18nextDetector = true, languages = [], fallbackLanguage = 'en', detection, ignoreRedirectRoutes, localisedUrls } = localeDetection || {};
-            const { enabled: backendEnabled = false } = backend || {};
-            let latestI18nInstance;
-            let I18nextProvider;
-            const loadReactI18nextIntegration = async ()=>{
-                if (!reactI18next) return null;
-                const { getReactI18nextIntegration } = await import("./i18n/react-i18next.mjs");
-                return getReactI18nextIntegration();
-            };
-            api.onBeforeRender(async (context)=>{
-                let i18nInstance = await getI18nInstance(userI18nInstance);
-                const { i18n: otherConfig } = api.getRuntimeConfig();
-                const { initOptions: otherInitOptions } = otherConfig || {};
-                const userInitOptions = merge(otherInitOptions || {}, initOptions || {});
-                const reactI18nextIntegration = await loadReactI18nextIntegration();
-                I18nextProvider = reactI18nextIntegration?.I18nextProvider ?? null;
-                if (reactI18nextIntegration?.initReactI18next) i18nInstance.use(reactI18nextIntegration.initReactI18next);
-                const pathname = getPathname(context);
-                if (i18nextDetector) useI18nextLanguageDetector(i18nInstance);
-                const mergedDetection = mergeDetectionOptions(i18nextDetector, detection, localePathRedirect, userInitOptions);
-                const mergedBackend = mergeBackendOptions(backend, userInitOptions);
-                const hasSdkConfig = 'function' == typeof userInitOptions?.backend?.sdk || mergedBackend?.sdk && 'function' == typeof mergedBackend.sdk;
-                if (mergedBackend && (backendEnabled || hasSdkConfig)) useI18nextBackend(i18nInstance, mergedBackend);
-                const { finalLanguage } = await detectLanguageWithPriority(i18nInstance, {
-                    languages,
-                    fallbackLanguage,
-                    localePathRedirect,
-                    i18nextDetector,
-                    detection,
-                    userInitOptions,
-                    mergedBackend,
-                    pathname,
-                    ssrContext: context.ssrContext
-                });
-                await initializeI18nInstance(i18nInstance, finalLanguage, fallbackLanguage, languages, mergedDetection, mergedBackend, userInitOptions);
-                if (!isBrowser() && i18nInstance.cloneInstance) {
-                    i18nInstance = i18nInstance.cloneInstance();
-                    await setupClonedInstance(i18nInstance, finalLanguage, fallbackLanguage, languages, backendEnabled, backend, i18nextDetector, detection, localePathRedirect, userInitOptions);
-                }
-                if (localePathRedirect) await ensureLanguageMatch(i18nInstance, finalLanguage);
-                if (!isBrowser()) exportServerLngToWindow(context, finalLanguage);
-                context.i18nInstance = i18nInstance;
-                latestI18nInstance = i18nInstance;
-                context.changeLanguage = async (newLang)=>{
-                    await changeI18nLanguage(i18nInstance, newLang, {
-                        detectionOptions: mergedDetection
-                    });
-                };
-            });
-            api.wrapRoot((App)=>(props)=>{
-                    const runtimeContext = useContext(RuntimeContext);
-                    const i18nInstance = runtimeContext.i18nInstance || latestI18nInstance;
-                    const initialLang = useMemo(()=>i18nInstance?.language || (localeDetection?.fallbackLanguage ?? 'en'), [
-                        i18nInstance?.language,
-                        localeDetection?.fallbackLanguage
-                    ]);
-                    const [lang, setLang] = useState(initialLang);
-                    const [forceUpdate, setForceUpdate] = useState(0);
-                    const prevLangRef = useRef(lang);
-                    const runtimeContextRef = useRef(runtimeContext);
-                    runtimeContextRef.current = runtimeContext;
-                    useEffect(()=>{
-                        if (i18nInstance?.language) {
-                            const translator = i18nInstance.translator;
-                            if (translator) translator.language = i18nInstance.language;
-                        }
-                    }, [
-                        i18nInstance?.language
-                    ]);
-                    useEffect(()=>{
-                        prevLangRef.current = lang;
-                    }, [
-                        lang
-                    ]);
-                    useSdkResourcesLoader(i18nInstance, setForceUpdate);
-                    useLanguageSync(i18nInstance, localePathRedirect, languages, runtimeContextRef, prevLangRef, setLang);
-                    useClientSideRedirect(i18nInstance, localePathRedirect, languages, fallbackLanguage, ignoreRedirectRoutes, localisedUrls);
-                    const contextValue = useMemo(()=>createContextValue(lang, i18nInstance, entryName, languages, localePathRedirect, ignoreRedirectRoutes, localisedUrls, setLang), [
-                        lang,
-                        i18nInstance,
-                        entryName,
-                        languages,
-                        localePathRedirect,
-                        ignoreRedirectRoutes,
-                        localisedUrls,
-                        forceUpdate
-                    ]);
-                    const children = props.children;
-                    const appContent = /*#__PURE__*/ jsxs(Fragment, {
-                        children: [
-                            Boolean(htmlLangAttr) && /*#__PURE__*/ jsx(Helmet, {
-                                htmlAttributes: {
-                                    lang
-                                }
-                            }),
-                            /*#__PURE__*/ jsx(ModernI18nProvider, {
-                                value: contextValue,
-                                children: App ? /*#__PURE__*/ jsx(App, {
-                                    ...props,
-                                    children: children
-                                }) : children
-                            })
-                        ]
-                    });
-                    if (!i18nInstance) return appContent;
-                    if (I18nextProvider) {
-                        const i18nextInstanceForProvider = getI18nextInstanceForProvider(i18nInstance);
-                        return /*#__PURE__*/ jsx(I18nextProvider, {
-                            i18n: i18nextInstanceForProvider,
-                            children: appContent
-                        });
-                    }
-                    return appContent;
-                });
-        }
-    });
+import { createI18nPlugin } from "./core.mjs";
+import { getReactI18nextIntegration } from "./i18n/react-i18next.mjs";
+export * from "./core.mjs";
+const i18nPlugin = createI18nPlugin(getReactI18nextIntegration);
 const runtime = i18nPlugin;
-export { I18nLink } from "./I18nLink.mjs";
-export { Link } from "./Link.mjs";
-export { canonicalPath, localizePath, useLocalizedLocation, useLocalizedPaths } from "./localizedPaths.mjs";
 export default runtime;
-export { buildLocalizedUrl, i18nPlugin, splitUrlTarget, useModernI18n };
+export { i18nPlugin };

package/dist/esm-node/runtime/no-react-i18next.mjs

@@ -0,0 +1,7 @@
+import "node:module";
+import { createI18nPlugin } from "./core.mjs";
+export * from "./core.mjs";
+const i18nPlugin = createI18nPlugin();
+const no_react_i18next = i18nPlugin;
+export default no_react_i18next;
+export { i18nPlugin };

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/core.d.ts

@@ -0,0 +1,30 @@
+import { type RuntimePlugin } from '@modern-js/runtime';
+import type React from 'react';
+import type { BaseBackendOptions, BaseLocaleDetectionOptions } from '../shared/type';
+import type { I18nInitOptions, I18nInstance } from './i18n';
+import './types';
+export type { I18nSdkLoader, I18nSdkLoadOptions } from '../shared/type';
+export type { Resources } from './i18n/instance';
+export interface I18nPluginOptions {
+    entryName?: string;
+    localeDetection?: BaseLocaleDetectionOptions;
+    backend?: BaseBackendOptions;
+    i18nInstance?: I18nInstance;
+    changeLanguage?: (lang: string) => void;
+    initOptions?: I18nInitOptions;
+    htmlLangAttr?: boolean;
+    reactI18next?: boolean;
+    [key: string]: any;
+}
+export interface ReactI18nextIntegration {
+    I18nextProvider: React.ComponentType<any> | null;
+    initReactI18next: any | null;
+}
+export type LoadReactI18nextIntegration = () => Promise<ReactI18nextIntegration | null>;
+export declare const createI18nPlugin: (loadReactI18nextIntegration?: LoadReactI18nextIntegration) => ((options: I18nPluginOptions) => RuntimePlugin);
+export type { AllowedLinkTarget, CanonicalRoutePath, UltramodernCanonicalRoutes, } from './canonicalRoutes';
+export { useModernI18n } from './context';
+export { I18nLink, type I18nLinkProps } from './I18nLink';
+export { Link, type LinkActiveOptions, type LinkBaseProps, type LinkParams, type LinkProps, } from './Link';
+export { canonicalPath, type LocalizedPathsConfig, localizePath, type UseLocalizedLocationReturn, type UseLocalizedPathsReturn, useLocalizedLocation, useLocalizedPaths, } from './localizedPaths';
+export { buildLocalizedUrl, splitUrlTarget } from './utils';

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/dist/types/runtime/index.d.ts

@@ -1,25 +1,3 @@
-import { type RuntimePlugin } from '@modern-js/runtime';
-import type { BaseBackendOptions, BaseLocaleDetectionOptions } from '../shared/type';
-import type { I18nInitOptions, I18nInstance } from './i18n';
-import './types';
-export type { I18nSdkLoader, I18nSdkLoadOptions } from '../shared/type';
-export type { Resources } from './i18n/instance';
-export interface I18nPluginOptions {
-    entryName?: string;
-    localeDetection?: BaseLocaleDetectionOptions;
-    backend?: BaseBackendOptions;
-    i18nInstance?: I18nInstance;
-    changeLanguage?: (lang: string) => void;
-    initOptions?: I18nInitOptions;
-    htmlLangAttr?: boolean;
-    reactI18next?: boolean;
-    [key: string]: any;
-}
-export declare const i18nPlugin: (options: I18nPluginOptions) => RuntimePlugin;
-export type { AllowedLinkTarget, CanonicalRoutePath, UltramodernCanonicalRoutes, } from './canonicalRoutes';
-export { useModernI18n } from './context';
-export { I18nLink, type I18nLinkProps } from './I18nLink';
-export { Link, type LinkActiveOptions, type LinkBaseProps, type LinkParams, type LinkProps, } from './Link';
-export { canonicalPath, type LocalizedPathsConfig, localizePath, type UseLocalizedLocationReturn, type UseLocalizedPathsReturn, useLocalizedLocation, useLocalizedPaths, } from './localizedPaths';
-export { buildLocalizedUrl, splitUrlTarget } from './utils';
+export * from './core';
+export declare const i18nPlugin: (options: import("./core").I18nPluginOptions) => import("@modern-js/runtime").RuntimePlugin;
 export default i18nPlugin;

package/dist/types/runtime/no-react-i18next.d.ts

@@ -0,0 +1,3 @@
+export * from './core';
+export declare const i18nPlugin: (options: import("./core").I18nPluginOptions) => import("@modern-js/runtime").RuntimePlugin;
+export default i18nPlugin;

package/package.json

@@ -17,7 +17,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "3.4.0-ultramodern.0",
+  "version": "3.4.0-ultramodern.10",
   "engines": {
     "node": ">=20"
   },
@@ -48,6 +48,13 @@
       },
       "default": "./dist/esm/runtime/index.mjs"
     },
+    "./runtime/no-react-i18next": {
+      "types": "./dist/types/runtime/no-react-i18next.d.ts",
+      "node": {
+        "module": "./dist/esm/runtime/no-react-i18next.mjs"
+      },
+      "default": "./dist/esm/runtime/no-react-i18next.mjs"
+    },
     "./server": {
       "types": "./dist/types/server/index.d.ts",
       "node": {
@@ -72,6 +79,9 @@
       "runtime": [
         "./dist/types/runtime/index.d.ts"
       ],
+      "runtime/no-react-i18next": [
+        "./dist/types/runtime/no-react-i18next.d.ts"
+      ],
       "server": [
         "./dist/types/server/index.d.ts"
       ],
@@ -87,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.0",
-    "@modern-js/server-runtime": "npm:@bleedingdev/modern-js-server-runtime@3.4.0-ultramodern.0",
-    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.4.0-ultramodern.0",
-    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.4.0-ultramodern.0",
-    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.4.0-ultramodern.0",
-    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.4.0-ultramodern.0"
+    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.4.0-ultramodern.10",
+    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.4.0-ultramodern.10",
+    "@modern-js/server-runtime": "npm:@bleedingdev/modern-js-server-runtime@3.4.0-ultramodern.10",
+    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.4.0-ultramodern.10",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.4.0-ultramodern.10",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.4.0-ultramodern.10"
   },
   "peerDependencies": {
-    "@modern-js/runtime": "3.4.0-ultramodern.0",
+    "@modern-js/runtime": "3.4.0-ultramodern.10",
     "i18next": ">=26.3.1",
     "react": "^19.2.7",
     "react-dom": "^19.2.7",
@@ -111,7 +121,7 @@
   },
   "devDependencies": {
     "@rslib/core": "0.23.0",
-    "@types/node": "^26.0.0",
+    "@types/node": "^26.0.1",
     "@typescript/native-preview": "7.0.0-dev.20260624.1",
     "i18next": "26.3.2",
     "react": "^19.2.7",
@@ -119,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.0",
-    "@modern-js/runtime": "npm:@bleedingdev/modern-js-runtime@3.4.0-ultramodern.0"
+    "@modern-js/app-tools": "npm:@bleedingdev/modern-js-app-tools@3.4.0-ultramodern.10",
+    "@modern-js/runtime": "npm:@bleedingdev/modern-js-runtime@3.4.0-ultramodern.10"
   },
   "sideEffects": false,
   "publishConfig": {

package/rstest.config.mts

@@ -31,6 +31,7 @@ export default {
         'tests/localisedUrls.test.ts',
         'tests/linkTypes.test.ts',
         'tests/backendDefaults.test.ts',
+        'tests/reactI18nextRuntimeBoundary.test.ts',
       ],
       extends: commonConfig,
     }),

package/src/cli/index.ts

@@ -126,10 +126,15 @@ export const i18nPlugin = (
         backend: backendOptions,
         ...extendedConfig,
       };
+      const runtimePluginPath =
+        customPlugin?.runtime?.path ||
+        (config.reactI18next === false
+          ? `@${metaName}/plugin-i18n/runtime/no-react-i18next`
+          : `@${metaName}/plugin-i18n/runtime`);
 
       plugins.push({
         name: customPlugin?.runtime?.name || 'i18n',
-        path: customPlugin?.runtime?.path || `@${metaName}/plugin-i18n/runtime`,
+        path: runtimePluginPath,
         config,
       });
       return {

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,