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

package/README.md

@@ -2,20 +2,236 @@
   <a href="https://modernjs.dev" target="blank"><img src="https://lf3-static.bytednsdoc.com/obj/eden-cn/ylaelkeh7nuhfnuhf/modernjs-cover.png" width="300" alt="Modern.js Logo" /></a>
 </p>
 
-<h1 align="center">Modern.js</h1>
+<h1 align="center">@modern-js/plugin-i18n</h1>
 
 <p align="center">
-  A Progressive React Framework for modern web development.
+  Internationalization plugin for Modern.js, providing multi-language support with locale-aware routing and navigation.
 </p>
 
+## Features
+
+- **Locale detection**: Supports detection from URL path, Cookie, LocalStorage, request headers, browser settings, and other sources.
+- **Resource loading**: Supports HTTP static files, file system loading for SSR, custom SDK functions, and chained backend progressive loading.
+- **Routing integration**: Automatically adds locale path prefixes and provides the `Link` component for language-agnostic navigation.
+- **SSR support**: Detects the language on the server and injects it into the page to avoid language flicker.
+- **TypeScript support**: Provides complete type definitions and type-safe route navigation.
+
 ## Getting Started
 
-Please follow [Quick Start](https://modernjs.dev/en/guides/get-started/quick-start) to get started with Modern.js.
+For full documentation, see the [Modern.js Internationalization Guide](https://modernjs.dev/en/guides/advanced-features/international/).
+
+## Link Component
+
+The `Link` component is the standard way to create navigation links in i18n-enabled applications. It automatically localizes language-agnostic canonical paths and provides type-safe navigation with params validation.
+
+### Basic Usage
+
+```tsx
+import { Link } from '@modern-js/plugin-i18n/runtime';
+
+function Navigation() {
+  return (
+    <nav>
+      <Link to="/">Home</Link>
+      <Link to="/about">About</Link>
+      <Link to="/talks/$slug" params={{ slug: 'my-talk' }} />
+      <Link to="/#work-with-me" />
+    </nav>
+  );
+}
+```
+
+### Key Features
+
+**Canonical path localization**: `to` accepts language-agnostic canonical paths. The Link automatically adds the locale prefix and applies `localisedUrls` slug mappings:
+
+```tsx
+// When current language is 'cs' and localisedUrls maps '/platform' to '/platforma':
+<Link to="/platform" />
+// renders as: <a href="/cs/platforma">...</a>
+```
+
+**Hash and query preservation**: Hash fragments and query strings in `to` are preserved during localization:
+
+```tsx
+<Link to="/#work-with-me" />  // Cross-page anchor → /cs#work-with-me
+<Link to="/talks?sort=date" /> // Search params preserved
+```
+
+**Typed routes and params**: When used with TanStack Router codegen, `to` accepts typed canonical route paths with validated params:
+
+```tsx
+// Route /talks/$slug exists → TypeScript validates this:
+<Link to="/talks/$slug" params={{ slug: 'my-talk' }} />
+
+// TypeScript error: route does not exist
+<Link to="/talkz" />
+
+// TypeScript error: missing required param
+<Link to="/talks/$slug" />
+```
+
+**Language-invariant active state**: The link is marked active when the location matches any localized variant of the canonical route:
+
+```tsx
+// Matches /en/talks/my-talk, /cs/prednaska/muj-pohovor, etc.
+<Link to="/talks/$slug" params={{ slug: 'my-talk' }} activeProps={{ className: 'active' }} />
+```
+
+**Active state props and classes**:
+
+```tsx
+<Link
+  to="/about"
+  activeProps={{ className: 'active-link' }}
+  activeOptions={{ exact: false }} // Nested routes also match
+/>
+// When active, renders: <a href="..." className="active-link" data-status="active" aria-current="page">
+```
+
+**External URLs and bare anchors render as plain `<a>` tags**:
+
+```tsx
+<Link to="https://example.com" /> // → <a href="https://example.com">
+<Link to="#contact" />           // → <a href="#contact">
+```
+
+### Props
+
+- `to` (string): Canonical (language-agnostic) target path, optionally with `#hash` and `?query` suffixes.
+- `params` (object, optional): Route param values for dynamic segments (e.g., `$slug`).
+- `hash` (string, optional): Hash fragment (overrides any `#hash` in `to`).
+- `search` (string | object, optional): Query string or object (overrides any `?query` in `to`).
+- `hashScrollIntoView` (boolean | ScrollIntoViewOptions, optional): TanStack Router scroll behavior.
+- `activeProps` (object, optional): Props applied when the link is active.
+- `activeOptions` (object, optional): `{ exact?: boolean }` for active state matching.
+- All standard `<a>` HTML attributes (className, style, onClick, etc.).
+
+## Localization Utilities
+
+### `localizePath(pathname, language, config)`
+
+Localize a canonical pathname for a given language, applying language prefix and `localisedUrls` mapping:
+
+```tsx
+import { localizePath } from '@modern-js/plugin-i18n/runtime';
+
+localizePath('/about', 'cs', {
+  languages: ['en', 'cs'],
+  localisedUrls: { '/about': { en: '/about', cs: '/o-nas' } }
+})
+// → '/cs/o-nas'
+```
+
+### `canonicalPath(target, config)`
+
+Reverse of `localizePath`: strip language prefix and reverse `localisedUrls` mapping:
+
+```tsx
+import { canonicalPath } from '@modern-js/plugin-i18n/runtime';
+
+canonicalPath('/cs/o-nas', {
+  languages: ['en', 'cs'],
+  localisedUrls: { '/about': { en: '/about', cs: '/o-nas' } }
+})
+// → '/about'
+```
+
+### `useLocalizedPaths()`
+
+Hook for context-bound `localizePath` and `canonicalPath` (reads plugin config automatically):
+
+```tsx
+import { useLocalizedPaths } from '@modern-js/plugin-i18n/runtime';
+
+function MyComponent() {
+  const { localizePath, canonicalPath } = useLocalizedPaths();
+  
+  const localized = localizePath('/about', 'cs');
+  const canonical = canonicalPath('/cs/o-nas');
+}
+```
+
+### `useLocalizedLocation()`
+
+Hook for hreflang tags and language switchers. Returns the current location's canonical path and per-language hrefs:
+
+```tsx
+import { useLocalizedLocation } from '@modern-js/plugin-i18n/runtime';
+
+function HrefLang() {
+  const { language, canonical, alternates } = useLocalizedLocation();
+  
+  return (
+    <>
+      <link rel="canonical" href={alternates['en']} />
+      {Object.entries(alternates).map(([lang, href]) => (
+        <link key={lang} rel="alternate" hrefLang={lang} href={href} />
+      ))}
+    </>
+  );
+}
+
+function LanguageSwitcher() {
+  const { alternates } = useLocalizedLocation();
+  
+  return (
+    <select onChange={(e) => window.location.href = alternates[e.target.value]}>
+      {Object.entries(alternates).map(([lang, href]) => (
+        <option key={lang} value={lang}>{lang}</option>
+      ))}
+    </select>
+  );
+}
+```
+
+## Migration from Deprecated I18nLink
+
+The deprecated `I18nLink` component is now an alias for `Link`. Update your code:
+
+| Old Pattern | New Pattern | Notes |
+|-------------|-------------|-------|
+| `import { I18nLink }` | `import { Link }` | Drop the `I18n` prefix. |
+| `<I18nLink to="/">` | `<Link to="/">` | Identical props and behavior. |
+| Hand-rolled `localizePath` helper | `useLocalizedPaths()` hook | Reads config from context automatically. |
+| Hand-rolled `matchPattern` for active state | `Link` with `activeProps`/`activeOptions` | Language-invariant matching. |
+| Manual hreflang blocks | `useLocalizedLocation()` hook | Generates per-language hrefs automatically. |
+
+**I18nLink deprecation notice:** `I18nLink` is deprecated and will be removed in a future version. A one-time development console warning is logged when used.
+
+```tsx
+// ❌ Old
+import { I18nLink } from '@modern-js/plugin-i18n/runtime';
+<I18nLink to="/about">About</I18nLink>
+
+// ✅ New
+import { Link } from '@modern-js/plugin-i18n/runtime';
+<Link to="/about">About</Link>
+```
+
+## Exported Types
+
+For TypeScript projects, the following types are exported from `@modern-js/plugin-i18n/runtime`:
+
+- `LinkProps<TTo>`: Props type for the `Link` component with typed `to` and `params`.
+- `LinkBaseProps`: Base props shared across router frameworks.
+- `LinkParams`: Record of route param values.
+- `LinkActiveOptions`: Active state matching options.
+- `UltramodernCanonicalRoutes`: Canonical route map (emitted by TanStack Router codegen).
+- `CanonicalRoutePath`: Typed canonical route path.
+- `AllowedLinkTarget`: Union of all valid canonical routes (when codegen is active).
+
+## Exported Utilities
+
+- `buildLocalizedUrl(pathname, language, languages, localisedUrls)`: Localize a pathname (used internally by `Link`).
+- `splitUrlTarget(urlString)`: Parse a URL into pathname, search, and hash.
 
 ## Documentation
 
-- [English Documentation](https://modernjs.dev/en/)
-- [中文文档](https://modernjs.dev)
+For complete documentation, including locale detection, resource loading, SSR, and custom route configuration, see:
+
+- [English Documentation](https://modernjs.dev/en/guides/advanced-features/international/)
+- [中文文档](https://modernjs.dev/guides/advanced-features/international/)
 
 ## Contributing
 
@@ -24,9 +240,3 @@ Please read the [Contributing Guide](https://github.com/web-infra-dev/modern.js/
 ## License
 
 Modern.js is [MIT licensed](https://github.com/web-infra-dev/modern.js/blob/main/LICENSE).
-
-## Credist
-
-Thanks to:
-
-- [@loadable/webpack-plugin](https://github.com/gregberge/loadable-components) to create a webpack plugin prepare for loadable usage in ssr.

package/dist/cjs/cli/index.js

@@ -1,20 +1,15 @@
 "use strict";
 var __webpack_require__ = {};
 (()=>{
-    __webpack_require__.n = (module)=>{
-        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
-        __webpack_require__.d(getter, {
-            a: getter
-        });
-        return getter;
-    };
-})();
-(()=>{
-    __webpack_require__.d = (exports1, definition)=>{
-        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-            enumerable: true,
-            get: definition[key]
-        });
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
     };
 })();
 (()=>{
@@ -37,42 +32,10 @@ __webpack_require__.d(__webpack_exports__, {
     i18nPlugin: ()=>i18nPlugin
 });
 const server_core_namespaceObject = require("@modern-js/server-core");
-const external_fs_namespaceObject = require("fs");
-var external_fs_default = /*#__PURE__*/ __webpack_require__.n(external_fs_namespaceObject);
-const external_path_namespaceObject = require("path");
-var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
 const localisedUrls_js_namespaceObject = require("../shared/localisedUrls.js");
 const utils_js_namespaceObject = require("../shared/utils.js");
-function hasJsonFiles(dirPath) {
-    try {
-        if (!external_fs_default().existsSync(dirPath) || !external_fs_default().statSync(dirPath).isDirectory()) return false;
-        const entries = external_fs_default().readdirSync(dirPath);
-        for (const entry of entries){
-            const entryPath = external_path_default().join(dirPath, entry);
-            const stat = external_fs_default().statSync(entryPath);
-            if (stat.isFile() && entry.endsWith('.json')) return true;
-            if (stat.isDirectory()) {
-                if (hasJsonFiles(entryPath)) return true;
-            }
-        }
-        return false;
-    } catch  {
-        return false;
-    }
-}
-function detectLocalesDirectory(appDirectory, normalizedConfig) {
-    const rootLocalesPath = external_path_default().join(appDirectory, 'locales');
-    if (hasJsonFiles(rootLocalesPath)) return true;
-    const configPublicPath = external_path_default().join(appDirectory, 'config', 'public', 'locales');
-    if (hasJsonFiles(configPublicPath)) return true;
-    const publicDir = normalizedConfig?.server?.publicDir;
-    if (publicDir) {
-        const publicDirPath = Array.isArray(publicDir) ? publicDir[0] : publicDir;
-        const localesPath = external_path_default().isAbsolute(publicDirPath) ? external_path_default().join(publicDirPath, 'locales') : external_path_default().join(appDirectory, publicDirPath, 'locales');
-        if (hasJsonFiles(localesPath)) return true;
-    }
-    return false;
-}
+const external_locales_js_namespaceObject = require("./locales.js");
+require("../runtime/types.js");
 const i18nPlugin = (options = {})=>({
         name: '@modern-js/plugin-i18n',
         setup: (api)=>{
@@ -82,26 +45,16 @@ const i18nPlugin = (options = {})=>({
                 let backendOptions;
                 const { appDirectory } = api.getAppContext();
                 const normalizedConfig = api.getNormalizedConfig();
+                const detectedLocales = (0, external_locales_js_namespaceObject.detectLocalesDirectory)(appDirectory, normalizedConfig);
                 if (backend) {
                     const entryBackendOptions = (0, utils_js_namespaceObject.getBackendOptions)(entrypoint.entryName, backend);
-                    if (entryBackendOptions?.enabled === false) backendOptions = entryBackendOptions;
-                    else if (entryBackendOptions?.loadPath || entryBackendOptions?.addPath) backendOptions = {
+                    backendOptions = entryBackendOptions?.enabled === false ? entryBackendOptions : detectedLocales ? (0, external_locales_js_namespaceObject.applyDetectedBackendPaths)(entryBackendOptions, detectedLocales) : entryBackendOptions?.loadPath || entryBackendOptions?.addPath ? {
                         ...entryBackendOptions,
                         enabled: true
-                    };
-                    else if (entryBackendOptions?.enabled !== true) {
-                        const hasLocales = detectLocalesDirectory(appDirectory, normalizedConfig);
-                        backendOptions = hasLocales ? {
-                            ...entryBackendOptions,
-                            enabled: true
-                        } : entryBackendOptions;
-                    } else backendOptions = entryBackendOptions;
-                } else {
-                    const hasLocales = detectLocalesDirectory(appDirectory, normalizedConfig);
-                    if (hasLocales) backendOptions = (0, utils_js_namespaceObject.getBackendOptions)(entrypoint.entryName, {
-                        enabled: true
-                    });
-                }
+                    } : entryBackendOptions;
+                } else if (detectedLocales) backendOptions = (0, external_locales_js_namespaceObject.applyDetectedBackendPaths)((0, utils_js_namespaceObject.getBackendOptions)(entrypoint.entryName, {
+                    enabled: true
+                }), detectedLocales);
                 const { metaName } = api.getAppContext();
                 let extendedConfig = restOptions;
                 if (transformRuntimeConfig) extendedConfig = transformRuntimeConfig(restOptions, entrypoint);

package/dist/cjs/cli/locales.js

@@ -0,0 +1,132 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    applyDetectedBackendPaths: ()=>applyDetectedBackendPaths,
+    detectLocalesDirectory: ()=>detectLocalesDirectory
+});
+const server_core_namespaceObject = require("@modern-js/server-core");
+const external_fs_namespaceObject = require("fs");
+var external_fs_default = /*#__PURE__*/ __webpack_require__.n(external_fs_namespaceObject);
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const LOCALES_RESOURCE_PATTERN = '{{lng}}/{{ns}}.json';
+function hasJsonFiles(dirPath) {
+    try {
+        if (!external_fs_default().existsSync(dirPath) || !external_fs_default().statSync(dirPath).isDirectory()) return false;
+        const entries = external_fs_default().readdirSync(dirPath);
+        for (const entry of entries){
+            const entryPath = external_path_default().join(dirPath, entry);
+            const stat = external_fs_default().statSync(entryPath);
+            if (stat.isFile() && entry.endsWith('.json')) return true;
+            if (stat.isDirectory() && hasJsonFiles(entryPath)) return true;
+        }
+        return false;
+    } catch  {
+        return false;
+    }
+}
+function toPosixPath(filePath) {
+    return filePath.split(external_path_default().sep).join(external_path_default().posix.sep);
+}
+function getPublicDirOutputPath(publicDir) {
+    return (0, server_core_namespaceObject.normalizePublicDirPath)(publicDir);
+}
+function buildDetectedLocalesDirectory(clientBasePath, serverBasePath, serverBasePathCandidates = [
+    serverBasePath
+]) {
+    const normalizedClientBasePath = clientBasePath.startsWith('/') ? clientBasePath : `/${clientBasePath}`;
+    const normalizedServerBasePath = toPosixPath(serverBasePath).replace(/\/$/, '');
+    const normalizedServerBasePathCandidates = Array.from(new Set(serverBasePathCandidates.map((candidate)=>toPosixPath(candidate).replace(/\/$/, ''))));
+    const serverLoadPaths = normalizedServerBasePathCandidates.map((candidate)=>`${candidate}/${LOCALES_RESOURCE_PATTERN}`);
+    const serverAddPaths = normalizedServerBasePathCandidates.map((candidate)=>`${candidate}/${LOCALES_RESOURCE_PATTERN}`);
+    return {
+        loadPath: `${normalizedClientBasePath}/${LOCALES_RESOURCE_PATTERN}`,
+        addPath: `${normalizedClientBasePath}/${LOCALES_RESOURCE_PATTERN}`,
+        serverLoadPath: `${normalizedServerBasePath}/${LOCALES_RESOURCE_PATTERN}`,
+        serverAddPath: `${normalizedServerBasePath}/${LOCALES_RESOURCE_PATTERN}`,
+        serverLoadPaths,
+        serverAddPaths
+    };
+}
+function detectLocalesDirectory(appDirectory, normalizedConfig) {
+    const publicDirs = (0, server_core_namespaceObject.normalizePublicDir)(normalizedConfig?.server?.publicDir);
+    const publicDirPrefixes = (0, server_core_namespaceObject.getPublicDirRoutePrefixes)(normalizedConfig?.server?.publicDir);
+    for(let index = 0; index < publicDirs.length; index++){
+        const publicDir = publicDirs[index];
+        if (external_path_default().isAbsolute(publicDir)) continue;
+        const publicDirPath = external_path_default().join(appDirectory, publicDir);
+        const publicDirPrefix = publicDirPrefixes[index] || `/${(0, server_core_namespaceObject.normalizePublicDirPath)(publicDir)}`;
+        const publicDirOutputPath = getPublicDirOutputPath(publicDir);
+        if ('locales' === external_path_default().basename((0, server_core_namespaceObject.normalizePublicDirPath)(publicDir)) && hasJsonFiles(publicDirPath)) return buildDetectedLocalesDirectory(publicDirPrefix, `./${publicDirOutputPath}`);
+        const localesPath = external_path_default().join(publicDirPath, 'locales');
+        if (hasJsonFiles(localesPath)) return buildDetectedLocalesDirectory(`${publicDirPrefix}/locales`, `./${publicDirOutputPath}/locales`);
+    }
+    const configPublicPath = external_path_default().join(appDirectory, 'config', 'public', 'locales');
+    if (hasJsonFiles(configPublicPath)) return buildDetectedLocalesDirectory('/locales', './public/locales', [
+        './config/public/locales',
+        './public/locales'
+    ]);
+    const rootLocalesPath = external_path_default().join(appDirectory, 'locales');
+    if (hasJsonFiles(rootLocalesPath)) return buildDetectedLocalesDirectory('/locales', './locales');
+}
+function applyDetectedBackendPaths(backendOptions, detectedLocales) {
+    if (!detectedLocales) return backendOptions;
+    const backendWithDetectedPaths = {
+        ...backendOptions,
+        enabled: true,
+        loadPath: backendOptions.loadPath ?? detectedLocales.loadPath,
+        addPath: backendOptions.addPath ?? detectedLocales.addPath,
+        serverLoadPath: backendOptions.serverLoadPath ?? detectedLocales.serverLoadPath,
+        serverLoadPaths: backendOptions.serverLoadPath || backendOptions.serverLoadPaths ? backendOptions.serverLoadPaths : detectedLocales.serverLoadPaths,
+        serverAddPath: backendOptions.serverAddPath ?? detectedLocales.serverAddPath,
+        serverAddPaths: backendOptions.serverAddPath || backendOptions.serverAddPaths ? backendOptions.serverAddPaths : detectedLocales.serverAddPaths,
+        _detectedLoadPath: detectedLocales.loadPath,
+        _detectedAddPath: detectedLocales.addPath
+    };
+    return backendWithDetectedPaths;
+}
+exports.applyDetectedBackendPaths = __webpack_exports__.applyDetectedBackendPaths;
+exports.detectLocalesDirectory = __webpack_exports__.detectLocalesDirectory;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "applyDetectedBackendPaths",
+    "detectLocalesDirectory"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/I18nLink.js

@@ -1,11 +1,15 @@
 "use strict";
 var __webpack_require__ = {};
 (()=>{
-    __webpack_require__.d = (exports1, definition)=>{
-        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-            enumerable: true,
-            get: definition[key]
-        });
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
     };
 })();
 (()=>{
@@ -28,22 +32,15 @@ __webpack_require__.d(__webpack_exports__, {
     default: ()=>runtime_I18nLink
 });
 const jsx_runtime_namespaceObject = require("react/jsx-runtime");
-const external_context_js_namespaceObject = require("./context.js");
-const external_routerAdapter_js_namespaceObject = require("./routerAdapter.js");
-const external_utils_js_namespaceObject = require("./utils.js");
+const external_Link_js_namespaceObject = require("./Link.js");
+let warnedDeprecation = false;
 const I18nLink = ({ to, children, ...props })=>{
-    const { Link, params, hasRouter } = (0, external_routerAdapter_js_namespaceObject.useI18nRouterAdapter)();
-    const { language, supportedLanguages, localisedUrls } = (0, external_context_js_namespaceObject.useModernI18n)();
-    const currentLang = language;
-    const localizedTo = (0, external_utils_js_namespaceObject.buildLocalizedUrl)(to, currentLang, supportedLanguages, localisedUrls);
-    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__*/ (0, jsx_runtime_namespaceObject.jsx)("a", {
-        href: localizedTo,
-        ...props,
-        children: children
-    });
-    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(Link, {
-        to: localizedTo,
+    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__*/ (0, jsx_runtime_namespaceObject.jsx)(external_Link_js_namespaceObject.Link, {
+        to: to,
         ...props,
         children: children
     });