@bleedingdev/modern-js-plugin-i18n 3.2.0-ultramodern.119 → 3.2.0-ultramodern.120

package/dist/cjs/runtime/localizedPaths.js

@@ -0,0 +1,105 @@
+"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__, {
+    canonicalPath: ()=>canonicalPath,
+    localizePath: ()=>localizePath,
+    useLocalizedLocation: ()=>useLocalizedLocation,
+    useLocalizedPaths: ()=>useLocalizedPaths
+});
+const external_react_namespaceObject = require("react");
+const localisedUrls_js_namespaceObject = require("../shared/localisedUrls.js");
+const external_context_js_namespaceObject = require("./context.js");
+const external_routerAdapter_js_namespaceObject = require("./routerAdapter.js");
+const external_utils_js_namespaceObject = require("./utils.js");
+const localizePath = (pathname, language, config)=>(0, external_utils_js_namespaceObject.buildLocalizedUrl)(pathname, language, config.languages, config.localisedUrls);
+const canonicalPath = (target, config)=>{
+    const { pathname, search, hash } = (0, external_utils_js_namespaceObject.splitUrlTarget)(target);
+    const segments = pathname.split('/').filter(Boolean);
+    const pathWithoutLanguage = segments.length > 0 && config.languages.includes(segments[0]) ? `/${segments.slice(1).join('/')}` : pathname || '/';
+    const localisedUrlsConfig = (0, localisedUrls_js_namespaceObject.resolveLocalisedUrlsConfig)(config.localisedUrls);
+    const resolvedPath = localisedUrlsConfig.enabled ? (0, localisedUrls_js_namespaceObject.resolveCanonicalLocalisedPath)(pathWithoutLanguage, config.languages, localisedUrlsConfig.map) : pathWithoutLanguage;
+    return `${resolvedPath}${search}${hash}`;
+};
+const useLocalizedPaths = ()=>{
+    const { supportedLanguages, localisedUrls } = (0, external_context_js_namespaceObject.useModernI18n)();
+    return (0, external_react_namespaceObject.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 } = (0, external_context_js_namespaceObject.useModernI18n)();
+    const { location } = (0, external_routerAdapter_js_namespaceObject.useI18nRouterAdapter)();
+    const pathname = location?.pathname ?? '/';
+    const search = location?.search ?? '';
+    const hash = location?.hash ?? '';
+    return (0, external_react_namespaceObject.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
+    ]);
+};
+exports.canonicalPath = __webpack_exports__.canonicalPath;
+exports.localizePath = __webpack_exports__.localizePath;
+exports.useLocalizedLocation = __webpack_exports__.useLocalizedLocation;
+exports.useLocalizedPaths = __webpack_exports__.useLocalizedPaths;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "canonicalPath",
+    "localizePath",
+    "useLocalizedLocation",
+    "useLocalizedPaths"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/utils.js

@@ -33,7 +33,8 @@ __webpack_require__.d(__webpack_exports__, {
     getEntryPath: ()=>getEntryPath,
     getLanguageFromPath: ()=>getLanguageFromPath,
     getPathname: ()=>getPathname,
-    shouldIgnoreRedirect: ()=>shouldIgnoreRedirect
+    shouldIgnoreRedirect: ()=>shouldIgnoreRedirect,
+    splitUrlTarget: ()=>splitUrlTarget
 });
 const runtime_namespaceObject = require("@modern-js/runtime");
 const context_namespaceObject = require("@modern-js/runtime/context");
@@ -53,16 +54,30 @@ const getLanguageFromPath = (pathname, languages, fallbackLanguage)=>{
     if (languages.includes(firstSegment)) return firstSegment;
     return fallbackLanguage;
 };
-const buildLocalizedUrl = (pathname, language, languages, localisedUrls)=>{
+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 { pathname, search, hash } = splitUrlTarget(target);
     const segments = pathname.split('/').filter(Boolean);
     const localisedUrlsConfig = (0, localisedUrls_js_namespaceObject.resolveLocalisedUrlsConfig)(localisedUrls);
-    const pathWithoutLanguage = segments.length > 0 && languages.includes(segments[0]) ? `/${segments.slice(1).join('/')}` : pathname;
+    const pathWithoutLanguage = segments.length > 0 && languages.includes(segments[0]) ? `/${segments.slice(1).join('/')}` : pathname || '/';
     const resolvedPath = localisedUrlsConfig.enabled ? (0, localisedUrls_js_namespaceObject.resolveLocalisedPath)(pathWithoutLanguage, language, languages, localisedUrlsConfig.map) : pathWithoutLanguage;
     const resolvedSegments = resolvedPath.split('/').filter(Boolean);
     return `/${[
         language,
         ...resolvedSegments
-    ].join('/')}`;
+    ].join('/')}${search}${hash}`;
 };
 const detectLanguageFromPath = (pathname, languages, localePathRedirect)=>{
     if (!localePathRedirect) return {
@@ -96,13 +111,15 @@ exports.getEntryPath = __webpack_exports__.getEntryPath;
 exports.getLanguageFromPath = __webpack_exports__.getLanguageFromPath;
 exports.getPathname = __webpack_exports__.getPathname;
 exports.shouldIgnoreRedirect = __webpack_exports__.shouldIgnoreRedirect;
+exports.splitUrlTarget = __webpack_exports__.splitUrlTarget;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "buildLocalizedUrl",
     "detectLanguageFromPath",
     "getEntryPath",
     "getLanguageFromPath",
     "getPathname",
-    "shouldIgnoreRedirect"
+    "shouldIgnoreRedirect",
+    "splitUrlTarget"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/cjs/shared/localisedUrls.js

@@ -129,7 +129,7 @@ const transformLocalisedRoute = (route, parentCanonicalPath, parentLocalisedPath
     if (!localisedUrlEntry) return [
         baseRoute
     ];
-    return getLocalisedRoutePaths(canonicalPath, parentLocalisedPaths, languages, localisedUrlEntry).map((localisedPath, index)=>cloneRouteWithLocalisedPath(baseRoute, localisedPath, index));
+    return getLocalisedRoutePaths(canonicalPath, parentLocalisedPaths, languages, localisedUrlEntry).map((localisedPath, index)=>cloneRouteWithLocalisedPath(baseRoute, localisedPath, index, canonicalPath));
 };
 const legalRouteIdPart = (value)=>value.replace(/[^a-zA-Z0-9_$-]+/g, '_').replace(/^_+|_+$/g, '') || 'index';
 const suffixRouteIds = (route, suffix)=>{
@@ -144,13 +144,14 @@ const suffixRouteIds = (route, suffix)=>{
         } : {}
     };
 };
-const cloneRouteWithLocalisedPath = (route, path, index)=>{
+const cloneRouteWithLocalisedPath = (route, path, index, canonicalPath)=>{
     const leadingLocaleParam = getLeadingLocaleParam(route.path);
     const localisedPath = leadingLocaleParam ? normaliseRoutePath(`${leadingLocaleParam}/${path}`) : path;
     const routeWithPath = {
         ...route,
         path: localisedPath
     };
+    routeWithPath.modernCanonicalPath = canonicalPath;
     return 0 === index ? routeWithPath : suffixRouteIds(routeWithPath, legalRouteIdPart(localisedPath));
 };
 const applyLocalisedUrlsToRoutes = (routes, languages, localisedUrls)=>{
@@ -206,6 +207,12 @@ const buildPathFromPattern = (pattern, params)=>{
 };
 const resolveLocalisedPath = (pathname, targetLanguage, languages, localisedUrls)=>{
     const normalizedPathname = normalisePathPattern(pathname);
+    for (const [canonicalPattern, localisedUrlEntry] of Object.entries(localisedUrls)){
+        const targetPattern = localisedUrlEntry[targetLanguage];
+        if (!targetPattern) continue;
+        const params = matchPathPattern(normalizedPathname, canonicalPattern);
+        if (params) return buildPathFromPattern(targetPattern, params);
+    }
     for (const localisedUrlEntry of Object.values(localisedUrls)){
         const targetPattern = localisedUrlEntry[targetLanguage];
         if (targetPattern) for (const language of languages){
@@ -217,21 +224,44 @@ const resolveLocalisedPath = (pathname, targetLanguage, languages, localisedUrls
     }
     return normalizedPathname;
 };
+const resolveCanonicalLocalisedPath = (pathname, languages, localisedUrls)=>{
+    const normalizedPathname = normalisePathPattern(pathname);
+    for (const [canonicalPattern, localisedUrlEntry] of Object.entries(localisedUrls)){
+        const canonicalParams = matchPathPattern(normalizedPathname, canonicalPattern);
+        if (canonicalParams) return buildPathFromPattern(canonicalPattern, canonicalParams);
+        for (const language of languages){
+            const sourcePattern = localisedUrlEntry[language];
+            if (!sourcePattern) continue;
+            const params = matchPathPattern(normalizedPathname, sourcePattern);
+            if (params) return buildPathFromPattern(canonicalPattern, params);
+        }
+    }
+    return normalizedPathname;
+};
 __webpack_require__.d(__webpack_exports__, {}, {
     applyLocalisedUrlsToRoutes: applyLocalisedUrlsToRoutes,
+    buildPathFromPattern: buildPathFromPattern,
+    matchPathPattern: matchPathPattern,
     normalisePathPattern: normalisePathPattern,
+    resolveCanonicalLocalisedPath: resolveCanonicalLocalisedPath,
     resolveLocalisedPath: resolveLocalisedPath,
     resolveLocalisedUrlsConfig: resolveLocalisedUrlsConfig,
     validateLocalisedUrls: validateLocalisedUrls
 });
 exports.applyLocalisedUrlsToRoutes = __webpack_exports__.applyLocalisedUrlsToRoutes;
+exports.buildPathFromPattern = __webpack_exports__.buildPathFromPattern;
+exports.matchPathPattern = __webpack_exports__.matchPathPattern;
 exports.normalisePathPattern = __webpack_exports__.normalisePathPattern;
+exports.resolveCanonicalLocalisedPath = __webpack_exports__.resolveCanonicalLocalisedPath;
 exports.resolveLocalisedPath = __webpack_exports__.resolveLocalisedPath;
 exports.resolveLocalisedUrlsConfig = __webpack_exports__.resolveLocalisedUrlsConfig;
 exports.validateLocalisedUrls = __webpack_exports__.validateLocalisedUrls;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "applyLocalisedUrlsToRoutes",
+    "buildPathFromPattern",
+    "matchPathPattern",
     "normalisePathPattern",
+    "resolveCanonicalLocalisedPath",
     "resolveLocalisedPath",
     "resolveLocalisedUrlsConfig",
     "validateLocalisedUrls"

package/dist/esm/runtime/I18nLink.mjs

@@ -1,23 +1,13 @@
 import { jsx } from "react/jsx-runtime";
-import { useModernI18n } from "./context.mjs";
-import { useI18nRouterAdapter } from "./routerAdapter.mjs";
-import { buildLocalizedUrl } from "./utils.mjs";
+import { Link } from "./Link.mjs";
+let warnedDeprecation = false;
 const I18nLink = ({ to, children, ...props })=>{
-    const { Link, params, hasRouter } = useI18nRouterAdapter();
-    const { language, supportedLanguages, localisedUrls } = useModernI18n();
-    const currentLang = language;
-    const localizedTo = buildLocalizedUrl(to, currentLang, supportedLanguages, localisedUrls);
-    if ('development' === process.env.NODE_ENV && hasRouter && !params.lang) console.warn("I18nLink is being used outside of a :lang dynamic route context. This may cause unexpected behavior. Please ensure I18nLink is used within a route that has a :lang parameter.");
-    if (!hasRouter || !Link) {
-        const { prefetch: _prefetch, preload: _preload, ...anchorProps } = props;
-        return /*#__PURE__*/ jsx("a", {
-            href: localizedTo,
-            ...anchorProps,
-            children: children
-        });
+    if ('development' === process.env.NODE_ENV && !warnedDeprecation) {
+        warnedDeprecation = true;
+        console.warn("[plugin-i18n] I18nLink is deprecated. Import { Link } from '@modern-js/plugin-i18n/runtime' instead — it accepts the same language-agnostic `to` values.");
     }
     return /*#__PURE__*/ jsx(Link, {
-        to: localizedTo,
+        to: to,
         ...props,
         children: children
     });

package/dist/esm/runtime/Link.mjs

@@ -0,0 +1,209 @@
+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, ...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 { prefetch: _prefetch, preload: _preload, replace: _replace, ...anchorProps } = rest;
+        return /*#__PURE__*/ jsx("a", {
+            href: to,
+            ...anchorProps,
+            children: children
+        });
+    }
+    const { Link: RouterLink, hasRouter, framework } = adapter;
+    if (!hasRouter || !RouterLink) {
+        const { prefetch: _prefetch, preload: _preload, 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) return /*#__PURE__*/ jsx(RouterLink, {
+        to: target.localizedPathname,
+        ...target.searchObject ? {
+            search: target.searchObject
+        } : {},
+        ...target.hash ? {
+            hash: target.hash
+        } : {},
+        ...void 0 === hashScrollIntoView ? {} : {
+            hashScrollIntoView
+        },
+        ...rest,
+        ...activeRest,
+        ...activeAttributes,
+        className: mergedClassName,
+        style: mergedStyle,
+        children: children
+    });
+    return /*#__PURE__*/ jsx(RouterLink, {
+        to: target.href,
+        ...rest,
+        ...activeRest,
+        ...activeAttributes,
+        className: mergedClassName,
+        style: mergedStyle,
+        children: children
+    });
+};
+const runtime_Link = Link;
+export default runtime_Link;
+export { Link, interpolateRouteParams };

package/dist/esm/runtime/index.mjs

@@ -12,7 +12,7 @@ import { detectLanguageWithPriority, exportServerLngToWindow, mergeDetectionOpti
 import { useI18nextLanguageDetector } from "./i18n/detection/middleware.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',
@@ -136,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,58 @@
+import { useMemo } from "react";
+import { resolveCanonicalLocalisedPath, resolveLocalisedUrlsConfig } 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 segments = pathname.split('/').filter(Boolean);
+    const pathWithoutLanguage = segments.length > 0 && config.languages.includes(segments[0]) ? `/${segments.slice(1).join('/')}` : pathname || '/';
+    const localisedUrlsConfig = resolveLocalisedUrlsConfig(config.localisedUrls);
+    const resolvedPath = localisedUrlsConfig.enabled ? resolveCanonicalLocalisedPath(pathWithoutLanguage, config.languages, localisedUrlsConfig.map) : pathWithoutLanguage;
+    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 };

package/dist/esm/runtime/utils.mjs

@@ -16,16 +16,30 @@ const getLanguageFromPath = (pathname, languages, fallbackLanguage)=>{
     if (languages.includes(firstSegment)) return firstSegment;
     return fallbackLanguage;
 };
-const buildLocalizedUrl = (pathname, language, languages, localisedUrls)=>{
+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 { pathname, search, hash } = splitUrlTarget(target);
     const segments = pathname.split('/').filter(Boolean);
     const localisedUrlsConfig = resolveLocalisedUrlsConfig(localisedUrls);
-    const pathWithoutLanguage = segments.length > 0 && languages.includes(segments[0]) ? `/${segments.slice(1).join('/')}` : pathname;
+    const pathWithoutLanguage = segments.length > 0 && languages.includes(segments[0]) ? `/${segments.slice(1).join('/')}` : pathname || '/';
     const resolvedPath = localisedUrlsConfig.enabled ? resolveLocalisedPath(pathWithoutLanguage, language, languages, localisedUrlsConfig.map) : pathWithoutLanguage;
     const resolvedSegments = resolvedPath.split('/').filter(Boolean);
     return `/${[
         language,
         ...resolvedSegments
-    ].join('/')}`;
+    ].join('/')}${search}${hash}`;
 };
 const detectLanguageFromPath = (pathname, languages, localePathRedirect)=>{
     if (!localePathRedirect) return {
@@ -53,4 +67,4 @@ const shouldIgnoreRedirect = (pathname, languages, ignoreRedirectRoutes)=>{
     if ('function' == typeof ignoreRedirectRoutes) return ignoreRedirectRoutes(normalizedPath);
     return ignoreRedirectRoutes.some((pattern)=>normalizedPath === pattern || normalizedPath.startsWith(`${pattern}/`));
 };
-export { buildLocalizedUrl, detectLanguageFromPath, getEntryPath, getLanguageFromPath, getPathname, shouldIgnoreRedirect };
+export { buildLocalizedUrl, detectLanguageFromPath, getEntryPath, getLanguageFromPath, getPathname, shouldIgnoreRedirect, splitUrlTarget };

package/dist/esm/shared/localisedUrls.mjs

@@ -100,7 +100,7 @@ const transformLocalisedRoute = (route, parentCanonicalPath, parentLocalisedPath
     if (!localisedUrlEntry) return [
         baseRoute
     ];
-    return getLocalisedRoutePaths(canonicalPath, parentLocalisedPaths, languages, localisedUrlEntry).map((localisedPath, index)=>cloneRouteWithLocalisedPath(baseRoute, localisedPath, index));
+    return getLocalisedRoutePaths(canonicalPath, parentLocalisedPaths, languages, localisedUrlEntry).map((localisedPath, index)=>cloneRouteWithLocalisedPath(baseRoute, localisedPath, index, canonicalPath));
 };
 const legalRouteIdPart = (value)=>value.replace(/[^a-zA-Z0-9_$-]+/g, '_').replace(/^_+|_+$/g, '') || 'index';
 const suffixRouteIds = (route, suffix)=>{
@@ -115,13 +115,14 @@ const suffixRouteIds = (route, suffix)=>{
         } : {}
     };
 };
-const cloneRouteWithLocalisedPath = (route, path, index)=>{
+const cloneRouteWithLocalisedPath = (route, path, index, canonicalPath)=>{
     const leadingLocaleParam = getLeadingLocaleParam(route.path);
     const localisedPath = leadingLocaleParam ? normaliseRoutePath(`${leadingLocaleParam}/${path}`) : path;
     const routeWithPath = {
         ...route,
         path: localisedPath
     };
+    routeWithPath.modernCanonicalPath = canonicalPath;
     return 0 === index ? routeWithPath : suffixRouteIds(routeWithPath, legalRouteIdPart(localisedPath));
 };
 const applyLocalisedUrlsToRoutes = (routes, languages, localisedUrls)=>{
@@ -177,6 +178,12 @@ const buildPathFromPattern = (pattern, params)=>{
 };
 const resolveLocalisedPath = (pathname, targetLanguage, languages, localisedUrls)=>{
     const normalizedPathname = normalisePathPattern(pathname);
+    for (const [canonicalPattern, localisedUrlEntry] of Object.entries(localisedUrls)){
+        const targetPattern = localisedUrlEntry[targetLanguage];
+        if (!targetPattern) continue;
+        const params = matchPathPattern(normalizedPathname, canonicalPattern);
+        if (params) return buildPathFromPattern(targetPattern, params);
+    }
     for (const localisedUrlEntry of Object.values(localisedUrls)){
         const targetPattern = localisedUrlEntry[targetLanguage];
         if (targetPattern) for (const language of languages){
@@ -188,4 +195,18 @@ const resolveLocalisedPath = (pathname, targetLanguage, languages, localisedUrls
     }
     return normalizedPathname;
 };
-export { applyLocalisedUrlsToRoutes, normalisePathPattern, resolveLocalisedPath, resolveLocalisedUrlsConfig, validateLocalisedUrls };
+const resolveCanonicalLocalisedPath = (pathname, languages, localisedUrls)=>{
+    const normalizedPathname = normalisePathPattern(pathname);
+    for (const [canonicalPattern, localisedUrlEntry] of Object.entries(localisedUrls)){
+        const canonicalParams = matchPathPattern(normalizedPathname, canonicalPattern);
+        if (canonicalParams) return buildPathFromPattern(canonicalPattern, canonicalParams);
+        for (const language of languages){
+            const sourcePattern = localisedUrlEntry[language];
+            if (!sourcePattern) continue;
+            const params = matchPathPattern(normalizedPathname, sourcePattern);
+            if (params) return buildPathFromPattern(canonicalPattern, params);
+        }
+    }
+    return normalizedPathname;
+};
+export { applyLocalisedUrlsToRoutes, buildPathFromPattern, matchPathPattern, normalisePathPattern, resolveCanonicalLocalisedPath, resolveLocalisedPath, resolveLocalisedUrlsConfig, validateLocalisedUrls };