@bleedingdev/modern-js-plugin-i18n 3.2.0-ultramodern.99 → 3.4.0-ultramodern.1

package/dist/esm-node/runtime/i18n/backend/defaults.node.mjs

@@ -1,20 +1,71 @@
 import "node:module";
+import fs from "fs";
+import path_0 from "path";
+const CONVENTIONAL_LOCALES_DIRS = [
+    './locales',
+    './config/public/locales'
+];
+const isDirectory = (dirPath)=>{
+    try {
+        return fs.statSync(dirPath).isDirectory();
+    } catch  {
+        return false;
+    }
+};
+const resolveDefaultLocalesDir = (cwd = process.cwd())=>{
+    for (const dir of CONVENTIONAL_LOCALES_DIRS)if (isDirectory(path_0.resolve(cwd, dir))) return dir;
+    return CONVENTIONAL_LOCALES_DIRS[0];
+};
 const DEFAULT_I18NEXT_BACKEND_OPTIONS = {
-    loadPath: './config/public/locales/{{lng}}/{{ns}}.json',
-    addPath: './config/public/locales/{{lng}}/{{ns}}.json'
+    get loadPath () {
+        return `${resolveDefaultLocalesDir()}/{{lng}}/{{ns}}.json`;
+    },
+    get addPath () {
+        return `${resolveDefaultLocalesDir()}/{{lng}}/{{ns}}.json`;
+    }
 };
 function convertPath(path) {
     if (!path) return path;
     if (path.startsWith('/')) return `.${path}`;
     return path;
 }
+function shouldUseServerPath(currentPath, detectedPath) {
+    return !detectedPath || currentPath === detectedPath;
+}
+function getResourceBasePath(resourcePath) {
+    const markerIndex = resourcePath.indexOf('{{lng}}');
+    if (markerIndex < 0) return resourcePath;
+    return resourcePath.slice(0, markerIndex).replace(/[\\/]+$/, '');
+}
+function pathExists(resourcePath) {
+    try {
+        return fs.existsSync(getResourceBasePath(resourcePath));
+    } catch  {
+        return false;
+    }
+}
+function getServerPath(pathCandidates, fallbackPath) {
+    const candidates = Array.from(new Set([
+        ...pathCandidates || [],
+        fallbackPath
+    ].filter(Boolean)));
+    return candidates.find(pathExists) || candidates[0];
+}
 function convertBackendOptions(options) {
     if (!options) return options;
     const converted = {
         ...options
     };
-    if (converted.loadPath) converted.loadPath = convertPath(converted.loadPath);
-    if (converted.addPath) converted.addPath = convertPath(converted.addPath);
+    if ((converted.serverLoadPath || converted.serverLoadPaths) && shouldUseServerPath(converted.loadPath, converted._detectedLoadPath)) converted.loadPath = getServerPath(converted.serverLoadPaths, converted.serverLoadPath);
+    else if (converted.loadPath) converted.loadPath = convertPath(converted.loadPath);
+    if ((converted.serverAddPath || converted.serverAddPaths) && shouldUseServerPath(converted.addPath, converted._detectedAddPath)) converted.addPath = getServerPath(converted.serverAddPaths, converted.serverAddPath);
+    else if (converted.addPath) converted.addPath = convertPath(converted.addPath);
+    delete converted.serverLoadPath;
+    delete converted.serverAddPath;
+    delete converted.serverLoadPaths;
+    delete converted.serverAddPaths;
+    delete converted._detectedLoadPath;
+    delete converted._detectedAddPath;
     return converted;
 }
-export { DEFAULT_I18NEXT_BACKEND_OPTIONS, convertBackendOptions };
+export { DEFAULT_I18NEXT_BACKEND_OPTIONS, convertBackendOptions, resolveDefaultLocalesDir };

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

@@ -13,7 +13,7 @@ import { detectLanguageWithPriority, exportServerLngToWindow, mergeDetectionOpti
 import { useI18nextLanguageDetector } from "./i18n/detection/middleware.mjs";
 import { getI18nextInstanceForProvider } from "./i18n/instance.mjs";
 import { changeI18nLanguage, ensureLanguageMatch, initializeI18nInstance, setupClonedInstance } from "./i18n/utils.mjs";
-import { getPathname } from "./utils.mjs";
+import { buildLocalizedUrl, getPathname, splitUrlTarget } from "./utils.mjs";
 import "./types.mjs";
 const i18nPlugin = (options)=>({
         name: '@modern-js/plugin-i18n',
@@ -137,5 +137,7 @@ const i18nPlugin = (options)=>({
     });
 const runtime = i18nPlugin;
 export { I18nLink } from "./I18nLink.mjs";
+export { Link } from "./Link.mjs";
+export { canonicalPath, localizePath, useLocalizedLocation, useLocalizedPaths } from "./localizedPaths.mjs";
 export default runtime;
-export { i18nPlugin, useModernI18n };
+export { buildLocalizedUrl, i18nPlugin, splitUrlTarget, useModernI18n };

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

@@ -0,0 +1,56 @@
+import "node:module";
+import { useMemo } from "react";
+import { canonicalTargetPathname } from "../shared/localisedUrls.mjs";
+import { useModernI18n } from "./context.mjs";
+import { useI18nRouterAdapter } from "./routerAdapter.mjs";
+import { buildLocalizedUrl, splitUrlTarget } from "./utils.mjs";
+const localizePath = (pathname, language, config)=>buildLocalizedUrl(pathname, language, config.languages, config.localisedUrls);
+const canonicalPath = (target, config)=>{
+    const { pathname, search, hash } = splitUrlTarget(target);
+    const resolvedPath = canonicalTargetPathname(pathname, config.languages, config.localisedUrls);
+    return `${resolvedPath}${search}${hash}`;
+};
+const useLocalizedPaths = ()=>{
+    const { supportedLanguages, localisedUrls } = useModernI18n();
+    return useMemo(()=>{
+        const config = {
+            languages: supportedLanguages,
+            localisedUrls
+        };
+        return {
+            localizePath: (pathname, language)=>localizePath(pathname, language, config),
+            canonicalPath: (pathname)=>canonicalPath(pathname, config)
+        };
+    }, [
+        supportedLanguages,
+        localisedUrls
+    ]);
+};
+const useLocalizedLocation = ()=>{
+    const { language, supportedLanguages, localisedUrls } = useModernI18n();
+    const { location } = useI18nRouterAdapter();
+    const pathname = location?.pathname ?? '/';
+    const search = location?.search ?? '';
+    const hash = location?.hash ?? '';
+    return useMemo(()=>{
+        const config = {
+            languages: supportedLanguages,
+            localisedUrls
+        };
+        const alternates = {};
+        for (const supportedLanguage of supportedLanguages)alternates[supportedLanguage] = `${localizePath(pathname, supportedLanguage, config)}${search}${hash}`;
+        return {
+            language,
+            canonical: canonicalPath(pathname, config),
+            alternates
+        };
+    }, [
+        language,
+        supportedLanguages,
+        localisedUrls,
+        pathname,
+        search,
+        hash
+    ]);
+};
+export { canonicalPath, localizePath, useLocalizedLocation, useLocalizedPaths };

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

@@ -1,6 +1,6 @@
 import "node:module";
 import { RuntimeContext, isBrowser } from "@modern-js/runtime";
-import { InternalRuntimeContext } from "@modern-js/runtime/context";
+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)=>{
@@ -26,7 +26,7 @@ const getWindowLocation = ()=>{
     };
 };
 const getRouterFramework = (runtimeContext, internalContext, inReactRouter)=>{
-    const framework = internalContext.routerFramework || internalContext.routerRuntime?.framework || runtimeContext.routerFramework;
+    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';
@@ -34,7 +34,7 @@ const getRouterFramework = (runtimeContext, internalContext, inReactRouter)=>{
 };
 const getRouterInstance = (internalContext, contextRouter)=>{
     if (contextRouter) return contextRouter;
-    const router = internalContext.routerInstance || internalContext.routerRuntime?.instance;
+    const router = getRouterRuntimeState(internalContext)?.instance;
     if (!router || 'object' != typeof router) return null;
     return router;
 };

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

@@ -1,7 +1,7 @@
 import "node:module";
 import { isBrowser } from "@modern-js/runtime";
 import { getGlobalBasename } from "@modern-js/runtime/context";
-import { resolveLocalisedPath, resolveLocalisedUrlsConfig } from "../shared/localisedUrls.mjs";
+import { localiseTargetPathname } from "../shared/localisedUrls.mjs";
 const getPathname = (context)=>{
     if (isBrowser()) return window.location.pathname;
     return context.ssrContext?.request?.pathname || '/';
@@ -17,16 +17,23 @@ const getLanguageFromPath = (pathname, languages, fallbackLanguage)=>{
     if (languages.includes(firstSegment)) return firstSegment;
     return fallbackLanguage;
 };
-const buildLocalizedUrl = (pathname, language, languages, localisedUrls)=>{
-    const segments = pathname.split('/').filter(Boolean);
-    const localisedUrlsConfig = resolveLocalisedUrlsConfig(localisedUrls);
-    const pathWithoutLanguage = segments.length > 0 && languages.includes(segments[0]) ? `/${segments.slice(1).join('/')}` : pathname;
-    const resolvedPath = localisedUrlsConfig.enabled ? resolveLocalisedPath(pathWithoutLanguage, language, languages, localisedUrlsConfig.map) : pathWithoutLanguage;
-    const resolvedSegments = resolvedPath.split('/').filter(Boolean);
-    return `/${[
-        language,
-        ...resolvedSegments
-    ].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,4 +61,4 @@ const shouldIgnoreRedirect = (pathname, languages, ignoreRedirectRoutes)=>{
     if ('function' == typeof ignoreRedirectRoutes) return ignoreRedirectRoutes(normalizedPath);
     return ignoreRedirectRoutes.some((pattern)=>normalizedPath === pattern || normalizedPath.startsWith(`${pattern}/`));
 };
-export { buildLocalizedUrl, detectLanguageFromPath, getEntryPath, getLanguageFromPath, getPathname, shouldIgnoreRedirect };
+export { buildLocalizedUrl, detectLanguageFromPath, getEntryPath, getLanguageFromPath, getPathname, shouldIgnoreRedirect, splitUrlTarget };

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

@@ -1,6 +1,6 @@
 import "node:module";
 import { DEFAULT_I18NEXT_DETECTION_OPTIONS, mergeDetectionOptions } from "../runtime/i18n/detection/config.mjs";
-import { resolveLocalisedPath, resolveLocalisedUrlsConfig } from "../shared/localisedUrls.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;
@@ -128,15 +128,7 @@ const buildLocalizedUrl = (req, urlPath, language, languages, localisedUrls)=>{
     const pathname = url.pathname;
     const basePath = urlPath.replace('/*', '');
     const remainingPath = pathname.startsWith(basePath) ? pathname.slice(basePath.length) : pathname;
-    const segments = remainingPath.split('/').filter(Boolean);
-    const localisedUrlsConfig = resolveLocalisedUrlsConfig(localisedUrls);
-    const pathWithoutLanguage = segments.length > 0 && languages.includes(segments[0]) ? `/${segments.slice(1).join('/')}` : remainingPath;
-    const resolvedPath = localisedUrlsConfig.enabled ? resolveLocalisedPath(pathWithoutLanguage, language, languages, localisedUrlsConfig.map) : pathWithoutLanguage;
-    const resolvedSegments = resolvedPath.split('/').filter(Boolean);
-    const newPathname = `/${[
-        language,
-        ...resolvedSegments
-    ].join('/')}`;
+    const newPathname = localiseTargetPathname(remainingPath, language, languages, localisedUrls);
     const suffix = `${url.search}${url.hash}`;
     const localizedUrl = '/' === basePath ? newPathname + suffix : basePath + newPathname + suffix;
     return localizedUrl;

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

@@ -4,12 +4,13 @@ const LOCALE_PARAM_NAMES = new Set([
     'locale',
     'language'
 ]);
-const normalisePathPattern = (path)=>{
+const normaliseSlashes = (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');
+    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);
@@ -35,16 +36,12 @@ const getLeadingLocaleParam = (path)=>{
     return getLocaleParamSegment(segments[0] || '');
 };
 const resolveLocalisedUrlsConfig = (option)=>{
-    if (false === option) return {
-        enabled: false,
-        map: {}
-    };
-    if (option && 'object' == typeof option) return {
+    if (option && 'object' == typeof option && Object.keys(option).length > 0) return {
         enabled: true,
         map: option
     };
     return {
-        enabled: true,
+        enabled: false,
         map: {}
     };
 };
@@ -101,7 +98,7 @@ const transformLocalisedRoute = (route, parentCanonicalPath, parentLocalisedPath
     if (!localisedUrlEntry) return [
         baseRoute
     ];
-    return getLocalisedRoutePaths(canonicalPath, parentLocalisedPaths, languages, localisedUrlEntry).map((localisedPath, index)=>cloneRouteWithLocalisedPath(baseRoute, localisedPath, index));
+    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)=>{
@@ -116,13 +113,14 @@ const suffixRouteIds = (route, suffix)=>{
         } : {}
     };
 };
-const cloneRouteWithLocalisedPath = (route, path, index)=>{
+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)=>{
@@ -135,9 +133,13 @@ const applyLocalisedUrlsToRoutes = (routes, 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 = normalisePathPattern(pattern).split('/').filter(Boolean);
+    const segments = normalizedPattern.split('/').filter(Boolean);
     const source = segments.map((segment)=>{
         if (segment.startsWith(':')) {
             names.push(getParamName(segment));
@@ -150,19 +152,55 @@ const compilePathPattern = (pattern)=>{
         }
         return `/${escapeRegExp(segment)}`;
     }).join('');
-    return {
+    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(normalisePathPattern(pathname));
+    const match = regexp.exec(normalisePathname(pathname));
     if (!match) return null;
-    return names.reduce((params, name, index)=>{
-        params[name] = decodeURIComponent(match[index + 1] || '');
-        return params;
-    }, {});
+    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);
@@ -177,16 +215,70 @@ const buildPathFromPattern = (pattern, params)=>{
     return `/${path}`;
 };
 const resolveLocalisedPath = (pathname, targetLanguage, languages, localisedUrls)=>{
-    const normalizedPathname = normalisePathPattern(pathname);
-    for (const localisedUrlEntry of Object.values(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) for (const language of languages){
+        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(targetPattern, params);
+            if (params) return buildPathFromPattern(canonicalPattern, params);
         }
     }
     return normalizedPathname;
 };
-export { applyLocalisedUrlsToRoutes, normalisePathPattern, resolveLocalisedPath, resolveLocalisedUrlsConfig, validateLocalisedUrls };
+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/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/cli/locales.d.ts

@@ -0,0 +1,17 @@
+import type { BackendOptions } from '../shared/type';
+interface NormalizedConfigForLocales {
+    server?: {
+        publicDir?: string | string[];
+    };
+}
+export interface DetectedLocalesDirectory {
+    loadPath: string;
+    addPath: string;
+    serverLoadPath: string;
+    serverAddPath: string;
+    serverLoadPaths?: string[];
+    serverAddPaths?: string[];
+}
+export declare function detectLocalesDirectory(appDirectory: string, normalizedConfig?: NormalizedConfigForLocales): DetectedLocalesDirectory | undefined;
+export declare function applyDetectedBackendPaths(backendOptions: BackendOptions, detectedLocales: DetectedLocalesDirectory | undefined): BackendOptions;
+export {};

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

@@ -5,19 +5,10 @@ export interface I18nLinkProps {
     [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>
- * ```
+ * @deprecated Use {@link Link} from `@modern-js/plugin-i18n/runtime` instead.
+ * `Link` accepts the same language-agnostic `to` values and additionally
+ * supports `#hash`/`?query` targets, typed canonical routes, `params`
+ * interpolation and language-invariant active state.
  */
 export declare const I18nLink: React.FC<I18nLinkProps>;
 export default I18nLink;

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 {};