@bleedingdev/modern-js-plugin-i18n 3.5.0-ultramodern.4 → 3.5.0-ultramodern.40

package/dist/esm/runtime/i18n/detection/index.mjs

@@ -1,260 +1,4 @@
-import { isBrowser } from "@modern-js/runtime";
-import { detectLanguageFromPath } from "../../utils.mjs";
-import { isI18nWrapperInstance } from "../instance.mjs";
-import { mergeDetectionOptions } from "./config.mjs";
-import { cacheUserLanguage, detectLanguage, readLanguageFromStorage, useI18nextLanguageDetector } from "./middleware.mjs";
-const detectorInstanceCache = new WeakMap();
-const DETECTOR_SAFE_OPTION_KEYS = [
-    'lowerCaseLng',
-    'nonExplicitSupportedLngs',
-    'load',
-    'partialBundledLanguages',
-    'returnNull',
-    'returnEmptyString',
-    'returnObjects',
-    'joinArrays',
-    'keySeparator',
-    'nsSeparator',
-    'pluralSeparator',
-    'contextSeparator',
-    'fallbackNS',
-    'ns',
-    'defaultNS',
-    'debug'
-];
-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 sortedEntries = sortedKeys.map((key)=>{
-        const stringifiedValue = stableStringify(value[key]);
-        return `${JSON.stringify(key)}:${stringifiedValue}`;
-    });
-    return `{${sortedEntries.join(',')}}`;
-};
-const buildDetectorConfigKey = (languages, fallbackLanguage, mergedDetection)=>stableStringify({
-        languages,
-        fallbackLanguage,
-        detection: mergedDetection
-    });
-const pickSafeDetectionOptions = (userInitOptions)=>{
-    if (!userInitOptions) return {};
-    const safeOptions = {};
-    for (const key of DETECTOR_SAFE_OPTION_KEYS){
-        const value = userInitOptions[key];
-        if (void 0 !== value) safeOptions[key] = value;
-    }
-    if (userInitOptions.interpolation) safeOptions.interpolation = {
-        ...userInitOptions.interpolation
-    };
-    return safeOptions;
-};
-const cleanupDetectorCacheEntry = (entry)=>{
-    if (!entry || !entry.isTemporary) return;
-    const instance = entry.instance;
-    try {
-        instance?.removeAllListeners?.();
-    } catch (error) {}
-    try {
-        instance?.off?.('*');
-    } catch (error) {}
-    try {
-        instance?.services?.backendConnector?.backend?.stop?.();
-    } catch (error) {}
-    try {
-        instance?.services?.backendConnector?.backend?.close?.();
-    } catch (error) {}
-};
-function exportServerLngToWindow(context, lng) {
-    context.__i18nData__ = {
-        lng
-    };
-}
-const getLanguageFromSSRData = (window1)=>{
-    try {
-        const ssrData = window1._SSR_DATA;
-        if (!ssrData || !ssrData.data || !ssrData.data.i18nData) return;
-        const lng = ssrData.data.i18nData.lng;
-        return 'string' == typeof lng && '' !== lng.trim() ? lng : void 0;
-    } catch (error) {
-        return;
-    }
-};
-const normalizeLanguageCode = (language)=>{
-    if (!language) return language;
-    const baseLang = language.split('-')[0];
-    return baseLang;
-};
-const isLanguageSupported = (language, supportedLanguages)=>{
-    if (!language) return false;
-    if (0 === supportedLanguages.length) return true;
-    if (supportedLanguages.includes(language)) return true;
-    const baseLang = normalizeLanguageCode(language);
-    if (baseLang !== language && supportedLanguages.includes(baseLang)) return true;
-    return false;
-};
-const getSupportedLanguage = (language, supportedLanguages)=>{
-    if (!language) return;
-    if (0 === supportedLanguages.length) return language;
-    if (supportedLanguages.includes(language)) return language;
-    const baseLang = normalizeLanguageCode(language);
-    if (baseLang !== language && supportedLanguages.includes(baseLang)) return baseLang;
-};
-const detectLanguageFromSSR = (languages)=>{
-    if (!isBrowser()) return;
-    try {
-        const ssrLanguage = getLanguageFromSSRData(window);
-        if (ssrLanguage && isLanguageSupported(ssrLanguage, languages)) return ssrLanguage;
-    } catch (error) {}
-};
-const detectLanguageFromPathPriority = (pathname, languages, localePathRedirect)=>{
-    if (!localePathRedirect) return;
-    if (!languages || 0 === languages.length) return;
-    if (!pathname || '' === pathname.trim()) return;
-    try {
-        const pathDetection = detectLanguageFromPath(pathname, languages, localePathRedirect);
-        if (true === pathDetection.detected && pathDetection.language) return pathDetection.language;
-    } catch (error) {}
-};
-const createDetectorInstance = (baseInstance, configKey)=>{
-    const cached = detectorInstanceCache.get(baseInstance);
-    if (cached && cached.configKey === configKey) return {
-        instance: cached.instance,
-        isTemporary: cached.isTemporary
-    };
-    if (cached) {
-        cleanupDetectorCacheEntry(cached);
-        detectorInstanceCache.delete(baseInstance);
-    }
-    const createNewInstance = ()=>{
-        if ('function' == typeof baseInstance.createInstance) try {
-            const created = baseInstance.createInstance();
-            if (created) return {
-                instance: created,
-                isTemporary: true
-            };
-        } catch (error) {}
-        if ('function' == typeof baseInstance.cloneInstance) try {
-            const cloned = baseInstance.cloneInstance();
-            if (cloned) return {
-                instance: cloned,
-                isTemporary: true
-            };
-        } catch (error) {}
-        return {
-            instance: baseInstance,
-            isTemporary: false
-        };
-    };
-    const created = createNewInstance();
-    if (created.isTemporary) detectorInstanceCache.set(baseInstance, {
-        instance: created.instance,
-        isTemporary: true,
-        configKey
-    });
-    return created;
-};
-const initializeI18nForDetector = async (i18nInstance, options)=>{
-    const mergedDetection = detection_mergeDetectionOptions(options.i18nextDetector, options.detection, options.localePathRedirect, options.userInitOptions);
-    const configKey = buildDetectorConfigKey(options.languages, options.fallbackLanguage, mergedDetection);
-    const { instance, isTemporary } = createDetectorInstance(i18nInstance, configKey);
-    const safeUserOptions = pickSafeDetectionOptions(options.userInitOptions);
-    const initOptions = {
-        ...safeUserOptions,
-        fallbackLng: options.fallbackLanguage,
-        supportedLngs: options.languages,
-        detection: mergedDetection,
-        initImmediate: true,
-        interpolation: {
-            ...safeUserOptions?.interpolation || {},
-            escapeValue: safeUserOptions?.interpolation?.escapeValue ?? false
-        },
-        react: {
-            useSuspense: false
-        }
-    };
-    useI18nextLanguageDetector(instance);
-    if (instance.isInitialized) {
-        if (isTemporary) await instance.init(initOptions);
-    } else await instance.init(initOptions);
-    return {
-        detectorInstance: instance,
-        isTemporary
-    };
-};
-const detectLanguageFromI18nextDetector = async (i18nInstance, options)=>{
-    if (!options.i18nextDetector) return;
-    const mergedDetection = detection_mergeDetectionOptions(options.i18nextDetector, options.detection, options.localePathRedirect, options.userInitOptions);
-    const { detectorInstance, isTemporary } = await initializeI18nForDetector(i18nInstance, options);
-    try {
-        const request = options.ssrContext?.request;
-        if (!isBrowser() && !request) return;
-        const detectorLang = detectLanguage(detectorInstance, request, mergedDetection);
-        if (detectorLang) {
-            const supportedLang = getSupportedLanguage(detectorLang, options.languages);
-            if (supportedLang) return supportedLang;
-        }
-        if (detectorInstance.isInitialized && detectorInstance.language) {
-            const currentLang = detectorInstance.language;
-            if (isLanguageSupported(currentLang, options.languages)) return currentLang;
-        }
-    } catch (error) {} finally{
-        if (isTemporary && detectorInstance !== i18nInstance) detectorInstanceCache.set(i18nInstance, {
-            instance: detectorInstance,
-            isTemporary: true,
-            configKey: buildDetectorConfigKey(options.languages, options.fallbackLanguage, mergedDetection)
-        });
-        else if (detectorInstance === i18nInstance) {
-            i18nInstance.isInitialized = false;
-            delete i18nInstance.language;
-        }
-    }
-};
-const detectLanguageWithPriority = async (i18nInstance, options)=>{
-    const { languages, fallbackLanguage, localePathRedirect, i18nextDetector, detection, userInitOptions, pathname, ssrContext } = options;
-    let detectedLanguage;
-    detectedLanguage = detectLanguageFromSSR(languages);
-    if (!detectedLanguage) detectedLanguage = detectLanguageFromPathPriority(pathname, languages, localePathRedirect);
-    if (!detectedLanguage && i18nextDetector) detectedLanguage = isI18nWrapperInstance(i18nInstance) ? readLanguageFromStorage(detection_mergeDetectionOptions(i18nextDetector, detection, localePathRedirect, userInitOptions)) : await detectLanguageFromI18nextDetector(i18nInstance, {
-        languages,
-        fallbackLanguage,
-        localePathRedirect,
-        i18nextDetector,
-        detection,
-        userInitOptions,
-        mergedBackend: options.mergedBackend,
-        ssrContext
-    });
-    const finalLanguage = detectedLanguage || userInitOptions?.lng || fallbackLanguage;
-    return {
-        detectedLanguage,
-        finalLanguage
-    };
-};
-const buildInitOptions = (params)=>{
-    const { finalLanguage, fallbackLanguage, languages, userInitOptions, mergedDetection, mergeBackend } = params;
-    return {
-        ...userInitOptions || {},
-        lng: finalLanguage,
-        fallbackLng: fallbackLanguage,
-        supportedLngs: languages,
-        detection: mergedDetection,
-        backend: mergeBackend,
-        interpolation: {
-            ...userInitOptions?.interpolation || {},
-            escapeValue: userInitOptions?.interpolation?.escapeValue ?? false
-        },
-        react: {
-            useSuspense: isBrowser()
-        }
-    };
-};
-const detection_mergeDetectionOptions = (i18nextDetector, detection, localePathRedirect, userInitOptions)=>{
-    let mergedDetection;
-    mergedDetection = i18nextDetector ? mergeDetectionOptions(detection, userInitOptions?.detection) : userInitOptions?.detection || {};
-    if (!mergedDetection || 'object' != typeof mergedDetection) mergedDetection = {};
-    if (localePathRedirect && mergedDetection.order) mergedDetection.order = mergedDetection.order.filter((item)=>'path' !== item);
-    return mergedDetection;
-};
-export { buildInitOptions, cacheUserLanguage, detectLanguageWithPriority, detection_mergeDetectionOptions as mergeDetectionOptions, exportServerLngToWindow, getLanguageFromSSRData };
+export { buildInitOptions, mergeDetectionOptions } from "./initOptions.mjs";
+export { cacheUserLanguage } from "./middleware.mjs";
+export { detectLanguageWithPriority } from "./priority.mjs";
+export { exportServerLngToWindow, getLanguageFromSSRData } from "./ssr.mjs";

package/dist/esm/runtime/i18n/detection/initOptions.mjs

@@ -0,0 +1,28 @@
+import { isBrowser } from "@modern-js/runtime";
+import { mergeDetectionOptions } from "./config.mjs";
+const buildInitOptions = (params)=>{
+    const { finalLanguage, fallbackLanguage, languages, userInitOptions, mergedDetection, mergeBackend } = params;
+    return {
+        ...userInitOptions || {},
+        lng: finalLanguage,
+        fallbackLng: fallbackLanguage,
+        supportedLngs: languages,
+        detection: mergedDetection,
+        backend: mergeBackend,
+        interpolation: {
+            ...userInitOptions?.interpolation || {},
+            escapeValue: userInitOptions?.interpolation?.escapeValue ?? false
+        },
+        react: {
+            useSuspense: isBrowser()
+        }
+    };
+};
+const initOptions_mergeDetectionOptions = (i18nextDetector, detection, localePathRedirect, userInitOptions)=>{
+    let mergedDetection;
+    mergedDetection = i18nextDetector ? mergeDetectionOptions(detection, userInitOptions?.detection) : userInitOptions?.detection || {};
+    if (!mergedDetection || 'object' != typeof mergedDetection) mergedDetection = {};
+    if (localePathRedirect && mergedDetection.order) mergedDetection.order = mergedDetection.order.filter((item)=>'path' !== item);
+    return mergedDetection;
+};
+export { buildInitOptions, initOptions_mergeDetectionOptions as mergeDetectionOptions };

package/dist/esm/runtime/i18n/detection/language.mjs

@@ -0,0 +1,21 @@
+const normalizeLanguageCode = (language)=>{
+    if (!language) return language;
+    const baseLang = language.split('-')[0];
+    return baseLang;
+};
+const isLanguageSupported = (language, supportedLanguages)=>{
+    if (!language) return false;
+    if (0 === supportedLanguages.length) return true;
+    if (supportedLanguages.includes(language)) return true;
+    const baseLang = normalizeLanguageCode(language);
+    if (baseLang !== language && supportedLanguages.includes(baseLang)) return true;
+    return false;
+};
+const getSupportedLanguage = (language, supportedLanguages)=>{
+    if (!language) return;
+    if (0 === supportedLanguages.length) return language;
+    if (supportedLanguages.includes(language)) return language;
+    const baseLang = normalizeLanguageCode(language);
+    if (baseLang !== language && supportedLanguages.includes(baseLang)) return baseLang;
+};
+export { getSupportedLanguage, isLanguageSupported };

package/dist/esm/runtime/i18n/detection/path.mjs

@@ -0,0 +1,11 @@
+import { detectLanguageFromPath } from "../../utils.mjs";
+const detectLanguageFromPathPriority = (pathname, languages, localePathRedirect)=>{
+    if (!localePathRedirect) return;
+    if (!languages || 0 === languages.length) return;
+    if (!pathname || '' === pathname.trim()) return;
+    try {
+        const pathDetection = detectLanguageFromPath(pathname, languages, localePathRedirect);
+        if (true === pathDetection.detected && pathDetection.language) return pathDetection.language;
+    } catch (error) {}
+};
+export { detectLanguageFromPathPriority };

package/dist/esm/runtime/i18n/detection/priority.mjs

@@ -0,0 +1,28 @@
+import { isI18nWrapperInstance } from "../instance.mjs";
+import { detectLanguageFromI18nextDetector } from "./detector.mjs";
+import { mergeDetectionOptions } from "./initOptions.mjs";
+import { readLanguageFromStorage } from "./middleware.mjs";
+import { detectLanguageFromPathPriority } from "./path.mjs";
+import { detectLanguageFromSSR } from "./ssr.mjs";
+const detectLanguageWithPriority = async (i18nInstance, options)=>{
+    const { languages, fallbackLanguage, localePathRedirect, i18nextDetector, detection, userInitOptions, pathname, ssrContext } = options;
+    let detectedLanguage;
+    detectedLanguage = detectLanguageFromPathPriority(pathname, languages, localePathRedirect);
+    if (!detectedLanguage) detectedLanguage = detectLanguageFromSSR(languages);
+    if (!detectedLanguage && i18nextDetector) detectedLanguage = isI18nWrapperInstance(i18nInstance) ? readLanguageFromStorage(mergeDetectionOptions(i18nextDetector, detection, localePathRedirect, userInitOptions)) : await detectLanguageFromI18nextDetector(i18nInstance, {
+        languages,
+        fallbackLanguage,
+        localePathRedirect,
+        i18nextDetector,
+        detection,
+        userInitOptions,
+        mergedBackend: options.mergedBackend,
+        ssrContext
+    });
+    const finalLanguage = detectedLanguage || userInitOptions?.lng || fallbackLanguage;
+    return {
+        detectedLanguage,
+        finalLanguage
+    };
+};
+export { detectLanguageWithPriority };

package/dist/esm/runtime/i18n/detection/ssr.mjs

@@ -0,0 +1,26 @@
+import { isBrowser } from "@modern-js/runtime";
+import { getSupportedLanguage } from "./language.mjs";
+function exportServerLngToWindow(context, lng) {
+    context.__i18nData__ = {
+        lng
+    };
+}
+const getLanguageFromSSRData = (window1)=>{
+    try {
+        const ssrData = window1._SSR_DATA;
+        if (!ssrData || !ssrData.data || !ssrData.data.i18nData) return;
+        const lng = ssrData.data.i18nData.lng;
+        return 'string' == typeof lng && '' !== lng.trim() ? lng : void 0;
+    } catch (error) {
+        return;
+    }
+};
+const detectLanguageFromSSR = (languages)=>{
+    if (!isBrowser()) return;
+    try {
+        const ssrLanguage = getLanguageFromSSRData(window);
+        const supportedLanguage = getSupportedLanguage(ssrLanguage, languages);
+        if (supportedLanguage) return supportedLanguage;
+    } catch (error) {}
+};
+export { detectLanguageFromSSR, exportServerLngToWindow, getLanguageFromSSRData };

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

@@ -1,8 +1,10 @@
 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) {
@@ -19,7 +21,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 {
@@ -56,4 +59,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/runtime/linkHelpers.mjs

@@ -0,0 +1,98 @@
+const warnedTargets = new Set();
+const warnOnce = (key, message)=>{
+    if ('development' !== process.env.NODE_ENV || warnedTargets.has(key)) return;
+    warnedTargets.add(key);
+    console.warn(message);
+};
+const interpolateRouteParams = (pathname, params)=>{
+    if (!/[$:*{]/.test(pathname)) return pathname;
+    const resolveParam = (name)=>{
+        const value = params?.[name];
+        return void 0 === value ? void 0 : String(value);
+    };
+    const segments = pathname.split('/').map((segment)=>{
+        if (!segment) return segment;
+        if (segment.startsWith('{-$') && segment.endsWith('}')) {
+            const value = resolveParam(segment.slice(3, -1));
+            return void 0 === value ? null : encodeURIComponent(value);
+        }
+        if ('$' === segment || '*' === segment) {
+            const value = resolveParam('_splat') ?? resolveParam('*');
+            return void 0 === value ? null : value.split('/').map(encodeURIComponent).join('/');
+        }
+        if (segment.startsWith('$')) {
+            const value = resolveParam(segment.slice(1));
+            if (void 0 === value) {
+                warnOnce(`missing-param:${pathname}:${segment}`, `[plugin-i18n] <Link to="${pathname}"> is missing required param "${segment.slice(1)}".`);
+                return segment;
+            }
+            return encodeURIComponent(value);
+        }
+        if (segment.startsWith(':')) {
+            const optional = segment.endsWith('?');
+            const name = segment.slice(1, optional ? -1 : void 0);
+            const value = resolveParam(name);
+            if (void 0 === value) {
+                if (optional) return null;
+                warnOnce(`missing-param:${pathname}:${segment}`, `[plugin-i18n] <Link to="${pathname}"> is missing required param "${name}".`);
+                return segment;
+            }
+            return encodeURIComponent(value);
+        }
+        return segment;
+    }).filter((segment)=>null !== segment);
+    return segments.join('/') || '/';
+};
+const normalizeSearch = (search, searchFromTo)=>{
+    if (search && 'object' == typeof search) {
+        const searchObject = {};
+        const params = new URLSearchParams();
+        for (const [key, value] of Object.entries(search)){
+            if (null == value) continue;
+            if (Array.isArray(value)) {
+                const values = value.filter((item)=>null != item).map(String);
+                if (0 === values.length) continue;
+                searchObject[key] = values;
+                for (const item of values)params.append(key, item);
+                continue;
+            }
+            const stringValue = String(value);
+            searchObject[key] = stringValue;
+            params.append(key, stringValue);
+        }
+        const serialized = params.toString();
+        return {
+            searchString: serialized ? `?${serialized}` : '',
+            searchObject: Object.keys(searchObject).length > 0 ? searchObject : void 0
+        };
+    }
+    const raw = 'string' == typeof search ? search : searchFromTo;
+    if (!raw) return {
+        searchString: '',
+        searchObject: void 0
+    };
+    const searchString = raw.startsWith('?') ? raw : `?${raw}`;
+    const searchObject = {};
+    new URLSearchParams(searchString).forEach((value, key)=>{
+        const existing = searchObject[key];
+        if (void 0 === existing) searchObject[key] = value;
+        else if (Array.isArray(existing)) existing.push(value);
+        else searchObject[key] = [
+            existing,
+            value
+        ];
+    });
+    return {
+        searchString,
+        searchObject
+    };
+};
+const splitActiveProps = (active, activeProps)=>{
+    if (!active || !activeProps) return {};
+    return activeProps;
+};
+const mergeClassNames = (...values)=>{
+    const classNames = values.filter((value)=>'string' == typeof value && value.length > 0);
+    return classNames.length > 0 ? classNames.join(' ') : void 0;
+};
+export { interpolateRouteParams, mergeClassNames, normalizeSearch, splitActiveProps, warnOnce };

package/dist/esm/runtime/pluginSetup.mjs

@@ -0,0 +1,64 @@
+import { isBrowser } from "@modern-js/runtime";
+import { merge } from "@modern-js/runtime-utils/merge";
+import { getI18nInstance } from "./i18n/index.mjs";
+import { mergeBackendOptions } from "./i18n/backend/index.mjs";
+import { detectLanguageWithPriority, exportServerLngToWindow, mergeDetectionOptions } from "./i18n/detection/index.mjs";
+import { useI18nextLanguageDetector } from "./i18n/detection/middleware.mjs";
+import { getPathname } from "./utils.mjs";
+let i18nLifecycleHelpersPromise;
+function loadI18nLifecycleHelpers() {
+    i18nLifecycleHelpersPromise ??= Promise.all([
+        import("./i18n/backend/middleware.mjs"),
+        import("./i18n/utils.mjs")
+    ]).then(([backendMiddleware, utils])=>({
+            useI18nextBackend: backendMiddleware.useI18nextBackend,
+            changeI18nLanguage: utils.changeI18nLanguage,
+            ensureLanguageMatch: utils.ensureLanguageMatch,
+            initializeI18nInstance: utils.initializeI18nInstance,
+            setupClonedInstance: utils.setupClonedInstance
+        }));
+    return i18nLifecycleHelpersPromise;
+}
+async function setupI18nBeforeRender(context, options) {
+    const { api, userI18nInstance, initOptions, backend, backendEnabled, i18nextDetector, detection, localePathRedirect, languages, fallbackLanguage, resolveReactI18nextIntegration, setI18nextProvider } = options;
+    const { useI18nextBackend, changeI18nLanguage, ensureLanguageMatch, initializeI18nInstance, setupClonedInstance } = await loadI18nLifecycleHelpers();
+    let i18nInstance = await getI18nInstance(userI18nInstance);
+    const { i18n: otherConfig } = api.getRuntimeConfig();
+    const { initOptions: otherInitOptions } = otherConfig || {};
+    const userInitOptions = merge(otherInitOptions || {}, initOptions || {});
+    const reactI18nextIntegration = await resolveReactI18nextIntegration();
+    setI18nextProvider(reactI18nextIntegration?.I18nextProvider ?? null);
+    if (reactI18nextIntegration?.initReactI18next) i18nInstance.use(reactI18nextIntegration.initReactI18next);
+    const pathname = getPathname(context);
+    if (i18nextDetector) useI18nextLanguageDetector(i18nInstance);
+    const mergedDetection = mergeDetectionOptions(i18nextDetector, detection, localePathRedirect, userInitOptions);
+    const mergedBackend = mergeBackendOptions(backend, userInitOptions);
+    const hasSdkConfig = 'function' == typeof userInitOptions?.backend?.sdk || mergedBackend?.sdk && 'function' == typeof mergedBackend.sdk;
+    if (mergedBackend && (backendEnabled || hasSdkConfig)) useI18nextBackend(i18nInstance, mergedBackend);
+    const { finalLanguage } = await detectLanguageWithPriority(i18nInstance, {
+        languages,
+        fallbackLanguage,
+        localePathRedirect,
+        i18nextDetector,
+        detection,
+        userInitOptions,
+        mergedBackend,
+        pathname,
+        ssrContext: context.ssrContext
+    });
+    await initializeI18nInstance(i18nInstance, finalLanguage, fallbackLanguage, languages, mergedDetection, mergedBackend, userInitOptions);
+    if (!isBrowser() && i18nInstance.cloneInstance) {
+        i18nInstance = i18nInstance.cloneInstance();
+        await setupClonedInstance(i18nInstance, finalLanguage, fallbackLanguage, languages, backendEnabled, backend, i18nextDetector, detection, localePathRedirect, userInitOptions);
+    }
+    if (localePathRedirect) await ensureLanguageMatch(i18nInstance, finalLanguage);
+    if (!isBrowser()) exportServerLngToWindow(context, finalLanguage);
+    context.i18nInstance = i18nInstance;
+    context.changeLanguage = async (newLang)=>{
+        await changeI18nLanguage(i18nInstance, newLang, {
+            detectionOptions: mergedDetection
+        });
+    };
+    return i18nInstance;
+}
+export { setupI18nBeforeRender };

package/dist/esm/runtime/providerComposition.mjs

@@ -0,0 +1,76 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { RuntimeContext } from "@modern-js/runtime";
+import { Helmet } from "@modern-js/runtime/head";
+import { useContext, useEffect, useMemo, useRef, useState } from "react";
+import { ModernI18nProvider } from "./context.mjs";
+import { createContextValue, useClientSideRedirect, useLanguageSync, useSdkResourcesLoader } from "./hooks.mjs";
+import { getI18nextInstanceForProvider } from "./i18n/instance.mjs";
+const createI18nRootWrapper = (options)=>(App)=>(props)=>{
+            const { entryName, htmlLangAttr, localePathRedirect, languages, fallbackLanguage, ignoreRedirectRoutes, localisedUrls, getLatestI18nInstance, getI18nextProvider } = options;
+            const runtimeContext = useContext(RuntimeContext);
+            const i18nInstance = runtimeContext.i18nInstance || getLatestI18nInstance();
+            const initialLang = useMemo(()=>i18nInstance?.language || fallbackLanguage, [
+                i18nInstance?.language,
+                fallbackLanguage
+            ]);
+            const [lang, setLang] = useState(initialLang);
+            const [forceUpdate, setForceUpdate] = useState(0);
+            const prevLangRef = useRef(lang);
+            const runtimeContextRef = useRef(runtimeContext);
+            runtimeContextRef.current = runtimeContext;
+            useEffect(()=>{
+                if (i18nInstance?.language) {
+                    const translator = i18nInstance.translator;
+                    if (translator) translator.language = i18nInstance.language;
+                }
+            }, [
+                i18nInstance?.language
+            ]);
+            useEffect(()=>{
+                prevLangRef.current = lang;
+            }, [
+                lang
+            ]);
+            useSdkResourcesLoader(i18nInstance, setForceUpdate);
+            useLanguageSync(i18nInstance, localePathRedirect, languages, runtimeContextRef, prevLangRef, setLang);
+            useClientSideRedirect(i18nInstance, localePathRedirect, languages, fallbackLanguage, ignoreRedirectRoutes, localisedUrls);
+            const contextValue = useMemo(()=>createContextValue(lang, i18nInstance, entryName, languages, localePathRedirect, ignoreRedirectRoutes, localisedUrls, setLang), [
+                lang,
+                i18nInstance,
+                entryName,
+                languages,
+                localePathRedirect,
+                ignoreRedirectRoutes,
+                localisedUrls,
+                forceUpdate
+            ]);
+            const children = props.children;
+            let appContent = App ? /*#__PURE__*/ jsx(App, {
+                ...props,
+                children: children
+            }) : children;
+            if (i18nInstance) {
+                const I18nextProvider = getI18nextProvider();
+                if (I18nextProvider) {
+                    const i18nextInstanceForProvider = getI18nextInstanceForProvider(i18nInstance);
+                    appContent = /*#__PURE__*/ jsx(I18nextProvider, {
+                        i18n: i18nextInstanceForProvider,
+                        children: appContent
+                    });
+                }
+            }
+            return /*#__PURE__*/ jsxs(Fragment, {
+                children: [
+                    Boolean(htmlLangAttr) && /*#__PURE__*/ jsx(Helmet, {
+                        htmlAttributes: {
+                            lang
+                        }
+                    }),
+                    /*#__PURE__*/ jsx(ModernI18nProvider, {
+                        value: contextValue,
+                        children: appContent
+                    })
+                ]
+            });
+        };
+export { createI18nRootWrapper };

package/dist/esm/runtime/reactI18next.mjs

@@ -0,0 +1,5 @@
+const resolveReactI18nextIntegration = async (reactI18next, loadReactI18nextIntegration)=>{
+    if (!reactI18next) return null;
+    return loadReactI18nextIntegration?.() ?? null;
+};
+export { resolveReactI18nextIntegration };