vinext 0.0.51 → 0.0.53

package/dist/config/config-matchers.d.ts

@@ -1,4 +1,4 @@
-import { HasCondition, NextHeader, NextRedirect, NextRewrite } from "./next-config.js";
+import { HasCondition, NextHeader, NextI18nConfig, NextRedirect, NextRewrite } from "./next-config.js";
 
 //#region src/config/config-matchers.d.ts
 /**
@@ -37,6 +37,28 @@ type RequestContext = {
   query: URLSearchParams;
   host: string;
 };
+/**
+ * basePath gating state passed alongside the pathname to every matcher.
+ *
+ * Rewrites/redirects/headers run with default `basePath: true` semantics in
+ * Next.js: the rule only matches when the inbound request was under the
+ * configured `basePath`. Rules with `basePath: false` opt out and match
+ * the original (un-stripped) pathname regardless of prefix.
+ *
+ * When `basePath` is empty (not configured) every rule is treated as
+ * basePath-defaulted: every request matches.
+ *
+ * @see .nextjs-ref/packages/next/src/lib/load-custom-routes.ts:198-220
+ */
+type BasePathMatchState = {
+  /** Configured `basePath` (without trailing slash) or "" when unset. */basePath: string;
+  /**
+   * True when the inbound request was originally under `basePath` (i.e.
+   * the prod-server/handler stripped the prefix before the matcher runs).
+   * Ignored when `basePath` is empty.
+   */
+  hadBasePath: boolean;
+};
 /**
  * Parse a Cookie header string into a key-value record.
  */
@@ -70,17 +92,6 @@ declare function applyMiddlewareRequestHeaders(middlewareHeaders: Record<string,
   postMwReqCtx: RequestContext;
 };
 declare function checkHasConditions(has: HasCondition[] | undefined, missing: HasCondition[] | undefined, ctx: RequestContext): boolean;
-/**
- * Match a Next.js config pattern (from redirects/rewrites sources) against a pathname.
- * Returns matched params or null.
- *
- * Supports:
- *   :param     - matches a single path segment
- *   :param*    - matches zero or more segments (catch-all)
- *   :param+    - matches one or more segments
- *   (regex)    - inline regex patterns in the source
- *   :param(constraint) - named param with inline regex constraint
- */
 declare function matchConfigPattern(pathname: string, pattern: string): Record<string, string> | null;
 /**
  * Apply redirect rules from next.config.js.
@@ -117,7 +128,7 @@ declare function matchConfigPattern(pathname: string, pattern: string): Record<s
  * an original index < N are checked via matchConfigPattern first — they are
  * few in practice (typically zero) so this is not a hot-path concern.
  */
-declare function matchRedirect(pathname: string, redirects: NextRedirect[], ctx: RequestContext): {
+declare function matchRedirect(pathname: string, redirects: NextRedirect[], ctx: RequestContext, basePathState?: BasePathMatchState): {
   destination: string;
   permanent: boolean;
 } | null;
@@ -129,7 +140,7 @@ declare function matchRedirect(pathname: string, redirects: NextRedirect[], ctx:
  * to evaluate has/missing conditions. Next.js always has request context
  * when evaluating rewrites, so this parameter is required.
  */
-declare function matchRewrite(pathname: string, rewrites: NextRewrite[], ctx: RequestContext): string | null;
+declare function matchRewrite(pathname: string, rewrites: NextRewrite[], ctx: RequestContext, basePathState?: BasePathMatchState): string | null;
 /**
  * Sanitize a redirect/rewrite destination to collapse protocol-relative URLs.
  *
@@ -166,10 +177,46 @@ declare function proxyExternalRequest(request: Request, externalUrl: string): Pr
  * to evaluate has/missing conditions. Next.js always has request context
  * when evaluating headers, so this parameter is required.
  */
-declare function matchHeaders(pathname: string, headers: NextHeader[], ctx: RequestContext): Array<{
+declare function matchHeaders(pathname: string, headers: NextHeader[], ctx: RequestContext, basePathState?: BasePathMatchState): Array<{
   key: string;
   value: string;
 }>;
+/**
+ * Apply Next.js i18n locale-prefix transformation to a set of redirect or
+ * rewrite rules. Mirrors the relevant slice of Next.js's `processRoutes`
+ * (load-custom-routes.ts) with one deliberate divergence noted below.
+ *
+ * For each rule:
+ *   - If `locale === false` or no i18n is configured, the rule is emitted
+ *     untouched. This is the core of issue #1336 item 1: with `locale: false`
+ *     the user-supplied source is matched against the raw locale-prefixed
+ *     URL so a `:locale` segment in the source captures the prefix itself.
+ *   - Otherwise an internal locale-capture variant is produced whose source
+ *     starts with `/:nextInternalLocale(en|sv|nl)` so that locale-prefixed
+ *     URLs match. For redirects only, a second variant prefixed with
+ *     `/${defaultLocale}` is also emitted, matching Next.js exactly.
+ *   - **Vinext divergence**: we ALSO retain the original (unprefixed) source
+ *     so that requests for the default locale that arrive without a prefix
+ *     still match. Next.js solves this upstream by path-normalising every
+ *     incoming default-locale request to include the prefix
+ *     (`resolve-routes.ts` lines ~251-263); vinext currently does that
+ *     normalisation only inside the pages-server-entry route matcher, so
+ *     the rewrite/redirect matcher would otherwise miss unprefixed paths.
+ *     Keeping the unprefixed variant gives functionally identical behaviour
+ *     without requiring a server-wide path normalisation pass. The original
+ *     source is appended LAST so the locale-aware variants win when both
+ *     forms could match.
+ *
+ * Destinations that are local (start with `/`) are similarly rewritten with
+ * `/:nextInternalLocale` for the locale-capture variant so the locale
+ * survives the rewrite/redirect target.
+ *
+ * Mirrors the Next.js reference in
+ * packages/next/src/lib/load-custom-routes.ts — see `processRoutes`.
+ */
+declare function applyLocaleToRoutes<T extends NextRedirect | NextRewrite>(routes: T[], i18n: NextI18nConfig | null | undefined, type: "redirect" | "rewrite", options?: {
+  trailingSlash?: boolean;
+}): T[];
 //#endregion
-export { RequestContext, applyMiddlewareRequestHeaders, checkHasConditions, escapeHeaderSource, isExternalUrl, isSafeRegex, matchConfigPattern, matchHeaders, matchRedirect, matchRewrite, normalizeHost, parseCookies, proxyExternalRequest, requestContextFromRequest, safeRegExp, sanitizeDestination };
+export { BasePathMatchState, RequestContext, applyLocaleToRoutes, applyMiddlewareRequestHeaders, checkHasConditions, escapeHeaderSource, isExternalUrl, isSafeRegex, matchConfigPattern, matchHeaders, matchRedirect, matchRewrite, normalizeHost, parseCookies, proxyExternalRequest, requestContextFromRequest, safeRegExp, sanitizeDestination };
 //# sourceMappingURL=config-matchers.d.ts.map

package/dist/config/config-matchers.js

@@ -1,4 +1,4 @@
-import { VINEXT_MW_CTX_HEADER, VINEXT_PRERENDER_SECRET_HEADER } from "../server/headers.js";
+import { VINEXT_MW_CTX_HEADER, VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER } from "../server/headers.js";
 import { buildRequestHeadersFromMiddlewareResponse } from "../server/middleware-request-headers.js";
 //#region src/config/config-matchers.ts
 /**
@@ -99,8 +99,18 @@ function getCachedRegex(cache, key, compile) {
 * locale-static fast-path match is found, any linear rules that appear earlier
 * in the array are still checked first.
 */
-/** Matches `/:param(alternation)?/static/suffix` — the locale-static pattern. */
-const _LOCALE_STATIC_RE = /^\/:[\w-]+\(([^)]+)\)\?\/([a-zA-Z0-9_~.%@!$&'*+,;=:/-]+)$/;
+/**
+* Matches `/:param(alternation)?/static/suffix` — the locale-static pattern.
+*
+* The `?` after the capture group is itself optional so that both forms are
+* detected:
+*   - `/:locale(en|fr)?/foo` (locale segment optional — user-written rules)
+*   - `/:nextInternalLocale(en|fr)/foo` (locale segment mandatory — emitted
+*      by `applyLocaleToRoutes` for the locale-capture variant)
+* Both forms benefit from O(1) suffix lookup; the optionality is recorded
+* on the entry so we know whether to try the no-locale-prefix bucket.
+*/
+const _LOCALE_STATIC_RE = /^\/:[\w-]+\(([^)]+)\)(\??)\/([a-zA-Z0-9_~.%@!$&'*+,;=:/-]+)$/;
 const _redirectIndexCache = /* @__PURE__ */ new WeakMap();
 /**
 * Build (or retrieve from cache) the redirect index for a given redirects array.
@@ -120,7 +130,8 @@ function _getRedirectIndex(redirects) {
 		if (m) {
 			const paramName = redirect.source.slice(2, redirect.source.indexOf("("));
 			const alternation = m[1];
-			const suffix = "/" + m[2];
+			const optional = m[2] === "?";
+			const suffix = "/" + m[3];
 			const altRe = safeRegExp("^(?:" + alternation + ")$");
 			if (!altRe) {
 				linear.push([i, redirect]);
@@ -129,6 +140,7 @@ function _getRedirectIndex(redirects) {
 			const entry = {
 				paramName,
 				altRe,
+				optional,
 				redirect,
 				originalIndex: i
 			};
@@ -307,6 +319,26 @@ function escapeHeaderSource(source) {
 	}
 	return result;
 }
+const _BASEPATH_DEFAULT = {
+	basePath: "",
+	hadBasePath: true
+};
+/**
+* Decide whether a rule should be evaluated at all given the current
+* basePath-gating state.
+*
+* Encodes the Next.js rules:
+*   - basePath: false rule → only when the request was NOT under basePath
+*     (i.e. it's the explicit opt-out path). When `basePath` itself is
+*     empty, basePath: false rules are still allowed to match — there's
+*     just no basePath to gate them.
+*   - default rule (basePath !== false) → only when the request WAS under
+*     basePath (or no basePath is configured).
+*/
+function shouldEvaluateRule(ruleBasePath, state) {
+	if (!state.basePath) return true;
+	return ruleBasePath === false ? !state.hadBasePath : state.hadBasePath;
+}
 /**
 * Parse a Cookie header string into a key-value record.
 */
@@ -472,8 +504,31 @@ function extractConstraint(str, re) {
 *   (regex)    - inline regex patterns in the source
 *   :param(constraint) - named param with inline regex constraint
 */
+/**
+* Strip a single trailing slash from a pathname for config-source matching.
+*
+* Next.js conditionally appends `(/)?` to rewrite/redirect/header source
+* regexes when `trailingSlash: true` (see Next.js
+* `resolve-rewrites.ts` and `server-utils.ts:checkRewrite`). Rather than
+* threading the trailingSlash flag through every matcher, we unconditionally
+* strip a trailing slash from the incoming pathname. When `trailingSlash: false`
+* the request pipeline emits a normalizing redirect (step 3) before config
+* rewrites/redirects (step 6) ever run, so the pathname is already slash-free;
+* the unconditional strip is defense-in-depth for that ordering. When
+* `trailingSlash: true` it bridges the gap between the canonicalized request
+* path (`/rewrite-1/`) and source patterns written without a trailing slash
+* (`/rewrite-1`).
+*
+* The root path `"/"` is preserved as-is.
+*/
+function stripTrailingSlashForConfigMatch(pathname) {
+	return pathname.length > 1 && pathname.endsWith("/") ? pathname.slice(0, -1) : pathname;
+}
 function matchConfigPattern(pathname, pattern) {
-	if (pattern.includes("(") || pattern.includes("\\") || /:[\w-]+[*+][^/]/.test(pattern) || /:[\w-]+\./.test(pattern)) try {
+	pathname = stripTrailingSlashForConfigMatch(pathname);
+	const catchAllAnchor = /:[\w-]+[*+]/.test(pattern);
+	const namedParamCount = (pattern.match(/:[\w-]+/g) || []).length;
+	if (pattern.includes("(") || pattern.includes("\\") || /:[\w-]+[*+][^/]/.test(pattern) || /:[\w-]+\./.test(pattern) || catchAllAnchor && namedParamCount > 1) try {
 		const compiled = getCachedRegex(_compiledPatternCache, pattern, () => {
 			const paramNames = [];
 			let regexStr = "";
@@ -566,16 +621,19 @@ function matchConfigPattern(pathname, pattern) {
 * an original index < N are checked via matchConfigPattern first — they are
 * few in practice (typically zero) so this is not a hot-path concern.
 */
-function matchRedirect(pathname, redirects, ctx) {
+function matchRedirect(pathname, redirects, ctx, basePathState = _BASEPATH_DEFAULT) {
 	if (redirects.length === 0) return null;
+	pathname = stripTrailingSlashForConfigMatch(pathname);
 	const index = _getRedirectIndex(redirects);
 	let localeMatch = null;
 	let localeMatchIndex = Infinity;
 	if (index.localeStatic.size > 0) {
 		const noLocaleBucket = index.localeStatic.get(pathname);
 		if (noLocaleBucket) for (const entry of noLocaleBucket) {
+			if (!entry.optional) continue;
 			if (entry.originalIndex >= localeMatchIndex) continue;
 			const redirect = entry.redirect;
+			if (!shouldEvaluateRule(redirect.basePath, basePathState)) continue;
 			const conditionParams = redirect.has || redirect.missing ? collectConditionParams(redirect.has, redirect.missing, ctx) : _emptyParams();
 			if (!conditionParams) continue;
 			localeMatch = {
@@ -597,6 +655,7 @@ function matchRedirect(pathname, redirects, ctx) {
 				if (entry.originalIndex >= localeMatchIndex) continue;
 				if (!entry.altRe.test(localePart)) continue;
 				const redirect = entry.redirect;
+				if (!shouldEvaluateRule(redirect.basePath, basePathState)) continue;
 				const conditionParams = redirect.has || redirect.missing ? collectConditionParams(redirect.has, redirect.missing, ctx) : _emptyParams();
 				if (!conditionParams) continue;
 				localeMatch = {
@@ -613,6 +672,7 @@ function matchRedirect(pathname, redirects, ctx) {
 	}
 	for (const [origIdx, redirect] of index.linear) {
 		if (origIdx >= localeMatchIndex) break;
+		if (!shouldEvaluateRule(redirect.basePath, basePathState)) continue;
 		const params = matchConfigPattern(pathname, redirect.source);
 		if (params) {
 			const conditionParams = redirect.has || redirect.missing ? collectConditionParams(redirect.has, redirect.missing, ctx) : _emptyParams();
@@ -636,8 +696,9 @@ function matchRedirect(pathname, redirects, ctx) {
 * to evaluate has/missing conditions. Next.js always has request context
 * when evaluating rewrites, so this parameter is required.
 */
-function matchRewrite(pathname, rewrites, ctx) {
+function matchRewrite(pathname, rewrites, ctx, basePathState = _BASEPATH_DEFAULT) {
 	for (const rewrite of rewrites) {
+		if (!shouldEvaluateRule(rewrite.basePath, basePathState)) continue;
 		const params = matchConfigPattern(pathname, rewrite.source);
 		if (params) {
 			const conditionParams = rewrite.has || rewrite.missing ? collectConditionParams(rewrite.has, rewrite.missing, ctx) : _emptyParams();
@@ -723,6 +784,7 @@ async function proxyExternalRequest(request, externalUrl) {
 	for (const key of headers.keys()) if (key.startsWith("x-middleware-")) keysToDelete.push(key);
 	for (const key of keysToDelete) headers.delete(key);
 	headers.delete(VINEXT_PRERENDER_SECRET_HEADER);
+	headers.delete(VINEXT_PRERENDER_ROUTE_PARAMS_HEADER);
 	headers.delete(VINEXT_MW_CTX_HEADER);
 	const method = request.method;
 	const hasBody = method !== "GET" && method !== "HEAD";
@@ -775,9 +837,11 @@ async function proxyExternalRequest(request, externalUrl) {
 * to evaluate has/missing conditions. Next.js always has request context
 * when evaluating headers, so this parameter is required.
 */
-function matchHeaders(pathname, headers, ctx) {
+function matchHeaders(pathname, headers, ctx, basePathState = _BASEPATH_DEFAULT) {
+	pathname = stripTrailingSlashForConfigMatch(pathname);
 	const result = [];
 	for (const rule of headers) {
+		if (!shouldEvaluateRule(rule.basePath, basePathState)) continue;
 		const sourceRegex = getCachedRegex(_compiledHeaderSourceCache, rule.source, () => safeRegExp("^" + escapeHeaderSource(rule.source) + "$"));
 		if (sourceRegex && sourceRegex.test(pathname)) {
 			if (rule.has || rule.missing) {
@@ -788,7 +852,79 @@ function matchHeaders(pathname, headers, ctx) {
 	}
 	return result;
 }
+/**
+* Escape a string for inclusion in a regex character class / alternation.
+* Mirrors `escape-string-regexp` semantics used by Next.js's processRoutes.
+*/
+function _escapeRegexString(value) {
+	return value.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&");
+}
+/**
+* Apply Next.js i18n locale-prefix transformation to a set of redirect or
+* rewrite rules. Mirrors the relevant slice of Next.js's `processRoutes`
+* (load-custom-routes.ts) with one deliberate divergence noted below.
+*
+* For each rule:
+*   - If `locale === false` or no i18n is configured, the rule is emitted
+*     untouched. This is the core of issue #1336 item 1: with `locale: false`
+*     the user-supplied source is matched against the raw locale-prefixed
+*     URL so a `:locale` segment in the source captures the prefix itself.
+*   - Otherwise an internal locale-capture variant is produced whose source
+*     starts with `/:nextInternalLocale(en|sv|nl)` so that locale-prefixed
+*     URLs match. For redirects only, a second variant prefixed with
+*     `/${defaultLocale}` is also emitted, matching Next.js exactly.
+*   - **Vinext divergence**: we ALSO retain the original (unprefixed) source
+*     so that requests for the default locale that arrive without a prefix
+*     still match. Next.js solves this upstream by path-normalising every
+*     incoming default-locale request to include the prefix
+*     (`resolve-routes.ts` lines ~251-263); vinext currently does that
+*     normalisation only inside the pages-server-entry route matcher, so
+*     the rewrite/redirect matcher would otherwise miss unprefixed paths.
+*     Keeping the unprefixed variant gives functionally identical behaviour
+*     without requiring a server-wide path normalisation pass. The original
+*     source is appended LAST so the locale-aware variants win when both
+*     forms could match.
+*
+* Destinations that are local (start with `/`) are similarly rewritten with
+* `/:nextInternalLocale` for the locale-capture variant so the locale
+* survives the rewrite/redirect target.
+*
+* Mirrors the Next.js reference in
+* packages/next/src/lib/load-custom-routes.ts — see `processRoutes`.
+*/
+function applyLocaleToRoutes(routes, i18n, type, options = {}) {
+	if (!i18n || routes.length === 0) return routes;
+	const trailingSlash = options.trailingSlash ?? false;
+	const internalLocale = `/:nextInternalLocale(${i18n.locales.map(_escapeRegexString).join("|")})`;
+	const suffixFor = (source) => source === "/" && !trailingSlash ? "" : source;
+	const defaultLocales = type === "redirect" ? [i18n.defaultLocale] : [];
+	const out = [];
+	for (const r of routes) {
+		if (r.locale === false) {
+			out.push(r);
+			continue;
+		}
+		const isExternal = !!r.destination && !r.destination.startsWith("/");
+		if (!isExternal) for (const locale of defaultLocales) {
+			const localizedSource = `/${locale}${suffixFor(r.source)}`;
+			out.push({
+				...r,
+				source: localizedSource
+			});
+		}
+		const internalSource = `${internalLocale}${suffixFor(r.source)}`;
+		let internalDestination = r.destination;
+		if (internalDestination && internalDestination.startsWith("/") && !isExternal) internalDestination = `/:nextInternalLocale${internalDestination === "/" && !trailingSlash ? "" : internalDestination}`;
+		out.push({
+			...r,
+			source: internalSource,
+			destination: internalDestination
+		});
+		out.push(r);
+	}
+	return out;
+}
 //#endregion
-export { applyMiddlewareRequestHeaders, checkHasConditions, escapeHeaderSource, isExternalUrl, isSafeRegex, matchConfigPattern, matchHeaders, matchRedirect, matchRewrite, normalizeHost, parseCookies, proxyExternalRequest, requestContextFromRequest, safeRegExp, sanitizeDestination };
+export { applyLocaleToRoutes, applyMiddlewareRequestHeaders, checkHasConditions, escapeHeaderSource, isExternalUrl, isSafeRegex, matchConfigPattern, matchHeaders, matchRedirect, matchRewrite, normalizeHost, parseCookies, proxyExternalRequest, requestContextFromRequest, safeRegExp, sanitizeDestination };
 
 //# sourceMappingURL=config-matchers.js.map