File size: 2,499 Bytes
1e92f2d |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 |
import { NEXT_URL } from '../client/components/app-router-headers'
import {
extractInterceptionRouteInformation,
isInterceptionRouteAppPath,
} from '../shared/lib/router/utils/interception-routes'
import type { Rewrite } from './load-custom-routes'
import { safePathToRegexp } from '../shared/lib/router/utils/route-match-utils'
import type { DeepReadonly } from '../shared/lib/deep-readonly'
// a function that converts normalised paths (e.g. /foo/[bar]/[baz]) to the format expected by pathToRegexp (e.g. /foo/:bar/:baz)
function toPathToRegexpPath(path: string): string {
return path.replace(/\[\[?([^\]]+)\]\]?/g, (_, capture) => {
// path-to-regexp only supports word characters, so we replace any non-word characters with underscores
const paramName = capture.replace(/\W+/g, '_')
// handle catch-all segments (e.g. /foo/bar/[...baz] or /foo/bar/[[...baz]])
if (capture.startsWith('...')) {
return `:${capture.slice(3)}*`
}
return ':' + paramName
})
}
export function generateInterceptionRoutesRewrites(
appPaths: string[],
basePath = ''
): Rewrite[] {
const rewrites: Rewrite[] = []
for (const appPath of appPaths) {
if (isInterceptionRouteAppPath(appPath)) {
const { interceptingRoute, interceptedRoute } =
extractInterceptionRouteInformation(appPath)
const normalizedInterceptingRoute = `${
interceptingRoute !== '/' ? toPathToRegexpPath(interceptingRoute) : ''
}/(.*)?`
const normalizedInterceptedRoute = toPathToRegexpPath(interceptedRoute)
const normalizedAppPath = toPathToRegexpPath(appPath)
// pathToRegexp returns a regex that matches the path, but we need to
// convert it to a string that can be used in a header value
// to the format that Next/the proxy expects
let interceptingRouteRegex = safePathToRegexp(normalizedInterceptingRoute)
.toString()
.slice(2, -3)
rewrites.push({
source: `${basePath}${normalizedInterceptedRoute}`,
destination: `${basePath}${normalizedAppPath}`,
has: [
{
type: 'header',
key: NEXT_URL,
value: interceptingRouteRegex,
},
],
})
}
}
return rewrites
}
export function isInterceptionRouteRewrite(route: DeepReadonly<Rewrite>) {
// When we generate interception rewrites in the above implementation, we always do so with only a single `has` condition.
return route.has?.[0]?.key === NEXT_URL
}
|