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

package/dist/cjs/runtime/core.js

@@ -39,37 +39,15 @@ __webpack_require__.d(__webpack_exports__, {
     useLocalizedPaths: ()=>external_localizedPaths_js_namespaceObject.useLocalizedPaths,
     useModernI18n: ()=>external_context_js_namespaceObject.useModernI18n
 });
-const jsx_runtime_namespaceObject = require("react/jsx-runtime");
-const runtime_namespaceObject = require("@modern-js/runtime");
-const head_namespaceObject = require("@modern-js/runtime/head");
-const merge_namespaceObject = require("@modern-js/runtime-utils/merge");
-const external_react_namespaceObject = require("react");
-const external_context_js_namespaceObject = require("./context.js");
-const external_hooks_js_namespaceObject = require("./hooks.js");
-const index_js_namespaceObject = require("./i18n/index.js");
-const backend_index_js_namespaceObject = require("./i18n/backend/index.js");
-const detection_index_js_namespaceObject = require("./i18n/detection/index.js");
-const middleware_js_namespaceObject = require("./i18n/detection/middleware.js");
-const instance_js_namespaceObject = require("./i18n/instance.js");
-const external_utils_js_namespaceObject = require("./utils.js");
+const external_pluginSetup_js_namespaceObject = require("./pluginSetup.js");
+const external_providerComposition_js_namespaceObject = require("./providerComposition.js");
+const external_reactI18next_js_namespaceObject = require("./reactI18next.js");
 require("./types.js");
+const external_context_js_namespaceObject = require("./context.js");
 const external_I18nLink_js_namespaceObject = require("./I18nLink.js");
 const external_Link_js_namespaceObject = require("./Link.js");
 const external_localizedPaths_js_namespaceObject = require("./localizedPaths.js");
-let i18nLifecycleHelpersPromise;
-function loadI18nLifecycleHelpers() {
-    i18nLifecycleHelpersPromise ??= Promise.all([
-        import("./i18n/backend/middleware.js"),
-        import("./i18n/utils.js")
-    ]).then(([backendMiddleware, utils])=>({
-            useI18nextBackend: backendMiddleware.useI18nextBackend,
-            changeI18nLanguage: utils.changeI18nLanguage,
-            ensureLanguageMatch: utils.ensureLanguageMatch,
-            initializeI18nInstance: utils.initializeI18nInstance,
-            setupClonedInstance: utils.setupClonedInstance
-        }));
-    return i18nLifecycleHelpersPromise;
-}
+const external_utils_js_namespaceObject = require("./utils.js");
 const createI18nPlugin = (loadReactI18nextIntegration)=>(options)=>({
             name: '@modern-js/plugin-i18n',
             setup: (api)=>{
@@ -78,116 +56,35 @@ const createI18nPlugin = (loadReactI18nextIntegration)=>(options)=>({
                 const { enabled: backendEnabled = false } = backend || {};
                 let latestI18nInstance;
                 let I18nextProvider;
-                const resolveReactI18nextIntegration = async ()=>{
-                    if (!reactI18next) return null;
-                    return loadReactI18nextIntegration?.() ?? null;
-                };
                 api.onBeforeRender(async (context)=>{
-                    const { useI18nextBackend, changeI18nLanguage, ensureLanguageMatch, initializeI18nInstance, setupClonedInstance } = await loadI18nLifecycleHelpers();
-                    let i18nInstance = await (0, index_js_namespaceObject.getI18nInstance)(userI18nInstance);
-                    const { i18n: otherConfig } = api.getRuntimeConfig();
-                    const { initOptions: otherInitOptions } = otherConfig || {};
-                    const userInitOptions = (0, merge_namespaceObject.merge)(otherInitOptions || {}, initOptions || {});
-                    const reactI18nextIntegration = await resolveReactI18nextIntegration();
-                    I18nextProvider = reactI18nextIntegration?.I18nextProvider ?? null;
-                    if (reactI18nextIntegration?.initReactI18next) i18nInstance.use(reactI18nextIntegration.initReactI18next);
-                    const pathname = (0, external_utils_js_namespaceObject.getPathname)(context);
-                    if (i18nextDetector) (0, middleware_js_namespaceObject.useI18nextLanguageDetector)(i18nInstance);
-                    const mergedDetection = (0, detection_index_js_namespaceObject.mergeDetectionOptions)(i18nextDetector, detection, localePathRedirect, userInitOptions);
-                    const mergedBackend = (0, backend_index_js_namespaceObject.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 (0, detection_index_js_namespaceObject.detectLanguageWithPriority)(i18nInstance, {
-                        languages,
-                        fallbackLanguage,
-                        localePathRedirect,
+                    latestI18nInstance = await (0, external_pluginSetup_js_namespaceObject.setupI18nBeforeRender)(context, {
+                        api,
+                        userI18nInstance,
+                        initOptions,
+                        backend,
+                        backendEnabled,
                         i18nextDetector,
                         detection,
-                        userInitOptions,
-                        mergedBackend,
-                        pathname,
-                        ssrContext: context.ssrContext
-                    });
-                    await initializeI18nInstance(i18nInstance, finalLanguage, fallbackLanguage, languages, mergedDetection, mergedBackend, userInitOptions);
-                    if (!(0, runtime_namespaceObject.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 (!(0, runtime_namespaceObject.isBrowser)()) (0, detection_index_js_namespaceObject.exportServerLngToWindow)(context, finalLanguage);
-                    context.i18nInstance = i18nInstance;
-                    latestI18nInstance = i18nInstance;
-                    context.changeLanguage = async (newLang)=>{
-                        await changeI18nLanguage(i18nInstance, newLang, {
-                            detectionOptions: mergedDetection
-                        });
-                    };
-                });
-                api.wrapRoot((App)=>(props)=>{
-                        const runtimeContext = (0, external_react_namespaceObject.useContext)(runtime_namespaceObject.RuntimeContext);
-                        const i18nInstance = runtimeContext.i18nInstance || latestI18nInstance;
-                        const initialLang = (0, external_react_namespaceObject.useMemo)(()=>i18nInstance?.language || (localeDetection?.fallbackLanguage ?? 'en'), [
-                            i18nInstance?.language,
-                            localeDetection?.fallbackLanguage
-                        ]);
-                        const [lang, setLang] = (0, external_react_namespaceObject.useState)(initialLang);
-                        const [forceUpdate, setForceUpdate] = (0, external_react_namespaceObject.useState)(0);
-                        const prevLangRef = (0, external_react_namespaceObject.useRef)(lang);
-                        const runtimeContextRef = (0, external_react_namespaceObject.useRef)(runtimeContext);
-                        runtimeContextRef.current = runtimeContext;
-                        (0, external_react_namespaceObject.useEffect)(()=>{
-                            if (i18nInstance?.language) {
-                                const translator = i18nInstance.translator;
-                                if (translator) translator.language = i18nInstance.language;
-                            }
-                        }, [
-                            i18nInstance?.language
-                        ]);
-                        (0, external_react_namespaceObject.useEffect)(()=>{
-                            prevLangRef.current = lang;
-                        }, [
-                            lang
-                        ]);
-                        (0, external_hooks_js_namespaceObject.useSdkResourcesLoader)(i18nInstance, setForceUpdate);
-                        (0, external_hooks_js_namespaceObject.useLanguageSync)(i18nInstance, localePathRedirect, languages, runtimeContextRef, prevLangRef, setLang);
-                        (0, external_hooks_js_namespaceObject.useClientSideRedirect)(i18nInstance, localePathRedirect, languages, fallbackLanguage, ignoreRedirectRoutes, localisedUrls);
-                        const contextValue = (0, external_react_namespaceObject.useMemo)(()=>(0, external_hooks_js_namespaceObject.createContextValue)(lang, i18nInstance, entryName, languages, localePathRedirect, ignoreRedirectRoutes, localisedUrls, setLang), [
-                            lang,
-                            i18nInstance,
-                            entryName,
-                            languages,
-                            localePathRedirect,
-                            ignoreRedirectRoutes,
-                            localisedUrls,
-                            forceUpdate
-                        ]);
-                        const children = props.children;
-                        const appContent = /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(jsx_runtime_namespaceObject.Fragment, {
-                            children: [
-                                Boolean(htmlLangAttr) && /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(head_namespaceObject.Helmet, {
-                                    htmlAttributes: {
-                                        lang
-                                    }
-                                }),
-                                /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_context_js_namespaceObject.ModernI18nProvider, {
-                                    value: contextValue,
-                                    children: App ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(App, {
-                                        ...props,
-                                        children: children
-                                    }) : children
-                                })
-                            ]
-                        });
-                        if (!i18nInstance) return appContent;
-                        if (I18nextProvider) {
-                            const i18nextInstanceForProvider = (0, instance_js_namespaceObject.getI18nextInstanceForProvider)(i18nInstance);
-                            return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(I18nextProvider, {
-                                i18n: i18nextInstanceForProvider,
-                                children: appContent
-                            });
+                        localePathRedirect,
+                        languages,
+                        fallbackLanguage,
+                        resolveReactI18nextIntegration: ()=>(0, external_reactI18next_js_namespaceObject.resolveReactI18nextIntegration)(reactI18next, loadReactI18nextIntegration),
+                        setI18nextProvider: (provider)=>{
+                            I18nextProvider = provider;
                         }
-                        return appContent;
                     });
+                });
+                api.wrapRoot((0, external_providerComposition_js_namespaceObject.createI18nRootWrapper)({
+                    entryName,
+                    htmlLangAttr,
+                    localePathRedirect,
+                    languages,
+                    fallbackLanguage,
+                    ignoreRedirectRoutes,
+                    localisedUrls,
+                    getLatestI18nInstance: ()=>latestI18nInstance,
+                    getI18nextProvider: ()=>I18nextProvider
+                }));
             }
         });
 exports.I18nLink = __webpack_exports__.I18nLink;

package/dist/cjs/runtime/i18n/backend/defaults.node.js

@@ -41,23 +41,23 @@ __webpack_require__.d(__webpack_exports__, {
     convertBackendOptions: ()=>convertBackendOptions,
     resolveDefaultLocalesDir: ()=>resolveDefaultLocalesDir
 });
-const external_fs_namespaceObject = require("fs");
-var external_fs_default = /*#__PURE__*/ __webpack_require__.n(external_fs_namespaceObject);
-const external_path_namespaceObject = require("path");
-var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
 const CONVENTIONAL_LOCALES_DIRS = [
     './locales',
     './config/public/locales'
 ];
 const isDirectory = (dirPath)=>{
     try {
-        return external_fs_default().statSync(dirPath).isDirectory();
+        return external_node_fs_default().statSync(dirPath).isDirectory();
     } catch  {
         return false;
     }
 };
 const resolveDefaultLocalesDir = (cwd = process.cwd())=>{
-    for (const dir of CONVENTIONAL_LOCALES_DIRS)if (isDirectory(external_path_default().resolve(cwd, dir))) return dir;
+    for (const dir of CONVENTIONAL_LOCALES_DIRS)if (isDirectory(external_node_path_default().resolve(cwd, dir))) return dir;
     return CONVENTIONAL_LOCALES_DIRS[0];
 };
 const DEFAULT_I18NEXT_BACKEND_OPTIONS = {
@@ -83,7 +83,7 @@ function getResourceBasePath(resourcePath) {
 }
 function pathExists(resourcePath) {
     try {
-        return external_fs_default().existsSync(getResourceBasePath(resourcePath));
+        return external_node_fs_default().existsSync(getResourceBasePath(resourcePath));
     } catch  {
         return false;
     }

package/dist/cjs/runtime/i18n/detection/cache.js

@@ -0,0 +1,150 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+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 record = value;
+    const sortedKeys = Object.keys(record).sort();
+    const sortedEntries = sortedKeys.map((key)=>{
+        const stringifiedValue = stableStringify(record[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) {}
+};
+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;
+};
+__webpack_require__.d(__webpack_exports__, {}, {
+    buildDetectorConfigKey: buildDetectorConfigKey,
+    createDetectorInstance: createDetectorInstance,
+    detectorInstanceCache: detectorInstanceCache,
+    pickSafeDetectionOptions: pickSafeDetectionOptions
+});
+exports.buildDetectorConfigKey = __webpack_exports__.buildDetectorConfigKey;
+exports.createDetectorInstance = __webpack_exports__.createDetectorInstance;
+exports.detectorInstanceCache = __webpack_exports__.detectorInstanceCache;
+exports.pickSafeDetectionOptions = __webpack_exports__.pickSafeDetectionOptions;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "buildDetectorConfigKey",
+    "createDetectorInstance",
+    "detectorInstanceCache",
+    "pickSafeDetectionOptions"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/i18n/detection/detector.js

@@ -0,0 +1,100 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    detectLanguageFromI18nextDetector: ()=>detectLanguageFromI18nextDetector
+});
+const runtime_namespaceObject = require("@modern-js/runtime");
+const external_cache_js_namespaceObject = require("./cache.js");
+const external_initOptions_js_namespaceObject = require("./initOptions.js");
+const external_language_js_namespaceObject = require("./language.js");
+const external_middleware_js_namespaceObject = require("./middleware.js");
+const initializeI18nForDetector = async (i18nInstance, options)=>{
+    const mergedDetection = (0, external_initOptions_js_namespaceObject.mergeDetectionOptions)(options.i18nextDetector, options.detection, options.localePathRedirect, options.userInitOptions);
+    const configKey = (0, external_cache_js_namespaceObject.buildDetectorConfigKey)(options.languages, options.fallbackLanguage, mergedDetection);
+    const { instance, isTemporary } = (0, external_cache_js_namespaceObject.createDetectorInstance)(i18nInstance, configKey);
+    const safeUserOptions = (0, external_cache_js_namespaceObject.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
+        }
+    };
+    (0, external_middleware_js_namespaceObject.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 = (0, external_initOptions_js_namespaceObject.mergeDetectionOptions)(options.i18nextDetector, options.detection, options.localePathRedirect, options.userInitOptions);
+    const { detectorInstance, isTemporary } = await initializeI18nForDetector(i18nInstance, options);
+    try {
+        const request = options.ssrContext?.request;
+        if (!(0, runtime_namespaceObject.isBrowser)() && !request) return;
+        const detectorLang = (0, external_middleware_js_namespaceObject.detectLanguage)(detectorInstance, request, mergedDetection);
+        if (detectorLang) {
+            const supportedLang = (0, external_language_js_namespaceObject.getSupportedLanguage)(detectorLang, options.languages);
+            if (supportedLang) return supportedLang;
+        }
+        if (detectorInstance.isInitialized && detectorInstance.language) {
+            const currentLang = detectorInstance.language;
+            if ((0, external_language_js_namespaceObject.isLanguageSupported)(currentLang, options.languages)) return currentLang;
+        }
+    } catch (error) {} finally{
+        if (isTemporary && detectorInstance !== i18nInstance) external_cache_js_namespaceObject.detectorInstanceCache.set(i18nInstance, {
+            instance: detectorInstance,
+            isTemporary: true,
+            configKey: (0, external_cache_js_namespaceObject.buildDetectorConfigKey)(options.languages, options.fallbackLanguage, mergedDetection)
+        });
+        else if (detectorInstance === i18nInstance) {
+            i18nInstance.isInitialized = false;
+            delete i18nInstance.language;
+        }
+    }
+};
+exports.detectLanguageFromI18nextDetector = __webpack_exports__.detectLanguageFromI18nextDetector;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "detectLanguageFromI18nextDetector"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});