@bleedingdev/modern-js-runtime-extensions 3.9.0-ultramodern.2 → 3.9.0-ultramodern.20

package/dist/esm-node/index.mjs

@@ -1,5 +1,7 @@
 import "node:module";
 export * from "./html.mjs";
 export * from "./navigationWarmup.mjs";
+export * from "./prefetchPolicy.mjs";
 export * from "./rendererHead.mjs";
+export * from "./routeHydration.mjs";
 export * from "./shellStream.mjs";

package/dist/esm-node/localisedLoaderIdentity.mjs

@@ -0,0 +1,14 @@
+import "node:module";
+function resolveLocalisedLoaderRouteId(routes, requestedId, matchedIds = []) {
+    if (matchedIds.includes(requestedId)) return requestedId;
+    const matched = new Set(matchedIds);
+    const visit = (nodes)=>{
+        for (const route of nodes){
+            if (route.id && matched.has(route.id) && route.modernLocalisedRoute?.id === requestedId) return route.id;
+            const child = route.children && visit(route.children);
+            if (child) return child;
+        }
+    };
+    return visit(routes) ?? requestedId;
+}
+export { resolveLocalisedLoaderRouteId };

package/dist/esm-node/localisedUrls/config.mjs

@@ -0,0 +1,12 @@
+import "node:module";
+const resolveLocalisedUrlsConfig = (option)=>{
+    if (option && 'object' == typeof option && Object.keys(option).length > 0) return {
+        enabled: true,
+        map: option
+    };
+    return {
+        enabled: false,
+        map: {}
+    };
+};
+export { resolveLocalisedUrlsConfig };

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

@@ -0,0 +1,9 @@
+import "node:module";
+export { resolveLocalisedUrlsConfig } from "./config.mjs";
+export { normalisePathPattern, normalisePathname } from "./normalise.mjs";
+export { canonicalTargetPathname, localiseTargetPathname, stripLanguagePrefix } from "./pathname.mjs";
+export { buildPathFromPattern, matchPathPattern } from "./patterns.mjs";
+export { DEFAULT_LOCALE_REDIRECT_SKIP_RULES, isDefaultLocaleRedirectSkipPath, matchesPathPrefix, shouldSkipLocaleRedirect } from "./redirect.mjs";
+export { resolveCanonicalLocalisedPath, resolveLocalisedPath } from "./resolve.mjs";
+export { createLocalisedRouteRewrite } from "./routeIdentity.mjs";
+export { applyLocalisedUrlsToRoutes, validateLocalisedUrls } from "./routes.mjs";

package/dist/esm-node/localisedUrls/normalise.mjs

@@ -0,0 +1,38 @@
+import "node:module";
+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] || '');
+};
+export { getLeadingLocaleParam, normalisePathPattern, normalisePathname, normaliseRoutePath, stripLeadingLocaleParam };

package/dist/esm-node/localisedUrls/pathname.mjs

@@ -0,0 +1,25 @@
+import "node:module";
+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, stripLanguagePrefix };

package/dist/esm-node/localisedUrls/patterns.mjs

@@ -0,0 +1,153 @@
+import "node:module";
+import { normalisePathPattern, normalisePathname } from "./normalise.mjs";
+const escapeRegExp = (value)=>value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+const getParamName = (segment)=>segment.slice(1).replace(/\?$/, '');
+const getOrderedPathParamSignature = (pattern)=>normalisePathPattern(pattern).split('/').filter(Boolean).flatMap((segment)=>{
+        if ('*' === segment) return [
+            '*'
+        ];
+        if (!segment.startsWith(':')) return [];
+        return [
+            `:${getParamName(segment)}${segment.endsWith('?') ? '?' : ''}`
+        ];
+    });
+const getPathParamSignature = (pattern)=>getOrderedPathParamSignature(pattern).sort((left, right)=>left < right ? -1 : left > right ? 1 : 0);
+const getPathPatternValidationIssue = (pattern)=>{
+    const segments = normalisePathPattern(pattern).split('/').filter(Boolean);
+    const seenParams = new Set();
+    for (const [index, segment] of segments.entries()){
+        if ('*' === segment) {
+            if (index !== segments.length - 1) return 'splat parameter "*" must be the final segment';
+            if (seenParams.has('*')) return 'duplicate splat parameter "*"';
+            seenParams.add('*');
+            continue;
+        }
+        if (!segment.startsWith(':')) continue;
+        const paramName = getParamName(segment);
+        if (seenParams.has(paramName)) return `duplicate path parameter ":${paramName}"`;
+        seenParams.add(paramName);
+    }
+};
+const getPhysicalPathPattern = (pattern)=>{
+    const segments = normalisePathPattern(pattern).split('/').filter(Boolean);
+    const physicalSegments = segments.map((segment)=>{
+        if ('*' === segment) return '*';
+        if (segment.startsWith(':')) return segment.endsWith('?') ? ':param?' : ':param';
+        return segment;
+    });
+    return `/${physicalSegments.join('/')}`;
+};
+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 optionalSegments = 0;
+    let splatSegments = 0;
+    for (const segment of segments)if ('*' === segment) splatSegments++;
+    else if (segment.startsWith(':')) {
+        dynamicSegments++;
+        if (segment.endsWith('?')) optionalSegments++;
+    } else staticSegments++;
+    return {
+        staticSegments,
+        dynamicSegments,
+        optionalSegments,
+        splatSegments,
+        totalSegments: segments.length
+    };
+};
+const comparePatternSpecificity = (left, right)=>{
+    const a = getPatternSpecificity(left);
+    const b = getPatternSpecificity(right);
+    return b.staticSegments - a.staticSegments || a.splatSegments - b.splatSegments || a.optionalSegments - b.optionalSegments || b.totalSegments - a.totalSegments || a.dynamicSegments - b.dynamicSegments;
+};
+const haveEqualPatternSpecificity = (left, right)=>0 === comparePatternSpecificity(left, right);
+const doPathPatternsOverlap = (left, right)=>{
+    const leftSegments = normalisePathPattern(left).split('/').filter(Boolean);
+    const rightSegments = normalisePathPattern(right).split('/').filter(Boolean);
+    if (leftSegments.length !== rightSegments.length) return false;
+    return leftSegments.every((leftSegment, index)=>{
+        const rightSegment = rightSegments[index];
+        const leftIsDynamic = '*' === leftSegment || leftSegment.startsWith(':');
+        const rightIsDynamic = '*' === rightSegment || rightSegment.startsWith(':');
+        return leftIsDynamic || rightIsDynamic || leftSegment === rightSegment;
+    });
+};
+const comparePatternNames = (left, right)=>{
+    const normalizedLeft = normalisePathPattern(left);
+    const normalizedRight = normalisePathPattern(right);
+    return normalizedLeft < normalizedRight ? -1 : normalizedLeft > normalizedRight ? 1 : 0;
+};
+const sortPatternsBySpecificity = (patterns)=>patterns.map((pattern, index)=>({
+            pattern,
+            index
+        })).sort((left, right)=>comparePatternSpecificity(left.pattern.pattern, right.pattern.pattern) || comparePatternNames(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;
+        Object.defineProperty(params, names[index], {
+            configurable: true,
+            enumerable: true,
+            value: decoded,
+            writable: true
+        });
+    }
+    return params;
+};
+const buildPathFromPattern = (pattern, params)=>{
+    const segments = normalisePathPattern(pattern).split('/').filter(Boolean);
+    const path = segments.map((segment)=>{
+        if (segment.startsWith(':')) {
+            const paramName = getParamName(segment);
+            const param = Object.hasOwn(params, paramName) ? params[paramName] : void 0;
+            if (void 0 === param || '' === param) {
+                if (segment.endsWith('?')) return '';
+                throw new Error(`Missing required path parameter "${paramName}" for pattern "${normalisePathPattern(pattern)}".`);
+            }
+            return encodeURIComponent(param);
+        }
+        if ('*' === segment) return encodeSplatParam(params['*'] || '');
+        return segment;
+    }).filter(Boolean).join('/');
+    return `/${path}`;
+};
+export { buildPathFromPattern, doPathPatternsOverlap, getOrderedPathParamSignature, getPathParamSignature, getPathPatternValidationIssue, getPhysicalPathPattern, haveEqualPatternSpecificity, matchPathPattern, sortPatternsBySpecificity };

package/dist/esm-node/localisedUrls/redirect.mjs

@@ -0,0 +1,54 @@
+import "node:module";
+import { normalisePathname } from "./normalise.mjs";
+import { stripLanguagePrefix } from "./pathname.mjs";
+const DEFAULT_LOCALE_REDIRECT_SKIP_RULES = [
+    {
+        type: 'exact',
+        path: '/backend-mf-manifest.json'
+    },
+    {
+        type: 'exact',
+        path: '/mf-manifest.json'
+    },
+    {
+        type: 'exact',
+        path: '/mf-stats.json'
+    },
+    {
+        type: 'pattern',
+        path: /^\/(?:backendRemoteEntry(?:\.[a-zA-Z0-9_-]+)?\.cjs|remoteEntry(?:\.[a-zA-Z0-9_-]+)?\.js)$/
+    },
+    {
+        type: 'prefix',
+        path: '/static/'
+    },
+    {
+        type: 'prefix',
+        path: '/upload/'
+    }
+];
+const stripTrailingSlash = (pathname)=>pathname.length > 1 ? pathname.replace(/\/+$/, '') : pathname;
+const matchesPathPrefix = (pathname, prefix)=>{
+    const normalizedPathname = normalisePathname(pathname);
+    const normalizedPrefix = stripTrailingSlash(normalisePathname(prefix));
+    return normalizedPathname === normalizedPrefix || normalizedPathname.startsWith(`${normalizedPrefix}/`);
+};
+const matchesSkipRule = (pathname, rule)=>{
+    if ('exact' === rule.type) return normalisePathname(pathname) === normalisePathname(rule.path);
+    if ('pattern' === rule.type) return rule.path.test(normalisePathname(pathname));
+    return matchesPathPrefix(pathname, rule.path);
+};
+const isDefaultLocaleRedirectSkipPath = (pathname, languages = [])=>{
+    const normalizedPathname = normalisePathname(pathname);
+    const pathWithoutLanguage = stripLanguagePrefix(normalizedPathname, languages);
+    return DEFAULT_LOCALE_REDIRECT_SKIP_RULES.some((rule)=>matchesSkipRule(pathWithoutLanguage, rule));
+};
+const shouldSkipLocaleRedirect = (pathname, languages = [], ignoreRedirectRoutes)=>{
+    const normalizedPathname = normalisePathname(pathname);
+    const pathWithoutLanguage = stripLanguagePrefix(normalizedPathname, languages);
+    if (isDefaultLocaleRedirectSkipPath(pathWithoutLanguage)) return true;
+    if (!ignoreRedirectRoutes) return false;
+    if ('function' == typeof ignoreRedirectRoutes) return ignoreRedirectRoutes(pathWithoutLanguage);
+    return ignoreRedirectRoutes.some((pattern)=>matchesPathPrefix(pathWithoutLanguage, pattern));
+};
+export { DEFAULT_LOCALE_REDIRECT_SKIP_RULES, isDefaultLocaleRedirectSkipPath, matchesPathPrefix, shouldSkipLocaleRedirect };

package/dist/esm-node/localisedUrls/resolve.mjs

@@ -0,0 +1,38 @@
+import "node:module";
+import { normalisePathname } from "./normalise.mjs";
+import { buildPathFromPattern, matchPathPattern, sortPatternsBySpecificity } from "./patterns.mjs";
+const getCanonicalCandidates = (localisedUrls)=>sortPatternsBySpecificity(Object.entries(localisedUrls).map(([canonicalPattern, localisedUrlEntry])=>({
+            pattern: canonicalPattern,
+            canonicalPattern,
+            localisedUrlEntry
+        })));
+const resolveLocalisedUrlPath = (pathname, languages, localisedUrls, options)=>{
+    const normalizedPathname = normalisePathname(pathname);
+    const canonicalCandidates = getCanonicalCandidates(localisedUrls);
+    const candidates = sortPatternsBySpecificity(canonicalCandidates.flatMap(({ canonicalPattern, localisedUrlEntry })=>{
+        const targetPattern = 'localised' === options.mode ? localisedUrlEntry[options.targetLanguage] : canonicalPattern;
+        if (!targetPattern) return [];
+        const sourcePatterns = new Set([
+            canonicalPattern,
+            ...languages.map((language)=>localisedUrlEntry[language]).filter((sourcePattern)=>Boolean(sourcePattern))
+        ]);
+        return Array.from(sourcePatterns, (sourcePattern)=>({
+                pattern: sourcePattern,
+                sourcePattern,
+                targetPattern
+            }));
+    }));
+    for (const { sourcePattern, targetPattern } of candidates){
+        const params = matchPathPattern(normalizedPathname, sourcePattern);
+        if (params) return buildPathFromPattern(targetPattern, params);
+    }
+    return normalizedPathname;
+};
+const resolveLocalisedPath = (pathname, targetLanguage, languages, localisedUrls)=>resolveLocalisedUrlPath(pathname, languages, localisedUrls, {
+        mode: 'localised',
+        targetLanguage
+    });
+const resolveCanonicalLocalisedPath = (pathname, languages, localisedUrls)=>resolveLocalisedUrlPath(pathname, languages, localisedUrls, {
+        mode: 'canonical'
+    });
+export { resolveCanonicalLocalisedPath, resolveLocalisedPath };

package/dist/esm-node/localisedUrls/routeIdentity.mjs

@@ -0,0 +1,55 @@
+import "node:module";
+import { normalisePathPattern } from "./normalise.mjs";
+import { buildPathFromPattern, matchPathPattern } from "./patterns.mjs";
+function rewritePath(url, mappings) {
+    for (const { from, to } of mappings){
+        const params = matchPathPattern(url.pathname, from);
+        if (params) {
+            url.pathname = buildPathFromPattern(to, params);
+            break;
+        }
+    }
+    return url;
+}
+function createLocalisedRouteRewrite(routes) {
+    const input = [];
+    const output = [];
+    const visit = (nodes, parent)=>{
+        for (const route of nodes){
+            const fullPath = normalisePathPattern(`${parent}/${route.path ?? ''}`);
+            const identity = route.modernLocalisedRoute;
+            if (identity?.paths && fullPath.endsWith(identity.canonicalPath)) {
+                const prefix = fullPath.slice(0, -identity.canonicalPath.length);
+                const hasLocale = prefix.split('/').some((segment)=>/^:(?:lang|locale|language)\??$/.test(segment));
+                for (const [language, localisedPath] of Object.entries(identity.paths)){
+                    const localePrefix = prefix.split('/').map((segment)=>/^:(?:lang|locale|language)\??$/.test(segment) ? language : segment).join('/');
+                    const canonical = normalisePathPattern(`${localePrefix}/${identity.canonicalPath}`);
+                    const localised = normalisePathPattern(`${localePrefix}/${localisedPath}`);
+                    if (canonical !== localised) {
+                        input.push({
+                            from: localised,
+                            to: canonical
+                        });
+                        if (hasLocale) output.push({
+                            from: canonical,
+                            to: localised
+                        });
+                    }
+                }
+            }
+            if (route.children) visit(route.children, fullPath);
+        }
+    };
+    visit(routes, '');
+    if (0 === input.length) return;
+    const specificity = (pattern)=>pattern.split('/').filter((segment)=>segment && !segment.startsWith(':') && '*' !== segment).length;
+    for (const mappings of [
+        input,
+        output
+    ])mappings.sort((a, b)=>specificity(b.from) - specificity(a.from));
+    return {
+        input: ({ url })=>rewritePath(url, input),
+        output: ({ url })=>rewritePath(url, output)
+    };
+}
+export { createLocalisedRouteRewrite };

package/dist/esm-node/localisedUrls/routes.mjs

@@ -0,0 +1,177 @@
+import "node:module";
+import { getLeadingLocaleParam, normalisePathPattern, normaliseRoutePath, stripLeadingLocaleParam } from "./normalise.mjs";
+import { doPathPatternsOverlap, getOrderedPathParamSignature, getPathParamSignature, getPathPatternValidationIssue, getPhysicalPathPattern, haveEqualPatternSpecificity } from "./patterns.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 isFrameworkInternalRoutePath = (canonicalPath)=>'/_mf' === canonicalPath || canonicalPath.startsWith('/_mf/');
+const legalRouteIdPart = (value)=>value.replace(/[^a-zA-Z0-9_$-]+/g, '_').replace(/^_+|_+$/g, '') || 'index';
+const formatParamSignature = (signature)=>signature.length > 0 ? signature.join(', ') : '(none)';
+const validateLocalisedUrlPatterns = (languages, localisedUrls)=>{
+    const physicalPatterns = new Map();
+    const claimedPatterns = [];
+    const claimPhysicalPattern = (sourcePattern, canonicalPath, source)=>{
+        const physicalPattern = getPhysicalPathPattern(sourcePattern);
+        const existing = physicalPatterns.get(physicalPattern);
+        if (existing && existing.canonicalPath !== canonicalPath) throw new Error(`localisedUrls["${existing.canonicalPath}"] ${existing.source} and localisedUrls["${canonicalPath}"] ${source} generate the same physical route pattern "${physicalPattern}". Localised route patterns must identify exactly one canonical route.`);
+        const overlapping = claimedPatterns.find((claimed)=>claimed.canonicalPath !== canonicalPath && haveEqualPatternSpecificity(claimed.pattern, sourcePattern) && doPathPatternsOverlap(claimed.pattern, sourcePattern));
+        if (overlapping) throw new Error(`localisedUrls["${overlapping.canonicalPath}"] ${overlapping.source} pattern "${overlapping.pattern}" and localisedUrls["${canonicalPath}"] ${source} pattern "${sourcePattern}" are equal-specificity overlapping route patterns. Localised route patterns must identify exactly one canonical route.`);
+        physicalPatterns.set(physicalPattern, {
+            canonicalPath,
+            source
+        });
+        claimedPatterns.push({
+            canonicalPath,
+            pattern: sourcePattern,
+            source
+        });
+    };
+    for (const [canonicalPath, entry] of Object.entries(localisedUrls).sort(([left], [right])=>left < right ? -1 : left > right ? 1 : 0)){
+        const canonicalIssue = getPathPatternValidationIssue(canonicalPath);
+        if (canonicalIssue) throw new Error(`localisedUrls["${canonicalPath}"] canonical pattern has ${canonicalIssue}.`);
+        const expectedSignature = getPathParamSignature(canonicalPath);
+        const expectedOrderedSignature = getOrderedPathParamSignature(canonicalPath);
+        claimPhysicalPattern(canonicalPath, canonicalPath, 'canonical pattern');
+        for (const language of languages){
+            const localisedPattern = entry[language];
+            if (!localisedPattern) continue;
+            const localisedIssue = getPathPatternValidationIssue(localisedPattern);
+            if (localisedIssue) throw new Error(`localisedUrls["${canonicalPath}"].${language} has ${localisedIssue}.`);
+            const actualSignature = getPathParamSignature(localisedPattern);
+            if (actualSignature.length !== expectedSignature.length || actualSignature.some((parameter, index)=>parameter !== expectedSignature[index])) throw new Error(`localisedUrls["${canonicalPath}"].${language} must use the same parameter signature as "${canonicalPath}": expected ${formatParamSignature(expectedSignature)}; received ${formatParamSignature(actualSignature)}.`);
+            const actualOrderedSignature = getOrderedPathParamSignature(localisedPattern);
+            if (expectedOrderedSignature.some((parameter)=>'*' === parameter || parameter.endsWith('?')) && actualOrderedSignature.some((parameter, index)=>parameter !== expectedOrderedSignature[index])) throw new Error(`localisedUrls["${canonicalPath}"].${language} must keep optional and splat parameters in canonical order: expected ${formatParamSignature(expectedOrderedSignature)}; received ${formatParamSignature(actualOrderedSignature)}.`);
+            claimPhysicalPattern(localisedPattern, canonicalPath, `.${language}`);
+        }
+    }
+};
+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)=>{
+    validateLocalisedUrlPatterns(languages, localisedUrls);
+    const visit = (route, parentPath)=>{
+        const canonicalPath = joinPath(parentPath, route.path);
+        if (isLocalisableRoutePath(route.path) && !isFrameworkInternalRoutePath(canonicalPath)) ensureLocalisedUrlsForPath(canonicalPath, languages, localisedUrls);
+        if ('children' in route && route.children) route.children.forEach((child)=>visit(child, canonicalPath));
+    };
+    routes.forEach((route)=>visit(route, ''));
+};
+const getLocalisedRouteIdSuffixes = (paths)=>{
+    const usedSuffixes = new Set();
+    return paths.map((path, index)=>{
+        if (0 === index) return;
+        const baseSuffix = legalRouteIdPart(path);
+        let suffix = baseSuffix;
+        let disambiguator = 2;
+        while(usedSuffixes.has(suffix))suffix = `${baseSuffix}_${disambiguator++}`;
+        usedSuffixes.add(suffix);
+        return suffix;
+    });
+};
+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));
+    });
+    const uniquePaths = Array.from(new Set(paths.filter(Boolean)));
+    return uniquePaths;
+};
+const transformLocalisedRoute = (route, parentCanonicalPath, parentLocalisedPaths, languages, localisedUrls, projection)=>{
+    const isSplat = '*' === stripLeadingLocaleParam(route.path);
+    const canonicalPath = isSplat ? normalisePathPattern(`${parentCanonicalPath}/*`) : joinPath(parentCanonicalPath, route.path);
+    const localisedUrlEntry = isLocalisableRoutePath(route.path) && !isFrameworkInternalRoutePath(canonicalPath) ? ensureLocalisedUrlsForPath(canonicalPath, languages, localisedUrls) : void 0;
+    const routeLocalisedPaths = localisedUrlEntry ? languages.reduce((acc, language)=>{
+        acc[language] = normalisePathPattern(localisedUrlEntry[language]);
+        return acc;
+    }, {}) : isSplat ? Object.fromEntries(Object.entries(parentLocalisedPaths).map(([language, path])=>[
+            language,
+            normalisePathPattern(`${path}/*`)
+        ])) : parentLocalisedPaths;
+    const children = 'children' in route && route.children ? route.children.flatMap((child)=>transformLocalisedRoute(child, canonicalPath, routeLocalisedPaths, languages, localisedUrls, projection)) : void 0;
+    const baseRoute = {
+        ...route,
+        ...!isFrameworkInternalRoutePath(canonicalPath) ? {
+            modernLocalisedRoute: {
+                id: route.id,
+                path: route.path,
+                canonicalPath,
+                paths: localisedUrlEntry ?? (isSplat ? routeLocalisedPaths : void 0)
+            }
+        } : {},
+        ...children ? {
+            children
+        } : {}
+    };
+    if (!localisedUrlEntry) return [
+        baseRoute
+    ];
+    const localisedPaths = getLocalisedRoutePaths(canonicalPath, parentLocalisedPaths, languages, localisedUrlEntry);
+    if ('canonical' === projection) return [
+        baseRoute
+    ];
+    const leadingLocaleParam = getLeadingLocaleParam(route.path);
+    const routeIdPaths = leadingLocaleParam ? localisedPaths.map((path)=>normaliseRoutePath(`${leadingLocaleParam}/${path}`)) : localisedPaths;
+    const routeIdSuffixes = getLocalisedRouteIdSuffixes(routeIdPaths);
+    return localisedPaths.map((localisedPath, index)=>cloneRouteWithLocalisedPath(baseRoute, localisedPath, routeIdSuffixes[index], canonicalPath));
+};
+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 collectRouteIdCounts = (routes, counts = new Map())=>{
+    for (const route of routes){
+        if (route.id) counts.set(route.id, (counts.get(route.id) ?? 0) + 1);
+        if ('children' in route && route.children) collectRouteIdCounts(route.children, counts);
+    }
+    return counts;
+};
+const validateNoNewRouteIdCollisions = (sourceRoutes, localisedRoutes)=>{
+    const sourceCounts = collectRouteIdCounts(sourceRoutes);
+    const localisedCounts = collectRouteIdCounts(localisedRoutes);
+    for (const [routeId, count] of localisedCounts)if (count > 1 && count > (sourceCounts.get(routeId) ?? 0)) throw new Error(`Localised route expansion generated duplicate route ID "${routeId}". Change the source route ID or localised path so every generated route remains identifiable.`);
+};
+const cloneRouteWithLocalisedPath = (route, path, routeIdSuffix, canonicalPath)=>{
+    const leadingLocaleParam = getLeadingLocaleParam(route.path);
+    const localisedPath = leadingLocaleParam ? normaliseRoutePath(`${leadingLocaleParam}/${path}`) : path;
+    const routeWithPath = {
+        ...route,
+        path: localisedPath
+    };
+    routeWithPath.modernCanonicalPath = canonicalPath;
+    return routeIdSuffix ? suffixRouteIds(routeWithPath, routeIdSuffix) : routeWithPath;
+};
+const applyLocalisedUrlsToRoutes = (routes, languages, localisedUrls, projection = 'physical')=>{
+    const rootLocalisedPaths = languages.reduce((acc, language)=>{
+        acc[language] = '/';
+        return acc;
+    }, {});
+    validateLocalisedUrls(routes, languages, localisedUrls);
+    const localisedRoutes = routes.flatMap((route)=>transformLocalisedRoute(route, '', rootLocalisedPaths, languages, localisedUrls, projection));
+    validateNoNewRouteIdCollisions(routes, localisedRoutes);
+    return localisedRoutes;
+};
+export { applyLocalisedUrlsToRoutes, validateLocalisedUrls };

package/dist/esm-node/localisedUrls/types.mjs

@@ -0,0 +1 @@
+import "node:module";

package/dist/esm-node/prefetchPolicy.mjs

@@ -0,0 +1,12 @@
+import "node:module";
+function resolvePreloadFromPrefetch(prefetch, preload) {
+    if (void 0 !== preload) return preload;
+    if ('none' === prefetch) return false;
+    if ('intent' === prefetch || 'render' === prefetch || 'viewport' === prefetch) return prefetch;
+    return 'viewport';
+}
+function normalizePreloadBehavior(preload, prefetch) {
+    const resolved = resolvePreloadFromPrefetch(prefetch, preload);
+    return false === resolved ? 'none' : resolved;
+}
+export { normalizePreloadBehavior, resolvePreloadFromPrefetch };