Refactor/unit tests part2 (#15990)

* fix(i18n): two locale and rendering bugs

* fix regression

* address feedback

* Update .changeset/kind-pants-wish.md

Co-authored-by:  Matthew Phillips <matthewphillips@cloudflare.com>

---------

Co-authored-by: Matthew Phillips <matthewphillips@cloudflare.com>

Author: ematipico

.changeset/kind-pants-wish.md

@@ -0,0 +1,5 @@
+---
+'astro': patch
+---
+
+Fixes an issue where `Astro.currentLocale` would always be the default locale instead of the actual one when using a dynamic route like `[locale].astro` or `[locale]/index.astro`. It now resolves to the correct locale from the URL.

.changeset/little-heads-kick.md

@@ -0,0 +1,5 @@
+---
+'astro': patch
+---
+
+Fixes an issue where visiting an invalid locale URL (e.g. `/asdf/`) would show the content of a dynamic `[locale]` page with a 404 status code, instead of showing your custom 404 page. Now, the correct 404 page is rendered when the locale in the URL doesn't match any configured locale.

packages/astro/src/core/render-context.ts

@@ -5,6 +5,7 @@ import type { ActionAPIContext } from '../actions/runtime/types.js';
 import { createCallAction, createGetActionResult, hasActionPayload } from '../actions/utils.js';
 import {
 	computeCurrentLocale,
+	computeCurrentLocaleFromParams,
 	computePreferredLocale,
 	computePreferredLocaleList,
 } from '../i18n/utils.js';
@@ -898,6 +899,16 @@ export class RenderContext {
 			}
 			pathname = pathname && !isRoute404or500(routeData) ? pathname : url.pathname;
 			computedLocale = computeCurrentLocale(pathname, locales, defaultLocale);
+			// If the route has dynamic params, check if any param value matches a
+			// configured locale. This handles routes like [locale].astro where the
+			// pathname contains unresolved placeholders and computeCurrentLocale
+			// falls back to the default locale.
+			if (routeData.params.length > 0) {
+				const localeFromParams = computeCurrentLocaleFromParams(this.params, locales);
+				if (localeFromParams) {
+					computedLocale = localeFromParams;
+				}
+			}
 		}
 
 		this.#currentLocale = computedLocale ?? fallbackTo;

packages/astro/src/core/routing/match.ts

@@ -6,6 +6,17 @@ import { isRoute404, isRoute500 } from './internal/route-errors.js';
 
 /** Find matching route from pathname */
 export function matchRoute(pathname: string, manifest: RoutesList): RouteData | undefined {
+	// Error pages (404/500) take precedence over dynamic routes that might
+	// capture the same path (e.g. [locale] matching /404). See #15098.
+	if (isRoute404(pathname)) {
+		const errorRoute = manifest.routes.find((route) => isRoute404(route.route));
+		if (errorRoute) return errorRoute;
+	}
+	if (isRoute500(pathname)) {
+		const errorRoute = manifest.routes.find((route) => isRoute500(route.route));
+		if (errorRoute) return errorRoute;
+	}
+
 	return manifest.routes.find((route) => {
 		return (
 			route.pattern.test(pathname) ||

packages/astro/src/core/routing/rewrite.ts

@@ -14,6 +14,7 @@ import {
 } from '../path.js';
 import { createRequest } from '../request.js';
 import { DEFAULT_404_ROUTE } from './internal/astro-designed-error-pages.js';
+import { isRoute404, isRoute500 } from './internal/route-errors.js';
 
 type FindRouteToRewrite = {
 	payload: RewritePayload;
@@ -99,6 +100,22 @@ export function findRouteToRewrite({
 	}
 
 	const decodedPathname = decodeURI(pathname);
+
+	// Error pages (404/500) take precedence over dynamic routes that might
+	// capture the same path (e.g. [locale] matching /404). See #15098.
+	if (isRoute404(decodedPathname)) {
+		const errorRoute = routes.find((route) => route.route === '/404');
+		if (errorRoute) {
+			return { routeData: errorRoute, newUrl, pathname: decodedPathname };
+		}
+	}
+	if (isRoute500(decodedPathname)) {
+		const errorRoute = routes.find((route) => route.route === '/500');
+		if (errorRoute) {
+			return { routeData: errorRoute, newUrl, pathname: decodedPathname };
+		}
+	}
+
 	let foundRoute;
 	for (const route of routes) {
 		if (route.pattern.test(decodedPathname)) {

packages/astro/src/i18n/middleware.ts

@@ -71,15 +71,28 @@ export function createI18nMiddleware(
 				return context.redirect(location, routeDecision.status);
 			}
 			case 'notFound': {
-				const notFoundRes = new Response(response.body, {
-					status: 404,
-					headers: response.headers,
-				});
-				notFoundRes.headers.set(REROUTE_DIRECTIVE_HEADER, 'no');
+				if (context.isPrerendered) {
+					// Prerendered pages are authored content — preserve the body so the
+					// build pipeline can write the file. The REROUTE_DIRECTIVE prevents
+					// the App from rerouting to the error page.
+					const prerenderedRes = new Response(response.body, {
+						status: 404,
+						headers: response.headers,
+					});
+					prerenderedRes.headers.set(REROUTE_DIRECTIVE_HEADER, 'no');
+					if (routeDecision.location) {
+						prerenderedRes.headers.set('Location', routeDecision.location);
+					}
+					return prerenderedRes;
+				}
+				// For SSR, return a null-body 404 so the App reroutes to the actual
+				// 404 page. This prevents dynamic routes like [locale] from serving
+				// their content for invalid locale paths.
+				const headers = new Headers();
 				if (routeDecision.location) {
-					notFoundRes.headers.set('Location', routeDecision.location);
+					headers.set('Location', routeDecision.location);
 				}
-				return notFoundRes;
+				return new Response(null, { status: 404, headers });
 			}
 			case 'continue':
 				break; // Continue to fallback check

packages/astro/src/i18n/utils.ts

@@ -187,3 +187,38 @@ export function computeCurrentLocale(
 		}
 	}
 }
+
+/**
+ * Check if any of the route's resolved param values match a configured locale.
+ * This handles dynamic routes like `[locale]` or `[...path]` where the locale
+ * isn't in a static segment of the route pathname.
+ */
+export function computeCurrentLocaleFromParams(
+	params: Record<string, string | undefined>,
+	locales: Locales,
+): string | undefined {
+	// Precompute lookup maps for O(1) matching instead of nested loops.
+	// normalizedCode -> original locale string or first code for object locales
+	const byNormalizedCode = new Map<string, string>();
+	// path -> first code (for object locales)
+	const byPath = new Map<string, string>();
+
+	for (const locale of locales) {
+		if (typeof locale === 'string') {
+			byNormalizedCode.set(normalizeTheLocale(locale), locale);
+		} else {
+			byPath.set(locale.path, locale.codes[0]);
+			for (const code of locale.codes) {
+				byNormalizedCode.set(normalizeTheLocale(code), code);
+			}
+		}
+	}
+
+	for (const value of Object.values(params)) {
+		if (!value) continue;
+		const pathMatch = byPath.get(value);
+		if (pathMatch) return pathMatch;
+		const codeMatch = byNormalizedCode.get(normalizeTheLocale(value));
+		if (codeMatch) return codeMatch;
+	}
+}

packages/astro/test/units/app/test-helpers.js

@@ -9,6 +9,7 @@
  * @param {Function} [options.middleware]
  * @param {Function} [options.actions]
  * @param {number} [options.actionBodySizeLimit]
+ * @param {object} [options.i18n]
  */
 export function createManifest({
 	routes,
@@ -18,6 +19,7 @@ export function createManifest({
 	middleware = undefined,
 	actions = undefined,
 	actionBodySizeLimit = 0,
+	i18n = undefined,
 } = {}) {
 	const rootDir = new URL('file:///astro-test/');
 	const buildDir = new URL('file:///astro-test/dist/');
@@ -44,7 +46,7 @@ export function createManifest({
 		pageMap,
 		serverIslandMappings: undefined,
 		key: Promise.resolve(/** @type {CryptoKey} */ ({})),
-		i18n: undefined,
+		i18n,
 		middleware,
 		actions,
 		sessionDriver: undefined,