@analogjs/router 3.0.0-alpha.7 → 3.0.0-alpha.70

package/fesm2022/analogjs-router.mjs

@@ -1,12 +1,14 @@
-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 { 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 { DOCUMENT, Directive, Injectable, InjectionToken, Injector, PLATFORM_ID, TransferState, assertInInjectionContext, inject, input, isDevMode, makeEnvironmentProviders, makeStateKey, output, provideAppInitializer, resource, signal } from "@angular/core";
+import { HttpClient, HttpHeaders, HttpResponse, ɵHTTP_ROOT_INTERCEPTOR_FNS } from "@angular/common/http";
+import { firstValueFrom, from, map, of, take } from "rxjs";
+import { Meta } from "@angular/platform-browser";
 import { isPlatformServer } from "@angular/common";
+import { toSignal } from "@angular/core/rxjs-interop";
 //#region packages/router/src/lib/define-route.ts
 /**
 * @deprecated Use `RouteMeta` type instead.
@@ -66,26 +68,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 +113,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 +124,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 +191,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
@@ -178,20 +224,22 @@ function requestContextInterceptor(req, next) {
 	const nitroGlobal = globalThis;
 	const serverFetch = injectInternalServerFetch() ?? nitroGlobal.$fetch;
 	if (serverFetch && baseUrl && (req.url.startsWith("/") || req.url.startsWith(baseUrl) || req.url.startsWith(`/${apiPrefix}`))) {
-		const requestUrl = new URL(req.url, baseUrl);
-		const storeKey = makeStateKey(`analog_${makeCacheKey(req, new URL(requestUrl).pathname)}`);
+		const requestUrl = new URL(req.urlWithParams, baseUrl);
+		const storeKey = makeStateKey(`analog_${makeCacheKey(req, `${requestUrl.pathname}${requestUrl.search}`)}`);
 		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 = {
@@ -207,8 +255,10 @@ function requestContextInterceptor(req, next) {
 		}));
 	}
 	if (req.url.startsWith("/") || req.url.includes("/_analog/")) {
-		const requestUrl = req.url.includes("/_analog/") ? req.url : `${window.location.origin}${req.url}`;
-		const storeKey = makeStateKey(`analog_${makeCacheKey(req, new URL(requestUrl).pathname)}`);
+		const toAbsoluteUrl = (url) => new URL(url, window.location.origin);
+		const requestUrl = toAbsoluteUrl(req.url).href;
+		const { pathname, search } = toAbsoluteUrl(req.urlWithParams);
+		const storeKey = makeStateKey(`analog_${makeCacheKey(req, `${pathname}${search}`)}`);
 		const cacheRestoreResponse = transferState.get(storeKey, null);
 		if (cacheRestoreResponse) {
 			transferState.remove(storeKey);
@@ -232,62 +282,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: "22.0.0",
 			ngImport: i0,
 			type: FormAction,
 			deps: [],
@@ -297,7 +368,7 @@ var FormAction = class FormAction {
 	static {
 		this.ɵdir = i0.ɵɵngDeclareDirective({
 			minVersion: "17.1.0",
-			version: "21.1.1",
+			version: "22.0.0",
 			type: FormAction,
 			isStandalone: true,
 			selector: "form[action],form[method]",
@@ -313,21 +384,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: "22.0.0",
 	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
 		}]
 	}],
@@ -375,141 +456,560 @@ function withDebugRoutes() {
 	};
 }
 //#endregion
-//#region packages/router/src/lib/server.component.ts
+//#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/server-fn/dispatcher.ts
+var SERVER_FN_DISPATCHER = new InjectionToken("@analogjs/router Server Function Dispatcher");
+//#endregion
+//#region packages/router/src/lib/server-fn/inject-server-fn.ts
 /**
-* @description
-* Component that defines the bridge between the client and server-only
-* components. The component passes the component ID and props to the server
-* and retrieves the rendered HTML and outputs from the server-only component.
-*
-* Status: experimental
+* Client transport for server functions. In the browser it goes through Angular
+* `HttpClient`, so client `HttpInterceptorFn`s apply. During SSR the dispatcher
+* token is provided, and the call short-circuits the HTTP round-trip: the
+* handler runs in-process in the current request injector. Lives in the client
+* entry (client-safe).
 */
-var ServerOnly = class ServerOnly {
+var ServerFnClient = class ServerFnClient {
 	constructor() {
-		this.component = input.required(...[]);
-		this.props = input(...[]);
-		this.outputs = output();
 		this.http = inject(HttpClient);
-		this.sanitizer = inject(DomSanitizer);
-		this.content = signal("", ...[]);
-		this.route = inject(ActivatedRoute, { optional: true });
-		this.baseURL = injectBaseURL();
 		this.transferState = inject(TransferState);
-		effect(() => {
-			const routeComponentId = this.route?.snapshot.data["component"];
-			const props = this.props() || {};
-			const componentId = routeComponentId || this.component();
-			const headers = new HttpHeaders(new Headers({
-				"Content-type": "application/json",
-				"X-Analog-Component": componentId
-			}));
-			const componentUrl = this.getComponentUrl(componentId);
-			const httpRequest = new HttpRequest("POST", componentUrl, props, { headers });
-			const storeKey = makeStateKey(makeCacheKey(httpRequest, new URL(componentUrl).pathname));
-			const componentState = this.transferState.get(storeKey, null);
-			if (componentState) {
-				this.updateContent(componentState);
-				this.transferState.remove(storeKey);
-			} else this.http.request(httpRequest).pipe(map((response) => {
-				if (response instanceof HttpResponse) return response.body;
-				return throwError(() => ({}));
-			}), catchError((error) => {
-				console.log(error);
-				return of({
-					html: "",
-					outputs: {}
-				});
-			})).subscribe((content) => this.updateContent(content));
-		});
+		this.injector = inject(Injector);
+		this.dispatcher = inject(SERVER_FN_DISPATCHER, { optional: true });
+	}
+	/** True while rendering on the server (the in-process dispatcher is provided). */
+	get isServer() {
+		return !!this.dispatcher;
 	}
-	updateContent(content) {
-		this.content.set(this.sanitizer.bypassSecurityTrustHtml(content.html));
-		this.outputs.emit(content.outputs);
+	async call(fn, input) {
+		if (this.dispatcher) return this.dispatcher(fn, input, this.injector);
+		return firstValueFrom(fn.method === "GET" ? this.http.get(fn.url) : this.http.post(fn.url, input ?? {}));
 	}
-	getComponentUrl(componentId) {
-		let baseURL = this.baseURL;
-		if (!baseURL && typeof window !== "undefined") baseURL = window.location.origin;
-		return `${baseURL}/_analog/components/${componentId}`;
+	/** Key a read's value for TransferState hydration (fn id + input). */
+	stateKey(fn, input) {
+		return makeStateKey(`__analog_fn_${fn.id}_${stableInput(input)}`);
+	}
+	readSeed(fn, input) {
+		const key = this.stateKey(fn, input);
+		if (this.transferState.hasKey(key)) {
+			const value = this.transferState.get(key, void 0);
+			this.transferState.remove(key);
+			return value;
+		}
+	}
+	writeSeed(fn, input, value) {
+		this.transferState.set(this.stateKey(fn, input), value);
 	}
 	static {
 		this.ɵfac = i0.ɵɵngDeclareFactory({
 			minVersion: "12.0.0",
-			version: "21.1.1",
+			version: "22.0.0",
 			ngImport: i0,
-			type: ServerOnly,
+			type: ServerFnClient,
 			deps: [],
-			target: i0.ɵɵFactoryTarget.Component
+			target: i0.ɵɵFactoryTarget.Injectable
 		});
 	}
 	static {
-		this.ɵcmp = i0.ɵɵngDeclareComponent({
-			minVersion: "17.1.0",
-			version: "21.1.1",
-			type: ServerOnly,
-			isStandalone: true,
-			selector: "server-only,ServerOnly,Server",
-			inputs: {
-				component: {
-					classPropertyName: "component",
-					publicName: "component",
-					isSignal: true,
-					isRequired: true,
-					transformFunction: null
-				},
-				props: {
-					classPropertyName: "props",
-					publicName: "props",
-					isSignal: true,
-					isRequired: false,
-					transformFunction: null
-				}
-			},
-			outputs: { outputs: "outputs" },
+		this.ɵprov = i0.ɵɵngDeclareInjectable({
+			minVersion: "12.0.0",
+			version: "22.0.0",
 			ngImport: i0,
-			template: ` <div [innerHTML]="content()"></div> `,
-			isInline: true,
-			changeDetection: i0.ChangeDetectionStrategy.OnPush
+			type: ServerFnClient,
+			providedIn: "root"
 		});
 	}
 };
 i0.ɵɵngDeclareClassMetadata({
 	minVersion: "12.0.0",
-	version: "21.1.1",
+	version: "22.0.0",
 	ngImport: i0,
-	type: ServerOnly,
+	type: ServerFnClient,
 	decorators: [{
-		type: Component,
-		args: [{
-			selector: "server-only,ServerOnly,Server",
-			changeDetection: ChangeDetectionStrategy.OnPush,
-			template: ` <div [innerHTML]="content()"></div> `
+		type: Injectable,
+		args: [{ providedIn: "root" }]
+	}]
+});
+/** No-op provider hook; ServerFnClient is `providedIn: 'root'`. */
+function provideServerFnClient() {
+	return [];
+}
+var NO_INPUT = Symbol("analog.serverFn.noInput");
+function injectServerFn(fn, args) {
+	assertInInjectionContext(injectServerFn);
+	const client = inject(ServerFnClient);
+	return resource({
+		params: () => args ? args() : NO_INPUT,
+		loader: async ({ params }) => {
+			const input = params === NO_INPUT ? void 0 : params;
+			const seeded = client.readSeed(fn, input);
+			if (seeded !== void 0) return seeded;
+			const value = await client.call(fn, input);
+			if (client.isServer) client.writeSeed(fn, input, value);
+			return value;
+		}
+	});
+}
+/**
+* Imperative binding of a server function: returns a callable that dispatches
+* the call through `HttpClient` (so client interceptors apply) and resolves the
+* result. Use for mutations and event-driven calls; use `injectServerFn` for
+* reactive reads.
+*/
+function injectServerFnMutation(fn) {
+	assertInInjectionContext(injectServerFnMutation);
+	const client = inject(ServerFnClient);
+	return (input) => client.call(fn, input);
+}
+function stableInput(input) {
+	if (input === void 0 || input === null) return "_";
+	return JSON.stringify(input);
+}
+//#endregion
+//#region packages/router/src/lib/server-fn/server-fn-ref.ts
+/**
+* Builds a server-function reference: the client-safe `{ __serverFn, id, url,
+* method }` metadata that `injectServerFn`/`ServerFnClient` dispatch through.
+*
+* Shared by both sides so they produce identical refs: the server `serverFn`
+* wraps this with registration + the handler, and the client build's scrub
+* transform emits a call to this factory in place of the server module so the
+* browser bundle carries only the ref, never the handler or its server imports.
+*
+* The returned value is callable-typed but throws if invoked directly — it is
+* always dispatched via `injectServerFn`/`ServerFnClient`, never called.
+*/
+function createServerFnRef(config) {
+	if (!config.id) throw new Error("[analog] serverFn is missing its build-derived id. Server functions require the Analog build transform (@analogjs/platform / @analogjs/vite-plugin-nitro); a raw import without it is not supported.");
+	const method = config.method ?? (config.input ? "POST" : "GET");
+	const url = `/_analog/fn/${config.id}`;
+	const ref = (() => {
+		throw new Error(`serverFn "${config.id}" must be called via injectServerFn/ServerFnClient`);
+	});
+	return Object.assign(ref, {
+		__serverFn: true,
+		id: config.id,
+		url,
+		method
+	});
+}
+//#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
+			}
 		}]
-	}],
-	ctorParameters: () => [],
-	propDecorators: {
-		component: [{
-			type: i0.Input,
-			args: [{
-				isSignal: true,
-				alias: "component",
-				required: true
-			}]
-		}],
-		props: [{
-			type: i0.Input,
-			args: [{
-				isSignal: true,
-				alias: "props",
-				required: false
-			}]
-		}],
-		outputs: [{
-			type: i0.Output,
-			args: ["outputs"]
+	};
+}
+/**
+* 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
-export { FormAction, ServerOnly, createRoutes, defineRouteMeta, getLoadResolver, injectActivatedRoute, injectDebugRoutes, injectLoad, injectRouteEndpointURL, injectRouter, provideFileRouter, requestContextInterceptor, routes, withDebugRoutes, withExtraRoutes };
+export { EXPERIMENTAL_LOADER_CACHE, EXPERIMENTAL_ROUTE_CONTEXT, EXPERIMENTAL_TYPED_ROUTER, FormAction, SERVER_FN_DISPATCHER, ServerFnClient, createRoutes, createServerFnRef, defineRouteMeta, getLoadResolver, injectActivatedRoute, injectDebugRoutes, injectLoad, injectLoadData, injectNavigate, injectParams, injectQuery, injectRouteContext, injectRouteEndpointURL, injectRouter, injectServerFn, injectServerFnMutation, issuePathToFieldName, issuesToFieldErrors, issuesToFormErrors, provideFileRouter, provideServerFnClient, requestContextInterceptor, routePath, routes, withDebugRoutes, withExtraRoutes, withLoaderCaching, withRouteContext, withTypedRouter };
 
 //# sourceMappingURL=analogjs-router.mjs.map