@analogjs/router 3.0.0-alpha.6 → 3.0.0-alpha.60

package/fesm2022/routes.mjs

@@ -1,301 +1,28 @@
-import { NavigationEnd, Router, UrlSegment } from "@angular/router";
+import { n as ANALOG_ROUTE_FILES, r as createRoutes$1 } from "./route-files.mjs";
 import { InjectionToken, inject } from "@angular/core";
-import { HttpClient } from "@angular/common/http";
-import { firstValueFrom } from "rxjs";
-import { injectAPIPrefix, injectBaseURL, injectInternalServerFetch } from "@analogjs/router/tokens";
-import { Meta } from "@angular/platform-browser";
-import { filter } from "rxjs/operators";
-//#region packages/router/src/lib/meta-tags.ts
-var ROUTE_META_TAGS_KEY = Symbol("@analogjs/router Route Meta Tags Key");
-var CHARSET_KEY = "charset";
-var HTTP_EQUIV_SELECTOR_KEY = "http-equiv";
-var NAME_KEY = "name";
-var PROPERTY_KEY = "property";
-var ITEMPROP_KEY = "itemprop";
-function updateMetaTagsOnRouteChange() {
-	const router = inject(Router);
-	const metaService = inject(Meta);
-	router.events.pipe(filter((event) => event instanceof NavigationEnd)).subscribe(() => {
-		const metaTagMap = getMetaTagMap(router.routerState.snapshot.root);
-		for (const metaTagSelector in metaTagMap) {
-			const metaTag = metaTagMap[metaTagSelector];
-			metaService.updateTag(metaTag, metaTagSelector);
-		}
-	});
-}
-function getMetaTagMap(route) {
-	const metaTagMap = {};
-	let currentRoute = route;
-	while (currentRoute) {
-		const metaTags = currentRoute.data[ROUTE_META_TAGS_KEY] ?? [];
-		for (const metaTag of metaTags) metaTagMap[getMetaTagSelector(metaTag)] = metaTag;
-		currentRoute = currentRoute.firstChild;
-	}
-	return metaTagMap;
-}
-function getMetaTagSelector(metaTag) {
-	if (metaTag.name) return `${NAME_KEY}="${metaTag.name}"`;
-	if (metaTag.property) return `${PROPERTY_KEY}="${metaTag.property}"`;
-	if (metaTag.httpEquiv) return `${HTTP_EQUIV_SELECTOR_KEY}="${metaTag.httpEquiv}"`;
-	if (metaTag.itemprop) return `${ITEMPROP_KEY}="${metaTag.itemprop}"`;
-	return CHARSET_KEY;
-}
-//#endregion
-//#region packages/router/src/lib/endpoints.ts
-var ANALOG_META_KEY = Symbol("@analogjs/router Analog Route Metadata Key");
-/**
-* This variable reference is replaced with a glob of all route endpoints.
-*/
-var ANALOG_PAGE_ENDPOINTS = {};
-//#endregion
-//#region packages/router/src/lib/inject-route-endpoint-url.ts
-function injectRouteEndpointURL(route) {
-	const routeConfig = route.routeConfig;
-	const apiPrefix = injectAPIPrefix();
-	const baseUrl = injectBaseURL();
-	const { queryParams, fragment: hash, params, parent } = route;
-	const segment = parent?.url.map((segment) => segment.path).join("/") || "";
-	const url = new URL("", {
-		"BASE_URL": "/",
-		"DEV": false,
-		"MODE": "production",
-		"PROD": true,
-		"SSR": false
-	}["VITE_ANALOG_PUBLIC_BASE_URL"] || baseUrl || (typeof window !== "undefined" && window.location.origin ? window.location.origin : ""));
-	url.pathname = `${url.pathname.endsWith("/") ? url.pathname : url.pathname + "/"}${apiPrefix}/_analog${routeConfig[ANALOG_META_KEY].endpoint}`;
-	url.search = `${new URLSearchParams(queryParams).toString()}`;
-	url.hash = hash ?? "";
-	Object.keys(params).forEach((param) => {
-		url.pathname = url.pathname.replace(`[${param}]`, params[param]);
-	});
-	url.pathname = url.pathname.replace("**", segment);
-	return url;
-}
-//#endregion
-//#region packages/router/src/lib/route-config.ts
-function toRouteConfig(routeMeta) {
-	if (routeMeta && isRedirectRouteMeta(routeMeta)) return routeMeta;
-	const { meta, ...routeConfig } = routeMeta ?? {};
-	if (Array.isArray(meta)) routeConfig.data = {
-		...routeConfig.data,
-		[ROUTE_META_TAGS_KEY]: meta
-	};
-	else if (typeof meta === "function") routeConfig.resolve = {
-		...routeConfig.resolve,
-		[ROUTE_META_TAGS_KEY]: meta
-	};
-	routeConfig.runGuardsAndResolvers = routeConfig.runGuardsAndResolvers ?? "paramsOrQueryParamsChange";
-	routeConfig.resolve = {
-		...routeConfig.resolve,
-		load: async (route) => {
-			if (ANALOG_PAGE_ENDPOINTS[route.routeConfig[ANALOG_META_KEY].endpointKey]) {
-				const http = inject(HttpClient);
-				const url = injectRouteEndpointURL(route);
-				const internalFetch = injectInternalServerFetch();
-				if (internalFetch) return internalFetch(url.pathname);
-				if (!!{
-					"BASE_URL": "/",
-					"DEV": false,
-					"MODE": "production",
-					"PROD": true,
-					"SSR": false
-				}["VITE_ANALOG_PUBLIC_BASE_URL"] && globalThis.$fetch) return globalThis.$fetch(url.pathname);
-				return firstValueFrom(http.get(`${url.href}`));
-			}
-			return {};
-		}
-	};
-	return routeConfig;
-}
-function isRedirectRouteMeta(routeMeta) {
-	return !!routeMeta.redirectTo;
-}
-//#endregion
-//#region packages/router/src/lib/markdown-helpers.ts
-var isNgZoneEnabled = typeof Zone !== "undefined" && !!Zone.root;
-function toMarkdownModule(markdownFileFactory) {
-	return async () => {
-		const createLoader = () => Promise.all([import("@analogjs/content"), markdownFileFactory()]);
-		const [{ parseRawContentFile, MarkdownRouteComponent, ContentRenderer }, markdownFile] = await (isNgZoneEnabled ? Zone.root.run(createLoader) : createLoader());
-		const { content, attributes } = parseRawContentFile(markdownFile);
-		const { title, meta } = attributes;
-		return {
-			default: MarkdownRouteComponent,
-			routeMeta: {
-				data: { _analogContent: content },
-				title,
-				meta,
-				resolve: { renderedAnalogContent: async () => {
-					const rendered = await inject(ContentRenderer).render(content);
-					return typeof rendered === "string" ? rendered : rendered.content;
-				} }
-			}
-		};
-	};
-}
-//#endregion
-//#region packages/router/src/lib/constants.ts
-var ENDPOINT_EXTENSION = ".server.ts";
-//#endregion
 //#region packages/router/src/lib/routes.ts
 /**
-* This variable reference is replaced with a glob of all page routes.
-*/
-var ANALOG_ROUTE_FILES = {};
-/**
-* This variable reference is replaced with a glob of all content routes.
-*/
-var ANALOG_CONTENT_ROUTE_FILES = {};
-/**
 * A function used to parse list of files and create configuration of routes.
 *
 * @param files
 * @returns Array of routes
 */
 function createRoutes(files, debug = false) {
-	const filenames = Object.keys(files);
-	if (filenames.length === 0) return [];
-	const rawRoutesByLevelMap = filenames.reduce((acc, filename) => {
-		const rawPath = toRawPath(filename);
-		const rawSegments = rawPath.split("/");
-		const level = rawSegments.length - 1;
-		const rawSegment = rawSegments[level];
-		const ancestorRawSegments = rawSegments.slice(0, level);
-		return {
-			...acc,
-			[level]: {
-				...acc[level],
-				[rawPath]: {
-					filename,
-					rawSegment,
-					ancestorRawSegments,
-					segment: toSegment(rawSegment),
-					level,
-					children: []
-				}
-			}
-		};
-	}, {});
-	const allLevels = Object.keys(rawRoutesByLevelMap).map(Number);
-	const maxLevel = Math.max(...allLevels);
-	for (let level = maxLevel; level > 0; level--) {
-		const rawRoutesMap = rawRoutesByLevelMap[level];
-		const rawPaths = Object.keys(rawRoutesMap);
-		for (const rawPath of rawPaths) {
-			const rawRoute = rawRoutesMap[rawPath];
-			const parentRawPath = rawRoute.ancestorRawSegments.join("/");
-			const parentRawSegmentIndex = rawRoute.ancestorRawSegments.length - 1;
-			const parentRawSegment = rawRoute.ancestorRawSegments[parentRawSegmentIndex];
-			rawRoutesByLevelMap[level - 1] ||= {};
-			rawRoutesByLevelMap[level - 1][parentRawPath] ||= {
-				filename: null,
-				rawSegment: parentRawSegment,
-				ancestorRawSegments: rawRoute.ancestorRawSegments.slice(0, parentRawSegmentIndex),
-				segment: toSegment(parentRawSegment),
-				level: level - 1,
-				children: []
-			};
-			rawRoutesByLevelMap[level - 1][parentRawPath].children.push(rawRoute);
-		}
-	}
-	const rootRawRoutesMap = rawRoutesByLevelMap[0];
-	const rawRoutes = Object.keys(rootRawRoutesMap).map((segment) => rootRawRoutesMap[segment]);
-	sortRawRoutes(rawRoutes);
-	return toRoutes(rawRoutes, files, debug);
-}
-function toRawPath(filename) {
-	return filename.replace(/^(?:[a-zA-Z]:[\\/])?(.*?)[\\/](?:routes|pages)[\\/]|(?:[\\/](?:app[\\/](?:routes|pages)|src[\\/]content)[\\/])|(\.page\.(js|ts|analog|ag)$)|(\.(ts|md|analog|ag)$)/g, "").replace(/\[\[\.\.\.([^\]]+)\]\]/g, "(opt-$1)").replace(/\[\.{3}.+\]/, "**").replace(/\[([^\]]+)\]/g, ":$1");
+	return createRoutes$1(files, (_filename, fileLoader) => fileLoader, debug);
 }
-function toSegment(rawSegment) {
-	return rawSegment.replace(/index|\(.*?\)/g, "").replace(/\.|\/+/g, "/").replace(/^\/+|\/+$/g, "");
-}
-function createOptionalCatchAllMatcher(paramName) {
-	return (segments) => {
-		if (segments.length === 0) return null;
-		const joined = segments.map((s) => s.path).join("/");
-		return {
-			consumed: segments,
-			posParams: { [paramName]: new UrlSegment(joined, {}) }
-		};
-	};
-}
-function toRoutes(rawRoutes, files, debug = false) {
-	const routes = [];
-	for (const rawRoute of rawRoutes) {
-		const children = rawRoute.children.length > 0 ? toRoutes(rawRoute.children, files, debug) : void 0;
-		let module = void 0;
-		let analogMeta = void 0;
-		if (rawRoute.filename) {
-			const isMarkdownFile = rawRoute.filename.endsWith(".md");
-			if (!debug) module = isMarkdownFile ? toMarkdownModule(files[rawRoute.filename]) : files[rawRoute.filename];
-			const endpointKey = rawRoute.filename.replace(/\.page\.(ts|analog|ag)$/, ENDPOINT_EXTENSION);
-			analogMeta = {
-				endpoint: (rawRoute.filename.replace(/\.page\.(ts|analog|ag)$/, "").replace(/\[\[\.\.\..+\]\]/, "**").replace(/\[\.{3}.+\]/, "**").replace(/^(.*?)\/pages/, "/pages") || "").replace(/\./g, "/").replace(/\/\((.*?)\)$/, "/-$1-"),
-				endpointKey
-			};
-		}
-		const optCatchAllMatch = rawRoute.filename?.match(/\[\[\.\.\.([^\]]+)\]\]/);
-		const optCatchAllParam = optCatchAllMatch ? optCatchAllMatch[1] : null;
-		const route = module ? {
-			path: rawRoute.segment,
-			loadChildren: () => module().then((m) => {
-				return [{
-					path: "",
-					component: m.default,
-					...toRouteConfig(m.routeMeta),
-					children,
-					[ANALOG_META_KEY]: analogMeta
-				}, ...optCatchAllParam ? [{
-					matcher: createOptionalCatchAllMatcher(optCatchAllParam),
-					component: m.default,
-					...toRouteConfig(m.routeMeta),
-					[ANALOG_META_KEY]: analogMeta
-				}] : []];
-			})
-		} : {
-			path: rawRoute.segment,
-			...debug ? {
-				filename: rawRoute.filename ? rawRoute.filename : void 0,
-				isLayout: children && children.length > 0 ? true : false
-			} : {},
-			children
-		};
-		routes.push(route);
-	}
-	return routes;
-}
-function sortRawRoutes(rawRoutes) {
-	rawRoutes.sort((a, b) => {
-		let segmentA = deprioritizeSegment(a.segment);
-		let segmentB = deprioritizeSegment(b.segment);
-		if (a.children.length > b.children.length) segmentA = `~${segmentA}`;
-		else if (a.children.length < b.children.length) segmentB = `~${segmentB}`;
-		return segmentA > segmentB ? 1 : -1;
-	});
-	for (const rawRoute of rawRoutes) sortRawRoutes(rawRoute.children);
-}
-function deprioritizeSegment(segment) {
-	return segment.replace(":", "~~").replace("**", "~~~~");
-}
-var routes = createRoutes({
-	...ANALOG_ROUTE_FILES,
-	...ANALOG_CONTENT_ROUTE_FILES
-});
+var routes = createRoutes(ANALOG_ROUTE_FILES);
 //#endregion
 //#region packages/router/src/lib/debug/routes.ts
 var DEBUG_ROUTES = new InjectionToken("@analogjs/router debug routes", {
 	providedIn: "root",
 	factory() {
-		return createRoutes({
-			...ANALOG_ROUTE_FILES,
-			...ANALOG_CONTENT_ROUTE_FILES
-		}, true);
+		return createRoutes(ANALOG_ROUTE_FILES, true);
 	}
 });
 function injectDebugRoutes() {
 	return inject(DEBUG_ROUTES);
 }
 //#endregion
-export { updateMetaTagsOnRouteChange as a, injectRouteEndpointURL as i, createRoutes as n, routes as r, injectDebugRoutes as t };
+export { createRoutes as n, routes as r, injectDebugRoutes as t };
 
 //# sourceMappingURL=routes.mjs.map

package/fesm2022/routes.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.mjs","names":[],"sources":["../../src/lib/routes.ts","../../src/lib/debug/routes.ts"],"sourcesContent":["import type { Route } from '@angular/router';\n\nimport type { RouteExport } from './models';\nimport { createRoutes as createBaseRoutes } from './route-builder';\nimport { ANALOG_ROUTE_FILES, type Files } from './route-files';\n\n/**\n * A function used to parse list of files and create configuration of routes.\n *\n * @param files\n * @returns Array of routes\n */\nexport function createRoutes(files: Files, debug = false): Route[] {\n  return createBaseRoutes(\n    files,\n    (_filename, fileLoader) => fileLoader as () => Promise<RouteExport>,\n    debug,\n  );\n}\n\nexport { ANALOG_ROUTE_FILES } from './route-files';\n\nexport const routes: Route[] = createRoutes(ANALOG_ROUTE_FILES);\n","import { inject, InjectionToken } from '@angular/core';\nimport { Route } from '@angular/router';\n\nimport { ANALOG_ROUTE_FILES, createRoutes } from '../routes';\n\nexport const DEBUG_ROUTES: InjectionToken<(Route & DebugRoute)[]> =\n  new InjectionToken<(Route & DebugRoute)[]>('@analogjs/router debug routes', {\n    providedIn: 'root',\n    factory() {\n      const debugRoutes = createRoutes(ANALOG_ROUTE_FILES, true);\n\n      return debugRoutes as (Route & DebugRoute)[];\n    },\n  });\n\nexport type DebugRoute = {\n  path: string;\n  filename: string;\n  isLayout: boolean;\n  children?: DebugRoute[];\n};\n\nexport function injectDebugRoutes(): (Route & DebugRoute)[] {\n  return inject(DEBUG_ROUTES);\n}\n"],"mappings":";;;;;;;;;AAYA,SAAgB,aAAa,OAAc,QAAQ,OAAgB;AACjE,QAAO,eACL,QACC,WAAW,eAAe,YAC3B,MACD;;AAKH,IAAa,SAAkB,aAAa,mBAAmB;;;ACjB/D,IAAa,eACX,IAAI,eAAuC,iCAAiC;CAC1E,YAAY;CACZ,UAAU;AAGR,SAFoB,aAAa,oBAAyB,KAAA;;CAI7D,CAAC;AASJ,SAAgB,oBAA4C;AAC1D,QAAO,OAAO,aAAa"}

package/fesm2022/src.mjs

@@ -0,0 +1,335 @@
+import { getRequestURL, readBody, readFormData, toRequest } from "nitro/h3";
+//#region packages/router/server/actions/src/actions.ts
+function fail(status, errors) {
+	return new Response(JSON.stringify(errors), {
+		status,
+		headers: { "X-Analog-Errors": "true" }
+	});
+}
+function json(data, config) {
+	return new Response(JSON.stringify(data), {
+		headers: { "Content-Type": "application/json; charset=utf-8" },
+		...config
+	});
+}
+function redirect(url, config = 302) {
+	if (typeof config === "number") return new Response(null, {
+		status: config,
+		headers: { Location: `${url}` }
+	});
+	return new Response(null, {
+		headers: { Location: `${url}` },
+		...config
+	});
+}
+//#endregion
+//#region packages/router/server/actions/src/parse-request-data.ts
+function appendEntry(target, key, value) {
+	const existingValue = target[key];
+	if (existingValue === void 0) {
+		target[key] = value;
+		return;
+	}
+	if (Array.isArray(existingValue)) {
+		existingValue.push(value);
+		return;
+	}
+	target[key] = [existingValue, value];
+}
+function getRequest(event) {
+	const maybeRequest = event.request;
+	if (maybeRequest) return maybeRequest;
+	return toRequest(event);
+}
+function getContentType(event) {
+	return getRequest(event).headers.get("content-type") ?? event.headers.get("content-type") ?? event.headers.get("Content-Type") ?? "";
+}
+function isJsonContentType(contentType) {
+	const mimeType = contentType.split(";", 1)[0]?.trim().toLowerCase() ?? "";
+	return mimeType === "application/json" || mimeType.endsWith("+json");
+}
+function isFormContentType(contentType) {
+	return contentType.includes("multipart/form-data") || contentType.includes("application/x-www-form-urlencoded");
+}
+function parseSearchParams(searchParams) {
+	const result = {};
+	searchParams.forEach((value, key) => {
+		appendEntry(result, key, value);
+	});
+	return result;
+}
+function parseFormData(formData) {
+	const result = {};
+	formData.forEach((value, key) => {
+		appendEntry(result, key, value);
+	});
+	return result;
+}
+async function parseRequestData(event) {
+	const request = getRequest(event);
+	const httpEvent = event;
+	const h3Event = event;
+	const method = event.method.toUpperCase();
+	if (method === "GET" || method === "HEAD") return parseSearchParams(new URL(request.url, "http://localhost").searchParams);
+	const contentType = getContentType(event);
+	if (isJsonContentType(contentType)) try {
+		return await readBody(httpEvent) ?? {};
+	} catch {
+		try {
+			return await request.json();
+		} catch {
+			return {};
+		}
+	}
+	if (isFormContentType(contentType)) try {
+		return parseFormData(await readFormData(h3Event));
+	} catch {
+		if (typeof request.formData === "function") return parseFormData(await request.formData());
+		return {};
+	}
+	try {
+		return await readBody(httpEvent) ?? {};
+	} catch {
+		try {
+			return await request.json();
+		} catch {
+			return {};
+		}
+	}
+}
+//#endregion
+//#region packages/router/server/actions/src/validate.ts
+/**
+* Validates unknown input against a Standard Schema.
+*
+* Handles both sync and async `validate` implementations — the Standard
+* Schema spec allows either return shape.
+*/
+async function validateWithSchema(schema, data) {
+	return schema["~standard"].validate(data);
+}
+//#endregion
+//#region packages/router/server/actions/src/define-action.ts
+/**
+* Creates a server action handler with Standard Schema input validation.
+*
+* Parses the request body (JSON or FormData) and validates it against the
+* provided schema before invoking the handler. On validation failure,
+* returns `fail(422, issues)` with `StandardSchemaV1.Issue[]`.
+* Repeated form fields are preserved as arrays instead of being collapsed
+* to the last value.
+*
+* @example
+* ```typescript
+* import { defineAction, json } from '@analogjs/router/server/actions';
+* import * as v from 'valibot';
+*
+* const Schema = v.object({
+*   email: v.pipe(v.string(), v.email()),
+* });
+*
+* export const action = defineAction({
+*   schema: Schema,
+*   handler: async ({ data }) => {
+*     // data is typed as { email: string }
+*     return json({ ok: true });
+*   },
+* });
+* ```
+*/
+function defineAction(options) {
+	function getParams(params) {
+		return params ?? {};
+	}
+	return async (ctx) => {
+		const rawParams = getParams(ctx.params);
+		if (options.params) {
+			const paramsResult = await validateWithSchema(options.params, rawParams);
+			if (paramsResult.issues) return fail(422, paramsResult.issues);
+			return handleValidatedRequest(ctx, options, paramsResult.value);
+		}
+		return handleValidatedRequest(ctx, options, rawParams);
+	};
+}
+async function handleValidatedRequest(ctx, options, params) {
+	const body = await parseRequestData(ctx.event);
+	let data = body;
+	if (options.schema) {
+		const result = await validateWithSchema(options.schema, body);
+		if (result.issues) return fail(422, result.issues);
+		data = result.value;
+	}
+	return options.handler({
+		data,
+		params,
+		req: ctx.req,
+		res: ctx.res,
+		fetch: ctx.fetch,
+		event: ctx.event
+	});
+}
+//#endregion
+//#region packages/router/server/actions/src/define-server-route.ts
+function isDevEnvironment() {
+	return typeof process !== "undefined" && (process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test");
+}
+function warnOnOutputIssues(issues) {
+	console.warn(`[analog] Server route output validation failed:\n` + issues.map((i) => {
+		const path = i.path ? ` at "${i.path.map((p) => typeof p === "object" ? p.key : p).join(".")}"` : "";
+		return `  - ${i.message}${path}`;
+	}).join("\n"));
+}
+function getRequestUrl(event) {
+	try {
+		return getRequestURL(event).href;
+	} catch {
+		return event.request.url;
+	}
+}
+/**
+* Creates an h3-compatible event handler with Standard Schema validation.
+*
+* - `input` schema validates the request body (POST/PUT/PATCH) or query
+*   params (GET). Returns 422 with `StandardSchemaV1.Issue[]` on failure.
+* - `output` schema validates the response in development only (stripped
+*   in production for zero overhead). Logs a warning on mismatch.
+* - Plain return values are serialized with `json(...)`; raw `Response`
+*   objects are returned unchanged.
+*
+* @example
+* ```typescript
+* import { defineServerRoute } from '@analogjs/router/server/actions';
+* import * as v from 'valibot';
+*
+* const Input = v.object({
+*   name: v.pipe(v.string(), v.minLength(1)),
+*   email: v.pipe(v.string(), v.email()),
+* });
+* const Output = v.object({
+*   id: v.string(),
+*   name: v.string(),
+* });
+*
+* export default defineServerRoute({
+*   input: Input,
+*   output: Output,
+*   handler: async ({ data }) => {
+*     const user = await db.users.create(data);
+*     return user;
+*   },
+* });
+* ```
+*/
+function defineServerRoute(options) {
+	return (async (event) => {
+		const method = event.method.toUpperCase();
+		let data;
+		let query;
+		let body;
+		let params = event.context?.params ?? {};
+		if (options.params) {
+			const paramsResult = await validateWithSchema(options.params, params);
+			if (paramsResult.issues) return fail(422, paramsResult.issues);
+			params = paramsResult.value;
+		}
+		if (options.input) {
+			data = await parseRequestData(event);
+			const inputResult = await validateWithSchema(options.input, data);
+			if (inputResult.issues) return fail(422, inputResult.issues);
+			data = inputResult.value;
+		} else {
+			if (options.query) {
+				const url = new URL(getRequestUrl(event), "http://localhost");
+				const queryResult = await validateWithSchema(options.query, parseSearchParams(url.searchParams));
+				if (queryResult.issues) return fail(422, queryResult.issues);
+				query = queryResult.value;
+			}
+			if (options.body && method !== "GET" && method !== "HEAD") {
+				body = await parseRequestData(event);
+				const bodyResult = await validateWithSchema(options.body, body);
+				if (bodyResult.issues) return fail(422, bodyResult.issues);
+				body = bodyResult.value;
+			}
+			if (method === "GET" || method === "HEAD") data = query;
+			else if (body !== void 0) data = body;
+			else data = query;
+		}
+		const result = await options.handler({
+			data,
+			query,
+			body,
+			params,
+			event
+		});
+		if (result instanceof Response) return result;
+		if (options.output && isDevEnvironment()) {
+			const outputResult = await validateWithSchema(options.output, result);
+			if (outputResult.issues) warnOnOutputIssues(outputResult.issues);
+		}
+		return json(result);
+	});
+}
+//#endregion
+//#region packages/router/server/actions/src/define-page-load.ts
+/**
+* Creates a typed page server load function with optional
+* Standard Schema validation for route params and query.
+*
+* Follows the same validation patterns as `defineAction` and
+* `defineServerRoute`: validates before invoking the handler,
+* returns `fail(422, issues)` on validation failure.
+*
+* @example
+* ```typescript
+* // src/app/pages/users/[id].server.ts
+* import { definePageLoad } from '@analogjs/router/server/actions';
+* import * as v from 'valibot';
+*
+* export const routeParamsSchema = v.object({
+*   id: v.pipe(v.string(), v.regex(/^\d+$/)),
+* });
+*
+* export const load = definePageLoad({
+*   params: routeParamsSchema,
+*   handler: async ({ params, fetch }) => {
+*     // params.id is typed as string (validated)
+*     const user = await fetch(`/api/users/${params.id}`);
+*     return user;
+*   },
+* });
+* ```
+*/
+function definePageLoad(options) {
+	return async (ctx) => {
+		let params = ctx.params ?? {};
+		let requestUrl;
+		try {
+			requestUrl = getRequestURL(ctx.event).href;
+		} catch {
+			requestUrl = ctx.event.request.url;
+		}
+		let query = parseSearchParams(new URL(requestUrl, "http://localhost").searchParams);
+		if (options.params) {
+			const result = await validateWithSchema(options.params, params);
+			if (result.issues) return fail(422, result.issues);
+			params = result.value;
+		}
+		if (options.query) {
+			const result = await validateWithSchema(options.query, query);
+			if (result.issues) return fail(422, result.issues);
+			query = result.value;
+		}
+		return options.handler({
+			params,
+			query,
+			req: ctx.req,
+			res: ctx.res,
+			fetch: ctx.fetch,
+			event: ctx.event
+		});
+	};
+}
+//#endregion
+export { fail as a, validateWithSchema as i, defineServerRoute as n, json as o, defineAction as r, redirect as s, definePageLoad as t };
+
+//# sourceMappingURL=src.mjs.map