@bleedingdev/modern-js-plugin-i18n 3.5.0-ultramodern.6 → 3.5.0-ultramodern.76

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

@@ -0,0 +1,78 @@
+import "node:module";
+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";
+import { useI18nRouterAdapter } from "./routerAdapter.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 { location } = useI18nRouterAdapter();
+            useEffect(()=>{
+                if (i18nInstance?.language) {
+                    const translator = i18nInstance.translator;
+                    if (translator) translator.language = i18nInstance.language;
+                }
+            }, [
+                i18nInstance?.language
+            ]);
+            useEffect(()=>{
+                prevLangRef.current = lang;
+            }, [
+                lang
+            ]);
+            useSdkResourcesLoader(i18nInstance, setForceUpdate);
+            const synchronizeLanguage = useLanguageSync(i18nInstance, localePathRedirect, languages, location?.pathname, prevLangRef, setLang);
+            useClientSideRedirect(i18nInstance, localePathRedirect, languages, fallbackLanguage, ignoreRedirectRoutes, localisedUrls);
+            const contextValue = useMemo(()=>createContextValue(lang, i18nInstance, entryName, languages, localePathRedirect, ignoreRedirectRoutes, localisedUrls, setLang, synchronizeLanguage), [
+                lang,
+                i18nInstance,
+                entryName,
+                languages,
+                localePathRedirect,
+                ignoreRedirectRoutes,
+                localisedUrls,
+                forceUpdate,
+                synchronizeLanguage
+            ]);
+            const children = props.children;
+            let appContent = App ? /*#__PURE__*/ jsx(App, {
+                ...props,
+                children: children
+            }) : children;
+            if (i18nInstance) {
+                const I18nextProvider = getI18nextProvider();
+                if (I18nextProvider) {
+                    const i18nextInstanceForProvider = getI18nextInstanceForProvider(i18nInstance, lang);
+                    appContent = /*#__PURE__*/ jsx(I18nextProvider, {
+                        i18n: i18nextInstanceForProvider,
+                        children: appContent
+                    });
+                }
+            }
+            return /*#__PURE__*/ jsxs(Fragment, {
+                children: [
+                    Boolean(htmlLangAttr) && /*#__PURE__*/ jsx(Helmet, {
+                        htmlAttributes: {
+                            lang
+                        }
+                    }),
+                    /*#__PURE__*/ jsx(ModernI18nProvider, {
+                        value: contextValue,
+                        children: appContent
+                    })
+                ]
+            });
+        };
+export { createI18nRootWrapper };

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

@@ -0,0 +1,6 @@
+import "node:module";
+const resolveReactI18nextIntegration = async (reactI18next, loadReactI18nextIntegration)=>{
+    if (!reactI18next) return null;
+    return loadReactI18nextIntegration?.() ?? null;
+};
+export { resolveReactI18nextIntegration };

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

@@ -66,28 +66,36 @@ const useI18nRouterAdapter = ()=>{
     const [, setRouterVersion] = useState(0);
     const hasRouter = 'tanstack' === framework || 'react-router' === framework || Boolean(reactRouterNavigate);
     useEffect(()=>{
-        if ('tanstack' !== framework) return;
         const router = getRouterInstance(internalContext, contextRouter);
         if (!router) return;
         const update = ()=>setRouterVersion((version)=>version + 1);
         const unsubscribers = [];
-        if ('function' == typeof router.stores?.location?.subscribe) {
-            const unsubscribe = router.stores.location.subscribe(update);
+        if ('react-router' === framework && !inReactRouter && 'function' == typeof router.subscribe) {
+            const subscribe = router.subscribe;
+            const unsubscribe = subscribe.call(router, update);
             if ('function' == typeof unsubscribe) unsubscribers.push(unsubscribe);
         }
-        if ('function' == typeof router.subscribe) for (const eventType of [
-            'onBeforeNavigate',
-            'onBeforeLoad'
-        ]){
-            const unsubscribe = router.subscribe(eventType, update);
+        if ('tanstack' === framework && 'function' == typeof router.stores?.location?.subscribe) {
+            const unsubscribe = router.stores.location.subscribe(update);
             if ('function' == typeof unsubscribe) unsubscribers.push(unsubscribe);
         }
+        if ('tanstack' === framework && 'function' == typeof router.subscribe) {
+            const subscribe = router.subscribe;
+            for (const eventType of [
+                'onBeforeNavigate',
+                'onBeforeLoad'
+            ]){
+                const unsubscribe = subscribe.call(router, eventType, update);
+                if ('function' == typeof unsubscribe) unsubscribers.push(unsubscribe);
+            }
+        }
         return ()=>{
             for (const unsubscribe of unsubscribers)unsubscribe();
         };
     }, [
         contextRouter,
         framework,
+        inReactRouter,
         internalContext
     ]);
     const navigate = useCallback((href, options)=>{

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

@@ -1,7 +1,7 @@
 import "node:module";
 import { isBrowser } from "@modern-js/runtime";
 import { getGlobalBasename } from "@modern-js/runtime/context";
-import { localiseTargetPathname } from "../shared/localisedUrls.mjs";
+import { localiseTargetPathname, shouldSkipLocaleRedirect } from "../shared/localisedUrls.mjs";
 const getPathname = (context)=>{
     if (isBrowser()) return window.location.pathname;
     return context.ssrContext?.request?.pathname || '/';
@@ -52,13 +52,5 @@ const detectLanguageFromPath = (pathname, languages, localePathRedirect)=>{
         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 shouldIgnoreRedirect = (pathname, languages, ignoreRedirectRoutes)=>shouldSkipLocaleRedirect(pathname, languages, ignoreRedirectRoutes);
 export { buildLocalizedUrl, detectLanguageFromPath, getEntryPath, getLanguageFromPath, getPathname, shouldIgnoreRedirect, splitUrlTarget };

package/dist/esm-node/server/apiPrefix.mjs

@@ -0,0 +1,32 @@
+import "node:module";
+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-node/server/detectorOptions.mjs

@@ -0,0 +1,60 @@
+import "node:module";
+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-node/server/index.mjs

@@ -1,138 +1,11 @@
 import "node:module";
-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 * 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;
-};
+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_0af3baa7 from "@modern-js/server-core/hono";
+const { languageDetector: languageDetector } = __rspack_external__modern_js_server_core_hono_0af3baa7;
 const i18nServerPlugin = (options)=>({
         name: '@modern-js/plugin-i18n/server',
         setup: (api)=>{
@@ -201,12 +74,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-node/server/redirectPolicy.mjs

@@ -0,0 +1,47 @@
+import "node:module";
+import { isDefaultLocaleRedirectSkipPath, localiseTargetPathname, matchesPathPrefix, shouldSkipLocaleRedirect, stripLanguagePrefix } from "../shared/localisedUrls.mjs";
+const stripUrlPathPrefix = (pathname, urlPath)=>{
+    const basePath = urlPath.replace('/*', '');
+    if (!basePath || '/' === basePath) return pathname;
+    const remainingPath = pathname.startsWith(basePath) ? pathname.slice(basePath.length) : pathname;
+    return remainingPath || '/';
+};
+const shouldIgnoreRedirect = (pathname, urlPath, ignoreRedirectRoutes)=>{
+    const remainingPath = stripUrlPathPrefix(pathname, urlPath);
+    return shouldSkipLocaleRedirect(remainingPath, [], ignoreRedirectRoutes);
+};
+const isStaticResourceRequest = (pathname, staticRoutePrefixes, languages = [])=>{
+    if (isDefaultLocaleRedirectSkipPath(pathname, languages)) return true;
+    const matchesStaticRoutePrefix = (targetPathname)=>staticRoutePrefixes.some((prefix)=>matchesPathPrefix(targetPathname, prefix));
+    if (matchesStaticRoutePrefix(pathname)) return true;
+    const pathWithoutLanguage = stripLanguagePrefix(pathname, languages);
+    return pathWithoutLanguage !== pathname && matchesStaticRoutePrefix(pathWithoutLanguage);
+};
+const getLanguageFromPath = (req, urlPath, languages)=>{
+    const url = new URL(req.url, `http://${req.header().host}`);
+    const pathname = url.pathname;
+    const remainingPath = stripUrlPathPrefix(pathname, urlPath);
+    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 = stripUrlPathPrefix(pathname, urlPath);
+    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-node/shared/detection.mjs

@@ -1,72 +1,2 @@
 import "node:module";
-import { DEFAULT_I18NEXT_DETECTION_OPTIONS, mergeDetectionOptions } from "../runtime/i18n/detection/config.mjs";
-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 };
+import "../runtime/i18n/detection/config.mjs";

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

@@ -0,0 +1,12 @@
+import "node:module";
+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-node/shared/localisedUrls/index.mjs

@@ -0,0 +1,8 @@
+import "node:module";
+export { resolveLocalisedUrlsConfig } from "./config.mjs";
+export { normalisePathPattern, normalisePathname } from "./normalise.mjs";
+export { canonicalTargetPathname, localiseTargetPathname, stripLanguagePrefix } from "./pathname.mjs";
+export { buildPathFromPattern, matchPathPattern } from "./patterns.mjs";
+export { DEFAULT_LOCALE_REDIRECT_SKIP_RULES, isDefaultLocaleRedirectSkipPath, matchesPathPrefix, shouldSkipLocaleRedirect } from "./redirect.mjs";
+export { resolveCanonicalLocalisedPath, resolveLocalisedPath } from "./resolve.mjs";
+export { applyLocalisedUrlsToRoutes, validateLocalisedUrls } from "./routes.mjs";

package/dist/esm-node/shared/localisedUrls/normalise.mjs

@@ -0,0 +1,38 @@
+import "node:module";
+const LOCALE_PARAM_NAMES = new Set([
+    'lang',
+    'locale',
+    'language'
+]);
+const normaliseSlashes = (path)=>{
+    const withoutDuplicateSlashes = path.replace(/\/+/g, '/');
+    const withLeadingSlash = withoutDuplicateSlashes.startsWith('/') ? withoutDuplicateSlashes : `/${withoutDuplicateSlashes}`;
+    return withLeadingSlash.length > 1 ? withLeadingSlash.replace(/\/+$/, '') : withLeadingSlash;
+};
+const normalisePathPattern = (path)=>normaliseSlashes(path).replace(/\[(.+?)\]/g, ':$1');
+const normalisePathname = (pathname)=>normaliseSlashes(pathname);
+const normaliseRoutePath = (path)=>{
+    const normalized = normalisePathPattern(path);
+    return '/' === normalized ? '' : normalized.slice(1);
+};
+const getLocaleParamSegment = (segment)=>{
+    if (!segment.startsWith(':')) return null;
+    const paramName = segment.slice(1).replace(/\?$/, '');
+    return LOCALE_PARAM_NAMES.has(paramName) ? segment : null;
+};
+const splitPathSegments = (path)=>{
+    if (!path) return [];
+    return normalisePathPattern(path).split('/').filter(Boolean);
+};
+const stripLeadingLocaleParam = (path)=>{
+    const segments = splitPathSegments(path);
+    const leadingLocaleParam = getLocaleParamSegment(segments[0] || '');
+    if (!leadingLocaleParam) return path;
+    const remainingPath = segments.slice(1).join('/');
+    return remainingPath ? `/${remainingPath}` : void 0;
+};
+const getLeadingLocaleParam = (path)=>{
+    const segments = splitPathSegments(path);
+    return getLocaleParamSegment(segments[0] || '');
+};
+export { getLeadingLocaleParam, normalisePathPattern, normalisePathname, normaliseRoutePath, stripLeadingLocaleParam };

package/dist/esm-node/shared/localisedUrls/pathname.mjs

@@ -0,0 +1,25 @@
+import "node:module";
+import { resolveLocalisedUrlsConfig } from "./config.mjs";
+import { resolveCanonicalLocalisedPath, resolveLocalisedPath } from "./resolve.mjs";
+const stripLanguagePrefix = (pathname, languages)=>{
+    const segments = pathname.split('/').filter(Boolean);
+    const firstSegment = segments[0]?.toLowerCase();
+    if (firstSegment && languages.some((language)=>language.toLowerCase() === firstSegment)) return `/${segments.slice(1).join('/')}`;
+    return pathname || '/';
+};
+const localiseTargetPathname = (pathname, language, languages, localisedUrls)=>{
+    const pathWithoutLanguage = stripLanguagePrefix(pathname, languages);
+    const localisedUrlsConfig = resolveLocalisedUrlsConfig(localisedUrls);
+    const resolvedPath = localisedUrlsConfig.enabled ? resolveLocalisedPath(pathWithoutLanguage, language, languages, localisedUrlsConfig.map) : pathWithoutLanguage;
+    const resolvedSegments = resolvedPath.split('/').filter(Boolean);
+    return `/${[
+        language,
+        ...resolvedSegments
+    ].join('/')}`;
+};
+const canonicalTargetPathname = (pathname, languages, localisedUrls)=>{
+    const pathWithoutLanguage = stripLanguagePrefix(pathname, languages);
+    const localisedUrlsConfig = resolveLocalisedUrlsConfig(localisedUrls);
+    return localisedUrlsConfig.enabled ? resolveCanonicalLocalisedPath(pathWithoutLanguage, languages, localisedUrlsConfig.map) : pathWithoutLanguage;
+};
+export { canonicalTargetPathname, localiseTargetPathname, stripLanguagePrefix };