@analogjs/router 3.0.0-alpha.4 → 3.0.0-alpha.40

package/fesm2022/analogjs-router.mjs

@@ -1,12 +1,15 @@
-import { a as updateMetaTagsOnRouteChange, i as injectRouteEndpointURL, n as createRoutes, r as routes, t as injectDebugRoutes } from "./routes.mjs";
+import { API_PREFIX, injectAPIPrefix, injectBaseURL, injectInternalServerFetch, injectRequest } from "./analogjs-router-tokens.mjs";
+import { a as updateMetaTagsOnRouteChange, i as injectRouteEndpointURL, n as ANALOG_ROUTE_FILES, o as updateJsonLdOnRouteChange, r as createRoutes$1, t as ANALOG_EXTRA_ROUTE_FILE_SOURCES } from "./route-files.mjs";
+import { n as createRoutes, r as routes, t as injectDebugRoutes } from "./routes.mjs";
 import { ActivatedRoute, ROUTES, Router, provideRouter } from "@angular/router";
 import * as i0 from "@angular/core";
-import { ChangeDetectionStrategy, Component, Directive, ENVIRONMENT_INITIALIZER, Injector, PLATFORM_ID, TransferState, effect, inject, input, makeEnvironmentProviders, makeStateKey, output, signal } from "@angular/core";
+import { ChangeDetectionStrategy, Component, DOCUMENT, Directive, InjectionToken, Injector, PLATFORM_ID, TransferState, assertInInjectionContext, effect, inject, input, isDevMode, makeEnvironmentProviders, makeStateKey, output, provideAppInitializer, signal } from "@angular/core";
 import { HttpClient, HttpHeaders, HttpRequest, HttpResponse, ɵHTTP_ROOT_INTERCEPTOR_FNS } from "@angular/common/http";
-import { catchError, from, map, of, throwError } from "rxjs";
-import { API_PREFIX, injectAPIPrefix, injectBaseURL, injectInternalServerFetch, injectRequest } from "@analogjs/router/tokens";
-import { DomSanitizer } from "@angular/platform-browser";
+import { catchError, from, map, of, take, throwError } from "rxjs";
+import { DomSanitizer, Meta } from "@angular/platform-browser";
 import { isPlatformServer } from "@angular/common";
+import { toSignal } from "@angular/core/rxjs-interop";
+import { LOCALE, REQUEST } from "@analogjs/router/tokens";
 //#region packages/router/src/lib/define-route.ts
 /**
 * @deprecated Use `RouteMeta` type instead.
@@ -66,26 +69,38 @@ function cookieInterceptor(req, next, location = inject(PLATFORM_ID), serverRequ
 	} else return next(req);
 }
 //#endregion
-//#region packages/router/src/lib/provide-file-router.ts
-/**
-* Sets up providers for the Angular router, and registers
-* file-based routes. Additional features can be provided
-* to further configure the behavior of the router.
-*
-* @param features
-* @returns Providers and features to configure the router with routes
-*/
-function provideFileRouter(...features) {
+//#region packages/router/src/lib/provide-file-router-base.ts
+function provideFileRouterWithRoutes(...features) {
 	const extraRoutesFeature = features.filter((feat) => feat.ɵkind >= 100);
 	const routerFeatures = features.filter((feat) => feat.ɵkind < 100);
 	return makeEnvironmentProviders([
 		extraRoutesFeature.map((erf) => erf.ɵproviders),
-		provideRouter(routes, ...routerFeatures),
+		provideRouter([], ...routerFeatures),
 		{
-			provide: ENVIRONMENT_INITIALIZER,
+			provide: ROUTES,
 			multi: true,
-			useValue: () => updateMetaTagsOnRouteChange()
+			useFactory: () => {
+				const extraSources = inject(ANALOG_EXTRA_ROUTE_FILE_SOURCES, { optional: true }) ?? [];
+				if (extraSources.length === 0) return createRoutes$1(ANALOG_ROUTE_FILES, (_filename, fileLoader) => fileLoader);
+				const allFiles = { ...ANALOG_ROUTE_FILES };
+				const resolverMap = /* @__PURE__ */ new Map();
+				for (const source of extraSources) for (const [key, loader] of Object.entries(source.files)) {
+					allFiles[key] = loader;
+					resolverMap.set(key, source.resolveModule);
+				}
+				return createRoutes$1(allFiles, (filename, fileLoader) => {
+					const resolver = resolverMap.get(filename);
+					return resolver ? resolver(filename, fileLoader) : fileLoader;
+				});
+			}
 		},
+		provideAppInitializer(() => {
+			const router = inject(Router);
+			const meta = inject(Meta);
+			const document = inject(DOCUMENT, { optional: true });
+			updateMetaTagsOnRouteChange(router, meta);
+			updateJsonLdOnRouteChange(router, document);
+		}),
 		{
 			provide: ɵHTTP_ROOT_INTERCEPTOR_FNS,
 			multi: true,
@@ -99,12 +114,6 @@ function provideFileRouter(...features) {
 		}
 	]);
 }
-/**
-* Provides extra custom routes in addition to the routes
-* discovered from the filesystem-based routing. These routes are
-* inserted before the filesystem-based routes, and take priority in
-* route matching.
-*/
 function withExtraRoutes(routes) {
 	return {
 		ɵkind: 100,
@@ -116,10 +125,32 @@ function withExtraRoutes(routes) {
 	};
 }
 //#endregion
+//#region packages/router/src/lib/provide-file-router.ts
+/**
+* Sets up providers for the Angular router, and registers
+* file-based routes. Additional features can be provided
+* to further configure the behavior of the router.
+*
+* @param features
+* @returns Providers and features to configure the router with routes
+*/
+function provideFileRouter(...features) {
+	return provideFileRouterWithRoutes(...features);
+}
+//#endregion
 //#region packages/router/src/lib/inject-load.ts
+function isResponse(value) {
+	return typeof value === "object" && value instanceof Response;
+}
 function injectLoad(options) {
 	return (options?.injector ?? inject(Injector)).get(ActivatedRoute).data.pipe(map((data) => data["load"]));
 }
+function injectLoadData(options) {
+	return injectLoad(options).pipe(map((result) => {
+		if (isResponse(result)) throw new Error("Expected page load data but received a response.");
+		return result;
+	}));
+}
 //#endregion
 //#region packages/router/src/lib/get-load-resolver.ts
 /**
@@ -161,6 +192,22 @@ function generateHash(str) {
 }
 //#endregion
 //#region packages/router/src/lib/request-context.ts
+function mergeFetchParams(requestUrl, request) {
+	const merged = /* @__PURE__ */ new Map();
+	for (const key of requestUrl.searchParams.keys()) {
+		const values = requestUrl.searchParams.getAll(key);
+		if (values.length > 0) merged.set(key, values);
+	}
+	for (const key of request.params.keys()) {
+		const values = request.params.getAll(key);
+		if (values?.length) merged.set(key, values);
+	}
+	if (merged.size === 0) return;
+	return [...merged.entries()].reduce((params, [key, values]) => {
+		params[key] = values.length === 1 ? values[0] : values;
+		return params;
+	}, {});
+}
 /**
 * Interceptor that is server-aware when making HttpClient requests.
 * Server-side requests use the full URL
@@ -181,17 +228,19 @@ function requestContextInterceptor(req, next) {
 		const requestUrl = new URL(req.url, baseUrl);
 		const storeKey = makeStateKey(`analog_${makeCacheKey(req, new URL(requestUrl).pathname)}`);
 		const fetchUrl = requestUrl.pathname;
+		const fetchParams = mergeFetchParams(requestUrl, req);
 		const responseType = req.responseType === "arraybuffer" ? "arrayBuffer" : req.responseType;
 		return from(serverFetch.raw(fetchUrl, {
 			method: req.method,
 			body: req.body ? req.body : void 0,
-			params: requestUrl.searchParams,
+			params: fetchParams,
 			responseType,
 			headers: req.headers.keys().reduce((hdrs, current) => {
-				return {
+				const value = req.headers.get(current);
+				return value != null ? {
 					...hdrs,
-					[current]: req.headers.get(current)
-				};
+					[current]: value
+				} : hdrs;
 			}, {})
 		}).then((res) => {
 			const cacheResponse = {
@@ -232,62 +281,83 @@ var FormAction = class FormAction {
 		this.state = output();
 		this.router = inject(Router);
 		this.route = inject(ActivatedRoute);
-		this.path = this._getPath();
+		this.currentState = signal("idle", ...[]);
+		/** Cached during construction (injection context) so inject() works. */
+		this._endpointUrl = this.route ? injectRouteEndpointURL(this.route.snapshot) : void 0;
 	}
 	submitted($event) {
 		$event.preventDefault();
-		this.state.emit("submitting");
-		const body = new FormData($event.target);
-		if ($event.target.method.toUpperCase() === "GET") this._handleGet(body, this.router.url);
-		else this._handlePost(body, this.path, $event);
+		const form = $event.target;
+		this._emitState("submitting");
+		const body = new FormData(form);
+		if (form.method.toUpperCase() === "GET") this._handleGet(body, this._getGetPath(form));
+		else this._handlePost(body, this._getPostPath(form), form.method);
 	}
 	_handleGet(body, path) {
-		const params = {};
-		body.forEach((formVal, formKey) => params[formKey] = formVal);
-		this.state.emit("navigate");
-		const url = path.split("?")[0];
-		this.router.navigate([url], {
-			queryParams: params,
-			onSameUrlNavigation: "reload"
+		const url = new URL(path, window.location.href);
+		const params = new URLSearchParams(url.search);
+		body.forEach((value, key) => {
+			params.append(key, value instanceof File ? value.name : value);
 		});
+		url.search = params.toString();
+		this._emitState("navigate");
+		this._navigateTo(url);
 	}
-	_handlePost(body, path, $event) {
+	_handlePost(body, path, method) {
 		fetch(path, {
-			method: $event.target.method,
+			method,
 			body
 		}).then((res) => {
 			if (res.ok) if (res.redirected) {
-				const redirectUrl = new URL(res.url).pathname;
-				this.state.emit("redirect");
-				this.router.navigate([redirectUrl]);
+				this._emitState("redirect");
+				this._navigateTo(new URL(res.url, window.location.href));
 			} else if (this._isJSON(res.headers.get("Content-type"))) res.json().then((result) => {
 				this.onSuccess.emit(result);
-				this.state.emit("success");
+				this._emitState("success");
 			});
 			else res.text().then((result) => {
 				this.onSuccess.emit(result);
-				this.state.emit("success");
+				this._emitState("success");
 			});
 			else if (res.headers.get("X-Analog-Errors")) res.json().then((errors) => {
 				this.onError.emit(errors);
-				this.state.emit("error");
+				this._emitState("error");
 			});
-			else this.state.emit("error");
+			else this._emitState("error");
 		}).catch((_) => {
-			this.state.emit("error");
+			this._emitState("error");
 		});
 	}
-	_getPath() {
-		if (this.route) return injectRouteEndpointURL(this.route.snapshot).pathname;
+	_getExplicitAction(form) {
+		return this.action().trim() || form.getAttribute("action")?.trim() || void 0;
+	}
+	_getGetPath(form) {
+		return this._getExplicitAction(form) ?? this.router.url;
+	}
+	_getPostPath(form) {
+		const explicitAction = this._getExplicitAction(form);
+		if (explicitAction) return new URL(explicitAction, window.location.href).toString();
+		if (this._endpointUrl) return this._endpointUrl.pathname;
 		return `/api/_analog/pages${window.location.pathname}`;
 	}
+	_emitState(state) {
+		this.currentState.set(state);
+		this.state.emit(state);
+	}
+	_navigateTo(url) {
+		if (url.origin === window.location.origin) {
+			this.router.navigateByUrl(`${url.pathname}${url.search}${url.hash}`, { onSameUrlNavigation: "reload" });
+			return;
+		}
+		window.location.assign(url.toString());
+	}
 	_isJSON(contentType) {
 		return (contentType ? contentType.split(";") : [])[0] === "application/json";
 	}
 	static {
 		this.ɵfac = i0.ɵɵngDeclareFactory({
 			minVersion: "12.0.0",
-			version: "21.1.1",
+			version: "21.2.8",
 			ngImport: i0,
 			type: FormAction,
 			deps: [],
@@ -297,7 +367,7 @@ var FormAction = class FormAction {
 	static {
 		this.ɵdir = i0.ɵɵngDeclareDirective({
 			minVersion: "17.1.0",
-			version: "21.1.1",
+			version: "21.2.8",
 			type: FormAction,
 			isStandalone: true,
 			selector: "form[action],form[method]",
@@ -313,21 +383,31 @@ var FormAction = class FormAction {
 				onError: "onError",
 				state: "state"
 			},
-			host: { listeners: { "submit": "submitted($event)" } },
+			host: {
+				listeners: { "submit": "submitted($event)" },
+				properties: {
+					"attr.data-state": "currentState()",
+					"attr.aria-busy": "currentState() === \"submitting\" ? \"true\" : null"
+				}
+			},
 			ngImport: i0
 		});
 	}
 };
 i0.ɵɵngDeclareClassMetadata({
 	minVersion: "12.0.0",
-	version: "21.1.1",
+	version: "21.2.8",
 	ngImport: i0,
 	type: FormAction,
 	decorators: [{
 		type: Directive,
 		args: [{
 			selector: "form[action],form[method]",
-			host: { "(submit)": `submitted($event)` },
+			host: {
+				"(submit)": `submitted($event)`,
+				"[attr.data-state]": "currentState()",
+				"[attr.aria-busy]": "currentState() === \"submitting\" ? \"true\" : null"
+			},
 			standalone: true
 		}]
 	}],
@@ -434,7 +514,7 @@ var ServerOnly = class ServerOnly {
 	static {
 		this.ɵfac = i0.ɵɵngDeclareFactory({
 			minVersion: "12.0.0",
-			version: "21.1.1",
+			version: "21.2.8",
 			ngImport: i0,
 			type: ServerOnly,
 			deps: [],
@@ -444,7 +524,7 @@ var ServerOnly = class ServerOnly {
 	static {
 		this.ɵcmp = i0.ɵɵngDeclareComponent({
 			minVersion: "17.1.0",
-			version: "21.1.1",
+			version: "21.2.8",
 			type: ServerOnly,
 			isStandalone: true,
 			selector: "server-only,ServerOnly,Server",
@@ -474,7 +554,7 @@ var ServerOnly = class ServerOnly {
 };
 i0.ɵɵngDeclareClassMetadata({
 	minVersion: "12.0.0",
-	version: "21.1.1",
+	version: "21.2.8",
 	ngImport: i0,
 	type: ServerOnly,
 	decorators: [{
@@ -510,6 +590,576 @@ i0.ɵɵngDeclareClassMetadata({
 	}
 });
 //#endregion
-export { FormAction, ServerOnly, createRoutes, defineRouteMeta, getLoadResolver, injectActivatedRoute, injectDebugRoutes, injectLoad, injectRouteEndpointURL, injectRouter, provideFileRouter, requestContextInterceptor, routes, withDebugRoutes, withExtraRoutes };
+//#region packages/router/src/lib/validation-errors.ts
+function getPathSegmentKey(segment) {
+	return typeof segment === "object" ? segment.key : segment;
+}
+function issuePathToFieldName(path) {
+	return path.map((segment) => String(getPathSegmentKey(segment))).join(".");
+}
+function issuesToFieldErrors(issues) {
+	return issues.reduce((errors, issue) => {
+		if (!issue.path?.length) return errors;
+		const fieldName = issuePathToFieldName(issue.path);
+		errors[fieldName] ??= [];
+		errors[fieldName].push(issue.message);
+		return errors;
+	}, {});
+}
+function issuesToFormErrors(issues) {
+	return issues.filter((issue) => !issue.path?.length).map((issue) => issue.message);
+}
+//#endregion
+//#region packages/router/src/lib/route-path.ts
+/**
+* Typed route path utilities for Analog.
+*
+* This module provides:
+* - The `AnalogRouteTable` base interface (augmented by generated code)
+* - The `AnalogRoutePath` union type
+* - The `routePath()` URL builder function
+*
+* No Angular dependencies — can be used in any context.
+*/
+/**
+* Builds a typed route link object from a route path pattern and options.
+*
+* The returned object separates path, query params, and fragment for
+* direct use with Angular's routerLink directive inputs.
+*
+* @example
+* routePath('/about')
+* // → { path: '/about', queryParams: null, fragment: undefined }
+*
+* routePath('/users/[id]', { params: { id: '42' } })
+* // → { path: '/users/42', queryParams: null, fragment: undefined }
+*
+* routePath('/users/[id]', { params: { id: '42' }, query: { tab: 'settings' }, hash: 'bio' })
+* // → { path: '/users/42', queryParams: { tab: 'settings' }, fragment: 'bio' }
+*
+* @example Template usage
+* ```html
+* @let link = routePath('/users/[id]', { params: { id: userId } });
+* <a [routerLink]="link.path" [queryParams]="link.queryParams" [fragment]="link.fragment">
+* ```
+*/
+function routePath(path, ...args) {
+	const options = args[0];
+	return buildRouteLink(path, options);
+}
+/**
+* Internal: builds a `RouteLinkResult` from path and options.
+* Exported for direct use in tests (avoids generic constraints).
+*/
+function buildRouteLink(path, options) {
+	const resolvedPath = buildPath(path, options?.params);
+	let queryParams = null;
+	if (options?.query) {
+		const filtered = {};
+		let hasEntries = false;
+		for (const [key, value] of Object.entries(options.query)) if (value !== void 0) {
+			filtered[key] = value;
+			hasEntries = true;
+		}
+		if (hasEntries) queryParams = filtered;
+	}
+	return {
+		path: resolvedPath,
+		queryParams,
+		fragment: options?.hash
+	};
+}
+/**
+* Resolves param placeholders and normalises slashes.
+* Returns only the path — no query string or hash.
+*/
+function buildPath(path, params) {
+	let url = path;
+	if (params) {
+		url = url.replace(/\[\[\.\.\.([^\]]+)\]\]/g, (_, name) => {
+			const value = params[name];
+			if (value == null) return "";
+			if (Array.isArray(value)) return value.map((v) => encodeURIComponent(v)).join("/");
+			return encodeURIComponent(String(value));
+		});
+		url = url.replace(/\[\.\.\.([^\]]+)\]/g, (_, name) => {
+			const value = params[name];
+			if (value == null) throw new Error(`Missing required catch-all param "${name}" for path "${path}"`);
+			if (Array.isArray(value)) {
+				if (value.length === 0) throw new Error(`Missing required catch-all param "${name}" for path "${path}"`);
+				return value.map((v) => encodeURIComponent(v)).join("/");
+			}
+			return encodeURIComponent(String(value));
+		});
+		url = url.replace(/\[([^\]]+)\]/g, (_, name) => {
+			const value = params[name];
+			if (value == null) throw new Error(`Missing required param "${name}" for path "${path}"`);
+			return encodeURIComponent(String(value));
+		});
+	} else {
+		url = url.replace(/\[\[\.\.\.([^\]]+)\]\]/g, "");
+		url = url.replace(/\[\.\.\.([^\]]+)\]/g, "");
+		url = url.replace(/\[([^\]]+)\]/g, "");
+	}
+	url = url.replace(/\/+/g, "/");
+	if (url.length > 1 && url.endsWith("/")) url = url.slice(0, -1);
+	if (!url.startsWith("/")) url = "/" + url;
+	return url;
+}
+/**
+* Internal URL builder. Separated from `routePath` so it can be
+* used without generic constraints (e.g., in `injectNavigate`).
+*/
+function buildUrl(path, options) {
+	let url = buildPath(path, options?.params);
+	if (options?.query) {
+		const parts = [];
+		for (const [key, value] of Object.entries(options.query)) {
+			if (value === void 0) continue;
+			if (Array.isArray(value)) for (const v of value) parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(v)}`);
+			else parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
+		}
+		if (parts.length > 0) url += "?" + parts.join("&");
+	}
+	if (options?.hash) url += "#" + options.hash;
+	return url;
+}
+//#endregion
+//#region packages/router/src/lib/inject-navigate.ts
+function isRoutePathOptionsBase(value) {
+	return !!value && typeof value === "object" && ("params" in value || "query" in value || "hash" in value);
+}
+/**
+* Injects a typed navigate function.
+*
+* @example
+* ```ts
+* const navigate = injectNavigate();
+*
+* navigate('/users/[id]', { params: { id: '42' } });   // ✅
+* navigate('/users/[id]', { params: { id: 42 } });     // ❌ type error
+*
+* // With navigation extras
+* navigate('/users/[id]', { params: { id: '42' } }, { replaceUrl: true });
+* ```
+*/
+function injectNavigate() {
+	const router = inject(Router);
+	const navigate = ((path, ...args) => {
+		let options;
+		let extras;
+		if (args.length > 1) {
+			options = args[0];
+			extras = args[1];
+		} else if (args.length === 1) if (isRoutePathOptionsBase(args[0])) options = args[0];
+		else extras = args[0];
+		const url = buildUrl(path, options);
+		return router.navigateByUrl(url, extras);
+	});
+	return navigate;
+}
+//#endregion
+//#region packages/router/src/lib/experimental.ts
+/** @experimental */
+var EXPERIMENTAL_TYPED_ROUTER = new InjectionToken("EXPERIMENTAL_TYPED_ROUTER");
+/** @experimental */
+var EXPERIMENTAL_ROUTE_CONTEXT = new InjectionToken("EXPERIMENTAL_ROUTE_CONTEXT");
+/** @experimental */
+var EXPERIMENTAL_LOADER_CACHE = new InjectionToken("EXPERIMENTAL_LOADER_CACHE");
+/**
+* Enables experimental typed router features.
+*
+* When active, `routePath()`, `injectNavigate()`, `injectParams()`,
+* and `injectQuery()` will enforce route table constraints and
+* optionally log warnings in strict mode.
+*
+* Inspired by TanStack Router's `Register` interface and strict type
+* checking across the entire navigation surface.
+*
+* @example
+* ```ts
+* provideFileRouter(
+*   withTypedRouter({ strictRouteParams: true }),
+* )
+* ```
+*
+* @experimental
+*/
+function withTypedRouter(options) {
+	return {
+		ɵkind: 102,
+		ɵproviders: [{
+			provide: EXPERIMENTAL_TYPED_ROUTER,
+			useValue: {
+				strictRouteParams: false,
+				...options
+			}
+		}]
+	};
+}
+/**
+* Provides root-level route context available to all route loaders
+* and components via `injectRouteContext()`.
+*
+* Inspired by TanStack Router's `createRootRouteWithContext<T>()` where
+* a typed context object is required at router creation and automatically
+* available in every route's `beforeLoad` and `loader`.
+*
+* In Angular terms, this creates a DI token that server-side load
+* functions and components can inject to access shared services
+* without importing them individually.
+*
+* @example
+* ```ts
+* // app.config.ts
+* provideFileRouter(
+*   withRouteContext({
+*     auth: inject(AuthService),
+*     db: inject(DatabaseService),
+*   }),
+* )
+*
+* // In a component
+* const ctx = injectRouteContext<{ auth: AuthService; db: DatabaseService }>();
+* ```
+*
+* @experimental
+*/
+function withRouteContext(context) {
+	return {
+		ɵkind: 103,
+		ɵproviders: [{
+			provide: EXPERIMENTAL_ROUTE_CONTEXT,
+			useValue: context
+		}]
+	};
+}
+/**
+* Configures experimental loader caching behavior for server-loaded
+* route data.
+*
+* Inspired by TanStack Router's built-in cache where `createRouter()`
+* accepts `defaultStaleTime` and `defaultGcTime` to control when
+* loaders re-execute and when cached data is discarded.
+*
+* @example
+* ```ts
+* provideFileRouter(
+*   withLoaderCaching({
+*     defaultStaleTime: 30_000,  // 30s before re-fetch
+*     defaultGcTime: 300_000,    // 5min cache retention
+*     defaultPendingMs: 200,     // 200ms loading delay
+*   }),
+* )
+* ```
+*
+* @experimental
+*/
+function withLoaderCaching(options) {
+	return {
+		ɵkind: 104,
+		ɵproviders: [{
+			provide: EXPERIMENTAL_LOADER_CACHE,
+			useValue: {
+				defaultStaleTime: 0,
+				defaultGcTime: 3e5,
+				defaultPendingMs: 0,
+				...options
+			}
+		}]
+	};
+}
+//#endregion
+//#region packages/router/src/lib/inject-typed-params.ts
+function extractRouteParams(routePath) {
+	const params = [];
+	for (const match of routePath.matchAll(/\[\[\.\.\.([^\]]+)\]\]/g)) params.push({
+		name: match[1],
+		type: "optionalCatchAll"
+	});
+	for (const match of routePath.matchAll(/(?<!\[)\[\.\.\.([^\]]+)\](?!\])/g)) params.push({
+		name: match[1],
+		type: "catchAll"
+	});
+	for (const match of routePath.matchAll(/(?<!\[)\[(?!\.)([^\]]+)\](?!\])/g)) params.push({
+		name: match[1],
+		type: "dynamic"
+	});
+	return params;
+}
+/**
+* When `strictRouteParams` is enabled, warns if expected params from the
+* `_from` pattern are missing from the active `ActivatedRoute`.
+*/
+function assertRouteMatch(from, route, kind) {
+	const expectedParams = extractRouteParams(from).filter((param) => param.type === "dynamic" || param.type === "catchAll").map((param) => param.name);
+	if (expectedParams.length === 0) return;
+	route.params.pipe(take(1)).subscribe((params) => {
+		for (const name of expectedParams) if (!(name in params)) {
+			console.warn(`[Analog] ${kind}('${from}'): expected param "${name}" is not present in the active route's params. Ensure this hook is used inside a component rendered by '${from}'.`);
+			break;
+		}
+	});
+}
+/**
+* Injects typed route params as a signal, constrained by the route table.
+*
+* Inspired by TanStack Router's `useParams({ from: '/users/$userId' })`
+* pattern where the `from` parameter narrows the return type to only
+* the params defined for that route.
+*
+* The `from` parameter is used purely for TypeScript type inference —
+* at runtime, params are read from the current `ActivatedRoute`. This
+* means it works correctly when used inside a component rendered by
+* the specified route.
+*
+* When `withTypedRouter({ strictRouteParams: true })` is configured,
+* a dev-mode assertion checks that the expected params from `from`
+* exist in the active route and warns on mismatch.
+*
+* @example
+* ```ts
+* // In a component rendered at /users/[id]
+* const params = injectParams('/users/[id]');
+* // params() → { id: string }
+*
+* // With schema validation output types
+* const params = injectParams('/products/[slug]');
+* // params() → validated output type from routeParamsSchema
+* ```
+*
+* @experimental
+*/
+function injectParams(_from, options) {
+	const injector = options?.injector;
+	const route = injector ? injector.get(ActivatedRoute) : inject(ActivatedRoute);
+	if (isDevMode()) {
+		if ((injector ? injector.get(EXPERIMENTAL_TYPED_ROUTER, null) : inject(EXPERIMENTAL_TYPED_ROUTER, { optional: true }))?.strictRouteParams) assertRouteMatch(_from, route, "injectParams");
+	}
+	return toSignal(route.params.pipe(map((params) => params)), { requireSync: true });
+}
+/**
+* Injects typed route query params as a signal, constrained by the
+* route table.
+*
+* Inspired by TanStack Router's `useSearch({ from: '/issues' })` pattern
+* where search params are validated and typed per-route via
+* `validateSearch` schemas.
+*
+* In Analog, the typing comes from `routeQuerySchema` exports that are
+* detected at build time and recorded in the generated route table.
+*
+* The `from` parameter is used purely for TypeScript type inference.
+* When `withTypedRouter({ strictRouteParams: true })` is configured,
+* a dev-mode assertion checks that the expected params from `from`
+* exist in the active route and warns on mismatch.
+*
+* @example
+* ```ts
+* // In a component rendered at /issues
+* // (where routeQuerySchema validates { page: number, status: string })
+* const query = injectQuery('/issues');
+* // query() → { page: number; status: string }
+* ```
+*
+* @experimental
+*/
+function injectQuery(_from, options) {
+	const injector = options?.injector;
+	const route = injector ? injector.get(ActivatedRoute) : inject(ActivatedRoute);
+	if (isDevMode()) {
+		if ((injector ? injector.get(EXPERIMENTAL_TYPED_ROUTER, null) : inject(EXPERIMENTAL_TYPED_ROUTER, { optional: true }))?.strictRouteParams) assertRouteMatch(_from, route, "injectQuery");
+	}
+	return toSignal(route.queryParams.pipe(map((params) => params)), { requireSync: true });
+}
+//#endregion
+//#region packages/router/src/lib/inject-route-context.ts
+/**
+* Injects the root route context provided via `withRouteContext()`.
+*
+* Inspired by TanStack Router's context inheritance where
+* `createRootRouteWithContext<T>()` makes a typed context available
+* to every route's `beforeLoad` and `loader` callbacks.
+*
+* In Angular, this uses DI under the hood — `withRouteContext(ctx)`
+* provides the value, and `injectRouteContext<T>()` retrieves it
+* with the expected type.
+*
+* @example
+* ```ts
+* // app.config.ts
+* provideFileRouter(
+*   withRouteContext({
+*     auth: inject(AuthService),
+*     analytics: inject(AnalyticsService),
+*   }),
+* )
+*
+* // any-page.page.ts
+* const ctx = injectRouteContext<{
+*   auth: AuthService;
+*   analytics: AnalyticsService;
+* }>();
+* ctx.analytics.trackPageView();
+* ```
+*
+* @experimental
+*/
+function injectRouteContext() {
+	return inject(EXPERIMENTAL_ROUTE_CONTEXT);
+}
+//#endregion
+//#region packages/router/src/lib/i18n/provide-i18n.ts
+/**
+* Injection token for the resolved i18n configuration.
+* Provided by `provideI18n()` and consumed by `injectSwitchLocale()`.
+* @internal
+*/
+var I18N_CONFIG = new InjectionToken("@analogjs/router I18n Config");
+/**
+* Resolves the full i18n config by merging explicit values with
+* build-time globals injected by the platform plugin.
+*/
+function resolveI18nConfig(config) {
+	const defaultLocale = config.defaultLocale ?? (typeof ANALOG_I18N_DEFAULT_LOCALE !== "undefined" ? ANALOG_I18N_DEFAULT_LOCALE : void 0);
+	const locales = config.locales ?? (typeof ANALOG_I18N_LOCALES !== "undefined" ? ANALOG_I18N_LOCALES : void 0);
+	if (!defaultLocale || !locales) throw new Error("[@analogjs/router] provideI18n() requires defaultLocale and locales. Either pass them explicitly or configure i18n in the analog() plugin in vite.config.ts.");
+	return {
+		defaultLocale,
+		locales,
+		loader: config.loader
+	};
+}
+/**
+* Provides runtime i18n support using Angular's $localize.
+*
+* This provider:
+* 1. Detects the active locale from the URL or falls back to the default.
+* 2. Makes the current locale available via the LOCALE injection token.
+* 3. Loads translations for the active locale at startup using $localize.
+*
+* Works in both SSR and client-only modes. On the client, locale is detected
+* from `window.location.pathname`. On the server, locale is detected from
+* the request in `provideServerContext()` and provided at the platform level;
+* this function does not shadow it.
+*
+* When the platform plugin is configured with `i18n` in `vite.config.ts`,
+* `defaultLocale` and `locales` are injected automatically — only
+* `loader` is required:
+*
+* ```typescript
+* provideI18n({
+*   loader: (locale) => import(`./i18n/${locale}.json`),
+* })
+* ```
+*/
+function provideI18n(config) {
+	const resolved = resolveI18nConfig(config);
+	const localeProviders = typeof window !== "undefined" ? [{
+		provide: LOCALE,
+		useValue: detectClientLocale(resolved)
+	}] : [];
+	return makeEnvironmentProviders([
+		{
+			provide: I18N_CONFIG,
+			useValue: resolved
+		},
+		...localeProviders,
+		provideAppInitializer(async () => {
+			await initI18n(resolved, resolveActiveLocale(resolved));
+		})
+	]);
+}
+/**
+* Resolves the active locale, preferring the injected `LOCALE` token
+* (which on the server reads from the platform-level provider set by
+* `provideServerContext()`) and falling back to the request URL,
+* `window.location.pathname`, or `defaultLocale`.
+*/
+function resolveActiveLocale(config) {
+	const injected = inject(LOCALE, { optional: true });
+	if (injected && config.locales.includes(injected)) return injected;
+	const req = inject(REQUEST, { optional: true });
+	const first = (req?.originalUrl ?? req?.url ?? (typeof window !== "undefined" ? window.location.pathname : "/")).split("?")[0].split("/").filter(Boolean)[0];
+	if (first && config.locales.includes(first)) return first;
+	return config.defaultLocale;
+}
+function detectClientLocale(config) {
+	if (typeof window === "undefined") return config.defaultLocale;
+	const firstSegment = window.location.pathname.split("/").filter(Boolean)[0];
+	if (firstSegment && config.locales.includes(firstSegment)) return firstSegment;
+	return config.defaultLocale;
+}
+/**
+* Loads translations for the given locale and registers them with $localize.
+*
+* Always clears any previously loaded translations first so that switching
+* between locales in a single SSR process does not mix translation maps.
+*/
+async function initI18n(config, locale) {
+	const activeLocale = locale ?? config.defaultLocale;
+	await clearTranslationsRuntime();
+	if (activeLocale === config.locales[0]) return;
+	const translations = await config.loader(activeLocale);
+	if (translations && Object.keys(translations).length > 0) await loadTranslationsRuntime(translations);
+}
+/**
+* Loads translations into the global $localize translation map.
+*
+* Uses `@angular/localize`'s `loadTranslations` when available so that
+* each translation string is parsed into the `{text, messageParts,
+* placeholderNames}` shape that `$localize.translate` expects. Falls back
+* to writing raw strings only as a last resort (in which case lookups
+* will not succeed — the fallback exists to keep error messages useful
+* for users who have not installed `@angular/localize`).
+*
+* Requires `@angular/localize/init` to be imported in the application
+* entry point so that `globalThis.$localize` is defined.
+*/
+async function loadTranslationsRuntime(translations) {
+	const $localize = globalThis.$localize;
+	if (!$localize) {
+		console.warn("[@analogjs/router] $localize is not available. Make sure to import @angular/localize/init in your application entry point.");
+		return;
+	}
+	try {
+		const { loadTranslations } = await import("@angular/localize");
+		loadTranslations(translations);
+	} catch {
+		console.warn("[@analogjs/router] Unable to import @angular/localize. Install it as a dependency to enable runtime translation loading.");
+		$localize.TRANSLATIONS ??= {};
+		for (const [id, message] of Object.entries(translations)) $localize.TRANSLATIONS[id] = message;
+	}
+}
+/** @internal — exported for tests; not re-exported from the package entry. */
+async function clearTranslationsRuntime() {
+	const $localize = globalThis.$localize;
+	if (!$localize) return;
+	try {
+		const { clearTranslations } = await import("@angular/localize");
+		clearTranslations();
+	} catch {
+		$localize.translate = void 0;
+		$localize.TRANSLATIONS = {};
+	}
+}
+function injectSwitchLocale() {
+	assertInInjectionContext(injectSwitchLocale);
+	const config = inject(I18N_CONFIG);
+	return (targetLocale) => {
+		if (typeof window === "undefined") return;
+		const { pathname, search, hash } = window.location;
+		const newPath = replaceLocaleInPath(pathname, targetLocale, config.locales);
+		window.location.href = `${newPath}${search}${hash}`;
+	};
+}
+function replaceLocaleInPath(pathname, targetLocale, locales) {
+	const segments = pathname.split("/").filter(Boolean);
+	if (segments.length > 0 && locales.includes(segments[0])) segments[0] = targetLocale;
+	else segments.unshift(targetLocale);
+	return "/" + segments.join("/");
+}
+//#endregion
+export { EXPERIMENTAL_LOADER_CACHE, EXPERIMENTAL_ROUTE_CONTEXT, EXPERIMENTAL_TYPED_ROUTER, FormAction, ServerOnly, createRoutes, defineRouteMeta, getLoadResolver, injectActivatedRoute, injectDebugRoutes, injectLoad, injectLoadData, injectNavigate, injectParams, injectQuery, injectRouteContext, injectRouteEndpointURL, injectRouter, injectSwitchLocale, issuePathToFieldName, issuesToFieldErrors, issuesToFormErrors, loadTranslationsRuntime, provideFileRouter, provideI18n, requestContextInterceptor, routePath, routes, withDebugRoutes, withExtraRoutes, withLoaderCaching, withRouteContext, withTypedRouter };
 
 //# sourceMappingURL=analogjs-router.mjs.map