@bleedingdev/modern-js-i18n-runtime-extensions 3.8.3-ultramodern.6 → 3.9.0-ultramodern.10

package/dist/esm-node/router-navigation/adapter.mjs

@@ -0,0 +1,198 @@
+import "node:module";
+import { Fragment, jsx } from "react/jsx-runtime";
+import { RuntimeContext, isBrowser } from "@modern-js/runtime";
+import { InternalRuntimeContext } from "@modern-js/runtime/context";
+import { getRouterRuntimeState, subscribeRouterRuntimeState } from "@modern-js/runtime-extensions/router-state";
+import { useCallback, useContext, useSyncExternalStore } from "react";
+const normalizeUrlPart = (value, prefix)=>{
+    if ('string' != typeof value || !value) return '';
+    return value.startsWith(prefix) ? value : `${prefix}${value}`;
+};
+const normalizeLocation = (location)=>{
+    if (!location || 'object' != typeof location) return null;
+    const locationValue = location;
+    if ('string' != typeof locationValue.pathname) return null;
+    return {
+        pathname: locationValue.pathname,
+        search: normalizeUrlPart('string' == typeof locationValue.search ? locationValue.search : locationValue.searchStr, '?'),
+        hash: normalizeUrlPart(locationValue.hash, '#')
+    };
+};
+const getWindowLocation = ()=>{
+    if (!isBrowser()) return null;
+    return {
+        pathname: window.location.pathname,
+        search: window.location.search,
+        hash: window.location.hash
+    };
+};
+const getRouterFramework = (runtimeContext, internalContext, inReactRouter)=>{
+    const framework = getRouterRuntimeState(internalContext)?.framework || getRouterRuntimeState(runtimeContext)?.framework;
+    if (framework) return framework;
+    if (internalContext.router?.useRouter || runtimeContext.router?.useRouter) return 'tanstack';
+    if (internalContext.router?.useLocation || internalContext.router?.useHref || runtimeContext.router?.useLocation || runtimeContext.router?.useHref) return 'react-router';
+    if (inReactRouter) return 'react-router';
+};
+const getRouterInstance = (internalContext, contextRouter)=>{
+    if (contextRouter) return contextRouter;
+    const router = getRouterRuntimeState(internalContext)?.instance;
+    if (!router || 'object' != typeof router) return null;
+    return router;
+};
+const getRouterStateLocation = (internalContext, contextRouter)=>{
+    const router = getRouterInstance(internalContext, contextRouter);
+    return normalizeLocation(router?.stores?.location?.get?.()) || normalizeLocation(router?.state?.location);
+};
+const getRouterParams = (internalContext, contextRouter)=>{
+    const router = getRouterInstance(internalContext, contextRouter);
+    const matches = router?.stores?.matches?.get?.() || router?.state?.matches;
+    if (!Array.isArray(matches)) return {};
+    return matches.reduce((params, match)=>{
+        if (match?.params) Object.assign(params, match.params);
+        return params;
+    }, {});
+};
+const getRouterSnapshot = (internalContext, contextRouter)=>{
+    const location = getRouterStateLocation(internalContext, contextRouter);
+    const params = getRouterParams(internalContext, contextRouter);
+    return JSON.stringify([
+        location?.pathname ?? '',
+        location?.search ?? '',
+        location?.hash ?? '',
+        Object.entries(params).sort(([left], [right])=>left.localeCompare(right))
+    ]);
+};
+const createI18nRouterNavigation = ({ I18nNavigationProvider, useNativeI18nRouterAdapter })=>{
+    const useIntegratedRouterAdapter = ()=>{
+        const runtimeContext = useContext(RuntimeContext);
+        const internalContext = useContext(InternalRuntimeContext);
+        const routerApi = internalContext.router || runtimeContext.router;
+        const native = useNativeI18nRouterAdapter();
+        const inReactRouter = native.hasRouter;
+        const reactRouterNavigate = native.navigate;
+        const reactRouterLocation = inReactRouter ? native.location : null;
+        const reactRouterParams = native.params;
+        const framework = getRouterFramework(runtimeContext, internalContext, inReactRouter);
+        const contextUseRouter = inReactRouter || 'tanstack' !== framework ? void 0 : internalContext.router?.useRouter || runtimeContext.router?.useRouter;
+        const contextRouter = contextUseRouter ? contextUseRouter({
+            warn: false
+        }) : null;
+        const slotRouter = getRouterInstance(internalContext, contextRouter);
+        const drivableSlotRouter = ('tanstack' === framework || 'react-router' === framework) && 'function' == typeof slotRouter?.navigate;
+        const hasRouter = Boolean(reactRouterNavigate) || drivableSlotRouter;
+        const subscribeToRouter = useCallback((update)=>{
+            const unsubscribers = [];
+            const unsubscribeFromSlot = subscribeRouterRuntimeState(internalContext, update);
+            if ('function' == typeof unsubscribeFromSlot) unsubscribers.push(unsubscribeFromSlot);
+            const router = getRouterInstance(internalContext, contextRouter);
+            if (!router) return ()=>{
+                for (const unsubscribe of unsubscribers)unsubscribe();
+            };
+            if ('react-router' === framework && !inReactRouter && 'function' == typeof router.subscribe) {
+                const subscribe = router.subscribe;
+                const unsubscribe = subscribe.call(router, update);
+                if ('function' == typeof unsubscribe) unsubscribers.push(unsubscribe);
+            }
+            if ('tanstack' === framework && 'function' == typeof router.stores?.location?.subscribe) {
+                const unsubscribe = router.stores.location.subscribe(update);
+                if ('function' == typeof unsubscribe) unsubscribers.push(unsubscribe);
+            }
+            if ('tanstack' === framework && 'function' == typeof router.subscribe) {
+                const subscribe = router.subscribe;
+                for (const eventType of [
+                    'onBeforeNavigate',
+                    'onBeforeLoad'
+                ]){
+                    const unsubscribe = subscribe.call(router, eventType, update);
+                    if ('function' == typeof unsubscribe) unsubscribers.push(unsubscribe);
+                }
+            }
+            return ()=>{
+                for (const unsubscribe of unsubscribers)unsubscribe();
+            };
+        }, [
+            contextRouter,
+            framework,
+            inReactRouter,
+            internalContext
+        ]);
+        const getSnapshot = useCallback(()=>getRouterSnapshot(internalContext, contextRouter), [
+            contextRouter,
+            internalContext
+        ]);
+        useSyncExternalStore(subscribeToRouter, getSnapshot, getSnapshot);
+        const navigate = useCallback((href, options)=>{
+            const router = getRouterInstance(internalContext, contextRouter);
+            const activeFramework = getRouterFramework(runtimeContext, internalContext, inReactRouter);
+            if ('tanstack' === activeFramework) {
+                if ('function' == typeof router?.navigate) return router.navigate({
+                    to: href,
+                    replace: options?.replace,
+                    ...options?.state === void 0 ? {} : {
+                        state: options.state
+                    }
+                });
+                throw new Error('TanStack router instance is not available.');
+            }
+            if (reactRouterNavigate) return reactRouterNavigate(href, options);
+            if ('react-router' === activeFramework) {
+                if ('function' == typeof router?.navigate) return router.navigate(href, options);
+                throw new Error('React Router instance is not available.');
+            }
+        }, [
+            contextRouter,
+            internalContext,
+            inReactRouter,
+            reactRouterNavigate,
+            runtimeContext
+        ]);
+        const location = (reactRouterLocation ? normalizeLocation(reactRouterLocation) : getRouterStateLocation(internalContext, contextRouter)) || getWindowLocation();
+        const params = inReactRouter ? reactRouterParams : getRouterParams(internalContext, contextRouter);
+        const Link = 'tanstack' === framework ? internalContext.router?.Link || runtimeContext.router?.Link || null : 'react-router' === framework || inReactRouter ? routerApi?.Link ?? null : null;
+        return {
+            framework,
+            hasRouter,
+            location,
+            navigate: hasRouter ? navigate : null,
+            Link,
+            params,
+            ...'tanstack' === framework ? {
+                createLinkProps: createTanstackLinkProps
+            } : {}
+        };
+    };
+    const createTanstackLinkProps = (target)=>{
+        const preload = void 0 !== target.preload ? target.preload : 'none' === target.prefetch ? false : target.prefetch;
+        return {
+            to: target.pathname,
+            ...target.search ? {
+                search: target.search
+            } : {},
+            ...target.hash ? {
+                hash: target.hash
+            } : {},
+            ...void 0 === target.hashScrollIntoView ? {} : {
+                hashScrollIntoView: target.hashScrollIntoView
+            },
+            ...void 0 === preload ? {} : {
+                preload
+            }
+        };
+    };
+    const I18nRouterNavigationProvider = ({ children })=>{
+        const value = useIntegratedRouterAdapter();
+        const native = useNativeI18nRouterAdapter();
+        if (!value.hasRouter || native.hasRouter) return /*#__PURE__*/ jsx(Fragment, {
+            children: children
+        });
+        return /*#__PURE__*/ jsx(I18nNavigationProvider, {
+            value: value,
+            children: children
+        });
+    };
+    return {
+        useIntegratedRouterAdapter,
+        I18nRouterNavigationProvider
+    };
+};
+export { createI18nRouterNavigation };

package/dist/esm-node/router-navigation/index.mjs

@@ -0,0 +1,2 @@
+import "node:module";
+export { createI18nRouterNavigation } from "./adapter.mjs";

package/dist/types/index.d.ts

@@ -1,3 +1,4 @@
-export * from './language-sync/controller';
-export * from './language-sync/react';
-export * from './localisedUrls/index';
+export * from './language-sync/controller.js';
+export * from './language-sync/react.js';
+export * from './localeRedirectPolicy.js';
+export * from './localisedUrls/index.js';

package/dist/types/language-sync/react.d.ts

@@ -1,5 +1,5 @@
 import type React from 'react';
-import { type LanguageSyncFailure, type LanguageSyncPolicy } from './controller';
+import { type LanguageSyncFailure, type LanguageSyncPolicy } from './controller.js';
 export interface LatestLanguageSyncOptions<TTarget extends object> {
     changeLanguage: (target: TTarget, language: string) => PromiseLike<unknown> | unknown;
     commitLanguage: (target: TTarget, language: string) => void;

package/dist/types/localeRedirectPolicy.d.ts

@@ -0,0 +1,22 @@
+import type { LocalisedUrlsOption } from './localisedUrls/index.js';
+interface LocaleRedirectRequest {
+    url: string;
+    header: () => {
+        host?: string;
+    };
+}
+/**
+ * Check if pathname should ignore automatic locale redirect.
+ */
+export declare const shouldIgnoreRedirect: (pathname: string, urlPath: string, ignoreRedirectRoutes?: string[] | ((pathname: string) => boolean)) => boolean;
+/**
+ * Check if pathname is a static or federation resource request.
+ *
+ * This includes configured staticRoutePrefixes, the shared default skip policy
+ * from ADR-0002, and language-prefixed variants such as /en/static/app.js.
+ */
+export declare const isStaticResourceRequest: (pathname: string, staticRoutePrefixes: string[], languages?: string[]) => boolean;
+export declare const getLanguageFromPath: (req: LocaleRedirectRequest, urlPath: string, languages: string[]) => string | null;
+export declare const buildLocalizedUrl: (req: LocaleRedirectRequest, urlPath: string, language: string, languages: string[], localisedUrls?: LocalisedUrlsOption) => string;
+export declare const createLocaleRedirectResponse: (location: string) => Response;
+export {};

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

@@ -1,4 +1,4 @@
-import type { LocalisedUrlsOption, ResolvedLocalisedUrlsConfig } from './types';
+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

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

@@ -1,9 +1,10 @@
-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 { applyLocalisedUrlsToRoutes, validateLocalisedUrls } from './routes';
-export type { LocalisedRoute, LocalisedUrlPathMap, LocalisedUrlsMap, LocalisedUrlsOption, ResolvedLocalisedUrlsConfig, } from './types';
+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/pathname.d.ts

@@ -1,4 +1,4 @@
-import type { LocalisedUrlsOption } from './types';
+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/redirect.d.ts

@@ -4,7 +4,15 @@ export type LocaleRedirectSkipRule = {
 } | {
     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;

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

@@ -1,4 +1,4 @@
-import type { LocalisedUrlsMap } from './types';
+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

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

@@ -0,0 +1,24 @@
+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 +1,3 @@
-import type { LocalisedRoute, LocalisedUrlsMap } from './types';
+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/paths.d.ts

@@ -0,0 +1,9 @@
+import { type LocalisedUrlsOption } from './localisedUrls/index.js';
+export interface LocalizedPathsConfig {
+    languages: string[];
+    localisedUrls?: LocalisedUrlsOption;
+}
+/** Synchronous mapped URL construction, independent of React/plugin setup. */
+export declare const buildLocalizedUrl: (target: string, language: string, languages: string[], localisedUrls?: LocalisedUrlsOption) => string;
+export declare const localizePath: (target: string, language: string, config: LocalizedPathsConfig) => string;
+export declare const canonicalPath: (target: string, config: LocalizedPathsConfig) => string;

package/dist/types/router-navigation/adapter.d.ts

@@ -0,0 +1,71 @@
+import type React from 'react';
+/**
+ * Fork-owned: the selected-router navigation adapter.
+ *
+ * `useNativeI18nRouterAdapter` only knows react-router's own hooks, so a bare
+ * `appTools() + i18nPlugin()` app running the TanStack router would fall back
+ * to plain `<a>` links and a non-reactive `window.location`. That breaks
+ * language-invariant active state and, worse, leaves the i18n language stuck
+ * after a client-side navigation to a localized URL.
+ *
+ * The subsystem lives in this fork-owned package rather than inside
+ * upstream-owned `@modern-js/plugin-i18n`: that package only wires it in
+ * through its existing `NavigationProvider` extension point, so the upstream
+ * package keeps a seam instead of gaining a fork subsystem. The primitives the
+ * adapter composes with - the navigation context provider, the native
+ * react-router adapter and the adapter shape - are injected by that seam, so
+ * nothing here imports `@modern-js/plugin-i18n` and no dependency cycle is
+ * created.
+ *
+ * The adapter reads the actual selected router out of the fork-owned router
+ * runtime-state slot, so it serves both routers without either plugin having
+ * to know about i18n.
+ */
+/** The primitives the host plugin injects; see `createI18nRouterNavigation`. */
+export interface I18nRouterNavigationDependencies<Adapter extends I18nRouterAdapterShape> {
+    I18nNavigationProvider: React.ComponentType<React.PropsWithChildren<{
+        value: Adapter;
+    }>>;
+    useNativeI18nRouterAdapter: () => Adapter;
+}
+export interface I18nRouterLinkTarget {
+    pathname: string;
+    href: string;
+    search?: Record<string, unknown>;
+    hash?: string;
+    hashScrollIntoView?: boolean | ScrollIntoViewOptions;
+    prefetch?: 'intent' | 'render' | 'viewport' | 'none';
+    preload?: unknown;
+}
+export interface I18nRouterAdapterShape {
+    framework?: string;
+    hasRouter: boolean;
+    location: {
+        pathname: string;
+        search: string;
+        hash: string;
+    } | null;
+    navigate: ((href: string, options?: {
+        replace?: boolean;
+        state?: unknown;
+    }) => void | Promise<void>) | null;
+    Link: React.ComponentType<{
+        to: string;
+        children?: React.ReactNode;
+        [key: string]: unknown;
+    }> | null;
+    params: Record<string, string>;
+    createLinkProps?: (target: I18nRouterLinkTarget) => {
+        to: string;
+        [key: string]: unknown;
+    };
+}
+/**
+ * Build the selected-router navigation hook and provider from the host
+ * plugin's own primitives. Injecting them is what keeps this fork-owned
+ * subsystem free of any import edge back into the plugin that installs it.
+ */
+export declare const createI18nRouterNavigation: <Adapter extends I18nRouterAdapterShape>({ I18nNavigationProvider, useNativeI18nRouterAdapter, }: I18nRouterNavigationDependencies<Adapter>) => {
+    useIntegratedRouterAdapter: () => Adapter;
+    I18nRouterNavigationProvider: ({ children, }: React.PropsWithChildren) => React.JSX.Element;
+};

package/dist/types/router-navigation/index.d.ts

@@ -0,0 +1 @@
+export { createI18nRouterNavigation, type I18nRouterAdapterShape, type I18nRouterLinkTarget, type I18nRouterNavigationDependencies, } from './adapter.js';

package/package.json

@@ -17,7 +17,7 @@
     "modern.js",
     "i18n"
   ],
-  "version": "3.8.3-ultramodern.6",
+  "version": "3.9.0-ultramodern.10",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.mjs",
@@ -30,13 +30,35 @@
       },
       "default": "./dist/esm/index.mjs"
     },
-    "./package.json": "./package.json"
+    "./router-navigation": {
+      "types": "./dist/types/router-navigation/index.d.ts",
+      "node": {
+        "import": "./dist/esm-node/router-navigation/index.mjs",
+        "require": "./dist/cjs/router-navigation/index.js"
+      },
+      "default": "./dist/esm/router-navigation/index.mjs"
+    },
+    "./package.json": "./package.json",
+    "./paths": {
+      "types": "./dist/types/paths.d.ts",
+      "node": {
+        "import": "./dist/esm-node/paths.mjs",
+        "require": "./dist/cjs/paths.js"
+      },
+      "default": "./dist/esm/paths.mjs"
+    }
   },
   "typesVersions": {
     "*": {
       ".": [
         "./dist/types/index.d.ts",
         "./src/index.ts"
+      ],
+      "paths": [
+        "./dist/types/paths.d.ts"
+      ],
+      "router-navigation": [
+        "./dist/types/router-navigation/index.d.ts"
       ]
     }
   },
@@ -44,17 +66,19 @@
     "node": ">=26.7.0"
   },
   "dependencies": {
+    "@modern-js/runtime-extensions": "npm:@bleedingdev/modern-js-runtime-extensions@3.9.0-ultramodern.10",
+    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.9.0-ultramodern.10",
     "i18next-browser-languagedetector": "^8.2.1"
   },
   "peerDependencies": {
-    "@modern-js/runtime": "3.8.3-ultramodern.6",
+    "@modern-js/runtime": "3.9.0-ultramodern.10",
     "react": "^19.2.8"
   },
   "devDependencies": {
-    "@modern-js/runtime": "npm:@bleedingdev/modern-js-runtime@3.8.3-ultramodern.6",
-    "@rslib/core": "0.23.2",
+    "@modern-js/runtime": "npm:@bleedingdev/modern-js-runtime@3.9.0-ultramodern.10",
+    "@rslib/core": "1.0.0",
     "@scripts/rstest-config": "2.66.0",
-    "@types/node": "^26.2.0",
+    "@types/node": "^26.4.1",
     "@typescript/native-preview": "7.0.0-dev.20260707.2",
     "react": "^19.2.8",
     "react-dom": "^19.2.8"

package/src/index.ts

@@ -1,3 +1,4 @@
 export * from './language-sync/controller';
 export * from './language-sync/react';
+export * from './localeRedirectPolicy';
 export * from './localisedUrls/index';

package/src/localeRedirectPolicy.ts

@@ -0,0 +1,127 @@
+import type { LocalisedUrlsOption } from './localisedUrls/index';
+import {
+  isDefaultLocaleRedirectSkipPath,
+  localiseTargetPathname,
+  matchesPathPrefix,
+  shouldSkipLocaleRedirect,
+  stripLanguagePrefix,
+} from './localisedUrls/index';
+
+interface LocaleRedirectRequest {
+  url: string;
+  header: () => {
+    host?: string;
+  };
+}
+
+const stripUrlPathPrefix = (pathname: string, urlPath: string): string => {
+  const basePath = urlPath.replace('/*', '');
+
+  if (!basePath || basePath === '/') {
+    return pathname;
+  }
+
+  const remainingPath = pathname.startsWith(basePath)
+    ? pathname.slice(basePath.length)
+    : pathname;
+
+  return remainingPath || '/';
+};
+
+/**
+ * Check if pathname should ignore automatic locale redirect.
+ */
+export const shouldIgnoreRedirect = (
+  pathname: string,
+  urlPath: string,
+  ignoreRedirectRoutes?: string[] | ((pathname: string) => boolean),
+): boolean => {
+  const remainingPath = stripUrlPathPrefix(pathname, urlPath);
+
+  return shouldSkipLocaleRedirect(remainingPath, [], ignoreRedirectRoutes);
+};
+
+/**
+ * Check if pathname is a static or federation resource request.
+ *
+ * This includes configured staticRoutePrefixes, the shared default skip policy
+ * from ADR-0002, and language-prefixed variants such as /en/static/app.js.
+ */
+export const isStaticResourceRequest = (
+  pathname: string,
+  staticRoutePrefixes: string[],
+  languages: string[] = [],
+): boolean => {
+  if (isDefaultLocaleRedirectSkipPath(pathname, languages)) {
+    return true;
+  }
+
+  const matchesStaticRoutePrefix = (targetPathname: string): boolean =>
+    staticRoutePrefixes.some(prefix =>
+      matchesPathPrefix(targetPathname, prefix),
+    );
+
+  if (matchesStaticRoutePrefix(pathname)) {
+    return true;
+  }
+
+  const pathWithoutLanguage = stripLanguagePrefix(pathname, languages);
+
+  return (
+    pathWithoutLanguage !== pathname &&
+    matchesStaticRoutePrefix(pathWithoutLanguage)
+  );
+};
+
+export const getLanguageFromPath = (
+  req: LocaleRedirectRequest,
+  urlPath: string,
+  languages: string[],
+): string | null => {
+  const url = new URL(req.url, `http://${req.header().host}`);
+  const pathname = url.pathname;
+  const remainingPath = stripUrlPathPrefix(pathname, urlPath);
+  const segments = remainingPath.split('/').filter(Boolean);
+  const firstSegment = segments[0];
+
+  if (languages.includes(firstSegment)) {
+    return firstSegment;
+  }
+
+  return null;
+};
+
+export const buildLocalizedUrl = (
+  req: LocaleRedirectRequest,
+  urlPath: string,
+  language: string,
+  languages: string[],
+  localisedUrls?: LocalisedUrlsOption,
+): string => {
+  const url = new URL(req.url);
+  const pathname = url.pathname;
+  const basePath = urlPath.replace('/*', '');
+  const remainingPath = stripUrlPathPrefix(pathname, urlPath);
+
+  const newPathname = localiseTargetPathname(
+    remainingPath,
+    language,
+    languages,
+    localisedUrls,
+  );
+  const suffix = `${url.search}${url.hash}`;
+  const localizedUrl =
+    basePath === '/' ? newPathname + suffix : basePath + newPathname + suffix;
+
+  return localizedUrl;
+};
+
+export const createLocaleRedirectResponse = (location: string): Response =>
+  new Response(null, {
+    status: 302,
+    headers: {
+      'Cache-Control': 'private, no-store',
+      Location: location,
+      Vary: 'Accept-Language, Cookie',
+    },
+  });

package/src/localisedUrls/index.ts

@@ -14,6 +14,10 @@ export {
   shouldSkipLocaleRedirect,
 } from './redirect';
 export { resolveCanonicalLocalisedPath, resolveLocalisedPath } from './resolve';
+export {
+  canonicaliseLocalisedRoutes,
+  createLocalisedRouteRewrite,
+} from './routeIdentity';
 export { applyLocalisedUrlsToRoutes, validateLocalisedUrls } from './routes';
 export type {
   LocalisedRoute,