@elurjs/kit 2.4.4

package/bin/elur-kit.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+import { existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
+
+const cwd = process.cwd();
+const here = dirname(fileURLToPath(import.meta.url));
+
+// Bun projects can use `bun:` protocol imports (bun:sqlite, etc.). When the
+// bin is spawned through node (e.g. `bun run build` -> sh -> `env node`),
+// those imports cannot be resolved, so re-exec with the Bun runtime when the
+// project is bun-managed (bun.lock present).
+if (
+  !process.versions.bun &&
+  (existsSync(join(cwd, "bun.lock")) || existsSync(join(cwd, "bun.lockb")))
+) {
+  const probe = spawnSync("bun", ["--version"], { stdio: "ignore" });
+  if (probe.status === 0) {
+    const result = spawnSync("bun", [fileURLToPath(import.meta.url), ...process.argv.slice(2)], {
+      stdio: "inherit",
+      env: process.env,
+    });
+    process.exit(result.status ?? 1);
+  }
+}
+
+// Register tsx so dynamic imports of user .ts pages/islands work at runtime
+// under Node. Bun transpiles TypeScript natively and does not need it.
+if (!process.versions.bun) {
+  const tsx = await import("tsx/esm/api").catch(() => null);
+  if (tsx) tsx.register();
+}
+
+const built = join(here, "../dist/lib/cli.js");
+
+if (!existsSync(built)) {
+  console.log("[elur-kit] dist/lib/cli.js not found, running npm run build:lib...");
+  const result = spawnSync("npm", ["run", "build:lib"], {
+    stdio: "inherit",
+    cwd: join(here, ".."),
+  });
+  if (result.status !== 0) {
+    console.error("[elur-kit] build:lib failed");
+    process.exit(result.status ?? 1);
+  }
+}
+
+const { run } = await import(built);
+
+run(process.argv).catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/dist/lib/action/define.d.cts

@@ -0,0 +1,72 @@
+import type { ActionFailure } from "../errors.js";
+/** Concurrency mode for actions called multiple times in rapid succession. */
+export type ActionConcurrencyMode = "latest" | "queue" | "parallel";
+/** Options for defining a typed server action. */
+export interface DefineActionOptions<TInput> {
+    /**
+     * Optional input validator. Can be a Zod schema, a plain function, or any
+     * object with a `.parse()` method. If validation fails, the action returns
+     * a 400 ActionFailure with the validation error.
+     */
+    input?: ActionInputValidator<TInput>;
+    /** Concurrency mode when the same action is called multiple times. */
+    concurrency?: ActionConcurrencyMode;
+    /** Whether the action is idempotent (safe to retry). */
+    idempotent?: boolean;
+    /** Tags to invalidate from the cache after a successful action (§9.4). */
+    invalidateTags?: string[];
+    /** Paths to invalidate from the cache after a successful action (§9.4). */
+    invalidatePaths?: string[];
+}
+/** A validator that has a `.parse()` method (Zod-compatible) or is a function. */
+export interface ActionInputValidator<T> {
+    parse(input: unknown): T;
+}
+/** Context passed to a defined action. */
+export interface ActionContext {
+    /** The original Web Request. */
+    request: Request;
+    /** AbortSignal from the request — aborts if the client disconnects. */
+    signal: AbortSignal;
+    /** Idempotency key from the request header, if present. */
+    idempotencyKey?: string;
+    /** Route params (for page-scoped actions). */
+    params: Record<string, string | string[]>;
+    /** Per-request locals (populated by middleware). */
+    locals: Record<string, unknown>;
+}
+/** A defined action function. */
+export type DefinedActionFn<TInput, TOutput> = (input: TInput, ctx: ActionContext) => Promise<TOutput | ActionFailure<TOutput>>;
+/** The return type of defineAction(): a callable with metadata. */
+export interface DefinedAction<TInput, TOutput> {
+    (input: TInput, ctx: ActionContext): Promise<TOutput | ActionFailure<TOutput>>;
+    /** Metadata for the action (used by the runtime/manifest). */
+    __elurAction: {
+        name: string;
+        concurrency: ActionConcurrencyMode;
+        idempotent: boolean;
+        invalidateTags: readonly string[];
+        invalidatePaths: readonly string[];
+    };
+}
+/**
+ * Defines a typed server action with validation, abort support, and cache
+ * invalidation metadata.
+ *
+ * ```ts
+ * import { defineAction, fail } from "@elurjs/kit/action";
+ *
+ * export const submitContact = defineAction({
+ *   input: { parse: (v) => v as { name: string; email: string } },
+ *   invalidateTags: ["contacts"],
+ * }, async (input, ctx) => {
+ *   if (!input.email.includes("@")) return fail(400, { email: "Invalid" });
+ *   await saveContact(input);
+ *   return { success: true };
+ * });
+ * ```
+ *
+ * Legacy exported async functions (without `defineAction`) continue to work
+ * as before — this is an opt-in upgrade.
+ */
+export declare function defineAction<TInput = unknown, TOutput = unknown>(options: DefineActionOptions<TInput>, handler: DefinedActionFn<TInput, TOutput>): DefinedAction<TInput, TOutput>;

package/dist/lib/action/define.d.ts

@@ -0,0 +1,72 @@
+import type { ActionFailure } from "../errors.js";
+/** Concurrency mode for actions called multiple times in rapid succession. */
+export type ActionConcurrencyMode = "latest" | "queue" | "parallel";
+/** Options for defining a typed server action. */
+export interface DefineActionOptions<TInput> {
+    /**
+     * Optional input validator. Can be a Zod schema, a plain function, or any
+     * object with a `.parse()` method. If validation fails, the action returns
+     * a 400 ActionFailure with the validation error.
+     */
+    input?: ActionInputValidator<TInput>;
+    /** Concurrency mode when the same action is called multiple times. */
+    concurrency?: ActionConcurrencyMode;
+    /** Whether the action is idempotent (safe to retry). */
+    idempotent?: boolean;
+    /** Tags to invalidate from the cache after a successful action (§9.4). */
+    invalidateTags?: string[];
+    /** Paths to invalidate from the cache after a successful action (§9.4). */
+    invalidatePaths?: string[];
+}
+/** A validator that has a `.parse()` method (Zod-compatible) or is a function. */
+export interface ActionInputValidator<T> {
+    parse(input: unknown): T;
+}
+/** Context passed to a defined action. */
+export interface ActionContext {
+    /** The original Web Request. */
+    request: Request;
+    /** AbortSignal from the request — aborts if the client disconnects. */
+    signal: AbortSignal;
+    /** Idempotency key from the request header, if present. */
+    idempotencyKey?: string;
+    /** Route params (for page-scoped actions). */
+    params: Record<string, string | string[]>;
+    /** Per-request locals (populated by middleware). */
+    locals: Record<string, unknown>;
+}
+/** A defined action function. */
+export type DefinedActionFn<TInput, TOutput> = (input: TInput, ctx: ActionContext) => Promise<TOutput | ActionFailure<TOutput>>;
+/** The return type of defineAction(): a callable with metadata. */
+export interface DefinedAction<TInput, TOutput> {
+    (input: TInput, ctx: ActionContext): Promise<TOutput | ActionFailure<TOutput>>;
+    /** Metadata for the action (used by the runtime/manifest). */
+    __elurAction: {
+        name: string;
+        concurrency: ActionConcurrencyMode;
+        idempotent: boolean;
+        invalidateTags: readonly string[];
+        invalidatePaths: readonly string[];
+    };
+}
+/**
+ * Defines a typed server action with validation, abort support, and cache
+ * invalidation metadata.
+ *
+ * ```ts
+ * import { defineAction, fail } from "@elurjs/kit/action";
+ *
+ * export const submitContact = defineAction({
+ *   input: { parse: (v) => v as { name: string; email: string } },
+ *   invalidateTags: ["contacts"],
+ * }, async (input, ctx) => {
+ *   if (!input.email.includes("@")) return fail(400, { email: "Invalid" });
+ *   await saveContact(input);
+ *   return { success: true };
+ * });
+ * ```
+ *
+ * Legacy exported async functions (without `defineAction`) continue to work
+ * as before — this is an opt-in upgrade.
+ */
+export declare function defineAction<TInput = unknown, TOutput = unknown>(options: DefineActionOptions<TInput>, handler: DefinedActionFn<TInput, TOutput>): DefinedAction<TInput, TOutput>;

package/dist/lib/action/error-store.d.cts

@@ -0,0 +1,29 @@
+/**
+ * Encodes an action failure for the redirect cookie. When the payload fits
+ * inside the cookie limit, it is embedded directly as a signed base64url JSON
+ * value. When it is too large, it is stored in memory and only a short signed
+ * id is written to the cookie.
+ *
+ * The cookie is signed with HMAC-SHA256 to prevent forgery (A-20).
+ *
+ * @returns The cookie value to set on the redirect response.
+ */
+export declare function encodeActionErrorCookie(data: unknown, status: number): {
+    value: string;
+    storeId?: string;
+};
+/**
+ * Decodes a cookie value (previously produced by `encodeActionErrorCookie`)
+ * into the failure payload. Verifies the HMAC signature first, then resolves
+ * in-memory overflow entries and deletes them after reading.
+ */
+export declare function decodeActionErrorCookie(value: string | undefined | null): {
+    data: unknown;
+    status: number;
+} | undefined;
+/** Name of the cookie used to relay action errors. */
+export declare const ACTION_ERROR_COOKIE = "__elur_js_action_error";
+/** Builds the Set-Cookie header value that clears the error cookie. */
+export declare function clearActionErrorCookieHeader(): string;
+/** Builds the Set-Cookie header value that sets the error cookie. */
+export declare function setActionErrorCookieHeader(value: string): string;

package/dist/lib/action/error-store.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Encodes an action failure for the redirect cookie. When the payload fits
+ * inside the cookie limit, it is embedded directly as a signed base64url JSON
+ * value. When it is too large, it is stored in memory and only a short signed
+ * id is written to the cookie.
+ *
+ * The cookie is signed with HMAC-SHA256 to prevent forgery (A-20).
+ *
+ * @returns The cookie value to set on the redirect response.
+ */
+export declare function encodeActionErrorCookie(data: unknown, status: number): {
+    value: string;
+    storeId?: string;
+};
+/**
+ * Decodes a cookie value (previously produced by `encodeActionErrorCookie`)
+ * into the failure payload. Verifies the HMAC signature first, then resolves
+ * in-memory overflow entries and deletes them after reading.
+ */
+export declare function decodeActionErrorCookie(value: string | undefined | null): {
+    data: unknown;
+    status: number;
+} | undefined;
+/** Name of the cookie used to relay action errors. */
+export declare const ACTION_ERROR_COOKIE = "__elur_js_action_error";
+/** Builds the Set-Cookie header value that clears the error cookie. */
+export declare function clearActionErrorCookieHeader(): string;
+/** Builds the Set-Cookie header value that sets the error cookie. */
+export declare function setActionErrorCookieHeader(value: string): string;

package/dist/lib/action/index.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("../action-DZHihU3Z.cjs");exports.callAction=e.t,exports.defineAction=e.r,exports.elurJsAction=e.n;

package/dist/lib/action/index.d.cts

@@ -0,0 +1,64 @@
+/**
+ * Client-side helpers for invoking server actions.
+ *
+ * Server actions are defined in `page.action.ts` files next to `page.ts`.
+ * They export async functions that run on the server. On the client, call them
+ * by name using `callAction` or the higher-level `elurJsAction` helper:
+ *
+ * ```ts
+ * import { callAction } from "@elurjs/kit/action";
+ *
+ * const result = await callAction("submitContact", { name: "Ada" }, { page: "/contact" });
+ * ```
+ *
+ * ```ts
+ * import { elurJsAction } from "@elurjs/kit/action";
+ *
+ * const contact = elurJsAction("submitContact", { page: "/contact" });
+ * await contact.submit({ name: "Ada" });
+ * console.log(contact.data.value, contact.error.value, contact.pending.value);
+ * ```
+ */
+import { ActionFailure, RedirectResponse } from "../errors.js";
+export interface ActionRequest {
+    name: string;
+    page?: string;
+    args: unknown[];
+}
+export interface CallActionOptions {
+    /** Page URL path that scopes the action, e.g. `/contact`. */
+    page?: string;
+}
+/**
+ * Call a server action by name.
+ *
+ * The request is sent as a POST to `/__elur-js/actions` with the action name,
+ * optional page scope, and serialized arguments. The server executes the
+ * matching exported function from the scanned `page.action.ts` modules and
+ * returns its JSON result.
+ */
+export declare function callAction<T = unknown>(name: string, args?: unknown, options?: CallActionOptions): Promise<T | ActionFailure<T> | RedirectResponse>;
+export interface ElurJsAction<TInput = unknown, TOutput = unknown> {
+    /** Submit the action with the given input. */
+    submit(input: TInput): Promise<TOutput | ActionFailure<TOutput> | RedirectResponse>;
+    /** Signal that is true while the action is running. */
+    pending: {
+        value: boolean;
+    };
+    /** Signal with the last successful result, action failure, redirect, or null. */
+    data: {
+        value: TOutput | ActionFailure<TOutput> | RedirectResponse | null;
+    };
+    /** Signal with the last error, or null. */
+    error: {
+        value: Error | null;
+    };
+}
+/**
+ * Create a reactive handle for a server action.
+ *
+ * Returns a `submit` function and signals for `pending`, `data`, and `error`.
+ * Useful for wiring actions to forms and islands without manual signal boilerplate.
+ */
+export declare function elurJsAction<TInput = unknown, TOutput = unknown>(name: string, options?: CallActionOptions): ElurJsAction<TInput, TOutput>;
+export { defineAction, type DefineActionOptions, type DefinedAction, type DefinedActionFn, type ActionContext, type ActionInputValidator, type ActionConcurrencyMode, } from "./define.js";

package/dist/lib/action/index.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Client-side helpers for invoking server actions.
+ *
+ * Server actions are defined in `page.action.ts` files next to `page.ts`.
+ * They export async functions that run on the server. On the client, call them
+ * by name using `callAction` or the higher-level `elurJsAction` helper:
+ *
+ * ```ts
+ * import { callAction } from "@elurjs/kit/action";
+ *
+ * const result = await callAction("submitContact", { name: "Ada" }, { page: "/contact" });
+ * ```
+ *
+ * ```ts
+ * import { elurJsAction } from "@elurjs/kit/action";
+ *
+ * const contact = elurJsAction("submitContact", { page: "/contact" });
+ * await contact.submit({ name: "Ada" });
+ * console.log(contact.data.value, contact.error.value, contact.pending.value);
+ * ```
+ */
+import { ActionFailure, RedirectResponse } from "../errors.js";
+export interface ActionRequest {
+    name: string;
+    page?: string;
+    args: unknown[];
+}
+export interface CallActionOptions {
+    /** Page URL path that scopes the action, e.g. `/contact`. */
+    page?: string;
+}
+/**
+ * Call a server action by name.
+ *
+ * The request is sent as a POST to `/__elur-js/actions` with the action name,
+ * optional page scope, and serialized arguments. The server executes the
+ * matching exported function from the scanned `page.action.ts` modules and
+ * returns its JSON result.
+ */
+export declare function callAction<T = unknown>(name: string, args?: unknown, options?: CallActionOptions): Promise<T | ActionFailure<T> | RedirectResponse>;
+export interface ElurJsAction<TInput = unknown, TOutput = unknown> {
+    /** Submit the action with the given input. */
+    submit(input: TInput): Promise<TOutput | ActionFailure<TOutput> | RedirectResponse>;
+    /** Signal that is true while the action is running. */
+    pending: {
+        value: boolean;
+    };
+    /** Signal with the last successful result, action failure, redirect, or null. */
+    data: {
+        value: TOutput | ActionFailure<TOutput> | RedirectResponse | null;
+    };
+    /** Signal with the last error, or null. */
+    error: {
+        value: Error | null;
+    };
+}
+/**
+ * Create a reactive handle for a server action.
+ *
+ * Returns a `submit` function and signals for `pending`, `data`, and `error`.
+ * Useful for wiring actions to forms and islands without manual signal boilerplate.
+ */
+export declare function elurJsAction<TInput = unknown, TOutput = unknown>(name: string, options?: CallActionOptions): ElurJsAction<TInput, TOutput>;
+export { defineAction, type DefineActionOptions, type DefinedAction, type DefinedActionFn, type ActionContext, type ActionInputValidator, type ActionConcurrencyMode, } from "./define.js";

package/dist/lib/action/index.js

@@ -0,0 +1,2 @@
+import { n as e, r as t, t as n } from "../action-BB6N5yD-.js";
+export { n as callAction, t as defineAction, e as elurJsAction };

package/dist/lib/action/origin.d.cts

@@ -0,0 +1,20 @@
+export interface OriginCheckOptions {
+    /** Extra origins allowed to call actions (e.g. preview deployments). */
+    allowedOrigins?: string[];
+    /**
+     * When true, requests missing both `Origin` and `Referer` are rejected.
+     * Defaults to false so curl/server-to-server calls keep working.
+     */
+    strictOrigin?: boolean;
+}
+/**
+ * Verifies that a request originates from the same host (or an allow-listed
+ * origin). Returns an error message when the request must be rejected, or
+ * undefined when it is allowed.
+ *
+ * @param request The incoming Request to actions.
+ * @param options Origin check configuration.
+ */
+export declare function verifyOrigin(request: Request, options?: OriginCheckOptions): string | undefined;
+/** Builds a 403 Response for a rejected origin. */
+export declare function originForbidden(message: string): Response;

package/dist/lib/action/origin.d.ts

@@ -0,0 +1,20 @@
+export interface OriginCheckOptions {
+    /** Extra origins allowed to call actions (e.g. preview deployments). */
+    allowedOrigins?: string[];
+    /**
+     * When true, requests missing both `Origin` and `Referer` are rejected.
+     * Defaults to false so curl/server-to-server calls keep working.
+     */
+    strictOrigin?: boolean;
+}
+/**
+ * Verifies that a request originates from the same host (or an allow-listed
+ * origin). Returns an error message when the request must be rejected, or
+ * undefined when it is allowed.
+ *
+ * @param request The incoming Request to actions.
+ * @param options Origin check configuration.
+ */
+export declare function verifyOrigin(request: Request, options?: OriginCheckOptions): string | undefined;
+/** Builds a 403 Response for a rejected origin. */
+export declare function originForbidden(message: string): Response;

package/dist/lib/action/scan.d.cts

@@ -0,0 +1,28 @@
+/**
+ * Registry of server actions grouped by page path.
+ *
+ * The outer key is the page URL path (e.g. "/contact"). The inner object maps
+ * each exported action name to the absolute file path of the `page.action.ts`
+ * module that defines it.
+ */
+export type ActionRegistry = Record<string, Record<string, string>>;
+/**
+ * Scans `page.action.ts` modules and returns a per-page registry of server actions.
+ *
+ * Only named function exports are collected; default exports are ignored. The
+ * registry is keyed by page URL path so the client can resolve actions scoped
+ * to a specific page and avoid name collisions between different routes.
+ */
+export declare function scanActions(appDir: string): Promise<ActionRegistry>;
+/**
+ * Return a copy of the action registry where every file path is made relative to
+ * the given project root. Useful for serializing actions into the HTML shell
+ * without exposing absolute server paths.
+ */
+export declare function relativeActions(actions: ActionRegistry, root: string): ActionRegistry;
+/**
+ * Return only the names of available actions per page, without file paths.
+ * This is the safe format to serialize into the HTML shell: the client only
+ * needs to know which actions exist, never where they are implemented.
+ */
+export declare function actionNames(actions: ActionRegistry): Record<string, string[]>;

package/dist/lib/action/scan.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Registry of server actions grouped by page path.
+ *
+ * The outer key is the page URL path (e.g. "/contact"). The inner object maps
+ * each exported action name to the absolute file path of the `page.action.ts`
+ * module that defines it.
+ */
+export type ActionRegistry = Record<string, Record<string, string>>;
+/**
+ * Scans `page.action.ts` modules and returns a per-page registry of server actions.
+ *
+ * Only named function exports are collected; default exports are ignored. The
+ * registry is keyed by page URL path so the client can resolve actions scoped
+ * to a specific page and avoid name collisions between different routes.
+ */
+export declare function scanActions(appDir: string): Promise<ActionRegistry>;
+/**
+ * Return a copy of the action registry where every file path is made relative to
+ * the given project root. Useful for serializing actions into the HTML shell
+ * without exposing absolute server paths.
+ */
+export declare function relativeActions(actions: ActionRegistry, root: string): ActionRegistry;
+/**
+ * Return only the names of available actions per page, without file paths.
+ * This is the safe format to serialize into the HTML shell: the client only
+ * needs to know which actions exist, never where they are implemented.
+ */
+export declare function actionNames(actions: ActionRegistry): Record<string, string[]>;

package/dist/lib/action/server.d.cts

@@ -0,0 +1,30 @@
+import { type OriginCheckOptions } from "./origin.js";
+/**
+ * Resolves a server action by name and optional page scope.
+ */
+export type ActionResolver = (name: string, page?: string) => Promise<((...args: unknown[]) => unknown) | undefined>;
+/** Options shared by `handleActionRequest` callers for CSRF protection. */
+export interface ActionSecurityOptions extends OriginCheckOptions {
+    /** Maximum body size in bytes. Defaults to 1MB (1_048_576). */
+    bodyLimit?: number;
+}
+/**
+ * Handles a POST request to the server action endpoint.
+ *
+ * Accepts both JSON requests (`{ name, page?, args }`) and HTML form submissions
+ * for progressive enhancement. The provided resolver looks up the action
+ * implementation, invokes it with the supplied arguments and returns the result
+ * as JSON or redirects back to the request origin for form submissions.
+ *
+ * Origin verification (CSRF protection) runs before parsing the body: any
+ * cross-origin POST is rejected with 403 unless its origin is allow-listed via
+ * `security.allowedOrigins`.
+ *
+ * For progressive-enhancement form submissions that fail, the failure payload
+ * is relayed back via a short-lived `__elur_js_action_error` cookie (SameSite=Lax,
+ * Max-Age=15s) instead of a query param, so errors do not leak into browser
+ * history, server logs or third-party Referer headers.
+ */
+export declare function handleActionRequest(request: Request, resolveAction: ActionResolver, security?: ActionSecurityOptions): Promise<Response>;
+export { verifyOrigin, originForbidden, type OriginCheckOptions } from "./origin.js";
+export { decodeActionErrorCookie, clearActionErrorCookieHeader, setActionErrorCookieHeader, ACTION_ERROR_COOKIE, } from "./error-store.js";

package/dist/lib/action/server.d.ts

@@ -0,0 +1,30 @@
+import { type OriginCheckOptions } from "./origin.js";
+/**
+ * Resolves a server action by name and optional page scope.
+ */
+export type ActionResolver = (name: string, page?: string) => Promise<((...args: unknown[]) => unknown) | undefined>;
+/** Options shared by `handleActionRequest` callers for CSRF protection. */
+export interface ActionSecurityOptions extends OriginCheckOptions {
+    /** Maximum body size in bytes. Defaults to 1MB (1_048_576). */
+    bodyLimit?: number;
+}
+/**
+ * Handles a POST request to the server action endpoint.
+ *
+ * Accepts both JSON requests (`{ name, page?, args }`) and HTML form submissions
+ * for progressive enhancement. The provided resolver looks up the action
+ * implementation, invokes it with the supplied arguments and returns the result
+ * as JSON or redirects back to the request origin for form submissions.
+ *
+ * Origin verification (CSRF protection) runs before parsing the body: any
+ * cross-origin POST is rejected with 403 unless its origin is allow-listed via
+ * `security.allowedOrigins`.
+ *
+ * For progressive-enhancement form submissions that fail, the failure payload
+ * is relayed back via a short-lived `__elur_js_action_error` cookie (SameSite=Lax,
+ * Max-Age=15s) instead of a query param, so errors do not leak into browser
+ * history, server logs or third-party Referer headers.
+ */
+export declare function handleActionRequest(request: Request, resolveAction: ActionResolver, security?: ActionSecurityOptions): Promise<Response>;
+export { verifyOrigin, originForbidden, type OriginCheckOptions } from "./origin.js";
+export { decodeActionErrorCookie, clearActionErrorCookieHeader, setActionErrorCookieHeader, ACTION_ERROR_COOKIE, } from "./error-store.js";

package/dist/lib/action-BB6N5yD-.js

@@ -0,0 +1,111 @@
+import { n as e, t } from "./errors-ePYxDlhU.js";
+import { signal as n } from "@elurjs/core";
+//#region src/action/define.ts
+var r = globalThis.AbortController;
+function i(e, t) {
+	let n = e.concurrency ?? "latest", i = e.idempotent ?? !1, o = e.invalidateTags ?? [], s = e.invalidatePaths ?? [], c = null, l = [], u = 0;
+	async function d(n, r) {
+		if (e.input) try {
+			n = e.input.parse(n);
+		} catch (e) {
+			let t = e instanceof Error ? e.message : String(e), { fail: n } = await import("./errors-ePYxDlhU.js").then((e) => e.r);
+			return n(400, { validation: t });
+		}
+		return t(n, r);
+	}
+	let f = async (e, t) => {
+		if (n === "latest") {
+			c && c.abort(), c = new r();
+			let n = a(t.signal, c.signal);
+			return d(e, {
+				...t,
+				signal: n
+			});
+		}
+		if (n === "queue") {
+			u > 0 && await new Promise((e) => l.push(e)), u++;
+			try {
+				return await d(e, t);
+			} finally {
+				u--;
+				let e = l.shift();
+				e && e();
+			}
+		}
+		return d(e, t);
+	};
+	return f.__elurAction = {
+		name: t.name || "anonymous",
+		concurrency: n,
+		idempotent: i,
+		invalidateTags: o,
+		invalidatePaths: s
+	}, f;
+}
+function a(...e) {
+	let t = new r();
+	for (let n of e) if (n) {
+		if (n.aborted) {
+			t.abort();
+			break;
+		}
+		n.addEventListener("abort", () => t.abort(), { once: !0 });
+	}
+	return t.signal;
+}
+//#endregion
+//#region src/action/index.ts
+function o(e) {
+	return typeof e == "object" && !!e && e.__elur_js_action_failure === !0;
+}
+function s(e) {
+	return typeof e == "object" && !!e && e.__elur_js_action_redirect === !0;
+}
+async function c(n, r = [], i = {}) {
+	let a = Array.isArray(r) ? r : [r], c = await fetch("/__elur-js/actions", {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			Accept: "application/json"
+		},
+		body: JSON.stringify({
+			name: n,
+			page: i.page,
+			args: a
+		})
+	}), l = await c.text();
+	if (!c.ok) {
+		let e;
+		try {
+			e = JSON.parse(l);
+		} catch {}
+		if (o(e) && e.status !== void 0) return new t(e.status, e.data);
+		throw Error(`Action "${n}" failed: ${l}`);
+	}
+	let u = JSON.parse(l);
+	return s(u) && u.status !== void 0 && u.location !== void 0 ? new e(u.status, u.location) : u;
+}
+function l(e, t = {}) {
+	let r = n(!1), i = n(null), a = n(null);
+	async function o(n) {
+		r.value = !0, i.value = null;
+		try {
+			let r = await c(e, n, t);
+			return a.value = r, r;
+		} catch (e) {
+			throw i.value = e instanceof Error ? e : Error(String(e)), e;
+		} finally {
+			r.value = !1;
+		}
+	}
+	return {
+		submit: o,
+		pending: r,
+		data: a,
+		error: i
+	};
+}
+//#endregion
+export { l as n, i as r, c as t };
+
+//# sourceMappingURL=action-BB6N5yD-.js.map