@modern-js/plugin-i18n 2.69.5 → 3.0.0-alpha.0

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

@@ -0,0 +1,119 @@
+import { jsx } from "react/jsx-runtime";
+import { isBrowser, useRuntimeContext } from "@modern-js/runtime";
+import { merge } from "@modern-js/runtime-utils/merge";
+import { useEffect, useMemo, useRef, useState } from "react";
+import { ModernI18nProvider, useModernI18n } from "./context.js";
+import { createContextValue, useClientSideRedirect, useLanguageSync, useSdkResourcesLoader } from "./hooks.js";
+import { getI18nInstance } from "./i18n/index.js";
+import { mergeBackendOptions } from "./i18n/backend/index.js";
+import { useI18nextBackend } from "./i18n/backend/middleware.js";
+import { detectLanguageWithPriority, exportServerLngToWindow, mergeDetectionOptions } from "./i18n/detection/index.js";
+import { useI18nextLanguageDetector } from "./i18n/detection/middleware.js";
+import { getI18nextInstanceForProvider, getI18nextProvider, getInitReactI18next } from "./i18n/instance.js";
+import { changeI18nLanguage, ensureLanguageMatch, initializeI18nInstance, setupClonedInstance } from "./i18n/utils.js";
+import { getPathname } from "./utils.js";
+import "./types.js";
+import { I18nLink } from "./I18nLink.js";
+const i18nPlugin = (options)=>({
+        name: '@modern-js/plugin-i18n',
+        setup: (api)=>{
+            const { entryName, i18nInstance: userI18nInstance, initOptions, localeDetection, backend } = options;
+            const { localePathRedirect = false, i18nextDetector = true, languages = [], fallbackLanguage = 'en', detection, ignoreRedirectRoutes } = localeDetection || {};
+            const { enabled: backendEnabled = false } = backend || {};
+            let I18nextProvider;
+            api.onBeforeRender(async (context)=>{
+                let i18nInstance = await getI18nInstance(userI18nInstance);
+                const { i18n: otherConfig } = api.getRuntimeConfig();
+                const { initOptions: otherInitOptions } = otherConfig || {};
+                const userInitOptions = merge(otherInitOptions || {}, initOptions || {});
+                const initReactI18next = await getInitReactI18next();
+                I18nextProvider = await getI18nextProvider();
+                if (initReactI18next) i18nInstance.use(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;
+                context.changeLanguage = async (newLang)=>{
+                    await changeI18nLanguage(i18nInstance, newLang, {
+                        detectionOptions: mergedDetection
+                    });
+                };
+            });
+            api.wrapRoot((App)=>(props)=>{
+                    const runtimeContext = useRuntimeContext();
+                    const i18nInstance = runtimeContext.i18nInstance;
+                    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);
+                    const contextValue = useMemo(()=>createContextValue(lang, i18nInstance, entryName, languages, localePathRedirect, ignoreRedirectRoutes, setLang), [
+                        lang,
+                        i18nInstance,
+                        entryName,
+                        languages,
+                        localePathRedirect,
+                        ignoreRedirectRoutes,
+                        forceUpdate
+                    ]);
+                    const appContent = /*#__PURE__*/ jsx(ModernI18nProvider, {
+                        value: contextValue,
+                        children: /*#__PURE__*/ jsx(App, {
+                            ...props
+                        })
+                    });
+                    if (!i18nInstance) return appContent;
+                    if (I18nextProvider) {
+                        const i18nextInstanceForProvider = getI18nextInstanceForProvider(i18nInstance);
+                        return /*#__PURE__*/ jsx(I18nextProvider, {
+                            i18n: i18nextInstanceForProvider,
+                            children: appContent
+                        });
+                    }
+                    return appContent;
+                });
+        }
+    });
+const runtime = i18nPlugin;
+export { I18nLink, runtime as default, i18nPlugin, useModernI18n };

package/dist/esm-node/runtime/utils.js

@@ -0,0 +1,82 @@
+import * as __rspack_external__modern_js_runtime_router_2dfd0c78 from "@modern-js/runtime/router";
+import { isBrowser } from "@modern-js/runtime";
+import { getGlobalBasename } from "@modern-js/runtime/context";
+var __webpack_modules__ = {
+    "@modern-js/runtime/router" (module) {
+        module.exports = __rspack_external__modern_js_runtime_router_2dfd0c78;
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+const getPathname = (context)=>{
+    if (isBrowser()) return window.location.pathname;
+    return context.ssrContext?.request?.pathname || '/';
+};
+const getEntryPath = ()=>{
+    const basename = getGlobalBasename();
+    if (basename) return '/' === basename ? '' : basename;
+    return '';
+};
+const getLanguageFromPath = (pathname, languages, fallbackLanguage)=>{
+    const segments = pathname.split('/').filter(Boolean);
+    const firstSegment = segments[0];
+    if (languages.includes(firstSegment)) return firstSegment;
+    return fallbackLanguage;
+};
+const buildLocalizedUrl = (pathname, language, languages)=>{
+    const segments = pathname.split('/').filter(Boolean);
+    if (segments.length > 0 && languages.includes(segments[0])) segments[0] = language;
+    else segments.unshift(language);
+    return `/${segments.join('/')}`;
+};
+const detectLanguageFromPath = (pathname, languages, localePathRedirect)=>{
+    if (!localePathRedirect) return {
+        detected: false
+    };
+    const relativePath = pathname.replace(getEntryPath(), '');
+    const segments = relativePath.split('/').filter(Boolean);
+    const firstSegment = segments[0];
+    if (firstSegment && languages.includes(firstSegment)) return {
+        detected: true,
+        language: firstSegment
+    };
+    return {
+        detected: false
+    };
+};
+const shouldIgnoreRedirect = (pathname, languages, ignoreRedirectRoutes)=>{
+    if (!ignoreRedirectRoutes) return false;
+    const segments = pathname.split('/').filter(Boolean);
+    let pathWithoutLang = pathname;
+    if (segments.length > 0 && languages.includes(segments[0])) pathWithoutLang = `/${segments.slice(1).join('/')}`;
+    const normalizedPath = pathWithoutLang.startsWith('/') ? pathWithoutLang : `/${pathWithoutLang}`;
+    if ('function' == typeof ignoreRedirectRoutes) return ignoreRedirectRoutes(normalizedPath);
+    return ignoreRedirectRoutes.some((pattern)=>normalizedPath === pattern || normalizedPath.startsWith(`${pattern}/`));
+};
+const useRouterHooks = ()=>{
+    try {
+        const { useLocation, useNavigate, useParams } = __webpack_require__("@modern-js/runtime/router");
+        return {
+            navigate: useNavigate(),
+            location: useLocation(),
+            params: useParams(),
+            hasRouter: true
+        };
+    } catch (error) {
+        return {
+            navigate: null,
+            location: null,
+            params: {},
+            hasRouter: false
+        };
+    }
+};
+export { buildLocalizedUrl, detectLanguageFromPath, getEntryPath, getLanguageFromPath, getPathname, shouldIgnoreRedirect, useRouterHooks };

package/dist/esm-node/server/index.js

@@ -0,0 +1,168 @@
+import { languageDetector } from "@modern-js/server-core/hono";
+import { DEFAULT_I18NEXT_DETECTION_OPTIONS, mergeDetectionOptions } from "../runtime/i18n/detection/config.js";
+import { getLocaleDetectionOptions } from "../shared/utils.js";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) Object.defineProperty(exports, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports, '__esModule', {
+            value: true
+        });
+    };
+})();
+var hono_namespaceObject = {};
+__webpack_require__.r(hono_namespaceObject);
+__webpack_require__.d(hono_namespaceObject, {
+    languageDetector: ()=>languageDetector
+});
+const { languageDetector: server_languageDetector } = hono_namespaceObject;
+const convertToHonoLanguageDetectorOptions = (languages, fallbackLanguage, detectionOptions)=>{
+    const mergedDetection = detectionOptions ? mergeDetectionOptions(detectionOptions) : DEFAULT_I18NEXT_DETECTION_OPTIONS;
+    const order = (mergedDetection.order || []).filter((item)=>![
+            'path',
+            'localStorage',
+            'navigator',
+            'htmlTag',
+            'subdomain'
+        ].includes(item));
+    const detectionOrder = order.length > 0 ? order : [
+        'querystring',
+        'cookie',
+        'header'
+    ];
+    const honoOrder = detectionOrder.map((item)=>{
+        if ('querystring' === item) return 'querystring';
+        if ('cookie' === item) return 'cookie';
+        if ('header' === item) return 'header';
+        return item;
+    });
+    const caches = false === mergedDetection.caches ? false : Array.isArray(mergedDetection.caches) && !mergedDetection.caches.includes('cookie') ? false : [
+        'cookie'
+    ];
+    return {
+        supportedLanguages: languages.length > 0 ? languages : [
+            fallbackLanguage
+        ],
+        fallbackLanguage,
+        order: honoOrder,
+        lookupQueryString: mergedDetection.lookupQuerystring || DEFAULT_I18NEXT_DETECTION_OPTIONS.lookupQuerystring || 'lng',
+        lookupCookie: mergedDetection.lookupCookie || DEFAULT_I18NEXT_DETECTION_OPTIONS.lookupCookie || 'i18next',
+        lookupFromHeaderKey: mergedDetection.lookupHeader || DEFAULT_I18NEXT_DETECTION_OPTIONS.lookupHeader || 'accept-language',
+        ...void 0 !== caches && {
+            caches
+        },
+        ignoreCase: true
+    };
+};
+const shouldIgnoreRedirect = (pathname, urlPath, ignoreRedirectRoutes)=>{
+    if (!ignoreRedirectRoutes) return false;
+    const basePath = urlPath.replace('/*', '');
+    const remainingPath = pathname.startsWith(basePath) ? pathname.slice(basePath.length) : pathname;
+    const normalizedPath = remainingPath.startsWith('/') ? remainingPath : `/${remainingPath}`;
+    if ('function' == typeof ignoreRedirectRoutes) return ignoreRedirectRoutes(normalizedPath);
+    return ignoreRedirectRoutes.some((pattern)=>normalizedPath === pattern || normalizedPath.startsWith(`${pattern}/`));
+};
+const isStaticResourceRequest = (pathname, staticRoutePrefixes, languages = [])=>{
+    if (staticRoutePrefixes.some((prefix)=>pathname.startsWith(`${prefix}/`) || pathname === prefix)) return true;
+    const standardStaticPrefixes = [
+        '/static/',
+        '/upload/'
+    ];
+    if (standardStaticPrefixes.some((prefix)=>pathname.startsWith(prefix))) return true;
+    const pathSegments = pathname.split('/').filter(Boolean);
+    if (pathSegments.length > 0 && languages.includes(pathSegments[0])) {
+        const pathWithoutLang = '/' + pathSegments.slice(1).join('/');
+        if (standardStaticPrefixes.some((prefix)=>pathWithoutLang.startsWith(prefix)) || staticRoutePrefixes.some((prefix)=>pathWithoutLang.startsWith(`${prefix}/`) || pathWithoutLang === prefix)) return true;
+    }
+    return false;
+};
+const getLanguageFromPath = (req, urlPath, languages)=>{
+    const url = new URL(req.url, `http://${req.header().host}`);
+    const pathname = url.pathname;
+    const basePath = urlPath.replace('/*', '');
+    const remainingPath = pathname.startsWith(basePath) ? pathname.slice(basePath.length) : pathname;
+    const segments = remainingPath.split('/').filter(Boolean);
+    const firstSegment = segments[0];
+    if (languages.includes(firstSegment)) return firstSegment;
+    return null;
+};
+const buildLocalizedUrl = (req, urlPath, language, languages)=>{
+    const url = new URL(req.url);
+    const pathname = url.pathname;
+    const basePath = urlPath.replace('/*', '');
+    const remainingPath = pathname.startsWith(basePath) ? pathname.slice(basePath.length) : pathname;
+    const segments = remainingPath.split('/').filter(Boolean);
+    if (segments.length > 0 && languages.includes(segments[0])) segments[0] = language;
+    else segments.unshift(language);
+    const newPathname = `/${segments.join('/')}`;
+    const suffix = `${url.search}${url.hash}`;
+    const localizedUrl = '/' === basePath ? newPathname + suffix : basePath + newPathname + suffix;
+    return localizedUrl;
+};
+const i18nServerPlugin = (options)=>({
+        name: '@modern-js/plugin-i18n/server',
+        setup: (api)=>{
+            api.onPrepare(()=>{
+                const { middlewares, routes } = api.getServerContext();
+                routes.map((route)=>{
+                    const { entryName } = route;
+                    if (!entryName) return;
+                    if (!options.localeDetection) return;
+                    const { localePathRedirect, i18nextDetector = true, languages = [], fallbackLanguage = 'en', detection, ignoreRedirectRoutes } = getLocaleDetectionOptions(entryName, options.localeDetection);
+                    const staticRoutePrefixes = options.staticRoutePrefixes;
+                    const originUrlPath = route.urlPath;
+                    const urlPath = originUrlPath.endsWith('/') ? `${originUrlPath}*` : `${originUrlPath}/*`;
+                    if (localePathRedirect) {
+                        if (i18nextDetector) {
+                            const detectorOptions = convertToHonoLanguageDetectorOptions(languages, fallbackLanguage, detection);
+                            const detectorHandler = server_languageDetector(detectorOptions);
+                            middlewares.push({
+                                name: 'i18n-language-detector',
+                                path: urlPath,
+                                handler: async (c, next)=>{
+                                    const url = new URL(c.req.url);
+                                    const pathname = url.pathname;
+                                    if (isStaticResourceRequest(pathname, staticRoutePrefixes, languages)) return await next();
+                                    return detectorHandler(c, next);
+                                }
+                            });
+                        }
+                        middlewares.push({
+                            name: 'i18n-server-middleware',
+                            path: urlPath,
+                            handler: async (c, next)=>{
+                                const url = new URL(c.req.url);
+                                const pathname = url.pathname;
+                                if (isStaticResourceRequest(pathname, staticRoutePrefixes, languages)) return await next();
+                                if (shouldIgnoreRedirect(pathname, urlPath, ignoreRedirectRoutes)) return await next();
+                                const language = getLanguageFromPath(c.req, urlPath, languages);
+                                if (!language) {
+                                    let detectedLanguage = null;
+                                    if (i18nextDetector) detectedLanguage = c.get('language') || null;
+                                    const targetLanguage = detectedLanguage || fallbackLanguage;
+                                    const localizedUrl = buildLocalizedUrl(c.req, originUrlPath, targetLanguage, languages);
+                                    return c.redirect(localizedUrl);
+                                }
+                                await next();
+                            }
+                        });
+                    }
+                });
+            });
+        }
+    });
+const server = i18nServerPlugin;
+export { server as default, i18nServerPlugin };

package/dist/esm-node/shared/deepMerge.js

@@ -0,0 +1,20 @@
+function isPlainObject(value) {
+    return null !== value && 'object' == typeof value && !Array.isArray(value) && !(value instanceof Date);
+}
+function deepMerge(defaultOptions, userOptions) {
+    if (!userOptions) return defaultOptions;
+    const merged = {
+        ...defaultOptions
+    };
+    for(const key in userOptions){
+        const userValue = userOptions[key];
+        if (void 0 === userValue) continue;
+        const defaultValue = merged[key];
+        const isUserValueObject = isPlainObject(userValue);
+        const isDefaultValueObject = isPlainObject(defaultValue);
+        if (isUserValueObject && isDefaultValueObject) merged[key] = deepMerge(defaultValue, userValue);
+        else merged[key] = userValue;
+    }
+    return merged;
+}
+export { deepMerge };

package/dist/esm-node/shared/detection.js

@@ -0,0 +1,71 @@
+import { DEFAULT_I18NEXT_DETECTION_OPTIONS, mergeDetectionOptions } from "../runtime/i18n/detection/config.js";
+function detectLanguageFromRequest(req, languages, detectionOptions) {
+    try {
+        const mergedDetection = detectionOptions ? mergeDetectionOptions(detectionOptions) : DEFAULT_I18NEXT_DETECTION_OPTIONS;
+        const order = (mergedDetection.order || []).filter((item)=>![
+                'path',
+                'localStorage',
+                'navigator',
+                'htmlTag',
+                'subdomain'
+            ].includes(item));
+        const detectionOrder = order.length > 0 ? order : [
+            'querystring',
+            'cookie',
+            'header'
+        ];
+        const getHeader = (name)=>{
+            req.headers, Headers;
+            return req.headers.get(name);
+        };
+        for (const method of detectionOrder){
+            let detectedLang = null;
+            switch(method){
+                case 'querystring':
+                    {
+                        const lookupKey = mergedDetection.lookupQuerystring || DEFAULT_I18NEXT_DETECTION_OPTIONS.lookupQuerystring || 'lng';
+                        const host = getHeader('host') || 'localhost';
+                        const url = new URL(req.url, `http://${host}`);
+                        detectedLang = url.searchParams.get(lookupKey);
+                        break;
+                    }
+                case 'cookie':
+                    {
+                        const lookupKey = mergedDetection.lookupCookie || DEFAULT_I18NEXT_DETECTION_OPTIONS.lookupCookie || 'i18next';
+                        const cookieHeader = getHeader('Cookie');
+                        if (cookieHeader) {
+                            const cookies = cookieHeader.split(';').reduce((acc, item)=>{
+                                const [key, value] = item.trim().split('=');
+                                if (key && value) acc[key] = value;
+                                return acc;
+                            }, {});
+                            detectedLang = cookies[lookupKey] || null;
+                        }
+                        break;
+                    }
+                case 'header':
+                    {
+                        const lookupKey = mergedDetection.lookupHeader || DEFAULT_I18NEXT_DETECTION_OPTIONS.lookupHeader || 'accept-language';
+                        const acceptLanguage = getHeader(lookupKey);
+                        if (acceptLanguage) {
+                            const languagesList = acceptLanguage.split(',').map((lang)=>{
+                                const [code, q] = lang.trim().split(';');
+                                return {
+                                    code: code.split('-')[0],
+                                    quality: q ? parseFloat(q.split('=')[1]) : 1.0
+                                };
+                            }).sort((a, b)=>b.quality - a.quality);
+                            for (const lang of languagesList)if (0 === languages.length || languages.includes(lang.code)) {
+                                detectedLang = lang.code;
+                                break;
+                            }
+                        }
+                        break;
+                    }
+            }
+            if (detectedLang && (0 === languages.length || languages.includes(detectedLang))) return detectedLang;
+        }
+    } catch (error) {}
+    return null;
+}
+export { detectLanguageFromRequest };

package/dist/esm-node/shared/utils.js

@@ -0,0 +1,35 @@
+function getEntryConfig(entryName, config, entryKey) {
+    const entryConfigMap = config[entryKey];
+    return entryConfigMap?.[entryName];
+}
+function removeEntryConfigKey(config, entryKey) {
+    const { [entryKey]: _, ...rest } = config;
+    return rest;
+}
+function getLocaleDetectionOptions(entryName, localeDetection) {
+    const fullConfig = localeDetection;
+    const entryConfig = getEntryConfig(entryName, fullConfig, 'localeDetectionByEntry');
+    if (entryConfig) {
+        const globalConfig = removeEntryConfigKey(fullConfig, 'localeDetectionByEntry');
+        return {
+            ...globalConfig,
+            ...entryConfig
+        };
+    }
+    if ('localeDetectionByEntry' in fullConfig) return removeEntryConfigKey(fullConfig, 'localeDetectionByEntry');
+    return localeDetection;
+}
+function getBackendOptions(entryName, backend) {
+    const fullConfig = backend;
+    const entryConfig = getEntryConfig(entryName, fullConfig, 'backendOptionsByEntry');
+    if (entryConfig) {
+        const globalConfig = removeEntryConfigKey(fullConfig, 'backendOptionsByEntry');
+        return {
+            ...globalConfig,
+            ...entryConfig
+        };
+    }
+    if ('backendOptionsByEntry' in fullConfig) return removeEntryConfigKey(fullConfig, 'backendOptionsByEntry');
+    return backend;
+}
+export { getBackendOptions, getEntryConfig, getLocaleDetectionOptions, removeEntryConfigKey };

package/dist/types/cli/index.d.ts

@@ -0,0 +1,21 @@
+import type { AppTools, CliPlugin } from '@modern-js/app-tools';
+import type { Entrypoint } from '@modern-js/types';
+import type { BackendOptions, LocaleDetectionOptions } from '../shared/type';
+export type TransformRuntimeConfigFn = (extendedConfig: Record<string, any>, entrypoint: Entrypoint) => Record<string, any>;
+export interface I18nPluginOptions {
+    localeDetection?: LocaleDetectionOptions;
+    backend?: BackendOptions;
+    transformRuntimeConfig?: TransformRuntimeConfigFn;
+    customPlugin?: {
+        runtime?: {
+            name?: string;
+            path?: string;
+        };
+        server?: {
+            name?: string;
+        };
+    };
+    [key: string]: any;
+}
+export declare const i18nPlugin: (options?: I18nPluginOptions) => CliPlugin<AppTools>;
+export default i18nPlugin;

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

@@ -0,0 +1,8 @@
+import type React from 'react';
+export interface I18nLinkProps {
+    to: string;
+    children: React.ReactNode;
+    [key: string]: any;
+}
+export declare const I18nLink: React.FC<I18nLinkProps>;
+export default I18nLink;

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

@@ -0,0 +1,38 @@
+import type { FC, ReactNode } from 'react';
+import type { I18nInstance } from './i18n';
+export interface ModernI18nContextValue {
+    language: string;
+    i18nInstance: I18nInstance;
+    entryName?: string;
+    languages?: string[];
+    localePathRedirect?: boolean;
+    ignoreRedirectRoutes?: string[] | ((pathname: string) => boolean);
+    updateLanguage?: (newLang: string) => void;
+}
+export interface ModernI18nProviderProps {
+    children: ReactNode;
+    value: ModernI18nContextValue;
+}
+export declare const ModernI18nProvider: FC<ModernI18nProviderProps>;
+export interface UseModernI18nReturn {
+    language: string;
+    changeLanguage: (newLang: string) => Promise<void>;
+    i18nInstance: I18nInstance;
+    supportedLanguages: string[];
+    isLanguageSupported: (lang: string) => boolean;
+    isResourcesReady: boolean;
+}
+/**
+ * Hook for accessing i18n functionality in Modern.js applications.
+ *
+ * This hook provides:
+ * - Current language from URL params or i18n context
+ * - changeLanguage function that updates both i18n instance and URL
+ * - Direct access to the i18n instance
+ * - List of supported languages
+ * - Helper function to check if a language is supported
+ *
+ * @param options - Optional configuration to override context settings
+ * @returns Object containing i18n functionality and utilities
+ */
+export declare const useModernI18n: () => UseModernI18nReturn;

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

@@ -0,0 +1,28 @@
+import type { TRuntimeContext } from '@modern-js/runtime';
+import type React from 'react';
+import type { I18nInstance } from './i18n';
+interface RuntimeContextWithI18n extends TRuntimeContext {
+    i18nInstance?: I18nInstance;
+}
+export declare function createContextValue(lang: string, i18nInstance: I18nInstance | undefined, entryName: string | undefined, languages: string[], localePathRedirect: boolean, ignoreRedirectRoutes: string[] | ((pathname: string) => boolean) | undefined, setLang: (lang: string) => void): {
+    language: string;
+    i18nInstance: I18nInstance;
+    entryName: string | undefined;
+    languages: string[];
+    localePathRedirect: boolean;
+    ignoreRedirectRoutes: string[] | ((pathname: string) => boolean) | undefined;
+    updateLanguage: (lang: string) => void;
+};
+export declare function useSdkResourcesLoader(i18nInstance: I18nInstance | undefined, setForceUpdate: React.Dispatch<React.SetStateAction<number>>): void;
+/**
+ * Hook to handle client-side redirect for locale path redirect in static deployments
+ * This ensures that when users access paths without language prefix, they are redirected
+ * to the localized version of the path
+ *
+ * Note: This hook only runs in CSR (Client-Side Rendering) scenarios.
+ * In SSR/SSG scenarios, server-side middleware handles redirects, so this hook is skipped.
+ * We use process.env.MODERN_TARGET to ensure this code is only included in browser bundles.
+ */
+export declare function useClientSideRedirect(i18nInstance: I18nInstance | undefined, localePathRedirect: boolean, languages: string[], fallbackLanguage: string, ignoreRedirectRoutes?: string[] | ((pathname: string) => boolean)): void;
+export declare function useLanguageSync(i18nInstance: I18nInstance | undefined, localePathRedirect: boolean, languages: string[], runtimeContextRef: React.MutableRefObject<RuntimeContextWithI18n>, prevLangRef: React.MutableRefObject<string>, setLang: (lang: string) => void): void;
+export {};

package/dist/types/runtime/i18n/backend/config.d.ts

@@ -0,0 +1,2 @@
+import type { BackendOptions } from '../instance';
+export declare function mergeBackendOptions(defaultOptions: BackendOptions, cliOptions?: BackendOptions, userOptions?: BackendOptions): BackendOptions;

package/dist/types/runtime/i18n/backend/defaults.d.ts

@@ -0,0 +1,13 @@
+export declare const DEFAULT_I18NEXT_BACKEND_OPTIONS: {
+    loadPath: string;
+    addPath: string;
+};
+declare global {
+    interface Window {
+        __assetPrefix__?: string;
+    }
+}
+export declare function convertBackendOptions<T extends {
+    loadPath?: string;
+    addPath?: string;
+}>(options: T): T;

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

@@ -0,0 +1,8 @@
+export declare const DEFAULT_I18NEXT_BACKEND_OPTIONS: {
+    loadPath: string;
+    addPath: string;
+};
+export declare function convertBackendOptions<T extends {
+    loadPath?: string;
+    addPath?: string;
+}>(options: T): T;

package/dist/types/runtime/i18n/backend/index.d.ts

@@ -0,0 +1,3 @@
+import type { BaseBackendOptions } from '../../../shared/type';
+import type { BackendOptions, I18nInitOptions } from '../instance';
+export declare const mergeBackendOptions: (backend?: BaseBackendOptions, userInitOptions?: I18nInitOptions) => BackendOptions | undefined;

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

@@ -0,0 +1,14 @@
+import type { BaseBackendOptions, ChainedBackendConfig } from '../../../shared/type';
+import type { I18nInstance } from '../instance';
+type BackendConfigWithChained = BaseBackendOptions & Partial<ChainedBackendConfig>;
+/**
+ * Common logic for using i18next backend
+ * This function handles the backend selection and chained backend configuration
+ *
+ * @param i18nInstance - The i18n instance to configure
+ * @param BackendWithSave - The wrapped backend class with save method (required for chained backend refresh logic)
+ * @param BackendBase - The base backend class (for non-chained use)
+ * @param backend - Optional backend configuration
+ */
+export declare function useI18nextBackendCommon(i18nInstance: I18nInstance, BackendWithSave: new (...args: any[]) => any, BackendBase: new (...args: any[]) => any, backend?: BackendConfigWithChained): void;
+export {};