@bleedingdev/modern-js-plugin-i18n 3.2.0-ultramodern.12 → 3.2.0-ultramodern.121

package/dist/esm/runtime/routerAdapter.mjs

@@ -0,0 +1,129 @@
+import { RuntimeContext, isBrowser } from "@modern-js/runtime";
+import { InternalRuntimeContext, getRouterRuntimeState } from "@modern-js/runtime/context";
+import { Link as router_Link, useInRouterContext, useLocation, useNavigate, useParams } from "@modern-js/runtime/router";
+import { useCallback, useContext, useEffect, useState } 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 useI18nRouterAdapter = ()=>{
+    const runtimeContext = useContext(RuntimeContext);
+    const internalContext = useContext(InternalRuntimeContext);
+    const inReactRouter = useInRouterContext();
+    const reactRouterNavigate = inReactRouter ? useNavigate() : null;
+    const reactRouterLocation = inReactRouter ? useLocation() : null;
+    const reactRouterParams = inReactRouter ? 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 [, 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 ('function' == typeof unsubscribe) unsubscribers.push(unsubscribe);
+        }
+        if ('function' == typeof router.subscribe) for (const eventType of [
+            'onBeforeNavigate',
+            'onBeforeLoad'
+        ]){
+            const unsubscribe = router.subscribe(eventType, update);
+            if ('function' == typeof unsubscribe) unsubscribers.push(unsubscribe);
+        }
+        return ()=>{
+            for (const unsubscribe of unsubscribers)unsubscribe();
+        };
+    }, [
+        contextRouter,
+        framework,
+        internalContext
+    ]);
+    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 ? router_Link : null;
+    return {
+        framework,
+        hasRouter,
+        location,
+        navigate: hasRouter ? navigate : null,
+        Link,
+        params
+    };
+};
+export { useI18nRouterAdapter };

package/dist/esm/runtime/utils.mjs

@@ -1,12 +1,6 @@
 import { isBrowser } from "@modern-js/runtime";
 import { getGlobalBasename } from "@modern-js/runtime/context";
-import { __webpack_require__ } from "../rslib-runtime.mjs";
-import * as __rspack_external__modern_js_runtime_router_2dfd0c78 from "@modern-js/runtime/router";
-__webpack_require__.add({
-    "@modern-js/runtime/router?f1fa" (module) {
-        module.exports = __rspack_external__modern_js_runtime_router_2dfd0c78;
-    }
-});
+import { localiseTargetPathname } from "../shared/localisedUrls.mjs";
 const getPathname = (context)=>{
     if (isBrowser()) return window.location.pathname;
     return context.ssrContext?.request?.pathname || '/';
@@ -22,11 +16,23 @@ const getLanguageFromPath = (pathname, languages, fallbackLanguage)=>{
     if (languages.includes(firstSegment)) return firstSegment;
     return fallbackLanguage;
 };
-const buildLocalizedUrl = (pathname, language, languages)=>{
-    const segments = pathname.split('/').filter(Boolean);
-    if (segments.length > 0 && languages.includes(segments[0])) segments[0] = language;
-    else segments.unshift(language);
-    return `/${segments.join('/')}`;
+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 { pathname, search, hash } = splitUrlTarget(target);
+    const localizedPathname = localiseTargetPathname(pathname, language, languages, localisedUrls);
+    return `${localizedPathname}${search}${hash}`;
 };
 const detectLanguageFromPath = (pathname, languages, localePathRedirect)=>{
     if (!localePathRedirect) return {
@@ -54,22 +60,4 @@ const shouldIgnoreRedirect = (pathname, languages, ignoreRedirectRoutes)=>{
     if ('function' == typeof ignoreRedirectRoutes) return ignoreRedirectRoutes(normalizedPath);
     return ignoreRedirectRoutes.some((pattern)=>normalizedPath === pattern || normalizedPath.startsWith(`${pattern}/`));
 };
-const useRouterHooks = ()=>{
-    try {
-        const { useLocation, useNavigate, useParams } = __webpack_require__("@modern-js/runtime/router?f1fa");
-        return {
-            navigate: useNavigate(),
-            location: useLocation(),
-            params: useParams(),
-            hasRouter: true
-        };
-    } catch (error) {
-        return {
-            navigate: null,
-            location: null,
-            params: {},
-            hasRouter: false
-        };
-    }
-};
-export { buildLocalizedUrl, detectLanguageFromPath, getEntryPath, getLanguageFromPath, getPathname, shouldIgnoreRedirect, useRouterHooks };
+export { buildLocalizedUrl, detectLanguageFromPath, getEntryPath, getLanguageFromPath, getPathname, shouldIgnoreRedirect, splitUrlTarget };

package/dist/esm/server/index.mjs

@@ -1,7 +1,38 @@
 import { DEFAULT_I18NEXT_DETECTION_OPTIONS, mergeDetectionOptions } from "../runtime/i18n/detection/config.mjs";
+import { localiseTargetPathname, 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)=>![
@@ -91,15 +122,12 @@ const getLanguageFromPath = (req, urlPath, languages)=>{
     if (languages.includes(firstSegment)) return firstSegment;
     return null;
 };
-const buildLocalizedUrl = (req, urlPath, language, languages)=>{
+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 segments = remainingPath.split('/').filter(Boolean);
-    if (segments.length > 0 && languages.includes(segments[0])) segments[0] = language;
-    else segments.unshift(language);
-    const newPathname = `/${segments.join('/')}`;
+    const newPathname = localiseTargetPathname(remainingPath, language, languages, localisedUrls);
     const suffix = `${url.search}${url.hash}`;
     const localizedUrl = '/' === basePath ? newPathname + suffix : basePath + newPathname + suffix;
     return localizedUrl;
@@ -109,6 +137,9 @@ const i18nServerPlugin = (options)=>({
         setup: (api)=>{
             api.onPrepare(()=>{
                 const { middlewares, routes } = api.getServerContext();
+                const serverConfig = api.getServerConfig();
+                const bffPrefix = serverConfig?.bff ? serverConfig.bff.prefix ?? '/api' : void 0;
+                const apiPrefixes = collectApiPrefixes(routes, bffPrefix);
                 const entryPaths = new Set();
                 routes.forEach((route)=>{
                     if (route.entryName && route.urlPath && '/' !== route.urlPath) {
@@ -120,7 +151,7 @@ const i18nServerPlugin = (options)=>({
                     const { entryName } = route;
                     if (!entryName) return;
                     if (!options.localeDetection) return;
-                    const { localePathRedirect, i18nextDetector = true, languages = [], fallbackLanguage = 'en', detection, ignoreRedirectRoutes } = getLocaleDetectionOptions(entryName, options.localeDetection);
+                    const { localePathRedirect, i18nextDetector = true, languages = [], fallbackLanguage = 'en', detection, ignoreRedirectRoutes, localisedUrls } = getLocaleDetectionOptions(entryName, options.localeDetection);
                     const staticRoutePrefixes = options.staticRoutePrefixes;
                     const originUrlPath = route.urlPath;
                     const urlPath = originUrlPath.endsWith('/') ? `${originUrlPath}*` : `${originUrlPath}/*`;
@@ -134,6 +165,7 @@ const i18nServerPlugin = (options)=>({
                                 handler: async (c, next)=>{
                                     const url = new URL(c.req.url);
                                     const pathname = url.pathname;
+                                    if (matchesApiPrefix(pathname, apiPrefixes)) return await next();
                                     if (isStaticResourceRequest(pathname, staticRoutePrefixes, languages)) return await next();
                                     if ('/' === originUrlPath) {
                                         const pathSegments = pathname.split('/').filter(Boolean);
@@ -152,6 +184,7 @@ const i18nServerPlugin = (options)=>({
                             handler: async (c, next)=>{
                                 const url = new URL(c.req.url);
                                 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 ('/' === originUrlPath) {
@@ -166,9 +199,14 @@ 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);
+                                    const localizedUrl = buildLocalizedUrl(c.req, originUrlPath, targetLanguage, languages, localisedUrls);
                                     return c.redirect(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);
+                                }
                                 await next();
                             }
                         });
@@ -179,4 +217,4 @@ const i18nServerPlugin = (options)=>({
     });
 const server = i18nServerPlugin;
 export default server;
-export { i18nServerPlugin };
+export { collectApiPrefixes, i18nServerPlugin, matchesApiPrefix };

package/dist/esm/shared/localisedUrls.mjs

@@ -0,0 +1,283 @@
+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] || '');
+};
+const resolveLocalisedUrlsConfig = (option)=>{
+    if (option && 'object' == typeof option && Object.keys(option).length > 0) return {
+        enabled: true,
+        map: option
+    };
+    return {
+        enabled: false,
+        map: {}
+    };
+};
+const isLocalisableRoutePath = (path)=>{
+    const pathWithoutLocale = stripLeadingLocaleParam(path);
+    if (!pathWithoutLocale || '/' === pathWithoutLocale || '*' === pathWithoutLocale) return false;
+    return true;
+};
+const joinPath = (parentPath, routePath)=>{
+    if (!isLocalisableRoutePath(routePath)) return parentPath;
+    const segment = normaliseRoutePath(stripLeadingLocaleParam(routePath) || '');
+    return normalisePathPattern(`${parentPath}/${segment}`);
+};
+const ensureLocalisedUrlsForPath = (canonicalPath, languages, localisedUrls)=>{
+    const entry = localisedUrls[canonicalPath];
+    if (!entry) throw new Error(`localisedUrls is enabled, but route "${canonicalPath}" does not define localised URLs for languages: ${languages.join(', ')}. Add localisedUrls["${canonicalPath}"] or set localeDetection.localisedUrls to false.`);
+    const missingLanguages = languages.filter((language)=>!entry[language]);
+    if (missingLanguages.length > 0) throw new Error(`localisedUrls["${canonicalPath}"] is missing languages: ${missingLanguages.join(', ')}. Every configured language must have a localised URL.`);
+    return entry;
+};
+const validateLocalisedUrls = (routes, languages, localisedUrls)=>{
+    const visit = (route, parentPath)=>{
+        const canonicalPath = joinPath(parentPath, route.path);
+        if (isLocalisableRoutePath(route.path)) ensureLocalisedUrlsForPath(canonicalPath, languages, localisedUrls);
+        if ('children' in route && route.children) route.children.forEach((child)=>visit(child, canonicalPath));
+    };
+    routes.forEach((route)=>visit(route, ''));
+};
+const getLocalisedRoutePaths = (canonicalPath, parentLocalisedPaths, languages, entry)=>{
+    const paths = languages.map((language)=>{
+        const fullPath = normalisePathPattern(entry[language]);
+        const parentPath = normalisePathPattern(parentLocalisedPaths[language] || '/');
+        if ('/' === parentPath) return normaliseRoutePath(fullPath) || void 0;
+        const parentPrefix = `${parentPath}/`;
+        if (!fullPath.startsWith(parentPrefix)) throw new Error(`localisedUrls["${canonicalPath}"].${language} must be nested under "${parentPath}" because its parent route is localised there.`);
+        return normaliseRoutePath(fullPath.slice(parentPath.length));
+    });
+    return Array.from(new Set(paths.filter(Boolean)));
+};
+const transformLocalisedRoute = (route, parentCanonicalPath, parentLocalisedPaths, languages, localisedUrls)=>{
+    const canonicalPath = joinPath(parentCanonicalPath, route.path);
+    const localisedUrlEntry = isLocalisableRoutePath(route.path) ? ensureLocalisedUrlsForPath(canonicalPath, languages, localisedUrls) : void 0;
+    const routeLocalisedPaths = localisedUrlEntry ? languages.reduce((acc, language)=>{
+        acc[language] = normalisePathPattern(localisedUrlEntry[language]);
+        return acc;
+    }, {}) : parentLocalisedPaths;
+    const children = 'children' in route && route.children ? route.children.flatMap((child)=>transformLocalisedRoute(child, canonicalPath, routeLocalisedPaths, languages, localisedUrls)) : void 0;
+    const baseRoute = {
+        ...route,
+        ...children ? {
+            children
+        } : {}
+    };
+    if (!localisedUrlEntry) return [
+        baseRoute
+    ];
+    return getLocalisedRoutePaths(canonicalPath, parentLocalisedPaths, languages, localisedUrlEntry).map((localisedPath, index)=>cloneRouteWithLocalisedPath(baseRoute, localisedPath, index, canonicalPath));
+};
+const legalRouteIdPart = (value)=>value.replace(/[^a-zA-Z0-9_$-]+/g, '_').replace(/^_+|_+$/g, '') || 'index';
+const suffixRouteIds = (route, suffix)=>{
+    const children = 'children' in route && route.children ? route.children.map((child)=>suffixRouteIds(child, suffix)) : void 0;
+    return {
+        ...route,
+        ...route.id ? {
+            id: `${route.id}__localised_${suffix}`
+        } : {},
+        ...children ? {
+            children
+        } : {}
+    };
+};
+const cloneRouteWithLocalisedPath = (route, path, index, canonicalPath)=>{
+    const leadingLocaleParam = getLeadingLocaleParam(route.path);
+    const localisedPath = leadingLocaleParam ? normaliseRoutePath(`${leadingLocaleParam}/${path}`) : path;
+    const routeWithPath = {
+        ...route,
+        path: localisedPath
+    };
+    routeWithPath.modernCanonicalPath = canonicalPath;
+    return 0 === index ? routeWithPath : suffixRouteIds(routeWithPath, legalRouteIdPart(localisedPath));
+};
+const applyLocalisedUrlsToRoutes = (routes, languages, localisedUrls)=>{
+    const rootLocalisedPaths = languages.reduce((acc, language)=>{
+        acc[language] = '/';
+        return acc;
+    }, {});
+    validateLocalisedUrls(routes, languages, localisedUrls);
+    return routes.flatMap((route)=>transformLocalisedRoute(route, '', rootLocalisedPaths, languages, localisedUrls));
+};
+const escapeRegExp = (value)=>value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+const getParamName = (segment)=>segment.slice(1).replace(/\?$/, '');
+const compiledPathPatternCache = new Map();
+const compilePathPattern = (pattern)=>{
+    const normalizedPattern = normalisePathPattern(pattern);
+    const cached = compiledPathPatternCache.get(normalizedPattern);
+    if (cached) return cached;
+    const names = [];
+    const segments = normalizedPattern.split('/').filter(Boolean);
+    const source = segments.map((segment)=>{
+        if (segment.startsWith(':')) {
+            names.push(getParamName(segment));
+            const paramPattern = '([^/]+)';
+            return segment.endsWith('?') ? `(?:/${paramPattern})?` : `/${paramPattern}`;
+        }
+        if ('*' === segment) {
+            names.push('*');
+            return '/(.*)';
+        }
+        return `/${escapeRegExp(segment)}`;
+    }).join('');
+    const compiled = {
+        names,
+        regexp: new RegExp(`^${source || '/'}$`)
+    };
+    compiledPathPatternCache.set(normalizedPattern, compiled);
+    return compiled;
+};
+const getPatternSpecificity = (pattern)=>{
+    const segments = normalisePathPattern(pattern).split('/').filter(Boolean);
+    let staticSegments = 0;
+    let dynamicSegments = 0;
+    let splatSegments = 0;
+    for (const segment of segments)if ('*' === segment) splatSegments++;
+    else if (segment.startsWith(':')) dynamicSegments++;
+    else staticSegments++;
+    return {
+        staticSegments,
+        dynamicSegments,
+        splatSegments,
+        totalSegments: segments.length
+    };
+};
+const comparePatternSpecificity = (left, right)=>{
+    const a = getPatternSpecificity(left);
+    const b = getPatternSpecificity(right);
+    return b.staticSegments - a.staticSegments || b.totalSegments - a.totalSegments || a.splatSegments - b.splatSegments || a.dynamicSegments - b.dynamicSegments;
+};
+const sortPatternsBySpecificity = (patterns)=>patterns.map((pattern, index)=>({
+            pattern,
+            index
+        })).sort((left, right)=>comparePatternSpecificity(left.pattern.pattern, right.pattern.pattern) || left.index - right.index).map(({ pattern })=>pattern);
+const decodePathParam = (value)=>{
+    try {
+        return decodeURIComponent(value);
+    } catch  {
+        return null;
+    }
+};
+const matchPathPattern = (pathname, pattern)=>{
+    const { names, regexp } = compilePathPattern(pattern);
+    const match = regexp.exec(normalisePathname(pathname));
+    if (!match) return null;
+    const params = {};
+    for(let index = 0; index < names.length; index++){
+        const decoded = decodePathParam(match[index + 1] || '');
+        if (null === decoded) return null;
+        params[names[index]] = decoded;
+    }
+    return params;
+};
+const buildPathFromPattern = (pattern, params)=>{
+    const segments = normalisePathPattern(pattern).split('/').filter(Boolean);
+    const path = segments.map((segment)=>{
+        if (segment.startsWith(':')) {
+            const param = params[getParamName(segment)];
+            return param ? encodeURIComponent(param) : '';
+        }
+        if ('*' === segment) return params['*'] || '';
+        return segment;
+    }).filter(Boolean).join('/');
+    return `/${path}`;
+};
+const resolveLocalisedPath = (pathname, targetLanguage, languages, localisedUrls)=>{
+    const normalizedPathname = normalisePathname(pathname);
+    const canonicalCandidates = sortPatternsBySpecificity(Object.entries(localisedUrls).map(([canonicalPattern, localisedUrlEntry])=>({
+            pattern: canonicalPattern,
+            canonicalPattern,
+            localisedUrlEntry
+        })));
+    for (const { canonicalPattern, localisedUrlEntry } of canonicalCandidates){
+        const targetPattern = localisedUrlEntry[targetLanguage];
+        if (!targetPattern) continue;
+        const params = matchPathPattern(normalizedPathname, canonicalPattern);
+        if (params) return buildPathFromPattern(targetPattern, params);
+    }
+    const localisedCandidates = sortPatternsBySpecificity(Object.values(localisedUrls).flatMap((localisedUrlEntry)=>{
+        const targetPattern = localisedUrlEntry[targetLanguage];
+        if (!targetPattern) return [];
+        return languages.map((language)=>localisedUrlEntry[language]).filter((sourcePattern)=>Boolean(sourcePattern)).map((sourcePattern)=>({
+                pattern: sourcePattern,
+                sourcePattern,
+                targetPattern
+            }));
+    }));
+    for (const { sourcePattern, targetPattern } of localisedCandidates){
+        const params = matchPathPattern(normalizedPathname, sourcePattern);
+        if (params) return buildPathFromPattern(targetPattern, params);
+    }
+    return normalizedPathname;
+};
+const resolveCanonicalLocalisedPath = (pathname, languages, localisedUrls)=>{
+    const normalizedPathname = normalisePathname(pathname);
+    const canonicalCandidates = sortPatternsBySpecificity(Object.entries(localisedUrls).map(([canonicalPattern, localisedUrlEntry])=>({
+            pattern: canonicalPattern,
+            canonicalPattern,
+            localisedUrlEntry
+        })));
+    for (const { canonicalPattern, localisedUrlEntry } of canonicalCandidates){
+        const canonicalParams = matchPathPattern(normalizedPathname, canonicalPattern);
+        if (canonicalParams) return buildPathFromPattern(canonicalPattern, canonicalParams);
+        for (const language of languages){
+            const sourcePattern = localisedUrlEntry[language];
+            if (!sourcePattern) continue;
+            const params = matchPathPattern(normalizedPathname, sourcePattern);
+            if (params) return buildPathFromPattern(canonicalPattern, params);
+        }
+    }
+    return normalizedPathname;
+};
+const stripLanguagePrefix = (pathname, languages)=>{
+    const segments = pathname.split('/').filter(Boolean);
+    if (segments.length > 0 && languages.includes(segments[0])) 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 { applyLocalisedUrlsToRoutes, buildPathFromPattern, canonicalTargetPathname, localiseTargetPathname, matchPathPattern, normalisePathPattern, normalisePathname, resolveCanonicalLocalisedPath, resolveLocalisedPath, resolveLocalisedUrlsConfig, validateLocalisedUrls };

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

@@ -2,7 +2,9 @@ import "node:module";
 import { getPublicDirRoutePrefixes } from "@modern-js/server-core";
 import fs from "fs";
 import path from "path";
+import { applyLocalisedUrlsToRoutes, resolveLocalisedUrlsConfig } from "../shared/localisedUrls.mjs";
 import { getBackendOptions, getLocaleDetectionOptions } from "../shared/utils.mjs";
+import "../runtime/types.mjs";
 function hasJsonFiles(dirPath) {
     try {
         if (!fs.existsSync(dirPath) || !fs.statSync(dirPath).isDirectory()) return false;
@@ -81,6 +83,27 @@ const i18nPlugin = (options = {})=>({
                     plugins
                 };
             });
+            api.modifyFileSystemRoutes(({ entrypoint, routes })=>{
+                if (!localeDetection) return {
+                    entrypoint,
+                    routes
+                };
+                const localeDetectionOptions = getLocaleDetectionOptions(entrypoint.entryName, localeDetection);
+                const { localePathRedirect, languages = [], localisedUrls } = localeDetectionOptions;
+                if (!localePathRedirect || 0 === languages.length) return {
+                    entrypoint,
+                    routes
+                };
+                const localisedUrlsConfig = resolveLocalisedUrlsConfig(localisedUrls);
+                if (!localisedUrlsConfig.enabled) return {
+                    entrypoint,
+                    routes
+                };
+                return {
+                    entrypoint,
+                    routes: applyLocalisedUrlsToRoutes(routes, languages, localisedUrlsConfig.map)
+                };
+            });
             api._internalServerPlugins(({ plugins })=>{
                 const { serverRoutes, metaName } = api.getAppContext();
                 const normalizedConfig = api.getNormalizedConfig();

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

@@ -1,29 +1,14 @@
 import "node:module";
 import { jsx } from "react/jsx-runtime";
-import { Link as router_Link, useInRouterContext, useParams } from "@modern-js/runtime/router";
-import { useModernI18n } from "./context.mjs";
-import { buildLocalizedUrl } from "./utils.mjs";
-const useRouterHooks = ()=>{
-    const inRouter = useInRouterContext();
-    return {
-        Link: inRouter ? router_Link : null,
-        params: inRouter ? useParams() : {},
-        hasRouter: inRouter
-    };
-};
+import { Link } from "./Link.mjs";
+let warnedDeprecation = false;
 const I18nLink = ({ to, children, ...props })=>{
-    const { Link, params, hasRouter } = useRouterHooks();
-    const { language, supportedLanguages } = useModernI18n();
-    const currentLang = language;
-    const localizedTo = buildLocalizedUrl(to, currentLang, supportedLanguages);
-    if ('development' === process.env.NODE_ENV && hasRouter && !params.lang) console.warn("I18nLink is being used outside of a :lang dynamic route context. This may cause unexpected behavior. Please ensure I18nLink is used within a route that has a :lang parameter.");
-    if (!hasRouter || !Link) return /*#__PURE__*/ jsx("a", {
-        href: localizedTo,
-        ...props,
-        children: children
-    });
+    if ('development' === process.env.NODE_ENV && !warnedDeprecation) {
+        warnedDeprecation = true;
+        console.warn("[plugin-i18n] I18nLink is deprecated. Import { Link } from '@modern-js/plugin-i18n/runtime' instead — it accepts the same language-agnostic `to` values.");
+    }
     return /*#__PURE__*/ jsx(Link, {
-        to: localizedTo,
+        to: to,
         ...props,
         children: children
     });