@bleedingdev/modern-js-plugin-i18n 3.5.0-ultramodern.36 → 3.5.0-ultramodern.38

package/dist/esm-node/runtime/i18n/detection/cache.mjs

@@ -22,9 +22,10 @@ const stableStringify = (value)=>{
     if (null == value) return JSON.stringify(value);
     if ('object' != typeof value) return JSON.stringify(value);
     if (Array.isArray(value)) return `[${value.map((item)=>stableStringify(item)).join(',')}]`;
-    const sortedKeys = Object.keys(value).sort();
+    const record = value;
+    const sortedKeys = Object.keys(record).sort();
     const sortedEntries = sortedKeys.map((key)=>{
-        const stringifiedValue = stableStringify(value[key]);
+        const stringifiedValue = stableStringify(record[key]);
         return `${JSON.stringify(key)}:${stringifiedValue}`;
     });
     return `{${sortedEntries.join(',')}}`;

package/dist/esm-node/runtime/i18n/instance.mjs

@@ -1,9 +1,11 @@
 import "node:module";
 function isI18nWrapperInstance(obj) {
     if (!obj || 'object' != typeof obj) return false;
-    if (!obj.i18nInstance || 'object' != typeof obj.i18nInstance) return false;
-    if (!obj.i18nInstance.instance) return false;
-    if ('function' != typeof obj.init || 'function' != typeof obj.use) return false;
+    const candidate = obj;
+    if (!candidate.i18nInstance || 'object' != typeof candidate.i18nInstance) return false;
+    const wrapper = candidate.i18nInstance;
+    if (!wrapper.instance) return false;
+    if ('function' != typeof candidate.init || 'function' != typeof candidate.use) return false;
     return true;
 }
 function getI18nWrapperI18nextInstance(wrapperInstance) {
@@ -20,7 +22,8 @@ function getActualI18nextInstance(instance) {
 function isI18nInstance(obj) {
     if (!obj || 'object' != typeof obj) return false;
     if (isI18nWrapperInstance(obj)) return true;
-    return 'function' == typeof obj.init && 'function' == typeof obj.use;
+    const candidate = obj;
+    return 'function' == typeof candidate.init && 'function' == typeof candidate.use;
 }
 async function tryImportI18next() {
     try {
@@ -57,4 +60,4 @@ async function getI18nInstance(userInstance) {
     if (i18nextInstance) return i18nextInstance;
     throw new Error('No i18n instance found');
 }
-export { getActualI18nextInstance, getI18nInstance, getI18nWrapperI18nextInstance, getI18nextInstanceForProvider, isI18nInstance, isI18nWrapperInstance };
+export { getActualI18nextInstance, getI18nInstance, getI18nextInstanceForProvider, isI18nInstance, isI18nWrapperInstance };

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 { localiseTargetPathname } from "../shared/localisedUrls.mjs";
+import { localiseTargetPathname, shouldSkipLocaleRedirect } from "../shared/localisedUrls.mjs";
 const getPathname = (context)=>{
     if (isBrowser()) return window.location.pathname;
     return context.ssrContext?.request?.pathname || '/';
@@ -52,13 +52,5 @@ const detectLanguageFromPath = (pathname, languages, localePathRedirect)=>{
         detected: false
     };
 };
-const shouldIgnoreRedirect = (pathname, languages, ignoreRedirectRoutes)=>{
-    if (!ignoreRedirectRoutes) return false;
-    const segments = pathname.split('/').filter(Boolean);
-    let pathWithoutLang = pathname;
-    if (segments.length > 0 && languages.includes(segments[0])) pathWithoutLang = `/${segments.slice(1).join('/')}`;
-    const normalizedPath = pathWithoutLang.startsWith('/') ? pathWithoutLang : `/${pathWithoutLang}`;
-    if ('function' == typeof ignoreRedirectRoutes) return ignoreRedirectRoutes(normalizedPath);
-    return ignoreRedirectRoutes.some((pattern)=>normalizedPath === pattern || normalizedPath.startsWith(`${pattern}/`));
-};
+const shouldIgnoreRedirect = (pathname, languages, ignoreRedirectRoutes)=>shouldSkipLocaleRedirect(pathname, languages, ignoreRedirectRoutes);
 export { buildLocalizedUrl, detectLanguageFromPath, getEntryPath, getLanguageFromPath, getPathname, shouldIgnoreRedirect, splitUrlTarget };

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

@@ -4,8 +4,8 @@ import { getLocaleDetectionOptions } from "../shared/utils.mjs";
 import { collectApiPrefixes, matchesApiPrefix } from "./apiPrefix.mjs";
 import { convertToHonoLanguageDetectorOptions } from "./detectorOptions.mjs";
 import { buildLocalizedUrl, createLocaleRedirectResponse, getLanguageFromPath, isStaticResourceRequest, shouldIgnoreRedirect } from "./redirectPolicy.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;
+import * as __rspack_external__modern_js_server_core_hono_0af3baa7 from "@modern-js/server-core/hono";
+const { languageDetector: languageDetector } = __rspack_external__modern_js_server_core_hono_0af3baa7;
 const i18nServerPlugin = (options)=>({
         name: '@modern-js/plugin-i18n/server',
         setup: (api)=>{

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

@@ -1,32 +1,26 @@
 import "node:module";
-import { localiseTargetPathname } from "../shared/localisedUrls.mjs";
-const shouldIgnoreRedirect = (pathname, urlPath, ignoreRedirectRoutes)=>{
-    if (!ignoreRedirectRoutes) return false;
+import { isDefaultLocaleRedirectSkipPath, localiseTargetPathname, matchesPathPrefix, shouldSkipLocaleRedirect, stripLanguagePrefix } from "../shared/localisedUrls.mjs";
+const stripUrlPathPrefix = (pathname, urlPath)=>{
     const basePath = urlPath.replace('/*', '');
+    if (!basePath || '/' === basePath) return pathname;
     const remainingPath = pathname.startsWith(basePath) ? pathname.slice(basePath.length) : pathname;
-    const normalizedPath = remainingPath.startsWith('/') ? remainingPath : `/${remainingPath}`;
-    if ('function' == typeof ignoreRedirectRoutes) return ignoreRedirectRoutes(normalizedPath);
-    return ignoreRedirectRoutes.some((pattern)=>normalizedPath === pattern || normalizedPath.startsWith(`${pattern}/`));
+    return remainingPath || '/';
+};
+const shouldIgnoreRedirect = (pathname, urlPath, ignoreRedirectRoutes)=>{
+    const remainingPath = stripUrlPathPrefix(pathname, urlPath);
+    return shouldSkipLocaleRedirect(remainingPath, [], ignoreRedirectRoutes);
 };
 const isStaticResourceRequest = (pathname, staticRoutePrefixes, languages = [])=>{
-    if (staticRoutePrefixes.some((prefix)=>pathname.startsWith(`${prefix}/`) || pathname === prefix)) return true;
-    const standardStaticPrefixes = [
-        '/static/',
-        '/upload/'
-    ];
-    if (standardStaticPrefixes.some((prefix)=>pathname.startsWith(prefix))) return true;
-    const pathSegments = pathname.split('/').filter(Boolean);
-    if (pathSegments.length > 0 && languages.includes(pathSegments[0])) {
-        const pathWithoutLang = '/' + pathSegments.slice(1).join('/');
-        if (standardStaticPrefixes.some((prefix)=>pathWithoutLang.startsWith(prefix)) || staticRoutePrefixes.some((prefix)=>pathWithoutLang.startsWith(`${prefix}/`) || pathWithoutLang === prefix)) return true;
-    }
-    return false;
+    if (isDefaultLocaleRedirectSkipPath(pathname, languages)) return true;
+    const matchesStaticRoutePrefix = (targetPathname)=>staticRoutePrefixes.some((prefix)=>matchesPathPrefix(targetPathname, prefix));
+    if (matchesStaticRoutePrefix(pathname)) return true;
+    const pathWithoutLanguage = stripLanguagePrefix(pathname, languages);
+    return pathWithoutLanguage !== pathname && matchesStaticRoutePrefix(pathWithoutLanguage);
 };
 const getLanguageFromPath = (req, urlPath, languages)=>{
     const url = new URL(req.url, `http://${req.header().host}`);
     const pathname = url.pathname;
-    const basePath = urlPath.replace('/*', '');
-    const remainingPath = pathname.startsWith(basePath) ? pathname.slice(basePath.length) : pathname;
+    const remainingPath = stripUrlPathPrefix(pathname, urlPath);
     const segments = remainingPath.split('/').filter(Boolean);
     const firstSegment = segments[0];
     if (languages.includes(firstSegment)) return firstSegment;
@@ -36,7 +30,7 @@ const buildLocalizedUrl = (req, urlPath, language, languages, localisedUrls)=>{
     const url = new URL(req.url);
     const pathname = url.pathname;
     const basePath = urlPath.replace('/*', '');
-    const remainingPath = pathname.startsWith(basePath) ? pathname.slice(basePath.length) : pathname;
+    const remainingPath = stripUrlPathPrefix(pathname, urlPath);
     const newPathname = localiseTargetPathname(remainingPath, language, languages, localisedUrls);
     const suffix = `${url.search}${url.hash}`;
     const localizedUrl = '/' === basePath ? newPathname + suffix : basePath + newPathname + suffix;

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

@@ -1,72 +1,2 @@
 import "node:module";
-import { DEFAULT_I18NEXT_DETECTION_OPTIONS, mergeDetectionOptions } from "../runtime/i18n/detection/config.mjs";
-function detectLanguageFromRequest(req, languages, detectionOptions) {
-    try {
-        const mergedDetection = detectionOptions ? mergeDetectionOptions(detectionOptions) : DEFAULT_I18NEXT_DETECTION_OPTIONS;
-        const order = (mergedDetection.order || []).filter((item)=>![
-                'path',
-                'localStorage',
-                'navigator',
-                'htmlTag',
-                'subdomain'
-            ].includes(item));
-        const detectionOrder = order.length > 0 ? order : [
-            'querystring',
-            'cookie',
-            'header'
-        ];
-        const getHeader = (name)=>{
-            req.headers, Headers;
-            return req.headers.get(name);
-        };
-        for (const method of detectionOrder){
-            let detectedLang = null;
-            switch(method){
-                case 'querystring':
-                    {
-                        const lookupKey = mergedDetection.lookupQuerystring || DEFAULT_I18NEXT_DETECTION_OPTIONS.lookupQuerystring || 'lng';
-                        const host = getHeader('host') || 'localhost';
-                        const url = new URL(req.url, `http://${host}`);
-                        detectedLang = url.searchParams.get(lookupKey);
-                        break;
-                    }
-                case 'cookie':
-                    {
-                        const lookupKey = mergedDetection.lookupCookie || DEFAULT_I18NEXT_DETECTION_OPTIONS.lookupCookie || 'i18next';
-                        const cookieHeader = getHeader('Cookie');
-                        if (cookieHeader) {
-                            const cookies = cookieHeader.split(';').reduce((acc, item)=>{
-                                const [key, value] = item.trim().split('=');
-                                if (key && value) acc[key] = value;
-                                return acc;
-                            }, {});
-                            detectedLang = cookies[lookupKey] || null;
-                        }
-                        break;
-                    }
-                case 'header':
-                    {
-                        const lookupKey = mergedDetection.lookupHeader || DEFAULT_I18NEXT_DETECTION_OPTIONS.lookupHeader || 'accept-language';
-                        const acceptLanguage = getHeader(lookupKey);
-                        if (acceptLanguage) {
-                            const languagesList = acceptLanguage.split(',').map((lang)=>{
-                                const [code, q] = lang.trim().split(';');
-                                return {
-                                    code: code.split('-')[0],
-                                    quality: q ? parseFloat(q.split('=')[1]) : 1.0
-                                };
-                            }).sort((a, b)=>b.quality - a.quality);
-                            for (const lang of languagesList)if (0 === languages.length || languages.includes(lang.code)) {
-                                detectedLang = lang.code;
-                                break;
-                            }
-                        }
-                        break;
-                    }
-            }
-            if (detectedLang && (0 === languages.length || languages.includes(detectedLang))) return detectedLang;
-        }
-    } catch (error) {}
-    return null;
-}
-export { detectLanguageFromRequest };
+import "../runtime/i18n/detection/config.mjs";

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

@@ -1,7 +1,8 @@
 import "node:module";
 export { resolveLocalisedUrlsConfig } from "./config.mjs";
 export { normalisePathPattern, normalisePathname } from "./normalise.mjs";
-export { canonicalTargetPathname, localiseTargetPathname } from "./pathname.mjs";
+export { canonicalTargetPathname, localiseTargetPathname, stripLanguagePrefix } from "./pathname.mjs";
 export { buildPathFromPattern, matchPathPattern } from "./patterns.mjs";
+export { DEFAULT_LOCALE_REDIRECT_SKIP_RULES, isDefaultLocaleRedirectSkipPath, matchesPathPrefix, shouldSkipLocaleRedirect } from "./redirect.mjs";
 export { resolveCanonicalLocalisedPath, resolveLocalisedPath } from "./resolve.mjs";
 export { applyLocalisedUrlsToRoutes, validateLocalisedUrls } from "./routes.mjs";

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

@@ -22,4 +22,4 @@ const canonicalTargetPathname = (pathname, languages, localisedUrls)=>{
     const localisedUrlsConfig = resolveLocalisedUrlsConfig(localisedUrls);
     return localisedUrlsConfig.enabled ? resolveCanonicalLocalisedPath(pathWithoutLanguage, languages, localisedUrlsConfig.map) : pathWithoutLanguage;
 };
-export { canonicalTargetPathname, localiseTargetPathname };
+export { canonicalTargetPathname, localiseTargetPathname, stripLanguagePrefix };

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

@@ -0,0 +1,49 @@
+import "node:module";
+import { normalisePathname } from "./normalise.mjs";
+import { stripLanguagePrefix } from "./pathname.mjs";
+const DEFAULT_LOCALE_REDIRECT_SKIP_RULES = [
+    {
+        type: 'exact',
+        path: '/mf-manifest.json'
+    },
+    {
+        type: 'exact',
+        path: '/mf-stats.json'
+    },
+    {
+        type: 'exact',
+        path: '/remoteEntry.js'
+    },
+    {
+        type: 'prefix',
+        path: '/static/'
+    },
+    {
+        type: 'prefix',
+        path: '/upload/'
+    }
+];
+const stripTrailingSlash = (pathname)=>pathname.length > 1 ? pathname.replace(/\/+$/, '') : pathname;
+const matchesPathPrefix = (pathname, prefix)=>{
+    const normalizedPathname = normalisePathname(pathname);
+    const normalizedPrefix = stripTrailingSlash(normalisePathname(prefix));
+    return normalizedPathname === normalizedPrefix || normalizedPathname.startsWith(`${normalizedPrefix}/`);
+};
+const matchesSkipRule = (pathname, rule)=>{
+    if ('exact' === rule.type) return normalisePathname(pathname) === normalisePathname(rule.path);
+    return matchesPathPrefix(pathname, rule.path);
+};
+const isDefaultLocaleRedirectSkipPath = (pathname, languages = [])=>{
+    const normalizedPathname = normalisePathname(pathname);
+    const pathWithoutLanguage = stripLanguagePrefix(normalizedPathname, languages);
+    return DEFAULT_LOCALE_REDIRECT_SKIP_RULES.some((rule)=>matchesSkipRule(pathWithoutLanguage, rule));
+};
+const shouldSkipLocaleRedirect = (pathname, languages = [], ignoreRedirectRoutes)=>{
+    const normalizedPathname = normalisePathname(pathname);
+    const pathWithoutLanguage = stripLanguagePrefix(normalizedPathname, languages);
+    if (isDefaultLocaleRedirectSkipPath(pathWithoutLanguage)) return true;
+    if (!ignoreRedirectRoutes) return false;
+    if ('function' == typeof ignoreRedirectRoutes) return ignoreRedirectRoutes(pathWithoutLanguage);
+    return ignoreRedirectRoutes.some((pattern)=>matchesPathPrefix(pathWithoutLanguage, pattern));
+};
+export { DEFAULT_LOCALE_REDIRECT_SKIP_RULES, isDefaultLocaleRedirectSkipPath, matchesPathPrefix, shouldSkipLocaleRedirect };

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

@@ -1,51 +1,48 @@
 import "node:module";
 import { normalisePathname } from "./normalise.mjs";
 import { buildPathFromPattern, matchPathPattern, sortPatternsBySpecificity } from "./patterns.mjs";
-const resolveLocalisedPath = (pathname, targetLanguage, languages, localisedUrls)=>{
-    const normalizedPathname = normalisePathname(pathname);
-    const canonicalCandidates = sortPatternsBySpecificity(Object.entries(localisedUrls).map(([canonicalPattern, localisedUrlEntry])=>({
+const getCanonicalCandidates = (localisedUrls)=>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) 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 resolveLocalisedUrlPath = (pathname, languages, localisedUrls, options)=>{
     const normalizedPathname = normalisePathname(pathname);
-    const canonicalCandidates = sortPatternsBySpecificity(Object.entries(localisedUrls).map(([canonicalPattern, localisedUrlEntry])=>({
-            pattern: canonicalPattern,
-            canonicalPattern,
-            localisedUrlEntry
-        })));
+    const canonicalCandidates = getCanonicalCandidates(localisedUrls);
     for (const { canonicalPattern, localisedUrlEntry } of canonicalCandidates){
+        const targetPattern = 'localised' === options.mode ? localisedUrlEntry[options.targetLanguage] : canonicalPattern;
+        if (!targetPattern) continue;
         const canonicalParams = matchPathPattern(normalizedPathname, canonicalPattern);
-        if (canonicalParams) return buildPathFromPattern(canonicalPattern, canonicalParams);
-        for (const language of languages){
+        if (canonicalParams) return buildPathFromPattern(targetPattern, canonicalParams);
+        if ('canonical' === options.mode) for (const language of languages){
             const sourcePattern = localisedUrlEntry[language];
             if (!sourcePattern) continue;
             const params = matchPathPattern(normalizedPathname, sourcePattern);
             if (params) return buildPathFromPattern(canonicalPattern, params);
         }
     }
+    if ('localised' === options.mode) {
+        const localisedCandidates = sortPatternsBySpecificity(Object.values(localisedUrls).flatMap((localisedUrlEntry)=>{
+            const targetPattern = localisedUrlEntry[options.targetLanguage];
+            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 resolveLocalisedPath = (pathname, targetLanguage, languages, localisedUrls)=>resolveLocalisedUrlPath(pathname, languages, localisedUrls, {
+        mode: 'localised',
+        targetLanguage
+    });
+const resolveCanonicalLocalisedPath = (pathname, languages, localisedUrls)=>resolveLocalisedUrlPath(pathname, languages, localisedUrls, {
+        mode: 'canonical'
+    });
 export { resolveCanonicalLocalisedPath, resolveLocalisedPath };

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

@@ -1,2 +1,2 @@
 import "node:module";
-export { applyLocalisedUrlsToRoutes, buildPathFromPattern, canonicalTargetPathname, localiseTargetPathname, matchPathPattern, normalisePathPattern, normalisePathname, resolveCanonicalLocalisedPath, resolveLocalisedPath, resolveLocalisedUrlsConfig, validateLocalisedUrls } from "./localisedUrls/index.mjs";
+export { DEFAULT_LOCALE_REDIRECT_SKIP_RULES, applyLocalisedUrlsToRoutes, buildPathFromPattern, canonicalTargetPathname, isDefaultLocaleRedirectSkipPath, localiseTargetPathname, matchPathPattern, matchesPathPrefix, normalisePathPattern, normalisePathname, resolveCanonicalLocalisedPath, resolveLocalisedPath, resolveLocalisedUrlsConfig, shouldSkipLocaleRedirect, stripLanguagePrefix, validateLocalisedUrls } from "./localisedUrls/index.mjs";

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

@@ -33,4 +33,4 @@ function getBackendOptions(entryName, backend) {
     if ('backendOptionsByEntry' in fullConfig) return removeEntryConfigKey(fullConfig, 'backendOptionsByEntry');
     return backend;
 }
-export { getBackendOptions, getEntryConfig, getLocaleDetectionOptions, removeEntryConfigKey };
+export { getBackendOptions, getLocaleDetectionOptions };

package/dist/types/cli/locales.d.ts

@@ -4,7 +4,7 @@ interface NormalizedConfigForLocales {
         publicDir?: string | string[];
     };
 }
-export interface DetectedLocalesDirectory {
+interface DetectedLocalesDirectory {
     loadPath: string;
     addPath: string;
     serverLoadPath: string;

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

@@ -1,7 +1,7 @@
 import type { FC, ReactNode } from 'react';
 import type { LocalisedUrlsOption } from '../shared/localisedUrls';
 import type { I18nInstance } from './i18n';
-export interface ModernI18nContextValue {
+interface ModernI18nContextValue {
     language: string;
     i18nInstance: I18nInstance;
     entryName?: string;
@@ -11,12 +11,12 @@ export interface ModernI18nContextValue {
     localisedUrls?: LocalisedUrlsOption;
     updateLanguage?: (newLang: string) => void;
 }
-export interface ModernI18nProviderProps {
+interface ModernI18nProviderProps {
     children: ReactNode;
     value: ModernI18nContextValue;
 }
 export declare const ModernI18nProvider: FC<ModernI18nProviderProps>;
-export interface UseModernI18nReturn {
+interface UseModernI18nReturn {
     language: string;
     changeLanguage: (newLang: string) => Promise<void>;
     t: (key: string | string[], ...args: any[]) => string;
@@ -40,3 +40,4 @@ export interface UseModernI18nReturn {
  * @returns Object containing i18n functionality and utilities
  */
 export declare const useModernI18n: () => UseModernI18nReturn;
+export {};

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

@@ -10,7 +10,7 @@ type LocationLike = {
 };
 export declare function getPathLanguage(pathname: string | undefined, languages: string[] | undefined, localePathRedirect: boolean | undefined): string | undefined;
 export declare function cacheI18nLanguage(i18nInstance: I18nInstance, language: string): void;
-export interface ChangeModernI18nLanguageOptions {
+interface ChangeModernI18nLanguageOptions {
     i18nInstance: I18nInstance;
     updateLanguage?: (newLang: string) => void;
     localePathRedirect?: boolean;
@@ -22,7 +22,7 @@ export interface ChangeModernI18nLanguageOptions {
     location?: LocationLike | null;
 }
 export declare function changeModernI18nLanguage(newLang: string, options: ChangeModernI18nLanguageOptions): Promise<void>;
-export declare function translateI18n(i18nInstance: I18nInstance, key: string | string[], ...args: any[]): string;
+export declare function translateI18n(i18nInstance: I18nInstance, key: string | string[], ...args: unknown[]): string;
 export declare function isI18nLanguageSupported(languages: string[] | undefined, lang: string): boolean;
 export declare function isI18nResourcesReady(i18nInstance: I18nInstance, currentLanguage: string): boolean;
 export {};

package/dist/types/runtime/i18n/backend/middleware.common.d.ts

@@ -1,6 +1,7 @@
 import type { BaseBackendOptions, ChainedBackendConfig } from '../../../shared/type';
 import type { I18nInstance } from '../instance';
 type BackendConfigWithChained = BaseBackendOptions & Partial<ChainedBackendConfig>;
+type BackendConstructor = new (...args: never[]) => unknown;
 /**
  * Common logic for using i18next backend
  * This function handles the backend selection and chained backend configuration
@@ -10,5 +11,5 @@ type BackendConfigWithChained = BaseBackendOptions & Partial<ChainedBackendConfi
  * @param BackendBase - The base backend class (for non-chained use)
  * @param backend - Optional backend configuration
  */
-export declare function useI18nextBackendCommon(i18nInstance: I18nInstance, BackendWithSave: new (...args: any[]) => any, BackendBase: new (...args: any[]) => any, backend?: BackendConfigWithChained): void;
+export declare function useI18nextBackendCommon(i18nInstance: I18nInstance, BackendWithSave: BackendConstructor, BackendBase: BackendConstructor, backend?: BackendConfigWithChained): void;
 export {};

package/dist/types/runtime/i18n/detection/cache.d.ts

@@ -6,7 +6,7 @@ interface DetectorCacheEntry {
 }
 export declare const detectorInstanceCache: WeakMap<I18nInstance, DetectorCacheEntry>;
 export declare const buildDetectorConfigKey: (languages: string[], fallbackLanguage: string, mergedDetection: LanguageDetectorOptions) => string;
-export declare const pickSafeDetectionOptions: (userInitOptions?: I18nInitOptions) => Partial<I18nInitOptions> & Record<string, any>;
+export declare const pickSafeDetectionOptions: (userInitOptions?: I18nInitOptions) => Partial<I18nInitOptions> & Record<string, unknown>;
 export declare const createDetectorInstance: (baseInstance: I18nInstance, configKey: string) => {
     instance: I18nInstance;
     isTemporary: boolean;

package/dist/types/runtime/i18n/detection/detector.d.ts

@@ -1,8 +1,8 @@
 import type { I18nInstance } from '../instance';
-import type { BaseLanguageDetectionOptions } from './types';
+import type { BaseLanguageDetectionOptions, LanguageDetectionSsrContext } from './types';
 /**
  * Priority 3: Detect language using i18next detector
  */
 export declare const detectLanguageFromI18nextDetector: (i18nInstance: I18nInstance, options: BaseLanguageDetectionOptions & {
-    ssrContext?: any;
+    ssrContext?: LanguageDetectionSsrContext;
 }) => Promise<string | undefined>;

package/dist/types/runtime/i18n/detection/middleware.d.ts

@@ -1,4 +1,4 @@
-import type { I18nInstance } from '../instance';
+import type { I18nInstance, LanguageDetectorOptions } from '../instance';
 /**
  * Register LanguageDetector plugin to i18n instance
  * Must be called before init() to properly register the detector
@@ -9,16 +9,16 @@ export declare const useI18nextLanguageDetector: (i18nInstance: I18nInstance) =>
  * Read language directly from localStorage/cookie
  * Fallback when detector is not available in services
  */
-export declare const readLanguageFromStorage: (detectionOptions?: any) => string | undefined;
+export declare const readLanguageFromStorage: (detectionOptions?: LanguageDetectorOptions) => string | undefined;
 /**
  * Detect language using i18next-browser-languagedetector
  * For initialized instances without detector in services, manually create a detector instance
  * For wrapper instances, access the underlying i18next instance's services
  */
-export declare const detectLanguage: (i18nInstance: I18nInstance, _request?: any, detectionOptions?: any) => string | undefined;
+export declare const detectLanguage: (i18nInstance: I18nInstance, _request?: unknown, detectionOptions?: LanguageDetectorOptions) => string | undefined;
 /**
  * Cache user language to localStorage/cookie
  * Uses LanguageDetector's cacheUserLanguage method when available
  * For wrapper instances, access the underlying i18next instance's services
  */
-export declare const cacheUserLanguage: (i18nInstance: I18nInstance, language: string, detectionOptions?: any) => void;
+export declare const cacheUserLanguage: (i18nInstance: I18nInstance, language: string, detectionOptions?: unknown) => void;

package/dist/types/runtime/i18n/detection/middleware.node.d.ts

@@ -1,10 +1,10 @@
-import type { I18nInstance } from '../instance';
-export declare const cacheUserLanguage: (_i18nInstance: I18nInstance, _language: string, _detectionOptions?: any) => void;
+import type { I18nInstance, LanguageDetectorOptions } from '../instance';
+export declare const cacheUserLanguage: (_i18nInstance: I18nInstance, _language: string, _detectionOptions?: unknown) => void;
 /**
  * Read language directly from storage (localStorage/cookie)
  * Not available in Node.js environment, returns undefined
  */
-export declare const readLanguageFromStorage: (_detectionOptions?: any) => string | undefined;
+export declare const readLanguageFromStorage: (_detectionOptions?: LanguageDetectorOptions) => string | undefined;
 /**
  * Register LanguageDetector plugin to i18n instance
  * Must be called before init() to properly register the detector
@@ -14,4 +14,4 @@ export declare const useI18nextLanguageDetector: (i18nInstance: I18nInstance) =>
  * Detect language using i18next-http-middleware LanguageDetector
  * For initialized instances without detector in services, manually create a detector instance
  */
-export declare const detectLanguage: (i18nInstance: I18nInstance, request?: any, detectionOptions?: any) => string | undefined;
+export declare const detectLanguage: (i18nInstance: I18nInstance, request?: unknown, detectionOptions?: LanguageDetectorOptions) => string | undefined;

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

@@ -1,4 +1,7 @@
-import type { I18nInitOptions, LanguageDetectorOptions } from '../instance';
+import type { BackendOptions, I18nInitOptions, LanguageDetectorOptions } from '../instance';
+export interface LanguageDetectionSsrContext {
+    request?: unknown;
+}
 export interface BaseLanguageDetectionOptions {
     languages: string[];
     fallbackLanguage: string;
@@ -6,11 +9,11 @@ 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 {
     detectedLanguage?: string;
@@ -24,6 +27,6 @@ export interface BuildInitOptionsParams {
     fallbackLanguage: string;
     languages: string[];
     userInitOptions?: I18nInitOptions;
-    mergedDetection?: any;
-    mergeBackend?: any;
+    mergedDetection?: LanguageDetectorOptions;
+    mergeBackend?: BackendOptions;
 }