@analogjs/router 3.0.0-alpha.56 → 3.0.0-alpha.58

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

@@ -1,335 +1,2 @@
-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
+import { a as fail, i as validateWithSchema, n as defineServerRoute, o as json, r as defineAction, s as redirect, t as definePageLoad } from "./src.mjs";
 export { defineAction, definePageLoad, defineServerRoute, fail, json, redirect, validateWithSchema };
-
-//# sourceMappingURL=analogjs-router-server-actions.mjs.map

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

@@ -1,22 +1,71 @@
-import { t as ANALOG_QUERY_STATE_KEY } from "./provide-analog-query.mjs";
-import { TransferState, makeEnvironmentProviders } from "@angular/core";
+import { r as ANALOG_QUERIES_KEY, t as ANALOG_QUERY_STATE_KEY } from "./provide-analog-query.mjs";
+import { t as definePageLoad } from "./src.mjs";
+import { ApplicationRef, ENVIRONMENT_INITIALIZER, TransferState, inject, makeEnvironmentProviders } from "@angular/core";
+import { filter, skipWhile, take } from "rxjs/operators";
 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]);
+	return makeEnvironmentProviders([{
+		provide: ENVIRONMENT_INITIALIZER,
+		multi: true,
+		useValue() {
+			const appRef = inject(ApplicationRef);
+			const queryClient = inject(QueryClient);
+			const transferState = inject(TransferState);
+			const subscription = appRef.isStable.pipe(skipWhile((stable) => stable), filter((stable) => stable), take(1)).subscribe(() => {
+				transferState.set(ANALOG_QUERY_STATE_KEY, dehydrate(queryClient));
+			});
+			appRef.onDestroy(() => subscription.unsubscribe());
+		}
+	}]);
 }
 //#endregion
-export { provideServerAnalogQuery };
+//#region packages/router/tanstack-query/server/src/define-page-load-queries.ts
+/**
+* Page load helper that prefetches TanStack Query queries inside the
+* `.server.ts` handler and ships the dehydrated cache alongside any
+* additional data. The router-side hydrator in `provideAnalogQuery()`
+* merges the dehydrated payload into the active `QueryClient` on
+* `ResolveEnd`, so components reading the same query options see a
+* warm cache on first render.
+*
+* @example
+* ```ts
+* // src/app/pages/posts.server.ts
+* import { definePageLoadQueries } from '@analogjs/router/tanstack-query/server';
+* import { queryOptions } from '@tanstack/angular-query-experimental';
+*
+* export const postsQuery = queryOptions({
+*   queryKey: ['posts'],
+*   queryFn: async ({ signal }) =>
+*     fetch('https://api.example.com/posts', { signal }).then((r) => r.json()),
+* });
+*
+* export const load = definePageLoadQueries({
+*   handler: async ({ client }) => {
+*     await client.prefetchQuery(postsQuery);
+*   },
+* });
+* ```
+*/
+function definePageLoadQueries(options) {
+	return definePageLoad({
+		params: options.params,
+		query: options.query,
+		handler: async (ctx) => {
+			const client = options.client?.() ?? new QueryClient();
+			const data = await options.handler({
+				...ctx,
+				client
+			});
+			return {
+				[ANALOG_QUERIES_KEY]: dehydrate(client),
+				data
+			};
+		}
+	});
+}
+//#endregion
+export { ANALOG_QUERIES_KEY, definePageLoadQueries, provideServerAnalogQuery };
 
 //# sourceMappingURL=analogjs-router-tanstack-query-server.mjs.map

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

@@ -1 +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"}
+{"version":3,"file":"analogjs-router-tanstack-query-server.mjs","names":[],"sources":["../../tanstack-query/src/provide-server-analog-query.ts","../../tanstack-query/server/src/define-page-load-queries.ts"],"sourcesContent":["import {\n  ApplicationRef,\n  ENVIRONMENT_INITIALIZER,\n  TransferState,\n  inject,\n  makeEnvironmentProviders,\n} from '@angular/core';\nimport type { EnvironmentProviders } from '@angular/core';\nimport { filter, skipWhile, take } from 'rxjs/operators';\nimport { QueryClient, dehydrate } from '@tanstack/angular-query-experimental';\n\nimport { ANALOG_QUERY_STATE_KEY } from './provide-analog-query';\n\nexport function provideServerAnalogQuery(): EnvironmentProviders {\n  return makeEnvironmentProviders([\n    {\n      provide: ENVIRONMENT_INITIALIZER,\n      multi: true,\n      useValue() {\n        // Dehydrate the QueryClient into `TransferState` once the app\n        // becomes stable POST-RENDER on the server. `renderApplication`\n        // awaits `whenStable()` itself before invoking\n        // `BEFORE_APP_SERIALIZED` (which is where Angular's\n        // `TRANSFER_STATE_SERIALIZATION_PROVIDERS` reads the store and\n        // writes the `ng-state` script). Settling our write at the same\n        // point — but ahead of Angular's own subscriber — lets the\n        // dehydrated cache land in `TransferState` before the serializer\n        // snapshots it, so component-issued queries make it to the client\n        // without depending on provider declaration order.\n        //\n        // `skipWhile(stable => stable)` waits past the initial \"no\n        // pending tasks yet\" emission `BehaviorSubject` semantics give\n        // us at subscribe time; the next stable transition is the\n        // post-render one with all queries settled.\n        const appRef = inject(ApplicationRef);\n        const queryClient = inject(QueryClient);\n        const transferState = inject(TransferState);\n\n        const subscription = appRef.isStable\n          .pipe(\n            skipWhile((stable) => stable),\n            filter((stable) => stable),\n            take(1),\n          )\n          .subscribe(() => {\n            transferState.set(ANALOG_QUERY_STATE_KEY, dehydrate(queryClient));\n          });\n\n        appRef.onDestroy(() => subscription.unsubscribe());\n      },\n    },\n  ]);\n}\n","import type { StandardSchemaV1 } from '@standard-schema/spec';\nimport { QueryClient, dehydrate } from '@tanstack/angular-query-experimental';\nimport type { DehydratedState } from '@tanstack/angular-query-experimental';\nimport type { H3Event, H3EventContext } from 'nitro/h3';\nimport type { $Fetch } from 'nitro/types';\n\nimport {\n  definePageLoad,\n  type PageLoadContext,\n} from '../../../server/actions/src/index.js';\nimport { ANALOG_QUERIES_KEY } from '../../src/constants.js';\n\nexport { ANALOG_QUERIES_KEY } from '../../src/constants.js';\n\ntype NodeContext = NonNullable<H3Event['node']>;\ntype OptionalSchema = StandardSchemaV1 | undefined;\n\nexport interface PageLoadQueriesResult<TData> {\n  __analogQueries: DehydratedState;\n  data: TData;\n}\n\nexport interface DefinePageLoadQueriesOptions<\n  TParamsSchema extends OptionalSchema,\n  TQuerySchema extends OptionalSchema,\n  TData,\n> {\n  params?: TParamsSchema;\n  query?: TQuerySchema;\n  /**\n   * Optional QueryClient factory. Defaults to `new QueryClient()`.\n   * Override to set `defaultOptions` (e.g. `queries: { staleTime: Infinity }`).\n   */\n  client?: () => QueryClient;\n  /**\n   * Handler receives the standard PageLoadContext plus a per-request\n   * QueryClient. Use `client.prefetchQuery` / `ensureQueryData` /\n   * `prefetchInfiniteQuery` to warm the cache; the dehydrated client\n   * is returned as `__analogQueries` on the load result. Anything you\n   * return from the handler becomes `data` on the same result.\n   */\n  handler: (\n    ctx: PageLoadContext<TParamsSchema, TQuerySchema> & { client: QueryClient },\n  ) => Promise<TData> | TData;\n}\n\n/**\n * Page load helper that prefetches TanStack Query queries inside the\n * `.server.ts` handler and ships the dehydrated cache alongside any\n * additional data. The router-side hydrator in `provideAnalogQuery()`\n * merges the dehydrated payload into the active `QueryClient` on\n * `ResolveEnd`, so components reading the same query options see a\n * warm cache on first render.\n *\n * @example\n * ```ts\n * // src/app/pages/posts.server.ts\n * import { definePageLoadQueries } from '@analogjs/router/tanstack-query/server';\n * import { queryOptions } from '@tanstack/angular-query-experimental';\n *\n * export const postsQuery = queryOptions({\n *   queryKey: ['posts'],\n *   queryFn: async ({ signal }) =>\n *     fetch('https://api.example.com/posts', { signal }).then((r) => r.json()),\n * });\n *\n * export const load = definePageLoadQueries({\n *   handler: async ({ client }) => {\n *     await client.prefetchQuery(postsQuery);\n *   },\n * });\n * ```\n */\nexport function definePageLoadQueries<\n  TParamsSchema extends OptionalSchema = undefined,\n  TQuerySchema extends OptionalSchema = undefined,\n  TData = void,\n>(\n  options: DefinePageLoadQueriesOptions<TParamsSchema, TQuerySchema, TData>,\n): (ctx: {\n  params: H3EventContext['params'];\n  req: NodeContext['req'];\n  res: NonNullable<NodeContext['res']>;\n  fetch: $Fetch;\n  event: H3Event;\n}) => Promise<PageLoadQueriesResult<TData> | Response> {\n  return definePageLoad({\n    params: options.params,\n    query: options.query,\n    handler: async (ctx): Promise<PageLoadQueriesResult<TData>> => {\n      const client = options.client?.() ?? new QueryClient();\n      const data = await options.handler({ ...ctx, client });\n      return {\n        [ANALOG_QUERIES_KEY]: dehydrate(client),\n        data,\n      };\n    },\n  });\n}\n"],"mappings":";;;;;;AAaA,SAAgB,2BAAiD;AAC/D,QAAO,yBACL,CACE;EACO,SAAA;EACP,OAAW;EAgBH,WAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACuCvB,SAAgB,sBAKd,SAOqD;AACrD,QAAO,eAAe;EACpB,QAAQ,QAAQ;EAChB,OAAO,QAAQ;EACf,SAAS,OAAO,QAA+C;GACvD,MAAS,SAAQ,QAAA,UAAkB,IAAA,IAAA,aAAa;GAChD,MAAO,OAAM,MAAQ,QAAQ,QAAA;IAAA,GAAA;IAAA;IAAA,CAAA;AAAK,UAAA;KAAK,qBAAA,UAAA,OAAA;IAAS;IAC/C;;EAEL,CAAA"}

package/fesm2022/analogjs-router.mjs

@@ -356,7 +356,7 @@ var FormAction = class FormAction {
 	static {
 		this.ɵfac = i0.ɵɵngDeclareFactory({
 			minVersion: "12.0.0",
-			version: "21.2.8",
+			version: "22.0.0",
 			ngImport: i0,
 			type: FormAction,
 			deps: [],
@@ -366,7 +366,7 @@ var FormAction = class FormAction {
 	static {
 		this.ɵdir = i0.ɵɵngDeclareDirective({
 			minVersion: "17.1.0",
-			version: "21.2.8",
+			version: "22.0.0",
 			type: FormAction,
 			isStandalone: true,
 			selector: "form[action],form[method]",
@@ -395,7 +395,7 @@ var FormAction = class FormAction {
 };
 i0.ɵɵngDeclareClassMetadata({
 	minVersion: "12.0.0",
-	version: "21.2.8",
+	version: "22.0.0",
 	ngImport: i0,
 	type: FormAction,
 	decorators: [{
@@ -513,7 +513,7 @@ var ServerOnly = class ServerOnly {
 	static {
 		this.ɵfac = i0.ɵɵngDeclareFactory({
 			minVersion: "12.0.0",
-			version: "21.2.8",
+			version: "22.0.0",
 			ngImport: i0,
 			type: ServerOnly,
 			deps: [],
@@ -523,7 +523,7 @@ var ServerOnly = class ServerOnly {
 	static {
 		this.ɵcmp = i0.ɵɵngDeclareComponent({
 			minVersion: "17.1.0",
-			version: "21.2.8",
+			version: "22.0.0",
 			type: ServerOnly,
 			isStandalone: true,
 			selector: "server-only,ServerOnly,Server",
@@ -553,7 +553,7 @@ var ServerOnly = class ServerOnly {
 };
 i0.ɵɵngDeclareClassMetadata({
 	minVersion: "12.0.0",
-	version: "21.2.8",
+	version: "22.0.0",
 	ngImport: i0,
 	type: ServerOnly,
 	decorators: [{