@bleedingdev/modern-js-plugin-i18n 3.2.0-ultramodern.12 → 3.2.0-ultramodern.121

package/dist/esm/runtime/Link.mjs

@@ -0,0 +1,221 @@
+import { jsx } from "react/jsx-runtime";
+import { useMemo } from "react";
+import { useModernI18n } from "./context.mjs";
+import { canonicalPath } from "./localizedPaths.mjs";
+import { useI18nRouterAdapter } from "./routerAdapter.mjs";
+import { buildLocalizedUrl, splitUrlTarget } from "./utils.mjs";
+const EXTERNAL_TARGET_RE = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
+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 entries = Object.entries(search).filter(([, value])=>null != value);
+        const searchObject = Object.fromEntries(entries.map(([key, value])=>[
+                key,
+                String(value)
+            ]));
+        const params = new URLSearchParams(searchObject);
+        const serialized = params.toString();
+        return {
+            searchString: serialized ? `?${serialized}` : '',
+            searchObject
+        };
+    }
+    const raw = 'string' == typeof search && search ? search : searchFromTo;
+    if (!raw) return {
+        searchString: '',
+        searchObject: void 0
+    };
+    const searchString = raw.startsWith('?') ? raw : `?${raw}`;
+    const searchObject = {};
+    new URLSearchParams(searchString).forEach((value, key)=>{
+        searchObject[key] = 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;
+};
+const Link = (props)=>{
+    const { to, params, children, hash: hashProp, search: searchProp, hashScrollIntoView, activeOptions, activeProps, prefetch, preload, ...rest } = props;
+    const adapter = useI18nRouterAdapter();
+    const { language, supportedLanguages, localisedUrls } = useModernI18n();
+    const config = {
+        languages: supportedLanguages,
+        localisedUrls
+    };
+    const isExternal = EXTERNAL_TARGET_RE.test(to);
+    const isBareHash = to.startsWith('#');
+    const target = useMemo(()=>{
+        if (isExternal || isBareHash) return null;
+        const { pathname, search: searchFromTo, hash: hashFromTo } = splitUrlTarget(to);
+        const interpolated = interpolateRouteParams(pathname || '/', params);
+        const firstSegment = interpolated.split('/').filter(Boolean)[0];
+        if (firstSegment && supportedLanguages.includes(firstSegment)) warnOnce(`lang-prefix:${to}`, `[plugin-i18n] <Link to="${to}"> starts with a language prefix. Write language-agnostic canonical paths; the Link localizes them automatically.`);
+        const localizedPathname = buildLocalizedUrl(interpolated, language, supportedLanguages, localisedUrls);
+        const hash = hashProp ?? (hashFromTo ? hashFromTo.slice(1) : '');
+        const { searchString, searchObject } = normalizeSearch(searchProp, searchFromTo);
+        return {
+            canonicalPathname: interpolated,
+            localizedPathname,
+            hash,
+            searchString,
+            searchObject,
+            href: `${localizedPathname}${searchString}${hash ? `#${hash}` : ''}`
+        };
+    }, [
+        to,
+        params,
+        hashProp,
+        searchProp,
+        isExternal,
+        isBareHash,
+        language,
+        supportedLanguages,
+        localisedUrls
+    ]);
+    const isActive = useMemo(()=>{
+        if (!target || !adapter.location) return false;
+        const current = canonicalPath(adapter.location.pathname, config);
+        const targetCanonical = canonicalPath(target.canonicalPathname, config);
+        const exact = activeOptions?.exact ?? '/' === targetCanonical;
+        if (current === targetCanonical) return true;
+        if (exact) return false;
+        return current.startsWith('/' === targetCanonical ? '/' : `${targetCanonical}/`);
+    }, [
+        target,
+        adapter.location,
+        activeOptions?.exact,
+        supportedLanguages,
+        localisedUrls
+    ]);
+    const resolvedActiveProps = splitActiveProps(isActive, activeProps);
+    const activeAttributes = isActive ? {
+        'data-status': 'active',
+        'aria-current': rest['aria-current'] ?? resolvedActiveProps['aria-current'] ?? 'page'
+    } : {};
+    if (!target) {
+        const { replace: _replace, ...anchorProps } = rest;
+        return /*#__PURE__*/ jsx("a", {
+            href: to,
+            ...anchorProps,
+            children: children
+        });
+    }
+    const { Link: RouterLink, hasRouter, framework } = adapter;
+    if (!hasRouter || !RouterLink) {
+        const { replace: _replace, ...anchorProps } = rest;
+        const { className: activeClassName, style: activeStyle, ...activeRest } = resolvedActiveProps;
+        return /*#__PURE__*/ jsx("a", {
+            href: target.href,
+            ...anchorProps,
+            ...activeRest,
+            ...activeAttributes,
+            className: mergeClassNames(rest.className, activeClassName),
+            style: {
+                ...rest.style,
+                ...activeStyle
+            },
+            children: children
+        });
+    }
+    const { className: activeClassName, style: activeStyle, ...activeRest } = resolvedActiveProps;
+    const mergedClassName = mergeClassNames(rest.className, activeClassName);
+    const mergedStyle = {
+        ...rest.style,
+        ...activeStyle
+    };
+    if ('tanstack' === framework) {
+        const tanstackPreload = void 0 !== preload ? preload : void 0 === prefetch ? void 0 : 'none' === prefetch ? false : prefetch;
+        return /*#__PURE__*/ jsx(RouterLink, {
+            to: target.localizedPathname,
+            ...target.searchObject ? {
+                search: target.searchObject
+            } : {},
+            ...target.hash ? {
+                hash: target.hash
+            } : {},
+            ...void 0 === hashScrollIntoView ? {} : {
+                hashScrollIntoView
+            },
+            ...void 0 === tanstackPreload ? {} : {
+                preload: tanstackPreload
+            },
+            ...rest,
+            ...activeRest,
+            ...activeAttributes,
+            className: mergedClassName,
+            style: mergedStyle,
+            children: children
+        });
+    }
+    return /*#__PURE__*/ jsx(RouterLink, {
+        to: target.href,
+        ...void 0 === prefetch ? {} : {
+            prefetch
+        },
+        ...void 0 === preload ? {} : {
+            preload
+        },
+        ...rest,
+        ...activeRest,
+        ...activeAttributes,
+        className: mergedClassName,
+        style: mergedStyle,
+        children: children
+    });
+};
+const runtime_Link = Link;
+export default runtime_Link;
+export { Link, interpolateRouteParams };

package/dist/esm/runtime/context.mjs

@@ -1,8 +1,9 @@
 import { jsx } from "react/jsx-runtime";
 import { isBrowser } from "@modern-js/runtime";
-import { createContext, useCallback, useContext, useMemo } from "react";
+import { createContext, useCallback, useContext, useEffect, useMemo } from "react";
 import { cacheUserLanguage } from "./i18n/detection/index.mjs";
-import { buildLocalizedUrl, detectLanguageFromPath, getEntryPath, shouldIgnoreRedirect, useRouterHooks } from "./utils.mjs";
+import { useI18nRouterAdapter } from "./routerAdapter.mjs";
+import { buildLocalizedUrl, detectLanguageFromPath, getEntryPath, shouldIgnoreRedirect } from "./utils.mjs";
 const ModernI18nContext = /*#__PURE__*/ createContext(null);
 const ModernI18nProvider = ({ children, value })=>/*#__PURE__*/ jsx(ModernI18nContext.Provider, {
         value: value,
@@ -11,9 +12,33 @@ const ModernI18nProvider = ({ children, value })=>/*#__PURE__*/ jsx(ModernI18nCo
 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 { language: contextLanguage, i18nInstance, languages, localePathRedirect, ignoreRedirectRoutes, localisedUrls, updateLanguage } = context;
+    const { navigate, location, hasRouter } = useI18nRouterAdapter();
+    const pathLanguage = useMemo(()=>{
+        if (!localePathRedirect || !location?.pathname) return;
+        const detected = detectLanguageFromPath(location.pathname, languages || [], localePathRedirect);
+        return detected.detected ? detected.language : void 0;
+    }, [
+        languages,
+        localePathRedirect,
+        location?.pathname
+    ]);
+    const currentLanguage = pathLanguage || contextLanguage;
+    useEffect(()=>{
+        if (!pathLanguage || pathLanguage === contextLanguage) return;
+        updateLanguage?.(pathLanguage);
+        i18nInstance?.setLang?.(pathLanguage);
+        i18nInstance?.changeLanguage?.(pathLanguage);
+        if (isBrowser()) {
+            const detectionOptions = i18nInstance.options?.detection;
+            cacheUserLanguage(i18nInstance, pathLanguage, detectionOptions);
+        }
+    }, [
+        contextLanguage,
+        i18nInstance,
+        pathLanguage,
+        updateLanguage
+    ]);
     const changeLanguage = useCallback(async (newLang)=>{
         try {
             if (!newLang || 'string' != typeof newLang) throw new Error('Language must be a non-empty string');
@@ -30,7 +55,7 @@ const useModernI18n = ()=>{
                 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 newPath = buildLocalizedUrl(relativePath, newLang, languages || [], localisedUrls);
                     const newUrl = entryPath + newPath + location.search + location.hash;
                     await navigate(newUrl, {
                         replace: true
@@ -43,7 +68,7 @@ const useModernI18n = ()=>{
                 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 newPath = buildLocalizedUrl(relativePath, newLang, languages || [], localisedUrls);
                     const newUrl = entryPath + newPath + window.location.search + window.location.hash;
                     window.history.pushState(null, '', newUrl);
                 }
@@ -58,6 +83,7 @@ const useModernI18n = ()=>{
         updateLanguage,
         localePathRedirect,
         ignoreRedirectRoutes,
+        localisedUrls,
         languages,
         hasRouter,
         navigate,
@@ -98,6 +124,7 @@ const useModernI18n = ()=>{
         changeLanguage,
         i18nInstance,
         supportedLanguages: languages || [],
+        localisedUrls,
         isLanguageSupported,
         isResourcesReady
     };

package/dist/esm/runtime/hooks.mjs

@@ -2,7 +2,8 @@ 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";
+import { useI18nRouterAdapter } from "./routerAdapter.mjs";
+import { buildLocalizedUrl, detectLanguageFromPath, getEntryPath, getPathname, shouldIgnoreRedirect } from "./utils.mjs";
 function createMinimalI18nInstance(language) {
     const minimalInstance = {
         language,
@@ -14,7 +15,7 @@ function createMinimalI18nInstance(language) {
     };
     return minimalInstance;
 }
-function createContextValue(lang, i18nInstance, entryName, languages, localePathRedirect, ignoreRedirectRoutes, setLang) {
+function createContextValue(lang, i18nInstance, entryName, languages, localePathRedirect, ignoreRedirectRoutes, localisedUrls, setLang) {
     const instance = i18nInstance || createMinimalI18nInstance(lang);
     return {
         language: lang,
@@ -23,6 +24,7 @@ function createContextValue(lang, i18nInstance, entryName, languages, localePath
         languages,
         localePathRedirect,
         ignoreRedirectRoutes,
+        localisedUrls,
         updateLanguage: setLang
     };
 }
@@ -72,9 +74,9 @@ function useSdkResourcesLoader(i18nInstance, setForceUpdate) {
         setForceUpdate
     ]);
 }
-function useClientSideRedirect(i18nInstance, localePathRedirect, languages, fallbackLanguage, ignoreRedirectRoutes) {
+function useClientSideRedirect(i18nInstance, localePathRedirect, languages, fallbackLanguage, ignoreRedirectRoutes, localisedUrls) {
     const hasRedirectedRef = useRef(false);
-    const { navigate, location, hasRouter } = useRouterHooks();
+    const { navigate, location, hasRouter } = useI18nRouterAdapter();
     useEffect(()=>{
         if ('browser' !== process.env.MODERN_TARGET) return;
         if (!localePathRedirect || !i18nInstance) return;
@@ -93,7 +95,7 @@ function useClientSideRedirect(i18nInstance, localePathRedirect, languages, fall
         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 newPath = buildLocalizedUrl(relativePath, targetLanguage, languages, localisedUrls);
         const newUrl = entryPath + newPath + currentSearch + currentHash;
         if (newUrl !== currentPathname + currentSearch + currentHash) {
             hasRedirectedRef.current = true;
@@ -110,7 +112,8 @@ function useClientSideRedirect(i18nInstance, localePathRedirect, languages, fall
         i18nInstance,
         languages,
         fallbackLanguage,
-        ignoreRedirectRoutes
+        ignoreRedirectRoutes,
+        localisedUrls
     ]);
 }
 function useLanguageSync(i18nInstance, localePathRedirect, languages, runtimeContextRef, prevLangRef, setLang) {

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

@@ -4,7 +4,7 @@ const DEFAULT_I18NEXT_BACKEND_OPTIONS = {
 };
 function convertPath(path) {
     if (!path) return path;
-    if (path.startsWith('/')) return `${window.__assetPrefix__ || ''}${path}`;
+    if (path.startsWith('/')) return "u" < typeof window ? path : `${window.__assetPrefix__ || ''}${path}`;
     return path;
 }
 function convertBackendOptions(options) {

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

@@ -1,6 +1,27 @@
+import fs from "fs";
+import path_0 from "path";
+const CONVENTIONAL_LOCALES_DIRS = [
+    './locales',
+    './config/public/locales'
+];
+const isDirectory = (dirPath)=>{
+    try {
+        return fs.statSync(dirPath).isDirectory();
+    } catch  {
+        return false;
+    }
+};
+const resolveDefaultLocalesDir = (cwd = process.cwd())=>{
+    for (const dir of CONVENTIONAL_LOCALES_DIRS)if (isDirectory(path_0.resolve(cwd, dir))) return dir;
+    return CONVENTIONAL_LOCALES_DIRS[0];
+};
 const DEFAULT_I18NEXT_BACKEND_OPTIONS = {
-    loadPath: './locales/{{lng}}/{{ns}}.json',
-    addPath: './locales/{{lng}}/{{ns}}.json'
+    get loadPath () {
+        return `${resolveDefaultLocalesDir()}/{{lng}}/{{ns}}.json`;
+    },
+    get addPath () {
+        return `${resolveDefaultLocalesDir()}/{{lng}}/{{ns}}.json`;
+    }
 };
 function convertPath(path) {
     if (!path) return path;
@@ -16,4 +37,4 @@ function convertBackendOptions(options) {
     if (converted.addPath) converted.addPath = convertPath(converted.addPath);
     return converted;
 }
-export { DEFAULT_I18NEXT_BACKEND_OPTIONS, convertBackendOptions };
+export { DEFAULT_I18NEXT_BACKEND_OPTIONS, convertBackendOptions, resolveDefaultLocalesDir };

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

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

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

@@ -40,14 +40,6 @@ async function createI18nextInstance() {
         return null;
     }
 }
-async function tryImportReactI18next() {
-    try {
-        const reactI18next = await import("react-i18next");
-        return reactI18next;
-    } catch (error) {
-        return null;
-    }
-}
 function getI18nextInstanceForProvider(instance) {
     if (isI18nWrapperInstance(instance)) {
         const i18nextInstance = getI18nWrapperI18nextInstance(instance);
@@ -64,14 +56,4 @@ async function getI18nInstance(userInstance) {
     if (i18nextInstance) return i18nextInstance;
     throw new Error('No i18n instance found');
 }
-async function getInitReactI18next() {
-    const reactI18nextModule = await tryImportReactI18next();
-    if (reactI18nextModule) return reactI18nextModule.initReactI18next;
-    return null;
-}
-async function getI18nextProvider() {
-    const reactI18nextModule = await tryImportReactI18next();
-    if (reactI18nextModule) return reactI18nextModule.I18nextProvider;
-    return null;
-}
-export { getActualI18nextInstance, getI18nInstance, getI18nWrapperI18nextInstance, getI18nextInstanceForProvider, getI18nextProvider, getInitReactI18next, isI18nInstance, isI18nWrapperInstance };
+export { getActualI18nextInstance, getI18nInstance, getI18nWrapperI18nextInstance, getI18nextInstanceForProvider, isI18nInstance, isI18nWrapperInstance };

package/dist/esm/runtime/i18n/react-i18next.mjs

@@ -0,0 +1,15 @@
+async function tryImportReactI18next() {
+    try {
+        return await import("react-i18next");
+    } catch (error) {
+        return null;
+    }
+}
+async function getReactI18nextIntegration() {
+    const reactI18nextModule = await tryImportReactI18next();
+    return {
+        I18nextProvider: reactI18nextModule?.I18nextProvider ?? null,
+        initReactI18next: reactI18nextModule?.initReactI18next ?? null
+    };
+}
+export { getReactI18nextIntegration };

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

@@ -100,18 +100,6 @@ const initializeI18nInstance = async (i18nInstance, finalLanguage, fallbackLangu
                 };
             }
         }
-        if (mergedBackend && hasOptions(i18nInstance)) {
-            const defaultNS = initOptions.defaultNS || initOptions.ns || 'translation';
-            const ns = Array.isArray(defaultNS) ? defaultNS[0] : defaultNS;
-            let retries = 20;
-            while(retries > 0){
-                const actualInstance = getActualI18nextInstance(i18nInstance);
-                const store = actualInstance.store;
-                if (store?.data?.[finalLanguage]?.[ns]) break;
-                await new Promise((resolve)=>setTimeout(resolve, 100));
-                retries--;
-            }
-        }
     }
 };
 function hasOptions(instance) {

package/dist/esm/runtime/index.mjs

@@ -10,26 +10,31 @@ import { mergeBackendOptions } from "./i18n/backend/index.mjs";
 import { useI18nextBackend } from "./i18n/backend/middleware.mjs";
 import { detectLanguageWithPriority, exportServerLngToWindow, mergeDetectionOptions } from "./i18n/detection/index.mjs";
 import { useI18nextLanguageDetector } from "./i18n/detection/middleware.mjs";
-import { getI18nextInstanceForProvider, getI18nextProvider, getInitReactI18next } from "./i18n/instance.mjs";
+import { getI18nextInstanceForProvider } from "./i18n/instance.mjs";
 import { changeI18nLanguage, ensureLanguageMatch, initializeI18nInstance, setupClonedInstance } from "./i18n/utils.mjs";
-import { getPathname } from "./utils.mjs";
+import { buildLocalizedUrl, getPathname, splitUrlTarget } from "./utils.mjs";
 import "./types.mjs";
 const i18nPlugin = (options)=>({
         name: '@modern-js/plugin-i18n',
         setup: (api)=>{
-            const { entryName, i18nInstance: userI18nInstance, initOptions, localeDetection, backend, htmlLangAttr = false } = options;
-            const { localePathRedirect = false, i18nextDetector = true, languages = [], fallbackLanguage = 'en', detection, ignoreRedirectRoutes } = localeDetection || {};
+            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 { enabled: backendEnabled = false } = backend || {};
             let latestI18nInstance;
             let I18nextProvider;
+            const loadReactI18nextIntegration = async ()=>{
+                if (!reactI18next) return null;
+                const { getReactI18nextIntegration } = await import("./i18n/react-i18next.mjs");
+                return getReactI18nextIntegration();
+            };
             api.onBeforeRender(async (context)=>{
                 let i18nInstance = await getI18nInstance(userI18nInstance);
                 const { i18n: otherConfig } = api.getRuntimeConfig();
                 const { initOptions: otherInitOptions } = otherConfig || {};
                 const userInitOptions = merge(otherInitOptions || {}, initOptions || {});
-                const initReactI18next = await getInitReactI18next();
-                I18nextProvider = await getI18nextProvider();
-                if (initReactI18next) i18nInstance.use(initReactI18next);
+                const reactI18nextIntegration = await loadReactI18nextIntegration();
+                I18nextProvider = reactI18nextIntegration?.I18nextProvider ?? null;
+                if (reactI18nextIntegration?.initReactI18next) i18nInstance.use(reactI18nextIntegration.initReactI18next);
                 const pathname = getPathname(context);
                 if (i18nextDetector) useI18nextLanguageDetector(i18nInstance);
                 const mergedDetection = mergeDetectionOptions(i18nextDetector, detection, localePathRedirect, userInitOptions);
@@ -89,16 +94,18 @@ const i18nPlugin = (options)=>({
                     ]);
                     useSdkResourcesLoader(i18nInstance, setForceUpdate);
                     useLanguageSync(i18nInstance, localePathRedirect, languages, runtimeContextRef, prevLangRef, setLang);
-                    useClientSideRedirect(i18nInstance, localePathRedirect, languages, fallbackLanguage, ignoreRedirectRoutes);
-                    const contextValue = useMemo(()=>createContextValue(lang, i18nInstance, entryName, languages, localePathRedirect, ignoreRedirectRoutes, setLang), [
+                    useClientSideRedirect(i18nInstance, localePathRedirect, languages, fallbackLanguage, ignoreRedirectRoutes, localisedUrls);
+                    const contextValue = useMemo(()=>createContextValue(lang, i18nInstance, entryName, languages, localePathRedirect, ignoreRedirectRoutes, localisedUrls, setLang), [
                         lang,
                         i18nInstance,
                         entryName,
                         languages,
                         localePathRedirect,
                         ignoreRedirectRoutes,
+                        localisedUrls,
                         forceUpdate
                     ]);
+                    const children = props.children;
                     const appContent = /*#__PURE__*/ jsxs(Fragment, {
                         children: [
                             Boolean(htmlLangAttr) && /*#__PURE__*/ jsx(Helmet, {
@@ -108,9 +115,10 @@ const i18nPlugin = (options)=>({
                             }),
                             /*#__PURE__*/ jsx(ModernI18nProvider, {
                                 value: contextValue,
-                                children: /*#__PURE__*/ jsx(App, {
-                                    ...props
-                                })
+                                children: App ? /*#__PURE__*/ jsx(App, {
+                                    ...props,
+                                    children: children
+                                }) : children
                             })
                         ]
                     });
@@ -128,5 +136,7 @@ const i18nPlugin = (options)=>({
     });
 const runtime = i18nPlugin;
 export { I18nLink } from "./I18nLink.mjs";
+export { Link } from "./Link.mjs";
+export { canonicalPath, localizePath, useLocalizedLocation, useLocalizedPaths } from "./localizedPaths.mjs";
 export default runtime;
-export { i18nPlugin, useModernI18n };
+export { buildLocalizedUrl, i18nPlugin, splitUrlTarget, useModernI18n };

package/dist/esm/runtime/localizedPaths.mjs

@@ -0,0 +1,55 @@
+import { useMemo } from "react";
+import { canonicalTargetPathname } from "../shared/localisedUrls.mjs";
+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 canonicalPath = (target, config)=>{
+    const { pathname, search, hash } = splitUrlTarget(target);
+    const resolvedPath = canonicalTargetPathname(pathname, config.languages, config.localisedUrls);
+    return `${resolvedPath}${search}${hash}`;
+};
+const useLocalizedPaths = ()=>{
+    const { supportedLanguages, localisedUrls } = useModernI18n();
+    return useMemo(()=>{
+        const config = {
+            languages: supportedLanguages,
+            localisedUrls
+        };
+        return {
+            localizePath: (pathname, language)=>localizePath(pathname, language, config),
+            canonicalPath: (pathname)=>canonicalPath(pathname, config)
+        };
+    }, [
+        supportedLanguages,
+        localisedUrls
+    ]);
+};
+const useLocalizedLocation = ()=>{
+    const { language, supportedLanguages, localisedUrls } = useModernI18n();
+    const { location } = useI18nRouterAdapter();
+    const pathname = location?.pathname ?? '/';
+    const search = location?.search ?? '';
+    const hash = location?.hash ?? '';
+    return useMemo(()=>{
+        const config = {
+            languages: supportedLanguages,
+            localisedUrls
+        };
+        const alternates = {};
+        for (const supportedLanguage of supportedLanguages)alternates[supportedLanguage] = `${localizePath(pathname, supportedLanguage, config)}${search}${hash}`;
+        return {
+            language,
+            canonical: canonicalPath(pathname, config),
+            alternates
+        };
+    }, [
+        language,
+        supportedLanguages,
+        localisedUrls,
+        pathname,
+        search,
+        hash
+    ]);
+};
+export { canonicalPath, localizePath, useLocalizedLocation, useLocalizedPaths };