@bleedingdev/modern-js-plugin-i18n 3.2.0-ultramodern.2 → 3.2.0-ultramodern.23

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

@@ -0,0 +1,29 @@
+import type { BaseBackendOptions } from '../../shared/type';
+import type { I18nInitOptions, I18nInstance } from './instance';
+export declare function assertI18nInstance(obj: any): asserts obj is I18nInstance;
+/**
+ * Build initialization options for i18n instance
+ */
+export declare const buildInitOptions: (finalLanguage: string, fallbackLanguage: string, languages: string[], mergedDetection: any, mergedBackend: any, userInitOptions?: I18nInitOptions, useSuspense?: boolean, i18nInstance?: I18nInstance) => Promise<I18nInitOptions>;
+/**
+ * Ensure i18n instance language matches the final detected language
+ */
+export declare const ensureLanguageMatch: (i18nInstance: I18nInstance, finalLanguage: string) => Promise<void>;
+/**
+ * Change language for i18n instance in onBeforeRender hook
+ * This function can be used by other runtime plugins to change language
+ * @param i18nInstance - The i18n instance
+ * @param newLang - The new language code to switch to
+ * @param options - Optional configuration
+ */
+export declare const changeI18nLanguage: (i18nInstance: I18nInstance, newLang: string, options?: {
+    detectionOptions?: any;
+}) => Promise<void>;
+/**
+ * Initialize i18n instance if not already initialized
+ */
+export declare const initializeI18nInstance: (i18nInstance: I18nInstance, finalLanguage: string, fallbackLanguage: string, languages: string[], mergedDetection: any, mergedBackend: any, userInitOptions?: I18nInitOptions, useSuspense?: boolean) => Promise<void>;
+/**
+ * Setup cloned instance for SSR with backend support
+ */
+export declare const setupClonedInstance: (i18nInstance: I18nInstance, finalLanguage: string, fallbackLanguage: string, languages: string[], backendEnabled: boolean, backend: BaseBackendOptions | undefined, i18nextDetector: boolean, detection: any, localePathRedirect: boolean, userInitOptions: I18nInitOptions | undefined) => Promise<void>;

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

@@ -0,0 +1,21 @@
+import { type RuntimePlugin } from '@modern-js/runtime';
+import type { BaseBackendOptions, BaseLocaleDetectionOptions } from '../shared/type';
+import type { I18nInitOptions, I18nInstance } from './i18n';
+import './types';
+export type { I18nSdkLoader, I18nSdkLoadOptions } from '../shared/type';
+export type { Resources } from './i18n/instance';
+export interface I18nPluginOptions {
+    entryName?: string;
+    localeDetection?: BaseLocaleDetectionOptions;
+    backend?: BaseBackendOptions;
+    i18nInstance?: I18nInstance;
+    changeLanguage?: (lang: string) => void;
+    initOptions?: I18nInitOptions;
+    htmlLangAttr?: boolean;
+    reactI18next?: boolean;
+    [key: string]: any;
+}
+export declare const i18nPlugin: (options: I18nPluginOptions) => RuntimePlugin;
+export { useModernI18n } from './context';
+export { I18nLink } from './I18nLink';
+export default i18nPlugin;

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

@@ -0,0 +1,15 @@
+import type { I18nInitOptions, I18nInstance } from './i18n';
+declare module '@modern-js/runtime' {
+    interface RuntimeConfig {
+        i18n?: {
+            i18nInstance?: I18nInstance;
+            changeLanguage?: (lang: string) => void;
+            setLang?: (lang: string) => void;
+            initOptions?: I18nInitOptions;
+        };
+    }
+    interface TInternalRuntimeContext {
+        i18nInstance?: I18nInstance;
+        changeLanguage?: (lang: string) => Promise<void>;
+    }
+}

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

@@ -0,0 +1,28 @@
+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;
+/**
+ * Helper function to get language from current pathname
+ * @param pathname - The current pathname
+ * @param languages - Array of supported languages
+ * @param fallbackLanguage - Fallback language when no language is detected
+ * @returns The detected language or fallback language
+ */
+export declare const getLanguageFromPath: (pathname: string, languages: string[], fallbackLanguage: string) => string;
+/**
+ * Helper function to build localized URL
+ * @param pathname - The current pathname
+ * @param language - The target language
+ * @param languages - Array of supported languages
+ * @returns The localized URL path
+ */
+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;
+};
+/**
+ * Check if the given pathname should ignore automatic locale redirect
+ */
+export declare const shouldIgnoreRedirect: (pathname: string, languages: string[], ignoreRedirectRoutes?: string[] | ((pathname: string) => boolean)) => boolean;

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

@@ -0,0 +1,14 @@
+import type { ServerPlugin } from '@modern-js/server-runtime';
+import type { LocaleDetectionOptions } from '../shared/type';
+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/deepMerge.d.ts

@@ -0,0 +1 @@
+export declare function deepMerge<T extends Record<string, any>>(defaultOptions: T, userOptions?: Partial<T>): T;

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

@@ -0,0 +1,11 @@
+import type { LanguageDetectorOptions } from '../runtime/i18n/instance';
+/**
+ * Detect language from request using the same detection logic as i18next
+ * This ensures consistency between server-side and client-side detection
+ */
+export declare function detectLanguageFromRequest(req: {
+    url: string;
+    headers: {
+        get: (name: string) => string | null;
+    } | Headers;
+}, languages: string[], detectionOptions?: LanguageDetectorOptions): string | null;

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

@@ -0,0 +1,168 @@
+import type { LanguageDetectorOptions, Resources } from '../runtime/i18n/instance';
+import type { LocalisedUrlsOption } from './localisedUrls';
+export interface BaseLocaleDetectionOptions {
+    localePathRedirect?: boolean;
+    i18nextDetector?: boolean;
+    languages?: string[];
+    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>;
+}
+/**
+ * Options for loading i18n resources via SDK
+ */
+export interface I18nSdkLoadOptions {
+    /** Single language code to load (e.g., 'en', 'zh') */
+    lng?: string;
+    /** Single namespace to load (e.g., 'translation', 'common') */
+    ns?: string;
+    /** Multiple language codes to load */
+    lngs?: string[];
+    /** Multiple namespaces to load */
+    nss?: string[];
+    /** Load all available languages and namespaces */
+    all?: boolean;
+}
+/**
+ * SDK function to load i18n resources
+ * Supports multiple loading modes:
+ * 1. Single resource: sdk({ lng: 'en', ns: 'translation' })
+ * 2. Batch by languages: sdk({ lngs: ['en', 'zh'], ns: 'translation' })
+ * 3. Batch by namespaces: sdk({ lng: 'en', nss: ['translation', 'common'] })
+ * 4. Batch by both: sdk({ lngs: ['en', 'zh'], nss: ['translation', 'common'] })
+ * 5. Load all: sdk({ all: true }) or sdk()
+ *
+ * @param options - Loading options
+ * @returns Promise that resolves to resources object or the resources object directly
+ *          Resources format: { [lng]: { [ns]: { [key]: value } } }
+ */
+export type I18nSdkLoader = (options: I18nSdkLoadOptions) => Promise<Resources> | Resources;
+/**
+ * Chained backend configuration
+ * Used internally when both loadPath and sdk are provided
+ */
+export interface ChainedBackendConfig {
+    _useChainedBackend: boolean;
+    _chainedBackendConfig: {
+        backendOptions: Array<Record<string, unknown>>;
+    };
+    cacheHitMode?: 'none' | 'refresh' | 'refreshAndUpdateStore';
+}
+/**
+ * Extended backend options that may include chained backend configuration
+ */
+export type ExtendedBackendOptions = BaseBackendOptions & Partial<ChainedBackendConfig>;
+export interface BaseBackendOptions {
+    enabled?: boolean;
+    loadPath?: string;
+    addPath?: string;
+    /**
+     * Cache hit mode for chained backend (only effective when both `loadPath` and `sdk` are provided)
+     *
+     * - `'none'` (default): If the first backend returns resources, stop and don't try the next backend
+     * - `'refresh'`: Try to refresh the cache by loading from the next backend and update the cache
+     * - `'refreshAndUpdateStore'`: Try to refresh the cache by loading from the next backend,
+     *   update the cache and also update the i18next resource store. This allows FS/HTTP resources
+     *   to be displayed first, then SDK resources will update them asynchronously.
+     *
+     * @default 'refreshAndUpdateStore' when both loadPath and sdk are provided
+     */
+    cacheHitMode?: 'none' | 'refresh' | 'refreshAndUpdateStore';
+    /**
+     * SDK function to load i18n resources dynamically
+     *
+     * **Important**: In `modern.config.ts`, you can only set this to `true` or any identifier
+     * to enable SDK mode. The actual SDK function must be provided in `modern.runtime.ts`
+     * via `initOptions.backend.sdk`.
+     *
+     * When both `loadPath` (or FS backend) and `sdk` are provided, the plugin will automatically
+     * use `i18next-chained-backend` to chain multiple backends. The order will be:
+     * 1. HTTP/FS backend (primary) - loads from `loadPath` or file system first for quick initial display
+     * 2. SDK backend (fallback/update) - loads from the SDK function to update/refresh translations
+     *
+     * With `cacheHitMode: 'refreshAndUpdateStore'` (default), FS/HTTP resources will be displayed
+     * immediately, then SDK resources will be loaded asynchronously to update the translations.
+     *
+     * If only `sdk` is provided, it will be used instead of the default HTTP/FS backend
+     *
+     * @example In modern.config.ts - enable SDK mode
+     * ```ts
+     * backend: {
+     *   enabled: true,
+     *   sdk: true, // or any identifier, just to enable SDK mode
+     * }
+     * ```
+     *
+     * @example In modern.runtime.ts - provide the actual SDK function
+     * ```ts
+     * export default defineRuntimeConfig({
+     *   i18n: {
+     *     initOptions: {
+     *       backend: {
+     *         sdk: async (options) => {
+     *           // Your SDK implementation
+     *           if (options.all) {
+     *             return await mySdk.getAllResources();
+     *           }
+     *           if (options.lng && options.ns) {
+     *             return await mySdk.getResource(options.lng, options.ns);
+     *           }
+     *           // Handle other cases...
+     *         }
+     *       }
+     *     }
+     *   }
+     * });
+     * ```
+     *
+     * @example Single resource loading
+     * ```ts
+     * sdk: async (options) => {
+     *   if (options.lng && options.ns) {
+     *     const response = await fetch(`/api/i18n/${options.lng}/${options.ns}`);
+     *     return response.json();
+     *   }
+     * }
+     * ```
+     *
+     * @example Load all resources at once
+     * ```ts
+     * sdk: async (options) => {
+     *   if (options?.all) {
+     *     // Load all languages and namespaces
+     *     return await mySdk.getAllResources();
+     *   }
+     *   // Handle other cases...
+     * }
+     * ```
+     *
+     * @example Batch loading
+     * ```ts
+     * sdk: async (options) => {
+     *   if (options?.lngs && options?.nss) {
+     *     // Load multiple languages and namespaces
+     *     return await mySdk.getBatchResources(options.lngs, options.nss);
+     *   }
+     *   // Handle single or other cases...
+     * }
+     * ```
+     */
+    sdk?: I18nSdkLoader | boolean | string;
+}
+export interface BackendOptions extends BaseBackendOptions {
+    backendOptionsByEntry?: Record<string, BaseBackendOptions>;
+}

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

@@ -0,0 +1,5 @@
+import type { BaseBackendOptions, BaseLocaleDetectionOptions } from './type';
+export declare function getEntryConfig<T extends Record<string, any>>(entryName: string, config: T, entryKey: string): T | undefined;
+export declare function removeEntryConfigKey<T extends Record<string, any>>(config: T, entryKey: string): Omit<T, typeof entryKey>;
+export declare function getLocaleDetectionOptions(entryName: string, localeDetection: BaseLocaleDetectionOptions): BaseLocaleDetectionOptions;
+export declare function getBackendOptions(entryName: string, backend: BaseBackendOptions): BaseBackendOptions;

package/package.json

@@ -17,7 +17,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "3.2.0-ultramodern.2",
+  "version": "3.2.0-ultramodern.23",
   "engines": {
     "node": ">=20"
   },
@@ -84,18 +84,18 @@
     "@swc/helpers": "^0.5.21",
     "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/server-core": "npm:@bleedingdev/modern-js-server-core@3.2.0-ultramodern.2",
-    "@modern-js/server-runtime": "npm:@bleedingdev/modern-js-server-runtime@3.2.0-ultramodern.2",
-    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.2.0-ultramodern.2",
-    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.2.0-ultramodern.2",
-    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.2.0-ultramodern.2",
-    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.2.0-ultramodern.2"
+    "i18next-http-middleware": "^3.9.7",
+    "@modern-js/plugin": "npm:@bleedingdev/modern-js-plugin@3.2.0-ultramodern.23",
+    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.2.0-ultramodern.23",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.2.0-ultramodern.23",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.2.0-ultramodern.23",
+    "@modern-js/server-runtime": "npm:@bleedingdev/modern-js-server-runtime@3.2.0-ultramodern.23",
+    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.2.0-ultramodern.23"
   },
   "peerDependencies": {
-    "@modern-js/runtime": "3.2.0-ultramodern.2",
+    "@modern-js/runtime": "3.2.0-ultramodern.23",
     "i18next": ">=25.7.4",
     "react": "^19.2.6",
     "react-dom": "^19.2.6",
@@ -112,16 +112,16 @@
   "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",
+    "@types/node": "^25.9.1",
+    "@typescript/native-preview": "7.0.0-dev.20260526.1",
     "i18next": "26.2.0",
     "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/app-tools": "npm:@bleedingdev/modern-js-app-tools@3.2.0-ultramodern.2",
-    "@modern-js/runtime": "npm:@bleedingdev/modern-js-runtime@3.2.0-ultramodern.2"
+    "ts-jest": "^29.4.11",
+    "@modern-js/app-tools": "npm:@bleedingdev/modern-js-app-tools@3.2.0-ultramodern.23",
+    "@modern-js/runtime": "npm:@bleedingdev/modern-js-runtime@3.2.0-ultramodern.23"
   },
   "sideEffects": false,
   "publishConfig": {

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,8 +1,16 @@
 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';
 
@@ -203,6 +211,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();

package/src/runtime/I18nLink.tsx

@@ -1,12 +1,12 @@
-import { Link, useInRouterContext, useParams } from '@modern-js/runtime/router';
 import type React from 'react';
 import { useModernI18n } from './context';
+import { useI18nRouterAdapter } from './routerAdapter';
 import { buildLocalizedUrl } from './utils';
 
 export interface I18nLinkProps {
   to: string;
   children: React.ReactNode;
-  [key: string]: any; // Allow other props to be passed through
+  [key: string]: any;
 }
 
 /**
@@ -24,30 +24,25 @@ export interface I18nLinkProps {
  * <I18nLink to="/">Home</I18nLink>
  * ```
  */
-// Use static imports to avoid breaking router tree-shaking. Detect router context via useInRouterContext.
-const useRouterHooks = () => {
-  const inRouter = useInRouterContext();
-  return {
-    Link: inRouter ? Link : null,
-    params: inRouter ? useParams() : ({} as any),
-    hasRouter: inRouter,
-  };
-};
-
 export const I18nLink: React.FC<I18nLinkProps> = ({
   to,
   children,
   ...props
 }) => {
-  const { Link, params, hasRouter } = useRouterHooks();
-  const { language, supportedLanguages } = useModernI18n();
+  const { Link, params, hasRouter } = useI18nRouterAdapter();
+  const { language, supportedLanguages, localisedUrls } = useModernI18n();
 
   // Get the current language from context (which reflects the actual current language)
   // URL params might be stale after language changes, so we prioritize the context language
   const currentLang = language;
 
   // Build the localized URL by adding language prefix
-  const localizedTo = buildLocalizedUrl(to, currentLang, supportedLanguages);
+  const localizedTo = buildLocalizedUrl(
+    to,
+    currentLang,
+    supportedLanguages,
+    localisedUrls,
+  );
 
   // In development mode, warn if used outside of :lang route context
   if (process.env.NODE_ENV === 'development' && hasRouter && !params.lang) {
@@ -57,7 +52,6 @@ export const I18nLink: React.FC<I18nLinkProps> = ({
     );
   }
 
-  // If router is not available, render as a regular anchor tag
   if (!hasRouter || !Link) {
     return (
       <a href={localizedTo} {...props}>