@bleedingdev/modern-js-plugin-i18n 3.2.0-ultramodern.11 → 3.2.0-ultramodern.111

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

@@ -0,0 +1,192 @@
+import "node:module";
+const LOCALE_PARAM_NAMES = new Set([
+    'lang',
+    'locale',
+    'language'
+]);
+const normalisePathPattern = (path)=>{
+    const withoutDuplicateSlashes = path.replace(/\/+/g, '/');
+    const withLeadingSlash = withoutDuplicateSlashes.startsWith('/') ? withoutDuplicateSlashes : `/${withoutDuplicateSlashes}`;
+    const withoutTrailingSlash = withLeadingSlash.length > 1 ? withLeadingSlash.replace(/\/+$/, '') : withLeadingSlash;
+    return withoutTrailingSlash.replace(/\[(.+?)\]/g, ':$1');
+};
+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 (false === option) return {
+        enabled: false,
+        map: {}
+    };
+    if (option && 'object' == typeof option) return {
+        enabled: true,
+        map: option
+    };
+    return {
+        enabled: true,
+        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));
+};
+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)=>{
+    const leadingLocaleParam = getLeadingLocaleParam(route.path);
+    const localisedPath = leadingLocaleParam ? normaliseRoutePath(`${leadingLocaleParam}/${path}`) : path;
+    const routeWithPath = {
+        ...route,
+        path: localisedPath
+    };
+    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 compilePathPattern = (pattern)=>{
+    const names = [];
+    const segments = normalisePathPattern(pattern).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('');
+    return {
+        names,
+        regexp: new RegExp(`^${source || '/'}$`)
+    };
+};
+const matchPathPattern = (pathname, pattern)=>{
+    const { names, regexp } = compilePathPattern(pattern);
+    const match = regexp.exec(normalisePathPattern(pathname));
+    if (!match) return null;
+    return names.reduce((params, name, index)=>{
+        params[name] = decodeURIComponent(match[index + 1] || '');
+        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 = normalisePathPattern(pathname);
+    for (const localisedUrlEntry of Object.values(localisedUrls)){
+        const targetPattern = localisedUrlEntry[targetLanguage];
+        if (targetPattern) for (const language of languages){
+            const sourcePattern = localisedUrlEntry[language];
+            if (!sourcePattern) continue;
+            const params = matchPathPattern(normalizedPathname, sourcePattern);
+            if (params) return buildPathFromPattern(targetPattern, params);
+        }
+    }
+    return normalizedPathname;
+};
+export { applyLocalisedUrlsToRoutes, normalisePathPattern, resolveLocalisedPath, resolveLocalisedUrlsConfig, validateLocalisedUrls };

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

@@ -1,6 +1,7 @@
 import type { AppTools, CliPlugin } from '@modern-js/app-tools';
 import type { Entrypoint } from '@modern-js/types';
 import type { BackendOptions, LocaleDetectionOptions } from '../shared/type';
+import '../runtime/types';
 export type TransformRuntimeConfigFn = (extendedConfig: Record<string, any>, entrypoint: Entrypoint) => Record<string, any>;
 export interface I18nPluginOptions {
     localeDetection?: LocaleDetectionOptions;

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

@@ -4,5 +4,20 @@ export interface I18nLinkProps {
     children: React.ReactNode;
     [key: string]: any;
 }
+/**
+ * I18nLink component that automatically adds language prefix to navigation links.
+ * This component should be used within a :lang dynamic route context.
+ *
+ * @example
+ * ```tsx
+ * // When current language is 'en' and to="/about"
+ * // The actual link will be "/en/about"
+ * <I18nLink to="/about">About</I18nLink>
+ *
+ * // When current language is 'zh' and to="/"
+ * // The actual link will be "/zh"
+ * <I18nLink to="/">Home</I18nLink>
+ * ```
+ */
 export declare const I18nLink: React.FC<I18nLinkProps>;
 export default I18nLink;

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

@@ -1,4 +1,5 @@
 import type { FC, ReactNode } from 'react';
+import type { LocalisedUrlsOption } from '../shared/localisedUrls';
 import type { I18nInstance } from './i18n';
 export interface ModernI18nContextValue {
     language: string;
@@ -7,6 +8,7 @@ export interface ModernI18nContextValue {
     languages?: string[];
     localePathRedirect?: boolean;
     ignoreRedirectRoutes?: string[] | ((pathname: string) => boolean);
+    localisedUrls?: LocalisedUrlsOption;
     updateLanguage?: (newLang: string) => void;
 }
 export interface ModernI18nProviderProps {
@@ -19,6 +21,7 @@ export interface UseModernI18nReturn {
     changeLanguage: (newLang: string) => Promise<void>;
     i18nInstance: I18nInstance;
     supportedLanguages: string[];
+    localisedUrls?: LocalisedUrlsOption;
     isLanguageSupported: (lang: string) => boolean;
     isResourcesReady: boolean;
 }

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

@@ -1,16 +1,18 @@
 import type { TRuntimeContext } from '@modern-js/runtime';
 import type React from 'react';
+import type { LocalisedUrlsOption } from '../shared/localisedUrls';
 import type { I18nInstance } from './i18n';
 interface RuntimeContextWithI18n extends TRuntimeContext {
     i18nInstance?: I18nInstance;
 }
-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): {
+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): {
     language: string;
     i18nInstance: I18nInstance;
     entryName: string | undefined;
     languages: string[];
     localePathRedirect: boolean;
     ignoreRedirectRoutes: string[] | ((pathname: string) => boolean) | undefined;
+    localisedUrls: LocalisedUrlsOption | undefined;
     updateLanguage: (lang: string) => void;
 };
 export declare function useSdkResourcesLoader(i18nInstance: I18nInstance | undefined, setForceUpdate: React.Dispatch<React.SetStateAction<number>>): void;
@@ -23,6 +25,6 @@ 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)): void;
+export declare function useClientSideRedirect(i18nInstance: I18nInstance | undefined, localePathRedirect: boolean, languages: string[], fallbackLanguage: string, ignoreRedirectRoutes?: string[] | ((pathname: string) => boolean), localisedUrls?: LocalisedUrlsOption): void;
 export declare function useLanguageSync(i18nInstance: I18nInstance | undefined, localePathRedirect: boolean, languages: string[], runtimeContextRef: React.MutableRefObject<RuntimeContextWithI18n>, prevLangRef: React.MutableRefObject<string>, setLang: (lang: string) => void): void;
 export {};

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

@@ -1,4 +1,4 @@
-import Backend from 'i18next-fs-backend';
+import Backend from 'i18next-fs-backend/cjs';
 import type { ExtendedBackendOptions } from '../../../shared/type';
 import type { I18nInstance } from '../instance';
 /**

package/dist/types/runtime/i18n/instance.d.ts

@@ -1,7 +1,4 @@
 import type { BaseBackendOptions } from '../../shared/type';
-type ReactI18nextModule = typeof import('react-i18next');
-type InitReactI18next = ReactI18nextModule['initReactI18next'];
-type I18nextProviderComponent = ReactI18nextModule['I18nextProvider'];
 export interface I18nResourceStore {
     data?: {
         [language: string]: {
@@ -64,9 +61,12 @@ export interface BackendOptions extends Omit<BaseBackendOptions, 'enabled'> {
     stringify?: (data: any) => string;
     [key: string]: any;
 }
+export type ResourceValue = string | {
+    [key: string]: ResourceValue;
+};
 export interface Resources {
     [lng: string]: {
-        [source: string]: string | Record<string, string>;
+        [source: string]: ResourceValue;
     };
 }
 export type I18nInitOptions = {
@@ -91,6 +91,4 @@ export type I18nInitOptions = {
 export declare function isI18nInstance(obj: any): obj is I18nInstance;
 export declare function getI18nextInstanceForProvider(instance: I18nInstance | any): any;
 export declare function getI18nInstance(userInstance?: I18nInstance | any): Promise<I18nInstance>;
-export declare function getInitReactI18next(): Promise<InitReactI18next | null>;
-export declare function getI18nextProvider(): Promise<I18nextProviderComponent | null>;
 export {};

package/dist/types/runtime/i18n/react-i18next.d.ts

@@ -0,0 +1,7 @@
+import type React from 'react';
+interface ReactI18nextIntegration {
+    I18nextProvider: React.ComponentType<any> | null;
+    initReactI18next: any | null;
+}
+export declare function getReactI18nextIntegration(): Promise<ReactI18nextIntegration>;
+export {};

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

@@ -12,6 +12,7 @@ export interface I18nPluginOptions {
     changeLanguage?: (lang: string) => void;
     initOptions?: I18nInitOptions;
     htmlLangAttr?: boolean;
+    reactI18next?: boolean;
     [key: string]: any;
 }
 export declare const i18nPlugin: (options: I18nPluginOptions) => RuntimePlugin;

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

@@ -0,0 +1,26 @@
+import type React from 'react';
+export type I18nRouterFramework = 'react-router' | 'tanstack' | string;
+export interface I18nRouterLocation {
+    pathname: string;
+    search: string;
+    hash: string;
+}
+export interface I18nRouterNavigateOptions {
+    replace?: boolean;
+    state?: unknown;
+}
+export type I18nRouterNavigate = (href: string, options?: I18nRouterNavigateOptions) => void | Promise<void>;
+export type I18nRouterLink = React.ComponentType<{
+    to: string;
+    children?: React.ReactNode;
+    [key: string]: unknown;
+}>;
+export interface I18nRouterAdapter {
+    framework?: I18nRouterFramework;
+    hasRouter: boolean;
+    location: I18nRouterLocation | null;
+    navigate: I18nRouterNavigate | null;
+    Link: I18nRouterLink | null;
+    params: Record<string, string>;
+}
+export declare const useI18nRouterAdapter: () => I18nRouterAdapter;

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

@@ -8,7 +8,7 @@ declare module '@modern-js/runtime' {
             initOptions?: I18nInitOptions;
         };
     }
-    interface TInternalRuntimeContext {
+    interface TRuntimeContext {
         i18nInstance?: I18nInstance;
         changeLanguage?: (lang: string) => Promise<void>;
     }

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

@@ -1,4 +1,5 @@
 import { type TInternalRuntimeContext } from '@modern-js/runtime/context';
+import type { LocalisedUrlsMap } from '../shared/localisedUrls';
 export declare const getPathname: (context: TInternalRuntimeContext) => string;
 export declare const getEntryPath: () => string;
 /**
@@ -16,7 +17,7 @@ export declare const getLanguageFromPath: (pathname: string, languages: string[]
  * @param languages - Array of supported languages
  * @returns The localized URL path
  */
-export declare const buildLocalizedUrl: (pathname: string, language: string, languages: string[]) => string;
+export declare const buildLocalizedUrl: (pathname: string, language: string, languages: string[], localisedUrls?: boolean | LocalisedUrlsMap) => string;
 export declare const detectLanguageFromPath: (pathname: string, languages: string[], localePathRedirect: boolean) => {
     detected: boolean;
     language?: string;
@@ -25,9 +26,3 @@ 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 useRouterHooks: () => {
-    navigate: any;
-    location: any;
-    params: any;
-    hasRouter: boolean;
-};

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

@@ -4,5 +4,11 @@ export interface I18nPluginOptions {
     localeDetection: LocaleDetectionOptions;
     staticRoutePrefixes: string[];
 }
+type ApiPrefixInput = string | string[] | undefined;
+export declare const collectApiPrefixes: (routes: Array<{
+    isApi?: boolean;
+    urlPath?: string;
+}>, bffPrefix?: ApiPrefixInput) => string[];
+export declare const matchesApiPrefix: (pathname: string, apiPrefixes: string[]) => boolean;
 export declare const i18nServerPlugin: (options: I18nPluginOptions) => ServerPlugin;
 export default i18nServerPlugin;

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

@@ -0,0 +1,13 @@
+import type { NestedRouteForCli, PageRoute } from '@modern-js/types';
+export type LocalisedUrlPathMap = Record<string, string>;
+export type LocalisedUrlsMap = Record<string, LocalisedUrlPathMap>;
+export type LocalisedUrlsOption = boolean | LocalisedUrlsMap;
+export interface ResolvedLocalisedUrlsConfig {
+    enabled: boolean;
+    map: LocalisedUrlsMap;
+}
+export declare const normalisePathPattern: (path: string) => string;
+export declare const resolveLocalisedUrlsConfig: (option: LocalisedUrlsOption | undefined) => ResolvedLocalisedUrlsConfig;
+export declare const validateLocalisedUrls: (routes: (NestedRouteForCli | PageRoute)[], languages: string[], localisedUrls: LocalisedUrlsMap) => void;
+export declare const applyLocalisedUrlsToRoutes: (routes: (NestedRouteForCli | PageRoute)[], languages: string[], localisedUrls: LocalisedUrlsMap) => (NestedRouteForCli | PageRoute)[];
+export declare const resolveLocalisedPath: (pathname: string, targetLanguage: string, languages: string[], localisedUrls: LocalisedUrlsMap) => string;

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

@@ -1,4 +1,5 @@
 import type { LanguageDetectorOptions, Resources } from '../runtime/i18n/instance';
+import type { LocalisedUrlsOption } from './localisedUrls';
 export interface BaseLocaleDetectionOptions {
     localePathRedirect?: boolean;
     i18nextDetector?: boolean;
@@ -6,6 +7,17 @@ export interface BaseLocaleDetectionOptions {
     fallbackLanguage?: string;
     detection?: LanguageDetectorOptions;
     ignoreRedirectRoutes?: string[] | ((pathname: string) => boolean);
+    /**
+     * Enables localised pathnames in addition to the locale prefix.
+     *
+     * - `false`: keep only locale-prefix behavior (`/en/about`).
+     * - object: map canonical route paths to every configured language.
+     *
+     * Defaults to `true` when `localePathRedirect` is enabled, so route
+     * generation validates that every localisable route path has entries for all
+     * configured languages.
+     */
+    localisedUrls?: LocalisedUrlsOption;
 }
 export interface LocaleDetectionOptions extends BaseLocaleDetectionOptions {
     localeDetectionByEntry?: Record<string, BaseLocaleDetectionOptions>;

package/package.json

@@ -17,7 +17,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "3.2.0-ultramodern.11",
+  "version": "3.2.0-ultramodern.111",
   "engines": {
     "node": ">=20"
   },
@@ -81,47 +81,43 @@
     }
   },
   "dependencies": {
-    "@swc/helpers": "^0.5.21",
+    "@swc/helpers": "^0.5.23",
     "i18next-browser-languagedetector": "^8.2.1",
     "i18next-chained-backend": "^5.0.4",
-    "i18next-fs-backend": "^2.6.5",
+    "i18next-fs-backend": "^2.6.6",
     "i18next-http-backend": "^4.0.0",
-    "i18next-http-middleware": "^3.9.6",
-    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.2.0-ultramodern.11",
-    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.2.0-ultramodern.11",
-    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.2.0-ultramodern.11",
-    "@modern-js/server-runtime": "npm:@bleedingdev/modern-js-server-runtime@3.2.0-ultramodern.11",
-    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.2.0-ultramodern.11",
-    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.2.0-ultramodern.11"
+    "i18next-http-middleware": "^3.9.7",
+    "react-i18next": "17.0.8",
+    "@modern-js/server-runtime": "npm:@bleedingdev/modern-js-server-runtime@3.2.0-ultramodern.111",
+    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.2.0-ultramodern.111",
+    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.2.0-ultramodern.111",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.2.0-ultramodern.111",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.2.0-ultramodern.111",
+    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.2.0-ultramodern.111"
   },
   "peerDependencies": {
-    "@modern-js/runtime": "3.2.0-ultramodern.11",
+    "@modern-js/runtime": "3.2.0-ultramodern.111",
     "i18next": ">=25.7.4",
-    "react": "^19.2.6",
-    "react-dom": "^19.2.6",
-    "react-i18next": ">=15.7.4"
+    "react": "^19.2.7",
+    "react-dom": "^19.2.7"
   },
   "peerDependenciesMeta": {
     "i18next": {
       "optional": true
-    },
-    "react-i18next": {
-      "optional": true
     }
   },
   "devDependencies": {
     "@rslib/core": "0.21.5",
     "@types/jest": "^30.0.0",
-    "@types/node": "^25.8.0",
-    "@typescript/native-preview": "7.0.0-dev.20260516.1",
-    "i18next": "26.2.0",
+    "@types/node": "^25.9.1",
+    "@typescript/native-preview": "7.0.0-dev.20260606.1",
+    "i18next": "26.3.1",
     "jest": "^30.4.2",
-    "react": "^19.2.6",
-    "react-dom": "^19.2.6",
-    "react-i18next": "17.0.8",
-    "ts-jest": "^29.4.9",
-    "@modern-js/runtime": "npm:@bleedingdev/modern-js-runtime@3.2.0-ultramodern.11",
-    "@modern-js/app-tools": "npm:@bleedingdev/modern-js-app-tools@3.2.0-ultramodern.11"
+    "react": "^19.2.7",
+    "react-dom": "^19.2.7",
+    "ts-jest": "^29.4.11",
+    "@modern-js/app-tools": "npm:@bleedingdev/modern-js-app-tools@3.2.0-ultramodern.111",
+    "@modern-js/runtime": "npm:@bleedingdev/modern-js-runtime@3.2.0-ultramodern.111"
   },
   "sideEffects": false,
   "publishConfig": {
@@ -130,7 +126,7 @@
   },
   "scripts": {
     "dev": "rslib build --watch",
-    "build": "rslib build",
+    "build": "rslib build && pnpm -w tsgo:dts \"$PWD\"",
     "test": "rstest --passWithNoTests"
   }
 }

package/rstest.config.mts

@@ -0,0 +1,39 @@
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import type { ProjectConfig } from '@rstest/core';
+import { withTestPreset } from '@scripts/rstest-config';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const commonConfig: ProjectConfig = {
+  setupFiles: [resolve(__dirname, '../../../scripts/rstest-config/setup.ts')],
+  globals: true,
+  tools: {
+    swc: {
+      jsc: {
+        transform: {
+          react: {
+            runtime: 'automatic',
+          },
+        },
+      },
+    },
+  },
+};
+
+export default {
+  projects: [
+    withTestPreset({
+      name: 'plugin-i18n-node',
+      testEnvironment: 'node',
+      include: ['tests/localisedUrls.test.ts'],
+      extends: commonConfig,
+    }),
+    withTestPreset({
+      name: 'plugin-i18n-client',
+      testEnvironment: 'happy-dom',
+      include: ['tests/routerAdapter.test.tsx'],
+      extends: commonConfig,
+    }),
+  ],
+};

package/src/cli/index.ts

@@ -1,10 +1,19 @@
 import type { AppTools, CliPlugin } from '@modern-js/app-tools';
 import { getPublicDirRoutePrefixes } from '@modern-js/server-core';
-import type { Entrypoint } from '@modern-js/types';
+import type {
+  Entrypoint,
+  NestedRouteForCli,
+  PageRoute,
+} from '@modern-js/types';
 import fs from 'fs';
 import path from 'path';
+import {
+  applyLocalisedUrlsToRoutes,
+  resolveLocalisedUrlsConfig,
+} from '../shared/localisedUrls';
 import type { BackendOptions, LocaleDetectionOptions } from '../shared/type';
 import { getBackendOptions, getLocaleDetectionOptions } from '../shared/utils';
+import '../runtime/types';
 
 export type TransformRuntimeConfigFn = (
   extendedConfig: Record<string, any>,
@@ -203,6 +212,40 @@ export const i18nPlugin = (
       };
     });
 
+    api.modifyFileSystemRoutes(({ entrypoint, routes }) => {
+      if (!localeDetection) {
+        return { entrypoint, routes };
+      }
+
+      const localeDetectionOptions = getLocaleDetectionOptions(
+        entrypoint.entryName,
+        localeDetection,
+      );
+      const {
+        localePathRedirect,
+        languages = [],
+        localisedUrls,
+      } = localeDetectionOptions;
+
+      if (!localePathRedirect || languages.length === 0) {
+        return { entrypoint, routes };
+      }
+
+      const localisedUrlsConfig = resolveLocalisedUrlsConfig(localisedUrls);
+      if (!localisedUrlsConfig.enabled) {
+        return { entrypoint, routes };
+      }
+
+      return {
+        entrypoint,
+        routes: applyLocalisedUrlsToRoutes(
+          routes as (NestedRouteForCli | PageRoute)[],
+          languages,
+          localisedUrlsConfig.map,
+        ),
+      };
+    });
+
     api._internalServerPlugins(({ plugins }) => {
       const { serverRoutes, metaName } = api.getAppContext();
       const normalizedConfig = api.getNormalizedConfig();