@analogjs/router 3.0.0-alpha.3 → 3.0.0-alpha.30

package/content/package.json

@@ -0,0 +1,4 @@
+{
+  "module": "../fesm2022/analogjs-router-content.mjs",
+  "typings": "../types/content/src/index.d.ts"
+}

package/fesm2022/analogjs-router-content.mjs

@@ -0,0 +1,63 @@
+import { r as createRoutes, t as ANALOG_EXTRA_ROUTE_FILE_SOURCES } from "./route-files.mjs";
+import { InjectionToken, inject } from "@angular/core";
+import { ContentRenderer, MarkdownRouteComponent, parseRawContentFile } from "@analogjs/content";
+//#region packages/router/content/src/lib/markdown-helpers.ts
+var isNgZoneEnabled = typeof Zone !== "undefined" && !!Zone.root;
+function toMarkdownModule(markdownFileFactory) {
+	return async () => {
+		const { content, attributes } = parseRawContentFile(await (isNgZoneEnabled ? Zone.root.run(markdownFileFactory) : markdownFileFactory()));
+		const { title, meta, jsonLd } = attributes;
+		return {
+			default: MarkdownRouteComponent,
+			routeMeta: {
+				data: { _analogContent: content },
+				title,
+				meta,
+				jsonLd,
+				resolve: { renderedAnalogContent: async () => {
+					const rendered = await inject(ContentRenderer).render(content);
+					return typeof rendered === "string" ? rendered : rendered.content;
+				} }
+			}
+		};
+	};
+}
+//#endregion
+//#region packages/router/content/src/lib/routes.ts
+/**
+* This variable reference is replaced with a glob of all content routes.
+*/
+var ANALOG_CONTENT_ROUTE_FILES = {};
+function createContentRoutes(files, debug = false) {
+	return createRoutes(files, (filename, fileLoader) => filename.endsWith(".md") ? toMarkdownModule(fileLoader) : fileLoader, debug);
+}
+//#endregion
+//#region packages/router/content/src/lib/with-content-routes.ts
+function withContentRoutes() {
+	return {
+		ɵkind: 101,
+		ɵproviders: [{
+			provide: ANALOG_EXTRA_ROUTE_FILE_SOURCES,
+			multi: true,
+			useValue: {
+				files: ANALOG_CONTENT_ROUTE_FILES,
+				resolveModule: (filename, fileLoader) => filename.endsWith(".md") ? toMarkdownModule(fileLoader) : fileLoader
+			}
+		}]
+	};
+}
+//#endregion
+//#region packages/router/content/src/lib/debug/routes.ts
+var DEBUG_CONTENT_ROUTES = new InjectionToken("@analogjs/router/content debug routes", {
+	providedIn: "root",
+	factory() {
+		return createContentRoutes(ANALOG_CONTENT_ROUTE_FILES, true);
+	}
+});
+function injectDebugContentRoutes() {
+	return inject(DEBUG_CONTENT_ROUTES);
+}
+//#endregion
+export { ANALOG_CONTENT_ROUTE_FILES, createContentRoutes, injectDebugContentRoutes, withContentRoutes };
+
+//# sourceMappingURL=analogjs-router-content.mjs.map

package/fesm2022/analogjs-router-content.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"analogjs-router-content.mjs","names":[],"sources":["../../content/src/lib/markdown-helpers.ts","../../content/src/lib/routes.ts","../../content/src/lib/with-content-routes.ts","../../content/src/lib/debug/routes.ts"],"sourcesContent":["import { inject } from '@angular/core';\nimport {\n  ContentRenderer,\n  MarkdownRouteComponent,\n  parseRawContentFile,\n} from '@analogjs/content';\n\nimport type { RouteExport } from '../../../src/lib/models';\n\ndeclare const Zone: any;\n\ntype RenderResult = string | { content: string };\ntype ContentRendererLike = {\n  render: (content: string) => Promise<RenderResult>;\n};\n\nconst isNgZoneEnabled = typeof Zone !== 'undefined' && !!Zone.root;\n\nexport function toMarkdownModule(\n  markdownFileFactory: () => Promise<string>,\n): () => Promise<RouteExport> {\n  return async () => {\n    const markdownFile = await (isNgZoneEnabled\n      ? Zone.root.run(markdownFileFactory)\n      : markdownFileFactory());\n\n    const { content, attributes } = parseRawContentFile(markdownFile);\n    const { title, meta, jsonLd } = attributes;\n\n    return {\n      default: MarkdownRouteComponent,\n      routeMeta: {\n        data: { _analogContent: content },\n        title,\n        meta,\n        jsonLd,\n        resolve: {\n          renderedAnalogContent: async () => {\n            const contentRenderer = inject<any>(\n              ContentRenderer as any,\n            ) as ContentRendererLike;\n            const rendered = await contentRenderer.render(content);\n            return typeof rendered === 'string' ? rendered : rendered.content;\n          },\n        },\n      },\n    };\n  };\n}\n","import type { Route } from '@angular/router';\n\nimport type { RouteExport } from '../../../src/lib/models';\nimport { createRoutes as createBaseRoutes } from '../../../src/lib/route-builder';\nimport { toMarkdownModule } from './markdown-helpers';\n\n/**\n * This variable reference is replaced with a glob of all content routes.\n */\nexport const ANALOG_CONTENT_ROUTE_FILES = {};\n\nexport type Files = Record<string, () => Promise<RouteExport | string>>;\n\nexport function createContentRoutes(files: Files, debug = false): Route[] {\n  return createBaseRoutes(\n    files,\n    (filename, fileLoader) =>\n      filename.endsWith('.md')\n        ? toMarkdownModule(fileLoader as () => Promise<string>)\n        : (fileLoader as () => Promise<RouteExport>),\n    debug,\n  );\n}\n","import { type RouterFeatures } from '@angular/router';\n\nimport { ANALOG_CONTENT_ROUTE_FILES } from './routes';\nimport { toMarkdownModule } from './markdown-helpers';\nimport type { RouteExport } from '../../../src/lib/models';\nimport {\n  ANALOG_EXTRA_ROUTE_FILE_SOURCES,\n  type ExtraRouteFileSource,\n} from '../../../src/lib/route-files';\n\nexport function withContentRoutes(): RouterFeatures {\n  return {\n    ɵkind: 101 as number,\n    ɵproviders: [\n      {\n        provide: ANALOG_EXTRA_ROUTE_FILE_SOURCES,\n        multi: true,\n        useValue: {\n          files: ANALOG_CONTENT_ROUTE_FILES,\n          resolveModule: (\n            filename: string,\n            fileLoader: () => Promise<unknown>,\n          ) =>\n            filename.endsWith('.md')\n              ? toMarkdownModule(fileLoader as () => Promise<string>)\n              : (fileLoader as () => Promise<RouteExport>),\n        } satisfies ExtraRouteFileSource,\n      },\n    ],\n  };\n}\n","import { inject, InjectionToken } from '@angular/core';\nimport { Route } from '@angular/router';\n\nimport { ANALOG_CONTENT_ROUTE_FILES, createContentRoutes } from '../routes';\n\nexport const DEBUG_CONTENT_ROUTES: InjectionToken<(Route & DebugRoute)[]> =\n  new InjectionToken<(Route & DebugRoute)[]>(\n    '@analogjs/router/content debug routes',\n    {\n      providedIn: 'root',\n      factory() {\n        const debugRoutes = createContentRoutes(\n          ANALOG_CONTENT_ROUTE_FILES as Record<string, () => Promise<string>>,\n          true,\n        );\n\n        return debugRoutes as (Route & DebugRoute)[];\n      },\n    },\n  );\n\nexport type DebugRoute = {\n  path: string;\n  filename: string;\n  isLayout: boolean;\n  children?: DebugRoute[];\n};\n\nexport function injectDebugContentRoutes(): (Route & DebugRoute)[] {\n  return inject(DEBUG_CONTENT_ROUTES);\n}\n"],"mappings":";;;;AAgBA,IAAM,kBAAkB,OAAO,SAAS,eAAe,CAAC,CAAC,KAAK;AAE9D,SAAgB,iBACd,qBAC4B;AAC5B,QAAO,YAAY;EAQjB,MAAO,EAAA,SAAA,eAAA,oBAPc,OAAO,kBAIpB,KAAS,KAAA,IAAA,oBAAe,GACxB,qBAAwB,EAEzB;EACL,MAAS,EAAA,OAAA,MAAA,WAAA;AACT,SAAW;GACD,SAAA;GACR,WAAA;IACA,MAAA,EAAA,gBAAA,SAAA;IACA;IAEE;IACQ;IAGA,SAAW,EACH,uBAAwB,YAAW;;AAIxD,YAAA,OAAA,aAAA,WAAA,WAAA,SAAA;;;;;;;;;;;ACrCL,IAAa,6BAA6B,EAAE;AAI5C,SAAgB,oBAAoB,OAAc,QAAQ,OAAgB;AACxE,QAAO,aACL,QACC,UAAU,eACT,SAAS,SAAS,MACd,GAAA,iBAAA,WAAA,GAAA,YAAA,MAAA;;;;ACRV,SAAgB,oBAAoC;AAClD,QAAO;EACL,OAAO;EACP,YACE,CACW;GACF,SAAA;GACG,OAAA;GACD,UAAA;IAEL,OAAA;wEAOL,iBAAA,WAAA,GAEJ;;;;;;;ACxBH,IAAa,uBACX,IAAI,eACF,yCACA;CACE,YAAY;CACZ,UAAU;AAMR,SALoB,oBAClB,4BAED,KAAA;;CAIJ,CACF;AASH,SAAgB,2BAAmD;AACjE,QAAO,OAAO,qBAAqB"}

package/fesm2022/analogjs-router-server-actions.mjs

@@ -1,3 +1,4 @@
+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), {
@@ -22,6 +23,313 @@ function redirect(url, config = 302) {
 	});
 }
 //#endregion
-export { fail, json, redirect };
+//#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 { defineAction, definePageLoad, defineServerRoute, fail, json, redirect, validateWithSchema };
 
 //# sourceMappingURL=analogjs-router-server-actions.mjs.map

package/fesm2022/analogjs-router-server-actions.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"analogjs-router-server-actions.mjs","names":[],"sources":["../../server/actions/src/actions.ts","../../server/actions/src/parse-request-data.ts","../../server/actions/src/validate.ts","../../server/actions/src/define-action.ts","../../server/actions/src/define-server-route.ts","../../server/actions/src/define-page-load.ts"],"sourcesContent":["import type { H3Event, H3EventContext } from 'nitro/h3';\nimport type { $Fetch } from 'nitro/types';\nimport type { NodeContext } from '../../../src/lib/route-types.js';\n\nexport type PageServerAction = {\n  params: H3EventContext['params'];\n  req: NodeContext['req'];\n  res: NonNullable<NodeContext['res']>;\n  fetch: $Fetch;\n  event: H3Event;\n};\n\nexport function fail<T = object>(status: number, errors: T): Response {\n  return new Response(JSON.stringify(errors), {\n    status,\n    headers: {\n      'X-Analog-Errors': 'true',\n    },\n  });\n}\n\nexport function json<T = object>(data: T, config?: ResponseInit): Response {\n  return new Response(JSON.stringify(data), {\n    headers: {\n      'Content-Type': 'application/json; charset=utf-8',\n    },\n    ...config,\n  });\n}\n\nexport function redirect(\n  url: string,\n  config: number | ResponseInit = 302,\n): Response {\n  if (typeof config === 'number') {\n    return new Response(null, {\n      status: config,\n      headers: {\n        Location: `${url}`,\n      },\n    });\n  }\n\n  return new Response(null, {\n    headers: {\n      Location: `${url}`,\n    },\n    ...config,\n  });\n}\n","import { readBody, readFormData, toRequest as h3ToRequest } from 'nitro/h3';\n\ntype RequestEntryValue = string | File;\ntype ParsedRequestValue = RequestEntryValue | RequestEntryValue[];\n\nfunction appendEntry(\n  target: Record<string, ParsedRequestValue>,\n  key: string,\n  value: RequestEntryValue,\n) {\n  const existingValue = target[key];\n\n  if (existingValue === undefined) {\n    target[key] = value;\n    return;\n  }\n\n  if (Array.isArray(existingValue)) {\n    existingValue.push(value);\n    return;\n  }\n\n  target[key] = [existingValue, value];\n}\n\nfunction getRequest(event: { method: string; headers: Headers }): Request {\n  const maybeRequest = (event as unknown as { request?: Request }).request;\n  if (maybeRequest) {\n    return maybeRequest;\n  }\n  return h3ToRequest(event as Parameters<typeof h3ToRequest>[0]);\n}\n\nfunction getContentType(event: { method: string; headers: Headers }): string {\n  const request = getRequest(event);\n\n  return (\n    request.headers.get('content-type') ??\n    event.headers.get('content-type') ??\n    event.headers.get('Content-Type') ??\n    ''\n  );\n}\n\nfunction isJsonContentType(contentType: string): boolean {\n  const mimeType = contentType.split(';', 1)[0]?.trim().toLowerCase() ?? '';\n  return mimeType === 'application/json' || mimeType.endsWith('+json');\n}\n\nfunction isFormContentType(contentType: string): boolean {\n  return (\n    contentType.includes('multipart/form-data') ||\n    contentType.includes('application/x-www-form-urlencoded')\n  );\n}\n\nexport function parseSearchParams(\n  searchParams: URLSearchParams,\n): Record<string, ParsedRequestValue> {\n  const result: Record<string, ParsedRequestValue> = {};\n  searchParams.forEach((value, key) => {\n    appendEntry(result, key, value);\n  });\n  return result;\n}\n\nexport function parseFormData(\n  formData: FormData,\n): Record<string, ParsedRequestValue> {\n  const result: Record<string, ParsedRequestValue> = {};\n  formData.forEach((value, key) => {\n    appendEntry(result, key, value as RequestEntryValue);\n  });\n  return result;\n}\n\nexport async function parseRequestData(event: {\n  method: string;\n  headers: Headers;\n}): Promise<unknown> {\n  const request = getRequest(event);\n  const httpEvent = event as unknown as Parameters<typeof readBody>[0];\n  const h3Event = event as unknown as Parameters<typeof readFormData>[0];\n  const method = event.method.toUpperCase();\n\n  if (method === 'GET' || method === 'HEAD') {\n    const url = new URL(request.url, 'http://localhost');\n    return parseSearchParams(url.searchParams);\n  }\n\n  const contentType = getContentType(event);\n\n  if (isJsonContentType(contentType)) {\n    try {\n      return (await readBody(httpEvent)) ?? {};\n    } catch {\n      try {\n        return await request.json();\n      } catch {\n        return {};\n      }\n    }\n  }\n\n  if (isFormContentType(contentType)) {\n    try {\n      return parseFormData(await readFormData(h3Event));\n    } catch {\n      if (typeof request.formData === 'function') {\n        return parseFormData(await request.formData());\n      }\n\n      return {};\n    }\n  }\n\n  try {\n    return (await readBody(httpEvent)) ?? {};\n  } catch {\n    try {\n      return await request.json();\n    } catch {\n      return {};\n    }\n  }\n}\n","import type { StandardSchemaV1 } from '@standard-schema/spec';\n\n/**\n * Validates unknown input against a Standard Schema.\n *\n * Handles both sync and async `validate` implementations — the Standard\n * Schema spec allows either return shape.\n */\nexport async function validateWithSchema<T extends StandardSchemaV1>(\n  schema: T,\n  data: unknown,\n): Promise<StandardSchemaV1.Result<StandardSchemaV1.InferOutput<T>>> {\n  return schema['~standard'].validate(data);\n}\n","import type { StandardSchemaV1 } from '@standard-schema/spec';\nimport type { H3Event, H3EventContext } from 'nitro/h3';\nimport type { $Fetch } from 'nitro/types';\nimport { fail } from './actions';\nimport { parseRequestData } from './parse-request-data';\nimport { validateWithSchema } from './validate';\n\ntype NodeContext = NonNullable<H3Event['node']>;\ntype OptionalSchema = StandardSchemaV1 | undefined;\ntype InferSchema<\n  TSchema extends OptionalSchema,\n  TFallback,\n> = TSchema extends StandardSchemaV1\n  ? StandardSchemaV1.InferOutput<TSchema>\n  : TFallback;\n\nexport interface DefineActionContext<\n  TSchema extends OptionalSchema = undefined,\n  TParamsSchema extends OptionalSchema = undefined,\n> {\n  data: InferSchema<TSchema, Record<string, unknown>>;\n  params: InferSchema<TParamsSchema, H3EventContext['params']>;\n  req: NodeContext['req'];\n  res: NonNullable<NodeContext['res']>;\n  fetch: $Fetch;\n  event: H3Event;\n}\n\nexport interface DefineActionOptions<\n  TSchema extends OptionalSchema = undefined,\n  TParamsSchema extends OptionalSchema = undefined,\n> {\n  schema?: TSchema;\n  params?: TParamsSchema;\n  handler: (\n    context: DefineActionContext<TSchema, TParamsSchema>,\n  ) => Promise<Response> | Response;\n}\n\n/**\n * Creates a server action handler with Standard Schema input validation.\n *\n * Parses the request body (JSON or FormData) and validates it against the\n * provided schema before invoking the handler. On validation failure,\n * returns `fail(422, issues)` with `StandardSchemaV1.Issue[]`.\n * Repeated form fields are preserved as arrays instead of being collapsed\n * to the last value.\n *\n * @example\n * ```typescript\n * import { defineAction, json } from '@analogjs/router/server/actions';\n * import * as v from 'valibot';\n *\n * const Schema = v.object({\n *   email: v.pipe(v.string(), v.email()),\n * });\n *\n * export const action = defineAction({\n *   schema: Schema,\n *   handler: async ({ data }) => {\n *     // data is typed as { email: string }\n *     return json({ ok: true });\n *   },\n * });\n * ```\n */\nexport function defineAction<\n  TSchema extends OptionalSchema = undefined,\n  TParamsSchema extends OptionalSchema = undefined,\n>(options: DefineActionOptions<TSchema, TParamsSchema>) {\n  type Params = InferSchema<TParamsSchema, H3EventContext['params']>;\n\n  function getParams(\n    params: H3EventContext['params'],\n  ): Params | Record<string, never> {\n    return (params ?? {}) as Params | Record<string, never>;\n  }\n\n  return async (ctx: {\n    params: H3EventContext['params'];\n    req: NodeContext['req'];\n    res: NonNullable<NodeContext['res']>;\n    fetch: $Fetch;\n    event: H3Event;\n  }): Promise<Response> => {\n    const rawParams = getParams(ctx.params);\n\n    if (options.params) {\n      const paramsResult = await validateWithSchema(options.params, rawParams);\n      if (paramsResult.issues) {\n        return fail(422, paramsResult.issues);\n      }\n      return handleValidatedRequest(ctx, options, paramsResult.value as Params);\n    }\n\n    return handleValidatedRequest(ctx, options, rawParams as Params);\n  };\n}\n\nasync function handleValidatedRequest<\n  TSchema extends OptionalSchema = undefined,\n  TParamsSchema extends OptionalSchema = undefined,\n>(\n  ctx: {\n    params: H3EventContext['params'];\n    req: NodeContext['req'];\n    res: NonNullable<NodeContext['res']>;\n    fetch: $Fetch;\n    event: H3Event;\n  },\n  options: DefineActionOptions<TSchema, TParamsSchema>,\n  params: InferSchema<TParamsSchema, H3EventContext['params']>,\n) {\n  type Data = InferSchema<TSchema, Record<string, unknown>>;\n  const body = await parseRequestData(ctx.event);\n\n  let data: unknown = body;\n\n  if (options.schema) {\n    const result = await validateWithSchema(options.schema, body);\n    if (result.issues) {\n      return fail(422, result.issues);\n    }\n    data = result.value;\n  }\n\n  return options.handler({\n    data: data as Data,\n    params,\n    req: ctx.req,\n    res: ctx.res,\n    fetch: ctx.fetch,\n    event: ctx.event,\n  });\n}\n","import type { StandardSchemaV1 } from '@standard-schema/spec';\nimport type { H3Event } from 'nitro/h3';\nimport { getRequestURL } from 'nitro/h3';\nimport { fail, json } from './actions';\nimport { parseRequestData, parseSearchParams } from './parse-request-data';\nimport { validateWithSchema } from './validate';\n\nexport type DefineServerRouteResult = Response | unknown;\n\nexport interface ServerRouteHandler<\n  TQuery = unknown,\n  TBody = unknown,\n  TResult = unknown,\n> {\n  (event: H3Event): Promise<Response>;\n  readonly _types: {\n    readonly query: TQuery;\n    readonly body: TBody;\n    readonly result: TResult;\n  };\n}\n\nexport type InferRouteQuery<T> =\n  T extends ServerRouteHandler<infer Q, any, any> ? Q : never;\nexport type InferRouteBody<T> =\n  T extends ServerRouteHandler<any, infer B, any> ? B : never;\nexport type InferRouteResult<T> =\n  T extends ServerRouteHandler<any, any, infer R>\n    ? Exclude<R, Response>\n    : never;\n\ntype OptionalSchema = StandardSchemaV1 | undefined;\ntype InferSchema<\n  TSchema extends OptionalSchema,\n  TFallback = unknown,\n> = TSchema extends StandardSchemaV1\n  ? StandardSchemaV1.InferOutput<TSchema>\n  : TFallback;\ntype ResolveDataSchema<\n  TInput extends OptionalSchema,\n  TQuery extends OptionalSchema,\n  TBody extends OptionalSchema,\n> = TInput extends StandardSchemaV1\n  ? StandardSchemaV1.InferOutput<TInput>\n  : TQuery extends StandardSchemaV1\n    ? TBody extends StandardSchemaV1\n      ?\n          | StandardSchemaV1.InferOutput<TQuery>\n          | StandardSchemaV1.InferOutput<TBody>\n      : StandardSchemaV1.InferOutput<TQuery>\n    : TBody extends StandardSchemaV1\n      ? StandardSchemaV1.InferOutput<TBody>\n      : unknown;\n\nexport interface DefineServerRouteContext<\n  TInput extends StandardSchemaV1 | undefined = undefined,\n  TQuery extends StandardSchemaV1 | undefined = undefined,\n  TBody extends StandardSchemaV1 | undefined = undefined,\n  TParams extends StandardSchemaV1 | undefined = undefined,\n> {\n  data: ResolveDataSchema<TInput, TQuery, TBody>;\n  query: InferSchema<TQuery, undefined>;\n  body: InferSchema<TBody, undefined>;\n  params: InferSchema<TParams, H3Event['context']['params']>;\n  event: H3Event;\n}\n\nexport interface DefineServerRouteOptions<\n  TInput extends StandardSchemaV1 | undefined = undefined,\n  TOutput extends StandardSchemaV1 | undefined = undefined,\n  TQuery extends StandardSchemaV1 | undefined = undefined,\n  TBody extends StandardSchemaV1 | undefined = undefined,\n  TParams extends StandardSchemaV1 | undefined = undefined,\n  TResult extends DefineServerRouteResult = DefineServerRouteResult,\n> {\n  input?: TInput;\n  query?: TQuery;\n  body?: TBody;\n  params?: TParams;\n  output?: TOutput;\n  handler: (\n    context: DefineServerRouteContext<TInput, TQuery, TBody, TParams>,\n  ) => Promise<TResult> | TResult;\n}\n\nfunction isDevEnvironment() {\n  return (\n    typeof process !== 'undefined' &&\n    (process.env['NODE_ENV'] === 'development' ||\n      process.env['NODE_ENV'] === 'test')\n  );\n}\n\nfunction warnOnOutputIssues(issues: ReadonlyArray<StandardSchemaV1.Issue>) {\n  console.warn(\n    `[analog] Server route output validation failed:\\n` +\n      issues\n        .map((i) => {\n          const path = i.path\n            ? ` at \"${i.path.map((p) => (typeof p === 'object' ? (p as { key: string }).key : p)).join('.')}\"`\n            : '';\n          return `  - ${i.message}${path}`;\n        })\n        .join('\\n'),\n  );\n}\n\nfunction getRequestUrl(event: H3Event): string {\n  try {\n    return getRequestURL(event).href;\n  } catch {\n    return (event as H3Event & { request: Request }).request.url;\n  }\n}\n\n/**\n * Creates an h3-compatible event handler with Standard Schema validation.\n *\n * - `input` schema validates the request body (POST/PUT/PATCH) or query\n *   params (GET). Returns 422 with `StandardSchemaV1.Issue[]` on failure.\n * - `output` schema validates the response in development only (stripped\n *   in production for zero overhead). Logs a warning on mismatch.\n * - Plain return values are serialized with `json(...)`; raw `Response`\n *   objects are returned unchanged.\n *\n * @example\n * ```typescript\n * import { defineServerRoute } from '@analogjs/router/server/actions';\n * import * as v from 'valibot';\n *\n * const Input = v.object({\n *   name: v.pipe(v.string(), v.minLength(1)),\n *   email: v.pipe(v.string(), v.email()),\n * });\n * const Output = v.object({\n *   id: v.string(),\n *   name: v.string(),\n * });\n *\n * export default defineServerRoute({\n *   input: Input,\n *   output: Output,\n *   handler: async ({ data }) => {\n *     const user = await db.users.create(data);\n *     return user;\n *   },\n * });\n * ```\n */\nexport function defineServerRoute<\n  TInput extends StandardSchemaV1 | undefined = undefined,\n  TOutput extends StandardSchemaV1 | undefined = undefined,\n  TQuery extends StandardSchemaV1 | undefined = undefined,\n  TBody extends StandardSchemaV1 | undefined = undefined,\n  TParams extends StandardSchemaV1 | undefined = undefined,\n  TResult extends DefineServerRouteResult = DefineServerRouteResult,\n>(\n  options: DefineServerRouteOptions<\n    TInput,\n    TOutput,\n    TQuery,\n    TBody,\n    TParams,\n    TResult\n  >,\n): ServerRouteHandler<\n  InferSchema<TQuery, undefined>,\n  InferSchema<TBody, undefined>,\n  TResult\n> {\n  return (async (event: H3Event): Promise<Response> => {\n    const method = event.method.toUpperCase();\n    let data: unknown;\n    let query: unknown;\n    let body: unknown;\n    let params: unknown = event.context?.params ?? {};\n\n    if (options.params) {\n      const paramsResult = await validateWithSchema(options.params, params);\n      if (paramsResult.issues) {\n        return fail(422, paramsResult.issues);\n      }\n      params = paramsResult.value;\n    }\n\n    if (options.input) {\n      data = await parseRequestData(event);\n\n      const inputResult = await validateWithSchema(options.input, data);\n      if (inputResult.issues) {\n        return fail(422, inputResult.issues);\n      }\n      data = inputResult.value;\n    } else {\n      if (options.query) {\n        const url = new URL(getRequestUrl(event), 'http://localhost');\n        const queryResult = await validateWithSchema(\n          options.query,\n          parseSearchParams(url.searchParams),\n        );\n        if (queryResult.issues) {\n          return fail(422, queryResult.issues);\n        }\n        query = queryResult.value;\n      }\n\n      if (options.body && method !== 'GET' && method !== 'HEAD') {\n        body = await parseRequestData(event);\n        const bodyResult = await validateWithSchema(options.body, body);\n        if (bodyResult.issues) {\n          return fail(422, bodyResult.issues);\n        }\n        body = bodyResult.value;\n      }\n\n      if (method === 'GET' || method === 'HEAD') {\n        data = query;\n      } else if (body !== undefined) {\n        data = body;\n      } else {\n        data = query;\n      }\n    }\n\n    const result = await options.handler({\n      data: data as ResolveDataSchema<TInput, TQuery, TBody>,\n      query: query as InferSchema<TQuery, undefined>,\n      body: body as InferSchema<TBody, undefined>,\n      params: params as InferSchema<TParams, H3Event['context']['params']>,\n      event,\n    });\n\n    if (result instanceof Response) {\n      return result;\n    }\n\n    if (options.output && isDevEnvironment()) {\n      const outputResult = await validateWithSchema(options.output, result);\n      if (outputResult.issues) {\n        warnOnOutputIssues(outputResult.issues);\n      }\n    }\n\n    return json(result);\n  }) as ServerRouteHandler<\n    InferSchema<TQuery, undefined>,\n    InferSchema<TBody, undefined>,\n    TResult\n  >;\n}\n","import type { StandardSchemaV1 } from '@standard-schema/spec';\nimport type { H3Event, H3EventContext } from 'nitro/h3';\nimport { getRequestURL } from 'nitro/h3';\nimport type { $Fetch } from 'nitro/types';\nimport { fail } from './actions';\nimport { parseSearchParams } from './parse-request-data';\nimport { validateWithSchema } from './validate';\n\ntype NodeContext = NonNullable<H3Event['node']>;\ntype OptionalSchema = StandardSchemaV1 | undefined;\ntype InferSchema<\n  TSchema extends OptionalSchema,\n  TFallback,\n> = TSchema extends StandardSchemaV1\n  ? StandardSchemaV1.InferOutput<TSchema>\n  : TFallback;\n\nexport interface PageLoadContext<\n  TParamsSchema extends OptionalSchema = undefined,\n  TQuerySchema extends OptionalSchema = undefined,\n> {\n  params: InferSchema<TParamsSchema, H3EventContext['params']>;\n  query: InferSchema<\n    TQuerySchema,\n    Record<string, string | string[] | undefined>\n  >;\n  req: NodeContext['req'];\n  res: NonNullable<NodeContext['res']>;\n  fetch: $Fetch;\n  event: H3Event;\n}\n\nexport interface DefinePageLoadOptions<\n  TParamsSchema extends OptionalSchema = undefined,\n  TQuerySchema extends OptionalSchema = undefined,\n  TResult = unknown,\n> {\n  params?: TParamsSchema;\n  query?: TQuerySchema;\n  handler: (\n    context: PageLoadContext<TParamsSchema, TQuerySchema>,\n  ) => Promise<TResult> | TResult;\n}\n\n/**\n * Creates a typed page server load function with optional\n * Standard Schema validation for route params and query.\n *\n * Follows the same validation patterns as `defineAction` and\n * `defineServerRoute`: validates before invoking the handler,\n * returns `fail(422, issues)` on validation failure.\n *\n * @example\n * ```typescript\n * // src/app/pages/users/[id].server.ts\n * import { definePageLoad } from '@analogjs/router/server/actions';\n * import * as v from 'valibot';\n *\n * export const routeParamsSchema = v.object({\n *   id: v.pipe(v.string(), v.regex(/^\\d+$/)),\n * });\n *\n * export const load = definePageLoad({\n *   params: routeParamsSchema,\n *   handler: async ({ params, fetch }) => {\n *     // params.id is typed as string (validated)\n *     const user = await fetch(`/api/users/${params.id}`);\n *     return user;\n *   },\n * });\n * ```\n */\nexport function definePageLoad<\n  TParamsSchema extends OptionalSchema = undefined,\n  TQuerySchema extends OptionalSchema = undefined,\n  TResult = unknown,\n>(\n  options: DefinePageLoadOptions<TParamsSchema, TQuerySchema, TResult>,\n): (ctx: {\n  params: H3EventContext['params'];\n  req: NodeContext['req'];\n  res: NonNullable<NodeContext['res']>;\n  fetch: $Fetch;\n  event: H3Event;\n}) => Promise<TResult | Response> {\n  type Params = InferSchema<TParamsSchema, H3EventContext['params']>;\n  type Query = InferSchema<\n    TQuerySchema,\n    Record<string, string | string[] | undefined>\n  >;\n\n  return async (ctx: {\n    params: H3EventContext['params'];\n    req: NodeContext['req'];\n    res: NonNullable<NodeContext['res']>;\n    fetch: $Fetch;\n    event: H3Event;\n  }) => {\n    let params: unknown = ctx.params ?? {};\n\n    let requestUrl: string;\n    try {\n      requestUrl = getRequestURL(ctx.event).href;\n    } catch {\n      requestUrl = (ctx.event as H3Event & { request: Request }).request.url;\n    }\n    const url = new URL(requestUrl, 'http://localhost');\n    let query: unknown = parseSearchParams(url.searchParams);\n\n    // Validate params\n    if (options.params) {\n      const result = await validateWithSchema(options.params, params);\n      if (result.issues) {\n        return fail(422, result.issues);\n      }\n      params = result.value;\n    }\n\n    // Validate query\n    if (options.query) {\n      const result = await validateWithSchema(options.query, query);\n      if (result.issues) {\n        return fail(422, result.issues);\n      }\n      query = result.value;\n    }\n\n    return options.handler({\n      params: params as Params,\n      query: query as Query,\n      req: ctx.req,\n      res: ctx.res,\n      fetch: ctx.fetch,\n      event: ctx.event,\n    });\n  };\n}\n"],"mappings":"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"}

package/fesm2022/analogjs-router-server.mjs

@@ -1,5 +1,5 @@
+import { BASE_URL, INTERNAL_FETCH, REQUEST, RESPONSE } from "./analogjs-router-tokens.mjs";
 import { APP_ID, InjectionToken, TransferState, assertInInjectionContext, enableProdMode, inject, makeStateKey, reflectComponentType, ɵConsole } from "@angular/core";
-import { BASE_URL, INTERNAL_FETCH, REQUEST, RESPONSE } from "@analogjs/router/tokens";
 import { bootstrapApplication } from "@angular/platform-browser";
 import { provideServerRendering, renderApplication, ɵSERVER_CONTEXT } from "@angular/platform-server";
 import { json } from "node:stream/consumers";
@@ -82,7 +82,7 @@ var components = /* @__PURE__ */ Object.assign({});
 async function renderServerComponent(url, serverContext, config) {
 	const { componentLoader, componentId } = getComponentLoader(serverComponentRequest(serverContext));
 	if (!componentLoader) return new Response(`Server Component Not Found ${componentId}`, { status: 404 });
-	const component = (await componentLoader())["default"];
+	const component = (await componentLoader()).default;
 	if (!component) return new Response(`No default export for ${componentId}`, { status: 422 });
 	const selector = reflectComponentType(component)?.selector.split(",")?.[0] || "server-component";
 	const body = await json(serverContext.req).catch(() => ({})) || {};

package/fesm2022/analogjs-router-server.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"analogjs-router-server.mjs","names":[],"sources":["../../server/src/provide-server-context.ts","../../server/src/tokens.ts","../../server/src/server-component-render.ts","../../server/src/render.ts"],"sourcesContent":["import { StaticProvider, ɵresetCompiledComponents } from '@angular/core';\nimport { ɵSERVER_CONTEXT as SERVER_CONTEXT } from '@angular/platform-server';\n\nimport {\n  BASE_URL,\n  INTERNAL_FETCH,\n  REQUEST,\n  RESPONSE,\n  ServerInternalFetch,\n  ServerRequest,\n  ServerResponse,\n} from '../../tokens/src/index.js';\n\nfunction getHeaderValue(\n  value: string | string[] | undefined,\n): string | undefined {\n  return Array.isArray(value) ? value[0] : value;\n}\n\nfunction getRequestHeader(\n  req: ServerRequest,\n  name: string,\n): string | undefined {\n  const headers = (req as { headers?: unknown }).headers;\n\n  if (!headers) {\n    return undefined;\n  }\n\n  if (\n    typeof headers === 'object' &&\n    headers !== null &&\n    'get' in headers &&\n    typeof headers.get === 'function'\n  ) {\n    return headers.get(name) ?? undefined;\n  }\n\n  return getHeaderValue(\n    (headers as Record<string, string | string[] | undefined>)[name],\n  );\n}\n\nexport function provideServerContext({\n  req,\n  res,\n  fetch,\n}: {\n  req: ServerRequest;\n  res: ServerResponse;\n  fetch?: ServerInternalFetch;\n}): StaticProvider[] {\n  const baseUrl = getBaseUrl(req);\n\n  if (import.meta.env.DEV) {\n    ɵresetCompiledComponents();\n  }\n\n  return [\n    { provide: SERVER_CONTEXT, useValue: 'ssr-analog' },\n    { provide: REQUEST, useValue: req },\n    { provide: RESPONSE, useValue: res },\n    { provide: BASE_URL, useValue: baseUrl },\n    { provide: INTERNAL_FETCH, useValue: fetch },\n  ];\n}\n\nexport function getBaseUrl(req: ServerRequest): string {\n  const protocol = getRequestProtocol(req);\n  const host =\n    getRequestHeader(req, 'x-forwarded-host') ??\n    getRequestHeader(req, 'host') ??\n    'localhost';\n  const originalUrl = req.originalUrl || req.url || '/';\n  const parsedUrl = new URL(\n    '',\n    `${protocol}://${host}${\n      originalUrl.endsWith('/')\n        ? originalUrl.substring(0, originalUrl.length - 1)\n        : originalUrl\n    }`,\n  );\n  const baseUrl = parsedUrl.origin;\n\n  return baseUrl;\n}\n\nexport function getRequestProtocol(\n  req: ServerRequest,\n  opts: { xForwardedProto?: boolean } = {},\n): string {\n  const forwardedProto = getRequestHeader(req, 'x-forwarded-proto')\n    ?.split(',')[0]\n    ?.trim();\n\n  if (opts.xForwardedProto !== false && forwardedProto === 'https') {\n    return 'https';\n  }\n\n  return (req.connection as { encrypted?: boolean })?.encrypted\n    ? 'https'\n    : 'http';\n}\n","import {\n  assertInInjectionContext,\n  inject,\n  InjectionToken,\n  makeStateKey,\n  Provider,\n  TransferState,\n} from '@angular/core';\n\nexport const STATIC_PROPS: InjectionToken<Record<string, any>> =\n  new InjectionToken<Record<string, any>>('Static Props');\n\nexport function provideStaticProps<T = Record<string, any>>(\n  props: T,\n): Provider {\n  return {\n    provide: STATIC_PROPS,\n    useFactory() {\n      return props;\n    },\n  };\n}\n\nexport function injectStaticProps(): Record<string, any> {\n  assertInInjectionContext(injectStaticProps);\n\n  return inject(STATIC_PROPS);\n}\n\nexport function injectStaticOutputs<T>(): { set(data: T): void } {\n  const transferState = inject(TransferState);\n  const outputsKey = makeStateKey<T>('_analog_output');\n\n  return {\n    set(data: T): void {\n      transferState.set(outputsKey, data);\n    },\n  };\n}\n","import { ApplicationConfig, Type } from '@angular/core';\nimport {\n  bootstrapApplication,\n  type BootstrapContext,\n} from '@angular/platform-browser';\nimport {\n  reflectComponentType,\n  ɵConsole as Console,\n  APP_ID,\n} from '@angular/core';\nimport {\n  provideServerRendering,\n  renderApplication,\n  ɵSERVER_CONTEXT as SERVER_CONTEXT,\n} from '@angular/platform-server';\nimport type { ServerContext } from '../../tokens/src/index.js';\nimport { json as readJsonStream } from 'node:stream/consumers';\n\nimport { provideStaticProps } from './tokens';\n\ntype ComponentLoader = () => Promise<Type<unknown>>;\n\nexport function serverComponentRequest(\n  serverContext: ServerContext,\n): string | undefined {\n  // `ServerContext` is still backed by raw Node req/res, so read the header\n  // directly instead of reconstructing an H3Event just for lookup.\n  // In h3 v2 / Nitro v3, req may be undefined during fetch-based prerendering\n  // (where event.node is not populated), so guard with optional chaining.\n  const serverComponentId = serverContext.req?.headers?.[\n    'x-analog-component'\n  ] as string | undefined;\n\n  if (\n    !serverComponentId &&\n    serverContext.req?.url &&\n    serverContext.req.url.startsWith('/_analog/components')\n  ) {\n    const componentId = serverContext.req.url.split('/')?.[3];\n\n    return componentId;\n  }\n\n  return serverComponentId;\n}\n\nconst components = import.meta.glob([\n  '/src/server/components/**/*.{ts,analog,ag}',\n]);\n\nexport async function renderServerComponent(\n  url: string,\n  serverContext: ServerContext,\n  config?: ApplicationConfig,\n): Promise<Response> {\n  const componentReqId = serverComponentRequest(serverContext) as string;\n  const { componentLoader, componentId } = getComponentLoader(componentReqId);\n\n  if (!componentLoader) {\n    return new Response(`Server Component Not Found ${componentId}`, {\n      status: 404,\n    });\n  }\n\n  const component = ((await componentLoader()) as { default?: Type<unknown> })\n    .default;\n\n  if (!component) {\n    return new Response(`No default export for ${componentId}`, {\n      status: 422,\n    });\n  }\n\n  const mirror = reflectComponentType(component);\n  const selector = mirror?.selector.split(',')?.[0] || 'server-component';\n  // Server component requests POST JSON props from the client bridge, so parse\n  // the Node request body directly instead of rebuilding an H3Event wrapper.\n  const body =\n    (await readJsonStream(serverContext.req).catch(() => ({}))) || {};\n  const appId = `analog-server-${selector.toLowerCase()}-${new Date().getTime()}`;\n\n  const bootstrap = (context?: BootstrapContext) =>\n    bootstrapApplication(\n      component,\n      {\n        providers: [\n          provideServerRendering(),\n          provideStaticProps(body),\n          { provide: SERVER_CONTEXT, useValue: 'analog-server-component' },\n          {\n            provide: APP_ID,\n            useFactory() {\n              return appId;\n            },\n          },\n          ...(config?.providers || []),\n        ],\n      },\n      context,\n    );\n\n  const html = await renderApplication(bootstrap, {\n    url,\n    document: `<${selector}></${selector}>`,\n    platformProviders: [\n      {\n        provide: Console,\n        useFactory() {\n          return {\n            warn: () => {\n              /* noop */\n            },\n            log: () => {\n              /* noop */\n            },\n          };\n        },\n      },\n    ],\n  });\n\n  const outputs = retrieveTransferredState(html, appId);\n  const responseData: { html: string; outputs: Record<string, unknown> } = {\n    html,\n    outputs,\n  };\n\n  return new Response(JSON.stringify(responseData), {\n    headers: {\n      'X-Analog-Component': 'true',\n    },\n  });\n}\n\nfunction getComponentLoader(componentReqId: string): {\n  componentLoader: ComponentLoader | undefined;\n  componentId: string;\n} {\n  const _componentId = `/src/server/components/${componentReqId.toLowerCase()}`;\n  let componentLoader: ComponentLoader | undefined = undefined;\n  let componentId = _componentId;\n\n  if (components[`${_componentId}.ts`]) {\n    componentId = `${_componentId}.ts`;\n    componentLoader = components[componentId] as ComponentLoader;\n  }\n\n  return { componentLoader, componentId };\n}\n\nfunction retrieveTransferredState(\n  html: string,\n  appId: string,\n): Record<string, unknown | undefined> {\n  const regex = new RegExp(\n    `<script id=\"${appId}-state\" type=\"application/json\">(.*?)</script>`,\n  );\n  const match = html.match(regex);\n\n  if (match) {\n    const scriptContent = match[1];\n\n    if (scriptContent) {\n      try {\n        const parsedContent: {\n          _analog_output: Record<string, unknown | undefined>;\n        } = JSON.parse(scriptContent);\n        return parsedContent._analog_output || {};\n      } catch (e) {\n        console.warn('Exception while parsing static outputs for ' + appId, e);\n      }\n    }\n\n    return {};\n  } else {\n    return {};\n  }\n}\n","import {\n  ApplicationConfig,\n  Provider,\n  Type,\n  enableProdMode,\n} from '@angular/core';\nimport {\n  bootstrapApplication,\n  type BootstrapContext,\n} from '@angular/platform-browser';\nimport { renderApplication } from '@angular/platform-server';\nimport type { ServerContext } from '../../tokens/src/index.js';\n\nimport { provideServerContext } from './provide-server-context';\nimport {\n  serverComponentRequest,\n  renderServerComponent,\n} from './server-component-render';\n\nif (import.meta.env.PROD) {\n  enableProdMode();\n}\n\n/**\n * Returns a function that accepts the navigation URL,\n * the root HTML, and server context.\n *\n * @param rootComponent\n * @param config\n * @param platformProviders\n * @returns Promise<string | Reponse>\n */\nexport function render(\n  rootComponent: Type<unknown>,\n  config: ApplicationConfig,\n  platformProviders: Provider[] = [],\n) {\n  function bootstrap(context?: BootstrapContext) {\n    return bootstrapApplication(rootComponent, config, context);\n  }\n\n  return async function render(\n    url: string,\n    document: string,\n    serverContext: ServerContext,\n  ): Promise<string | Response> {\n    if (serverComponentRequest(serverContext)) {\n      return await renderServerComponent(url, serverContext);\n    }\n\n    const html = await renderApplication(bootstrap, {\n      document,\n      url,\n      platformProviders: [\n        provideServerContext(serverContext),\n        platformProviders,\n      ],\n    });\n\n    return html;\n  };\n}\n"],"mappings":"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"}

package/fesm2022/analogjs-router-tanstack-query-server.mjs

@@ -0,0 +1,22 @@
+import { t as ANALOG_QUERY_STATE_KEY } from "./provide-analog-query.mjs";
+import { TransferState, makeEnvironmentProviders } from "@angular/core";
+import { QueryClient, dehydrate } from "@tanstack/angular-query-experimental";
+import { BEFORE_APP_SERIALIZED } from "@angular/platform-server";
+//#region packages/router/tanstack-query/src/provide-server-analog-query.ts
+var SERVER_ANALOG_QUERY_PROVIDER = {
+	provide: BEFORE_APP_SERIALIZED,
+	multi: true,
+	useFactory: (queryClient, transferState) => {
+		return () => {
+			transferState.set(ANALOG_QUERY_STATE_KEY, dehydrate(queryClient));
+		};
+	},
+	deps: [QueryClient, TransferState]
+};
+function provideServerAnalogQuery() {
+	return makeEnvironmentProviders([SERVER_ANALOG_QUERY_PROVIDER]);
+}
+//#endregion
+export { provideServerAnalogQuery };
+
+//# sourceMappingURL=analogjs-router-tanstack-query-server.mjs.map

package/fesm2022/analogjs-router-tanstack-query-server.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"analogjs-router-tanstack-query-server.mjs","names":[],"sources":["../../tanstack-query/src/provide-server-analog-query.ts"],"sourcesContent":["import { TransferState, makeEnvironmentProviders } from '@angular/core';\nimport type { EnvironmentProviders, Provider } from '@angular/core';\nimport { BEFORE_APP_SERIALIZED } from '@angular/platform-server';\nimport { QueryClient, dehydrate } from '@tanstack/angular-query-experimental';\n\nimport { ANALOG_QUERY_STATE_KEY } from './provide-analog-query';\n\nconst SERVER_ANALOG_QUERY_PROVIDER: Provider = {\n  provide: BEFORE_APP_SERIALIZED,\n  multi: true,\n  useFactory: (queryClient: QueryClient, transferState: TransferState) => {\n    return () => {\n      transferState.set(ANALOG_QUERY_STATE_KEY, dehydrate(queryClient));\n    };\n  },\n  deps: [QueryClient, TransferState],\n};\n\nexport function provideServerAnalogQuery(): EnvironmentProviders {\n  return makeEnvironmentProviders([SERVER_ANALOG_QUERY_PROVIDER]);\n}\n"],"mappings":";;;;;AAOA,IAAM,+BAAyC;CAC7C,SAAS;CACT,OAAO;CACP,aAAa,aAA0B,kBAAiC;AACtE,eAAa;AACX,iBAAkB,IAAA,wBAAwB,UAAU,YAAa,CAAA;;;CAGrE,MAAO,CAAA,aAAa,cAAA;CACrB;AAED,SAAgB,2BAAiD;AAC/D,QAAO,yBAA0B,CAAA,6BAA8B,CAAA"}

package/fesm2022/analogjs-router-tanstack-query.mjs

@@ -0,0 +1,39 @@
+import { n as provideAnalogQuery, t as ANALOG_QUERY_STATE_KEY } from "./provide-analog-query.mjs";
+import { lastValueFrom } from "rxjs";
+//#region packages/router/tanstack-query/src/server-query.ts
+function buildUrl(base, params) {
+	if (!params) return base;
+	const parts = [];
+	for (const [key, value] of Object.entries(params)) {
+		if (value === void 0 || value === null) continue;
+		const k = encodeURIComponent(key);
+		if (Array.isArray(value)) for (const item of value) parts.push(`${k}=${encodeURIComponent(String(item))}`);
+		else parts.push(`${k}=${encodeURIComponent(String(value))}`);
+	}
+	if (parts.length === 0) return base;
+	return `${base}${base.includes("?") ? "&" : "?"}${parts.join("&")}`;
+}
+function serverQueryOptions(http, url, options) {
+	const { query, ...rest } = options;
+	return {
+		...rest,
+		queryFn: () => lastValueFrom(http.get(buildUrl(url, query)))
+	};
+}
+function serverMutationOptions(http, url, options) {
+	return {
+		mutationFn: (body) => lastValueFrom(http.post(url, body)),
+		...options
+	};
+}
+function serverInfiniteQueryOptions(http, url, options) {
+	const { query: buildQuery, ...rest } = options;
+	return {
+		...rest,
+		queryFn: (context) => lastValueFrom(http.get(buildUrl(url, buildQuery(context))))
+	};
+}
+//#endregion
+export { ANALOG_QUERY_STATE_KEY, provideAnalogQuery, serverInfiniteQueryOptions, serverMutationOptions, serverQueryOptions };
+
+//# sourceMappingURL=analogjs-router-tanstack-query.mjs.map

package/fesm2022/analogjs-router-tanstack-query.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"analogjs-router-tanstack-query.mjs","names":[],"sources":["../../tanstack-query/src/server-query.ts"],"sourcesContent":["import type { HttpClient } from '@angular/common/http';\nimport { lastValueFrom } from 'rxjs';\nimport type {\n  CreateQueryOptions,\n  CreateMutationOptions,\n  CreateInfiniteQueryOptions,\n  DefaultError,\n  InfiniteData,\n  QueryKey,\n} from '@tanstack/angular-query-experimental';\nimport type {\n  ServerRouteHandler,\n  InferRouteQuery,\n  InferRouteBody,\n  InferRouteResult,\n} from '../../server/actions/src/index.js';\n\nfunction buildUrl(base: string, params?: Record<string, unknown>): string {\n  if (!params) return base;\n  const parts: string[] = [];\n  for (const [key, value] of Object.entries(params)) {\n    if (value === undefined || value === null) continue;\n    const k = encodeURIComponent(key);\n    if (Array.isArray(value)) {\n      for (const item of value) {\n        parts.push(`${k}=${encodeURIComponent(String(item))}`);\n      }\n    } else {\n      parts.push(`${k}=${encodeURIComponent(String(value))}`);\n    }\n  }\n  if (parts.length === 0) return base;\n  const separator = base.includes('?') ? '&' : '?';\n  return `${base}${separator}${parts.join('&')}`;\n}\n\nexport function serverQueryOptions<\n  TRoute extends ServerRouteHandler<any, any, any>,\n  TError = DefaultError,\n  TData = InferRouteResult<TRoute>,\n  TQueryKey extends QueryKey = QueryKey,\n>(\n  http: HttpClient,\n  url: string,\n  options: { queryKey: TQueryKey; query?: InferRouteQuery<TRoute> } & Omit<\n    CreateQueryOptions<InferRouteResult<TRoute>, TError, TData, TQueryKey>,\n    'queryKey' | 'queryFn'\n  >,\n): CreateQueryOptions<InferRouteResult<TRoute>, TError, TData, TQueryKey> {\n  const { query, ...rest } = options;\n  return {\n    ...rest,\n    queryFn: () =>\n      lastValueFrom(\n        http.get<InferRouteResult<TRoute>>(\n          buildUrl(url, query as Record<string, any>),\n        ),\n      ),\n  } as CreateQueryOptions<InferRouteResult<TRoute>, TError, TData, TQueryKey>;\n}\n\nexport function serverMutationOptions<\n  TRoute extends ServerRouteHandler<any, any, any>,\n  TError = DefaultError,\n  TOnMutateResult = unknown,\n>(\n  http: HttpClient,\n  url: string,\n  options?: Omit<\n    CreateMutationOptions<\n      InferRouteResult<TRoute>,\n      TError,\n      InferRouteBody<TRoute>,\n      TOnMutateResult\n    >,\n    'mutationFn'\n  >,\n): CreateMutationOptions<\n  InferRouteResult<TRoute>,\n  TError,\n  InferRouteBody<TRoute>,\n  TOnMutateResult\n> {\n  return {\n    mutationFn: (body: InferRouteBody<TRoute>) =>\n      lastValueFrom(http.post<InferRouteResult<TRoute>>(url, body)),\n    ...options,\n  } as CreateMutationOptions<\n    InferRouteResult<TRoute>,\n    TError,\n    InferRouteBody<TRoute>,\n    TOnMutateResult\n  >;\n}\n\nexport function serverInfiniteQueryOptions<\n  TRoute extends ServerRouteHandler<any, any, any>,\n  TError = DefaultError,\n  TData = InfiniteData<InferRouteResult<TRoute>>,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n>(\n  http: HttpClient,\n  url: string,\n  options: {\n    queryKey: TQueryKey;\n    query: (context: { pageParam: TPageParam }) => InferRouteQuery<TRoute>;\n    initialPageParam: TPageParam;\n    getNextPageParam: (\n      lastPage: InferRouteResult<TRoute>,\n      allPages: InferRouteResult<TRoute>[],\n    ) => TPageParam | undefined | null;\n  } & Omit<\n    CreateInfiniteQueryOptions<\n      InferRouteResult<TRoute>,\n      TError,\n      TData,\n      TQueryKey,\n      TPageParam\n    >,\n    'queryKey' | 'queryFn' | 'initialPageParam' | 'getNextPageParam'\n  >,\n): CreateInfiniteQueryOptions<\n  InferRouteResult<TRoute>,\n  TError,\n  TData,\n  TQueryKey,\n  TPageParam\n> {\n  const { query: buildQuery, ...rest } = options;\n  return {\n    ...rest,\n    queryFn: (context: { pageParam: TPageParam }) =>\n      lastValueFrom(\n        http.get<InferRouteResult<TRoute>>(\n          buildUrl(url, buildQuery(context) as Record<string, any>),\n        ),\n      ),\n  } as CreateInfiniteQueryOptions<\n    InferRouteResult<TRoute>,\n    TError,\n    TData,\n    TQueryKey,\n    TPageParam\n  >;\n}\n"],"mappings":";;;AAiBA,SAAS,SAAS,MAAc,QAA0C;AACxE,KAAK,CAAA,OACC,QAAkB;CACxB,MAAK,QAAY,EAAA;AACf,MAAI,MAAA,CAAU,KAAA,UAAa,OAAA,QAAgB,OAAA,EAAA;AACrC,MAAI,UAAA,KAAA,KAAuB,UAAA,KACvB;EACH,MAAM,IAAA,mBAAe,IAAA;AACxB,MAAM,MAAQ,QAAK,MAAA,CAAA,MAAA,MAAA,QAAA,MAEhB,OAAA,KAAA,GAAA,EAAA,GAAA,mBAAA,OAAA,KAAA,CAAA,GAAA;MAIC,OAAA,KAAW,GAAG,EAAA,GAAA,mBAAO,OAAA,MAAA,CAAA,GAAA;;wBAK1B,QAAA;AAcL,QAAO,GAAA,OADW,KAAA,SAAS,IAAA,GAAA,MAAA,MACpB,MAAA,KAAA,IAAA;;SAEL,mBAEI,MACE,KAAA,SAAc;CAGrB,MAAA,EAAA,OAAA,GAAA,SAAA;;EAGI,GAAA;EAsBE,eAAA,cAAA,KAAA,IAAA,SAAA,KAAA,MAAA,CAAA,CAAA;EACL;;SAGD,sBAAA,MAAA,KAAA,SAAA;;EAQI,aAAS,SAAA,cAOd,KACA,KACA,KAAA,KAwBA,CAAA;EACM,GAAE;EACR;;SAEY,2BAED,MACH,KAAA,SAAc;CAGrB,MAAA,EAAA,OAAA,YAAA,GAAA,SAAA"}

package/fesm2022/analogjs-router-tokens.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"analogjs-router-tokens.mjs","names":[],"sources":["../../tokens/src/index.ts"],"sourcesContent":["import { InjectionToken, inject } from '@angular/core';\nimport type { $Fetch } from 'nitro/types';\nimport type {\n  IncomingMessage,\n  ServerResponse as NodeServerResponse,\n} from 'node:http';\n\nexport type ServerRequest = IncomingMessage & { originalUrl: string };\nexport type ServerResponse = NodeServerResponse;\nexport type ServerInternalFetch = $Fetch;\nexport type ServerContext = {\n  req: ServerRequest;\n  res: ServerResponse;\n  fetch?: ServerInternalFetch;\n};\n\nexport const REQUEST: InjectionToken<ServerRequest> =\n  new InjectionToken<ServerRequest>('@analogjs/router Server Request');\nexport const RESPONSE: InjectionToken<ServerResponse> =\n  new InjectionToken<ServerResponse>('@analogjs/router Server Response');\nexport const BASE_URL: InjectionToken<string> = new InjectionToken<string>(\n  '@analogjs/router Base URL',\n);\nexport const INTERNAL_FETCH: InjectionToken<ServerInternalFetch> =\n  new InjectionToken<ServerInternalFetch>(\n    '@analogjs/router Internal Server Fetch',\n  );\n\nexport const API_PREFIX: InjectionToken<string> = new InjectionToken<string>(\n  '@analogjs/router API Prefix',\n);\n\nexport function injectRequest(): ServerRequest | null {\n  return inject(REQUEST, { optional: true });\n}\n\nexport function injectResponse(): ServerResponse | null {\n  return inject(RESPONSE, { optional: true });\n}\n\nexport function injectBaseURL(): string | null {\n  return inject(BASE_URL, { optional: true });\n}\n\nexport function injectInternalServerFetch(): ServerInternalFetch | null {\n  return inject(INTERNAL_FETCH, { optional: true });\n}\n\nexport function injectAPIPrefix(): string {\n  return inject(API_PREFIX);\n}\n"],"mappings":";;AAgBA,IAAa,UACX,IAAI,eAA8B,kCAAkC;AACtE,IAAa,WACX,IAAI,eAA+B,mCAAmC;AACxE,IAAa,WAAmC,IAAI,eAClD,4BACD;AACD,IAAa,iBACX,IAAI,eACF,yCACD;AAEH,IAAa,aAAqC,IAAI,eACpD,8BACD;AAED,SAAgB,gBAAsC;AACpD,QAAO,OAAO,SAAW,EAAA,UAAU,MAAO,CAAA;;AAG5C,SAAgB,iBAAwC;AACtD,QAAO,OAAO,UAAY,EAAA,UAAU,MAAO,CAAA;;AAG7C,SAAgB,gBAA+B;AAC7C,QAAO,OAAO,UAAY,EAAA,UAAU,MAAO,CAAA;;AAG7C,SAAgB,4BAAwD;AACtE,QAAO,OAAO,gBAAkB,EAAA,UAAU,MAAO,CAAA;;AAGnD,SAAgB,kBAA0B;AACxC,QAAO,OAAO,WAAW"}