@bleedingdev/modern-js-plugin-i18n 3.2.0-ultramodern.0

package/dist/esm/runtime/context.mjs

@@ -0,0 +1,105 @@
+import { jsx } from "react/jsx-runtime";
+import { isBrowser } from "@modern-js/runtime";
+import { createContext, useCallback, useContext, useMemo } from "react";
+import { cacheUserLanguage } from "./i18n/detection/index.mjs";
+import { buildLocalizedUrl, detectLanguageFromPath, getEntryPath, shouldIgnoreRedirect, useRouterHooks } from "./utils.mjs";
+const ModernI18nContext = /*#__PURE__*/ createContext(null);
+const ModernI18nProvider = ({ children, value })=>/*#__PURE__*/ jsx(ModernI18nContext.Provider, {
+        value: value,
+        children: children
+    });
+const useModernI18n = ()=>{
+    const context = useContext(ModernI18nContext);
+    if (!context) throw new Error('useModernI18n must be used within a ModernI18nProvider');
+    const { language: contextLanguage, i18nInstance, languages, localePathRedirect, ignoreRedirectRoutes, updateLanguage } = context;
+    const { navigate, location, hasRouter } = useRouterHooks();
+    const currentLanguage = contextLanguage;
+    const changeLanguage = useCallback(async (newLang)=>{
+        try {
+            if (!newLang || 'string' != typeof newLang) throw new Error('Language must be a non-empty string');
+            await i18nInstance?.setLang?.(newLang);
+            await i18nInstance?.changeLanguage?.(newLang);
+            if (isBrowser()) {
+                const detectionOptions = i18nInstance.options?.detection;
+                cacheUserLanguage(i18nInstance, newLang, detectionOptions);
+            }
+            if (localePathRedirect && isBrowser() && hasRouter && navigate && location) {
+                const currentPath = location.pathname;
+                const entryPath = getEntryPath();
+                const relativePath = currentPath.replace(entryPath, '');
+                const pathLanguage = detectLanguageFromPath(currentPath, languages || [], localePathRedirect);
+                if (pathLanguage.detected && pathLanguage.language === newLang) return;
+                if (!shouldIgnoreRedirect(relativePath, languages || [], ignoreRedirectRoutes)) {
+                    const newPath = buildLocalizedUrl(relativePath, newLang, languages || []);
+                    const newUrl = entryPath + newPath + location.search + location.hash;
+                    await navigate(newUrl, {
+                        replace: true
+                    });
+                }
+            } else if (localePathRedirect && isBrowser() && !hasRouter) {
+                const currentPath = window.location.pathname;
+                const entryPath = getEntryPath();
+                const relativePath = currentPath.replace(entryPath, '');
+                const pathLanguage = detectLanguageFromPath(currentPath, languages || [], localePathRedirect);
+                if (pathLanguage.detected && pathLanguage.language === newLang) return;
+                if (!shouldIgnoreRedirect(relativePath, languages || [], ignoreRedirectRoutes)) {
+                    const newPath = buildLocalizedUrl(relativePath, newLang, languages || []);
+                    const newUrl = entryPath + newPath + window.location.search + window.location.hash;
+                    window.history.pushState(null, '', newUrl);
+                }
+            }
+            if (updateLanguage) updateLanguage(newLang);
+        } catch (error) {
+            console.error('Failed to change language:', error);
+            throw error;
+        }
+    }, [
+        i18nInstance,
+        updateLanguage,
+        localePathRedirect,
+        ignoreRedirectRoutes,
+        languages,
+        hasRouter,
+        navigate,
+        location
+    ]);
+    const isLanguageSupported = useCallback((lang)=>languages?.includes(lang) || false, [
+        languages
+    ]);
+    const isResourcesReady = useMemo(()=>{
+        if (!i18nInstance?.isInitialized) return false;
+        const backend = i18nInstance?.services?.backend;
+        if (backend && 'function' == typeof backend.isLoading) {
+            const loadingResources = backend.getLoadingResources();
+            const isCurrentLanguageLoading = loadingResources.some(({ language })=>language === currentLanguage);
+            if (isCurrentLanguageLoading) return false;
+        }
+        const store = i18nInstance.store;
+        if (!store?.data) return false;
+        const langData = store.data[currentLanguage];
+        if (!langData || 'object' != typeof langData) return false;
+        const options = i18nInstance.options;
+        const namespaces = options?.ns || options?.defaultNS || [
+            'translation'
+        ];
+        const requiredNamespaces = Array.isArray(namespaces) ? namespaces : [
+            namespaces
+        ];
+        return requiredNamespaces.every((ns)=>{
+            const nsData = langData[ns];
+            return nsData && 'object' == typeof nsData && Object.keys(nsData).length > 0;
+        });
+    }, [
+        currentLanguage,
+        i18nInstance
+    ]);
+    return {
+        language: currentLanguage,
+        changeLanguage,
+        i18nInstance,
+        supportedLanguages: languages || [],
+        isLanguageSupported,
+        isResourcesReady
+    };
+};
+export { ModernI18nProvider, useModernI18n };

package/dist/esm/runtime/hooks.mjs

@@ -0,0 +1,151 @@
+import { isBrowser } from "@modern-js/runtime";
+import { useEffect, useRef } from "react";
+import { I18N_SDK_RESOURCES_LOADED_EVENT, getI18nSdkBackendId } from "./i18n/backend/sdk-event.mjs";
+import { cacheUserLanguage } from "./i18n/detection/index.mjs";
+import { buildLocalizedUrl, detectLanguageFromPath, getEntryPath, getPathname, shouldIgnoreRedirect, useRouterHooks } from "./utils.mjs";
+function createMinimalI18nInstance(language) {
+    const minimalInstance = {
+        language,
+        isInitialized: false,
+        init: ()=>Promise.resolve(void 0),
+        use: ()=>{},
+        createInstance: ()=>minimalInstance,
+        services: {}
+    };
+    return minimalInstance;
+}
+function createContextValue(lang, i18nInstance, entryName, languages, localePathRedirect, ignoreRedirectRoutes, setLang) {
+    const instance = i18nInstance || createMinimalI18nInstance(lang);
+    return {
+        language: lang,
+        i18nInstance: instance,
+        entryName,
+        languages,
+        localePathRedirect,
+        ignoreRedirectRoutes,
+        updateLanguage: setLang
+    };
+}
+function useSdkResourcesLoader(i18nInstance, setForceUpdate) {
+    useEffect(()=>{
+        if (!i18nInstance || !isBrowser()) return;
+        const backendId = getI18nSdkBackendId(i18nInstance.services?.resourceStore) || getI18nSdkBackendId(i18nInstance.services?.store) || getI18nSdkBackendId(i18nInstance.store);
+        if (!backendId) return;
+        const handleSdkResourcesLoaded = (event)=>{
+            const customEvent = event;
+            const { language, namespace, backendId: eventBackendId } = customEvent.detail || {};
+            if (!language || !namespace) return;
+            if (eventBackendId && eventBackendId !== backendId) return;
+            const triggerUpdate = (retryCount = 0)=>{
+                const store = i18nInstance.store;
+                const hasResource = store?.data?.[language]?.[namespace];
+                if (hasResource || retryCount >= 10) {
+                    if (store?.data?.[language]?.[namespace]) {
+                        if ('function' == typeof store.emit) store.emit('added', language, namespace);
+                    }
+                    if ('function' == typeof i18nInstance.emit) {
+                        i18nInstance.emit('loaded', {
+                            language,
+                            namespace
+                        });
+                        i18nInstance.emit('loaded', language, namespace);
+                    }
+                    if ('function' == typeof i18nInstance.reloadResources) i18nInstance.reloadResources(language, namespace).then(()=>{
+                        if ('function' == typeof i18nInstance.emit) i18nInstance.emit('loaded', {
+                            language,
+                            namespace
+                        });
+                        setForceUpdate((prev)=>prev + 1);
+                    }).catch(()=>{});
+                    if ('function' == typeof i18nInstance.emit) i18nInstance.emit('languageChanged', language);
+                    setForceUpdate((prev)=>prev + 1);
+                } else setTimeout(()=>triggerUpdate(retryCount + 1), 10);
+            };
+            triggerUpdate();
+        };
+        window.addEventListener(I18N_SDK_RESOURCES_LOADED_EVENT, handleSdkResourcesLoaded);
+        return ()=>{
+            window.removeEventListener(I18N_SDK_RESOURCES_LOADED_EVENT, handleSdkResourcesLoaded);
+        };
+    }, [
+        i18nInstance,
+        setForceUpdate
+    ]);
+}
+function useClientSideRedirect(i18nInstance, localePathRedirect, languages, fallbackLanguage, ignoreRedirectRoutes) {
+    const hasRedirectedRef = useRef(false);
+    const { navigate, location, hasRouter } = useRouterHooks();
+    useEffect(()=>{
+        if ('browser' !== process.env.MODERN_TARGET) return;
+        if (!localePathRedirect || !i18nInstance) return;
+        try {
+            const ssrData = window._SSR_DATA;
+            if (ssrData) return;
+        } catch  {}
+        if (hasRedirectedRef.current) return;
+        if (!i18nInstance.isInitialized) return;
+        const currentPathname = hasRouter && location ? location.pathname : window.location.pathname;
+        const currentSearch = hasRouter && location ? location.search : window.location.search;
+        const currentHash = hasRouter && location ? location.hash : window.location.hash;
+        const entryPath = getEntryPath();
+        const relativePath = currentPathname.replace(entryPath, '');
+        if (shouldIgnoreRedirect(relativePath, languages, ignoreRedirectRoutes)) return;
+        const pathDetection = detectLanguageFromPath(currentPathname, languages, localePathRedirect);
+        if (pathDetection.detected) return;
+        const targetLanguage = i18nInstance.language || fallbackLanguage || languages[0] || 'en';
+        const newPath = buildLocalizedUrl(relativePath, targetLanguage, languages);
+        const newUrl = entryPath + newPath + currentSearch + currentHash;
+        if (newUrl !== currentPathname + currentSearch + currentHash) {
+            hasRedirectedRef.current = true;
+            if (hasRouter && navigate && location) navigate(newUrl, {
+                replace: true
+            });
+            else window.location.replace(newUrl);
+        }
+    }, [
+        navigate,
+        location,
+        hasRouter,
+        localePathRedirect,
+        i18nInstance,
+        languages,
+        fallbackLanguage,
+        ignoreRedirectRoutes
+    ]);
+}
+function useLanguageSync(i18nInstance, localePathRedirect, languages, runtimeContextRef, prevLangRef, setLang) {
+    useEffect(()=>{
+        if (!i18nInstance) return;
+        if (localePathRedirect) {
+            const currentPathname = getPathname(runtimeContextRef.current);
+            const pathDetection = detectLanguageFromPath(currentPathname, languages, localePathRedirect);
+            if (pathDetection.detected && pathDetection.language) {
+                const currentLang = pathDetection.language;
+                if (currentLang !== prevLangRef.current) {
+                    prevLangRef.current = currentLang;
+                    setLang(currentLang);
+                    i18nInstance.setLang?.(currentLang);
+                    i18nInstance.changeLanguage?.(currentLang);
+                    if (isBrowser()) {
+                        const detectionOptions = i18nInstance.options?.detection;
+                        cacheUserLanguage(i18nInstance, currentLang, detectionOptions);
+                    }
+                }
+            }
+        } else {
+            const instanceLang = i18nInstance.language;
+            if (instanceLang && instanceLang !== prevLangRef.current) {
+                prevLangRef.current = instanceLang;
+                setLang(instanceLang);
+            }
+        }
+    }, [
+        i18nInstance,
+        localePathRedirect,
+        languages,
+        runtimeContextRef,
+        prevLangRef,
+        setLang
+    ]);
+}
+export { createContextValue, useClientSideRedirect, useLanguageSync, useSdkResourcesLoader };

package/dist/esm/runtime/i18n/backend/config.mjs

@@ -0,0 +1,5 @@
+import { deepMerge } from "../../../shared/deepMerge.mjs";
+function mergeBackendOptions(defaultOptions, cliOptions = {}, userOptions) {
+    return deepMerge(deepMerge(defaultOptions, cliOptions), userOptions ?? {});
+}
+export { mergeBackendOptions };

package/dist/esm/runtime/i18n/backend/defaults.mjs

@@ -0,0 +1,19 @@
+const DEFAULT_I18NEXT_BACKEND_OPTIONS = {
+    loadPath: '/locales/{{lng}}/{{ns}}.json',
+    addPath: '/locales/{{lng}}/{{ns}}.json'
+};
+function convertPath(path) {
+    if (!path) return path;
+    if (path.startsWith('/')) return `${window.__assetPrefix__ || ''}${path}`;
+    return path;
+}
+function convertBackendOptions(options) {
+    if (!options) return options;
+    const converted = {
+        ...options
+    };
+    if (converted.loadPath) converted.loadPath = convertPath(converted.loadPath);
+    if (converted.addPath) converted.addPath = convertPath(converted.addPath);
+    return converted;
+}
+export { DEFAULT_I18NEXT_BACKEND_OPTIONS, convertBackendOptions };

package/dist/esm/runtime/i18n/backend/defaults.node.mjs

@@ -0,0 +1,19 @@
+const DEFAULT_I18NEXT_BACKEND_OPTIONS = {
+    loadPath: './locales/{{lng}}/{{ns}}.json',
+    addPath: './locales/{{lng}}/{{ns}}.json'
+};
+function convertPath(path) {
+    if (!path) return path;
+    if (path.startsWith('/')) return `.${path}`;
+    return path;
+}
+function convertBackendOptions(options) {
+    if (!options) return options;
+    const converted = {
+        ...options
+    };
+    if (converted.loadPath) converted.loadPath = convertPath(converted.loadPath);
+    if (converted.addPath) converted.addPath = convertPath(converted.addPath);
+    return converted;
+}
+export { DEFAULT_I18NEXT_BACKEND_OPTIONS, convertBackendOptions };

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

@@ -0,0 +1,74 @@
+import { mergeBackendOptions } from "./config.mjs";
+import { DEFAULT_I18NEXT_BACKEND_OPTIONS, convertBackendOptions } from "./defaults.mjs";
+function hasSdkFunction(backend, userInitOptions) {
+    return 'function' == typeof userInitOptions?.backend?.sdk || !!backend?.enabled && !!backend?.sdk && 'function' == typeof backend.sdk;
+}
+function hasLoadPath(backend, userInitOptions) {
+    const userLoadPath = userInitOptions?.backend?.loadPath ?? backend?.loadPath;
+    const isExplicit = !!userLoadPath && '' !== userLoadPath;
+    const hasPath = isExplicit || !!backend?.enabled && void 0 === userLoadPath;
+    return {
+        hasPath,
+        isExplicit
+    };
+}
+function ensureDefaultLoadPath(merged, backend, isExplicitLoadPath = false) {
+    if (backend?.enabled && !isExplicitLoadPath && !merged.loadPath) {
+        merged.loadPath = DEFAULT_I18NEXT_BACKEND_OPTIONS.loadPath;
+        merged.addPath = DEFAULT_I18NEXT_BACKEND_OPTIONS.addPath;
+    }
+}
+function getFinalLoadPath(mergedOptions, backend, userInitOptions) {
+    return mergedOptions?.loadPath || userInitOptions?.backend?.loadPath || (backend?.enabled ? DEFAULT_I18NEXT_BACKEND_OPTIONS.loadPath : void 0);
+}
+function getFinalSdk(mergedOptions, backend, userInitOptions) {
+    return mergedOptions?.sdk || userInitOptions?.backend?.sdk || (backend?.sdk && 'function' == typeof backend.sdk ? backend.sdk : void 0);
+}
+function buildChainedBackendConfig(backend, userInitOptions) {
+    const merged = mergeBackendOptions(DEFAULT_I18NEXT_BACKEND_OPTIONS, backend, userInitOptions?.backend);
+    const { isExplicit } = hasLoadPath(backend, userInitOptions);
+    ensureDefaultLoadPath(merged, backend, isExplicit);
+    const mergedOptions = convertBackendOptions(merged);
+    const finalLoadPath = getFinalLoadPath(mergedOptions, backend, userInitOptions);
+    const finalSdk = getFinalSdk(mergedOptions, backend, userInitOptions);
+    const chainedBackendOptions = [
+        {
+            loadPath: finalLoadPath,
+            addPath: mergedOptions?.addPath || DEFAULT_I18NEXT_BACKEND_OPTIONS.addPath
+        },
+        {
+            sdk: finalSdk
+        }
+    ];
+    return {
+        ...mergedOptions,
+        loadPath: finalLoadPath,
+        sdk: finalSdk,
+        cacheHitMode: mergedOptions?.cacheHitMode || backend?.cacheHitMode || userInitOptions?.backend?.cacheHitMode || 'refreshAndUpdateStore',
+        _useChainedBackend: true,
+        _chainedBackendConfig: {
+            backendOptions: chainedBackendOptions
+        }
+    };
+}
+function buildSdkOnlyBackendConfig(backend, userInitOptions) {
+    const merged = mergeBackendOptions({}, backend, userInitOptions?.backend);
+    return convertBackendOptions(merged) || {};
+}
+function buildHttpFsBackendConfig(backend, userInitOptions) {
+    if (!backend?.enabled && !userInitOptions?.backend) return;
+    const mergedBackend = backend?.enabled ? mergeBackendOptions(DEFAULT_I18NEXT_BACKEND_OPTIONS, backend, userInitOptions?.backend) : userInitOptions?.backend;
+    if (mergedBackend) {
+        const { isExplicit } = hasLoadPath(backend, userInitOptions);
+        ensureDefaultLoadPath(mergedBackend, backend, isExplicit);
+    }
+    return convertBackendOptions(mergedBackend) || {};
+}
+const backend_mergeBackendOptions = (backend, userInitOptions)=>{
+    const sdkFunction = hasSdkFunction(backend, userInitOptions);
+    const { hasPath } = hasLoadPath(backend, userInitOptions);
+    if (hasPath && sdkFunction) return buildChainedBackendConfig(backend, userInitOptions);
+    if (sdkFunction) return buildSdkOnlyBackendConfig(backend, userInitOptions);
+    return buildHttpFsBackendConfig(backend, userInitOptions);
+};
+export { backend_mergeBackendOptions as mergeBackendOptions };

package/dist/esm/runtime/i18n/backend/middleware.common.mjs

@@ -0,0 +1,61 @@
+import i18next_chained_backend from "i18next-chained-backend";
+import { getActualI18nextInstance } from "../instance.mjs";
+import { SdkBackend } from "./sdk-backend.mjs";
+function checkBackendConfig(backend) {
+    const hasSdk = backend?.sdk && 'function' == typeof backend.sdk;
+    const hasLoadPath = !!backend?.loadPath;
+    const useChained = backend?._useChainedBackend;
+    return {
+        hasSdk,
+        hasLoadPath,
+        useChained
+    };
+}
+function buildChainedBackendConfig(backend, BackendWithSave) {
+    const cacheHitMode = backend.cacheHitMode || 'refreshAndUpdateStore';
+    if (backend._chainedBackendConfig) return {
+        backends: [
+            BackendWithSave,
+            SdkBackend
+        ],
+        backendOptions: backend._chainedBackendConfig.backendOptions,
+        cacheHitMode
+    };
+    return {
+        backends: [
+            BackendWithSave,
+            SdkBackend
+        ],
+        backendOptions: [
+            {
+                loadPath: backend.loadPath,
+                addPath: backend.addPath
+            },
+            {
+                sdk: backend.sdk
+            }
+        ],
+        cacheHitMode
+    };
+}
+function setupChainedBackend(i18nInstance, backend, BackendWithSave) {
+    i18nInstance.use(i18next_chained_backend);
+    const actualInstance = getActualI18nextInstance(i18nInstance);
+    if (actualInstance?.options) actualInstance.options.backend = buildChainedBackendConfig(backend, BackendWithSave);
+    if (i18nInstance.options) i18nInstance.options.backend = buildChainedBackendConfig(backend, BackendWithSave);
+}
+function cleanBackendConfig(backend) {
+    const { _useChainedBackend, _chainedBackendConfig, ...cleanBackend } = backend;
+    return cleanBackend;
+}
+function useI18nextBackendCommon(i18nInstance, BackendWithSave, BackendBase, backend) {
+    if (!backend) return i18nInstance.use(BackendBase);
+    const { hasSdk, hasLoadPath, useChained } = checkBackendConfig(backend);
+    if (useChained || hasLoadPath && hasSdk) return void setupChainedBackend(i18nInstance, backend, BackendWithSave);
+    if (hasSdk) return i18nInstance.use(SdkBackend);
+    const actualInstance = getActualI18nextInstance(i18nInstance);
+    if (actualInstance?.options) actualInstance.options.backend = cleanBackendConfig(backend);
+    if (i18nInstance.options) i18nInstance.options.backend = cleanBackendConfig(backend);
+    return i18nInstance.use(BackendBase);
+}
+export { useI18nextBackendCommon };

package/dist/esm/runtime/i18n/backend/middleware.mjs

@@ -0,0 +1,7 @@
+import i18next_http_backend from "i18next-http-backend";
+import { useI18nextBackendCommon } from "./middleware.common.mjs";
+class HttpBackendWithSave extends i18next_http_backend {
+    save(_language, _namespace, _data) {}
+}
+const useI18nextBackend = (i18nInstance, backend)=>useI18nextBackendCommon(i18nInstance, HttpBackendWithSave, i18next_http_backend, backend);
+export { HttpBackendWithSave, useI18nextBackend };

package/dist/esm/runtime/i18n/backend/middleware.node.mjs

@@ -0,0 +1,8 @@
+import i18next_fs_backend from "i18next-fs-backend";
+import { useI18nextBackendCommon } from "./middleware.common.mjs";
+class FsBackendWithSave extends i18next_fs_backend {
+    save(_language, _namespace, _data) {}
+}
+const HttpBackendWithSave = FsBackendWithSave;
+const useI18nextBackend = (i18nInstance, backend)=>useI18nextBackendCommon(i18nInstance, FsBackendWithSave, i18next_fs_backend, backend);
+export { FsBackendWithSave, HttpBackendWithSave, useI18nextBackend };

package/dist/esm/runtime/i18n/backend/sdk-backend.mjs

@@ -0,0 +1,141 @@
+import { I18N_SDK_RESOURCES_LOADED_EVENT, createI18nSdkBackendId, setI18nSdkBackendId } from "./sdk-event.mjs";
+class SdkBackend {
+    init(services, backendOptions, _i18nextOptions) {
+        this.services = services;
+        this.sdk = backendOptions?.sdk;
+        setI18nSdkBackendId(services.resourceStore || services.store, this.backendId);
+        if (!this.sdk) throw new Error('SdkBackend requires an SDK function to be provided in backend options');
+    }
+    read(language, namespace, callback) {
+        if (!this.sdk) {
+            console.error('[i18n] SdkBackend.read - SDK function not initialized');
+            callback(new Error('SDK function not initialized'), null);
+            return;
+        }
+        const cached = this.allResourcesCache ? this.extractFromCache(language, namespace) : null;
+        if (null !== cached) {
+            const mergedData = this.mergeWithExistingResources(language, namespace, cached);
+            callback(null, mergedData);
+            return;
+        }
+        const cacheKey = this.getCacheKey(language, namespace);
+        const existingPromise = this.loadingPromises.get(cacheKey);
+        if (existingPromise) return void this.handlePromise(existingPromise, language, namespace, callback, false);
+        this.loadResource(language, namespace, callback);
+    }
+    create(_languages, _namespace, _key, _fallbackValue) {}
+    isLoading(language, namespace) {
+        return this.loadingPromises.has(this.getCacheKey(language, namespace));
+    }
+    getLoadingResources() {
+        const loading = [];
+        for (const key of this.loadingPromises.keys()){
+            const [language, namespace] = key.split(':');
+            if (language && namespace) loading.push({
+                language,
+                namespace
+            });
+        }
+        return loading;
+    }
+    hasLoadingResources() {
+        return this.loadingPromises.size > 0;
+    }
+    getCacheKey(language, namespace) {
+        return `${language}:${namespace}`;
+    }
+    loadResource(language, namespace, callback) {
+        try {
+            const result = this.callSdk(language, namespace);
+            const loadPromise = result instanceof Promise ? result : Promise.resolve(result);
+            const cacheKey = this.getCacheKey(language, namespace);
+            this.loadingPromises.set(cacheKey, loadPromise);
+            this.handlePromise(loadPromise, language, namespace, callback, true);
+        } catch (error) {
+            callback(this.normalizeError(error), null);
+        }
+    }
+    handlePromise(promise, language, namespace, callback, shouldUpdateCache) {
+        const cacheKey = this.getCacheKey(language, namespace);
+        promise.then((data)=>{
+            const formattedData = this.formatResources(data, language, namespace);
+            const mergedData = this.mergeWithExistingResources(language, namespace, formattedData);
+            if (shouldUpdateCache) {
+                this.updateCache(language, namespace, mergedData);
+                this.loadingPromises.delete(cacheKey);
+            }
+            callback(null, mergedData);
+            this.triggerI18nextUpdate(language, namespace);
+        }).catch((error)=>{
+            if (shouldUpdateCache) this.loadingPromises.delete(cacheKey);
+            callback(this.normalizeError(error), null);
+        });
+    }
+    normalizeError(error) {
+        return error instanceof Error ? error : new Error(String(error));
+    }
+    callSdk(language, namespace) {
+        if (!this.sdk) throw new Error('SDK function not initialized');
+        const options = {
+            lng: language,
+            ns: namespace
+        };
+        return this.sdk(options);
+    }
+    extractFromCache(language, namespace) {
+        if (!this.allResourcesCache) return null;
+        const langData = this.allResourcesCache[language];
+        if (!this.isObject(langData)) return null;
+        const nsData = langData[namespace];
+        if (!this.isObject(nsData)) return null;
+        return nsData;
+    }
+    updateCache(language, namespace, data) {
+        if (!this.allResourcesCache) this.allResourcesCache = {};
+        if (!this.allResourcesCache[language]) this.allResourcesCache[language] = {};
+        if (this.isObject(data)) this.allResourcesCache[language][namespace] = data;
+    }
+    formatResources(data, language, namespace) {
+        if (!this.isObject(data)) return {};
+        const dataObj = data;
+        const langData = dataObj[language];
+        if (this.isObject(langData)) {
+            const nsData = langData[namespace];
+            if (this.isObject(nsData)) return nsData;
+        }
+        const hasLanguageKeys = Object.keys(dataObj).some((key)=>this.isObject(dataObj[key]));
+        if (!hasLanguageKeys) return dataObj;
+        return {};
+    }
+    isObject(value) {
+        return null !== value && 'object' == typeof value;
+    }
+    mergeWithExistingResources(language, namespace, sdkData) {
+        const store = this.services?.resourceStore || this.services?.store;
+        const existingData = store?.data?.[language]?.[namespace] || {};
+        return {
+            ...existingData,
+            ...sdkData
+        };
+    }
+    triggerI18nextUpdate(language, namespace) {
+        if ("u" > typeof window) {
+            const event = new CustomEvent(I18N_SDK_RESOURCES_LOADED_EVENT, {
+                detail: {
+                    language,
+                    namespace,
+                    backendId: this.backendId
+                }
+            });
+            window.dispatchEvent(event);
+        }
+    }
+    constructor(_services, _options){
+        this.type = 'backend';
+        this.allResourcesCache = null;
+        this.backendId = createI18nSdkBackendId();
+        this.loadingPromises = new Map();
+    }
+}
+SdkBackend.type = 'backend';
+export { SdkBackend };

package/dist/esm/runtime/i18n/backend/sdk-event.mjs

@@ -0,0 +1,21 @@
+const I18N_SDK_RESOURCES_LOADED_EVENT = 'i18n-sdk-resources-loaded';
+const I18N_SDK_BACKEND_ID_KEY = '__modern_i18n_sdk_backend_id__';
+let sdkBackendInstanceCount = 0;
+function createI18nSdkBackendId() {
+    sdkBackendInstanceCount += 1;
+    return `modern-i18n-sdk-backend-${sdkBackendInstanceCount}`;
+}
+function setI18nSdkBackendId(target, backendId) {
+    if (!target || 'object' != typeof target) return;
+    Object.defineProperty(target, I18N_SDK_BACKEND_ID_KEY, {
+        configurable: true,
+        enumerable: false,
+        value: backendId,
+        writable: true
+    });
+}
+function getI18nSdkBackendId(target) {
+    if (!target || 'object' != typeof target) return;
+    return target[I18N_SDK_BACKEND_ID_KEY];
+}
+export { I18N_SDK_RESOURCES_LOADED_EVENT, createI18nSdkBackendId, getI18nSdkBackendId, setI18nSdkBackendId };

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

@@ -0,0 +1,26 @@
+import { deepMerge } from "../../../shared/deepMerge.mjs";
+const DEFAULT_I18NEXT_DETECTION_OPTIONS = {
+    caches: [
+        'cookie',
+        'localStorage'
+    ],
+    order: [
+        'querystring',
+        'cookie',
+        'localStorage',
+        'header',
+        'navigator',
+        'htmlTag',
+        'path',
+        'subdomain'
+    ],
+    cookieMinutes: 525600,
+    lookupQuerystring: 'lng',
+    lookupCookie: 'i18next',
+    lookupLocalStorage: 'i18nextLng',
+    lookupHeader: 'accept-language'
+};
+function mergeDetectionOptions(cliOptions, userOptions, defaultOptions = DEFAULT_I18NEXT_DETECTION_OPTIONS) {
+    return deepMerge(deepMerge(defaultOptions, cliOptions ?? {}), userOptions ?? {});
+}
+export { DEFAULT_I18NEXT_DETECTION_OPTIONS, mergeDetectionOptions };