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

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

@@ -0,0 +1,66 @@
+import type React from 'react';
+import type { LinkParamsProp, LinkTargetPathname, ValidateLinkTo } from './canonicalRoutes';
+export type LinkParams = Record<string, string | number | undefined>;
+/**
+ * Interpolate `$param`, `:param`, optional (`{-$param}` / `:param?`) and splat
+ * (`$` / `*`) segments with concrete values before localization, so
+ * pattern-mapped slugs localize correctly.
+ */
+export declare const interpolateRouteParams: (pathname: string, params?: LinkParams) => string;
+export interface LinkActiveOptions {
+    /**
+     * `true`: active only when the location matches the target exactly.
+     * `false`: also active when the location is nested under the target.
+     * Defaults to prefix matching, except for `/` which defaults to exact.
+     */
+    exact?: boolean;
+}
+type AnchorRest = Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, 'href' | 'children'>;
+export interface LinkBaseProps extends AnchorRest {
+    children?: React.ReactNode;
+    /** Hash fragment without the leading `#`. Overrides a `#hash` inside `to`. */
+    hash?: string;
+    /** Search params. Object form is passed natively to TanStack Link. */
+    search?: string | Record<string, unknown>;
+    hashScrollIntoView?: boolean | ScrollIntoViewOptions;
+    replace?: boolean;
+    /**
+     * Prefetching behavior, forwarded to the underlying router link:
+     * react-router gets it verbatim (Modern.js `PrefetchLink` supports it),
+     * TanStack receives it as its native `preload` prop (`'none'` -> `false`).
+     * Stripped from plain `<a>` fallbacks (external / no-router targets).
+     */
+    prefetch?: 'intent' | 'render' | 'viewport' | 'none';
+    /**
+     * Native preload value of the underlying router link. When set, it wins
+     * over `prefetch` on the TanStack branch.
+     */
+    preload?: unknown;
+    activeOptions?: LinkActiveOptions;
+    /** Extra anchor props applied when the link is active. */
+    activeProps?: AnchorRest & Record<string, unknown>;
+    [key: string]: unknown;
+}
+export type LinkProps<TTo extends string = string> = LinkBaseProps & {
+    to: TTo;
+} & ValidateLinkTo<TTo> & LinkParamsProp<LinkTargetPathname<TTo>>;
+/**
+ * The standard UltraModern link: a vanilla link in every respect except that
+ * it localizes canonical, language-agnostic paths automatically.
+ *
+ * - `to` accepts canonical routes (`/talks/$slug`), optionally with `#hash`
+ *   and `?query` suffixes; both survive localization.
+ * - External URLs and bare `#hash` targets render a plain `<a>`.
+ * - Active state is language-invariant: a canonical `to` is active when the
+ *   current location matches any localized variant of that route.
+ *
+ * @example
+ * ```tsx
+ * <Link to="/talks/$slug" params={{ slug: talk.slug }} hash="abstract" />
+ * <Link to="/platform" />            // -> /cs/platforma under cs
+ * <Link to="/#work-with-me" />       // cross-page hash, SPA navigation
+ * <Link to="https://ai.bleeding.dev" /> // external -> plain <a>
+ * ```
+ */
+export declare const Link: <TTo extends string = string>(props: LinkProps<TTo>) => React.ReactElement;
+export default Link;

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

@@ -0,0 +1,60 @@
+/**
+ * Canonical (language-agnostic) route map.
+ *
+ * Empty by default; populated via declaration merging by the generated
+ * `register.gen.d.ts` that `@modern-js/plugin-tanstack` emits:
+ *
+ * ```ts
+ * declare module '@modern-js/plugin-i18n/runtime' {
+ *   interface UltramodernCanonicalRoutes {
+ *     '/': Record<string, never>;
+ *     '/talks': Record<string, never>;
+ *     '/talks/$slug': { slug: string };
+ *   }
+ * }
+ * ```
+ *
+ * Keys are canonical route patterns in TanStack notation (`$param`,
+ * `{-$param}`); values describe the route's path params.
+ */
+export interface UltramodernCanonicalRoutes {
+}
+export type CanonicalRoutePath = keyof UltramodernCanonicalRoutes & string;
+type HasCanonicalRoutes = [keyof UltramodernCanonicalRoutes] extends [never] ? false : true;
+/**
+ * Targets that bypass canonical-route validation: external URLs, same-page
+ * hash anchors, and canonical paths with a `?search` and/or `#hash` suffix
+ * (the pathname part of suffixed targets is still validated).
+ */
+type ExternalLinkTarget = `http://${string}` | `https://${string}` | `mailto:${string}` | `tel:${string}` | `//${string}`;
+type SuffixedCanonicalTarget = `${CanonicalRoutePath}?${string}` | `${CanonicalRoutePath}#${string}`;
+export type AllowedLinkTarget = CanonicalRoutePath | SuffixedCanonicalTarget | ExternalLinkTarget | `#${string}`;
+/**
+ * Validates a literal `to` against the canonical route map. Computed strings
+ * (type `string`) always pass — the escape hatch for dynamic values. When no
+ * canonical map has been generated, everything passes.
+ */
+export type ValidateLinkTo<TTo extends string> = HasCanonicalRoutes extends false ? unknown : string extends TTo ? unknown : TTo extends AllowedLinkTarget ? unknown : {
+    to: {
+        error: 'Not a canonical route. Authors must write language-agnostic paths; see UltramodernCanonicalRoutes.';
+        received: TTo;
+    };
+};
+/** Strip `?search`/`#hash` suffixes from a link target type. */
+export type LinkTargetPathname<TTo extends string> = TTo extends `${infer TPath}#${string}` ? TPath extends `${infer TPure}?${string}` ? TPure : TPath : TTo extends `${infer TPath}?${string}` ? TPath : TTo;
+/**
+ * `params` prop contract for a canonical target: required when the route has
+ * required params, optional when all params are optional, forbidden when the
+ * route has none. Non-canonical (computed/external) targets accept a loose
+ * record.
+ */
+export type LinkParamsProp<TPath extends string> = TPath extends CanonicalRoutePath ? UltramodernCanonicalRoutes[TPath] extends Record<string, never> ? {
+    params?: undefined;
+} : Record<string, never> extends UltramodernCanonicalRoutes[TPath] ? {
+    params?: UltramodernCanonicalRoutes[TPath];
+} : {
+    params: UltramodernCanonicalRoutes[TPath];
+} : {
+    params?: Record<string, string | number | undefined>;
+};
+export {};

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/defaults.node.d.ts

@@ -1,6 +1,7 @@
+export declare const resolveDefaultLocalesDir: (cwd?: string) => string;
 export declare const DEFAULT_I18NEXT_BACKEND_OPTIONS: {
-    loadPath: string;
-    addPath: string;
+    readonly loadPath: string;
+    readonly addPath: string;
 };
 export declare function convertBackendOptions<T extends {
     loadPath?: string;

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,9 +12,14 @@ export interface I18nPluginOptions {
     changeLanguage?: (lang: string) => void;
     initOptions?: I18nInitOptions;
     htmlLangAttr?: boolean;
+    reactI18next?: boolean;
     [key: string]: any;
 }
 export declare const i18nPlugin: (options: I18nPluginOptions) => RuntimePlugin;
+export type { AllowedLinkTarget, CanonicalRoutePath, UltramodernCanonicalRoutes, } from './canonicalRoutes';
 export { useModernI18n } from './context';
-export { I18nLink } from './I18nLink';
+export { I18nLink, type I18nLinkProps } from './I18nLink';
+export { Link, type LinkActiveOptions, type LinkBaseProps, type LinkParams, type LinkProps, } from './Link';
+export { canonicalPath, type LocalizedPathsConfig, localizePath, type UseLocalizedLocationReturn, type UseLocalizedPathsReturn, useLocalizedLocation, useLocalizedPaths, } from './localizedPaths';
+export { buildLocalizedUrl, splitUrlTarget } from './utils';
 export default i18nPlugin;

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

@@ -0,0 +1,39 @@
+import type { LocalisedUrlsOption } from '../shared/localisedUrls';
+export interface LocalizedPathsConfig {
+    languages: string[];
+    localisedUrls?: LocalisedUrlsOption;
+}
+/**
+ * Localize a canonical, language-agnostic target for the given language:
+ * adds the language prefix and applies `localisedUrls` pattern mapping.
+ * `?search`/`#hash` suffixes are preserved verbatim.
+ */
+export declare const localizePath: (pathname: string, language: string, config: LocalizedPathsConfig) => string;
+/**
+ * Reverse of {@link localizePath}: strip the language prefix and map localized
+ * slugs back to the canonical pattern's path. `?search`/`#hash` suffixes are
+ * preserved verbatim.
+ */
+export declare const canonicalPath: (target: string, config: LocalizedPathsConfig) => string;
+export interface UseLocalizedPathsReturn {
+    localizePath: (pathname: string, language: string) => string;
+    canonicalPath: (pathname: string) => string;
+}
+/**
+ * Context-bound versions of {@link localizePath} and {@link canonicalPath} —
+ * the plugin configuration (languages, localisedUrls) is read from the i18n
+ * provider, so apps never copy pattern-matching helpers again.
+ */
+export declare const useLocalizedPaths: () => UseLocalizedPathsReturn;
+export interface UseLocalizedLocationReturn {
+    language: string;
+    /** Canonical (language-agnostic) path of the current location. */
+    canonical: string;
+    /** Per-language hrefs for the current location, search+hash preserved. */
+    alternates: Record<string, string>;
+}
+/**
+ * Per-language hrefs for the current location — for hreflang `<link>` tags and
+ * language switchers. SSR-safe: the location comes from the router adapter.
+ */
+export declare const useLocalizedLocation: () => UseLocalizedLocationReturn;

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 { LocalisedUrlsOption } from '../shared/localisedUrls';
 export declare const getPathname: (context: TInternalRuntimeContext) => string;
 export declare const getEntryPath: () => string;
 /**
@@ -9,14 +10,23 @@ 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 pathname - The current pathname
+ * @param target - The language-agnostic target; may include `?search` and `#hash`
  * @param language - The target language
  * @param languages - Array of supported languages
- * @returns The localized URL path
+ * @returns The localized URL path with search and hash re-appended verbatim
  */
-export declare const buildLocalizedUrl: (pathname: string, language: string, languages: string[]) => string;
+export declare const buildLocalizedUrl: (target: string, language: string, languages: string[], localisedUrls?: LocalisedUrlsOption) => string;
 export declare const detectLanguageFromPath: (pathname: string, languages: string[], localePathRedirect: boolean) => {
     detected: boolean;
     language?: string;
@@ -25,9 +35,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,36 @@
+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;
+/**
+ * Normalise a concrete request pathname: slash cleanup only. Unlike
+ * {@link normalisePathPattern} it must not rewrite literal `[x]` segments to
+ * `:x` params — pathnames are values, not patterns.
+ */
+export declare const normalisePathname: (pathname: string) => string;
+/**
+ * Localised URLs are strictly opt-in: only an explicit, non-empty map enables
+ * route expansion and validation. `true`, `false`, an empty map and absence
+ * all resolve to disabled, so upstream-style configs (`localePathRedirect` +
+ * `languages` without a map) keep plain locale-prefix behavior instead of
+ * failing the build for every route missing from a map they never wrote.
+ */
+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 matchPathPattern: (pathname: string, pattern: string) => Record<string, string> | null;
+export declare const buildPathFromPattern: (pattern: string, params: Record<string, string>) => string;
+export declare const resolveLocalisedPath: (pathname: string, targetLanguage: string, languages: string[], localisedUrls: LocalisedUrlsMap) => string;
+/**
+ * Reverse-map a language-specific pathname (without language prefix) back to
+ * the canonical, language-agnostic path: localized slug patterns are matched
+ * against every language variant and rebuilt from the canonical map key.
+ */
+export declare const resolveCanonicalLocalisedPath: (pathname: string, languages: string[], localisedUrls: LocalisedUrlsMap) => string;
+export declare const localiseTargetPathname: (pathname: string, language: string, languages: string[], localisedUrls?: LocalisedUrlsOption) => string;
+export declare const canonicalTargetPathname: (pathname: string, languages: string[], localisedUrls?: LocalisedUrlsOption) => 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,19 @@ export interface BaseLocaleDetectionOptions {
     fallbackLanguage?: string;
     detection?: LanguageDetectorOptions;
     ignoreRedirectRoutes?: string[] | ((pathname: string) => boolean);
+    /**
+     * Enables localised pathnames in addition to the locale prefix.
+     *
+     * - non-empty object: map canonical route paths to every configured
+     *   language; route generation then validates that every localisable route
+     *   path has entries for all configured languages.
+     * - absent / `false` / `true` / empty object: keep only locale-prefix
+     *   behavior (`/en/about`).
+     *
+     * Strictly opt-in: without a map, `localePathRedirect` + `languages` behave
+     * exactly like upstream Modern.js.
+     */
+    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.12",
+  "version": "3.2.0-ultramodern.121",
   "engines": {
     "node": ">=20"
   },
@@ -81,25 +81,25 @@
     }
   },
   "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.12",
-    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.2.0-ultramodern.12",
-    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.2.0-ultramodern.12",
-    "@modern-js/server-runtime": "npm:@bleedingdev/modern-js-server-runtime@3.2.0-ultramodern.12",
-    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.2.0-ultramodern.12",
-    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.2.0-ultramodern.12"
+    "i18next-http-middleware": "^3.9.7",
+    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.2.0-ultramodern.121",
+    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.2.0-ultramodern.121",
+    "@modern-js/server-runtime": "npm:@bleedingdev/modern-js-server-runtime@3.2.0-ultramodern.121",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.2.0-ultramodern.121",
+    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.2.0-ultramodern.121",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.2.0-ultramodern.121"
   },
   "peerDependencies": {
-    "@modern-js/runtime": "3.2.0-ultramodern.12",
+    "@modern-js/runtime": "3.2.0-ultramodern.121",
     "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",
+    "react-i18next": "^17.0.0"
   },
   "peerDependenciesMeta": {
     "i18next": {
@@ -110,18 +110,18 @@
     }
   },
   "devDependencies": {
-    "@rslib/core": "0.21.5",
+    "@rslib/core": "0.22.0",
     "@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.3",
+    "@typescript/native-preview": "7.0.0-dev.20260610.1",
+    "i18next": "26.3.1",
     "jest": "^30.4.2",
-    "react": "^19.2.6",
-    "react-dom": "^19.2.6",
+    "react": "^19.2.7",
+    "react-dom": "^19.2.7",
     "react-i18next": "17.0.8",
-    "ts-jest": "^29.4.9",
-    "@modern-js/app-tools": "npm:@bleedingdev/modern-js-app-tools@3.2.0-ultramodern.12",
-    "@modern-js/runtime": "npm:@bleedingdev/modern-js-runtime@3.2.0-ultramodern.12"
+    "ts-jest": "^29.4.11",
+    "@modern-js/app-tools": "npm:@bleedingdev/modern-js-app-tools@3.2.0-ultramodern.121",
+    "@modern-js/runtime": "npm:@bleedingdev/modern-js-runtime@3.2.0-ultramodern.121"
   },
   "sideEffects": false,
   "publishConfig": {
@@ -130,7 +130,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,44 @@
+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/i18nUtils.test.ts',
+        'tests/localisedUrls.test.ts',
+        'tests/linkTypes.test.ts',
+        'tests/backendDefaults.test.ts',
+      ],
+      extends: commonConfig,
+    }),
+    withTestPreset({
+      name: 'plugin-i18n-client',
+      testEnvironment: 'happy-dom',
+      include: ['tests/routerAdapter.test.tsx', 'tests/link.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();