@bleedingdev/modern-js-plugin-i18n 3.5.0-ultramodern.35 → 3.5.0-ultramodern.37

package/src/runtime/i18n/detection/detector.ts

@@ -14,7 +14,10 @@ import { getSupportedLanguage, isLanguageSupported } from './language';
 
 import { detectLanguage, useI18nextLanguageDetector } from './middleware';
 
-import type { BaseLanguageDetectionOptions } from './types';
+import type {
+  BaseLanguageDetectionOptions,
+  LanguageDetectionSsrContext,
+} from './types';
 
 /**
  * Initialize i18n instance for detector if needed
@@ -24,6 +27,10 @@ interface DetectorInitResult {
   isTemporary: boolean;
 }
 
+type MutableDetectorInstanceState = Omit<I18nInstance, 'language'> & {
+  language?: string;
+};
+
 const initializeI18nForDetector = async (
   i18nInstance: I18nInstance,
   options: BaseLanguageDetectionOptions,
@@ -48,7 +55,7 @@ const initializeI18nForDetector = async (
 
   const safeUserOptions = pickSafeDetectionOptions(options.userInitOptions);
 
-  // Only initialize detection capability, don't load any resources to avoid conflicts with subsequent backend initialization
+  // Only initialize detection capability, don't load resources to avoid conflicts with subsequent backend initialization
   const initOptions: I18nInitOptions = {
     ...safeUserOptions,
     fallbackLng: options.fallbackLanguage,
@@ -81,7 +88,9 @@ const initializeI18nForDetector = async (
  */
 export const detectLanguageFromI18nextDetector = async (
   i18nInstance: I18nInstance,
-  options: BaseLanguageDetectionOptions & { ssrContext?: any },
+  options: BaseLanguageDetectionOptions & {
+    ssrContext?: LanguageDetectionSsrContext;
+  },
 ): Promise<string | undefined> => {
   if (!options.i18nextDetector) {
     return undefined;
@@ -108,7 +117,7 @@ export const detectLanguageFromI18nextDetector = async (
 
     const detectorLang = detectLanguage(
       detectorInstance,
-      request as any,
+      request,
       mergedDetection,
     );
 
@@ -148,8 +157,8 @@ export const detectLanguageFromI18nextDetector = async (
       });
     } else if (detectorInstance === i18nInstance) {
       // As a fallback, prevent i18nInstance from being polluted by detector init
-      (i18nInstance as any).isInitialized = false;
-      delete (i18nInstance as any).language;
+      i18nInstance.isInitialized = false;
+      delete (i18nInstance as unknown as MutableDetectorInstanceState).language;
     }
   }
 

package/src/runtime/i18n/detection/middleware.node.ts

@@ -1,10 +1,22 @@
 import { LanguageDetector } from 'i18next-http-middleware';
-import type { I18nInstance } from '../instance';
+import type { I18nInstance, LanguageDetectorOptions } from '../instance';
+
+type HttpDetectorInit = (
+  services: NonNullable<I18nInstance['services']>,
+  options?: unknown,
+  allOptions?: unknown,
+) => void;
+
+type HttpDetectorDetect = (
+  request: unknown,
+  response: unknown,
+  detectionOrder?: unknown,
+) => string | string[] | undefined;
 
 export const cacheUserLanguage = (
   _i18nInstance: I18nInstance,
   _language: string,
-  _detectionOptions?: any,
+  _detectionOptions?: unknown,
 ): void => {
   return;
 };
@@ -14,7 +26,7 @@ export const cacheUserLanguage = (
  * Not available in Node.js environment, returns undefined
  */
 export const readLanguageFromStorage = (
-  _detectionOptions?: any,
+  _detectionOptions?: LanguageDetectorOptions,
 ): string | undefined => {
   // In Node.js environment, storage-based detection is not available
   return undefined;
@@ -36,8 +48,8 @@ export const useI18nextLanguageDetector = (i18nInstance: I18nInstance) => {
  */
 export const detectLanguage = (
   i18nInstance: I18nInstance,
-  request?: any,
-  detectionOptions?: any,
+  request?: unknown,
+  detectionOptions?: LanguageDetectorOptions,
 ): string | undefined => {
   if (!request) {
     return undefined;
@@ -65,9 +77,16 @@ export const detectLanguage = (
       const optionsToUse = detectionOptions
         ? { ...i18nInstance.options, detection: detectionOptions }
         : i18nInstance.options;
-      manualDetector.init(i18nInstance.services, optionsToUse as any);
+      (manualDetector.init as unknown as HttpDetectorInit)(
+        i18nInstance.services,
+        optionsToUse,
+      );
 
-      const result = (manualDetector.detect as any)(request, {}, undefined);
+      const result = (manualDetector.detect as unknown as HttpDetectorDetect)(
+        request,
+        {},
+        undefined,
+      );
       if (typeof result === 'string') {
         return result;
       }

package/src/runtime/i18n/detection/middleware.ts

@@ -1,8 +1,10 @@
 import { isBrowser } from '@modern-js/runtime';
 import LanguageDetector from 'i18next-browser-languagedetector';
-import type { I18nInstance } from '../instance';
+import type { I18nInstance, LanguageDetectorOptions } from '../instance';
 import { getActualI18nextInstance, isI18nWrapperInstance } from '../instance';
 
+type BrowserDetectorInitOptions = Parameters<LanguageDetector['init']>[1];
+
 /**
  * Register LanguageDetector plugin to i18n instance
  * Must be called before init() to properly register the detector
@@ -27,7 +29,7 @@ export const useI18nextLanguageDetector = (i18nInstance: I18nInstance) => {
  * Fallback when detector is not available in services
  */
 export const readLanguageFromStorage = (
-  detectionOptions?: any,
+  detectionOptions?: LanguageDetectorOptions,
 ): string | undefined => {
   try {
     const options = detectionOptions || {};
@@ -112,8 +114,8 @@ export const readLanguageFromStorage = (
  */
 export const detectLanguage = (
   i18nInstance: I18nInstance,
-  _request?: any,
-  detectionOptions?: any,
+  _request?: unknown,
+  detectionOptions?: LanguageDetectorOptions,
 ): string | undefined => {
   try {
     // For wrapper instances, get the underlying i18next instance
@@ -160,7 +162,10 @@ export const detectLanguage = (
         const mergedOptions = detectionOptions
           ? { ...optionsToUse, detection: detectionOptions }
           : optionsToUse;
-        manualDetector.init(servicesToUse, mergedOptions as any);
+        manualDetector.init(
+          servicesToUse,
+          mergedOptions as unknown as BrowserDetectorInitOptions,
+        );
 
         const result = manualDetector.detect();
         if (typeof result === 'string') {
@@ -186,7 +191,7 @@ export const detectLanguage = (
 export const cacheUserLanguage = (
   i18nInstance: I18nInstance,
   language: string,
-  detectionOptions?: any,
+  detectionOptions?: unknown,
 ): void => {
   if (typeof window === 'undefined') {
     return;
@@ -231,7 +236,10 @@ export const cacheUserLanguage = (
           : optionsToUse;
 
         const manualDetector = new LanguageDetector();
-        manualDetector.init(servicesToUse, mergedOptions as any);
+        manualDetector.init(
+          servicesToUse,
+          mergedOptions as unknown as BrowserDetectorInitOptions,
+        );
 
         if (typeof manualDetector.cacheUserLanguage === 'function') {
           manualDetector.cacheUserLanguage(language);

package/src/runtime/i18n/detection/types.ts

@@ -1,4 +1,12 @@
-import type { I18nInitOptions, LanguageDetectorOptions } from '../instance';
+import type {
+  BackendOptions,
+  I18nInitOptions,
+  LanguageDetectorOptions,
+} from '../instance';
+
+export interface LanguageDetectionSsrContext {
+  request?: unknown;
+}
 
 export interface BaseLanguageDetectionOptions {
   languages: string[];
@@ -7,12 +15,12 @@ export interface BaseLanguageDetectionOptions {
   i18nextDetector: boolean;
   detection?: LanguageDetectorOptions;
   userInitOptions?: I18nInitOptions;
-  mergedBackend?: any;
+  mergedBackend?: BackendOptions;
 }
 
 export interface LanguageDetectionOptions extends BaseLanguageDetectionOptions {
   pathname: string;
-  ssrContext?: any;
+  ssrContext?: LanguageDetectionSsrContext;
 }
 
 export interface LanguageDetectionResult {
@@ -28,6 +36,6 @@ export interface BuildInitOptionsParams {
   fallbackLanguage: string;
   languages: string[];
   userInitOptions?: I18nInitOptions;
-  mergedDetection?: any;
-  mergeBackend?: any;
+  mergedDetection?: LanguageDetectorOptions;
+  mergeBackend?: BackendOptions;
 }

package/src/runtime/i18n/instance.ts

@@ -1,9 +1,9 @@
 import type { BaseBackendOptions } from '../../shared/type';
 
-export interface I18nResourceStore {
+interface I18nResourceStore {
   data?: {
     [language: string]: {
-      [namespace: string]: string | { [key: string]: any };
+      [namespace: string]: ResourceValue;
     };
   };
   addResourceBundle?: (
@@ -15,30 +15,49 @@ export interface I18nResourceStore {
   ) => void;
 }
 
-export function isI18nWrapperInstance(obj: any): boolean {
+type I18nWrapperInstance = I18nInstance & {
+  i18nInstance: {
+    instance: I18nInstance;
+  };
+};
+
+export function isI18nWrapperInstance(
+  obj: unknown,
+): obj is I18nWrapperInstance {
   if (!obj || typeof obj !== 'object') {
     return false;
   }
-  if (!obj.i18nInstance || typeof obj.i18nInstance !== 'object') {
+  const candidate = obj as {
+    i18nInstance?: unknown;
+    init?: unknown;
+    use?: unknown;
+  };
+  if (!candidate.i18nInstance || typeof candidate.i18nInstance !== 'object') {
     return false;
   }
-  if (!obj.i18nInstance.instance) {
+  const wrapper = candidate.i18nInstance as { instance?: unknown };
+  if (!wrapper.instance) {
     return false;
   }
-  if (typeof obj.init !== 'function' || typeof obj.use !== 'function') {
+  if (
+    typeof candidate.init !== 'function' ||
+    typeof candidate.use !== 'function'
+  ) {
     return false;
   }
   return true;
 }
 
-export function getI18nWrapperI18nextInstance(wrapperInstance: any): any {
+function getI18nWrapperI18nextInstance(
+  wrapperInstance: unknown,
+): I18nInstance | null {
   if (isI18nWrapperInstance(wrapperInstance)) {
     return wrapperInstance.i18nInstance?.instance;
   }
   return null;
 }
 
-export function getActualI18nextInstance(instance: I18nInstance | any): any {
+export function getActualI18nextInstance(instance: I18nInstance): I18nInstance {
   if (isI18nWrapperInstance(instance)) {
     const i18nextInstance = getI18nWrapperI18nextInstance(instance);
     return i18nextInstance || instance;
@@ -50,39 +69,42 @@ export interface I18nInstance {
   language: string;
   isInitialized?: boolean;
   init: {
-    (callback?: (error: any, t: any) => void): Promise<any>;
+    (callback?: (error: unknown, t: unknown) => void): Promise<unknown>;
     (
       options: I18nInitOptions,
-      callback?: (error: any, t: any) => void,
-    ): Promise<any>;
+      callback?: (error: unknown, t: unknown) => void,
+    ): Promise<unknown>;
   };
   changeLanguage?: (
     lng?: string,
-    callback?: (error: any, t: any) => void,
-  ) => Promise<any>;
+    callback?: (error: unknown, t: unknown) => void,
+  ) => Promise<unknown>;
   setLang?: (lang: string) => void | Promise<void>;
-  use: (plugin: any) => void;
+  use: (plugin: unknown) => void;
   createInstance?: (options?: I18nInitOptions) => I18nInstance;
   cloneInstance?: () => I18nInstance; // ssr need
   // i18next store (may not be in type definition but exists at runtime)
   store?: I18nResourceStore;
-  emit?: (event: string, ...args: any[]) => void;
+  emit?: (event: string, ...args: unknown[]) => void;
   reloadResources?: (language?: string, namespace?: string) => Promise<void>;
   services?: {
     languageDetector?: {
-      detect: (request?: any, options?: any) => string | string[] | undefined;
-      [key: string]: any;
+      detect: (
+        request?: unknown,
+        options?: unknown,
+      ) => string | string[] | undefined;
+      [key: string]: unknown;
     };
     resourceStore?: I18nResourceStore;
-    backend?: any; // Backend instance (e.g., SdkBackend)
-    [key: string]: any;
+    backend?: unknown; // Backend instance (e.g., SdkBackend)
+    [key: string]: unknown;
   };
   // i18next instance options (available after initialization)
   options?: {
     backend?: BackendOptions;
-    [key: string]: any;
+    [key: string]: unknown;
   };
-  [key: string]: any;
+  [key: string]: unknown;
 }
 
 type LanguageDetectorOrder = string[];
@@ -101,12 +123,12 @@ export interface LanguageDetectorOptions {
 }
 
 export interface BackendOptions extends Omit<BaseBackendOptions, 'enabled'> {
-  parse?: (data: string) => any;
-  stringify?: (data: any) => string;
+  parse?: (data: string) => unknown;
+  stringify?: (data: unknown) => string;
   [key: string]: any;
 }
 
-export type ResourceValue = string | { [key: string]: ResourceValue };
+type ResourceValue = string | { [key: string]: ResourceValue };
 
 export interface Resources {
   [lng: string]: {
@@ -126,15 +148,15 @@ export type I18nInitOptions = {
   defaultNS?: string | string[];
   interpolation?: {
     escapeValue?: boolean;
-    [key: string]: any;
+    [key: string]: unknown;
   };
   react?: {
     useSuspense?: boolean;
-    [key: string]: any;
+    [key: string]: unknown;
   };
 };
 
-export function isI18nInstance(obj: any): obj is I18nInstance {
+export function isI18nInstance(obj: unknown): obj is I18nInstance {
   if (!obj || typeof obj !== 'object') {
     return false;
   }
@@ -143,7 +165,10 @@ export function isI18nInstance(obj: any): obj is I18nInstance {
     return true;
   }
 
-  return typeof obj.init === 'function' && typeof obj.use === 'function';
+  const candidate = obj as { init?: unknown; use?: unknown };
+  return (
+    typeof candidate.init === 'function' && typeof candidate.use === 'function'
+  );
 }
 
 async function tryImportI18next(): Promise<I18nInstance | null> {
@@ -170,8 +195,8 @@ async function createI18nextInstance(): Promise<I18nInstance | null> {
 }
 
 export function getI18nextInstanceForProvider(
-  instance: I18nInstance | any,
-): any {
+  instance: I18nInstance,
+): I18nInstance {
   if (isI18nWrapperInstance(instance)) {
     const i18nextInstance = getI18nWrapperI18nextInstance(instance);
     if (i18nextInstance) {
@@ -183,7 +208,7 @@ export function getI18nextInstanceForProvider(
 }
 
 export async function getI18nInstance(
-  userInstance?: I18nInstance | any,
+  userInstance?: unknown,
 ): Promise<I18nInstance> {
   if (userInstance) {
     if (isI18nWrapperInstance(userInstance)) {

package/src/runtime/i18n/utils.ts

@@ -11,7 +11,16 @@ import {
   isI18nWrapperInstance,
 } from './instance';
 
-export function assertI18nInstance(obj: any): asserts obj is I18nInstance {
+type MergedBackendOptions = NonNullable<I18nInitOptions['backend']> & {
+  _useChainedBackend?: boolean;
+  _chainedBackendConfig?: {
+    backendOptions: Array<Record<string, unknown>>;
+  };
+  backends?: unknown[];
+  backendOptions?: unknown;
+};
+
+export function assertI18nInstance(obj: unknown): asserts obj is I18nInstance {
   if (!isI18nInstance(obj)) {
     throw new Error('Object does not implement I18nInstance interface');
   }
@@ -24,8 +33,8 @@ export const buildInitOptions = async (
   finalLanguage: string,
   fallbackLanguage: string,
   languages: string[],
-  mergedDetection: any,
-  mergedBackend: any,
+  mergedDetection: I18nInitOptions['detection'],
+  mergedBackend: MergedBackendOptions | undefined,
   userInitOptions?: I18nInitOptions,
   useSuspense?: boolean,
   i18nInstance?: I18nInstance,
@@ -84,8 +93,8 @@ export const buildInitOptions = async (
     if (isChainedBackend && mergedBackend._chainedBackendConfig) {
       // Try to get backend classes from i18nInstance.options.backend.backends first
       // This avoids importing fs-backend in browser environment
-      let HttpBackend: any;
-      let SdkBackendClass: any;
+      let HttpBackend: unknown;
+      let SdkBackendClass: unknown;
 
       if (
         i18nInstance?.options?.backend?.backends &&
@@ -148,7 +157,7 @@ export const changeI18nLanguage = async (
   i18nInstance: I18nInstance,
   newLang: string,
   options?: {
-    detectionOptions?: any;
+    detectionOptions?: I18nInitOptions['detection'];
   },
 ): Promise<void> => {
   if (!newLang || typeof newLang !== 'string') {
@@ -179,8 +188,8 @@ export const initializeI18nInstance = async (
   finalLanguage: string,
   fallbackLanguage: string,
   languages: string[],
-  mergedDetection: any,
-  mergedBackend: any,
+  mergedDetection: I18nInitOptions['detection'],
+  mergedBackend: MergedBackendOptions | undefined,
   userInitOptions?: I18nInitOptions,
   useSuspense?: boolean,
 ): Promise<void> => {
@@ -265,7 +274,7 @@ export const setupClonedInstance = async (
   backendEnabled: boolean,
   backend: BaseBackendOptions | undefined,
   i18nextDetector: boolean,
-  detection: any,
+  detection: I18nInitOptions['detection'],
   localePathRedirect: boolean,
   userInitOptions: I18nInitOptions | undefined,
 ): Promise<void> => {

package/src/runtime/pluginSetup.ts

@@ -57,7 +57,7 @@ export interface RuntimeContextWithI18n extends TInternalRuntimeContext {
   changeLanguage?: (lang: string) => Promise<void>;
 }
 
-export interface SetupI18nBeforeRenderOptions {
+interface SetupI18nBeforeRenderOptions {
   api: I18nRuntimeApi;
   userI18nInstance?: I18nInstance;
   initOptions?: I18nInitOptions;

package/src/runtime/providerComposition.tsx

@@ -14,7 +14,7 @@ import type { I18nInstance } from './i18n';
 import { getI18nextInstanceForProvider } from './i18n/instance';
 import type { RuntimeContextWithI18n } from './pluginSetup';
 
-export interface I18nRootWrapperOptions {
+interface I18nRootWrapperOptions {
   entryName?: string;
   htmlLangAttr: boolean;
   localePathRedirect: boolean;

package/src/runtime/routerAdapter.tsx

@@ -15,31 +15,31 @@ import {
 import type React from 'react';
 import { useCallback, useContext, useEffect, useState } from 'react';
 
-export type I18nRouterFramework = 'react-router' | 'tanstack' | string;
+type I18nRouterFramework = 'react-router' | 'tanstack' | string;
 
-export interface I18nRouterLocation {
+interface I18nRouterLocation {
   pathname: string;
   search: string;
   hash: string;
 }
 
-export interface I18nRouterNavigateOptions {
+interface I18nRouterNavigateOptions {
   replace?: boolean;
   state?: unknown;
 }
 
-export type I18nRouterNavigate = (
+type I18nRouterNavigate = (
   href: string,
   options?: I18nRouterNavigateOptions,
 ) => void | Promise<void>;
 
-export type I18nRouterLink = React.ComponentType<{
+type I18nRouterLink = React.ComponentType<{
   to: string;
   children?: React.ReactNode;
   [key: string]: unknown;
 }>;
 
-export interface I18nRouterAdapter {
+interface I18nRouterAdapter {
   framework?: I18nRouterFramework;
   hasRouter: boolean;
   location: I18nRouterLocation | null;

package/src/runtime/utils.ts

@@ -1,7 +1,10 @@
 import { isBrowser } from '@modern-js/runtime';
 import { getGlobalBasename } from '@modern-js/runtime/context';
 import type { LocalisedUrlsOption } from '../shared/localisedUrls';
-import { localiseTargetPathname } from '../shared/localisedUrls';
+import {
+  localiseTargetPathname,
+  shouldSkipLocaleRedirect,
+} from '../shared/localisedUrls';
 
 // Structural parameter: hooks.ts passes a public-TRuntimeContext-based
 // context while core.tsx passes the internal one; both carry the request
@@ -129,32 +132,5 @@ export const shouldIgnoreRedirect = (
   languages: string[],
   ignoreRedirectRoutes?: string[] | ((pathname: string) => boolean),
 ): boolean => {
-  if (!ignoreRedirectRoutes) {
-    return false;
-  }
-
-  // Remove language prefix if present (e.g., /en/api -> /api)
-  const segments = pathname.split('/').filter(Boolean);
-  let pathWithoutLang = pathname;
-  if (segments.length > 0 && languages.includes(segments[0])) {
-    // Remove language prefix
-    pathWithoutLang = `/${segments.slice(1).join('/')}`;
-  }
-
-  // Normalize path (ensure it starts with /)
-  const normalizedPath = pathWithoutLang.startsWith('/')
-    ? pathWithoutLang
-    : `/${pathWithoutLang}`;
-
-  if (typeof ignoreRedirectRoutes === 'function') {
-    return ignoreRedirectRoutes(normalizedPath);
-  }
-
-  // Check if pathname matches any of the ignore patterns
-  return ignoreRedirectRoutes.some(pattern => {
-    // Support both exact match and prefix match
-    return (
-      normalizedPath === pattern || normalizedPath.startsWith(`${pattern}/`)
-    );
-  });
+  return shouldSkipLocaleRedirect(pathname, languages, ignoreRedirectRoutes);
 };