@bleedingdev/modern-js-plugin-i18n 3.9.0-ultramodern.4 → 3.9.0-ultramodern.6

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

@@ -1,151 +1,40 @@
 import "node:module";
+import { jsx } from "react/jsx-runtime";
 import { RuntimeContext, isBrowser } from "@modern-js/runtime";
-import { InternalRuntimeContext, getRouterRuntimeState } from "@modern-js/runtime/context";
-import { useCallback, useContext, useSyncExternalStore } from "react";
-const normalizeUrlPart = (value, prefix)=>{
-    if ('string' != typeof value || !value) return '';
-    return value.startsWith(prefix) ? value : `${prefix}${value}`;
-};
-const normalizeLocation = (location)=>{
-    if (!location || 'object' != typeof location) return null;
-    const locationValue = location;
-    if ('string' != typeof locationValue.pathname) return null;
-    return {
-        pathname: locationValue.pathname,
-        search: normalizeUrlPart('string' == typeof locationValue.search ? locationValue.search : locationValue.searchStr, '?'),
-        hash: normalizeUrlPart(locationValue.hash, '#')
-    };
-};
-const getWindowLocation = ()=>{
-    if (!isBrowser()) return null;
-    return {
-        pathname: window.location.pathname,
-        search: window.location.search,
-        hash: window.location.hash
-    };
-};
-const getRouterFramework = (runtimeContext, internalContext, inReactRouter)=>{
-    const framework = getRouterRuntimeState(internalContext)?.framework || getRouterRuntimeState(runtimeContext)?.framework;
-    if (framework) return framework;
-    if (internalContext.router?.useRouter || runtimeContext.router?.useRouter) return 'tanstack';
-    if (internalContext.router?.useLocation || internalContext.router?.useHref || runtimeContext.router?.useLocation || runtimeContext.router?.useHref) return 'react-router';
-    if (inReactRouter) return 'react-router';
-};
-const getRouterInstance = (internalContext, contextRouter)=>{
-    if (contextRouter) return contextRouter;
-    const router = getRouterRuntimeState(internalContext)?.instance;
-    if (!router || 'object' != typeof router) return null;
-    return router;
-};
-const getRouterStateLocation = (internalContext, contextRouter)=>{
-    const router = getRouterInstance(internalContext, contextRouter);
-    return normalizeLocation(router?.stores?.location?.get?.()) || normalizeLocation(router?.state?.location);
-};
-const getRouterParams = (internalContext, contextRouter)=>{
-    const router = getRouterInstance(internalContext, contextRouter);
-    const matches = router?.stores?.matches?.get?.() || router?.state?.matches;
-    if (!Array.isArray(matches)) return {};
-    return matches.reduce((params, match)=>{
-        if (match?.params) Object.assign(params, match.params);
-        return params;
-    }, {});
-};
-const getRouterSnapshot = (internalContext, contextRouter)=>{
-    const location = getRouterStateLocation(internalContext, contextRouter);
-    const params = getRouterParams(internalContext, contextRouter);
-    return JSON.stringify([
-        location?.pathname ?? '',
-        location?.search ?? '',
-        location?.hash ?? '',
-        Object.entries(params).sort(([left], [right])=>left.localeCompare(right))
-    ]);
-};
-const useI18nRouterAdapter = ()=>{
+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);
+const I18nNavigationProvider = ({ children, value })=>/*#__PURE__*/ jsx(I18nNavigationContext.Provider, {
+        value: value,
+        children: children
+    });
+const useNativeI18nRouterAdapter = ()=>{
     const runtimeContext = useContext(RuntimeContext);
     const internalContext = useContext(InternalRuntimeContext);
     const routerApi = internalContext.router || runtimeContext.router;
-    const inReactRouter = routerApi?.useInRouterContext?.() ?? false;
-    const reactRouterNavigate = inReactRouter ? routerApi?.useNavigate?.() ?? null : null;
-    const reactRouterLocation = inReactRouter ? routerApi?.useLocation?.() ?? null : null;
-    const reactRouterParams = inReactRouter ? routerApi?.useParams?.() ?? {} : {};
-    const framework = getRouterFramework(runtimeContext, internalContext, inReactRouter);
-    const contextUseRouter = inReactRouter || 'tanstack' !== framework ? void 0 : internalContext.router?.useRouter || runtimeContext.router?.useRouter;
-    const contextRouter = contextUseRouter ? contextUseRouter({
-        warn: false
-    }) : null;
-    const hasRouter = 'tanstack' === framework || 'react-router' === framework || Boolean(reactRouterNavigate);
-    const subscribeToRouter = useCallback((update)=>{
-        const router = getRouterInstance(internalContext, contextRouter);
-        if (!router) return ()=>void 0;
-        const unsubscribers = [];
-        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 ('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 getSnapshot = useCallback(()=>getRouterSnapshot(internalContext, contextRouter), [
-        contextRouter,
-        internalContext
-    ]);
-    useSyncExternalStore(subscribeToRouter, getSnapshot, getSnapshot);
-    const navigate = useCallback((href, options)=>{
-        const router = getRouterInstance(internalContext, contextRouter);
-        const activeFramework = getRouterFramework(runtimeContext, internalContext, inReactRouter);
-        if ('tanstack' === activeFramework) {
-            if ('function' == typeof router?.navigate) return router.navigate({
-                to: href,
-                replace: options?.replace,
-                ...options?.state === void 0 ? {} : {
-                    state: options.state
-                }
-            });
-            throw new Error('TanStack router instance is not available.');
-        }
-        if (reactRouterNavigate) return reactRouterNavigate(href, options);
-        if ('react-router' === activeFramework) {
-            if ('function' == typeof router?.navigate) return router.navigate(href, options);
-            throw new Error('React Router instance is not available.');
-        }
-    }, [
-        contextRouter,
-        internalContext,
-        inReactRouter,
-        reactRouterNavigate,
-        runtimeContext
-    ]);
-    const location = (reactRouterLocation ? normalizeLocation(reactRouterLocation) : getRouterStateLocation(internalContext, contextRouter)) || getWindowLocation();
-    const params = inReactRouter ? reactRouterParams : getRouterParams(internalContext, contextRouter);
-    const Link = 'tanstack' === framework ? internalContext.router?.Link || runtimeContext.router?.Link || null : 'react-router' === framework || inReactRouter ? routerApi?.Link ?? null : null;
+    const hasRouter = routerApi?.useInRouterContext?.() ?? false;
+    const navigate = hasRouter ? routerApi?.useNavigate?.() ?? null : null;
+    const routerLocation = hasRouter ? routerApi?.useLocation?.() ?? null : null;
+    const params = hasRouter ? routerApi?.useParams?.() ?? {} : {};
+    const location = routerLocation ?? (isBrowser() ? {
+        pathname: window.location.pathname,
+        search: window.location.search,
+        hash: window.location.hash
+    } : null);
     return {
-        framework,
+        framework: hasRouter ? 'react-router' : void 0,
         hasRouter,
+        navigate,
         location,
-        navigate: hasRouter ? navigate : null,
-        Link,
-        params
+        params,
+        Link: hasRouter ? routerApi?.Link ?? null : null
     };
 };
-export { useI18nRouterAdapter };
+const useI18nRouterAdapter = ()=>{
+    const provided = useContext(I18nNavigationContext);
+    const native = useNativeI18nRouterAdapter();
+    return provided ?? native;
+};
+export { I18nNavigationProvider, useI18nRouterAdapter, useNativeI18nRouterAdapter };

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

@@ -1,7 +1,7 @@
 import "node:module";
-import { localiseTargetPathname, shouldSkipLocaleRedirect } from "@modern-js/i18n-runtime-extensions";
 import { isBrowser } from "@modern-js/runtime";
 import { getGlobalBasename } from "@modern-js/runtime/context";
+import { splitUrlTarget } from "@modern-js/runtime-utils/url";
 const getPathname = (context)=>{
     if (isBrowser()) return window.location.pathname;
     return context.ssrContext?.request?.pathname || '/';
@@ -17,22 +17,13 @@ const getLanguageFromPath = (pathname, languages, fallbackLanguage)=>{
     if (languages.includes(firstSegment)) return firstSegment;
     return fallbackLanguage;
 };
-const splitUrlTarget = (target)=>{
-    const hashIndex = target.indexOf('#');
-    const hash = hashIndex >= 0 ? target.slice(hashIndex) : '';
-    const beforeHash = hashIndex >= 0 ? target.slice(0, hashIndex) : target;
-    const searchIndex = beforeHash.indexOf('?');
-    const search = searchIndex >= 0 ? beforeHash.slice(searchIndex) : '';
-    const pathname = searchIndex >= 0 ? beforeHash.slice(0, searchIndex) : beforeHash;
-    return {
-        pathname,
-        search,
-        hash
-    };
-};
-const buildLocalizedUrl = (target, language, languages, localisedUrls)=>{
+const buildLocalizedUrl = (target, language, languages, urlStrategy)=>{
     const { pathname, search, hash } = splitUrlTarget(target);
-    const localizedPathname = localiseTargetPathname(pathname, language, languages, localisedUrls);
+    if (urlStrategy) return `${urlStrategy.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);
+    const localizedPathname = `/${segments.join('/')}`;
     return `${localizedPathname}${search}${hash}`;
 };
 const detectLanguageFromPath = (pathname, languages, localePathRedirect)=>{
@@ -52,5 +43,12 @@ const detectLanguageFromPath = (pathname, languages, localePathRedirect)=>{
         detected: false
     };
 };
-const shouldIgnoreRedirect = (pathname, languages, ignoreRedirectRoutes)=>shouldSkipLocaleRedirect(pathname, languages, ignoreRedirectRoutes);
+const shouldIgnoreRedirect = (pathname, languages, ignoreRedirectRoutes, urlStrategy)=>{
+    if (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();
+    const normalizedPath = `/${segments.join('/')}`;
+    return 'function' == typeof ignoreRedirectRoutes ? ignoreRedirectRoutes(normalizedPath) : ignoreRedirectRoutes.some((pattern)=>normalizedPath === pattern || normalizedPath.startsWith(`${pattern}/`));
+};
 export { buildLocalizedUrl, detectLanguageFromPath, getEntryPath, getLanguageFromPath, getPathname, shouldIgnoreRedirect, splitUrlTarget };

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

@@ -1,5 +1,4 @@
 import "node:module";
-import { resolveLocalisedUrlsConfig } from "@modern-js/i18n-runtime-extensions";
 import { getLocaleDetectionOptions } from "../shared/utils.mjs";
 import { collectApiPrefixes, matchesApiPrefix } from "./apiPrefix.mjs";
 import { convertToHonoLanguageDetectorOptions } from "./detectorOptions.mjs";
@@ -25,7 +24,11 @@ const i18nServerPlugin = (options)=>({
                     const { entryName } = route;
                     if (!entryName) return;
                     if (!options.localeDetection) return;
-                    const { localePathRedirect, i18nextDetector = true, languages = [], fallbackLanguage = 'en', detection, ignoreRedirectRoutes, localisedUrls } = getLocaleDetectionOptions(entryName, options.localeDetection);
+                    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 staticRoutePrefixes = options.staticRoutePrefixes;
                     const originUrlPath = route.urlPath;
                     const urlPath = originUrlPath.endsWith('/') ? `${originUrlPath}*` : `${originUrlPath}/*`;
@@ -40,6 +43,7 @@ const i18nServerPlugin = (options)=>({
                                     const url = new URL(c.req.url);
                                     const pathname = url.pathname;
                                     if (matchesApiPrefix(pathname, apiPrefixes)) return await next();
+                                    if (shouldIgnoreRedirect(pathname, urlPath, ignoreRedirectRoutes, urlStrategy, languages)) return await next();
                                     if (isStaticResourceRequest(pathname, staticRoutePrefixes, languages)) return await next();
                                     if ('/' === originUrlPath) {
                                         const pathSegments = pathname.split('/').filter(Boolean);
@@ -60,7 +64,7 @@ const i18nServerPlugin = (options)=>({
                                 const pathname = url.pathname;
                                 if (matchesApiPrefix(pathname, apiPrefixes)) return await next();
                                 if (isStaticResourceRequest(pathname, staticRoutePrefixes, languages)) return await next();
-                                if (shouldIgnoreRedirect(pathname, urlPath, ignoreRedirectRoutes)) return await next();
+                                if (shouldIgnoreRedirect(pathname, urlPath, ignoreRedirectRoutes, urlStrategy, languages)) return await next();
                                 if ('/' === originUrlPath) {
                                     const pathSegments = pathname.split('/').filter(Boolean);
                                     if (pathSegments.length > 0) {
@@ -73,12 +77,11 @@ const i18nServerPlugin = (options)=>({
                                     let detectedLanguage = null;
                                     if (i18nextDetector) detectedLanguage = c.get('language') || null;
                                     const targetLanguage = detectedLanguage || fallbackLanguage;
-                                    const localizedUrl = buildLocalizedUrl(c.req, originUrlPath, targetLanguage, languages, localisedUrls);
+                                    const localizedUrl = buildLocalizedUrl(c.req, originUrlPath, targetLanguage, languages, urlStrategy);
                                     return createLocaleRedirectResponse(localizedUrl);
                                 }
-                                const localisedUrlsConfig = resolveLocalisedUrlsConfig(localisedUrls);
-                                if (localisedUrlsConfig.enabled) {
-                                    const expectedUrl = buildLocalizedUrl(c.req, originUrlPath, language, languages, localisedUrls);
+                                if (urlStrategy) {
+                                    const expectedUrl = buildLocalizedUrl(c.req, originUrlPath, language, languages, urlStrategy);
                                     if (expectedUrl !== `${pathname}${url.search}${url.hash}`) return createLocaleRedirectResponse(expectedUrl);
                                 }
                                 await next();

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

@@ -1,40 +1,45 @@
 import "node:module";
-import { isDefaultLocaleRedirectSkipPath, localiseTargetPathname, matchesPathPrefix, shouldSkipLocaleRedirect, stripLanguagePrefix } from "@modern-js/i18n-runtime-extensions";
 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 || '/';
+    return pathname === basePath || pathname.startsWith(`${basePath}/`) ? pathname.slice(basePath.length) || '/' : pathname;
 };
-const shouldIgnoreRedirect = (pathname, urlPath, ignoreRedirectRoutes)=>{
+const shouldIgnoreRedirect = (pathname, urlPath, ignoreRedirectRoutes, urlStrategy, languages = [])=>{
     const remainingPath = stripUrlPathPrefix(pathname, urlPath);
-    return shouldSkipLocaleRedirect(remainingPath, [], ignoreRedirectRoutes);
+    if (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();
+    const normalizedPath = `/${segments.join('/')}`;
+    return 'function' == typeof ignoreRedirectRoutes ? ignoreRedirectRoutes(normalizedPath) : ignoreRedirectRoutes.some((pattern)=>normalizedPath === pattern || normalizedPath.startsWith(`${pattern}/`));
 };
 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 prefixes = [
+        ...staticRoutePrefixes,
+        '/static',
+        '/upload'
+    ];
+    const matches = (target)=>prefixes.some((prefix)=>target === prefix || target.startsWith(`${prefix}/`));
+    if (matches(pathname)) return true;
+    const segments = pathname.split('/').filter(Boolean);
+    if (segments[0] && languages.some((language)=>language.toLowerCase() === segments[0].toLowerCase())) return matches(`/${segments.slice(1).join('/')}`);
+    return false;
 };
 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 host = req.header?.().host;
+    const url = new URL(req.url, host ? `http://${host}` : void 0);
+    const firstSegment = stripUrlPathPrefix(url.pathname, urlPath).split('/').filter(Boolean)[0];
+    return languages.find((language)=>language.toLowerCase() === firstSegment?.toLowerCase()) ?? null;
 };
-const buildLocalizedUrl = (req, urlPath, language, languages, localisedUrls)=>{
+const buildLocalizedUrl = (req, urlPath, language, languages, urlStrategy)=>{
     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 remainingPath = stripUrlPathPrefix(url.pathname, urlPath);
+    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('/')}`;
+    return `${'/' === basePath ? '' : basePath}${pathname}${url.search}${url.hash}`;
 };
 const createLocaleRedirectResponse = (location)=>new Response(null, {
         status: 302,

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

@@ -0,0 +1 @@
+import "node:module";

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

@@ -1,19 +1,22 @@
-import type { LocalisedUrlsOption } from '@modern-js/i18n-runtime-extensions';
 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';
-interface ModernI18nContextValue {
+export { getActualI18nextInstance } from './i18n/instance.js';
+export interface ModernI18nContextValue {
     language: string;
     i18nInstance: I18nInstance;
     entryName?: string;
     languages?: string[];
     localePathRedirect?: boolean;
     ignoreRedirectRoutes?: string[] | ((pathname: string) => boolean);
-    localisedUrls?: LocalisedUrlsOption;
+    urlStrategy?: I18nUrlStrategy;
     updateLanguage?: (newLang: string) => void;
     synchronizeLanguage?: (newLang: string) => void;
 }
-interface ModernI18nProviderProps {
+export declare const ModernI18nContext: import("react").Context<ModernI18nContextValue | null>;
+export declare const ReactI18nextProviderContext: import("react").Context<ComponentType<any> | null>;
+export interface ModernI18nProviderProps {
     children: ReactNode;
     i18nextProvider?: ComponentType<any> | null;
     value: ModernI18nContextValue;
@@ -26,11 +29,6 @@ export interface FederatedI18nBoundaryProps {
     resources: Resources;
     supportedLanguages?: string[];
 }
-/**
- * Keeps a federated surface's translation resources inside its delivery unit.
- * The host supplies only the active language; the remote owns and versions the
- * resources used below this boundary.
- */
 export declare const FederatedI18nBoundary: FC<FederatedI18nBoundaryProps>;
 export interface UseModernI18nReturn<TInstance extends I18nInstance = I18nInstance> {
     language: string;
@@ -38,7 +36,7 @@ export interface UseModernI18nReturn<TInstance extends I18nInstance = I18nInstan
     t: (key: string | string[], ...args: any[]) => string;
     i18nInstance: TInstance;
     supportedLanguages: string[];
-    localisedUrls?: LocalisedUrlsOption;
+    urlStrategy?: I18nUrlStrategy;
     isLanguageSupported: (lang: string) => boolean;
     isResourcesReady: boolean;
 }
@@ -62,4 +60,3 @@ export interface UseModernI18nReturn<TInstance extends I18nInstance = I18nInstan
  * @returns Object containing i18n functionality and utilities
  */
 export declare const useModernI18n: <TInstance extends I18nInstance = I18nInstance>() => UseModernI18nReturn<TInstance>;
-export {};

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

@@ -1,4 +1,4 @@
-import type { LocalisedUrlsOption } from '@modern-js/i18n-runtime-extensions';
+import type { I18nUrlStrategy } from '../shared/urlStrategy.js';
 import type { I18nInstance } from './i18n/index.js';
 type Navigate = (url: string, options?: {
     replace?: boolean;
@@ -16,7 +16,7 @@ interface ChangeModernI18nLanguageOptions {
     updateLanguage?: (newLang: string) => void;
     localePathRedirect?: boolean;
     ignoreRedirectRoutes?: string[] | ((pathname: string) => boolean);
-    localisedUrls?: LocalisedUrlsOption;
+    urlStrategy?: I18nUrlStrategy;
     languages?: string[];
     hasRouter: boolean;
     navigate?: Navigate | null;

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

@@ -1,11 +1,17 @@
 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 { I18nInitOptions, I18nInstance } from './i18n/index.js';
+import { type I18nLanguageSynchronizationProps } from './providerComposition.js';
+export type { I18nLanguageSynchronizationProps } from './providerComposition.js';
 import { type LoadReactI18nextIntegration } from './reactI18next.js';
 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 type { LoadReactI18nextIntegration, ReactI18nextIntegration, } from './reactI18next.js';
+export { I18nNavigationProvider, type I18nRouterAdapter, type I18nRouterLinkTarget, useI18nRouterAdapter, useNativeI18nRouterAdapter, } from './routerAdapter.js';
 export interface I18nPluginOptions {
     entryName?: string;
     localeDetection?: BaseLocaleDetectionOptions;
@@ -15,6 +21,9 @@ export interface I18nPluginOptions {
     initOptions?: I18nInitOptions;
     htmlLangAttr?: boolean;
     reactI18next?: boolean;
+    urlStrategy?: I18nUrlStrategy;
+    NavigationProvider?: React.ComponentType<React.PropsWithChildren>;
+    LanguageSynchronization?: React.ComponentType<I18nLanguageSynchronizationProps>;
     [key: string]: any;
 }
 export declare const createI18nPlugin: (loadReactI18nextIntegration?: LoadReactI18nextIntegration) => ((options: I18nPluginOptions) => RuntimePlugin);
@@ -22,5 +31,5 @@ export type { AllowedLinkTarget, CanonicalRoutePath, UltramodernCanonicalRoutes,
 export { FederatedI18nBoundary, type FederatedI18nBoundaryProps, type UseModernI18nReturn, useModernI18n, } from './context.js';
 export { I18nLink, type I18nLinkProps } from './I18nLink.js';
 export { Link, type LinkActiveOptions, type LinkBaseProps, type LinkParams, type LinkProps, } from './Link.js';
-export { canonicalPath, type LocalizedPathsConfig, localizePath, type UseLocalizedLocationReturn, type UseLocalizedPathsReturn, useLocalizedLocation, useLocalizedPaths, } from './localizedPaths.js';
-export { buildLocalizedUrl, splitUrlTarget } from './utils.js';
+export { type LocalizedPathsConfig, type UseLocalizedLocationReturn, type UseLocalizedPathsReturn, useLocalizedLocation, useLocalizedPaths, } from './localizedPaths.js';
+export { splitUrlTarget } from './utils.js';

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

@@ -1,16 +1,15 @@
-import type { LocalisedUrlsOption } from '@modern-js/i18n-runtime-extensions';
 import type React from 'react';
+import type { I18nUrlStrategy } from '../shared/urlStrategy.js';
 import type { I18nInstance } from './i18n/index.js';
-export declare function createContextValue(lang: string, i18nInstance: I18nInstance | undefined, entryName: string | undefined, languages: string[], localePathRedirect: boolean, ignoreRedirectRoutes: string[] | ((pathname: string) => boolean) | undefined, localisedUrls: LocalisedUrlsOption | undefined, setLang: (lang: string) => void, synchronizeLanguage: (lang: string) => void): {
+export declare function createContextValue(lang: string, i18nInstance: I18nInstance | undefined, entryName: string | undefined, languages: string[], localePathRedirect: boolean, ignoreRedirectRoutes: string[] | ((pathname: string) => boolean) | undefined, setLang: (lang: string) => void, urlStrategy?: I18nUrlStrategy): {
     language: string;
     i18nInstance: I18nInstance;
     entryName: string | undefined;
     languages: string[];
     localePathRedirect: boolean;
     ignoreRedirectRoutes: string[] | ((pathname: string) => boolean) | undefined;
-    localisedUrls: LocalisedUrlsOption | undefined;
+    urlStrategy: I18nUrlStrategy | undefined;
     updateLanguage: (lang: string) => void;
-    synchronizeLanguage: (lang: string) => void;
 };
 export declare function useSdkResourcesLoader(i18nInstance: I18nInstance | undefined, setForceUpdate: React.Dispatch<React.SetStateAction<number>>): void;
 /**
@@ -22,5 +21,5 @@ export declare function useSdkResourcesLoader(i18nInstance: I18nInstance | undef
  * In SSR/SSG scenarios, server-side middleware handles redirects, so this hook is skipped.
  * We use process.env.MODERN_TARGET to ensure this code is only included in browser bundles.
  */
-export declare function useClientSideRedirect(i18nInstance: I18nInstance | undefined, localePathRedirect: boolean, languages: string[], fallbackLanguage: string, ignoreRedirectRoutes?: string[] | ((pathname: string) => boolean), localisedUrls?: LocalisedUrlsOption): void;
+export declare function useClientSideRedirect(i18nInstance: I18nInstance | undefined, localePathRedirect: boolean, languages: string[], fallbackLanguage: string, ignoreRedirectRoutes?: string[] | ((pathname: string) => boolean), urlStrategy?: I18nUrlStrategy): void;
 export declare function useLanguageSync(i18nInstance: I18nInstance | undefined, localePathRedirect: boolean, languages: string[], pathname: string | undefined, prevLangRef: React.MutableRefObject<string>, setLang: (lang: string) => void): (currentLang: string) => void;

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

@@ -1,11 +1,11 @@
-import { type LocalisedUrlsOption } from '@modern-js/i18n-runtime-extensions';
+import type { I18nUrlStrategy } from '../shared/urlStrategy.js';
 export interface LocalizedPathsConfig {
     languages: string[];
-    localisedUrls?: LocalisedUrlsOption;
+    urlStrategy?: I18nUrlStrategy;
 }
 /**
  * Localize a canonical, language-agnostic target for the given language:
- * adds the language prefix and applies `localisedUrls` pattern mapping.
+ * adds the language prefix and applies the configured URL strategy.
  * `?search`/`#hash` suffixes are preserved verbatim.
  */
 export declare const localizePath: (pathname: string, language: string, config: LocalizedPathsConfig) => string;
@@ -21,7 +21,7 @@ export interface UseLocalizedPathsReturn {
 }
 /**
  * Context-bound versions of {@link localizePath} and {@link canonicalPath} —
- * the plugin configuration (languages, localisedUrls) is read from the i18n
+ * the languages and URL strategy are read from the i18n
  * provider, so apps never copy pattern-matching helpers again.
  */
 export declare const useLocalizedPaths: () => UseLocalizedPathsReturn;

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

@@ -1,6 +1,16 @@
 import type React from 'react';
 import type { BaseLocaleDetectionOptions } from '../shared/type.js';
+import type { I18nUrlStrategy } from '../shared/urlStrategy.js';
 import type { I18nInstance } from './i18n/index.js';
+export interface I18nLanguageSynchronizationProps {
+    i18nInstance: I18nInstance | undefined;
+    localePathRedirect: boolean;
+    languages: string[];
+    pathname: string | undefined;
+    prevLangRef: React.MutableRefObject<string>;
+    setLang: (language: string) => void;
+    children: (synchronizeLanguage: (language: string) => void) => React.ReactNode;
+}
 interface I18nRootWrapperOptions {
     entryName?: string;
     htmlLangAttr: boolean;
@@ -8,7 +18,9 @@ interface I18nRootWrapperOptions {
     languages: string[];
     fallbackLanguage: string;
     ignoreRedirectRoutes?: BaseLocaleDetectionOptions['ignoreRedirectRoutes'];
-    localisedUrls?: BaseLocaleDetectionOptions['localisedUrls'];
+    urlStrategy?: I18nUrlStrategy;
+    NavigationProvider?: React.ComponentType<React.PropsWithChildren>;
+    LanguageSynchronization?: React.ComponentType<I18nLanguageSynchronizationProps>;
     getLatestI18nInstance: () => I18nInstance | undefined;
     getI18nextProvider: () => React.ComponentType<any> | null | undefined;
 }

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

@@ -1,27 +1,44 @@
 import type React from 'react';
-type I18nRouterFramework = 'react-router' | 'tanstack' | string;
 interface I18nRouterLocation {
     pathname: string;
     search: string;
     hash: string;
 }
-interface I18nRouterNavigateOptions {
+type I18nRouterNavigate = (href: string, options?: {
     replace?: boolean;
     state?: unknown;
-}
-type I18nRouterNavigate = (href: string, options?: I18nRouterNavigateOptions) => void | Promise<void>;
+}) => void | Promise<void>;
 type I18nRouterLink = React.ComponentType<{
     to: string;
     children?: React.ReactNode;
     [key: string]: unknown;
 }>;
-interface I18nRouterAdapter {
-    framework?: I18nRouterFramework;
+export interface I18nRouterLinkTarget {
+    pathname: string;
+    href: string;
+    search?: Record<string, unknown>;
+    hash?: string;
+    hashScrollIntoView?: boolean | ScrollIntoViewOptions;
+    prefetch?: 'intent' | 'render' | 'viewport' | 'none';
+    preload?: unknown;
+}
+export interface I18nRouterAdapter {
+    framework?: string;
     hasRouter: boolean;
     location: I18nRouterLocation | null;
     navigate: I18nRouterNavigate | null;
     Link: I18nRouterLink | null;
     params: Record<string, string>;
+    /** Convert an already resolved target to the selected router's own props. */
+    createLinkProps?: (target: I18nRouterLinkTarget) => {
+        to: string;
+        [key: string]: unknown;
+    };
 }
+export declare const I18nNavigationProvider: ({ children, value, }: React.PropsWithChildren<{
+    value: I18nRouterAdapter;
+}>) => React.JSX.Element;
+/** Read native router hooks only when their own provider is present. */
+export declare const useNativeI18nRouterAdapter: () => I18nRouterAdapter;
 export declare const useI18nRouterAdapter: () => I18nRouterAdapter;
 export {};

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

@@ -1,4 +1,5 @@
-import { type LocalisedUrlsOption } from '@modern-js/i18n-runtime-extensions';
+import type { I18nUrlStrategy } from '../shared/urlStrategy.js';
+export { splitUrlTarget } from '@modern-js/runtime-utils/url';
 export declare const getPathname: (context: {
     ssrContext?: {
         request?: {
@@ -15,15 +16,6 @@ export declare const getEntryPath: () => string;
  * @returns The detected language or fallback language
  */
 export declare const getLanguageFromPath: (pathname: string, languages: string[], fallbackLanguage: string) => string;
-/**
- * Split a link target into its pathname, search and hash parts without
- * relying on `new URL` (SSR-hot path; targets are relative).
- */
-export declare const splitUrlTarget: (target: string) => {
-    pathname: string;
-    search: string;
-    hash: string;
-};
 /**
  * Helper function to build localized URL
  * @param target - The language-agnostic target; may include `?search` and `#hash`
@@ -31,7 +23,7 @@ export declare const splitUrlTarget: (target: string) => {
  * @param languages - Array of supported languages
  * @returns The localized URL path with search and hash re-appended verbatim
  */
-export declare const buildLocalizedUrl: (target: string, language: string, languages: string[], localisedUrls?: LocalisedUrlsOption) => string;
+export declare const buildLocalizedUrl: (target: string, language: string, languages: string[], urlStrategy?: I18nUrlStrategy) => string;
 export declare const detectLanguageFromPath: (pathname: string, languages: string[], localePathRedirect: boolean) => {
     detected: boolean;
     language?: string;
@@ -39,4 +31,4 @@ export declare const detectLanguageFromPath: (pathname: string, languages: strin
 /**
  * Check if the given pathname should ignore automatic locale redirect
  */
-export declare const shouldIgnoreRedirect: (pathname: string, languages: string[], ignoreRedirectRoutes?: string[] | ((pathname: string) => boolean)) => boolean;
+export declare const shouldIgnoreRedirect: (pathname: string, languages: string[], ignoreRedirectRoutes?: string[] | ((pathname: string) => boolean), urlStrategy?: I18nUrlStrategy) => boolean;