@bleedingdev/modern-js-plugin-i18n 3.5.0-ultramodern.30 → 3.5.0-ultramodern.31

package/dist/esm/shared/localisedUrls/pathname.mjs

@@ -0,0 +1,24 @@
+import { resolveLocalisedUrlsConfig } from "./config.mjs";
+import { resolveCanonicalLocalisedPath, resolveLocalisedPath } from "./resolve.mjs";
+const stripLanguagePrefix = (pathname, languages)=>{
+    const segments = pathname.split('/').filter(Boolean);
+    const firstSegment = segments[0]?.toLowerCase();
+    if (firstSegment && languages.some((language)=>language.toLowerCase() === firstSegment)) return `/${segments.slice(1).join('/')}`;
+    return pathname || '/';
+};
+const localiseTargetPathname = (pathname, language, languages, localisedUrls)=>{
+    const pathWithoutLanguage = stripLanguagePrefix(pathname, languages);
+    const localisedUrlsConfig = resolveLocalisedUrlsConfig(localisedUrls);
+    const resolvedPath = localisedUrlsConfig.enabled ? resolveLocalisedPath(pathWithoutLanguage, language, languages, localisedUrlsConfig.map) : pathWithoutLanguage;
+    const resolvedSegments = resolvedPath.split('/').filter(Boolean);
+    return `/${[
+        language,
+        ...resolvedSegments
+    ].join('/')}`;
+};
+const canonicalTargetPathname = (pathname, languages, localisedUrls)=>{
+    const pathWithoutLanguage = stripLanguagePrefix(pathname, languages);
+    const localisedUrlsConfig = resolveLocalisedUrlsConfig(localisedUrls);
+    return localisedUrlsConfig.enabled ? resolveCanonicalLocalisedPath(pathWithoutLanguage, languages, localisedUrlsConfig.map) : pathWithoutLanguage;
+};
+export { canonicalTargetPathname, localiseTargetPathname };

package/dist/esm/shared/localisedUrls/patterns.mjs

@@ -0,0 +1,86 @@
+import { normalisePathPattern, normalisePathname } from "./normalise.mjs";
+const escapeRegExp = (value)=>value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+const getParamName = (segment)=>segment.slice(1).replace(/\?$/, '');
+const compiledPathPatternCache = new Map();
+const compilePathPattern = (pattern)=>{
+    const normalizedPattern = normalisePathPattern(pattern);
+    const cached = compiledPathPatternCache.get(normalizedPattern);
+    if (cached) return cached;
+    const names = [];
+    const segments = normalizedPattern.split('/').filter(Boolean);
+    const source = segments.map((segment)=>{
+        if (segment.startsWith(':')) {
+            names.push(getParamName(segment));
+            const paramPattern = '([^/]+)';
+            return segment.endsWith('?') ? `(?:/${paramPattern})?` : `/${paramPattern}`;
+        }
+        if ('*' === segment) {
+            names.push('*');
+            return '/(.*)';
+        }
+        return `/${escapeRegExp(segment)}`;
+    }).join('');
+    const compiled = {
+        names,
+        regexp: new RegExp(`^${source || '/'}$`)
+    };
+    compiledPathPatternCache.set(normalizedPattern, compiled);
+    return compiled;
+};
+const getPatternSpecificity = (pattern)=>{
+    const segments = normalisePathPattern(pattern).split('/').filter(Boolean);
+    let staticSegments = 0;
+    let dynamicSegments = 0;
+    let splatSegments = 0;
+    for (const segment of segments)if ('*' === segment) splatSegments++;
+    else if (segment.startsWith(':')) dynamicSegments++;
+    else staticSegments++;
+    return {
+        staticSegments,
+        dynamicSegments,
+        splatSegments,
+        totalSegments: segments.length
+    };
+};
+const comparePatternSpecificity = (left, right)=>{
+    const a = getPatternSpecificity(left);
+    const b = getPatternSpecificity(right);
+    return b.staticSegments - a.staticSegments || b.totalSegments - a.totalSegments || a.splatSegments - b.splatSegments || a.dynamicSegments - b.dynamicSegments;
+};
+const sortPatternsBySpecificity = (patterns)=>patterns.map((pattern, index)=>({
+            pattern,
+            index
+        })).sort((left, right)=>comparePatternSpecificity(left.pattern.pattern, right.pattern.pattern) || left.index - right.index).map(({ pattern })=>pattern);
+const decodePathParam = (value)=>{
+    try {
+        return decodeURIComponent(value);
+    } catch  {
+        return null;
+    }
+};
+const encodeSplatParam = (value)=>value.split('/').map(encodeURIComponent).join('/');
+const matchPathPattern = (pathname, pattern)=>{
+    const { names, regexp } = compilePathPattern(pattern);
+    const match = regexp.exec(normalisePathname(pathname));
+    if (!match) return null;
+    const params = {};
+    for(let index = 0; index < names.length; index++){
+        const decoded = decodePathParam(match[index + 1] || '');
+        if (null === decoded) return null;
+        params[names[index]] = decoded;
+    }
+    return params;
+};
+const buildPathFromPattern = (pattern, params)=>{
+    const segments = normalisePathPattern(pattern).split('/').filter(Boolean);
+    const path = segments.map((segment)=>{
+        if (segment.startsWith(':')) {
+            const param = params[getParamName(segment)];
+            return param ? encodeURIComponent(param) : '';
+        }
+        if ('*' === segment) return encodeSplatParam(params['*'] || '');
+        return segment;
+    }).filter(Boolean).join('/');
+    return `/${path}`;
+};
+export { buildPathFromPattern, matchPathPattern, sortPatternsBySpecificity };

package/dist/esm/shared/localisedUrls/resolve.mjs

@@ -0,0 +1,50 @@
+import { normalisePathname } from "./normalise.mjs";
+import { buildPathFromPattern, matchPathPattern, sortPatternsBySpecificity } from "./patterns.mjs";
+const resolveLocalisedPath = (pathname, targetLanguage, languages, localisedUrls)=>{
+    const normalizedPathname = normalisePathname(pathname);
+    const canonicalCandidates = sortPatternsBySpecificity(Object.entries(localisedUrls).map(([canonicalPattern, localisedUrlEntry])=>({
+            pattern: canonicalPattern,
+            canonicalPattern,
+            localisedUrlEntry
+        })));
+    for (const { canonicalPattern, localisedUrlEntry } of canonicalCandidates){
+        const targetPattern = localisedUrlEntry[targetLanguage];
+        if (!targetPattern) continue;
+        const params = matchPathPattern(normalizedPathname, canonicalPattern);
+        if (params) return buildPathFromPattern(targetPattern, params);
+    }
+    const localisedCandidates = sortPatternsBySpecificity(Object.values(localisedUrls).flatMap((localisedUrlEntry)=>{
+        const targetPattern = localisedUrlEntry[targetLanguage];
+        if (!targetPattern) return [];
+        return languages.map((language)=>localisedUrlEntry[language]).filter((sourcePattern)=>Boolean(sourcePattern)).map((sourcePattern)=>({
+                pattern: sourcePattern,
+                sourcePattern,
+                targetPattern
+            }));
+    }));
+    for (const { sourcePattern, targetPattern } of localisedCandidates){
+        const params = matchPathPattern(normalizedPathname, sourcePattern);
+        if (params) return buildPathFromPattern(targetPattern, params);
+    }
+    return normalizedPathname;
+};
+const resolveCanonicalLocalisedPath = (pathname, languages, localisedUrls)=>{
+    const normalizedPathname = normalisePathname(pathname);
+    const canonicalCandidates = sortPatternsBySpecificity(Object.entries(localisedUrls).map(([canonicalPattern, localisedUrlEntry])=>({
+            pattern: canonicalPattern,
+            canonicalPattern,
+            localisedUrlEntry
+        })));
+    for (const { canonicalPattern, localisedUrlEntry } of canonicalCandidates){
+        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 { resolveCanonicalLocalisedPath, resolveLocalisedPath };

package/dist/esm/shared/localisedUrls/routes.mjs

@@ -0,0 +1,88 @@
+import { getLeadingLocaleParam, normalisePathPattern, normaliseRoutePath, stripLeadingLocaleParam } from "./normalise.mjs";
+const isLocalisableRoutePath = (path)=>{
+    const pathWithoutLocale = stripLeadingLocaleParam(path);
+    if (!pathWithoutLocale || '/' === pathWithoutLocale || '*' === pathWithoutLocale) return false;
+    return true;
+};
+const joinPath = (parentPath, routePath)=>{
+    if (!isLocalisableRoutePath(routePath)) return parentPath;
+    const segment = normaliseRoutePath(stripLeadingLocaleParam(routePath) || '');
+    return normalisePathPattern(`${parentPath}/${segment}`);
+};
+const ensureLocalisedUrlsForPath = (canonicalPath, languages, localisedUrls)=>{
+    const entry = localisedUrls[canonicalPath];
+    if (!entry) throw new Error(`localisedUrls is enabled, but route "${canonicalPath}" does not define localised URLs for languages: ${languages.join(', ')}. Add localisedUrls["${canonicalPath}"] or set localeDetection.localisedUrls to false.`);
+    const missingLanguages = languages.filter((language)=>!entry[language]);
+    if (missingLanguages.length > 0) throw new Error(`localisedUrls["${canonicalPath}"] is missing languages: ${missingLanguages.join(', ')}. Every configured language must have a localised URL.`);
+    return entry;
+};
+const validateLocalisedUrls = (routes, languages, localisedUrls)=>{
+    const visit = (route, parentPath)=>{
+        const canonicalPath = joinPath(parentPath, route.path);
+        if (isLocalisableRoutePath(route.path)) ensureLocalisedUrlsForPath(canonicalPath, languages, localisedUrls);
+        if ('children' in route && route.children) route.children.forEach((child)=>visit(child, canonicalPath));
+    };
+    routes.forEach((route)=>visit(route, ''));
+};
+const getLocalisedRoutePaths = (canonicalPath, parentLocalisedPaths, languages, entry)=>{
+    const paths = languages.map((language)=>{
+        const fullPath = normalisePathPattern(entry[language]);
+        const parentPath = normalisePathPattern(parentLocalisedPaths[language] || '/');
+        if ('/' === parentPath) return normaliseRoutePath(fullPath) || void 0;
+        const parentPrefix = `${parentPath}/`;
+        if (!fullPath.startsWith(parentPrefix)) throw new Error(`localisedUrls["${canonicalPath}"].${language} must be nested under "${parentPath}" because its parent route is localised there.`);
+        return normaliseRoutePath(fullPath.slice(parentPath.length));
+    });
+    return Array.from(new Set(paths.filter(Boolean)));
+};
+const transformLocalisedRoute = (route, parentCanonicalPath, parentLocalisedPaths, languages, localisedUrls)=>{
+    const canonicalPath = joinPath(parentCanonicalPath, route.path);
+    const localisedUrlEntry = isLocalisableRoutePath(route.path) ? ensureLocalisedUrlsForPath(canonicalPath, languages, localisedUrls) : void 0;
+    const routeLocalisedPaths = localisedUrlEntry ? languages.reduce((acc, language)=>{
+        acc[language] = normalisePathPattern(localisedUrlEntry[language]);
+        return acc;
+    }, {}) : parentLocalisedPaths;
+    const children = 'children' in route && route.children ? route.children.flatMap((child)=>transformLocalisedRoute(child, canonicalPath, routeLocalisedPaths, languages, localisedUrls)) : void 0;
+    const baseRoute = {
+        ...route,
+        ...children ? {
+            children
+        } : {}
+    };
+    if (!localisedUrlEntry) return [
+        baseRoute
+    ];
+    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)=>{
+    const children = 'children' in route && route.children ? route.children.map((child)=>suffixRouteIds(child, suffix)) : void 0;
+    return {
+        ...route,
+        ...route.id ? {
+            id: `${route.id}__localised_${suffix}`
+        } : {},
+        ...children ? {
+            children
+        } : {}
+    };
+};
+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)=>{
+    const rootLocalisedPaths = languages.reduce((acc, language)=>{
+        acc[language] = '/';
+        return acc;
+    }, {});
+    validateLocalisedUrls(routes, languages, localisedUrls);
+    return routes.flatMap((route)=>transformLocalisedRoute(route, '', rootLocalisedPaths, languages, localisedUrls));
+};
+export { applyLocalisedUrlsToRoutes, validateLocalisedUrls };

package/dist/esm/shared/localisedUrls.mjs

@@ -1,283 +1 @@
-const LOCALE_PARAM_NAMES = new Set([
-    'lang',
-    'locale',
-    'language'
-]);
-const normaliseSlashes = (path)=>{
-    const withoutDuplicateSlashes = path.replace(/\/+/g, '/');
-    const withLeadingSlash = withoutDuplicateSlashes.startsWith('/') ? withoutDuplicateSlashes : `/${withoutDuplicateSlashes}`;
-    return withLeadingSlash.length > 1 ? withLeadingSlash.replace(/\/+$/, '') : withLeadingSlash;
-};
-const normalisePathPattern = (path)=>normaliseSlashes(path).replace(/\[(.+?)\]/g, ':$1');
-const normalisePathname = (pathname)=>normaliseSlashes(pathname);
-const normaliseRoutePath = (path)=>{
-    const normalized = normalisePathPattern(path);
-    return '/' === normalized ? '' : normalized.slice(1);
-};
-const getLocaleParamSegment = (segment)=>{
-    if (!segment.startsWith(':')) return null;
-    const paramName = segment.slice(1).replace(/\?$/, '');
-    return LOCALE_PARAM_NAMES.has(paramName) ? segment : null;
-};
-const splitPathSegments = (path)=>{
-    if (!path) return [];
-    return normalisePathPattern(path).split('/').filter(Boolean);
-};
-const stripLeadingLocaleParam = (path)=>{
-    const segments = splitPathSegments(path);
-    const leadingLocaleParam = getLocaleParamSegment(segments[0] || '');
-    if (!leadingLocaleParam) return path;
-    const remainingPath = segments.slice(1).join('/');
-    return remainingPath ? `/${remainingPath}` : void 0;
-};
-const getLeadingLocaleParam = (path)=>{
-    const segments = splitPathSegments(path);
-    return getLocaleParamSegment(segments[0] || '');
-};
-const resolveLocalisedUrlsConfig = (option)=>{
-    if (option && 'object' == typeof option && Object.keys(option).length > 0) return {
-        enabled: true,
-        map: option
-    };
-    return {
-        enabled: false,
-        map: {}
-    };
-};
-const isLocalisableRoutePath = (path)=>{
-    const pathWithoutLocale = stripLeadingLocaleParam(path);
-    if (!pathWithoutLocale || '/' === pathWithoutLocale || '*' === pathWithoutLocale) return false;
-    return true;
-};
-const joinPath = (parentPath, routePath)=>{
-    if (!isLocalisableRoutePath(routePath)) return parentPath;
-    const segment = normaliseRoutePath(stripLeadingLocaleParam(routePath) || '');
-    return normalisePathPattern(`${parentPath}/${segment}`);
-};
-const ensureLocalisedUrlsForPath = (canonicalPath, languages, localisedUrls)=>{
-    const entry = localisedUrls[canonicalPath];
-    if (!entry) throw new Error(`localisedUrls is enabled, but route "${canonicalPath}" does not define localised URLs for languages: ${languages.join(', ')}. Add localisedUrls["${canonicalPath}"] or set localeDetection.localisedUrls to false.`);
-    const missingLanguages = languages.filter((language)=>!entry[language]);
-    if (missingLanguages.length > 0) throw new Error(`localisedUrls["${canonicalPath}"] is missing languages: ${missingLanguages.join(', ')}. Every configured language must have a localised URL.`);
-    return entry;
-};
-const validateLocalisedUrls = (routes, languages, localisedUrls)=>{
-    const visit = (route, parentPath)=>{
-        const canonicalPath = joinPath(parentPath, route.path);
-        if (isLocalisableRoutePath(route.path)) ensureLocalisedUrlsForPath(canonicalPath, languages, localisedUrls);
-        if ('children' in route && route.children) route.children.forEach((child)=>visit(child, canonicalPath));
-    };
-    routes.forEach((route)=>visit(route, ''));
-};
-const getLocalisedRoutePaths = (canonicalPath, parentLocalisedPaths, languages, entry)=>{
-    const paths = languages.map((language)=>{
-        const fullPath = normalisePathPattern(entry[language]);
-        const parentPath = normalisePathPattern(parentLocalisedPaths[language] || '/');
-        if ('/' === parentPath) return normaliseRoutePath(fullPath) || void 0;
-        const parentPrefix = `${parentPath}/`;
-        if (!fullPath.startsWith(parentPrefix)) throw new Error(`localisedUrls["${canonicalPath}"].${language} must be nested under "${parentPath}" because its parent route is localised there.`);
-        return normaliseRoutePath(fullPath.slice(parentPath.length));
-    });
-    return Array.from(new Set(paths.filter(Boolean)));
-};
-const transformLocalisedRoute = (route, parentCanonicalPath, parentLocalisedPaths, languages, localisedUrls)=>{
-    const canonicalPath = joinPath(parentCanonicalPath, route.path);
-    const localisedUrlEntry = isLocalisableRoutePath(route.path) ? ensureLocalisedUrlsForPath(canonicalPath, languages, localisedUrls) : void 0;
-    const routeLocalisedPaths = localisedUrlEntry ? languages.reduce((acc, language)=>{
-        acc[language] = normalisePathPattern(localisedUrlEntry[language]);
-        return acc;
-    }, {}) : parentLocalisedPaths;
-    const children = 'children' in route && route.children ? route.children.flatMap((child)=>transformLocalisedRoute(child, canonicalPath, routeLocalisedPaths, languages, localisedUrls)) : void 0;
-    const baseRoute = {
-        ...route,
-        ...children ? {
-            children
-        } : {}
-    };
-    if (!localisedUrlEntry) return [
-        baseRoute
-    ];
-    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)=>{
-    const children = 'children' in route && route.children ? route.children.map((child)=>suffixRouteIds(child, suffix)) : void 0;
-    return {
-        ...route,
-        ...route.id ? {
-            id: `${route.id}__localised_${suffix}`
-        } : {},
-        ...children ? {
-            children
-        } : {}
-    };
-};
-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)=>{
-    const rootLocalisedPaths = languages.reduce((acc, language)=>{
-        acc[language] = '/';
-        return acc;
-    }, {});
-    validateLocalisedUrls(routes, languages, localisedUrls);
-    return routes.flatMap((route)=>transformLocalisedRoute(route, '', rootLocalisedPaths, languages, localisedUrls));
-};
-const escapeRegExp = (value)=>value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-const getParamName = (segment)=>segment.slice(1).replace(/\?$/, '');
-const compiledPathPatternCache = new Map();
-const compilePathPattern = (pattern)=>{
-    const normalizedPattern = normalisePathPattern(pattern);
-    const cached = compiledPathPatternCache.get(normalizedPattern);
-    if (cached) return cached;
-    const names = [];
-    const segments = normalizedPattern.split('/').filter(Boolean);
-    const source = segments.map((segment)=>{
-        if (segment.startsWith(':')) {
-            names.push(getParamName(segment));
-            const paramPattern = '([^/]+)';
-            return segment.endsWith('?') ? `(?:/${paramPattern})?` : `/${paramPattern}`;
-        }
-        if ('*' === segment) {
-            names.push('*');
-            return '/(.*)';
-        }
-        return `/${escapeRegExp(segment)}`;
-    }).join('');
-    const compiled = {
-        names,
-        regexp: new RegExp(`^${source || '/'}$`)
-    };
-    compiledPathPatternCache.set(normalizedPattern, compiled);
-    return compiled;
-};
-const getPatternSpecificity = (pattern)=>{
-    const segments = normalisePathPattern(pattern).split('/').filter(Boolean);
-    let staticSegments = 0;
-    let dynamicSegments = 0;
-    let splatSegments = 0;
-    for (const segment of segments)if ('*' === segment) splatSegments++;
-    else if (segment.startsWith(':')) dynamicSegments++;
-    else staticSegments++;
-    return {
-        staticSegments,
-        dynamicSegments,
-        splatSegments,
-        totalSegments: segments.length
-    };
-};
-const comparePatternSpecificity = (left, right)=>{
-    const a = getPatternSpecificity(left);
-    const b = getPatternSpecificity(right);
-    return b.staticSegments - a.staticSegments || b.totalSegments - a.totalSegments || a.splatSegments - b.splatSegments || a.dynamicSegments - b.dynamicSegments;
-};
-const sortPatternsBySpecificity = (patterns)=>patterns.map((pattern, index)=>({
-            pattern,
-            index
-        })).sort((left, right)=>comparePatternSpecificity(left.pattern.pattern, right.pattern.pattern) || left.index - right.index).map(({ pattern })=>pattern);
-const decodePathParam = (value)=>{
-    try {
-        return decodeURIComponent(value);
-    } catch  {
-        return null;
-    }
-};
-const matchPathPattern = (pathname, pattern)=>{
-    const { names, regexp } = compilePathPattern(pattern);
-    const match = regexp.exec(normalisePathname(pathname));
-    if (!match) return null;
-    const params = {};
-    for(let index = 0; index < names.length; index++){
-        const decoded = decodePathParam(match[index + 1] || '');
-        if (null === decoded) return null;
-        params[names[index]] = decoded;
-    }
-    return params;
-};
-const buildPathFromPattern = (pattern, params)=>{
-    const segments = normalisePathPattern(pattern).split('/').filter(Boolean);
-    const path = segments.map((segment)=>{
-        if (segment.startsWith(':')) {
-            const param = params[getParamName(segment)];
-            return param ? encodeURIComponent(param) : '';
-        }
-        if ('*' === segment) return params['*'] || '';
-        return segment;
-    }).filter(Boolean).join('/');
-    return `/${path}`;
-};
-const resolveLocalisedPath = (pathname, targetLanguage, languages, localisedUrls)=>{
-    const normalizedPathname = normalisePathname(pathname);
-    const canonicalCandidates = sortPatternsBySpecificity(Object.entries(localisedUrls).map(([canonicalPattern, localisedUrlEntry])=>({
-            pattern: canonicalPattern,
-            canonicalPattern,
-            localisedUrlEntry
-        })));
-    for (const { canonicalPattern, localisedUrlEntry } of canonicalCandidates){
-        const targetPattern = localisedUrlEntry[targetLanguage];
-        if (!targetPattern) continue;
-        const params = matchPathPattern(normalizedPathname, canonicalPattern);
-        if (params) return buildPathFromPattern(targetPattern, params);
-    }
-    const localisedCandidates = sortPatternsBySpecificity(Object.values(localisedUrls).flatMap((localisedUrlEntry)=>{
-        const targetPattern = localisedUrlEntry[targetLanguage];
-        if (!targetPattern) return [];
-        return languages.map((language)=>localisedUrlEntry[language]).filter((sourcePattern)=>Boolean(sourcePattern)).map((sourcePattern)=>({
-                pattern: sourcePattern,
-                sourcePattern,
-                targetPattern
-            }));
-    }));
-    for (const { sourcePattern, targetPattern } of localisedCandidates){
-        const params = matchPathPattern(normalizedPathname, sourcePattern);
-        if (params) return buildPathFromPattern(targetPattern, params);
-    }
-    return normalizedPathname;
-};
-const resolveCanonicalLocalisedPath = (pathname, languages, localisedUrls)=>{
-    const normalizedPathname = normalisePathname(pathname);
-    const canonicalCandidates = sortPatternsBySpecificity(Object.entries(localisedUrls).map(([canonicalPattern, localisedUrlEntry])=>({
-            pattern: canonicalPattern,
-            canonicalPattern,
-            localisedUrlEntry
-        })));
-    for (const { canonicalPattern, localisedUrlEntry } of canonicalCandidates){
-        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;
-};
-const stripLanguagePrefix = (pathname, languages)=>{
-    const segments = pathname.split('/').filter(Boolean);
-    if (segments.length > 0 && languages.includes(segments[0])) return `/${segments.slice(1).join('/')}`;
-    return pathname || '/';
-};
-const localiseTargetPathname = (pathname, language, languages, localisedUrls)=>{
-    const pathWithoutLanguage = stripLanguagePrefix(pathname, languages);
-    const localisedUrlsConfig = resolveLocalisedUrlsConfig(localisedUrls);
-    const resolvedPath = localisedUrlsConfig.enabled ? resolveLocalisedPath(pathWithoutLanguage, language, languages, localisedUrlsConfig.map) : pathWithoutLanguage;
-    const resolvedSegments = resolvedPath.split('/').filter(Boolean);
-    return `/${[
-        language,
-        ...resolvedSegments
-    ].join('/')}`;
-};
-const canonicalTargetPathname = (pathname, languages, localisedUrls)=>{
-    const pathWithoutLanguage = stripLanguagePrefix(pathname, languages);
-    const localisedUrlsConfig = resolveLocalisedUrlsConfig(localisedUrls);
-    return localisedUrlsConfig.enabled ? resolveCanonicalLocalisedPath(pathWithoutLanguage, languages, localisedUrlsConfig.map) : pathWithoutLanguage;
-};
-export { applyLocalisedUrlsToRoutes, buildPathFromPattern, canonicalTargetPathname, localiseTargetPathname, matchPathPattern, normalisePathPattern, normalisePathname, resolveCanonicalLocalisedPath, resolveLocalisedPath, resolveLocalisedUrlsConfig, validateLocalisedUrls };
+export { applyLocalisedUrlsToRoutes, buildPathFromPattern, canonicalTargetPathname, localiseTargetPathname, matchPathPattern, normalisePathPattern, normalisePathname, resolveCanonicalLocalisedPath, resolveLocalisedPath, resolveLocalisedUrlsConfig, validateLocalisedUrls } from "./localisedUrls/index.mjs";

package/dist/esm-node/cli/index.mjs

@@ -32,7 +32,8 @@ const i18nPlugin = (options = {})=>({
                     backend: backendOptions,
                     ...extendedConfig
                 };
-                const runtimePluginPath = customPlugin?.runtime?.path || (false === config.reactI18next ? `@${metaName}/plugin-i18n/runtime/no-react-i18next` : `@${metaName}/plugin-i18n/runtime`);
+                const { reactI18next } = extendedConfig;
+                const runtimePluginPath = customPlugin?.runtime?.path || (false === reactI18next ? `@${metaName}/plugin-i18n/runtime/no-react-i18next` : `@${metaName}/plugin-i18n/runtime`);
                 plugins.push({
                     name: customPlugin?.runtime?.name || 'i18n',
                     path: runtimePluginPath,

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

@@ -2,92 +2,11 @@ import "node:module";
 import { jsx } from "react/jsx-runtime";
 import { useMemo } from "react";
 import { useModernI18n } from "./context.mjs";
+import { interpolateRouteParams, mergeClassNames, normalizeSearch, splitActiveProps, warnOnce } from "./linkHelpers.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();