astro 4.14.6 → 4.15.0

package/client.d.ts

@@ -150,6 +150,9 @@ declare module 'astro:transitions/client' {
 		import('./dist/virtual-modules/transitions-events.js').TransitionBeforeSwapEvent;
 	export const isTransitionBeforePreparationEvent: EventModule['isTransitionBeforePreparationEvent'];
 	export const isTransitionBeforeSwapEvent: EventModule['isTransitionBeforeSwapEvent'];
+	type TransitionSwapFunctionModule =
+		typeof import('./dist/virtual-modules/transitions-swap-functions.js');
+	export const swapFunctions: TransitionSwapFunctionModule['swapFunctions'];
 }
 
 declare module 'astro:prefetch' {
@@ -172,6 +175,10 @@ declare module 'astro:components' {
 	export * from 'astro/components';
 }
 
+declare module 'astro:schema' {
+	export * from 'astro/zod';
+}
+
 type MD = import('./dist/@types/astro.js').MarkdownInstance<Record<string, any>>;
 interface ExportedMarkdownModuleEntities {
 	frontmatter: MD['frontmatter'];

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

@@ -35,7 +35,7 @@ export type { AssetsPrefix, SSRManifest } from '../core/app/types.js';
 export type { AstroCookieGetOptions, AstroCookieSetOptions, AstroCookies, } from '../core/cookies/index.js';
 export interface AstroBuiltinProps {
     'client:load'?: boolean;
-    'client:idle'?: boolean;
+    'client:idle'?: IdleRequestOptions | boolean;
     'client:media'?: string;
     'client:visible'?: ClientVisibleOptions | boolean;
     'client:only'?: boolean | string;
@@ -1531,6 +1531,42 @@ export interface AstroUserConfig {
              *```
              * */
             redirectToDefaultLocale?: boolean;
+            /**
+             * @docs
+             * @name i18n.routing.fallbackType
+             * @kind h4
+             * @type {"redirect" | "rewrite"}
+             * @default `"redirect"`
+             * @version 4.15.0
+             * @description
+             *
+             * When [`i18n.fallback`](#i18nfallback) is configured to avoid showing a 404 page for missing page routes, this option controls whether to [redirect](https://docs.astro.build/en/guides/routing/#redirects) to the fallback page, or to [rewrite](https://docs.astro.build/en/guides/routing/#rewrites) the fallback page's content in place.
+             *
+             * By default, Astro's i18n routing creates pages that redirect your visitors to a new destination based on your fallback configuration. The browser will refresh and show the destination address in the URL bar.
+             *
+             * When `i18n.routing.fallback: "rewrite"` is configured, Astro will create pages that render the contents of the fallback page on the original, requested URL.
+             *
+             * With the following configuration, if you have the file `src/pages/en/about.astro` but not `src/pages/fr/about.astro`, the `astro build` command will generate `dist/fr/about.html` with the same content as the `dist/en/index.html` page.
+             * Your site visitor will see the English version of the page at `https://example.com/fr/about/` and will not be redirected.
+             *
+             * ```js
+             * //astro.config.mjs
+             * export default defineConfig({
+             * 	 i18n: {
+             *     defaultLocale: "en",
+             *     locales: ["en", "fr"],
+             *     routing: {
+             *     	prefixDefaultLocale: false,
+             *     	fallbackType: "rewrite",
+             *     },
+             *     fallback: {
+             *     	fr: "en",
+             *     }
+             *   },
+             * })
+             * ```
+             */
+            fallbackType: 'redirect' | 'rewrite';
             /**
              * @name i18n.routing.strategy
              * @type {"pathname"}
@@ -1654,106 +1690,6 @@ export interface AstroUserConfig {
          * ```
          */
         directRenderScript?: boolean;
-        /**
-         * @docs
-         * @name experimental.actions
-         * @type {boolean}
-         * @default `false`
-         * @version 4.8.0
-         * @description
-         *
-         * Actions help you write type-safe backend functions you can call from anywhere. Enable server rendering [using the `output` property](https://docs.astro.build/en/basics/rendering-modes/#on-demand-rendered) and add the `actions` flag to the `experimental` object:
-         *
-         * ```js
-         * {
-         *   output: 'hybrid', // or 'server'
-         *   experimental: {
-         *     actions: true,
-         *   },
-         * }
-         * ```
-         *
-         * Declare all your actions in `src/actions/index.ts`. This file is the global actions handler.
-         *
-         * Define an action using the `defineAction()` utility from the `astro:actions` module. An action accepts the `handler` property to define your server-side request handler. If your action accepts arguments, apply the `input` property to validate parameters with Zod.
-         *
-         * This example defines two actions: `like` and `comment`. The `like` action accepts a JSON object with a `postId` string, while the `comment` action accepts [FormData](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest_API/Using_FormData_Objects) with `postId`, `author`, and `body` strings. Each `handler` updates your database and return a type-safe response.
-         *
-         * ```ts
-         * // src/actions/index.ts
-         * import { defineAction, z } from "astro:actions";
-         *
-         * export const server = {
-         *   like: defineAction({
-         *     input: z.object({ postId: z.string() }),
-         *     handler: async ({ postId }) => {
-         *       // update likes in db
-         *
-         *       return likes;
-         *     },
-         *   }),
-         *   comment: defineAction({
-         *     accept: 'form',
-         *     input: z.object({
-         *       postId: z.string(),
-         *       author: z.string(),
-         *       body: z.string(),
-         *     }),
-         *     handler: async ({ postId }) => {
-         *       // insert comments in db
-         *
-         *       return comment;
-         *     },
-         *   }),
-         * };
-         * ```
-         *
-         * Then, call an action from your client components using the `actions` object from `astro:actions`. You can pass a type-safe object when using JSON, or a [FormData](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest_API/Using_FormData_Objects) object when using `accept: 'form'` in your action definition.
-         *
-         * This example calls the `like` and `comment` actions from a React component:
-         *
-         * ```tsx "actions"
-         * // src/components/blog.tsx
-         * import { actions } from "astro:actions";
-         * import { useState } from "react";
-         *
-         * export function Like({ postId }: { postId: string }) {
-         *   const [likes, setLikes] = useState(0);
-         *   return (
-         *     <button
-         *       onClick={async () => {
-         *         const newLikes = await actions.like({ postId });
-         *         setLikes(newLikes);
-         *       }}
-         *     >
-         *       {likes} likes
-         *     </button>
-         *   );
-         * }
-         *
-         * export function Comment({ postId }: { postId: string }) {
-         *   return (
-         *     <form
-         *       onSubmit={async (e) => {
-         *         e.preventDefault();
-         *         const formData = new FormData(e.target as HTMLFormElement);
-         *         const result = await actions.blog.comment(formData);
-         *         // handle result
-         *       }}
-         *     >
-         *       <input type="hidden" name="postId" value={postId} />
-         *       <label htmlFor="author">Author</label>
-         *       <input id="author" type="text" name="author" />
-         *       <textarea rows={10} name="body"></textarea>
-         *       <button type="submit">Post</button>
-         *     </form>
-         *   );
-         * }
-         * ```
-         *
-         * For a complete overview, and to give feedback on this experimental API, see the [Actions RFC](https://github.com/withastro/roadmap/blob/actions/proposals/0046-actions.md).
-         */
-        actions?: boolean;
         /**
          * @docs
          * @name experimental.contentCollectionCache
@@ -2303,6 +2239,7 @@ export interface RouteOptions {
 }
 /**
  * Resolved Astro Config
+ *
  * Config with user settings along with all defaults filled in.
  */
 export interface AstroConfig extends AstroConfigType {
@@ -2378,7 +2315,7 @@ export interface ContentEntryType {
         viteId: string;
     }): rollup.LoadResult | Promise<rollup.LoadResult>;
     contentModuleTypes?: string;
-    getRenderFunction?(settings: AstroSettings): Promise<ContentEntryRenderFuction>;
+    getRenderFunction?(config: AstroConfig): Promise<ContentEntryRenderFuction>;
     /**
      * Handle asset propagation for rendered content to avoid bleed.
      * Ex. MDX content can import styles and scripts, so `handlePropagation` should be true.
@@ -3016,7 +2953,7 @@ declare global {
         interface IntegrationHooks {
             'astro:config:setup': (options: {
                 config: AstroConfig;
-                command: 'dev' | 'build' | 'preview';
+                command: 'dev' | 'build' | 'preview' | 'sync';
                 isRestart: boolean;
                 updateConfig: (newConfig: DeepPartial<AstroConfig>) => AstroConfig;
                 addRenderer: (renderer: AstroRenderer) => void;

package/dist/actions/integration.d.ts

@@ -0,0 +1,8 @@
+import type { AstroIntegration, AstroSettings } from '../@types/astro.js';
+/**
+ * This integration is applied when the user is using Actions in their project.
+ * It will inject the necessary routes and middlewares to handle actions.
+ */
+export default function astroIntegrationActionsRouteHandler({ settings, }: {
+    settings: AstroSettings;
+}): AstroIntegration;

package/dist/actions/integration.js

@@ -0,0 +1,45 @@
+import { ActionsWithoutServerOutputError } from "../core/errors/errors-data.js";
+import { AstroError } from "../core/errors/errors.js";
+import { isServerLikeOutput, viteID } from "../core/util.js";
+import { ACTIONS_TYPES_FILE, VIRTUAL_MODULE_ID } from "./consts.js";
+function astroIntegrationActionsRouteHandler({
+  settings
+}) {
+  return {
+    name: VIRTUAL_MODULE_ID,
+    hooks: {
+      async "astro:config:setup"(params) {
+        params.injectRoute({
+          pattern: "/_actions/[...path]",
+          entrypoint: "astro/actions/runtime/route.js",
+          prerender: false
+        });
+        params.addMiddleware({
+          entrypoint: "astro/actions/runtime/middleware.js",
+          order: "post"
+        });
+      },
+      "astro:config:done": async (params) => {
+        if (!isServerLikeOutput(params.config)) {
+          const error = new AstroError(ActionsWithoutServerOutputError);
+          error.stack = void 0;
+          throw error;
+        }
+        const stringifiedActionsImport = JSON.stringify(
+          viteID(new URL("./actions", params.config.srcDir))
+        );
+        settings.injectedTypes.push({
+          filename: ACTIONS_TYPES_FILE,
+          content: `declare module "astro:actions" {
+	type Actions = typeof import(${stringifiedActionsImport})["server"];
+
+	export const actions: Actions;
+}`
+        });
+      }
+    }
+  };
+}
+export {
+  astroIntegrationActionsRouteHandler as default
+};

package/dist/actions/{index.d.ts → plugins.d.ts}

@@ -1,10 +1,6 @@
-import fsMod from 'node:fs';
+import type fsMod from 'node:fs';
 import type { Plugin as VitePlugin } from 'vite';
-import type { AstroIntegration, AstroSettings } from '../@types/astro.js';
-export default function astroActions({ fs, settings, }: {
-    fs?: typeof fsMod;
-    settings: AstroSettings;
-}): AstroIntegration;
+import type { AstroSettings } from '../@types/astro.js';
 /**
  * This plugin is responsible to load the known file `actions/index.js` / `actions.js`
  * If the file doesn't exist, it returns an empty object.
@@ -13,3 +9,7 @@ export default function astroActions({ fs, settings, }: {
 export declare function vitePluginUserActions({ settings }: {
     settings: AstroSettings;
 }): VitePlugin;
+export declare function vitePluginActions({ fs, settings, }: {
+    fs: typeof fsMod;
+    settings: AstroSettings;
+}): VitePlugin;

package/dist/actions/plugins.js

@@ -0,0 +1,80 @@
+import {
+  NOOP_ACTIONS,
+  RESOLVED_VIRTUAL_INTERNAL_MODULE_ID,
+  RESOLVED_VIRTUAL_MODULE_ID,
+  VIRTUAL_INTERNAL_MODULE_ID,
+  VIRTUAL_MODULE_ID
+} from "./consts.js";
+import { isActionsFilePresent } from "./utils.js";
+function vitePluginUserActions({ settings }) {
+  let resolvedActionsId;
+  return {
+    name: "@astro/plugin-actions",
+    async resolveId(id) {
+      if (id === NOOP_ACTIONS) {
+        return NOOP_ACTIONS;
+      }
+      if (id === VIRTUAL_INTERNAL_MODULE_ID) {
+        const resolvedModule = await this.resolve(
+          `${decodeURI(new URL("actions", settings.config.srcDir).pathname)}`
+        );
+        if (!resolvedModule) {
+          return NOOP_ACTIONS;
+        }
+        resolvedActionsId = resolvedModule.id;
+        return RESOLVED_VIRTUAL_INTERNAL_MODULE_ID;
+      }
+    },
+    load(id) {
+      if (id === NOOP_ACTIONS) {
+        return "export const server = {}";
+      } else if (id === RESOLVED_VIRTUAL_INTERNAL_MODULE_ID) {
+        return `export { server } from '${resolvedActionsId}';`;
+      }
+    }
+  };
+}
+function vitePluginActions({
+  fs,
+  settings
+}) {
+  return {
+    name: VIRTUAL_MODULE_ID,
+    enforce: "pre",
+    resolveId(id) {
+      if (id === VIRTUAL_MODULE_ID) {
+        return RESOLVED_VIRTUAL_MODULE_ID;
+      }
+    },
+    async configureServer(server) {
+      const filePresentOnStartup = await isActionsFilePresent(fs, settings.config.srcDir);
+      async function watcherCallback() {
+        const filePresent = await isActionsFilePresent(fs, settings.config.srcDir);
+        if (filePresentOnStartup !== filePresent) {
+          server.restart();
+        }
+      }
+      server.watcher.on("add", watcherCallback);
+      server.watcher.on("change", watcherCallback);
+    },
+    async load(id, opts) {
+      if (id !== RESOLVED_VIRTUAL_MODULE_ID) return;
+      let code = await fs.promises.readFile(
+        new URL("../../templates/actions.mjs", import.meta.url),
+        "utf-8"
+      );
+      if (opts?.ssr) {
+        code += `
+export * from 'astro/actions/runtime/virtual/server.js';`;
+      } else {
+        code += `
+export * from 'astro/actions/runtime/virtual/client.js';`;
+      }
+      return code;
+    }
+  };
+}
+export {
+  vitePluginActions,
+  vitePluginUserActions
+};

package/dist/actions/runtime/middleware.js

@@ -1,6 +1,4 @@
 import { yellow } from "kleur/colors";
-import { ActionQueryStringInvalidError } from "../../core/errors/errors-data.js";
-import { AstroError } from "../../core/errors/errors.js";
 import { defineMiddleware } from "../../core/middleware/index.js";
 import { ACTION_QUERY_PARAMS } from "../consts.js";
 import { formContentTypes, hasContentType } from "./utils.js";
@@ -31,9 +29,6 @@ const onRequest = defineMiddleware(async (context, next) => {
   if (context.request.method === "POST" && actionName) {
     return handlePost({ context, next, actionName });
   }
-  if (context.request.method === "POST") {
-    return handlePostLegacy({ context, next });
-  }
   return next();
 });
 async function renderResult({
@@ -62,12 +57,6 @@ async function handlePost({
 }) {
   const { request } = context;
   const baseAction = await getAction(actionName);
-  if (!baseAction) {
-    throw new AstroError({
-      ...ActionQueryStringInvalidError,
-      message: ActionQueryStringInvalidError.message(actionName)
-    });
-  }
   const contentType = request.headers.get("content-type");
   let formData;
   if (contentType && hasContentType(contentType, formContentTypes)) {
@@ -103,28 +92,6 @@ async function redirectWithResult({
   }
   return context.redirect(context.url.pathname);
 }
-async function handlePostLegacy({ context, next }) {
-  const { request } = 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 next();
-  const actionName = formData.get(ACTION_QUERY_PARAMS.actionName);
-  if (!actionName) return next();
-  const baseAction = await getAction(actionName);
-  if (!baseAction) {
-    throw new AstroError({
-      ...ActionQueryStringInvalidError,
-      message: ActionQueryStringInvalidError.message(actionName)
-    });
-  }
-  const action = baseAction.bind(context);
-  const actionResult = await action(formData);
-  return redirectWithResult({ context, actionName, actionResult });
-}
 function isActionPayload(json) {
   if (typeof json !== "object" || json == null) return false;
   if (!("actionResult" in json) || typeof json.actionResult !== "object") return false;

package/dist/actions/runtime/route.js

@@ -3,9 +3,13 @@ import { getAction } from "./virtual/get-action.js";
 import { serializeActionResult } from "./virtual/shared.js";
 const POST = async (context) => {
   const { request, url } = context;
-  const baseAction = await getAction(url.pathname);
-  if (!baseAction) {
-    return new Response(null, { status: 404 });
+  let baseAction;
+  try {
+    baseAction = await getAction(url.pathname);
+  } catch (e) {
+    if (import.meta.env.DEV) throw e;
+    console.error(e);
+    return new Response(e instanceof Error ? e.message : null, { status: 404 });
   }
   const contentType = request.headers.get("Content-Type");
   const contentLength = request.headers.get("Content-Length");

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

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

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

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

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

@@ -5,4 +5,4 @@ import type { ActionAccept, ActionClient } from './server.js';
  * 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>;
+export declare function getAction(path: string): Promise<ActionClient<unknown, ActionAccept, ZodType>>;

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

@@ -1,14 +1,26 @@
+import { ActionNotFoundError } from "../../../core/errors/errors-data.js";
+import { AstroError } from "../../../core/errors/errors.js";
 async function getAction(path) {
   const pathKeys = path.replace("/_actions/", "").split(".");
   let { server: actionLookup } = await import("astro:internal-actions");
+  if (actionLookup == null || !(typeof actionLookup === "object")) {
+    throw new TypeError(
+      `Expected \`server\` export in actions file to be an object. Received ${typeof actionLookup}.`
+    );
+  }
   for (const key of pathKeys) {
     if (!(key in actionLookup)) {
-      return void 0;
+      throw new AstroError({
+        ...ActionNotFoundError,
+        message: ActionNotFoundError.message(pathKeys.join("."))
+      });
     }
     actionLookup = actionLookup[key];
   }
   if (typeof actionLookup !== "function") {
-    return void 0;
+    throw new TypeError(
+      `Expected handler for action ${pathKeys.join(".")} to be a function. Received ${typeof actionLookup}.`
+    );
   }
   return actionLookup;
 }

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

@@ -2,7 +2,6 @@ import { z } from 'zod';
 import type { ActionAPIContext, ErrorInferenceObject, MaybePromise } from '../utils.js';
 import { type SafeResult } from './shared.js';
 export * from './shared.js';
-export { z } from 'zod';
 export type ActionAccept = 'form' | 'json';
 export type ActionHandler<TInputSchema, TOutput> = TInputSchema extends z.ZodType ? (input: z.infer<TInputSchema>, context: ActionAPIContext) => MaybePromise<TOutput> : (input: any, context: ActionAPIContext) => MaybePromise<TOutput>;
 export type ActionReturnType<T extends ActionHandler<any, any>> = Awaited<ReturnType<T>>;

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

@@ -3,7 +3,6 @@ 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";
 function defineAction({
   accept,
   input: inputSchema,
@@ -114,6 +113,5 @@ function unwrapSchemaEffects(schema) {
 }
 export {
   defineAction,
-  formDataToObject,
-  z2 as z
+  formDataToObject
 };

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

@@ -39,17 +39,6 @@ export declare class ActionInputError<T extends ErrorInferenceObject> extends Ac
 }
 export declare function callSafely<TOutput>(handler: () => MaybePromise<TOutput>): Promise<SafeResult<z.ZodType, TOutput>>;
 export declare function getActionQueryString(name: string): string;
-/**
- * @deprecated You can now pass action functions
- * directly to the `action` attribute on a form.
- *
- * Example: `<form action={actions.like} />`
- */
-export declare function getActionProps<T extends (args: FormData) => MaybePromise<unknown>>(action: T): {
-    readonly type: "hidden";
-    readonly name: "_astroAction";
-    readonly value: string;
-};
 export type SerializedActionResult = {
     type: 'data';
     contentType: 'application/json+devalue';

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

@@ -121,18 +121,6 @@ function getActionQueryString(name) {
   const searchParams = new URLSearchParams({ [_ACTION_QUERY_PARAMS.actionName]: name });
   return `?${searchParams.toString()}`;
 }
-function getActionProps(action) {
-  const params = new URLSearchParams(action.toString());
-  const actionName = params.get("_astroAction");
-  if (!actionName) {
-    throw new Error("Invalid actions function was passed to getActionProps()");
-  }
-  return {
-    type: "hidden",
-    name: "_astroAction",
-    value: actionName
-  };
-}
 function serializeActionResult(res) {
   if (res.error) {
     if (import.meta.env?.DEV) {
@@ -180,10 +168,22 @@ function serializeActionResult(res) {
 }
 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.parse(res.body)), data: void 0 };
+      return { error: ActionError.fromJson(json), data: void 0 };
     } else {
-      const error = ActionError.fromJson(JSON.parse(res.body));
+      const error = ActionError.fromJson(json);
       error.stack = actionResultErrorStack.get();
       return {
         error,
@@ -219,7 +219,6 @@ export {
   ActionInputError,
   callSafely,
   deserializeActionResult,
-  getActionProps,
   getActionQueryString,
   isActionError,
   isInputError,

package/dist/actions/utils.d.ts

@@ -1,6 +1,11 @@
+import type fsMod from 'node:fs';
 import type { APIContext } from '../@types/astro.js';
 import type { Locals } from './runtime/middleware.js';
 import type { ActionAPIContext } from './runtime/utils.js';
 export declare function hasActionPayload(locals: APIContext['locals']): locals is Locals;
 export declare function createGetActionResult(locals: APIContext['locals']): APIContext['getActionResult'];
 export declare function createCallAction(context: ActionAPIContext): APIContext['callAction'];
+/**
+ * Check whether the Actions config file is present.
+ */
+export declare function isActionsFilePresent(fs: typeof fsMod, srcDir: URL): Promise<boolean>;

package/dist/actions/utils.js

@@ -1,3 +1,4 @@
+import * as eslexer from "es-module-lexer";
 import { deserializeActionResult, getActionQueryString } from "./runtime/virtual/shared.js";
 function hasActionPayload(locals) {
   return "_actionPayload" in locals;
@@ -16,8 +17,46 @@ function createCallAction(context) {
     return action(input);
   };
 }
+let didInitLexer = false;
+async function isActionsFilePresent(fs, srcDir) {
+  if (!didInitLexer) await eslexer.init;
+  const actionsFile = search(fs, srcDir);
+  if (!actionsFile) return false;
+  let contents;
+  try {
+    contents = fs.readFileSync(actionsFile, "utf-8");
+  } catch {
+    return false;
+  }
+  const [, exports] = eslexer.parse(contents, actionsFile.pathname);
+  for (const exp of exports) {
+    if (exp.n === "server") {
+      return true;
+    }
+  }
+  return false;
+}
+function search(fs, srcDir) {
+  const paths = [
+    "actions.mjs",
+    "actions.js",
+    "actions.mts",
+    "actions.ts",
+    "actions/index.mjs",
+    "actions/index.js",
+    "actions/index.mts",
+    "actions/index.ts"
+  ].map((p) => new URL(p, srcDir));
+  for (const file of paths) {
+    if (fs.existsSync(file)) {
+      return file;
+    }
+  }
+  return void 0;
+}
 export {
   createCallAction,
   createGetActionResult,
-  hasActionPayload
+  hasActionPayload,
+  isActionsFilePresent
 };

package/dist/assets/utils/resolveImports.d.ts

@@ -5,5 +5,5 @@
  * @param filePath The path to the file that contains the imagem relative to the site root
  * @returns A module id of the image that can be rsolved by Vite, or undefined if it is not a local image
  */
-export declare function imageSrcToImportId(imageSrc: string, filePath: string): string | undefined;
+export declare function imageSrcToImportId(imageSrc: string, filePath?: string): string | undefined;
 export declare const importIdToSymbolName: (importId: string) => string;