@bleedingdev/modern-js-plugin-i18n 3.5.0-ultramodern.3 → 3.5.0-ultramodern.31

package/dist/esm/runtime/i18n/detection/priority.mjs

@@ -0,0 +1,28 @@
+import { isI18nWrapperInstance } from "../instance.mjs";
+import { detectLanguageFromI18nextDetector } from "./detector.mjs";
+import { mergeDetectionOptions } from "./initOptions.mjs";
+import { readLanguageFromStorage } from "./middleware.mjs";
+import { detectLanguageFromPathPriority } from "./path.mjs";
+import { detectLanguageFromSSR } from "./ssr.mjs";
+const detectLanguageWithPriority = async (i18nInstance, options)=>{
+    const { languages, fallbackLanguage, localePathRedirect, i18nextDetector, detection, userInitOptions, pathname, ssrContext } = options;
+    let detectedLanguage;
+    detectedLanguage = detectLanguageFromPathPriority(pathname, languages, localePathRedirect);
+    if (!detectedLanguage) detectedLanguage = detectLanguageFromSSR(languages);
+    if (!detectedLanguage && i18nextDetector) detectedLanguage = isI18nWrapperInstance(i18nInstance) ? readLanguageFromStorage(mergeDetectionOptions(i18nextDetector, detection, localePathRedirect, userInitOptions)) : await detectLanguageFromI18nextDetector(i18nInstance, {
+        languages,
+        fallbackLanguage,
+        localePathRedirect,
+        i18nextDetector,
+        detection,
+        userInitOptions,
+        mergedBackend: options.mergedBackend,
+        ssrContext
+    });
+    const finalLanguage = detectedLanguage || userInitOptions?.lng || fallbackLanguage;
+    return {
+        detectedLanguage,
+        finalLanguage
+    };
+};
+export { detectLanguageWithPriority };

package/dist/esm/runtime/i18n/detection/ssr.mjs

@@ -0,0 +1,26 @@
+import { isBrowser } from "@modern-js/runtime";
+import { getSupportedLanguage } from "./language.mjs";
+function exportServerLngToWindow(context, lng) {
+    context.__i18nData__ = {
+        lng
+    };
+}
+const getLanguageFromSSRData = (window1)=>{
+    try {
+        const ssrData = window1._SSR_DATA;
+        if (!ssrData || !ssrData.data || !ssrData.data.i18nData) return;
+        const lng = ssrData.data.i18nData.lng;
+        return 'string' == typeof lng && '' !== lng.trim() ? lng : void 0;
+    } catch (error) {
+        return;
+    }
+};
+const detectLanguageFromSSR = (languages)=>{
+    if (!isBrowser()) return;
+    try {
+        const ssrLanguage = getLanguageFromSSRData(window);
+        const supportedLanguage = getSupportedLanguage(ssrLanguage, languages);
+        if (supportedLanguage) return supportedLanguage;
+    } catch (error) {}
+};
+export { detectLanguageFromSSR, exportServerLngToWindow, getLanguageFromSSRData };

package/dist/esm/runtime/linkHelpers.mjs

@@ -0,0 +1,98 @@
+const warnedTargets = new Set();
+const warnOnce = (key, message)=>{
+    if ('development' !== process.env.NODE_ENV || warnedTargets.has(key)) return;
+    warnedTargets.add(key);
+    console.warn(message);
+};
+const interpolateRouteParams = (pathname, params)=>{
+    if (!/[$:*{]/.test(pathname)) return pathname;
+    const resolveParam = (name)=>{
+        const value = params?.[name];
+        return void 0 === value ? void 0 : String(value);
+    };
+    const segments = pathname.split('/').map((segment)=>{
+        if (!segment) return segment;
+        if (segment.startsWith('{-$') && segment.endsWith('}')) {
+            const value = resolveParam(segment.slice(3, -1));
+            return void 0 === value ? null : encodeURIComponent(value);
+        }
+        if ('$' === segment || '*' === segment) {
+            const value = resolveParam('_splat') ?? resolveParam('*');
+            return void 0 === value ? null : value.split('/').map(encodeURIComponent).join('/');
+        }
+        if (segment.startsWith('$')) {
+            const value = resolveParam(segment.slice(1));
+            if (void 0 === value) {
+                warnOnce(`missing-param:${pathname}:${segment}`, `[plugin-i18n] <Link to="${pathname}"> is missing required param "${segment.slice(1)}".`);
+                return segment;
+            }
+            return encodeURIComponent(value);
+        }
+        if (segment.startsWith(':')) {
+            const optional = segment.endsWith('?');
+            const name = segment.slice(1, optional ? -1 : void 0);
+            const value = resolveParam(name);
+            if (void 0 === value) {
+                if (optional) return null;
+                warnOnce(`missing-param:${pathname}:${segment}`, `[plugin-i18n] <Link to="${pathname}"> is missing required param "${name}".`);
+                return segment;
+            }
+            return encodeURIComponent(value);
+        }
+        return segment;
+    }).filter((segment)=>null !== segment);
+    return segments.join('/') || '/';
+};
+const normalizeSearch = (search, searchFromTo)=>{
+    if (search && 'object' == typeof search) {
+        const searchObject = {};
+        const params = new URLSearchParams();
+        for (const [key, value] of Object.entries(search)){
+            if (null == value) continue;
+            if (Array.isArray(value)) {
+                const values = value.filter((item)=>null != item).map(String);
+                if (0 === values.length) continue;
+                searchObject[key] = values;
+                for (const item of values)params.append(key, item);
+                continue;
+            }
+            const stringValue = String(value);
+            searchObject[key] = stringValue;
+            params.append(key, stringValue);
+        }
+        const serialized = params.toString();
+        return {
+            searchString: serialized ? `?${serialized}` : '',
+            searchObject: Object.keys(searchObject).length > 0 ? searchObject : void 0
+        };
+    }
+    const raw = 'string' == typeof search ? search : searchFromTo;
+    if (!raw) return {
+        searchString: '',
+        searchObject: void 0
+    };
+    const searchString = raw.startsWith('?') ? raw : `?${raw}`;
+    const searchObject = {};
+    new URLSearchParams(searchString).forEach((value, key)=>{
+        const existing = searchObject[key];
+        if (void 0 === existing) searchObject[key] = value;
+        else if (Array.isArray(existing)) existing.push(value);
+        else searchObject[key] = [
+            existing,
+            value
+        ];
+    });
+    return {
+        searchString,
+        searchObject
+    };
+};
+const splitActiveProps = (active, activeProps)=>{
+    if (!active || !activeProps) return {};
+    return activeProps;
+};
+const mergeClassNames = (...values)=>{
+    const classNames = values.filter((value)=>'string' == typeof value && value.length > 0);
+    return classNames.length > 0 ? classNames.join(' ') : void 0;
+};
+export { interpolateRouteParams, mergeClassNames, normalizeSearch, splitActiveProps, warnOnce };

package/dist/esm/runtime/pluginSetup.mjs

@@ -0,0 +1,64 @@
+import { isBrowser } from "@modern-js/runtime";
+import { merge } from "@modern-js/runtime-utils/merge";
+import { getI18nInstance } from "./i18n/index.mjs";
+import { mergeBackendOptions } from "./i18n/backend/index.mjs";
+import { detectLanguageWithPriority, exportServerLngToWindow, mergeDetectionOptions } from "./i18n/detection/index.mjs";
+import { useI18nextLanguageDetector } from "./i18n/detection/middleware.mjs";
+import { getPathname } from "./utils.mjs";
+let i18nLifecycleHelpersPromise;
+function loadI18nLifecycleHelpers() {
+    i18nLifecycleHelpersPromise ??= Promise.all([
+        import("./i18n/backend/middleware.mjs"),
+        import("./i18n/utils.mjs")
+    ]).then(([backendMiddleware, utils])=>({
+            useI18nextBackend: backendMiddleware.useI18nextBackend,
+            changeI18nLanguage: utils.changeI18nLanguage,
+            ensureLanguageMatch: utils.ensureLanguageMatch,
+            initializeI18nInstance: utils.initializeI18nInstance,
+            setupClonedInstance: utils.setupClonedInstance
+        }));
+    return i18nLifecycleHelpersPromise;
+}
+async function setupI18nBeforeRender(context, options) {
+    const { api, userI18nInstance, initOptions, backend, backendEnabled, i18nextDetector, detection, localePathRedirect, languages, fallbackLanguage, resolveReactI18nextIntegration, setI18nextProvider } = options;
+    const { useI18nextBackend, changeI18nLanguage, ensureLanguageMatch, initializeI18nInstance, setupClonedInstance } = await loadI18nLifecycleHelpers();
+    let i18nInstance = await getI18nInstance(userI18nInstance);
+    const { i18n: otherConfig } = api.getRuntimeConfig();
+    const { initOptions: otherInitOptions } = otherConfig || {};
+    const userInitOptions = merge(otherInitOptions || {}, initOptions || {});
+    const reactI18nextIntegration = await resolveReactI18nextIntegration();
+    setI18nextProvider(reactI18nextIntegration?.I18nextProvider ?? null);
+    if (reactI18nextIntegration?.initReactI18next) i18nInstance.use(reactI18nextIntegration.initReactI18next);
+    const pathname = getPathname(context);
+    if (i18nextDetector) useI18nextLanguageDetector(i18nInstance);
+    const mergedDetection = mergeDetectionOptions(i18nextDetector, detection, localePathRedirect, userInitOptions);
+    const mergedBackend = mergeBackendOptions(backend, userInitOptions);
+    const hasSdkConfig = 'function' == typeof userInitOptions?.backend?.sdk || mergedBackend?.sdk && 'function' == typeof mergedBackend.sdk;
+    if (mergedBackend && (backendEnabled || hasSdkConfig)) useI18nextBackend(i18nInstance, mergedBackend);
+    const { finalLanguage } = await detectLanguageWithPriority(i18nInstance, {
+        languages,
+        fallbackLanguage,
+        localePathRedirect,
+        i18nextDetector,
+        detection,
+        userInitOptions,
+        mergedBackend,
+        pathname,
+        ssrContext: context.ssrContext
+    });
+    await initializeI18nInstance(i18nInstance, finalLanguage, fallbackLanguage, languages, mergedDetection, mergedBackend, userInitOptions);
+    if (!isBrowser() && i18nInstance.cloneInstance) {
+        i18nInstance = i18nInstance.cloneInstance();
+        await setupClonedInstance(i18nInstance, finalLanguage, fallbackLanguage, languages, backendEnabled, backend, i18nextDetector, detection, localePathRedirect, userInitOptions);
+    }
+    if (localePathRedirect) await ensureLanguageMatch(i18nInstance, finalLanguage);
+    if (!isBrowser()) exportServerLngToWindow(context, finalLanguage);
+    context.i18nInstance = i18nInstance;
+    context.changeLanguage = async (newLang)=>{
+        await changeI18nLanguage(i18nInstance, newLang, {
+            detectionOptions: mergedDetection
+        });
+    };
+    return i18nInstance;
+}
+export { setupI18nBeforeRender };

package/dist/esm/runtime/providerComposition.mjs

@@ -0,0 +1,75 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { RuntimeContext } from "@modern-js/runtime";
+import { Helmet } from "@modern-js/runtime/head";
+import { useContext, useEffect, useMemo, useRef, useState } from "react";
+import { ModernI18nProvider } from "./context.mjs";
+import { createContextValue, useClientSideRedirect, useLanguageSync, useSdkResourcesLoader } from "./hooks.mjs";
+import { getI18nextInstanceForProvider } from "./i18n/instance.mjs";
+const createI18nRootWrapper = (options)=>(App)=>(props)=>{
+            const { entryName, htmlLangAttr, localePathRedirect, languages, fallbackLanguage, ignoreRedirectRoutes, localisedUrls, getLatestI18nInstance, getI18nextProvider } = options;
+            const runtimeContext = useContext(RuntimeContext);
+            const i18nInstance = runtimeContext.i18nInstance || getLatestI18nInstance();
+            const initialLang = useMemo(()=>i18nInstance?.language || fallbackLanguage, [
+                i18nInstance?.language,
+                fallbackLanguage
+            ]);
+            const [lang, setLang] = useState(initialLang);
+            const [forceUpdate, setForceUpdate] = useState(0);
+            const prevLangRef = useRef(lang);
+            const runtimeContextRef = useRef(runtimeContext);
+            runtimeContextRef.current = runtimeContext;
+            useEffect(()=>{
+                if (i18nInstance?.language) {
+                    const translator = i18nInstance.translator;
+                    if (translator) translator.language = i18nInstance.language;
+                }
+            }, [
+                i18nInstance?.language
+            ]);
+            useEffect(()=>{
+                prevLangRef.current = lang;
+            }, [
+                lang
+            ]);
+            useSdkResourcesLoader(i18nInstance, setForceUpdate);
+            useLanguageSync(i18nInstance, localePathRedirect, languages, runtimeContextRef, prevLangRef, setLang);
+            useClientSideRedirect(i18nInstance, localePathRedirect, languages, fallbackLanguage, ignoreRedirectRoutes, localisedUrls);
+            const contextValue = useMemo(()=>createContextValue(lang, i18nInstance, entryName, languages, localePathRedirect, ignoreRedirectRoutes, localisedUrls, setLang), [
+                lang,
+                i18nInstance,
+                entryName,
+                languages,
+                localePathRedirect,
+                ignoreRedirectRoutes,
+                localisedUrls,
+                forceUpdate
+            ]);
+            const children = props.children;
+            const appContent = /*#__PURE__*/ jsxs(Fragment, {
+                children: [
+                    Boolean(htmlLangAttr) && /*#__PURE__*/ jsx(Helmet, {
+                        htmlAttributes: {
+                            lang
+                        }
+                    }),
+                    /*#__PURE__*/ jsx(ModernI18nProvider, {
+                        value: contextValue,
+                        children: App ? /*#__PURE__*/ jsx(App, {
+                            ...props,
+                            children: children
+                        }) : children
+                    })
+                ]
+            });
+            if (!i18nInstance) return appContent;
+            const I18nextProvider = getI18nextProvider();
+            if (I18nextProvider) {
+                const i18nextInstanceForProvider = getI18nextInstanceForProvider(i18nInstance);
+                return /*#__PURE__*/ jsx(I18nextProvider, {
+                    i18n: i18nextInstanceForProvider,
+                    children: appContent
+                });
+            }
+            return appContent;
+        };
+export { createI18nRootWrapper };

package/dist/esm/runtime/reactI18next.mjs

@@ -0,0 +1,5 @@
+const resolveReactI18nextIntegration = async (reactI18next, loadReactI18nextIntegration)=>{
+    if (!reactI18next) return null;
+    return loadReactI18nextIntegration?.() ?? null;
+};
+export { resolveReactI18nextIntegration };

package/dist/esm/server/apiPrefix.mjs

@@ -0,0 +1,31 @@
+const normalizeApiPrefix = (prefix)=>{
+    const trimmedPrefix = prefix.trim();
+    if (!trimmedPrefix) return null;
+    const prefixedPath = trimmedPrefix.startsWith('/') ? trimmedPrefix : `/${trimmedPrefix}`;
+    const withoutWildcard = prefixedPath.replace(/\/\*$/, '');
+    const normalizedPrefix = withoutWildcard.length > 1 ? withoutWildcard.replace(/\/+$/, '') : withoutWildcard;
+    return '/' === normalizedPrefix ? null : normalizedPrefix;
+};
+const collectApiPrefixes = (routes, bffPrefix)=>{
+    const prefixes = new Set();
+    for (const route of routes){
+        if (!route.isApi || !route.urlPath) continue;
+        const normalizedPrefix = normalizeApiPrefix(route.urlPath);
+        if (normalizedPrefix) prefixes.add(normalizedPrefix);
+    }
+    const bffPrefixes = Array.isArray(bffPrefix) ? bffPrefix : bffPrefix ? [
+        bffPrefix
+    ] : [];
+    for (const prefix of bffPrefixes){
+        const normalizedPrefix = normalizeApiPrefix(prefix);
+        if (normalizedPrefix) prefixes.add(normalizedPrefix);
+    }
+    return [
+        ...prefixes
+    ];
+};
+const matchesApiPrefix = (pathname, apiPrefixes)=>{
+    const normalizedPathname = pathname.startsWith('/') ? pathname : `/${pathname}`;
+    return apiPrefixes.some((prefix)=>normalizedPathname === prefix || normalizedPathname.startsWith(`${prefix}/`));
+};
+export { collectApiPrefixes, matchesApiPrefix };

package/dist/esm/server/detectorOptions.mjs

@@ -0,0 +1,59 @@
+import { DEFAULT_I18NEXT_DETECTION_OPTIONS, mergeDetectionOptions } from "../runtime/i18n/detection/config.mjs";
+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'
+    ];
+    const cookieMinutes = mergedDetection.cookieMinutes;
+    const cookieMaxAge = 'number' == typeof cookieMinutes && Number.isFinite(cookieMinutes) ? Math.max(0, Math.floor(60 * cookieMinutes)) : 60 * DEFAULT_I18NEXT_DETECTION_OPTIONS.cookieMinutes;
+    const cookieDomain = mergedDetection.cookieDomain;
+    const cookieSecure = mergedDetection.cookieSecure;
+    const cookieHttpOnly = mergedDetection.cookieHttpOnly;
+    const cookieSameSite = mergedDetection.cookieSameSite;
+    const normalizedCookieDomain = 'string' == typeof cookieDomain ? cookieDomain : void 0;
+    const cookieOptions = {
+        maxAge: cookieMaxAge,
+        sameSite: 'None' === cookieSameSite || 'none' === cookieSameSite ? 'None' : 'Lax' === cookieSameSite || 'lax' === cookieSameSite ? 'Lax' : 'Strict',
+        secure: 'boolean' == typeof cookieSecure ? cookieSecure : false,
+        httpOnly: 'boolean' == typeof cookieHttpOnly ? cookieHttpOnly : false,
+        ...normalizedCookieDomain ? {
+            domain: normalizedCookieDomain
+        } : {}
+    };
+    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
+        },
+        ...false !== caches && {
+            cookieOptions
+        },
+        ignoreCase: true
+    };
+};
+export { convertToHonoLanguageDetectorOptions };

package/dist/esm/server/index.mjs

@@ -1,137 +1,10 @@
-import { DEFAULT_I18NEXT_DETECTION_OPTIONS, mergeDetectionOptions } from "../runtime/i18n/detection/config.mjs";
-import { localiseTargetPathname, resolveLocalisedUrlsConfig } from "../shared/localisedUrls.mjs";
+import { resolveLocalisedUrlsConfig } from "../shared/localisedUrls.mjs";
 import { getLocaleDetectionOptions } from "../shared/utils.mjs";
+import { collectApiPrefixes, matchesApiPrefix } from "./apiPrefix.mjs";
+import { convertToHonoLanguageDetectorOptions } from "./detectorOptions.mjs";
+import { buildLocalizedUrl, createLocaleRedirectResponse, getLanguageFromPath, isStaticResourceRequest, shouldIgnoreRedirect } from "./redirectPolicy.mjs";
 import * as __rspack_external__modern_js_server_core_hono_a76ca254 from "@modern-js/server-core/hono";
 const { languageDetector: languageDetector } = __rspack_external__modern_js_server_core_hono_a76ca254;
-const normalizeApiPrefix = (prefix)=>{
-    const trimmedPrefix = prefix.trim();
-    if (!trimmedPrefix) return null;
-    const prefixedPath = trimmedPrefix.startsWith('/') ? trimmedPrefix : `/${trimmedPrefix}`;
-    const withoutWildcard = prefixedPath.replace(/\/\*$/, '');
-    const normalizedPrefix = withoutWildcard.length > 1 ? withoutWildcard.replace(/\/+$/, '') : withoutWildcard;
-    return '/' === normalizedPrefix ? null : normalizedPrefix;
-};
-const collectApiPrefixes = (routes, bffPrefix)=>{
-    const prefixes = new Set();
-    for (const route of routes){
-        if (!route.isApi || !route.urlPath) continue;
-        const normalizedPrefix = normalizeApiPrefix(route.urlPath);
-        if (normalizedPrefix) prefixes.add(normalizedPrefix);
-    }
-    const bffPrefixes = Array.isArray(bffPrefix) ? bffPrefix : bffPrefix ? [
-        bffPrefix
-    ] : [];
-    for (const prefix of bffPrefixes){
-        const normalizedPrefix = normalizeApiPrefix(prefix);
-        if (normalizedPrefix) prefixes.add(normalizedPrefix);
-    }
-    return [
-        ...prefixes
-    ];
-};
-const matchesApiPrefix = (pathname, apiPrefixes)=>{
-    const normalizedPathname = pathname.startsWith('/') ? pathname : `/${pathname}`;
-    return apiPrefixes.some((prefix)=>normalizedPathname === prefix || normalizedPathname.startsWith(`${prefix}/`));
-};
-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'
-    ];
-    const cookieMinutes = mergedDetection.cookieMinutes;
-    const cookieMaxAge = 'number' == typeof cookieMinutes && Number.isFinite(cookieMinutes) ? Math.max(0, Math.floor(60 * cookieMinutes)) : 60 * DEFAULT_I18NEXT_DETECTION_OPTIONS.cookieMinutes;
-    const cookieDomain = mergedDetection.cookieDomain;
-    const cookieSecure = mergedDetection.cookieSecure;
-    const cookieHttpOnly = mergedDetection.cookieHttpOnly;
-    const cookieSameSite = mergedDetection.cookieSameSite;
-    const normalizedCookieDomain = 'string' == typeof cookieDomain ? cookieDomain : void 0;
-    const cookieOptions = {
-        maxAge: cookieMaxAge,
-        sameSite: 'None' === cookieSameSite || 'none' === cookieSameSite ? 'None' : 'Lax' === cookieSameSite || 'lax' === cookieSameSite ? 'Lax' : 'Strict',
-        secure: 'boolean' == typeof cookieSecure ? cookieSecure : false,
-        httpOnly: 'boolean' == typeof cookieHttpOnly ? cookieHttpOnly : false,
-        ...normalizedCookieDomain ? {
-            domain: normalizedCookieDomain
-        } : {}
-    };
-    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
-        },
-        ...false !== caches && {
-            cookieOptions
-        },
-        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, localisedUrls)=>{
-    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 newPathname = localiseTargetPathname(remainingPath, language, languages, localisedUrls);
-    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)=>{
@@ -200,12 +73,12 @@ const i18nServerPlugin = (options)=>({
                                     if (i18nextDetector) detectedLanguage = c.get('language') || null;
                                     const targetLanguage = detectedLanguage || fallbackLanguage;
                                     const localizedUrl = buildLocalizedUrl(c.req, originUrlPath, targetLanguage, languages, localisedUrls);
-                                    return c.redirect(localizedUrl);
+                                    return createLocaleRedirectResponse(localizedUrl);
                                 }
                                 const localisedUrlsConfig = resolveLocalisedUrlsConfig(localisedUrls);
                                 if (localisedUrlsConfig.enabled) {
                                     const expectedUrl = buildLocalizedUrl(c.req, originUrlPath, language, languages, localisedUrls);
-                                    if (expectedUrl !== `${pathname}${url.search}${url.hash}`) return c.redirect(expectedUrl);
+                                    if (expectedUrl !== `${pathname}${url.search}${url.hash}`) return createLocaleRedirectResponse(expectedUrl);
                                 }
                                 await next();
                             }

package/dist/esm/server/redirectPolicy.mjs

@@ -0,0 +1,52 @@
+import { localiseTargetPathname } from "../shared/localisedUrls.mjs";
+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, localisedUrls)=>{
+    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 newPathname = localiseTargetPathname(remainingPath, language, languages, localisedUrls);
+    const suffix = `${url.search}${url.hash}`;
+    const localizedUrl = '/' === basePath ? newPathname + suffix : basePath + newPathname + suffix;
+    return localizedUrl;
+};
+const createLocaleRedirectResponse = (location)=>new Response(null, {
+        status: 302,
+        headers: {
+            'Cache-Control': 'private, no-store',
+            Location: location,
+            Vary: 'Accept-Language, Cookie'
+        }
+    });
+export { buildLocalizedUrl, createLocaleRedirectResponse, getLanguageFromPath, isStaticResourceRequest, shouldIgnoreRedirect };

package/dist/esm/shared/localisedUrls/config.mjs

@@ -0,0 +1,11 @@
+const resolveLocalisedUrlsConfig = (option)=>{
+    if (option && 'object' == typeof option && Object.keys(option).length > 0) return {
+        enabled: true,
+        map: option
+    };
+    return {
+        enabled: false,
+        map: {}
+    };
+};
+export { resolveLocalisedUrlsConfig };

package/dist/esm/shared/localisedUrls/index.mjs

@@ -0,0 +1,6 @@
+export { resolveLocalisedUrlsConfig } from "./config.mjs";
+export { normalisePathPattern, normalisePathname } from "./normalise.mjs";
+export { canonicalTargetPathname, localiseTargetPathname } from "./pathname.mjs";
+export { buildPathFromPattern, matchPathPattern } from "./patterns.mjs";
+export { resolveCanonicalLocalisedPath, resolveLocalisedPath } from "./resolve.mjs";
+export { applyLocalisedUrlsToRoutes, validateLocalisedUrls } from "./routes.mjs";