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

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

@@ -0,0 +1,192 @@
+import "node:module";
+const LOCALE_PARAM_NAMES = new Set([
+    'lang',
+    'locale',
+    'language'
+]);
+const normalisePathPattern = (path)=>{
+    const withoutDuplicateSlashes = path.replace(/\/+/g, '/');
+    const withLeadingSlash = withoutDuplicateSlashes.startsWith('/') ? withoutDuplicateSlashes : `/${withoutDuplicateSlashes}`;
+    const withoutTrailingSlash = withLeadingSlash.length > 1 ? withLeadingSlash.replace(/\/+$/, '') : withLeadingSlash;
+    return withoutTrailingSlash.replace(/\[(.+?)\]/g, ':$1');
+};
+const normaliseRoutePath = (path)=>{
+    const normalized = normalisePathPattern(path);
+    return '/' === normalized ? '' : normalized.slice(1);
+};
+const getLocaleParamSegment = (segment)=>{
+    if (!segment.startsWith(':')) return null;
+    const paramName = segment.slice(1).replace(/\?$/, '');
+    return LOCALE_PARAM_NAMES.has(paramName) ? segment : null;
+};
+const splitPathSegments = (path)=>{
+    if (!path) return [];
+    return normalisePathPattern(path).split('/').filter(Boolean);
+};
+const stripLeadingLocaleParam = (path)=>{
+    const segments = splitPathSegments(path);
+    const leadingLocaleParam = getLocaleParamSegment(segments[0] || '');
+    if (!leadingLocaleParam) return path;
+    const remainingPath = segments.slice(1).join('/');
+    return remainingPath ? `/${remainingPath}` : void 0;
+};
+const getLeadingLocaleParam = (path)=>{
+    const segments = splitPathSegments(path);
+    return getLocaleParamSegment(segments[0] || '');
+};
+const resolveLocalisedUrlsConfig = (option)=>{
+    if (false === option) return {
+        enabled: false,
+        map: {}
+    };
+    if (option && 'object' == typeof option) return {
+        enabled: true,
+        map: option
+    };
+    return {
+        enabled: true,
+        map: {}
+    };
+};
+const isLocalisableRoutePath = (path)=>{
+    const pathWithoutLocale = stripLeadingLocaleParam(path);
+    if (!pathWithoutLocale || '/' === pathWithoutLocale || '*' === pathWithoutLocale) return false;
+    return true;
+};
+const joinPath = (parentPath, routePath)=>{
+    if (!isLocalisableRoutePath(routePath)) return parentPath;
+    const segment = normaliseRoutePath(stripLeadingLocaleParam(routePath) || '');
+    return normalisePathPattern(`${parentPath}/${segment}`);
+};
+const ensureLocalisedUrlsForPath = (canonicalPath, languages, localisedUrls)=>{
+    const entry = localisedUrls[canonicalPath];
+    if (!entry) throw new Error(`localisedUrls is enabled, but route "${canonicalPath}" does not define localised URLs for languages: ${languages.join(', ')}. Add localisedUrls["${canonicalPath}"] or set localeDetection.localisedUrls to false.`);
+    const missingLanguages = languages.filter((language)=>!entry[language]);
+    if (missingLanguages.length > 0) throw new Error(`localisedUrls["${canonicalPath}"] is missing languages: ${missingLanguages.join(', ')}. Every configured language must have a localised URL.`);
+    return entry;
+};
+const validateLocalisedUrls = (routes, languages, localisedUrls)=>{
+    const visit = (route, parentPath)=>{
+        const canonicalPath = joinPath(parentPath, route.path);
+        if (isLocalisableRoutePath(route.path)) ensureLocalisedUrlsForPath(canonicalPath, languages, localisedUrls);
+        if ('children' in route && route.children) route.children.forEach((child)=>visit(child, canonicalPath));
+    };
+    routes.forEach((route)=>visit(route, ''));
+};
+const getLocalisedRoutePaths = (canonicalPath, parentLocalisedPaths, languages, entry)=>{
+    const paths = languages.map((language)=>{
+        const fullPath = normalisePathPattern(entry[language]);
+        const parentPath = normalisePathPattern(parentLocalisedPaths[language] || '/');
+        if ('/' === parentPath) return normaliseRoutePath(fullPath) || void 0;
+        const parentPrefix = `${parentPath}/`;
+        if (!fullPath.startsWith(parentPrefix)) throw new Error(`localisedUrls["${canonicalPath}"].${language} must be nested under "${parentPath}" because its parent route is localised there.`);
+        return normaliseRoutePath(fullPath.slice(parentPath.length));
+    });
+    return Array.from(new Set(paths.filter(Boolean)));
+};
+const transformLocalisedRoute = (route, parentCanonicalPath, parentLocalisedPaths, languages, localisedUrls)=>{
+    const canonicalPath = joinPath(parentCanonicalPath, route.path);
+    const localisedUrlEntry = isLocalisableRoutePath(route.path) ? ensureLocalisedUrlsForPath(canonicalPath, languages, localisedUrls) : void 0;
+    const routeLocalisedPaths = localisedUrlEntry ? languages.reduce((acc, language)=>{
+        acc[language] = normalisePathPattern(localisedUrlEntry[language]);
+        return acc;
+    }, {}) : parentLocalisedPaths;
+    const children = 'children' in route && route.children ? route.children.flatMap((child)=>transformLocalisedRoute(child, canonicalPath, routeLocalisedPaths, languages, localisedUrls)) : void 0;
+    const baseRoute = {
+        ...route,
+        ...children ? {
+            children
+        } : {}
+    };
+    if (!localisedUrlEntry) return [
+        baseRoute
+    ];
+    return getLocalisedRoutePaths(canonicalPath, parentLocalisedPaths, languages, localisedUrlEntry).map((localisedPath, index)=>cloneRouteWithLocalisedPath(baseRoute, localisedPath, index));
+};
+const legalRouteIdPart = (value)=>value.replace(/[^a-zA-Z0-9_$-]+/g, '_').replace(/^_+|_+$/g, '') || 'index';
+const suffixRouteIds = (route, suffix)=>{
+    const children = 'children' in route && route.children ? route.children.map((child)=>suffixRouteIds(child, suffix)) : void 0;
+    return {
+        ...route,
+        ...route.id ? {
+            id: `${route.id}__localised_${suffix}`
+        } : {},
+        ...children ? {
+            children
+        } : {}
+    };
+};
+const cloneRouteWithLocalisedPath = (route, path, index)=>{
+    const leadingLocaleParam = getLeadingLocaleParam(route.path);
+    const localisedPath = leadingLocaleParam ? normaliseRoutePath(`${leadingLocaleParam}/${path}`) : path;
+    const routeWithPath = {
+        ...route,
+        path: localisedPath
+    };
+    return 0 === index ? routeWithPath : suffixRouteIds(routeWithPath, legalRouteIdPart(localisedPath));
+};
+const applyLocalisedUrlsToRoutes = (routes, languages, localisedUrls)=>{
+    const rootLocalisedPaths = languages.reduce((acc, language)=>{
+        acc[language] = '/';
+        return acc;
+    }, {});
+    validateLocalisedUrls(routes, languages, localisedUrls);
+    return routes.flatMap((route)=>transformLocalisedRoute(route, '', rootLocalisedPaths, languages, localisedUrls));
+};
+const escapeRegExp = (value)=>value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+const getParamName = (segment)=>segment.slice(1).replace(/\?$/, '');
+const compilePathPattern = (pattern)=>{
+    const names = [];
+    const segments = normalisePathPattern(pattern).split('/').filter(Boolean);
+    const source = segments.map((segment)=>{
+        if (segment.startsWith(':')) {
+            names.push(getParamName(segment));
+            const paramPattern = '([^/]+)';
+            return segment.endsWith('?') ? `(?:/${paramPattern})?` : `/${paramPattern}`;
+        }
+        if ('*' === segment) {
+            names.push('*');
+            return '/(.*)';
+        }
+        return `/${escapeRegExp(segment)}`;
+    }).join('');
+    return {
+        names,
+        regexp: new RegExp(`^${source || '/'}$`)
+    };
+};
+const matchPathPattern = (pathname, pattern)=>{
+    const { names, regexp } = compilePathPattern(pattern);
+    const match = regexp.exec(normalisePathPattern(pathname));
+    if (!match) return null;
+    return names.reduce((params, name, index)=>{
+        params[name] = decodeURIComponent(match[index + 1] || '');
+        return params;
+    }, {});
+};
+const buildPathFromPattern = (pattern, params)=>{
+    const segments = normalisePathPattern(pattern).split('/').filter(Boolean);
+    const path = segments.map((segment)=>{
+        if (segment.startsWith(':')) {
+            const param = params[getParamName(segment)];
+            return param ? encodeURIComponent(param) : '';
+        }
+        if ('*' === segment) return params['*'] || '';
+        return segment;
+    }).filter(Boolean).join('/');
+    return `/${path}`;
+};
+const resolveLocalisedPath = (pathname, targetLanguage, languages, localisedUrls)=>{
+    const normalizedPathname = normalisePathPattern(pathname);
+    for (const localisedUrlEntry of Object.values(localisedUrls)){
+        const targetPattern = localisedUrlEntry[targetLanguage];
+        if (targetPattern) for (const language of languages){
+            const sourcePattern = localisedUrlEntry[language];
+            if (!sourcePattern) continue;
+            const params = matchPathPattern(normalizedPathname, sourcePattern);
+            if (params) return buildPathFromPattern(targetPattern, params);
+        }
+    }
+    return normalizedPathname;
+};
+export { applyLocalisedUrlsToRoutes, normalisePathPattern, resolveLocalisedPath, resolveLocalisedUrlsConfig, validateLocalisedUrls };

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

@@ -0,0 +1,21 @@
+import type { AppTools, CliPlugin } from '@modern-js/app-tools';
+import type { Entrypoint } from '@modern-js/types';
+import type { BackendOptions, LocaleDetectionOptions } from '../shared/type';
+export type TransformRuntimeConfigFn = (extendedConfig: Record<string, any>, entrypoint: Entrypoint) => Record<string, any>;
+export interface I18nPluginOptions {
+    localeDetection?: LocaleDetectionOptions;
+    backend?: BackendOptions;
+    transformRuntimeConfig?: TransformRuntimeConfigFn;
+    customPlugin?: {
+        runtime?: {
+            name?: string;
+            path?: string;
+        };
+        server?: {
+            name?: string;
+        };
+    };
+    [key: string]: any;
+}
+export declare const i18nPlugin: (options?: I18nPluginOptions) => CliPlugin<AppTools>;
+export default i18nPlugin;

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

@@ -0,0 +1,23 @@
+import type React from 'react';
+export interface I18nLinkProps {
+    to: string;
+    children: React.ReactNode;
+    [key: string]: any;
+}
+/**
+ * I18nLink component that automatically adds language prefix to navigation links.
+ * This component should be used within a :lang dynamic route context.
+ *
+ * @example
+ * ```tsx
+ * // When current language is 'en' and to="/about"
+ * // The actual link will be "/en/about"
+ * <I18nLink to="/about">About</I18nLink>
+ *
+ * // When current language is 'zh' and to="/"
+ * // The actual link will be "/zh"
+ * <I18nLink to="/">Home</I18nLink>
+ * ```
+ */
+export declare const I18nLink: React.FC<I18nLinkProps>;
+export default I18nLink;

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

@@ -0,0 +1,41 @@
+import type { FC, ReactNode } from 'react';
+import type { LocalisedUrlsOption } from '../shared/localisedUrls';
+import type { I18nInstance } from './i18n';
+export interface ModernI18nContextValue {
+    language: string;
+    i18nInstance: I18nInstance;
+    entryName?: string;
+    languages?: string[];
+    localePathRedirect?: boolean;
+    ignoreRedirectRoutes?: string[] | ((pathname: string) => boolean);
+    localisedUrls?: LocalisedUrlsOption;
+    updateLanguage?: (newLang: string) => void;
+}
+export interface ModernI18nProviderProps {
+    children: ReactNode;
+    value: ModernI18nContextValue;
+}
+export declare const ModernI18nProvider: FC<ModernI18nProviderProps>;
+export interface UseModernI18nReturn {
+    language: string;
+    changeLanguage: (newLang: string) => Promise<void>;
+    i18nInstance: I18nInstance;
+    supportedLanguages: string[];
+    localisedUrls?: LocalisedUrlsOption;
+    isLanguageSupported: (lang: string) => boolean;
+    isResourcesReady: boolean;
+}
+/**
+ * Hook for accessing i18n functionality in Modern.js applications.
+ *
+ * This hook provides:
+ * - Current language from URL params or i18n context
+ * - changeLanguage function that updates both i18n instance and URL
+ * - Direct access to the i18n instance
+ * - List of supported languages
+ * - Helper function to check if a language is supported
+ *
+ * @param options - Optional configuration to override context settings
+ * @returns Object containing i18n functionality and utilities
+ */
+export declare const useModernI18n: () => UseModernI18nReturn;

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

@@ -0,0 +1,30 @@
+import type { TRuntimeContext } from '@modern-js/runtime';
+import type React from 'react';
+import type { LocalisedUrlsOption } from '../shared/localisedUrls';
+import type { I18nInstance } from './i18n';
+interface RuntimeContextWithI18n extends TRuntimeContext {
+    i18nInstance?: I18nInstance;
+}
+export declare function createContextValue(lang: string, i18nInstance: I18nInstance | undefined, entryName: string | undefined, languages: string[], localePathRedirect: boolean, ignoreRedirectRoutes: string[] | ((pathname: string) => boolean) | undefined, localisedUrls: LocalisedUrlsOption | undefined, setLang: (lang: string) => void): {
+    language: string;
+    i18nInstance: I18nInstance;
+    entryName: string | undefined;
+    languages: string[];
+    localePathRedirect: boolean;
+    ignoreRedirectRoutes: string[] | ((pathname: string) => boolean) | undefined;
+    localisedUrls: LocalisedUrlsOption | undefined;
+    updateLanguage: (lang: string) => void;
+};
+export declare function useSdkResourcesLoader(i18nInstance: I18nInstance | undefined, setForceUpdate: React.Dispatch<React.SetStateAction<number>>): void;
+/**
+ * Hook to handle client-side redirect for locale path redirect in static deployments
+ * This ensures that when users access paths without language prefix, they are redirected
+ * to the localized version of the path
+ *
+ * Note: This hook only runs in CSR (Client-Side Rendering) scenarios.
+ * In SSR/SSG scenarios, server-side middleware handles redirects, so this hook is skipped.
+ * We use process.env.MODERN_TARGET to ensure this code is only included in browser bundles.
+ */
+export declare function useClientSideRedirect(i18nInstance: I18nInstance | undefined, localePathRedirect: boolean, languages: string[], fallbackLanguage: string, ignoreRedirectRoutes?: string[] | ((pathname: string) => boolean), localisedUrls?: LocalisedUrlsOption): void;
+export declare function useLanguageSync(i18nInstance: I18nInstance | undefined, localePathRedirect: boolean, languages: string[], runtimeContextRef: React.MutableRefObject<RuntimeContextWithI18n>, prevLangRef: React.MutableRefObject<string>, setLang: (lang: string) => void): void;
+export {};

package/dist/types/runtime/i18n/backend/config.d.ts

@@ -0,0 +1,2 @@
+import type { BackendOptions } from '../instance';
+export declare function mergeBackendOptions(defaultOptions: BackendOptions, cliOptions?: BackendOptions, userOptions?: BackendOptions): BackendOptions;

package/dist/types/runtime/i18n/backend/defaults.d.ts

@@ -0,0 +1,13 @@
+export declare const DEFAULT_I18NEXT_BACKEND_OPTIONS: {
+    loadPath: string;
+    addPath: string;
+};
+declare global {
+    interface Window {
+        __assetPrefix__?: string;
+    }
+}
+export declare function convertBackendOptions<T extends {
+    loadPath?: string;
+    addPath?: string;
+}>(options: T): T;

package/dist/types/runtime/i18n/backend/defaults.node.d.ts

@@ -0,0 +1,8 @@
+export declare const DEFAULT_I18NEXT_BACKEND_OPTIONS: {
+    loadPath: string;
+    addPath: string;
+};
+export declare function convertBackendOptions<T extends {
+    loadPath?: string;
+    addPath?: string;
+}>(options: T): T;

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

@@ -0,0 +1,3 @@
+import type { BaseBackendOptions } from '../../../shared/type';
+import type { BackendOptions, I18nInitOptions } from '../instance';
+export declare const mergeBackendOptions: (backend?: BaseBackendOptions, userInitOptions?: I18nInitOptions) => BackendOptions | undefined;

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

@@ -0,0 +1,14 @@
+import type { BaseBackendOptions, ChainedBackendConfig } from '../../../shared/type';
+import type { I18nInstance } from '../instance';
+type BackendConfigWithChained = BaseBackendOptions & Partial<ChainedBackendConfig>;
+/**
+ * Common logic for using i18next backend
+ * This function handles the backend selection and chained backend configuration
+ *
+ * @param i18nInstance - The i18n instance to configure
+ * @param BackendWithSave - The wrapped backend class with save method (required for chained backend refresh logic)
+ * @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 {};

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

@@ -0,0 +1,12 @@
+import Backend from 'i18next-http-backend';
+import type { ExtendedBackendOptions } from '../../../shared/type';
+import type { I18nInstance } from '../instance';
+/**
+ * Wrapper for HTTP backend to add a no-op save method
+ * This is required for i18next-chained-backend to trigger refresh logic
+ * when cacheHitMode is 'refresh' or 'refreshAndUpdateStore'
+ */
+export declare class HttpBackendWithSave extends Backend {
+    save(_language: string, _namespace: string, _data: unknown): void;
+}
+export declare const useI18nextBackend: (i18nInstance: I18nInstance, backend?: ExtendedBackendOptions) => void;

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

@@ -0,0 +1,13 @@
+import Backend from 'i18next-fs-backend/cjs';
+import type { ExtendedBackendOptions } from '../../../shared/type';
+import type { I18nInstance } from '../instance';
+/**
+ * Wrapper for FS backend to add a no-op save method
+ * This is required for i18next-chained-backend to trigger refresh logic
+ * when cacheHitMode is 'refresh' or 'refreshAndUpdateStore'
+ */
+export declare class FsBackendWithSave extends Backend {
+    save(_language: string, _namespace: string, _data: unknown): void;
+}
+export declare const HttpBackendWithSave: typeof FsBackendWithSave;
+export declare const useI18nextBackend: (i18nInstance: I18nInstance, backend?: ExtendedBackendOptions) => void;

package/dist/types/runtime/i18n/backend/sdk-backend.d.ts

@@ -0,0 +1,53 @@
+import type { I18nSdkLoader } from '../../../shared/type';
+interface BackendOptions {
+    sdk?: I18nSdkLoader;
+    [key: string]: unknown;
+}
+interface I18nextServices {
+    resourceStore?: {
+        data?: {
+            [language: string]: {
+                [namespace: string]: Record<string, string>;
+            };
+        };
+    };
+    store?: {
+        data?: {
+            [language: string]: {
+                [namespace: string]: Record<string, string>;
+            };
+        };
+    };
+    [key: string]: any;
+}
+export declare class SdkBackend {
+    static type: string;
+    type: 'backend';
+    sdk?: I18nSdkLoader;
+    private allResourcesCache;
+    private backendId;
+    private loadingPromises;
+    private services?;
+    constructor(_services: unknown, _options: Record<string, unknown>);
+    init(services: I18nextServices, backendOptions: BackendOptions, _i18nextOptions: unknown): void;
+    read(language: string, namespace: string, callback: (error: Error | null, data: unknown) => void): void;
+    create(_languages: string[], _namespace: string, _key: string, _fallbackValue: string): void;
+    isLoading(language: string, namespace: string): boolean;
+    getLoadingResources(): Array<{
+        language: string;
+        namespace: string;
+    }>;
+    hasLoadingResources(): boolean;
+    private getCacheKey;
+    private loadResource;
+    private handlePromise;
+    private normalizeError;
+    private callSdk;
+    private extractFromCache;
+    private updateCache;
+    private formatResources;
+    private isObject;
+    private mergeWithExistingResources;
+    private triggerI18nextUpdate;
+}
+export {};

package/dist/types/runtime/i18n/backend/sdk-event.d.ts

@@ -0,0 +1,9 @@
+export declare const I18N_SDK_RESOURCES_LOADED_EVENT = "i18n-sdk-resources-loaded";
+export interface I18nSdkResourcesLoadedEventDetail {
+    language: string;
+    namespace: string;
+    backendId?: string;
+}
+export declare function createI18nSdkBackendId(): string;
+export declare function setI18nSdkBackendId(target: unknown, backendId: string): void;
+export declare function getI18nSdkBackendId(target: unknown): string | undefined;

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

@@ -0,0 +1,11 @@
+import type { LanguageDetectorOptions } from '../instance';
+export declare const DEFAULT_I18NEXT_DETECTION_OPTIONS: {
+    caches: string[];
+    order: string[];
+    cookieMinutes: number;
+    lookupQuerystring: string;
+    lookupCookie: string;
+    lookupLocalStorage: string;
+    lookupHeader: string;
+};
+export declare function mergeDetectionOptions(cliOptions?: LanguageDetectorOptions, userOptions?: LanguageDetectorOptions, defaultOptions?: LanguageDetectorOptions): LanguageDetectorOptions;

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

@@ -0,0 +1,50 @@
+import { type TRuntimeContext } from '@modern-js/runtime';
+import type { I18nInitOptions, I18nInstance, LanguageDetectorOptions } from '../instance';
+import { cacheUserLanguage } from './middleware';
+export { cacheUserLanguage };
+export declare function exportServerLngToWindow(context: TRuntimeContext, lng: string): void;
+export declare const getLanguageFromSSRData: (window: Window) => string | undefined;
+export interface BaseLanguageDetectionOptions {
+    languages: string[];
+    fallbackLanguage: string;
+    localePathRedirect: boolean;
+    i18nextDetector: boolean;
+    detection?: LanguageDetectorOptions;
+    userInitOptions?: I18nInitOptions;
+    mergedBackend?: any;
+}
+export interface LanguageDetectionOptions extends BaseLanguageDetectionOptions {
+    pathname: string;
+    ssrContext?: any;
+}
+export interface LanguageDetectionResult {
+    detectedLanguage?: string;
+    finalLanguage: string;
+}
+/**
+ * Detect language with priority:
+ * Priority 1: SSR data (try window._SSR_DATA first, works for both SSR and CSR)
+ * Priority 2: Path detection
+ * Priority 3: i18next detector (reads from cookie/localStorage)
+ * Priority 4: User config language or fallback
+ */
+export declare const detectLanguageWithPriority: (i18nInstance: I18nInstance, options: LanguageDetectionOptions) => Promise<LanguageDetectionResult>;
+/**
+ * Options for building i18n init options
+ */
+export interface BuildInitOptionsParams {
+    finalLanguage: string;
+    fallbackLanguage: string;
+    languages: string[];
+    userInitOptions?: I18nInitOptions;
+    mergedDetection?: any;
+    mergeBackend?: any;
+}
+/**
+ * Build i18n initialization options
+ */
+export declare const buildInitOptions: (params: BuildInitOptionsParams) => I18nInitOptions;
+/**
+ * Merge detection and backend options
+ */
+export declare const mergeDetectionOptions: (i18nextDetector: boolean, detection?: LanguageDetectorOptions, localePathRedirect?: boolean, userInitOptions?: I18nInitOptions) => LanguageDetectorOptions;

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

@@ -0,0 +1,24 @@
+import type { I18nInstance } from '../instance';
+/**
+ * Register LanguageDetector plugin to i18n instance
+ * Must be called before init() to properly register the detector
+ * For wrapper instances, ensure detector is registered on the underlying i18next instance
+ */
+export declare const useI18nextLanguageDetector: (i18nInstance: I18nInstance) => void | I18nInstance;
+/**
+ * Read language directly from localStorage/cookie
+ * Fallback when detector is not available in services
+ */
+export declare const readLanguageFromStorage: (detectionOptions?: any) => 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;
+/**
+ * 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;

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

@@ -0,0 +1,17 @@
+import type { I18nInstance } from '../instance';
+export declare const cacheUserLanguage: (_i18nInstance: I18nInstance, _language: string, _detectionOptions?: any) => void;
+/**
+ * Read language directly from storage (localStorage/cookie)
+ * Not available in Node.js environment, returns undefined
+ */
+export declare const readLanguageFromStorage: (_detectionOptions?: any) => string | undefined;
+/**
+ * Register LanguageDetector plugin to i18n instance
+ * Must be called before init() to properly register the detector
+ */
+export declare const useI18nextLanguageDetector: (i18nInstance: I18nInstance) => void | 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;

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

@@ -0,0 +1,3 @@
+export type { I18nInitOptions, I18nInstance, } from './instance';
+export { getI18nInstance, isI18nInstance } from './instance';
+export { assertI18nInstance } from './utils';

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

@@ -0,0 +1,96 @@
+import type { BaseBackendOptions } from '../../shared/type';
+type ReactI18nextModule = typeof import('react-i18next');
+type InitReactI18next = ReactI18nextModule['initReactI18next'];
+type I18nextProviderComponent = ReactI18nextModule['I18nextProvider'];
+export interface I18nResourceStore {
+    data?: {
+        [language: string]: {
+            [namespace: string]: string | {
+                [key: string]: any;
+            };
+        };
+    };
+    addResourceBundle?: (language: string, namespace: string, resources: Record<string, string>, deep?: boolean, overwrite?: boolean) => void;
+}
+export declare function isI18nWrapperInstance(obj: any): boolean;
+export declare function getI18nWrapperI18nextInstance(wrapperInstance: any): any;
+export declare function getActualI18nextInstance(instance: I18nInstance | any): any;
+export interface I18nInstance {
+    language: string;
+    isInitialized?: boolean;
+    init: {
+        (callback?: (error: any, t: any) => void): Promise<any>;
+        (options: I18nInitOptions, callback?: (error: any, t: any) => void): Promise<any>;
+    };
+    changeLanguage?: (lng?: string, callback?: (error: any, t: any) => void) => Promise<any>;
+    setLang?: (lang: string) => void | Promise<void>;
+    use: (plugin: any) => void;
+    createInstance?: (options?: I18nInitOptions) => I18nInstance;
+    cloneInstance?: () => I18nInstance;
+    store?: I18nResourceStore;
+    emit?: (event: string, ...args: any[]) => void;
+    reloadResources?: (language?: string, namespace?: string) => Promise<void>;
+    services?: {
+        languageDetector?: {
+            detect: (request?: any, options?: any) => string | string[] | undefined;
+            [key: string]: any;
+        };
+        resourceStore?: I18nResourceStore;
+        backend?: any;
+        [key: string]: any;
+    };
+    options?: {
+        backend?: BackendOptions;
+        [key: string]: any;
+    };
+    [key: string]: any;
+}
+type LanguageDetectorOrder = string[];
+type LanguageDetectorCaches = boolean | string[];
+export interface LanguageDetectorOptions {
+    order?: LanguageDetectorOrder;
+    lookupQuerystring?: string;
+    lookupCookie?: string;
+    lookupLocalStorage?: string;
+    lookupSession?: string;
+    lookupFromPathIndex?: number;
+    caches?: LanguageDetectorCaches;
+    cookieExpirationDate?: Date;
+    cookieDomain?: string;
+    lookupHeader?: string;
+}
+export interface BackendOptions extends Omit<BaseBackendOptions, 'enabled'> {
+    parse?: (data: string) => any;
+    stringify?: (data: any) => string;
+    [key: string]: any;
+}
+export interface Resources {
+    [lng: string]: {
+        [source: string]: string | Record<string, string>;
+    };
+}
+export type I18nInitOptions = {
+    lng?: string;
+    fallbackLng?: string;
+    supportedLngs?: string[];
+    initImmediate?: boolean;
+    detection?: LanguageDetectorOptions;
+    backend?: BackendOptions;
+    resources?: Resources;
+    ns?: string | string[];
+    defaultNS?: string | string[];
+    interpolation?: {
+        escapeValue?: boolean;
+        [key: string]: any;
+    };
+    react?: {
+        useSuspense?: boolean;
+        [key: string]: any;
+    };
+};
+export declare function isI18nInstance(obj: any): obj is I18nInstance;
+export declare function getI18nextInstanceForProvider(instance: I18nInstance | any): any;
+export declare function getI18nInstance(userInstance?: I18nInstance | any): Promise<I18nInstance>;
+export declare function getInitReactI18next(): Promise<InitReactI18next | null>;
+export declare function getI18nextProvider(): Promise<I18nextProviderComponent | null>;
+export {};