@bleedingdev/modern-js-i18n-runtime-extensions 3.9.0-ultramodern.11 → 3.9.0-ultramodern.13

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

@@ -1,38 +0,0 @@
-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

@@ -1,78 +0,0 @@
-import "node:module";
-import { normalisePathPattern } from "./normalise.mjs";
-import { buildPathFromPattern, matchPathPattern } from "./patterns.mjs";
-function canonicaliseLocalisedRoutes(routes) {
-    const seen = new Set();
-    return routes.flatMap((route)=>{
-        const identity = route.modernLocalisedRoute;
-        const key = identity?.id ?? identity?.path;
-        if (void 0 !== key) {
-            if (seen.has(key)) return [];
-            seen.add(key);
-        }
-        return [
-            {
-                ...route,
-                ...identity ? {
-                    id: identity.id,
-                    path: identity.path
-                } : {},
-                ...route.children ? {
-                    children: canonicaliseLocalisedRoutes(route.children)
-                } : {}
-            }
-        ];
-    });
-}
-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(canonicaliseLocalisedRoutes(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 { canonicaliseLocalisedRoutes, createLocalisedRouteRewrite };

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

@@ -1,170 +0,0 @@
-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)=>{
-    const canonicalPath = 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;
-    }, {}) : parentLocalisedPaths;
-    const children = 'children' in route && route.children ? route.children.flatMap((child)=>transformLocalisedRoute(child, canonicalPath, routeLocalisedPaths, languages, localisedUrls)) : void 0;
-    const baseRoute = {
-        ...route,
-        ...!isFrameworkInternalRoutePath(canonicalPath) ? {
-            modernLocalisedRoute: {
-                id: route.id,
-                path: route.path,
-                canonicalPath,
-                paths: localisedUrlEntry
-            }
-        } : {},
-        ...children ? {
-            children
-        } : {}
-    };
-    if (!localisedUrlEntry) return [
-        baseRoute
-    ];
-    const localisedPaths = getLocalisedRoutePaths(canonicalPath, parentLocalisedPaths, languages, localisedUrlEntry);
-    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)=>{
-    const rootLocalisedPaths = languages.reduce((acc, language)=>{
-        acc[language] = '/';
-        return acc;
-    }, {});
-    validateLocalisedUrls(routes, languages, localisedUrls);
-    const localisedRoutes = routes.flatMap((route)=>transformLocalisedRoute(route, '', rootLocalisedPaths, languages, localisedUrls));
-    validateNoNewRouteIdCollisions(routes, localisedRoutes);
-    return localisedRoutes;
-};
-export { applyLocalisedUrlsToRoutes, validateLocalisedUrls };

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

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

package/dist/types/localisedUrls/config.d.ts

@@ -1,9 +0,0 @@
-import type { LocalisedUrlsOption, ResolvedLocalisedUrlsConfig } from './types.js';
-/**
- * Localised URLs are strictly opt-in: only an explicit, non-empty map enables
- * route expansion and validation. `true`, `false`, an empty map and absence
- * all resolve to disabled, so upstream-style configs (`localePathRedirect` +
- * `languages` without a map) keep plain locale-prefix behavior instead of
- * failing the build for every route missing from a map they never wrote.
- */
-export declare const resolveLocalisedUrlsConfig: (option: LocalisedUrlsOption | undefined) => ResolvedLocalisedUrlsConfig;

package/dist/types/localisedUrls/index.d.ts

@@ -1,10 +0,0 @@
-export { resolveLocalisedUrlsConfig } from './config.js';
-export { normalisePathname, normalisePathPattern } from './normalise.js';
-export { canonicalTargetPathname, localiseTargetPathname, stripLanguagePrefix, } from './pathname.js';
-export { buildPathFromPattern, matchPathPattern } from './patterns.js';
-export type { LocaleRedirectSkipRule } from './redirect.js';
-export { DEFAULT_LOCALE_REDIRECT_SKIP_RULES, isDefaultLocaleRedirectSkipPath, matchesPathPrefix, shouldSkipLocaleRedirect, } from './redirect.js';
-export { resolveCanonicalLocalisedPath, resolveLocalisedPath } from './resolve.js';
-export { canonicaliseLocalisedRoutes, createLocalisedRouteRewrite, } from './routeIdentity.js';
-export { applyLocalisedUrlsToRoutes, validateLocalisedUrls } from './routes.js';
-export type { LocalisedRoute, LocalisedUrlPathMap, LocalisedUrlsMap, LocalisedUrlsOption, ResolvedLocalisedUrlsConfig, } from './types.js';

package/dist/types/localisedUrls/normalise.d.ts

@@ -1,10 +0,0 @@
-export declare const normalisePathPattern: (path: string) => string;
-/**
- * Normalise a concrete request pathname: slash cleanup only. Unlike
- * {@link normalisePathPattern} it must not rewrite literal `[x]` segments to
- * `:x` params — pathnames are values, not patterns.
- */
-export declare const normalisePathname: (pathname: string) => string;
-export declare const normaliseRoutePath: (path: string) => string;
-export declare const stripLeadingLocaleParam: (path?: string) => string | undefined;
-export declare const getLeadingLocaleParam: (path?: string) => string | null;

package/dist/types/localisedUrls/pathname.d.ts

@@ -1,4 +0,0 @@
-import type { LocalisedUrlsOption } from './types.js';
-export declare const stripLanguagePrefix: (pathname: string, languages: string[]) => string;
-export declare const localiseTargetPathname: (pathname: string, language: string, languages: string[], localisedUrls?: LocalisedUrlsOption) => string;
-export declare const canonicalTargetPathname: (pathname: string, languages: string[], localisedUrls?: LocalisedUrlsOption) => string;

package/dist/types/localisedUrls/patterns.d.ts

@@ -1,11 +0,0 @@
-export declare const getOrderedPathParamSignature: (pattern: string) => string[];
-export declare const getPathParamSignature: (pattern: string) => string[];
-export declare const getPathPatternValidationIssue: (pattern: string) => string | undefined;
-export declare const getPhysicalPathPattern: (pattern: string) => string;
-export declare const haveEqualPatternSpecificity: (left: string, right: string) => boolean;
-export declare const doPathPatternsOverlap: (left: string, right: string) => boolean;
-export declare const sortPatternsBySpecificity: <T extends {
-    pattern: string;
-}>(patterns: T[]) => T[];
-export declare const matchPathPattern: (pathname: string, pattern: string) => Record<string, string> | null;
-export declare const buildPathFromPattern: (pattern: string, params: Record<string, string>) => string;

package/dist/types/localisedUrls/redirect.d.ts

@@ -1,19 +0,0 @@
-export type LocaleRedirectSkipRule = {
-    type: 'exact';
-    path: string;
-} | {
-    type: 'prefix';
-    path: string;
-} | {
-    type: 'pattern';
-    path: RegExp;
-};
-/**
- * Federation artifacts are never pages. The remote entries match the same
- * shapes the federation layer itself recognises and serves (`mfCache.ts`):
- * a manifest may name a root entry such as `remoteEntry.catalog.js`.
- */
-export declare const DEFAULT_LOCALE_REDIRECT_SKIP_RULES: readonly LocaleRedirectSkipRule[];
-export declare const matchesPathPrefix: (pathname: string, prefix: string) => boolean;
-export declare const isDefaultLocaleRedirectSkipPath: (pathname: string, languages?: string[]) => boolean;
-export declare const shouldSkipLocaleRedirect: (pathname: string, languages?: string[], ignoreRedirectRoutes?: string[] | ((pathname: string) => boolean)) => boolean;

package/dist/types/localisedUrls/resolve.d.ts

@@ -1,7 +0,0 @@
-import type { LocalisedUrlsMap } from './types.js';
-export declare const resolveLocalisedPath: (pathname: string, targetLanguage: string, languages: string[], localisedUrls: LocalisedUrlsMap) => string;
-/**
- * Reverse-map language-specific pathnames back to language-agnostic
- * LocalisedUrlsMap keys.
- */
-export declare const resolveCanonicalLocalisedPath: (pathname: string, languages: string[], localisedUrls: LocalisedUrlsMap) => string;

package/dist/types/localisedUrls/routeIdentity.d.ts

@@ -1,24 +0,0 @@
-interface RouteIdentity {
-    id?: string;
-    path?: string;
-    canonicalPath: string;
-    paths?: Record<string, string>;
-}
-interface RouteNode {
-    id?: string;
-    path?: string;
-    children?: RouteNode[];
-    modernLocalisedRoute?: RouteIdentity;
-}
-/** Restore one source route identity for routers with strict route-ID hooks. */
-export declare function canonicaliseLocalisedRoutes<T extends RouteNode>(routes: T[]): T[];
-/** Use the router's URL rewrite seam; browser URLs retain their locale spelling. */
-export declare function createLocalisedRouteRewrite(routes: RouteNode[]): {
-    input: ({ url }: {
-        url: URL;
-    }) => URL;
-    output: ({ url }: {
-        url: URL;
-    }) => URL;
-} | undefined;
-export {};

package/dist/types/localisedUrls/routes.d.ts

@@ -1,3 +0,0 @@
-import type { LocalisedRoute, LocalisedUrlsMap } from './types.js';
-export declare const validateLocalisedUrls: (routes: LocalisedRoute[], languages: string[], localisedUrls: LocalisedUrlsMap) => void;
-export declare const applyLocalisedUrlsToRoutes: (routes: LocalisedRoute[], languages: string[], localisedUrls: LocalisedUrlsMap) => LocalisedRoute[];

package/dist/types/localisedUrls/types.d.ts

@@ -1,14 +0,0 @@
-export type LocalisedRoute = {
-    type: 'nested' | 'page';
-    path?: string;
-    id?: string;
-    children?: LocalisedRoute[];
-    [key: string]: any;
-};
-export type LocalisedUrlPathMap = Record<string, string>;
-export type LocalisedUrlsMap = Record<string, LocalisedUrlPathMap>;
-export type LocalisedUrlsOption = boolean | LocalisedUrlsMap;
-export interface ResolvedLocalisedUrlsConfig {
-    enabled: boolean;
-    map: LocalisedUrlsMap;
-}

package/src/localisedUrls/config.ts

@@ -1,18 +0,0 @@
-import type { LocalisedUrlsOption, ResolvedLocalisedUrlsConfig } from './types';
-
-/**
- * Localised URLs are strictly opt-in: only an explicit, non-empty map enables
- * route expansion and validation. `true`, `false`, an empty map and absence
- * all resolve to disabled, so upstream-style configs (`localePathRedirect` +
- * `languages` without a map) keep plain locale-prefix behavior instead of
- * failing the build for every route missing from a map they never wrote.
- */
-export const resolveLocalisedUrlsConfig = (
-  option: LocalisedUrlsOption | undefined,
-): ResolvedLocalisedUrlsConfig => {
-  if (option && typeof option === 'object' && Object.keys(option).length > 0) {
-    return { enabled: true, map: option };
-  }
-
-  return { enabled: false, map: {} };
-};

package/src/localisedUrls/index.ts

@@ -1,28 +0,0 @@
-export { resolveLocalisedUrlsConfig } from './config';
-export { normalisePathname, normalisePathPattern } from './normalise';
-export {
-  canonicalTargetPathname,
-  localiseTargetPathname,
-  stripLanguagePrefix,
-} from './pathname';
-export { buildPathFromPattern, matchPathPattern } from './patterns';
-export type { LocaleRedirectSkipRule } from './redirect';
-export {
-  DEFAULT_LOCALE_REDIRECT_SKIP_RULES,
-  isDefaultLocaleRedirectSkipPath,
-  matchesPathPrefix,
-  shouldSkipLocaleRedirect,
-} from './redirect';
-export { resolveCanonicalLocalisedPath, resolveLocalisedPath } from './resolve';
-export {
-  canonicaliseLocalisedRoutes,
-  createLocalisedRouteRewrite,
-} from './routeIdentity';
-export { applyLocalisedUrlsToRoutes, validateLocalisedUrls } from './routes';
-export type {
-  LocalisedRoute,
-  LocalisedUrlPathMap,
-  LocalisedUrlsMap,
-  LocalisedUrlsOption,
-  ResolvedLocalisedUrlsConfig,
-} from './types';

package/src/localisedUrls/normalise.ts

@@ -1,62 +0,0 @@
-const LOCALE_PARAM_NAMES = new Set(['lang', 'locale', 'language']);
-
-const normaliseSlashes = (path: string): string => {
-  const withoutDuplicateSlashes = path.replace(/\/+/g, '/');
-  const withLeadingSlash = withoutDuplicateSlashes.startsWith('/')
-    ? withoutDuplicateSlashes
-    : `/${withoutDuplicateSlashes}`;
-
-  return withLeadingSlash.length > 1
-    ? withLeadingSlash.replace(/\/+$/, '')
-    : withLeadingSlash;
-};
-
-export const normalisePathPattern = (path: string): string =>
-  normaliseSlashes(path).replace(/\[(.+?)\]/g, ':$1');
-
-/**
- * Normalise a concrete request pathname: slash cleanup only. Unlike
- * {@link normalisePathPattern} it must not rewrite literal `[x]` segments to
- * `:x` params — pathnames are values, not patterns.
- */
-export const normalisePathname = (pathname: string): string =>
-  normaliseSlashes(pathname);
-
-export const normaliseRoutePath = (path: string): string => {
-  const normalized = normalisePathPattern(path);
-  return normalized === '/' ? '' : normalized.slice(1);
-};
-
-const getLocaleParamSegment = (segment: string): string | null => {
-  if (!segment.startsWith(':')) {
-    return null;
-  }
-
-  const paramName = segment.slice(1).replace(/\?$/, '');
-  return LOCALE_PARAM_NAMES.has(paramName) ? segment : null;
-};
-
-const splitPathSegments = (path?: string): string[] => {
-  if (!path) {
-    return [];
-  }
-
-  return normalisePathPattern(path).split('/').filter(Boolean);
-};
-
-export const stripLeadingLocaleParam = (path?: string): string | undefined => {
-  const segments = splitPathSegments(path);
-  const leadingLocaleParam = getLocaleParamSegment(segments[0] || '');
-
-  if (!leadingLocaleParam) {
-    return path;
-  }
-
-  const remainingPath = segments.slice(1).join('/');
-  return remainingPath ? `/${remainingPath}` : undefined;
-};
-
-export const getLeadingLocaleParam = (path?: string): string | null => {
-  const segments = splitPathSegments(path);
-  return getLocaleParamSegment(segments[0] || '');
-};

package/src/localisedUrls/pathname.ts

@@ -1,60 +0,0 @@
-import { resolveLocalisedUrlsConfig } from './config';
-
-import { resolveCanonicalLocalisedPath, resolveLocalisedPath } from './resolve';
-
-import type { LocalisedUrlsOption } from './types';
-
-export const stripLanguagePrefix = (
-  pathname: string,
-  languages: string[],
-): string => {
-  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 || '/';
-};
-
-export const localiseTargetPathname = (
-  pathname: string,
-  language: string,
-  languages: string[],
-  localisedUrls?: LocalisedUrlsOption,
-): string => {
-  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('/')}`;
-};
-
-export const canonicalTargetPathname = (
-  pathname: string,
-  languages: string[],
-  localisedUrls?: LocalisedUrlsOption,
-): string => {
-  const pathWithoutLanguage = stripLanguagePrefix(pathname, languages);
-  const localisedUrlsConfig = resolveLocalisedUrlsConfig(localisedUrls);
-
-  return localisedUrlsConfig.enabled
-    ? resolveCanonicalLocalisedPath(
-        pathWithoutLanguage,
-        languages,
-        localisedUrlsConfig.map,
-      )
-    : pathWithoutLanguage;
-};