astro 4.13.0 → 4.13.2

package/astro-jsx.d.ts

@@ -14,7 +14,6 @@ declare namespace astroHTML.JSX {
 	export type Children = Child | Child[];
 
 	interface ElementChildrenAttribute {
-		// eslint-disable-next-line @typescript-eslint/ban-types
 		children: {};
 	}
 

package/astro.js

@@ -52,6 +52,7 @@ async function errorNodeUnsupported() {
 Node.js v${process.versions.node} is not supported by Astro!
 Please upgrade Node.js to a supported version: "${engines}"\n`);
 
+	// eslint-disable-next-line @typescript-eslint/no-require-imports
 	const ci = typeof require !== 'undefined' ? require('ci-info') : await import('ci-info');
 
 	// Special instructions for CI environments, which may have special steps needed.
@@ -65,7 +66,7 @@ Please upgrade Node.js to a supported version: "${engines}"\n`);
 			}
 		}
 		console.log(
-			`${ci.name} CI Environment Detected!\nAdditional steps may be needed to set your Node.js version:`
+			`${ci.name} CI Environment Detected!\nAdditional steps may be needed to set your Node.js version:`,
 		);
 		console.log(`Documentation: https://docs.astro.build/en/guides/deploy/`);
 		if (CI_INSTRUCTIONS[platform]) {

package/client.d.ts

@@ -50,7 +50,7 @@ declare module 'astro:assets' {
 		 * This is functionally equivalent to using the `<Image />` component, as the component calls this function internally.
 		 */
 		getImage: (
-			options: import('./dist/assets/types.js').UnresolvedImageTransform
+			options: import('./dist/assets/types.js').UnresolvedImageTransform,
 		) => Promise<import('./dist/assets/types.js').GetImageResult>;
 		imageConfig: import('./dist/@types/astro.js').AstroConfig['image'];
 		getConfiguredImageService: typeof import('./dist/assets/index.js').getConfiguredImageService;

package/components/Picture.astro

@@ -53,8 +53,8 @@ const optimizedImages: GetImageResult[] = await Promise.all(
 				format: format,
 				widths: props.widths,
 				densities: props.densities,
-			})
-	)
+			}),
+	),
 );
 
 let resultFallbackFormat = fallbackFormat ?? defaultFallbackFormat;

package/components/ViewTransitions.astro

@@ -53,7 +53,7 @@ const { fallback = 'animate' } = Astro.props;
 	if (supportsViewTransitions || getFallback() !== 'none') {
 		if (import.meta.env.DEV && window.matchMedia('(prefers-reduced-motion)').matches) {
 			console.warn(
-				`[transitions]: all view transition animations, including fallback animation, are disabled as this device has the prefer-reduced-motion setting enabled.`
+				`[transitions]: all view transition animations, including fallback animation, are disabled as this device has the prefer-reduced-motion setting enabled.`,
 			);
 		}
 		document.addEventListener('click', (ev) => {

package/config.d.ts

@@ -17,7 +17,7 @@ export function defineConfig(config: AstroUserConfig): AstroUserConfig;
  */
 export function getViteConfig(
 	config: ViteUserConfig,
-	inlineAstroConfig?: AstroInlineConfig
+	inlineAstroConfig?: AstroInlineConfig,
 ): ViteUserConfigFn;
 
 /**

package/dist/@types/astro.d.ts

@@ -4,7 +4,7 @@ import type { MarkdownHeading, MarkdownVFile, RehypePlugins, RemarkPlugins, Rema
 import type * as babel from '@babel/core';
 import type * as rollup from 'rollup';
 import type * as vite from 'vite';
-import type { ActionAccept, ActionClient, ActionInputSchema } from '../actions/runtime/virtual/server.js';
+import type { ActionAccept, ActionClient, ActionInputSchema, ActionReturnType } from '../actions/runtime/virtual/server.js';
 import type { RemotePattern } from '../assets/utils/remotePattern.js';
 import type { AssetsPrefix, SSRManifest, SerializedSSRManifest } from '../core/app/types.js';
 import type { PageBuildData } from '../core/build/types.js';
@@ -182,6 +182,21 @@ export interface AstroGlobal<Props extends Record<string, any> = Record<string,
      * ```
      */
     getActionResult: AstroSharedContext['getActionResult'];
+    /**
+     * Call an Action directly from an Astro page or API endpoint.
+     * Expects the action function as the first parameter,
+     * and the type-safe action input as the second parameter.
+     * Returns a Promise with the action result.
+     *
+     * Example usage:
+     *
+     * ```typescript
+     * import { actions } from 'astro:actions';
+     *
+     * const result = await Astro.callAction(actions.getPost, { postId: 'test' });
+     * ```
+     */
+    callAction: AstroSharedContext['callAction'];
     /** Redirect to another page
      *
      * Example usage:
@@ -2491,7 +2506,11 @@ interface AstroSharedContext<Props extends Record<string, any> = Record<string,
     /**
      * Get action result on the server when using a form POST.
      */
-    getActionResult: <TAccept extends ActionAccept, TInputSchema extends ActionInputSchema<TAccept>, TAction extends ActionClient<unknown, TAccept, TInputSchema>>(action: TAction) => Awaited<ReturnType<TAction>> | undefined;
+    getActionResult: <TAccept extends ActionAccept, TInputSchema extends ActionInputSchema<TAccept>, TAction extends ActionClient<unknown, TAccept, TInputSchema>>(action: TAction) => ActionReturnType<TAction> | undefined;
+    /**
+     * Call action handler from the server.
+     */
+    callAction: <TAccept extends ActionAccept, TInputSchema extends ActionInputSchema<TAccept>, TOutput, TAction extends ActionClient<TOutput, TAccept, TInputSchema> | ActionClient<TOutput, TAccept, TInputSchema>['orThrow']>(action: TAction, input: Parameters<TAction>[0]) => Promise<ActionReturnType<TAction>>;
     /**
      * Route parameters for this request if this is a dynamic route.
      */

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

@@ -1,8 +1,8 @@
-import type { APIContext } from '../../@types/astro.js';
+import { type SerializedActionResult } from './virtual/shared.js';
 export type Locals = {
     _actionsInternal: {
-        getActionResult: APIContext['getActionResult'];
-        actionResult?: ReturnType<APIContext['getActionResult']>;
+        actionResult: SerializedActionResult;
+        actionName: string;
     };
 };
 export declare const onRequest: import("../../@types/astro.js").MiddlewareHandler;

package/dist/actions/runtime/middleware.js

@@ -1,34 +1,31 @@
 import { yellow } from "kleur/colors";
-import {
-  ActionQueryStringInvalidError,
-  ActionsUsedWithForGetError
-} from "../../core/errors/errors-data.js";
+import { ActionQueryStringInvalidError } from "../../core/errors/errors-data.js";
 import { AstroError } from "../../core/errors/errors.js";
 import { defineMiddleware } from "../../core/middleware/index.js";
-import { ApiContextStorage } from "./store.js";
-import { formContentTypes, getAction, hasContentType } from "./utils.js";
-import { getActionQueryString } from "./virtual/shared.js";
+import { formContentTypes, hasContentType } from "./utils.js";
+import { getAction } from "./virtual/get-action.js";
+import {
+  serializeActionResult
+} from "./virtual/shared.js";
 const onRequest = defineMiddleware(async (context, next) => {
   const locals = context.locals;
   const { request } = context;
-  if (locals._actionsInternal) return ApiContextStorage.run(context, () => next());
-  if (request.method === "POST" && request.body === null) {
-    return nextWithStaticStub(next, context);
+  if (locals._actionsInternal) return next();
+  if (import.meta.env.DEV && request.method === "POST" && request.body === null) {
+    console.warn(
+      yellow("[astro:actions]"),
+      'POST requests should not be sent to prerendered pages. If you\'re using Actions, disable prerendering with `export const prerender = "false".'
+    );
+    return next();
   }
   const actionName = context.url.searchParams.get("_astroAction");
   if (context.request.method === "POST" && actionName) {
     return handlePost({ context, next, actionName });
   }
-  if (context.request.method === "GET" && actionName) {
-    throw new AstroError({
-      ...ActionsUsedWithForGetError,
-      message: ActionsUsedWithForGetError.message(actionName)
-    });
-  }
   if (context.request.method === "POST") {
     return handlePostLegacy({ context, next });
   }
-  return nextWithLocalsStub(next, context);
+  return next();
 });
 async function handlePost({
   context,
@@ -36,8 +33,8 @@ async function handlePost({
   actionName
 }) {
   const { request } = context;
-  const action = await getAction(actionName);
-  if (!action) {
+  const baseAction = await getAction(actionName);
+  if (!baseAction) {
     throw new AstroError({
       ...ActionQueryStringInvalidError,
       message: ActionQueryStringInvalidError.message(actionName)
@@ -48,83 +45,53 @@ async function handlePost({
   if (contentType && hasContentType(contentType, formContentTypes)) {
     formData = await request.clone().formData();
   }
-  const actionResult = await ApiContextStorage.run(context, () => action(formData));
+  const action = baseAction.bind(context);
+  const actionResult = await action(formData);
   return handleResult({ context, next, actionName, actionResult });
 }
-function handleResult({
+async function handleResult({
   context,
   next,
   actionName,
   actionResult
 }) {
-  const actionsInternal = {
-    getActionResult: (actionFn) => {
-      if (actionFn.toString() !== getActionQueryString(actionName)) {
-        return Promise.resolve(void 0);
-      }
-      return actionResult;
-    },
-    actionResult
-  };
   const locals = context.locals;
-  Object.defineProperty(locals, "_actionsInternal", { writable: false, value: actionsInternal });
-  return ApiContextStorage.run(context, async () => {
-    const response = await next();
-    if (actionResult.error) {
-      return new Response(response.body, {
-        status: actionResult.error.status,
-        statusText: actionResult.error.type,
-        headers: response.headers
-      });
-    }
-    return response;
-  });
+  locals._actionsInternal = {
+    actionName,
+    actionResult: serializeActionResult(actionResult)
+  };
+  const response = await next();
+  if (actionResult.error) {
+    return new Response(response.body, {
+      status: actionResult.error.status,
+      statusText: actionResult.error.type,
+      headers: response.headers
+    });
+  }
+  return response;
 }
 async function handlePostLegacy({ context, next }) {
   const { request } = context;
-  if (context.url.pathname.startsWith("/_actions")) return nextWithLocalsStub(next, context);
+  if (context.url.pathname.startsWith("/_actions")) return next();
   const contentType = request.headers.get("content-type");
   let formData;
   if (contentType && hasContentType(contentType, formContentTypes)) {
     formData = await request.clone().formData();
   }
-  if (!formData) return nextWithLocalsStub(next, context);
+  if (!formData) return next();
   const actionName = formData.get("_astroAction");
-  if (!actionName) return nextWithLocalsStub(next, context);
-  const action = await getAction(actionName);
-  if (!action) {
+  if (!actionName) return next();
+  const baseAction = await getAction(actionName);
+  if (!baseAction) {
     throw new AstroError({
       ...ActionQueryStringInvalidError,
       message: ActionQueryStringInvalidError.message(actionName)
     });
   }
-  const actionResult = await ApiContextStorage.run(context, () => action(formData));
+  const action = baseAction.bind(context);
+  const actionResult = await action(formData);
   return handleResult({ context, next, actionName, actionResult });
 }
-function nextWithStaticStub(next, context) {
-  Object.defineProperty(context.locals, "_actionsInternal", {
-    writable: false,
-    value: {
-      getActionResult: () => {
-        console.warn(
-          yellow("[astro:actions]"),
-          "`getActionResult()` should not be called on prerendered pages. Astro can only handle actions for pages rendered on-demand."
-        );
-        return void 0;
-      }
-    }
-  });
-  return ApiContextStorage.run(context, () => next());
-}
-function nextWithLocalsStub(next, context) {
-  Object.defineProperty(context.locals, "_actionsInternal", {
-    writable: false,
-    value: {
-      getActionResult: () => void 0
-    }
-  });
-  return ApiContextStorage.run(context, () => next());
-}
 export {
   onRequest
 };

package/dist/actions/runtime/route.js

@@ -1,15 +1,16 @@
-import { ApiContextStorage } from "./store.js";
-import { formContentTypes, getAction, hasContentType } from "./utils.js";
+import { formContentTypes, hasContentType } from "./utils.js";
+import { getAction } from "./virtual/get-action.js";
+import { serializeActionResult } from "./virtual/shared.js";
 const POST = async (context) => {
   const { request, url } = context;
-  const action = await getAction(url.pathname);
-  if (!action) {
+  const baseAction = await getAction(url.pathname);
+  if (!baseAction) {
     return new Response(null, { status: 404 });
   }
   const contentType = request.headers.get("Content-Type");
   const contentLength = request.headers.get("Content-Length");
   let args;
-  if (contentLength === "0") {
+  if (!contentType || contentLength === "0") {
     args = void 0;
   } else if (contentType && hasContentType(contentType, formContentTypes)) {
     args = await request.clone().formData();
@@ -18,26 +19,18 @@ const POST = async (context) => {
   } else {
     return new Response(null, { status: 415 });
   }
-  const result = await ApiContextStorage.run(context, () => action(args));
-  if (result.error) {
-    return new Response(
-      JSON.stringify({
-        ...result.error,
-        message: result.error.message,
-        stack: import.meta.env.PROD ? void 0 : result.error.stack
-      }),
-      {
-        status: result.error.status,
-        headers: {
-          "Content-Type": "application/json"
-        }
-      }
-    );
+  const action = baseAction.bind(context);
+  const result = await action(args);
+  const serialized = serializeActionResult(result);
+  if (serialized.type === "empty") {
+    return new Response(null, {
+      status: serialized.status
+    });
   }
-  return new Response(JSON.stringify(result.data), {
-    status: result.data !== void 0 ? 200 : 204,
+  return new Response(serialized.body, {
+    status: serialized.status,
     headers: {
-      "Content-Type": "application/json"
+      "Content-Type": serialized.contentType
     }
   });
 };

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

@@ -1,14 +1,8 @@
-import type { ZodType } from 'zod';
-import type { ActionAccept, ActionClient } from './virtual/server.js';
+import type { APIContext } from '../../@types/astro.js';
 export declare const formContentTypes: string[];
 export declare function hasContentType(contentType: string, expected: string[]): boolean;
+export type ActionAPIContext = Omit<APIContext, 'getActionResult' | 'callAction' | 'props'>;
 export type MaybePromise<T> = T | Promise<T>;
-/**
- * Get server-side action based on the route path.
- * Imports from the virtual module `astro:internal-actions`, which maps to
- * the user's `src/actions/index.ts` file at build-time.
- */
-export declare function getAction(path: string): Promise<ActionClient<unknown, ActionAccept, ZodType> | undefined>;
 /**
  * Used to preserve the input schema type in the error object.
  * This allows for type inference on the `fields` property

package/dist/actions/runtime/utils.js

@@ -3,22 +3,7 @@ function hasContentType(contentType, expected) {
   const type = contentType.split(";")[0].toLowerCase();
   return expected.some((t) => type === t);
 }
-async function getAction(path) {
-  const pathKeys = path.replace("/_actions/", "").split(".");
-  let { server: actionLookup } = await import("astro:internal-actions");
-  for (const key of pathKeys) {
-    if (!(key in actionLookup)) {
-      return void 0;
-    }
-    actionLookup = actionLookup[key];
-  }
-  if (typeof actionLookup !== "function") {
-    return void 0;
-  }
-  return actionLookup;
-}
 export {
   formContentTypes,
-  getAction,
   hasContentType
 };

package/dist/actions/runtime/virtual/client.d.ts

@@ -1,4 +1,3 @@
 export * from './shared.js';
 export declare function defineAction(): void;
-export declare function getApiContext(): void;
 export declare const z: {};

package/dist/actions/runtime/virtual/client.js

@@ -2,9 +2,6 @@ export * from "./shared.js";
 function defineAction() {
   throw new Error("[astro:action] `defineAction()` unexpectedly used on the client.");
 }
-function getApiContext() {
-  throw new Error("[astro:action] `getApiContext()` unexpectedly used on the client.");
-}
 const z = new Proxy(
   {},
   {
@@ -15,6 +12,5 @@ const z = new Proxy(
 );
 export {
   defineAction,
-  getApiContext,
   z
 };

package/dist/actions/runtime/virtual/get-action.d.ts

@@ -0,0 +1,8 @@
+import type { ZodType } from 'zod';
+import type { ActionAccept, ActionClient } from './server.js';
+/**
+ * Get server-side action based on the route path.
+ * Imports from the virtual module `astro:internal-actions`, which maps to
+ * the user's `src/actions/index.ts` file at build-time.
+ */
+export declare function getAction(path: string): Promise<ActionClient<unknown, ActionAccept, ZodType> | undefined>;

package/dist/actions/runtime/virtual/get-action.js

@@ -0,0 +1,17 @@
+async function getAction(path) {
+  const pathKeys = path.replace("/_actions/", "").split(".");
+  let { server: actionLookup } = await import("astro:internal-actions");
+  for (const key of pathKeys) {
+    if (!(key in actionLookup)) {
+      return void 0;
+    }
+    actionLookup = actionLookup[key];
+  }
+  if (typeof actionLookup !== "function") {
+    return void 0;
+  }
+  return actionLookup;
+}
+export {
+  getAction
+};

package/dist/actions/runtime/virtual/server.d.ts

@@ -1,11 +1,8 @@
 import { z } from 'zod';
-import { type ActionAPIContext, getApiContext as _getApiContext } from '../store.js';
-import type { ErrorInferenceObject, MaybePromise } from '../utils.js';
+import type { ActionAPIContext, ErrorInferenceObject, MaybePromise } from '../utils.js';
 import { type SafeResult } from './shared.js';
 export * from './shared.js';
 export { z } from 'zod';
-/** @deprecated Access context from the second `handler()` parameter. */
-export declare const getApiContext: typeof _getApiContext;
 export type ActionAccept = 'form' | 'json';
 export type ActionInputSchema<T extends ActionAccept | undefined> = T extends 'form' ? z.AnyZodObject | z.ZodType<FormData> : z.ZodType;
 export type ActionHandler<TInputSchema, TOutput> = TInputSchema extends z.ZodType ? (input: z.infer<TInputSchema>, context: ActionAPIContext) => MaybePromise<TOutput> : (input: any, context: ActionAPIContext) => MaybePromise<TOutput>;

package/dist/actions/runtime/virtual/server.js

@@ -1,53 +1,61 @@
 import { z } from "zod";
-import { getApiContext as _getApiContext } from "../store.js";
+import { ActionCalledFromServerError } from "../../../core/errors/errors-data.js";
+import { AstroError } from "../../../core/errors/errors.js";
 import { ActionError, ActionInputError, callSafely } from "./shared.js";
 export * from "./shared.js";
 import { z as z2 } from "zod";
-const getApiContext = _getApiContext;
 function defineAction({
   accept,
   input: inputSchema,
   handler
 }) {
   const serverHandler = accept === "form" ? getFormServerHandler(handler, inputSchema) : getJsonServerHandler(handler, inputSchema);
-  const safeServerHandler = async (unparsedInput) => {
-    return callSafely(() => serverHandler(unparsedInput));
-  };
+  async function safeServerHandler(unparsedInput) {
+    if (typeof this === "function") {
+      throw new AstroError(ActionCalledFromServerError);
+    }
+    return callSafely(() => serverHandler(unparsedInput, this));
+  }
   Object.assign(safeServerHandler, {
-    orThrow: serverHandler
+    orThrow(unparsedInput) {
+      if (typeof this === "function") {
+        throw new AstroError(ActionCalledFromServerError);
+      }
+      return serverHandler(unparsedInput, this);
+    }
   });
   return safeServerHandler;
 }
 function getFormServerHandler(handler, inputSchema) {
-  return async (unparsedInput) => {
+  return async (unparsedInput, context) => {
     if (!(unparsedInput instanceof FormData)) {
       throw new ActionError({
         code: "UNSUPPORTED_MEDIA_TYPE",
         message: "This action only accepts FormData."
       });
     }
-    if (!(inputSchema instanceof z.ZodObject)) return await handler(unparsedInput, getApiContext());
+    if (!(inputSchema instanceof z.ZodObject)) return await handler(unparsedInput, context);
     const parsed = await inputSchema.safeParseAsync(formDataToObject(unparsedInput, inputSchema));
     if (!parsed.success) {
       throw new ActionInputError(parsed.error.issues);
     }
-    return await handler(parsed.data, getApiContext());
+    return await handler(parsed.data, context);
   };
 }
 function getJsonServerHandler(handler, inputSchema) {
-  return async (unparsedInput) => {
+  return async (unparsedInput, context) => {
     if (unparsedInput instanceof FormData) {
       throw new ActionError({
         code: "UNSUPPORTED_MEDIA_TYPE",
         message: "This action only accepts JSON."
       });
     }
-    if (!inputSchema) return await handler(unparsedInput, getApiContext());
+    if (!inputSchema) return await handler(unparsedInput, context);
     const parsed = await inputSchema.safeParseAsync(unparsedInput);
     if (!parsed.success) {
       throw new ActionInputError(parsed.error.issues);
     }
-    return await handler(parsed.data, getApiContext());
+    return await handler(parsed.data, context);
   };
 }
 function formDataToObject(formData, schema) {
@@ -87,6 +95,5 @@ function handleFormDataGet(key, formData, validator, baseValidator) {
 export {
   defineAction,
   formDataToObject,
-  getApiContext,
   z2 as z
 };

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

@@ -13,8 +13,9 @@ export declare class ActionError<T extends ErrorInferenceObject = ErrorInference
     });
     static codeToStatus(code: ActionErrorCode): number;
     static statusToCode(status: number): ActionErrorCode;
-    static fromResponse(res: Response): Promise<ActionError<ErrorInferenceObject>>;
+    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> = {
@@ -43,3 +44,19 @@ export declare function getActionProps<T extends (args: FormData) => MaybePromis
     readonly name: "_astroAction";
     readonly value: 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>;