@bleedingdev/modern-js-plugin-i18n 3.8.3-ultramodern.6 → 3.9.0-ultramodern.10

package/dist/esm-node/runtime/context.mjs

@@ -1,8 +1,8 @@
 import "node:module";
 import { jsx } from "react/jsx-runtime";
+import { RuntimeComponentResolverContext } from "@modern-js/runtime/context";
 import { createContext, useCallback, useContext, useEffect, useMemo } from "react";
 import { changeModernI18nLanguage, getPathLanguage, isI18nLanguageSupported, isI18nResourcesReady, translateI18n } from "./contextHelpers.mjs";
-import { getActualI18nextInstance } from "./i18n/instance.mjs";
 import { useI18nRouterAdapter } from "./routerAdapter.mjs";
 const modernI18nContextKey = Symbol.for('@modern-js/plugin-i18n/runtime/ModernI18nContext');
 const reactI18nextProviderContextKey = Symbol.for('@modern-js/plugin-i18n/runtime/ReactI18nextProviderContext');
@@ -23,68 +23,23 @@ const ModernI18nProvider = ({ children, i18nextProvider, value })=>{
         children: content
     });
 };
-const FederatedI18nBoundary = ({ children, defaultNamespace, fallbackLanguage, resources, supportedLanguages })=>{
-    const parent = useContext(ModernI18nContext);
-    const I18nextProvider = useContext(ReactI18nextProviderContext);
-    if (!parent) throw new Error('FederatedI18nBoundary must be used within ModernI18nProvider');
-    const languages = supportedLanguages ?? parent.languages ?? Object.keys(resources);
-    const scopedInstance = useMemo(()=>{
-        const parentInstance = getActualI18nextInstance(parent.i18nInstance);
-        const clone = parentInstance.cloneInstance?.({
-            defaultNS: defaultNamespace,
-            fallbackLng: fallbackLanguage ?? languages[0] ?? parent.language,
-            forkResourceStore: true,
-            initImmediate: false,
-            lng: parent.language,
-            ns: [
-                defaultNamespace
-            ],
-            resources,
-            supportedLngs: languages
-        });
-        if (!clone) throw new Error('FederatedI18nBoundary requires an i18n instance with cloneInstance support');
-        const resourceStore = clone.store;
-        const parentResourceStore = parentInstance.store;
-        const sharesNestedResourceState = Object.entries(resourceStore?.data ?? {}).some(([language, namespaces])=>{
-            const parentNamespaces = parentResourceStore?.data?.[language];
-            return namespaces === parentNamespaces || Object.entries(namespaces).some(([namespace, resource])=>null !== resource && 'object' == typeof resource && resource === parentNamespaces?.[namespace]);
-        });
-        if (clone === parentInstance || resourceStore === parentResourceStore || resourceStore?.data === parentResourceStore?.data || sharesNestedResourceState) throw new Error('FederatedI18nBoundary cloneInstance did not isolate the host resource store');
-        if (!resourceStore?.addResourceBundle || !clone.removeResourceBundle || !resourceStore.data) throw new Error('FederatedI18nBoundary requires an isolated mutable i18n resource store');
-        for (const [language, namespaces] of Object.entries(resourceStore.data))for (const namespace of Object.keys(namespaces))clone.removeResourceBundle(language, namespace);
-        for (const [language, namespaces] of Object.entries(resources))for (const [namespace, resource] of Object.entries(namespaces))resourceStore.addResourceBundle(language, namespace, resource, true, true);
-        return clone;
-    }, [
-        defaultNamespace,
-        fallbackLanguage,
-        languages,
-        parent.i18nInstance,
-        parent.language,
-        resources
-    ]);
-    const value = useMemo(()=>({
-            ...parent,
-            i18nInstance: scopedInstance,
-            language: parent.language,
-            languages
-        }), [
-        languages,
-        parent,
-        scopedInstance
-    ]);
-    const scopedContent = /*#__PURE__*/ jsx(ModernI18nProvider, {
-        value: value,
-        children: children
+const MissingFederatedI18nBoundary = ()=>{
+    throw new Error('FederatedI18nBoundary requires the @modern-js/i18n-integration runtime plugin');
+};
+const FederatedI18nBoundary = (props)=>{
+    const resolveComponent = useContext(RuntimeComponentResolverContext);
+    const Boundary = resolveComponent?.(MissingFederatedI18nBoundary, {
+        name: 'i18n.FederatedI18nBoundary'
+    }) ?? MissingFederatedI18nBoundary;
+    if (Boundary === FederatedI18nBoundary) throw new Error('FederatedI18nBoundary resolver returned its own wrapper');
+    return /*#__PURE__*/ jsx(Boundary, {
+        ...props
     });
-    return I18nextProvider ? /*#__PURE__*/ jsx(I18nextProvider, {
-        i18n: scopedInstance,
-        children: scopedContent
-    }) : scopedContent;
 };
 const useModernI18n = ()=>{
     const context = useContext(ModernI18nContext);
     if (!context) throw new Error('useModernI18n must be used within ModernI18nProvider');
-    const { language: contextLanguage, i18nInstance, languages, localePathRedirect, ignoreRedirectRoutes, localisedUrls, updateLanguage, synchronizeLanguage } = context;
+    const { language: contextLanguage, i18nInstance, languages, localePathRedirect, ignoreRedirectRoutes, urlStrategy, updateLanguage, synchronizeLanguage } = context;
     const { navigate, location, hasRouter } = useI18nRouterAdapter();
     const pathLanguage = useMemo(()=>getPathLanguage(location?.pathname, languages, localePathRedirect), [
         languages,
@@ -103,7 +58,7 @@ const useModernI18n = ()=>{
             updateLanguage,
             localePathRedirect,
             ignoreRedirectRoutes,
-            localisedUrls,
+            urlStrategy,
             languages,
             hasRouter,
             navigate,
@@ -113,7 +68,7 @@ const useModernI18n = ()=>{
         updateLanguage,
         localePathRedirect,
         ignoreRedirectRoutes,
-        localisedUrls,
+        urlStrategy,
         languages,
         hasRouter,
         navigate,
@@ -136,9 +91,10 @@ const useModernI18n = ()=>{
         t,
         i18nInstance: i18nInstance,
         supportedLanguages: languages || [],
-        localisedUrls,
+        urlStrategy,
         isLanguageSupported,
         isResourcesReady
     };
 };
-export { FederatedI18nBoundary, ModernI18nProvider, useModernI18n };
+export { getActualI18nextInstance } from "./i18n/instance.mjs";
+export { FederatedI18nBoundary, ModernI18nContext, ModernI18nProvider, ReactI18nextProviderContext, useModernI18n };

package/dist/esm-node/runtime/contextHelpers.mjs

@@ -18,7 +18,7 @@ async function changeI18nInstanceLanguage(i18nInstance, language) {
     else await i18nInstance.changeLanguage?.(language);
 }
 async function changeModernI18nLanguage(newLang, options) {
-    const { i18nInstance, updateLanguage, localePathRedirect, ignoreRedirectRoutes, localisedUrls, languages, hasRouter, navigate, location } = options;
+    const { i18nInstance, updateLanguage, localePathRedirect, ignoreRedirectRoutes, urlStrategy, languages, hasRouter, navigate, location } = options;
     try {
         if (!newLang || 'string' != typeof newLang) throw new Error('Language must be non-empty string');
         await changeI18nInstanceLanguage(i18nInstance, newLang);
@@ -29,8 +29,8 @@ async function changeModernI18nLanguage(newLang, options) {
             const relativePath = currentPath.replace(entryPath, '');
             const pathLanguage = detectLanguageFromPath(currentPath, languages || [], localePathRedirect);
             if (pathLanguage.detected && pathLanguage.language === newLang) return void updateLanguage?.(newLang);
-            if (!shouldIgnoreRedirect(relativePath, languages || [], ignoreRedirectRoutes)) {
-                const newPath = buildLocalizedUrl(relativePath, newLang, languages || [], localisedUrls);
+            if (!shouldIgnoreRedirect(relativePath, languages || [], ignoreRedirectRoutes, urlStrategy)) {
+                const newPath = buildLocalizedUrl(relativePath, newLang, languages || [], urlStrategy);
                 const newUrl = entryPath + newPath + location.search + location.hash;
                 await navigate(newUrl, {
                     replace: true
@@ -42,8 +42,8 @@ async function changeModernI18nLanguage(newLang, options) {
             const relativePath = currentPath.replace(entryPath, '');
             const pathLanguage = detectLanguageFromPath(currentPath, languages || [], localePathRedirect);
             if (pathLanguage.detected && pathLanguage.language === newLang) return void updateLanguage?.(newLang);
-            if (!shouldIgnoreRedirect(relativePath, languages || [], ignoreRedirectRoutes)) {
-                const newPath = buildLocalizedUrl(relativePath, newLang, languages || [], localisedUrls);
+            if (!shouldIgnoreRedirect(relativePath, languages || [], ignoreRedirectRoutes, urlStrategy)) {
+                const newPath = buildLocalizedUrl(relativePath, newLang, languages || [], urlStrategy);
                 const newUrl = entryPath + newPath + window.location.search + window.location.hash;
                 window.history.pushState(null, '', newUrl);
             }

package/dist/esm-node/runtime/core.mjs

@@ -1,4 +1,7 @@
 import "node:module";
+import { resolveMappedUrlStrategy } from "../shared/mappedUrlStrategy.mjs";
+import { asI18nUrlStrategy } from "../shared/urlStrategy.mjs";
+import { I18nRouterNavigationProvider, useIntegratedRouterAdapter } from "./navigation.mjs";
 import { setupI18nBeforeRender } from "./pluginSetup.mjs";
 import { createI18nRootWrapper } from "./providerComposition.mjs";
 import { resolveReactI18nextIntegration } from "./reactI18next.mjs";
@@ -6,9 +9,10 @@ import "./types.mjs";
 const createI18nPlugin = (loadReactI18nextIntegration)=>(options)=>({
             name: '@modern-js/plugin-i18n',
             setup: (api)=>{
-                const { entryName, i18nInstance: userI18nInstance, initOptions, localeDetection, backend, htmlLangAttr = false, reactI18next = true } = options;
-                const { localePathRedirect = false, i18nextDetector = true, languages = [], fallbackLanguage = 'en', detection, ignoreRedirectRoutes, localisedUrls } = localeDetection || {};
+                const { entryName, i18nInstance: userI18nInstance, initOptions, localeDetection, backend, htmlLangAttr = false, reactI18next = true, urlStrategy, NavigationProvider, LanguageSynchronization } = options;
+                const { localePathRedirect = false, i18nextDetector = true, languages = [], fallbackLanguage = 'en', detection, ignoreRedirectRoutes } = localeDetection || {};
                 const { enabled: backendEnabled = false } = backend || {};
+                const resolvedUrlStrategy = asI18nUrlStrategy(urlStrategy) ?? resolveMappedUrlStrategy(localeDetection);
                 let latestI18nInstance;
                 let I18nextProvider;
                 api.onBeforeRender(async (context)=>{
@@ -36,15 +40,18 @@ const createI18nPlugin = (loadReactI18nextIntegration)=>(options)=>({
                     languages,
                     fallbackLanguage,
                     ignoreRedirectRoutes,
-                    localisedUrls,
+                    urlStrategy: resolvedUrlStrategy,
+                    NavigationProvider: NavigationProvider ?? I18nRouterNavigationProvider,
+                    LanguageSynchronization,
                     getLatestI18nInstance: ()=>latestI18nInstance,
                     getI18nextProvider: ()=>I18nextProvider
                 }));
             }
         });
+export { I18nNavigationProvider, useI18nRouterAdapter, useNativeI18nRouterAdapter } from "./routerAdapter.mjs";
 export { FederatedI18nBoundary, useModernI18n } from "./context.mjs";
 export { I18nLink } from "./I18nLink.mjs";
 export { Link } from "./Link.mjs";
-export { canonicalPath, localizePath, useLocalizedLocation, useLocalizedPaths } from "./localizedPaths.mjs";
-export { buildLocalizedUrl, splitUrlTarget } from "./utils.mjs";
-export { createI18nPlugin };
+export { useLocalizedLocation, useLocalizedPaths } from "./localizedPaths.mjs";
+export { splitUrlTarget } from "./utils.mjs";
+export { I18nRouterNavigationProvider, createI18nPlugin, useIntegratedRouterAdapter };

package/dist/esm-node/runtime/hooks.mjs

@@ -19,7 +19,7 @@ function createMinimalI18nInstance(language) {
     };
     return minimalInstance;
 }
-function createContextValue(lang, i18nInstance, entryName, languages, localePathRedirect, ignoreRedirectRoutes, localisedUrls, setLang, synchronizeLanguage) {
+function createContextValue(lang, i18nInstance, entryName, languages, localePathRedirect, ignoreRedirectRoutes, setLang, urlStrategy) {
     const instance = i18nInstance || createMinimalI18nInstance(lang);
     return {
         language: lang,
@@ -28,9 +28,8 @@ function createContextValue(lang, i18nInstance, entryName, languages, localePath
         languages,
         localePathRedirect,
         ignoreRedirectRoutes,
-        localisedUrls,
-        updateLanguage: setLang,
-        synchronizeLanguage
+        urlStrategy,
+        updateLanguage: setLang
     };
 }
 function useSdkResourcesLoader(i18nInstance, setForceUpdate) {
@@ -79,7 +78,7 @@ function useSdkResourcesLoader(i18nInstance, setForceUpdate) {
         setForceUpdate
     ]);
 }
-function useClientSideRedirect(i18nInstance, localePathRedirect, languages, fallbackLanguage, ignoreRedirectRoutes, localisedUrls) {
+function useClientSideRedirect(i18nInstance, localePathRedirect, languages, fallbackLanguage, ignoreRedirectRoutes, urlStrategy) {
     const urlRef = useRef('');
     const { navigate, location, hasRouter } = useI18nRouterAdapter();
     useEffect(()=>{
@@ -96,10 +95,10 @@ function useClientSideRedirect(i18nInstance, localePathRedirect, languages, fall
         const currentHash = hasRouter && location ? location.hash : window.location.hash;
         const entryPath = getEntryPath();
         const relativePath = currentPathname.replace(entryPath, '');
-        if (shouldIgnoreRedirect(relativePath, languages, ignoreRedirectRoutes)) return;
+        if (shouldIgnoreRedirect(relativePath, languages, ignoreRedirectRoutes, urlStrategy)) return;
         const pathDetection = detectLanguageFromPath(currentPathname, languages, localePathRedirect);
         const targetLanguage = pathDetection.language || i18nInstance.language || fallbackLanguage || languages[0] || 'en';
-        const newPath = buildLocalizedUrl(relativePath, targetLanguage, languages, localisedUrls);
+        const newPath = buildLocalizedUrl(relativePath, targetLanguage, languages, urlStrategy);
         const newUrl = entryPath + newPath + currentSearch + currentHash;
         urlRef.current = currentPathname;
         if (newUrl !== currentPathname + currentSearch + currentHash) if (hasRouter && navigate && location) navigate(newUrl, {
@@ -115,7 +114,7 @@ function useClientSideRedirect(i18nInstance, localePathRedirect, languages, fall
         languages,
         fallbackLanguage,
         ignoreRedirectRoutes,
-        localisedUrls
+        urlStrategy
     ]);
 }
 function useLanguageSync(i18nInstance, localePathRedirect, languages, pathname, prevLangRef, setLang) {

package/dist/esm-node/runtime/localizedPaths.mjs

@@ -1,21 +1,23 @@
 import "node:module";
-import { canonicalTargetPathname } from "@modern-js/i18n-runtime-extensions";
 import { useMemo } from "react";
 import { useModernI18n } from "./context.mjs";
 import { useI18nRouterAdapter } from "./routerAdapter.mjs";
 import { buildLocalizedUrl, splitUrlTarget } from "./utils.mjs";
-const localizePath = (pathname, language, config)=>buildLocalizedUrl(pathname, language, config.languages, config.localisedUrls);
+const localizePath = (pathname, language, config)=>buildLocalizedUrl(pathname, language, config.languages, config.urlStrategy);
 const canonicalPath = (target, config)=>{
     const { pathname, search, hash } = splitUrlTarget(target);
-    const resolvedPath = canonicalTargetPathname(pathname, config.languages, config.localisedUrls);
+    if (config.urlStrategy) return `${config.urlStrategy.canonicalPathname(pathname, config.languages)}${search}${hash}`;
+    const segments = pathname.split('/').filter(Boolean);
+    if (segments[0] && config.languages.some((language)=>language.toLowerCase() === segments[0].toLowerCase())) segments.shift();
+    const resolvedPath = `/${segments.join('/')}`;
     return `${resolvedPath}${search}${hash}`;
 };
 const useLocalizedPaths = ()=>{
-    const { supportedLanguages, localisedUrls } = useModernI18n();
+    const { supportedLanguages, urlStrategy } = useModernI18n();
     return useMemo(()=>{
         const config = {
             languages: supportedLanguages,
-            localisedUrls
+            urlStrategy
         };
         return {
             localizePath: (pathname, language)=>localizePath(pathname, language, config),
@@ -23,11 +25,11 @@ const useLocalizedPaths = ()=>{
         };
     }, [
         supportedLanguages,
-        localisedUrls
+        urlStrategy
     ]);
 };
 const useLocalizedLocation = ()=>{
-    const { language, supportedLanguages, localisedUrls } = useModernI18n();
+    const { language, supportedLanguages, urlStrategy } = useModernI18n();
     const { location } = useI18nRouterAdapter();
     const pathname = location?.pathname ?? '/';
     const search = location?.search ?? '';
@@ -35,7 +37,7 @@ const useLocalizedLocation = ()=>{
     return useMemo(()=>{
         const config = {
             languages: supportedLanguages,
-            localisedUrls
+            urlStrategy
         };
         const alternates = {};
         for (const supportedLanguage of supportedLanguages)alternates[supportedLanguage] = `${localizePath(pathname, supportedLanguage, config)}${search}${hash}`;
@@ -47,7 +49,7 @@ const useLocalizedLocation = ()=>{
     }, [
         language,
         supportedLanguages,
-        localisedUrls,
+        urlStrategy,
         pathname,
         search,
         hash

package/dist/esm-node/runtime/navigation.mjs

@@ -0,0 +1,8 @@
+import "node:module";
+import { createI18nRouterNavigation } from "@modern-js/i18n-runtime-extensions/router-navigation";
+import { I18nNavigationProvider, useNativeI18nRouterAdapter } from "./routerAdapter.mjs";
+const { I18nRouterNavigationProvider: I18nRouterNavigationProvider, useIntegratedRouterAdapter: useIntegratedRouterAdapter } = createI18nRouterNavigation({
+    I18nNavigationProvider: I18nNavigationProvider,
+    useNativeI18nRouterAdapter: useNativeI18nRouterAdapter
+});
+export { I18nRouterNavigationProvider, useIntegratedRouterAdapter };

package/dist/esm-node/runtime/providerComposition.mjs

@@ -1,15 +1,20 @@
 import "node:module";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
-import { useLanguageSync } from "@modern-js/i18n-runtime-extensions";
 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, useSdkResourcesLoader } from "./hooks.mjs";
+import { createContextValue, useClientSideRedirect, useLanguageSync, useSdkResourcesLoader } from "./hooks.mjs";
 import { getI18nextInstanceForProvider } from "./i18n/instance.mjs";
 import { useI18nRouterAdapter } from "./routerAdapter.mjs";
-const createI18nRootWrapper = (options)=>(App)=>(props)=>{
-            const { entryName, htmlLangAttr, localePathRedirect, languages, fallbackLanguage, ignoreRedirectRoutes, localisedUrls, getLatestI18nInstance, getI18nextProvider } = options;
+const NativeLanguageSynchronization = ({ i18nInstance, localePathRedirect, languages, pathname, prevLangRef, setLang, children })=>{
+    const synchronizeLanguage = useLanguageSync(i18nInstance, localePathRedirect, languages, pathname, prevLangRef, setLang);
+    return children(synchronizeLanguage);
+};
+const createI18nRootWrapper = (options)=>(App)=>{
+        const LanguageSynchronization = options.LanguageSynchronization ?? NativeLanguageSynchronization;
+        const I18nRoot = (props)=>{
+            const { entryName, htmlLangAttr, localePathRedirect, languages, fallbackLanguage, ignoreRedirectRoutes, urlStrategy, getLatestI18nInstance, getI18nextProvider } = options;
             const runtimeContext = useContext(RuntimeContext);
             const i18nInstance = runtimeContext.i18nInstance || getLatestI18nInstance();
             const initialLang = useMemo(()=>i18nInstance?.language || fallbackLanguage, [
@@ -34,18 +39,16 @@ const createI18nRootWrapper = (options)=>(App)=>(props)=>{
                 lang
             ]);
             useSdkResourcesLoader(i18nInstance, setForceUpdate);
-            const synchronizeLanguage = useLanguageSync(i18nInstance, localePathRedirect, languages, location?.pathname, prevLangRef, setLang);
-            useClientSideRedirect(i18nInstance, localePathRedirect, languages, fallbackLanguage, ignoreRedirectRoutes, localisedUrls);
-            const contextValue = useMemo(()=>createContextValue(lang, i18nInstance, entryName, languages, localePathRedirect, ignoreRedirectRoutes, localisedUrls, setLang, synchronizeLanguage), [
+            useClientSideRedirect(i18nInstance, localePathRedirect, languages, fallbackLanguage, ignoreRedirectRoutes, urlStrategy);
+            const contextValue = useMemo(()=>createContextValue(lang, i18nInstance, entryName, languages, localePathRedirect, ignoreRedirectRoutes, setLang, urlStrategy), [
                 lang,
                 i18nInstance,
                 entryName,
                 languages,
                 localePathRedirect,
                 ignoreRedirectRoutes,
-                localisedUrls,
-                forceUpdate,
-                synchronizeLanguage
+                urlStrategy,
+                forceUpdate
             ]);
             const I18nextProvider = getI18nextProvider();
             const i18nextInstanceForProvider = useMemo(()=>i18nInstance ? getI18nextInstanceForProvider(i18nInstance, lang) : void 0, [
@@ -68,12 +71,33 @@ const createI18nRootWrapper = (options)=>(App)=>(props)=>{
                             lang
                         }
                     }),
-                    /*#__PURE__*/ jsx(ModernI18nProvider, {
-                        i18nextProvider: I18nextProvider,
-                        value: contextValue,
-                        children: appContent
+                    /*#__PURE__*/ jsx(LanguageSynchronization, {
+                        i18nInstance: i18nInstance,
+                        localePathRedirect: localePathRedirect,
+                        languages: languages,
+                        pathname: location?.pathname,
+                        prevLangRef: prevLangRef,
+                        setLang: setLang,
+                        children: (synchronizeLanguage)=>/*#__PURE__*/ jsx(ModernI18nProvider, {
+                                i18nextProvider: I18nextProvider,
+                                value: {
+                                    ...contextValue,
+                                    synchronizeLanguage
+                                },
+                                children: appContent
+                            })
                     })
                 ]
             });
         };
+        const { NavigationProvider } = options;
+        if (!NavigationProvider) return I18nRoot;
+        return function(props) {
+            return /*#__PURE__*/ jsx(NavigationProvider, {
+                children: /*#__PURE__*/ jsx(I18nRoot, {
+                    ...props
+                })
+            });
+        };
+    };
 export { createI18nRootWrapper };

package/dist/esm-node/runtime/routerAdapter.mjs

@@ -1,151 +1,40 @@
 import "node:module";
+import { jsx } from "react/jsx-runtime";
 import { RuntimeContext, isBrowser } from "@modern-js/runtime";
-import { InternalRuntimeContext, getRouterRuntimeState } from "@modern-js/runtime/context";
-import { useCallback, useContext, useSyncExternalStore } from "react";
-const normalizeUrlPart = (value, prefix)=>{
-    if ('string' != typeof value || !value) return '';
-    return value.startsWith(prefix) ? value : `${prefix}${value}`;
-};
-const normalizeLocation = (location)=>{
-    if (!location || 'object' != typeof location) return null;
-    const locationValue = location;
-    if ('string' != typeof locationValue.pathname) return null;
-    return {
-        pathname: locationValue.pathname,
-        search: normalizeUrlPart('string' == typeof locationValue.search ? locationValue.search : locationValue.searchStr, '?'),
-        hash: normalizeUrlPart(locationValue.hash, '#')
-    };
-};
-const getWindowLocation = ()=>{
-    if (!isBrowser()) return null;
-    return {
-        pathname: window.location.pathname,
-        search: window.location.search,
-        hash: window.location.hash
-    };
-};
-const getRouterFramework = (runtimeContext, internalContext, inReactRouter)=>{
-    const framework = getRouterRuntimeState(internalContext)?.framework || getRouterRuntimeState(runtimeContext)?.framework;
-    if (framework) return framework;
-    if (internalContext.router?.useRouter || runtimeContext.router?.useRouter) return 'tanstack';
-    if (internalContext.router?.useLocation || internalContext.router?.useHref || runtimeContext.router?.useLocation || runtimeContext.router?.useHref) return 'react-router';
-    if (inReactRouter) return 'react-router';
-};
-const getRouterInstance = (internalContext, contextRouter)=>{
-    if (contextRouter) return contextRouter;
-    const router = getRouterRuntimeState(internalContext)?.instance;
-    if (!router || 'object' != typeof router) return null;
-    return router;
-};
-const getRouterStateLocation = (internalContext, contextRouter)=>{
-    const router = getRouterInstance(internalContext, contextRouter);
-    return normalizeLocation(router?.stores?.location?.get?.()) || normalizeLocation(router?.state?.location);
-};
-const getRouterParams = (internalContext, contextRouter)=>{
-    const router = getRouterInstance(internalContext, contextRouter);
-    const matches = router?.stores?.matches?.get?.() || router?.state?.matches;
-    if (!Array.isArray(matches)) return {};
-    return matches.reduce((params, match)=>{
-        if (match?.params) Object.assign(params, match.params);
-        return params;
-    }, {});
-};
-const getRouterSnapshot = (internalContext, contextRouter)=>{
-    const location = getRouterStateLocation(internalContext, contextRouter);
-    const params = getRouterParams(internalContext, contextRouter);
-    return JSON.stringify([
-        location?.pathname ?? '',
-        location?.search ?? '',
-        location?.hash ?? '',
-        Object.entries(params).sort(([left], [right])=>left.localeCompare(right))
-    ]);
-};
-const useI18nRouterAdapter = ()=>{
+import { InternalRuntimeContext } from "@modern-js/runtime/context";
+import { createContext, useContext } from "react";
+const navigationContextKey = Symbol.for('@modern-js/plugin-i18n/runtime/I18nNavigationContext');
+const contextStore = globalThis;
+const I18nNavigationContext = contextStore[navigationContextKey] ??= /*#__PURE__*/ createContext(null);
+const I18nNavigationProvider = ({ children, value })=>/*#__PURE__*/ jsx(I18nNavigationContext.Provider, {
+        value: value,
+        children: children
+    });
+const useNativeI18nRouterAdapter = ()=>{
     const runtimeContext = useContext(RuntimeContext);
     const internalContext = useContext(InternalRuntimeContext);
     const routerApi = internalContext.router || runtimeContext.router;
-    const inReactRouter = routerApi?.useInRouterContext?.() ?? false;
-    const reactRouterNavigate = inReactRouter ? routerApi?.useNavigate?.() ?? null : null;
-    const reactRouterLocation = inReactRouter ? routerApi?.useLocation?.() ?? null : null;
-    const reactRouterParams = inReactRouter ? routerApi?.useParams?.() ?? {} : {};
-    const framework = getRouterFramework(runtimeContext, internalContext, inReactRouter);
-    const contextUseRouter = inReactRouter || 'tanstack' !== framework ? void 0 : internalContext.router?.useRouter || runtimeContext.router?.useRouter;
-    const contextRouter = contextUseRouter ? contextUseRouter({
-        warn: false
-    }) : null;
-    const hasRouter = 'tanstack' === framework || 'react-router' === framework || Boolean(reactRouterNavigate);
-    const subscribeToRouter = useCallback((update)=>{
-        const router = getRouterInstance(internalContext, contextRouter);
-        if (!router) return ()=>void 0;
-        const unsubscribers = [];
-        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 ('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 getSnapshot = useCallback(()=>getRouterSnapshot(internalContext, contextRouter), [
-        contextRouter,
-        internalContext
-    ]);
-    useSyncExternalStore(subscribeToRouter, getSnapshot, getSnapshot);
-    const navigate = useCallback((href, options)=>{
-        const router = getRouterInstance(internalContext, contextRouter);
-        const activeFramework = getRouterFramework(runtimeContext, internalContext, inReactRouter);
-        if ('tanstack' === activeFramework) {
-            if ('function' == typeof router?.navigate) return router.navigate({
-                to: href,
-                replace: options?.replace,
-                ...options?.state === void 0 ? {} : {
-                    state: options.state
-                }
-            });
-            throw new Error('TanStack router instance is not available.');
-        }
-        if (reactRouterNavigate) return reactRouterNavigate(href, options);
-        if ('react-router' === activeFramework) {
-            if ('function' == typeof router?.navigate) return router.navigate(href, options);
-            throw new Error('React Router instance is not available.');
-        }
-    }, [
-        contextRouter,
-        internalContext,
-        inReactRouter,
-        reactRouterNavigate,
-        runtimeContext
-    ]);
-    const location = (reactRouterLocation ? normalizeLocation(reactRouterLocation) : getRouterStateLocation(internalContext, contextRouter)) || getWindowLocation();
-    const params = inReactRouter ? reactRouterParams : getRouterParams(internalContext, contextRouter);
-    const Link = 'tanstack' === framework ? internalContext.router?.Link || runtimeContext.router?.Link || null : 'react-router' === framework || inReactRouter ? routerApi?.Link ?? null : null;
+    const hasRouter = routerApi?.useInRouterContext?.() ?? false;
+    const navigate = hasRouter ? routerApi?.useNavigate?.() ?? null : null;
+    const routerLocation = hasRouter ? routerApi?.useLocation?.() ?? null : null;
+    const params = hasRouter ? routerApi?.useParams?.() ?? {} : {};
+    const location = routerLocation ?? (isBrowser() ? {
+        pathname: window.location.pathname,
+        search: window.location.search,
+        hash: window.location.hash
+    } : null);
     return {
-        framework,
+        framework: hasRouter ? 'react-router' : void 0,
         hasRouter,
+        navigate,
         location,
-        navigate: hasRouter ? navigate : null,
-        Link,
-        params
+        params,
+        Link: hasRouter ? routerApi?.Link ?? null : null
     };
 };
-export { useI18nRouterAdapter };
+const useI18nRouterAdapter = ()=>{
+    const provided = useContext(I18nNavigationContext);
+    const native = useNativeI18nRouterAdapter();
+    return provided ?? native;
+};
+export { I18nNavigationProvider, useI18nRouterAdapter, useNativeI18nRouterAdapter };

package/dist/esm-node/runtime/utils.mjs

@@ -1,7 +1,9 @@
 import "node:module";
-import { localiseTargetPathname, shouldSkipLocaleRedirect } from "@modern-js/i18n-runtime-extensions";
 import { isBrowser } from "@modern-js/runtime";
 import { getGlobalBasename } from "@modern-js/runtime/context";
+import { splitUrlTarget } from "@modern-js/runtime-utils/url";
+import { isDefaultLocaleRedirectSkipPath } from "../shared/mappedUrlStrategy.mjs";
+import { asI18nUrlStrategy } from "../shared/urlStrategy.mjs";
 const getPathname = (context)=>{
     if (isBrowser()) return window.location.pathname;
     return context.ssrContext?.request?.pathname || '/';
@@ -17,22 +19,14 @@ const getLanguageFromPath = (pathname, languages, fallbackLanguage)=>{
     if (languages.includes(firstSegment)) return firstSegment;
     return fallbackLanguage;
 };
-const splitUrlTarget = (target)=>{
-    const hashIndex = target.indexOf('#');
-    const hash = hashIndex >= 0 ? target.slice(hashIndex) : '';
-    const beforeHash = hashIndex >= 0 ? target.slice(0, hashIndex) : target;
-    const searchIndex = beforeHash.indexOf('?');
-    const search = searchIndex >= 0 ? beforeHash.slice(searchIndex) : '';
-    const pathname = searchIndex >= 0 ? beforeHash.slice(0, searchIndex) : beforeHash;
-    return {
-        pathname,
-        search,
-        hash
-    };
-};
-const buildLocalizedUrl = (target, language, languages, localisedUrls)=>{
+const buildLocalizedUrl = (target, language, languages, urlStrategy)=>{
     const { pathname, search, hash } = splitUrlTarget(target);
-    const localizedPathname = localiseTargetPathname(pathname, language, languages, localisedUrls);
+    const strategy = asI18nUrlStrategy(urlStrategy);
+    if (strategy) return `${strategy.localizePathname(pathname, language, languages)}${search}${hash}`;
+    const segments = pathname.split('/').filter(Boolean);
+    if (segments[0] && languages.some((item)=>item.toLowerCase() === segments[0].toLowerCase())) segments[0] = language;
+    else segments.unshift(language);
+    const localizedPathname = `/${segments.join('/')}`;
     return `${localizedPathname}${search}${hash}`;
 };
 const detectLanguageFromPath = (pathname, languages, localePathRedirect)=>{
@@ -52,5 +46,13 @@ const detectLanguageFromPath = (pathname, languages, localePathRedirect)=>{
         detected: false
     };
 };
-const shouldIgnoreRedirect = (pathname, languages, ignoreRedirectRoutes)=>shouldSkipLocaleRedirect(pathname, languages, ignoreRedirectRoutes);
+const shouldIgnoreRedirect = (pathname, languages, ignoreRedirectRoutes, urlStrategy)=>{
+    if (isDefaultLocaleRedirectSkipPath(pathname, languages)) return true;
+    if (asI18nUrlStrategy(urlStrategy)?.shouldSkipRedirect?.(pathname, languages)) return true;
+    if (!ignoreRedirectRoutes) return false;
+    const segments = pathname.split('/').filter(Boolean);
+    if (segments[0] && languages.some((item)=>item.toLowerCase() === segments[0].toLowerCase())) segments.shift();
+    const normalizedPath = `/${segments.join('/')}`;
+    return 'function' == typeof ignoreRedirectRoutes ? ignoreRedirectRoutes(normalizedPath) : ignoreRedirectRoutes.some((pattern)=>normalizedPath === pattern || normalizedPath.startsWith(`${pattern}/`));
+};
 export { buildLocalizedUrl, detectLanguageFromPath, getEntryPath, getLanguageFromPath, getPathname, shouldIgnoreRedirect, splitUrlTarget };