@bleedingdev/modern-js-plugin-i18n 3.5.0-ultramodern.9 → 3.5.0-ultramodern.91

package/dist/cjs/runtime/i18n/instance.js

@@ -29,9 +29,11 @@ var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 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) {
@@ -48,7 +50,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 {
@@ -69,12 +72,36 @@ async function createI18nextInstance() {
         return null;
     }
 }
-function getI18nextInstanceForProvider(instance) {
+function getI18nextInstanceForProvider(instance, language) {
+    let providerInstance = instance;
     if (isI18nWrapperInstance(instance)) {
         const i18nextInstance = getI18nWrapperI18nextInstance(instance);
-        if (i18nextInstance) return i18nextInstance;
+        if (i18nextInstance) providerInstance = i18nextInstance;
     }
-    return instance;
+    if (!language || "u" < typeof Proxy) return providerInstance;
+    return new Proxy(providerInstance, {
+        get (target, property, receiver) {
+            if ('language' === property || 'resolvedLanguage' === property) return language;
+            if ('languages' === property) {
+                const languages = Reflect.get(target, property, receiver);
+                return Array.isArray(languages) ? [
+                    language,
+                    ...languages.filter((item)=>item !== language)
+                ] : [
+                    language
+                ];
+            }
+            if ('t' === property && 'function' == typeof target.getFixedT) return target.getFixedT(language);
+            if ('hasLoadedNamespace' === property && 'function' == typeof target.hasLoadedNamespace) {
+                const hasLoadedNamespace = target.hasLoadedNamespace;
+                return (namespace, options)=>hasLoadedNamespace.call(target, namespace, {
+                        ...options,
+                        lng: options?.lng || language
+                    });
+            }
+            return Reflect.get(target, property, receiver);
+        }
+    });
 }
 async function getI18nInstance(userInstance) {
     if (userInstance) {
@@ -88,21 +115,18 @@ async function getI18nInstance(userInstance) {
 __webpack_require__.d(__webpack_exports__, {
     getActualI18nextInstance: ()=>getActualI18nextInstance,
     getI18nInstance: ()=>getI18nInstance,
-    getI18nWrapperI18nextInstance: ()=>getI18nWrapperI18nextInstance,
     getI18nextInstanceForProvider: ()=>getI18nextInstanceForProvider,
     isI18nInstance: ()=>isI18nInstance,
     isI18nWrapperInstance: ()=>isI18nWrapperInstance
 });
 exports.getActualI18nextInstance = __webpack_exports__.getActualI18nextInstance;
 exports.getI18nInstance = __webpack_exports__.getI18nInstance;
-exports.getI18nWrapperI18nextInstance = __webpack_exports__.getI18nWrapperI18nextInstance;
 exports.getI18nextInstanceForProvider = __webpack_exports__.getI18nextInstanceForProvider;
 exports.isI18nInstance = __webpack_exports__.isI18nInstance;
 exports.isI18nWrapperInstance = __webpack_exports__.isI18nWrapperInstance;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "getActualI18nextInstance",
     "getI18nInstance",
-    "getI18nWrapperI18nextInstance",
     "getI18nextInstanceForProvider",
     "isI18nInstance",
     "isI18nWrapperInstance"

package/dist/cjs/runtime/linkHelpers.js

@@ -0,0 +1,148 @@
+"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 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;
+};
+__webpack_require__.d(__webpack_exports__, {}, {
+    interpolateRouteParams: interpolateRouteParams,
+    mergeClassNames: mergeClassNames,
+    normalizeSearch: normalizeSearch,
+    splitActiveProps: splitActiveProps,
+    warnOnce: warnOnce
+});
+exports.interpolateRouteParams = __webpack_exports__.interpolateRouteParams;
+exports.mergeClassNames = __webpack_exports__.mergeClassNames;
+exports.normalizeSearch = __webpack_exports__.normalizeSearch;
+exports.splitActiveProps = __webpack_exports__.splitActiveProps;
+exports.warnOnce = __webpack_exports__.warnOnce;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "interpolateRouteParams",
+    "mergeClassNames",
+    "normalizeSearch",
+    "splitActiveProps",
+    "warnOnce"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/pluginSetup.js

@@ -0,0 +1,102 @@
+"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__, {
+    setupI18nBeforeRender: ()=>setupI18nBeforeRender
+});
+const runtime_namespaceObject = require("@modern-js/runtime");
+const merge_namespaceObject = require("@modern-js/runtime-utils/merge");
+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 external_utils_js_namespaceObject = require("./utils.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;
+}
+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 (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();
+    setI18nextProvider(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,
+        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;
+    context.changeLanguage = async (newLang)=>{
+        await changeI18nLanguage(i18nInstance, newLang, {
+            detectionOptions: mergedDetection
+        });
+    };
+    return i18nInstance;
+}
+exports.setupI18nBeforeRender = __webpack_exports__.setupI18nBeforeRender;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "setupI18nBeforeRender"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/providerComposition.js

@@ -0,0 +1,115 @@
+"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__, {
+    createI18nRootWrapper: ()=>createI18nRootWrapper
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const runtime_namespaceObject = require("@modern-js/runtime");
+const head_namespaceObject = require("@modern-js/runtime/head");
+const external_react_namespaceObject = require("react");
+const external_context_js_namespaceObject = require("./context.js");
+const external_hooks_js_namespaceObject = require("./hooks.js");
+const instance_js_namespaceObject = require("./i18n/instance.js");
+const external_routerAdapter_js_namespaceObject = require("./routerAdapter.js");
+const createI18nRootWrapper = (options)=>(App)=>(props)=>{
+            const { entryName, htmlLangAttr, localePathRedirect, languages, fallbackLanguage, ignoreRedirectRoutes, localisedUrls, getLatestI18nInstance, getI18nextProvider } = options;
+            const runtimeContext = (0, external_react_namespaceObject.useContext)(runtime_namespaceObject.RuntimeContext);
+            const i18nInstance = runtimeContext.i18nInstance || getLatestI18nInstance();
+            const initialLang = (0, external_react_namespaceObject.useMemo)(()=>i18nInstance?.language || fallbackLanguage, [
+                i18nInstance?.language,
+                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 { location } = (0, external_routerAdapter_js_namespaceObject.useI18nRouterAdapter)();
+            (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);
+            const synchronizeLanguage = (0, external_hooks_js_namespaceObject.useLanguageSync)(i18nInstance, localePathRedirect, languages, location?.pathname, 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, synchronizeLanguage), [
+                lang,
+                i18nInstance,
+                entryName,
+                languages,
+                localePathRedirect,
+                ignoreRedirectRoutes,
+                localisedUrls,
+                forceUpdate,
+                synchronizeLanguage
+            ]);
+            const children = props.children;
+            let appContent = App ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(App, {
+                ...props,
+                children: children
+            }) : children;
+            if (i18nInstance) {
+                const I18nextProvider = getI18nextProvider();
+                if (I18nextProvider) {
+                    const i18nextInstanceForProvider = (0, instance_js_namespaceObject.getI18nextInstanceForProvider)(i18nInstance, lang);
+                    appContent = /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(I18nextProvider, {
+                        i18n: i18nextInstanceForProvider,
+                        children: appContent
+                    });
+                }
+            }
+            return /*#__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: appContent
+                    })
+                ]
+            });
+        };
+exports.createI18nRootWrapper = __webpack_exports__.createI18nRootWrapper;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createI18nRootWrapper"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/reactI18next.js

@@ -0,0 +1,43 @@
+"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 resolveReactI18nextIntegration = async (reactI18next, loadReactI18nextIntegration)=>{
+    if (!reactI18next) return null;
+    return loadReactI18nextIntegration?.() ?? null;
+};
+__webpack_require__.d(__webpack_exports__, {}, {
+    resolveReactI18nextIntegration: resolveReactI18nextIntegration
+});
+exports.resolveReactI18nextIntegration = __webpack_exports__.resolveReactI18nextIntegration;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "resolveReactI18nextIntegration"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/routerAdapter.js

@@ -97,28 +97,36 @@ const useI18nRouterAdapter = ()=>{
     const [, setRouterVersion] = (0, external_react_namespaceObject.useState)(0);
     const hasRouter = 'tanstack' === framework || 'react-router' === framework || Boolean(reactRouterNavigate);
     (0, external_react_namespaceObject.useEffect)(()=>{
-        if ('tanstack' !== framework) return;
         const router = getRouterInstance(internalContext, contextRouter);
         if (!router) return;
         const update = ()=>setRouterVersion((version)=>version + 1);
         const unsubscribers = [];
-        if ('function' == typeof router.stores?.location?.subscribe) {
-            const unsubscribe = router.stores.location.subscribe(update);
+        if ('react-router' === framework && !inReactRouter && 'function' == typeof router.subscribe) {
+            const subscribe = router.subscribe;
+            const unsubscribe = subscribe.call(router, update);
             if ('function' == typeof unsubscribe) unsubscribers.push(unsubscribe);
         }
-        if ('function' == typeof router.subscribe) for (const eventType of [
-            'onBeforeNavigate',
-            'onBeforeLoad'
-        ]){
-            const unsubscribe = router.subscribe(eventType, update);
+        if ('tanstack' === framework && 'function' == typeof router.stores?.location?.subscribe) {
+            const unsubscribe = router.stores.location.subscribe(update);
             if ('function' == typeof unsubscribe) unsubscribers.push(unsubscribe);
         }
+        if ('tanstack' === framework && 'function' == typeof router.subscribe) {
+            const subscribe = router.subscribe;
+            for (const eventType of [
+                'onBeforeNavigate',
+                'onBeforeLoad'
+            ]){
+                const unsubscribe = subscribe.call(router, eventType, update);
+                if ('function' == typeof unsubscribe) unsubscribers.push(unsubscribe);
+            }
+        }
         return ()=>{
             for (const unsubscribe of unsubscribers)unsubscribe();
         };
     }, [
         contextRouter,
         framework,
+        inReactRouter,
         internalContext
     ]);
     const navigate = (0, external_react_namespaceObject.useCallback)((href, options)=>{

package/dist/cjs/runtime/utils.js

@@ -89,15 +89,7 @@ const detectLanguageFromPath = (pathname, languages, localePathRedirect)=>{
         detected: false
     };
 };
-const shouldIgnoreRedirect = (pathname, languages, ignoreRedirectRoutes)=>{
-    if (!ignoreRedirectRoutes) return false;
-    const segments = pathname.split('/').filter(Boolean);
-    let pathWithoutLang = pathname;
-    if (segments.length > 0 && languages.includes(segments[0])) pathWithoutLang = `/${segments.slice(1).join('/')}`;
-    const normalizedPath = pathWithoutLang.startsWith('/') ? pathWithoutLang : `/${pathWithoutLang}`;
-    if ('function' == typeof ignoreRedirectRoutes) return ignoreRedirectRoutes(normalizedPath);
-    return ignoreRedirectRoutes.some((pattern)=>normalizedPath === pattern || normalizedPath.startsWith(`${pattern}/`));
-};
+const shouldIgnoreRedirect = (pathname, languages, ignoreRedirectRoutes)=>(0, localisedUrls_js_namespaceObject.shouldSkipLocaleRedirect)(pathname, languages, ignoreRedirectRoutes);
 exports.buildLocalizedUrl = __webpack_exports__.buildLocalizedUrl;
 exports.detectLanguageFromPath = __webpack_exports__.detectLanguageFromPath;
 exports.getEntryPath = __webpack_exports__.getEntryPath;

package/dist/cjs/server/apiPrefix.js

@@ -0,0 +1,72 @@
+"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 normalizeApiPrefix = (prefix)=>{
+    const trimmedPrefix = prefix.trim();
+    if (!trimmedPrefix) return null;
+    const prefixedPath = trimmedPrefix.startsWith('/') ? trimmedPrefix : `/${trimmedPrefix}`;
+    const withoutWildcard = prefixedPath.replace(/\/\*$/, '');
+    const normalizedPrefix = withoutWildcard.length > 1 ? withoutWildcard.replace(/\/+$/, '') : withoutWildcard;
+    return '/' === normalizedPrefix ? null : normalizedPrefix;
+};
+const collectApiPrefixes = (routes, bffPrefix)=>{
+    const prefixes = new Set();
+    for (const route of routes){
+        if (!route.isApi || !route.urlPath) continue;
+        const normalizedPrefix = normalizeApiPrefix(route.urlPath);
+        if (normalizedPrefix) prefixes.add(normalizedPrefix);
+    }
+    const bffPrefixes = Array.isArray(bffPrefix) ? bffPrefix : bffPrefix ? [
+        bffPrefix
+    ] : [];
+    for (const prefix of bffPrefixes){
+        const normalizedPrefix = normalizeApiPrefix(prefix);
+        if (normalizedPrefix) prefixes.add(normalizedPrefix);
+    }
+    return [
+        ...prefixes
+    ];
+};
+const matchesApiPrefix = (pathname, apiPrefixes)=>{
+    const normalizedPathname = pathname.startsWith('/') ? pathname : `/${pathname}`;
+    return apiPrefixes.some((prefix)=>normalizedPathname === prefix || normalizedPathname.startsWith(`${prefix}/`));
+};
+__webpack_require__.d(__webpack_exports__, {}, {
+    collectApiPrefixes: collectApiPrefixes,
+    matchesApiPrefix: matchesApiPrefix
+});
+exports.collectApiPrefixes = __webpack_exports__.collectApiPrefixes;
+exports.matchesApiPrefix = __webpack_exports__.matchesApiPrefix;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "collectApiPrefixes",
+    "matchesApiPrefix"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});