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

package/dist/esm/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";
+import { createContextValue, useClientSideRedirect, useLanguageSync, useSdkResourcesLoader } from "./hooks";
+import { getI18nInstance } from "./i18n";
+import { mergeBackendOptions } from "./i18n/backend";
+import { useI18nextBackend } from "./i18n/backend/middleware";
+import { detectLanguageWithPriority, exportServerLngToWindow, mergeDetectionOptions } from "./i18n/detection";
+import { useI18nextLanguageDetector } from "./i18n/detection/middleware";
+import { getI18nextInstanceForProvider, getI18nextProvider, getInitReactI18next } from "./i18n/instance";
+import { changeI18nLanguage, ensureLanguageMatch, initializeI18nInstance, setupClonedInstance } from "./i18n/utils";
+import { getPathname } from "./utils";
+import "./types";
+import { I18nLink } from "./I18nLink";
+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/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/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/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/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/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/esm-node/cli/index.js

@@ -0,0 +1,106 @@
+import fs from "fs";
+import path from "path";
+import { getPublicDirRoutePrefixes } from "@modern-js/server-core";
+import { getBackendOptions, getLocaleDetectionOptions } from "../shared/utils.js";
+function hasJsonFiles(dirPath) {
+    try {
+        if (!fs.existsSync(dirPath) || !fs.statSync(dirPath).isDirectory()) return false;
+        const entries = fs.readdirSync(dirPath);
+        for (const entry of entries){
+            const entryPath = path.join(dirPath, entry);
+            const stat = fs.statSync(entryPath);
+            if (stat.isFile() && entry.endsWith('.json')) return true;
+            if (stat.isDirectory()) {
+                if (hasJsonFiles(entryPath)) return true;
+            }
+        }
+        return false;
+    } catch  {
+        return false;
+    }
+}
+function detectLocalesDirectory(appDirectory, normalizedConfig) {
+    const rootLocalesPath = path.join(appDirectory, 'locales');
+    if (hasJsonFiles(rootLocalesPath)) return true;
+    const configPublicPath = path.join(appDirectory, 'config', 'public', 'locales');
+    if (hasJsonFiles(configPublicPath)) return true;
+    const publicDir = normalizedConfig?.server?.publicDir;
+    if (publicDir) {
+        const publicDirPath = Array.isArray(publicDir) ? publicDir[0] : publicDir;
+        const localesPath = path.isAbsolute(publicDirPath) ? path.join(publicDirPath, 'locales') : path.join(appDirectory, publicDirPath, 'locales');
+        if (hasJsonFiles(localesPath)) return true;
+    }
+    return false;
+}
+const i18nPlugin = (options = {})=>({
+        name: '@modern-js/plugin-i18n',
+        setup: (api)=>{
+            const { localeDetection, backend, transformRuntimeConfig, customPlugin, ...restOptions } = options;
+            api._internalRuntimePlugins(({ entrypoint, plugins })=>{
+                const localeDetectionOptions = localeDetection ? getLocaleDetectionOptions(entrypoint.entryName, localeDetection) : void 0;
+                let backendOptions;
+                const { appDirectory } = api.getAppContext();
+                const normalizedConfig = api.getNormalizedConfig();
+                if (backend) {
+                    const entryBackendOptions = getBackendOptions(entrypoint.entryName, backend);
+                    if (entryBackendOptions?.enabled === false) backendOptions = entryBackendOptions;
+                    else if (entryBackendOptions?.loadPath || entryBackendOptions?.addPath) backendOptions = {
+                        ...entryBackendOptions,
+                        enabled: true
+                    };
+                    else if (entryBackendOptions?.enabled !== true) {
+                        const hasLocales = detectLocalesDirectory(appDirectory, normalizedConfig);
+                        backendOptions = hasLocales ? {
+                            ...entryBackendOptions,
+                            enabled: true
+                        } : entryBackendOptions;
+                    } else backendOptions = entryBackendOptions;
+                } else {
+                    const hasLocales = detectLocalesDirectory(appDirectory, normalizedConfig);
+                    if (hasLocales) backendOptions = getBackendOptions(entrypoint.entryName, {
+                        enabled: true
+                    });
+                }
+                const { metaName } = api.getAppContext();
+                let extendedConfig = restOptions;
+                if (transformRuntimeConfig) extendedConfig = transformRuntimeConfig(restOptions, entrypoint);
+                const config = {
+                    entryName: entrypoint.entryName,
+                    localeDetection: localeDetectionOptions,
+                    backend: backendOptions,
+                    ...extendedConfig
+                };
+                plugins.push({
+                    name: customPlugin?.runtime?.name || 'i18n',
+                    path: customPlugin?.runtime?.path || `@${metaName}/plugin-i18n/runtime`,
+                    config
+                });
+                return {
+                    entrypoint,
+                    plugins
+                };
+            });
+            api._internalServerPlugins(({ plugins })=>{
+                const { serverRoutes, metaName } = api.getAppContext();
+                const normalizedConfig = api.getNormalizedConfig();
+                let staticRoutePrefixes = [];
+                if (serverRoutes && Array.isArray(serverRoutes)) staticRoutePrefixes = serverRoutes.filter((route)=>!route.entryName && route.entryPath.startsWith('public')).map((route)=>route.urlPath).filter(Boolean);
+                const publicDirPrefixes = getPublicDirRoutePrefixes(normalizedConfig?.server?.publicDir);
+                publicDirPrefixes.forEach((prefix)=>{
+                    if (!staticRoutePrefixes.includes(prefix)) staticRoutePrefixes.push(prefix);
+                });
+                plugins.push({
+                    name: customPlugin?.server?.name || `@${metaName}/plugin-i18n/server`,
+                    options: {
+                        localeDetection,
+                        staticRoutePrefixes
+                    }
+                });
+                return {
+                    plugins
+                };
+            });
+        }
+    });
+const cli = i18nPlugin;
+export { cli as default, i18nPlugin };

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

@@ -0,0 +1,31 @@
+import { jsx } from "react/jsx-runtime";
+import { Link as router_Link, useInRouterContext, useParams } from "@modern-js/runtime/router";
+import { useModernI18n } from "./context.js";
+import { buildLocalizedUrl } from "./utils.js";
+const useRouterHooks = ()=>{
+    const inRouter = useInRouterContext();
+    return {
+        Link: inRouter ? router_Link : null,
+        params: inRouter ? useParams() : {},
+        hasRouter: inRouter
+    };
+};
+const I18nLink = ({ to, children, ...props })=>{
+    const { Link, params, hasRouter } = useRouterHooks();
+    const { language, supportedLanguages } = useModernI18n();
+    const currentLang = language;
+    const localizedTo = buildLocalizedUrl(to, currentLang, supportedLanguages);
+    if ('development' === process.env.NODE_ENV && hasRouter && !params.lang) console.warn("I18nLink is being used outside of a :lang dynamic route context. This may cause unexpected behavior. Please ensure I18nLink is used within a route that has a :lang parameter.");
+    if (!hasRouter || !Link) return /*#__PURE__*/ jsx("a", {
+        href: localizedTo,
+        ...props,
+        children: children
+    });
+    return /*#__PURE__*/ jsx(Link, {
+        to: localizedTo,
+        ...props,
+        children: children
+    });
+};
+const runtime_I18nLink = I18nLink;
+export { I18nLink, runtime_I18nLink as default };