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

package/dist/cjs/server/index.cjs

@@ -0,0 +1,178 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    i18nServerPlugin: ()=>i18nServerPlugin,
+    default: ()=>server
+});
+const hono_namespaceObject = require("@modern-js/server-core/hono");
+const config_cjs_namespaceObject = require("../runtime/i18n/detection/config.cjs");
+const utils_cjs_namespaceObject = require("../shared/utils.cjs");
+const { languageDetector } = hono_namespaceObject;
+const convertToHonoLanguageDetectorOptions = (languages, fallbackLanguage, detectionOptions)=>{
+    const mergedDetection = detectionOptions ? (0, config_cjs_namespaceObject.mergeDetectionOptions)(detectionOptions) : config_cjs_namespaceObject.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 || config_cjs_namespaceObject.DEFAULT_I18NEXT_DETECTION_OPTIONS.lookupQuerystring || 'lng',
+        lookupCookie: mergedDetection.lookupCookie || config_cjs_namespaceObject.DEFAULT_I18NEXT_DETECTION_OPTIONS.lookupCookie || 'i18next',
+        lookupFromHeaderKey: mergedDetection.lookupHeader || config_cjs_namespaceObject.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 } = (0, utils_cjs_namespaceObject.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 = 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;
+exports["default"] = __webpack_exports__["default"];
+exports.i18nServerPlugin = __webpack_exports__.i18nServerPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "default",
+    "i18nServerPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/shared/deepMerge.cjs

@@ -0,0 +1,54 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    deepMerge: ()=>deepMerge
+});
+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;
+}
+exports.deepMerge = __webpack_exports__.deepMerge;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "deepMerge"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/shared/detection.cjs

@@ -0,0 +1,105 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    detectLanguageFromRequest: ()=>detectLanguageFromRequest
+});
+const config_cjs_namespaceObject = require("../runtime/i18n/detection/config.cjs");
+function detectLanguageFromRequest(req, languages, detectionOptions) {
+    try {
+        const mergedDetection = detectionOptions ? (0, config_cjs_namespaceObject.mergeDetectionOptions)(detectionOptions) : config_cjs_namespaceObject.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 || config_cjs_namespaceObject.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 || config_cjs_namespaceObject.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 || config_cjs_namespaceObject.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;
+}
+exports.detectLanguageFromRequest = __webpack_exports__.detectLanguageFromRequest;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "detectLanguageFromRequest"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/shared/type.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/shared/utils.cjs

@@ -0,0 +1,78 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    getBackendOptions: ()=>getBackendOptions,
+    getEntryConfig: ()=>getEntryConfig,
+    getLocaleDetectionOptions: ()=>getLocaleDetectionOptions,
+    removeEntryConfigKey: ()=>removeEntryConfigKey
+});
+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;
+}
+exports.getBackendOptions = __webpack_exports__.getBackendOptions;
+exports.getEntryConfig = __webpack_exports__.getEntryConfig;
+exports.getLocaleDetectionOptions = __webpack_exports__.getLocaleDetectionOptions;
+exports.removeEntryConfigKey = __webpack_exports__.removeEntryConfigKey;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getBackendOptions",
+    "getEntryConfig",
+    "getLocaleDetectionOptions",
+    "removeEntryConfigKey"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/esm/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";
+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/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";
+import { buildLocalizedUrl } from "./utils";
+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 };

package/dist/esm/runtime/context.js

@@ -0,0 +1,101 @@
+import { jsx } from "react/jsx-runtime";
+import { isBrowser } from "@modern-js/runtime";
+import { createContext, useCallback, useContext, useMemo } from "react";
+import { cacheUserLanguage } from "./i18n/detection";
+import { buildLocalizedUrl, getEntryPath, shouldIgnoreRedirect, useRouterHooks } from "./utils";
+const ModernI18nContext = /*#__PURE__*/ createContext(null);
+const ModernI18nProvider = ({ children, value })=>/*#__PURE__*/ jsx(ModernI18nContext.Provider, {
+        value: value,
+        children: children
+    });
+const useModernI18n = ()=>{
+    const context = useContext(ModernI18nContext);
+    if (!context) throw new Error('useModernI18n must be used within a ModernI18nProvider');
+    const { language: contextLanguage, i18nInstance, languages, localePathRedirect, ignoreRedirectRoutes, updateLanguage } = context;
+    const { navigate, location, hasRouter } = useRouterHooks();
+    const currentLanguage = contextLanguage;
+    const changeLanguage = useCallback(async (newLang)=>{
+        try {
+            if (!newLang || 'string' != typeof newLang) throw new Error('Language must be a non-empty string');
+            await i18nInstance?.setLang?.(newLang);
+            await i18nInstance?.changeLanguage?.(newLang);
+            if (isBrowser()) {
+                const detectionOptions = i18nInstance.options?.detection;
+                cacheUserLanguage(i18nInstance, newLang, detectionOptions);
+            }
+            if (localePathRedirect && isBrowser() && hasRouter && navigate && location) {
+                const currentPath = location.pathname;
+                const entryPath = getEntryPath();
+                const relativePath = currentPath.replace(entryPath, '');
+                if (!shouldIgnoreRedirect(relativePath, languages || [], ignoreRedirectRoutes)) {
+                    const newPath = buildLocalizedUrl(relativePath, newLang, languages || []);
+                    const newUrl = entryPath + newPath + location.search + location.hash;
+                    await navigate(newUrl, {
+                        replace: true
+                    });
+                }
+            } else if (localePathRedirect && isBrowser() && !hasRouter) {
+                const currentPath = window.location.pathname;
+                const entryPath = getEntryPath();
+                const relativePath = currentPath.replace(entryPath, '');
+                if (!shouldIgnoreRedirect(relativePath, languages || [], ignoreRedirectRoutes)) {
+                    const newPath = buildLocalizedUrl(relativePath, newLang, languages || []);
+                    const newUrl = entryPath + newPath + window.location.search + window.location.hash;
+                    window.history.pushState(null, '', newUrl);
+                }
+            }
+            if (updateLanguage) updateLanguage(newLang);
+        } catch (error) {
+            console.error('Failed to change language:', error);
+            throw error;
+        }
+    }, [
+        i18nInstance,
+        updateLanguage,
+        localePathRedirect,
+        ignoreRedirectRoutes,
+        languages,
+        hasRouter,
+        navigate,
+        location
+    ]);
+    const isLanguageSupported = useCallback((lang)=>languages?.includes(lang) || false, [
+        languages
+    ]);
+    const isResourcesReady = useMemo(()=>{
+        if (!i18nInstance?.isInitialized) return false;
+        const backend = i18nInstance?.services?.backend;
+        if (backend && 'function' == typeof backend.isLoading) {
+            const loadingResources = backend.getLoadingResources();
+            const isCurrentLanguageLoading = loadingResources.some(({ language })=>language === currentLanguage);
+            if (isCurrentLanguageLoading) return false;
+        }
+        const store = i18nInstance.store;
+        if (!store?.data) return false;
+        const langData = store.data[currentLanguage];
+        if (!langData || 'object' != typeof langData) return false;
+        const options = i18nInstance.options;
+        const namespaces = options?.ns || options?.defaultNS || [
+            'translation'
+        ];
+        const requiredNamespaces = Array.isArray(namespaces) ? namespaces : [
+            namespaces
+        ];
+        return requiredNamespaces.every((ns)=>{
+            const nsData = langData[ns];
+            return nsData && 'object' == typeof nsData && Object.keys(nsData).length > 0;
+        });
+    }, [
+        currentLanguage,
+        i18nInstance
+    ]);
+    return {
+        language: currentLanguage,
+        changeLanguage,
+        i18nInstance,
+        supportedLanguages: languages || [],
+        isLanguageSupported,
+        isResourcesReady
+    };
+};
+export { ModernI18nProvider, useModernI18n };