astro 5.16.5 → 6.0.0-alpha.1

package/templates/content/types.d.ts

@@ -15,21 +15,13 @@ declare module 'astro:content' {
 			[key: string]: unknown;
 		};
 	}
-}
 
-declare module 'astro:content' {
 	type Flatten<T> = T extends { [K: string]: infer U } ? U : never;
 
-	export type CollectionKey = keyof AnyEntryMap;
-	export type CollectionEntry<C extends CollectionKey> = Flatten<AnyEntryMap[C]>;
-
-	export type ContentCollectionKey = keyof ContentEntryMap;
-	export type DataCollectionKey = keyof DataEntryMap;
+	export type CollectionKey = keyof DataEntryMap;
+	export type CollectionEntry<C extends CollectionKey> = Flatten<DataEntryMap[C]>;
 
 	type AllValuesOf<T> = T extends any ? T[keyof T] : never;
-	type ValidContentEntrySlug<C extends keyof ContentEntryMap> = AllValuesOf<
-		ContentEntryMap[C]
-	>['slug'];
 
 	export type ReferenceDataEntry<
 		C extends CollectionKey,
@@ -38,41 +30,17 @@ declare module 'astro:content' {
 		collection: C;
 		id: E;
 	};
-	export type ReferenceContentEntry<
-		C extends keyof ContentEntryMap,
-		E extends ValidContentEntrySlug<C> | (string & {}) = string,
-	> = {
-		collection: C;
-		slug: E;
-	};
+
 	export type ReferenceLiveEntry<C extends keyof LiveContentConfig['collections']> = {
 		collection: C;
 		id: string;
 	};
 
-	/** @deprecated Use `getEntry` instead. */
-	export function getEntryBySlug<
-		C extends keyof ContentEntryMap,
-		E extends ValidContentEntrySlug<C> | (string & {}),
-	>(
-		collection: C,
-		// Note that this has to accept a regular string too, for SSR
-		entrySlug: E,
-	): E extends ValidContentEntrySlug<C>
-		? Promise<CollectionEntry<C>>
-		: Promise<CollectionEntry<C> | undefined>;
-
-	/** @deprecated Use `getEntry` instead. */
-	export function getDataEntryById<C extends keyof DataEntryMap, E extends keyof DataEntryMap[C]>(
-		collection: C,
-		entryId: E,
-	): Promise<CollectionEntry<C>>;
-
-	export function getCollection<C extends keyof AnyEntryMap, E extends CollectionEntry<C>>(
+	export function getCollection<C extends keyof DataEntryMap, E extends CollectionEntry<C>>(
 		collection: C,
 		filter?: (entry: CollectionEntry<C>) => entry is E,
 	): Promise<E[]>;
-	export function getCollection<C extends keyof AnyEntryMap>(
+	export function getCollection<C extends keyof DataEntryMap>(
 		collection: C,
 		filter?: (entry: CollectionEntry<C>) => unknown,
 	): Promise<CollectionEntry<C>[]>;
@@ -84,14 +52,6 @@ declare module 'astro:content' {
 		import('astro').LiveDataCollectionResult<LiveLoaderDataType<C>, LiveLoaderErrorType<C>>
 	>;
 
-	export function getEntry<
-		C extends keyof ContentEntryMap,
-		E extends ValidContentEntrySlug<C> | (string & {}),
-	>(
-		entry: ReferenceContentEntry<C, E>,
-	): E extends ValidContentEntrySlug<C>
-		? Promise<CollectionEntry<C>>
-		: Promise<CollectionEntry<C> | undefined>;
 	export function getEntry<
 		C extends keyof DataEntryMap,
 		E extends keyof DataEntryMap[C] | (string & {}),
@@ -100,15 +60,6 @@ declare module 'astro:content' {
 	): E extends keyof DataEntryMap[C]
 		? Promise<DataEntryMap[C][E]>
 		: Promise<CollectionEntry<C> | undefined>;
-	export function getEntry<
-		C extends keyof ContentEntryMap,
-		E extends ValidContentEntrySlug<C> | (string & {}),
-	>(
-		collection: C,
-		slug: E,
-	): E extends ValidContentEntrySlug<C>
-		? Promise<CollectionEntry<C>>
-		: Promise<CollectionEntry<C> | undefined>;
 	export function getEntry<
 		C extends keyof DataEntryMap,
 		E extends keyof DataEntryMap[C] | (string & {}),
@@ -126,47 +77,51 @@ declare module 'astro:content' {
 	): Promise<import('astro').LiveDataEntryResult<LiveLoaderDataType<C>, LiveLoaderErrorType<C>>>;
 
 	/** Resolve an array of entry references from the same collection */
-	export function getEntries<C extends keyof ContentEntryMap>(
-		entries: ReferenceContentEntry<C, ValidContentEntrySlug<C>>[],
-	): Promise<CollectionEntry<C>[]>;
 	export function getEntries<C extends keyof DataEntryMap>(
 		entries: ReferenceDataEntry<C, keyof DataEntryMap[C]>[],
 	): Promise<CollectionEntry<C>[]>;
 
-	export function render<C extends keyof AnyEntryMap>(
-		entry: AnyEntryMap[C][string],
+	export function render<C extends keyof DataEntryMap>(
+		entry: DataEntryMap[C][string],
 	): Promise<RenderResult>;
 
-	export function reference<C extends keyof AnyEntryMap>(
+	export function reference<
+		C extends
+			| keyof DataEntryMap
+			// Allow generic `string` to avoid excessive type errors in the config
+			// if `dev` is not running to update as you edit.
+			// Invalid collection names will be caught at build time.
+			| (string & {}),
+	>(
 		collection: C,
-	): import('astro/zod').ZodEffects<
+	): import('astro/zod').ZodPipe<
 		import('astro/zod').ZodString,
-		C extends keyof ContentEntryMap
-			? ReferenceContentEntry<C, ValidContentEntrySlug<C>>
-			: ReferenceDataEntry<C, keyof DataEntryMap[C]>
+		import('astro/zod').ZodTransform<
+			C extends keyof DataEntryMap
+				? {
+						collection: C;
+						id: string;
+					}
+				: never,
+			string
+		>
 	>;
-	// Allow generic `string` to avoid excessive type errors in the config
-	// if `dev` is not running to update as you edit.
-	// Invalid collection names will be caught at build time.
-	export function reference<C extends string>(
-		collection: C,
-	): import('astro/zod').ZodEffects<import('astro/zod').ZodString, never>;
 
 	type ReturnTypeOrOriginal<T> = T extends (...args: any[]) => infer R ? R : T;
-	type InferEntrySchema<C extends keyof AnyEntryMap> = import('astro/zod').infer<
+	type InferEntrySchema<C extends keyof DataEntryMap> = import('astro/zod').infer<
 		ReturnTypeOrOriginal<Required<ContentConfig['collections'][C]>['schema']>
 	>;
-
-	type ContentEntryMap = {
-		// @@CONTENT_ENTRY_MAP@@
-	};
+	type InferLoaderSchema<
+		C extends keyof DataEntryMap,
+		L = Required<ContentConfig['collections'][C]>['loader'],
+	> = L extends { schema: import('astro/zod').ZodSchema }
+		? import('astro/zod').infer<Required<ContentConfig['collections'][C]>['loader']['schema']>
+		: any;
 
 	type DataEntryMap = {
 		// @@DATA_ENTRY_MAP@@
 	};
 
-	type AnyEntryMap = ContentEntryMap & DataEntryMap;
-
 	type ExtractLoaderTypes<T> = T extends import('astro/loaders').LiveLoader<
 		infer TData,
 		infer TEntryFilter,
@@ -175,7 +130,6 @@ declare module 'astro:content' {
 	>
 		? { data: TData; entryFilter: TEntryFilter; collectionFilter: TCollectionFilter; error: TError }
 		: { data: never; entryFilter: never; collectionFilter: never; error: never };
-	type ExtractDataType<T> = ExtractLoaderTypes<T>['data'];
 	type ExtractEntryFilterType<T> = ExtractLoaderTypes<T>['entryFilter'];
 	type ExtractCollectionFilterType<T> = ExtractLoaderTypes<T>['collectionFilter'];
 	type ExtractErrorType<T> = ExtractLoaderTypes<T>['error'];

package/types/actions.d.ts

@@ -1,7 +1,3 @@
 declare module 'astro:actions' {
-	export * from 'astro/actions/runtime/server.js';
-
-	export function getActionPath(
-		action: import('astro/actions/runtime/server.js').ActionClient<any, any, any>,
-	): string;
+	export * from 'astro/actions/runtime/entrypoints/server.js';
 }

package/types/content.d.ts

@@ -1,5 +1,5 @@
 declare module 'astro:content' {
-	export { z } from 'astro/zod';
+	import zod from 'astro/zod';
 	export type {
 		ImageFunction,
 		DataEntry,
@@ -8,17 +8,15 @@ declare module 'astro:content' {
 		BaseSchema,
 		SchemaContext,
 	} from 'astro/content/config';
+	export { defineLiveCollection, defineCollection } from 'astro/content/config';
 
-	export function defineLiveCollection<
-		L extends import('astro/loaders').LiveLoader,
-		S extends import('astro/content/config').BaseSchema | undefined = undefined,
-	>(
-		config: import('astro/content/config').LiveCollectionConfig<L, S>,
-	): import('astro/content/config').LiveCollectionConfig<L, S>;
-
-	export function defineCollection<S extends import('astro/content/config').BaseSchema>(
-		config: import('astro/content/config').CollectionConfig<S>,
-	): import('astro/content/config').CollectionConfig<S>;
+	// TODO: remove in Astro 7
+	/**
+	 * @deprecated
+	 * `import { z } from 'astro:content'` is deprecated and will be removed
+	 * in Astro 7. Use `import { z } from 'astro/zod'` instead.
+	 */
+	export const z = zod.z;
 
 	/** Run `astro dev` or `astro sync` to generate high fidelity types */
 	export const getEntryBySlug: (...args: any[]) => any;

package/types/transitions.d.ts

@@ -0,0 +1,25 @@
+declare module 'astro:transitions' {
+	export * from 'astro/virtual-modules/transitions.js';
+	export { default as ClientRouter } from 'astro/components/ClientRouter.astro';
+}
+
+declare module 'astro:transitions/client' {
+	export {
+		navigate,
+		supportsViewTransitions,
+		transitionEnabledOnThisPage,
+	} from 'astro/virtual-modules/transitions-router.js';
+	export * from 'astro/virtual-modules/transitions-types.js';
+	export {
+		TRANSITION_BEFORE_PREPARATION,
+		isTransitionBeforePreparationEvent,
+		TransitionBeforePreparationEvent,
+		TRANSITION_AFTER_PREPARATION,
+		TRANSITION_BEFORE_SWAP,
+		isTransitionBeforeSwapEvent,
+		TransitionBeforeSwapEvent,
+		TRANSITION_AFTER_SWAP,
+		TRANSITION_PAGE_LOAD,
+	} from 'astro/virtual-modules/transitions-events.js';
+	export { swapFunctions } from 'astro/virtual-modules/transitions-swap-functions.js';
+}

package/dist/actions/loadActions.d.ts

@@ -1,8 +0,0 @@
-import type { SSRActions } from '../core/app/types.js';
-import type { ModuleLoader } from '../core/module-loader/index.js';
-/**
- * It accepts a module loader and the astro settings, and it attempts to load the middlewares defined in the configuration.
- *
- * If not middlewares were not set, the function returns an empty array.
- */
-export declare function loadActions(moduleLoader: ModuleLoader): Promise<SSRActions>;

package/dist/actions/loadActions.js

@@ -1,13 +0,0 @@
-import { ActionsCantBeLoaded } from "../core/errors/errors-data.js";
-import { AstroError } from "../core/errors/index.js";
-import { ENTRYPOINT_VIRTUAL_MODULE_ID } from "./consts.js";
-async function loadActions(moduleLoader) {
-  try {
-    return await moduleLoader.import(ENTRYPOINT_VIRTUAL_MODULE_ID);
-  } catch (error) {
-    throw new AstroError(ActionsCantBeLoaded, { cause: error });
-  }
-}
-export {
-  loadActions
-};

package/dist/actions/runtime/route.d.ts

@@ -1,2 +0,0 @@
-import type { APIRoute } from '../../types/public/common.js';
-export declare const POST: APIRoute;

package/dist/actions/runtime/shared.d.ts

@@ -1,60 +0,0 @@
-import type { z } from 'zod';
-import { AstroError } from '../../core/errors/errors.js';
-import { appendForwardSlash as _appendForwardSlash } from '../../core/path.js';
-import type { ActionAPIContext as _ActionAPIContext, ErrorInferenceObject, MaybePromise } from './utils.js';
-export type ActionAPIContext = _ActionAPIContext;
-export declare const ACTION_QUERY_PARAMS: {
-    actionName: string;
-    actionPayload: string;
-};
-export declare const appendForwardSlash: typeof _appendForwardSlash;
-export declare const ACTION_ERROR_CODES: readonly ["BAD_REQUEST", "UNAUTHORIZED", "PAYMENT_REQUIRED", "FORBIDDEN", "NOT_FOUND", "METHOD_NOT_ALLOWED", "NOT_ACCEPTABLE", "PROXY_AUTHENTICATION_REQUIRED", "REQUEST_TIMEOUT", "CONFLICT", "GONE", "LENGTH_REQUIRED", "PRECONDITION_FAILED", "CONTENT_TOO_LARGE", "URI_TOO_LONG", "UNSUPPORTED_MEDIA_TYPE", "RANGE_NOT_SATISFIABLE", "EXPECTATION_FAILED", "MISDIRECTED_REQUEST", "UNPROCESSABLE_CONTENT", "LOCKED", "FAILED_DEPENDENCY", "TOO_EARLY", "UPGRADE_REQUIRED", "PRECONDITION_REQUIRED", "TOO_MANY_REQUESTS", "REQUEST_HEADER_FIELDS_TOO_LARGE", "UNAVAILABLE_FOR_LEGAL_REASONS", "INTERNAL_SERVER_ERROR", "NOT_IMPLEMENTED", "BAD_GATEWAY", "SERVICE_UNAVAILABLE", "GATEWAY_TIMEOUT", "HTTP_VERSION_NOT_SUPPORTED", "VARIANT_ALSO_NEGOTIATES", "INSUFFICIENT_STORAGE", "LOOP_DETECTED", "NETWORK_AUTHENTICATION_REQUIRED"];
-export type ActionErrorCode = (typeof ACTION_ERROR_CODES)[number];
-export declare class ActionError<_T extends ErrorInferenceObject = ErrorInferenceObject> extends Error {
-    type: string;
-    code: ActionErrorCode;
-    status: number;
-    constructor(params: {
-        message?: string;
-        code: ActionErrorCode;
-        stack?: string;
-    });
-    static codeToStatus(code: ActionErrorCode): number;
-    static statusToCode(status: number): ActionErrorCode;
-    static fromJson(body: any): ActionError<ErrorInferenceObject>;
-}
-export declare function isActionError(error?: unknown): error is ActionError;
-export declare function isInputError<T extends ErrorInferenceObject>(error?: ActionError<T>): error is ActionInputError<T>;
-export declare function isInputError(error?: unknown): error is ActionInputError<ErrorInferenceObject>;
-export type SafeResult<TInput extends ErrorInferenceObject, TOutput> = {
-    data: TOutput;
-    error: undefined;
-} | {
-    data: undefined;
-    error: ActionError<TInput>;
-};
-export declare class ActionInputError<T extends ErrorInferenceObject> extends ActionError {
-    type: string;
-    issues: z.ZodIssue[];
-    fields: z.ZodError<T>['formErrors']['fieldErrors'];
-    constructor(issues: z.ZodIssue[]);
-}
-export declare function callSafely<TOutput>(handler: () => MaybePromise<TOutput>): Promise<SafeResult<z.ZodType, TOutput>>;
-export declare function getActionQueryString(name: string): string;
-export type SerializedActionResult = {
-    type: 'data';
-    contentType: 'application/json+devalue';
-    status: 200;
-    body: string;
-} | {
-    type: 'error';
-    contentType: 'application/json';
-    status: number;
-    body: string;
-} | {
-    type: 'empty';
-    status: 204;
-};
-export declare function serializeActionResult(res: SafeResult<any, any>): SerializedActionResult;
-export declare function deserializeActionResult(res: SerializedActionResult): SafeResult<any, any>;
-export declare function astroCalledServerError(): AstroError;

package/dist/actions/runtime/shared.js

@@ -1,296 +0,0 @@
-import { parse as devalueParse, stringify as devalueStringify } from "devalue";
-import { REDIRECT_STATUS_CODES } from "../../core/constants.js";
-import { AstroError } from "../../core/errors/errors.js";
-import {
-  ActionCalledFromServerError,
-  ActionsReturnedInvalidDataError
-} from "../../core/errors/errors-data.js";
-import { appendForwardSlash as _appendForwardSlash } from "../../core/path.js";
-import { ACTION_QUERY_PARAMS as _ACTION_QUERY_PARAMS } from "../consts.js";
-const ACTION_QUERY_PARAMS = _ACTION_QUERY_PARAMS;
-const appendForwardSlash = _appendForwardSlash;
-const ACTION_ERROR_CODES = [
-  "BAD_REQUEST",
-  "UNAUTHORIZED",
-  "PAYMENT_REQUIRED",
-  "FORBIDDEN",
-  "NOT_FOUND",
-  "METHOD_NOT_ALLOWED",
-  "NOT_ACCEPTABLE",
-  "PROXY_AUTHENTICATION_REQUIRED",
-  "REQUEST_TIMEOUT",
-  "CONFLICT",
-  "GONE",
-  "LENGTH_REQUIRED",
-  "PRECONDITION_FAILED",
-  "CONTENT_TOO_LARGE",
-  "URI_TOO_LONG",
-  "UNSUPPORTED_MEDIA_TYPE",
-  "RANGE_NOT_SATISFIABLE",
-  "EXPECTATION_FAILED",
-  "MISDIRECTED_REQUEST",
-  "UNPROCESSABLE_CONTENT",
-  "LOCKED",
-  "FAILED_DEPENDENCY",
-  "TOO_EARLY",
-  "UPGRADE_REQUIRED",
-  "PRECONDITION_REQUIRED",
-  "TOO_MANY_REQUESTS",
-  "REQUEST_HEADER_FIELDS_TOO_LARGE",
-  "UNAVAILABLE_FOR_LEGAL_REASONS",
-  "INTERNAL_SERVER_ERROR",
-  "NOT_IMPLEMENTED",
-  "BAD_GATEWAY",
-  "SERVICE_UNAVAILABLE",
-  "GATEWAY_TIMEOUT",
-  "HTTP_VERSION_NOT_SUPPORTED",
-  "VARIANT_ALSO_NEGOTIATES",
-  "INSUFFICIENT_STORAGE",
-  "LOOP_DETECTED",
-  "NETWORK_AUTHENTICATION_REQUIRED"
-];
-const codeToStatusMap = {
-  // Implemented from IANA HTTP Status Code Registry
-  // https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
-  BAD_REQUEST: 400,
-  UNAUTHORIZED: 401,
-  PAYMENT_REQUIRED: 402,
-  FORBIDDEN: 403,
-  NOT_FOUND: 404,
-  METHOD_NOT_ALLOWED: 405,
-  NOT_ACCEPTABLE: 406,
-  PROXY_AUTHENTICATION_REQUIRED: 407,
-  REQUEST_TIMEOUT: 408,
-  CONFLICT: 409,
-  GONE: 410,
-  LENGTH_REQUIRED: 411,
-  PRECONDITION_FAILED: 412,
-  CONTENT_TOO_LARGE: 413,
-  URI_TOO_LONG: 414,
-  UNSUPPORTED_MEDIA_TYPE: 415,
-  RANGE_NOT_SATISFIABLE: 416,
-  EXPECTATION_FAILED: 417,
-  MISDIRECTED_REQUEST: 421,
-  UNPROCESSABLE_CONTENT: 422,
-  LOCKED: 423,
-  FAILED_DEPENDENCY: 424,
-  TOO_EARLY: 425,
-  UPGRADE_REQUIRED: 426,
-  PRECONDITION_REQUIRED: 428,
-  TOO_MANY_REQUESTS: 429,
-  REQUEST_HEADER_FIELDS_TOO_LARGE: 431,
-  UNAVAILABLE_FOR_LEGAL_REASONS: 451,
-  INTERNAL_SERVER_ERROR: 500,
-  NOT_IMPLEMENTED: 501,
-  BAD_GATEWAY: 502,
-  SERVICE_UNAVAILABLE: 503,
-  GATEWAY_TIMEOUT: 504,
-  HTTP_VERSION_NOT_SUPPORTED: 505,
-  VARIANT_ALSO_NEGOTIATES: 506,
-  INSUFFICIENT_STORAGE: 507,
-  LOOP_DETECTED: 508,
-  NETWORK_AUTHENTICATION_REQUIRED: 511
-};
-const statusToCodeMap = Object.entries(codeToStatusMap).reduce(
-  // reverse the key-value pairs
-  (acc, [key, value]) => ({ ...acc, [value]: key }),
-  {}
-);
-class ActionError extends Error {
-  type = "AstroActionError";
-  code = "INTERNAL_SERVER_ERROR";
-  status = 500;
-  constructor(params) {
-    super(params.message);
-    this.code = params.code;
-    this.status = ActionError.codeToStatus(params.code);
-    if (params.stack) {
-      this.stack = params.stack;
-    }
-  }
-  static codeToStatus(code) {
-    return codeToStatusMap[code];
-  }
-  static statusToCode(status) {
-    return statusToCodeMap[status] ?? "INTERNAL_SERVER_ERROR";
-  }
-  static fromJson(body) {
-    if (isInputError(body)) {
-      return new ActionInputError(body.issues);
-    }
-    if (isActionError(body)) {
-      return new ActionError(body);
-    }
-    return new ActionError({
-      code: "INTERNAL_SERVER_ERROR"
-    });
-  }
-}
-function isActionError(error) {
-  return typeof error === "object" && error != null && "type" in error && error.type === "AstroActionError";
-}
-function isInputError(error) {
-  return typeof error === "object" && error != null && "type" in error && error.type === "AstroActionInputError" && "issues" in error && Array.isArray(error.issues);
-}
-class ActionInputError extends ActionError {
-  type = "AstroActionInputError";
-  // We don't expose all ZodError properties.
-  // Not all properties will serialize from server to client,
-  // and we don't want to import the full ZodError object into the client.
-  issues;
-  fields;
-  constructor(issues) {
-    super({
-      message: `Failed to validate: ${JSON.stringify(issues, null, 2)}`,
-      code: "BAD_REQUEST"
-    });
-    this.issues = issues;
-    this.fields = {};
-    for (const issue of issues) {
-      if (issue.path.length > 0) {
-        const key = issue.path[0].toString();
-        this.fields[key] ??= [];
-        this.fields[key]?.push(issue.message);
-      }
-    }
-  }
-}
-async function callSafely(handler) {
-  try {
-    const data = await handler();
-    return { data, error: void 0 };
-  } catch (e) {
-    if (e instanceof ActionError) {
-      return { data: void 0, error: e };
-    }
-    return {
-      data: void 0,
-      error: new ActionError({
-        message: e instanceof Error ? e.message : "Unknown error",
-        code: "INTERNAL_SERVER_ERROR"
-      })
-    };
-  }
-}
-function getActionQueryString(name) {
-  const searchParams = new URLSearchParams({ [_ACTION_QUERY_PARAMS.actionName]: name });
-  return `?${searchParams.toString()}`;
-}
-function serializeActionResult(res) {
-  if (res.error) {
-    if (import.meta.env?.DEV) {
-      actionResultErrorStack.set(res.error.stack);
-    }
-    let body2;
-    if (res.error instanceof ActionInputError) {
-      body2 = {
-        type: res.error.type,
-        issues: res.error.issues,
-        fields: res.error.fields
-      };
-    } else {
-      body2 = {
-        ...res.error,
-        message: res.error.message
-      };
-    }
-    return {
-      type: "error",
-      status: res.error.status,
-      contentType: "application/json",
-      body: JSON.stringify(body2)
-    };
-  }
-  if (res.data === void 0) {
-    return {
-      type: "empty",
-      status: 204
-    };
-  }
-  let body;
-  try {
-    body = devalueStringify(res.data, {
-      // Add support for URL objects
-      URL: (value) => value instanceof URL && value.href
-    });
-  } catch (e) {
-    let hint = ActionsReturnedInvalidDataError.hint;
-    if (res.data instanceof Response) {
-      hint = REDIRECT_STATUS_CODES.includes(res.data.status) ? "If you need to redirect when the action succeeds, trigger a redirect where the action is called. See the Actions guide for server and client redirect examples: https://docs.astro.build/en/guides/actions." : "If you need to return a Response object, try using a server endpoint instead. See https://docs.astro.build/en/guides/endpoints/#server-endpoints-api-routes";
-    }
-    throw new AstroError({
-      ...ActionsReturnedInvalidDataError,
-      message: ActionsReturnedInvalidDataError.message(String(e)),
-      hint
-    });
-  }
-  return {
-    type: "data",
-    status: 200,
-    contentType: "application/json+devalue",
-    body
-  };
-}
-function deserializeActionResult(res) {
-  if (res.type === "error") {
-    let json;
-    try {
-      json = JSON.parse(res.body);
-    } catch {
-      return {
-        data: void 0,
-        error: new ActionError({
-          message: res.body,
-          code: "INTERNAL_SERVER_ERROR"
-        })
-      };
-    }
-    if (import.meta.env?.PROD) {
-      return { error: ActionError.fromJson(json), data: void 0 };
-    } else {
-      const error = ActionError.fromJson(json);
-      error.stack = actionResultErrorStack.get();
-      return {
-        error,
-        data: void 0
-      };
-    }
-  }
-  if (res.type === "empty") {
-    return { data: void 0, error: void 0 };
-  }
-  return {
-    data: devalueParse(res.body, {
-      URL: (href) => new URL(href)
-    }),
-    error: void 0
-  };
-}
-const actionResultErrorStack = /* @__PURE__ */ function actionResultErrorStackFn() {
-  let errorStack;
-  return {
-    set(stack) {
-      errorStack = stack;
-    },
-    get() {
-      return errorStack;
-    }
-  };
-}();
-function astroCalledServerError() {
-  return new AstroError(ActionCalledFromServerError);
-}
-export {
-  ACTION_ERROR_CODES,
-  ACTION_QUERY_PARAMS,
-  ActionError,
-  ActionInputError,
-  appendForwardSlash,
-  astroCalledServerError,
-  callSafely,
-  deserializeActionResult,
-  getActionQueryString,
-  isActionError,
-  isInputError,
-  serializeActionResult
-};

package/dist/actions/runtime/utils.d.ts

@@ -1,31 +0,0 @@
-import type { APIContext, AstroSharedContext } from '../../types/public/context.js';
-import type { SerializedActionResult } from './shared.js';
-export type ActionPayload = {
-    actionResult: SerializedActionResult;
-    actionName: string;
-};
-export type Locals = {
-    _actionPayload: ActionPayload;
-};
-export declare const ACTION_API_CONTEXT_SYMBOL: unique symbol;
-export declare const formContentTypes: string[];
-export declare function hasContentType(contentType: string, expected: string[]): boolean;
-export type ActionAPIContext = Pick<APIContext, 'rewrite' | 'request' | 'url' | 'isPrerendered' | 'locals' | 'clientAddress' | 'cookies' | 'currentLocale' | 'generator' | 'routePattern' | 'site' | 'params' | 'preferredLocale' | 'preferredLocaleList' | 'originPathname' | 'session' | 'csp'> & {
-    /**
-     * @deprecated
-     * The use of `rewrite` in Actions is deprecated
-     */
-    rewrite: AstroSharedContext['rewrite'];
-};
-export type MaybePromise<T> = T | Promise<T>;
-/**
- * Used to preserve the input schema type in the error object.
- * This allows for type inference on the `fields` property
- * when type narrowed to an `ActionInputError`.
- *
- * Example: Action has an input schema of `{ name: z.string() }`.
- * When calling the action and checking `isInputError(result.error)`,
- * `result.error.fields` will be typed with the `name` field.
- */
-export type ErrorInferenceObject = Record<string, any>;
-export declare function isActionAPIContext(ctx: ActionAPIContext): boolean;

package/dist/actions/runtime/utils.js

@@ -1,16 +0,0 @@
-const ACTION_API_CONTEXT_SYMBOL = Symbol.for("astro.actionAPIContext");
-const formContentTypes = ["application/x-www-form-urlencoded", "multipart/form-data"];
-function hasContentType(contentType, expected) {
-  const type = contentType.split(";")[0].toLowerCase();
-  return expected.some((t) => type === t);
-}
-function isActionAPIContext(ctx) {
-  const symbol = Reflect.get(ctx, ACTION_API_CONTEXT_SYMBOL);
-  return symbol === true;
-}
-export {
-  ACTION_API_CONTEXT_SYMBOL,
-  formContentTypes,
-  hasContentType,
-  isActionAPIContext
-};