@bleedingdev/modern-js-plugin-i18n 3.9.0-ultramodern.8 → 3.9.3-ultramodern.1

package/dist/esm-node/cli/localisedRoutes.mjs

@@ -0,0 +1,10 @@
+import "node:module";
+import { applyLocalisedUrlsToRoutes, resolveLocalisedUrlsConfig } from "@modern-js/i18n-runtime-extensions";
+import { getEntrypointRoutesOwner } from "@modern-js/runtime/cli";
+const applyLocalisedRoutes = (routes, localeDetection, entrypoint)=>{
+    const { localePathRedirect, languages = [], localisedUrls } = localeDetection ?? {};
+    const resolved = resolveLocalisedUrlsConfig(localisedUrls);
+    if (!localePathRedirect || !languages.length || !resolved.enabled) return routes;
+    return applyLocalisedUrlsToRoutes(routes, languages, resolved.map, entrypoint && '@modern-js/plugin-tanstack' === getEntrypointRoutesOwner(entrypoint) ? 'canonical' : 'physical');
+};
+export { applyLocalisedRoutes };

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

@@ -1,18 +1,10 @@
 import "node:module";
 import { jsx } from "react/jsx-runtime";
 import { RuntimeComponentResolverContext } from "@modern-js/runtime/context";
-import { createContext, useCallback, useContext, useEffect, useMemo } from "react";
+import { useCallback, useContext, useEffect, useMemo } from "react";
 import { changeModernI18nLanguage, getPathLanguage, isI18nLanguageSupported, isI18nResourcesReady, translateI18n } from "./contextHelpers.mjs";
 import { useI18nRouterAdapter } from "./routerAdapter.mjs";
-const modernI18nContextKey = Symbol.for('@modern-js/plugin-i18n/runtime/ModernI18nContext');
-const reactI18nextProviderContextKey = Symbol.for('@modern-js/plugin-i18n/runtime/ReactI18nextProviderContext');
-const getGlobalContext = (key, defaultValue)=>{
-    const globalStore = globalThis;
-    globalStore[key] ??= /*#__PURE__*/ createContext(defaultValue);
-    return globalStore[key];
-};
-const ModernI18nContext = getGlobalContext(modernI18nContextKey, null);
-const ReactI18nextProviderContext = getGlobalContext(reactI18nextProviderContextKey, null);
+import { ModernI18nContext, ReactI18nextProviderContext } from "./sharedContexts.mjs";
 const ModernI18nProvider = ({ children, i18nextProvider, value })=>{
     const content = /*#__PURE__*/ jsx(ModernI18nContext.Provider, {
         value: value,

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

@@ -0,0 +1,6 @@
+import "node:module";
+import { createContext } from "react";
+const ModernI18nContext = createContext(null);
+const ReactI18nextProviderContext = createContext(null);
+const I18nNavigationContext = createContext(null);
+export { I18nNavigationContext, ModernI18nContext, ReactI18nextProviderContext };

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

@@ -1,4 +1,7 @@
 import "node:module";
+import { resolveMappedUrlStrategy } from "../shared/mappedUrlStrategy.mjs";
+import { asI18nUrlStrategy } from "../shared/urlStrategy.mjs";
+import { I18nRouterNavigationProvider, useIntegratedRouterAdapter } from "./navigation.mjs";
 import { setupI18nBeforeRender } from "./pluginSetup.mjs";
 import { createI18nRootWrapper } from "./providerComposition.mjs";
 import { resolveReactI18nextIntegration } from "./reactI18next.mjs";
@@ -9,6 +12,7 @@ const createI18nPlugin = (loadReactI18nextIntegration)=>(options)=>({
                 const { entryName, i18nInstance: userI18nInstance, initOptions, localeDetection, backend, htmlLangAttr = false, reactI18next = true, urlStrategy, NavigationProvider, LanguageSynchronization } = options;
                 const { localePathRedirect = false, i18nextDetector = true, languages = [], fallbackLanguage = 'en', detection, ignoreRedirectRoutes } = localeDetection || {};
                 const { enabled: backendEnabled = false } = backend || {};
+                const resolvedUrlStrategy = asI18nUrlStrategy(urlStrategy) ?? resolveMappedUrlStrategy(localeDetection);
                 let latestI18nInstance;
                 let I18nextProvider;
                 api.onBeforeRender(async (context)=>{
@@ -36,8 +40,8 @@ const createI18nPlugin = (loadReactI18nextIntegration)=>(options)=>({
                     languages,
                     fallbackLanguage,
                     ignoreRedirectRoutes,
-                    urlStrategy,
-                    NavigationProvider,
+                    urlStrategy: resolvedUrlStrategy,
+                    NavigationProvider: NavigationProvider ?? I18nRouterNavigationProvider,
                     LanguageSynchronization,
                     getLatestI18nInstance: ()=>latestI18nInstance,
                     getI18nextProvider: ()=>I18nextProvider
@@ -50,4 +54,4 @@ export { I18nLink } from "./I18nLink.mjs";
 export { Link } from "./Link.mjs";
 export { useLocalizedLocation, useLocalizedPaths } from "./localizedPaths.mjs";
 export { splitUrlTarget } from "./utils.mjs";
-export { createI18nPlugin };
+export { I18nRouterNavigationProvider, createI18nPlugin, useIntegratedRouterAdapter };

package/dist/esm-node/runtime/i18n/detection/middleware.mjs

@@ -12,7 +12,7 @@ const useI18nextLanguageDetector = (i18nInstance)=>{
     }
     return i18nInstance;
 };
-const readLanguageFromStorage = (detectionOptions)=>{
+const readLanguageFromStorage = (detectionOptions, _request, _languages)=>{
     try {
         const options = detectionOptions || {};
         const order = options.order || [

package/dist/esm-node/runtime/i18n/detection/middleware.node.mjs

@@ -1,7 +1,16 @@
 import "node:module";
 import { LanguageDetector } from "i18next-http-middleware";
+import { detectLanguageFromRequest } from "../../../shared/detection.mjs";
+const isDetectionRequest = (request)=>{
+    if (!request || 'object' != typeof request) return false;
+    const { url, headers } = request;
+    return 'string' == typeof url && !!headers && 'object' == typeof headers;
+};
 const cacheUserLanguage = (_i18nInstance, _language, _detectionOptions)=>{};
-const readLanguageFromStorage = (_detectionOptions)=>{};
+const readLanguageFromStorage = (detectionOptions, request, languages = [])=>{
+    if (!isDetectionRequest(request)) return;
+    return detectLanguageFromRequest(request, languages, detectionOptions) ?? void 0;
+};
 const useI18nextLanguageDetector = (i18nInstance)=>{
     if (!i18nInstance.isInitialized) return i18nInstance.use(LanguageDetector);
     return i18nInstance;

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

@@ -10,7 +10,7 @@ const detectLanguageWithPriority = async (i18nInstance, 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, {
+    if (!detectedLanguage && i18nextDetector) detectedLanguage = isI18nWrapperInstance(i18nInstance) ? readLanguageFromStorage(mergeDetectionOptions(i18nextDetector, detection, localePathRedirect, userInitOptions), ssrContext?.request, languages) : await detectLanguageFromI18nextDetector(i18nInstance, {
         languages,
         fallbackLanguage,
         localePathRedirect,

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

@@ -0,0 +1,8 @@
+import "node:module";
+import { createI18nRouterNavigation } from "@modern-js/i18n-runtime-extensions/router-navigation";
+import { I18nNavigationProvider, useNativeI18nRouterAdapter } from "./routerAdapter.mjs";
+const { I18nRouterNavigationProvider: I18nRouterNavigationProvider, useIntegratedRouterAdapter: useIntegratedRouterAdapter } = createI18nRouterNavigation({
+    I18nNavigationProvider: I18nNavigationProvider,
+    useNativeI18nRouterAdapter: useNativeI18nRouterAdapter
+});
+export { I18nRouterNavigationProvider, useIntegratedRouterAdapter };

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

@@ -1,11 +1,9 @@
 import "node:module";
 import { jsx } from "react/jsx-runtime";
+import { I18nNavigationContext } from "@modern-js/plugin-i18n/runtime/contexts";
 import { RuntimeContext, isBrowser } from "@modern-js/runtime";
 import { InternalRuntimeContext } from "@modern-js/runtime/context";
-import { createContext, useContext } from "react";
-const navigationContextKey = Symbol.for('@modern-js/plugin-i18n/runtime/I18nNavigationContext');
-const contextStore = globalThis;
-const I18nNavigationContext = contextStore[navigationContextKey] ??= /*#__PURE__*/ createContext(null);
+import { useContext } from "react";
 const I18nNavigationProvider = ({ children, value })=>/*#__PURE__*/ jsx(I18nNavigationContext.Provider, {
         value: value,
         children: children

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

@@ -0,0 +1,2 @@
+import "node:module";
+export { ModernI18nContext, ReactI18nextProviderContext } from "@modern-js/plugin-i18n/runtime/contexts";

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

@@ -2,6 +2,8 @@ import "node:module";
 import { isBrowser } from "@modern-js/runtime";
 import { getGlobalBasename } from "@modern-js/runtime/context";
 import { splitUrlTarget } from "@modern-js/runtime-utils/url";
+import { isDefaultLocaleRedirectSkipPath } from "../shared/mappedUrlStrategy.mjs";
+import { asI18nUrlStrategy } from "../shared/urlStrategy.mjs";
 const getPathname = (context)=>{
     if (isBrowser()) return window.location.pathname;
     return context.ssrContext?.request?.pathname || '/';
@@ -19,7 +21,8 @@ const getLanguageFromPath = (pathname, languages, fallbackLanguage)=>{
 };
 const buildLocalizedUrl = (target, language, languages, urlStrategy)=>{
     const { pathname, search, hash } = splitUrlTarget(target);
-    if (urlStrategy) return `${urlStrategy.localizePathname(pathname, language, languages)}${search}${hash}`;
+    const strategy = asI18nUrlStrategy(urlStrategy);
+    if (strategy) return `${strategy.localizePathname(pathname, language, languages)}${search}${hash}`;
     const segments = pathname.split('/').filter(Boolean);
     if (segments[0] && languages.some((item)=>item.toLowerCase() === segments[0].toLowerCase())) segments[0] = language;
     else segments.unshift(language);
@@ -44,7 +47,8 @@ const detectLanguageFromPath = (pathname, languages, localePathRedirect)=>{
     };
 };
 const shouldIgnoreRedirect = (pathname, languages, ignoreRedirectRoutes, urlStrategy)=>{
-    if (urlStrategy?.shouldSkipRedirect?.(pathname, languages)) return true;
+    if (isDefaultLocaleRedirectSkipPath(pathname, languages)) return true;
+    if (asI18nUrlStrategy(urlStrategy)?.shouldSkipRedirect?.(pathname, languages)) return true;
     if (!ignoreRedirectRoutes) return false;
     const segments = pathname.split('/').filter(Boolean);
     if (segments[0] && languages.some((item)=>item.toLowerCase() === segments[0].toLowerCase())) segments.shift();

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

@@ -0,0 +1,8 @@
+import "node:module";
+import { createMappedUrlStrategy } from "./mappedUrlStrategy.mjs";
+const createDefaultUrlStrategy = (localisedUrls)=>createMappedUrlStrategy(localisedUrls);
+const resolveDefaultUrlStrategy = (localisedUrls)=>{
+    if (!localisedUrls || 'object' != typeof localisedUrls || 0 === Object.keys(localisedUrls).length) return;
+    return createDefaultUrlStrategy(localisedUrls);
+};
+export { createDefaultUrlStrategy, resolveDefaultUrlStrategy };

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

@@ -1,6 +1,8 @@
 import "node:module";
+import { asI18nUrlStrategy } from "../shared/urlStrategy.mjs";
 import { getLocaleDetectionOptions } from "../shared/utils.mjs";
 import { collectApiPrefixes, matchesApiPrefix } from "./apiPrefix.mjs";
+import { resolveDefaultUrlStrategy } from "./defaultUrlStrategy.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";
@@ -27,8 +29,7 @@ const i18nServerPlugin = (options)=>({
                     const entryLocaleDetection = getLocaleDetectionOptions(entryName, options.localeDetection);
                     const { localePathRedirect, i18nextDetector = true, languages = [], fallbackLanguage = 'en', detection, ignoreRedirectRoutes } = entryLocaleDetection;
                     const legacyLocalisedUrls = Reflect.get(entryLocaleDetection, 'localisedUrls');
-                    const urlStrategy = options.resolveUrlStrategy?.(entryName);
-                    if (legacyLocalisedUrls && 'object' == typeof legacyLocalisedUrls && Object.keys(legacyLocalisedUrls).length > 0 && !urlStrategy) throw new Error('Mapped locale URLs require a URL strategy. Use the i18n integration server plugin or supply resolveUrlStrategy.');
+                    const urlStrategy = asI18nUrlStrategy(options.resolveUrlStrategy?.(entryName)) ?? resolveDefaultUrlStrategy(legacyLocalisedUrls);
                     const staticRoutePrefixes = options.staticRoutePrefixes;
                     const originUrlPath = route.urlPath;
                     const urlPath = originUrlPath.endsWith('/') ? `${originUrlPath}*` : `${originUrlPath}/*`;

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

@@ -0,0 +1,2 @@
+import "node:module";
+export { createMappedUrlStrategy, resolveMappedUrlStrategy } from "../shared/mappedUrlStrategy.mjs";

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

@@ -1,4 +1,6 @@
 import "node:module";
+import { isDefaultLocaleRedirectSkipPath } from "../shared/mappedUrlStrategy.mjs";
+import { asI18nUrlStrategy } from "../shared/urlStrategy.mjs";
 const stripUrlPathPrefix = (pathname, urlPath)=>{
     const basePath = urlPath.replace('/*', '');
     if (!basePath || '/' === basePath) return pathname;
@@ -6,7 +8,8 @@ const stripUrlPathPrefix = (pathname, urlPath)=>{
 };
 const shouldIgnoreRedirect = (pathname, urlPath, ignoreRedirectRoutes, urlStrategy, languages = [])=>{
     const remainingPath = stripUrlPathPrefix(pathname, urlPath);
-    if (urlStrategy?.shouldSkipRedirect?.(remainingPath, languages)) return true;
+    if (isDefaultLocaleRedirectSkipPath(remainingPath, languages)) return true;
+    if (asI18nUrlStrategy(urlStrategy)?.shouldSkipRedirect?.(remainingPath, languages)) return true;
     if (!ignoreRedirectRoutes) return false;
     const segments = remainingPath.split('/').filter(Boolean);
     if (segments[0] && languages.some((language)=>language.toLowerCase() === segments[0].toLowerCase())) segments.shift();
@@ -38,7 +41,8 @@ const buildLocalizedUrl = (req, urlPath, language, languages, urlStrategy)=>{
     const segments = remainingPath.split('/').filter(Boolean);
     if (segments[0] && languages.some((item)=>item.toLowerCase() === segments[0].toLowerCase())) segments[0] = language;
     else segments.unshift(language);
-    const pathname = urlStrategy ? urlStrategy.localizePathname(remainingPath, language, languages) : `/${segments.join('/')}`;
+    const strategy = asI18nUrlStrategy(urlStrategy);
+    const pathname = strategy ? strategy.localizePathname(remainingPath, language, languages) : `/${segments.join('/')}`;
     return `${'/' === basePath ? '' : basePath}${pathname}${url.search}${url.hash}`;
 };
 const createLocaleRedirectResponse = (location)=>new Response(null, {

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

@@ -1,2 +1,86 @@
 import "node:module";
-import "../runtime/i18n/detection/config.mjs";
+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)=>{
+            const headers = req.headers;
+            if ('function' == typeof headers?.get) return headers.get(name);
+            const value = headers[name.toLowerCase()];
+            if (Array.isArray(value)) return value[0] ?? null;
+            return value ?? null;
+        };
+        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,
+                                    baseCode: 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;
+                                }
+                                if (languages.includes(lang.baseCode)) {
+                                    detectedLang = lang.baseCode;
+                                    break;
+                                }
+                            }
+                        }
+                        break;
+                    }
+            }
+            if (detectedLang && (0 === languages.length || languages.includes(detectedLang))) return detectedLang;
+            if (detectedLang) {
+                const baseLang = detectedLang.split('-')[0];
+                if (languages.includes(baseLang)) return baseLang;
+            }
+        }
+    } catch (error) {}
+    return null;
+}
+export { detectLanguageFromRequest };

package/dist/esm-node/shared/mappedUrlStrategy.mjs

@@ -0,0 +1,20 @@
+import "node:module";
+import { canonicalTargetPathname, isDefaultLocaleRedirectSkipPath, localiseTargetPathname } from "@modern-js/i18n-runtime-extensions";
+const createMappedUrlStrategy = (localisedUrls)=>({
+        localizePathname: (pathname, language, languages)=>localiseTargetPathname(pathname, language, [
+                ...languages
+            ], localisedUrls),
+        canonicalPathname: (pathname, languages)=>canonicalTargetPathname(pathname, [
+                ...languages
+            ], localisedUrls),
+        shouldSkipRedirect: (pathname, languages)=>isDefaultLocaleRedirectSkipPath(pathname, [
+                ...languages
+            ])
+    });
+const resolveMappedUrlStrategy = (localeDetection)=>{
+    if (!localeDetection || 'object' != typeof localeDetection) return;
+    const localisedUrls = Reflect.get(localeDetection, 'localisedUrls');
+    if (!localisedUrls || 'object' != typeof localisedUrls || 0 === Object.keys(localisedUrls).length) return;
+    return createMappedUrlStrategy(localisedUrls);
+};
+export { createMappedUrlStrategy, isDefaultLocaleRedirectSkipPath, resolveMappedUrlStrategy };

package/dist/esm-node/shared/urlStrategy.mjs

@@ -1 +1,8 @@
 import "node:module";
+const asI18nUrlStrategy = (candidate)=>{
+    if (!candidate || 'object' != typeof candidate) return;
+    const strategy = candidate;
+    return 'function' == typeof strategy.localizePathname && 'function' == typeof strategy.canonicalPathname ? strategy : void 0;
+};
+const isUnusableI18nUrlStrategy = (candidate)=>Boolean(candidate) && 'object' == typeof candidate && void 0 === asI18nUrlStrategy(candidate);
+export { asI18nUrlStrategy, isUnusableI18nUrlStrategy };

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

@@ -0,0 +1,19 @@
+import { getEntrypointRoutesOwner } from '@modern-js/runtime/cli';
+import type { Entrypoint, NestedRouteForCli, PageRoute } from '@modern-js/types';
+import type { BaseLocaleDetectionOptions } from '../shared/type.js';
+type FileSystemRoutes = (NestedRouteForCli | PageRoute)[];
+/**
+ * Expand file-system routes from `localeDetection.localisedUrls`.
+ *
+ * Fork-owned: the localised-URL engine lives in
+ * `@modern-js/i18n-runtime-extensions`, which upstream-owned files must not
+ * import. `cli/index.ts` calls this through a relative import so the seam, not
+ * the edge, is what appears in the upstream-shaped file.
+ *
+ * Returns the routes unchanged unless locale-path redirects are on, languages
+ * are declared, and a non-empty map is configured — an upstream-style config
+ * with `localePathRedirect` and `languages` but no map keeps plain
+ * locale-prefix behaviour.
+ */
+export declare const applyLocalisedRoutes: (routes: FileSystemRoutes, localeDetection: BaseLocaleDetectionOptions | undefined, entrypoint?: Entrypoint & Parameters<typeof getEntrypointRoutesOwner>[0]) => FileSystemRoutes;
+export {};

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

@@ -2,6 +2,7 @@ import type { ComponentType, FC, ReactNode } from 'react';
 import type { I18nUrlStrategy } from '../shared/urlStrategy.js';
 import type { I18nInstance } from './i18n/index.js';
 import type { Resources } from './i18n/instance.js';
+import { ModernI18nContext, ReactI18nextProviderContext } from './sharedContexts.js';
 export { getActualI18nextInstance } from './i18n/instance.js';
 export interface ModernI18nContextValue {
     language: string;
@@ -14,8 +15,7 @@ export interface ModernI18nContextValue {
     updateLanguage?: (newLang: string) => void;
     synchronizeLanguage?: (newLang: string) => void;
 }
-export declare const ModernI18nContext: import("react").Context<ModernI18nContextValue | null>;
-export declare const ReactI18nextProviderContext: import("react").Context<ComponentType<any> | null>;
+export { ModernI18nContext, ReactI18nextProviderContext };
 export interface ModernI18nProviderProps {
     children: ReactNode;
     i18nextProvider?: ComponentType<any> | null;

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

@@ -0,0 +1,6 @@
+import type { ComponentType } from 'react';
+import type { ModernI18nContextValue } from './context.js';
+import type { I18nRouterAdapter } from './routerAdapter.js';
+export declare const ModernI18nContext: import("react").Context<ModernI18nContextValue | null>;
+export declare const ReactI18nextProviderContext: import("react").Context<ComponentType<any> | null>;
+export declare const I18nNavigationContext: import("react").Context<I18nRouterAdapter | null>;

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

@@ -1,7 +1,7 @@
 import type { RuntimePlugin } from '@modern-js/runtime';
 import type React from 'react';
 import type { BaseBackendOptions, BaseLocaleDetectionOptions } from '../shared/type.js';
-import type { I18nUrlStrategy } from '../shared/urlStrategy.js';
+import { type I18nUrlStrategy } from '../shared/urlStrategy.js';
 import type { I18nInitOptions, I18nInstance } from './i18n/index.js';
 import { type I18nLanguageSynchronizationProps } from './providerComposition.js';
 export type { I18nLanguageSynchronizationProps } from './providerComposition.js';
@@ -10,6 +10,7 @@ import './types.js';
 export type { I18nSdkLoader, I18nSdkLoadOptions } from '../shared/type.js';
 export type { I18nUrlStrategy } from '../shared/urlStrategy.js';
 export type { I18nInitOptions, I18nInstance, Resources, TranslateFn, } from './i18n/instance.js';
+export { I18nRouterNavigationProvider, useIntegratedRouterAdapter, } from './navigation.js';
 export type { LoadReactI18nextIntegration, ReactI18nextIntegration, } from './reactI18next.js';
 export { I18nNavigationProvider, type I18nRouterAdapter, type I18nRouterLinkTarget, useI18nRouterAdapter, useNativeI18nRouterAdapter, } from './routerAdapter.js';
 export interface I18nPluginOptions {

package/dist/types/runtime/i18n/detection/middleware.d.ts

@@ -9,7 +9,7 @@ export declare const useI18nextLanguageDetector: (i18nInstance: I18nInstance) =>
  * Read language directly from localStorage/cookie
  * Fallback when detector is not available in services
  */
-export declare const readLanguageFromStorage: (detectionOptions?: LanguageDetectorOptions) => string | undefined;
+export declare const readLanguageFromStorage: (detectionOptions?: LanguageDetectorOptions, _request?: unknown, _languages?: string[]) => string | undefined;
 /**
  * Detect language using i18next-browser-languagedetector
  * For initialized instances without detector in services, manually create a detector instance

package/dist/types/runtime/i18n/detection/middleware.node.d.ts

@@ -1,10 +1,6 @@
 import type { I18nInstance, LanguageDetectorOptions } from '../instance.js';
 export declare const cacheUserLanguage: (_i18nInstance: I18nInstance, _language: string, _detectionOptions?: unknown) => void;
-/**
- * Read language directly from storage (localStorage/cookie)
- * Not available in Node.js environment, returns undefined
- */
-export declare const readLanguageFromStorage: (_detectionOptions?: LanguageDetectorOptions) => string | undefined;
+export declare const readLanguageFromStorage: (detectionOptions?: LanguageDetectorOptions, request?: unknown, languages?: string[]) => string | undefined;
 /**
  * Register LanguageDetector plugin to i18n instance
  * Must be called before init() to properly register the detector

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

@@ -0,0 +1,10 @@
+import { type I18nRouterAdapter } from './routerAdapter.js';
+/**
+ * The seam, and only the seam. The selected-router navigation adapter is a
+ * fork subsystem, so it lives in the fork-owned
+ * `@modern-js/i18n-runtime-extensions` and is attached here through the
+ * `NavigationProvider` extension point this package already exposes. The
+ * factory takes this package's own primitives as arguments, so the fork
+ * package never imports back into it and the dependency stays one-way.
+ */
+export declare const I18nRouterNavigationProvider: ({ children, }: React.PropsWithChildren) => React.JSX.Element, useIntegratedRouterAdapter: () => I18nRouterAdapter;

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

@@ -0,0 +1 @@
+export { ModernI18nContext, ReactI18nextProviderContext, } from './contexts.js';

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

@@ -1,4 +1,4 @@
-import type { I18nUrlStrategy } from '../shared/urlStrategy.js';
+import { type I18nUrlStrategy } from '../shared/urlStrategy.js';
 export { splitUrlTarget } from '@modern-js/runtime-utils/url';
 export declare const getPathname: (context: {
     ssrContext?: {

package/dist/types/server/defaultUrlStrategy.d.ts

@@ -0,0 +1,11 @@
+import type { LocalisedUrlsOption } from '@modern-js/i18n-runtime-extensions';
+import type { I18nUrlStrategy } from '../shared/urlStrategy.js';
+/**
+ * Mapped locale URLs work without any extra plugin. `localeDetection.localisedUrls`
+ * alone is enough: the server derives the URL policy from the map it is given.
+ * An explicit `resolveUrlStrategy` still wins, so an integration can replace the
+ * policy wholesale.
+ */
+export declare const createDefaultUrlStrategy: (localisedUrls?: LocalisedUrlsOption) => I18nUrlStrategy;
+/** A non-empty map is the only configuration that needs a derived policy. */
+export declare const resolveDefaultUrlStrategy: (localisedUrls: unknown) => I18nUrlStrategy | undefined;

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

@@ -1,6 +1,6 @@
 import type { ServerPlugin } from '@modern-js/server-runtime';
 import type { LocaleDetectionOptions } from '../shared/type.js';
-import type { I18nUrlStrategy } from '../shared/urlStrategy.js';
+import { type I18nUrlStrategy } from '../shared/urlStrategy.js';
 export { collectApiPrefixes, matchesApiPrefix } from './apiPrefix.js';
 export interface I18nPluginOptions {
     localeDetection: LocaleDetectionOptions;

package/dist/types/server/mappedUrlStrategy.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The mapped-URL policy moved to `../shared` so the client runtime can derive
+ * the same policy the server does — SSR and a hydrated `<Link>` have to agree
+ * on the mapping or client navigation targets a path the server will not serve.
+ * Re-exported here to keep the server-side import path stable.
+ */
+export { createMappedUrlStrategy, resolveMappedUrlStrategy, } from '../shared/mappedUrlStrategy.js';

package/dist/types/server/redirectPolicy.d.ts

@@ -1,4 +1,4 @@
-import type { I18nUrlStrategy } from '../shared/urlStrategy.js';
+import { type I18nUrlStrategy } from '../shared/urlStrategy.js';
 interface LocaleRedirectRequest {
     url: string;
     header?: () => {

package/dist/types/shared/detection.d.ts

@@ -1 +1,11 @@
-export {};
+import type { LanguageDetectorOptions } from '../runtime/i18n/instance.js';
+/**
+ * Detect language from request using the same detection logic as i18next
+ * This ensures consistency between server-side and client-side detection
+ */
+export declare function detectLanguageFromRequest(req: {
+    url: string;
+    headers: Headers | {
+        get: (name: string) => string | null;
+    } | Record<string, string | string[] | undefined>;
+}, languages: string[], detectionOptions?: LanguageDetectorOptions): string | null;

package/dist/types/shared/mappedUrlStrategy.d.ts

@@ -0,0 +1,27 @@
+import { type LocalisedUrlsOption } from '@modern-js/i18n-runtime-extensions';
+import type { I18nUrlStrategy } from './urlStrategy.js';
+/**
+ * The fork's native locale-redirect exclusions (federation artifacts, static
+ * and upload prefixes). Re-exported from this fork-owned seam so the native
+ * runtime and server redirect paths apply them without importing the
+ * extensions package themselves.
+ */
+export { isDefaultLocaleRedirectSkipPath } from '@modern-js/i18n-runtime-extensions';
+/**
+ * Build the URL policy from a mapped-locale-URL configuration.
+ *
+ * `localeDetection.localisedUrls` is plain data, so unlike a `urlStrategy`
+ * object it survives the JSON boundary between `modern.config.ts` and the
+ * generated runtime registration. It is therefore the one configuration both
+ * sides can rely on for mapped URLs.
+ *
+ * This is shared rather than server-only on purpose. The server and the client
+ * have to agree on the mapping or a hydrated `<Link>` navigates to a path the
+ * server will not serve: SSR renders `/cs/obchodni-podminky` while a
+ * client-side navigation asks for `/cs/terms-of-service`. The helpers below are
+ * pure pathname functions from `@modern-js/i18n-runtime-extensions`, so the
+ * client cost is a few hundred bytes of string work and no i18n engine.
+ */
+export declare const createMappedUrlStrategy: (localisedUrls?: LocalisedUrlsOption) => I18nUrlStrategy;
+/** Only a non-empty map needs a derived policy. */
+export declare const resolveMappedUrlStrategy: (localeDetection: unknown) => I18nUrlStrategy | undefined;

package/dist/types/shared/type.d.ts

@@ -6,6 +6,16 @@ export interface BaseLocaleDetectionOptions {
     fallbackLanguage?: string;
     detection?: LanguageDetectorOptions;
     ignoreRedirectRoutes?: string[] | ((pathname: string) => boolean);
+    /**
+     * Canonical-path -> per-language path map, e.g.
+     * `{ '/products': { en: '/products', cs: '/produkty' } }`.
+     *
+     * Plain data on purpose: the generated runtime registration carries plugin
+     * options as JSON, so a map survives the trip where a `urlStrategy` object
+     * would lose its methods. The CLI expands file-system routes from it, and
+     * the server derives its URL strategy from it, with no extra plugin.
+     */
+    localisedUrls?: boolean | Record<string, Record<string, string>>;
 }
 export interface LocaleDetectionOptions extends BaseLocaleDetectionOptions {
     localeDetectionByEntry?: Record<string, BaseLocaleDetectionOptions>;

package/dist/types/shared/urlStrategy.d.ts

@@ -5,3 +5,14 @@ export interface I18nUrlStrategy {
     /** Adds exclusions; it cannot enable redirects excluded by native rules. */
     shouldSkipRedirect?(pathname: string, languages: readonly string[]): boolean;
 }
+/**
+ * A URL strategy reaches the runtime through the generated runtime
+ * registration, which carries plugin options as JSON. Functions do not survive
+ * that, so a configured strategy can arrive as an empty object — which is
+ * truthy and would make every call site throw. Anything that is not a complete
+ * strategy is treated as absent, and the caller falls back to the built-in
+ * language-prefix behaviour.
+ */
+export declare const asI18nUrlStrategy: (candidate: unknown) => I18nUrlStrategy | undefined;
+/** `true` when a value was configured as a strategy but cannot be used as one. */
+export declare const isUnusableI18nUrlStrategy: (candidate: unknown) => boolean;