react-form-action 2.9.1 → 2.10.0

package/README.md

@@ -22,6 +22,7 @@ End-to-end typesafe success, error & validation state control for Next.js form a
 - ✅ The `React.useActionState()` accessible via the `useActionContext()` hook.
 - ✅ Computes progress flags like `isInvalid`, `isSuccess` based on the envelope type.
 - ✅ Binds the action with the arguments from the _args_ prop.
+- ✅ Has an optional `validate` prop to validate the form data client-side before calling the server action.
 
 **Context-bound `<Form />` component**
 

package/dist/client.d.mts

@@ -1,31 +1,32 @@
-import * as React$1 from 'react';
-import React__default, { PropsWithChildren, JSX } from 'react';
-import { F as FormAction, A as ActionState, I as InitialState, a as InvalidState, b as FailureState, S as SuccessState } from './createFormAction-DjhozgiG.mjs';
-import { $ZodErrorTree } from 'zod/v4/core';
-
+import { a as InvalidState, i as InitialState, n as FailureState, o as SuccessState, r as FormAction, t as ActionState } from "./createFormAction-4p5Fvn2A.mjs";
+import React$1, { JSX, PropsWithChildren } from "react";
+import { $ZodErrorTree } from "zod/v4/core";
+//#region src/Action.d.ts
 type ActionProps<Data, Error, ValidationError, Arguments extends unknown[] = []> = PropsWithChildren<Arguments extends [unknown, ...unknown[]] ? {
-    action: FormAction<Data, Error, ValidationError, FormData, Arguments>;
-    args: Arguments;
-    initialData: Data;
-    permalink?: string;
+  action: FormAction<Data, Error, ValidationError, FormData, Arguments>;
+  args: Arguments;
+  initialData: Data;
+  permalink?: string;
+  validate?: (payload: FormData) => null | ValidationError;
 } : {
-    action: FormAction<Data, Error, ValidationError, FormData, Arguments>;
-    initialData: Data;
-    args?: undefined;
-    permalink?: string;
+  action: FormAction<Data, Error, ValidationError, FormData, Arguments>;
+  initialData: Data;
+  args?: undefined;
+  permalink?: string;
+  validate?: (payload: FormData) => null | ValidationError;
 }>;
 type ActionStatusFlags<T extends ActionState<unknown, unknown, unknown>["type"] | unknown = unknown> = {
-    isInitial: T extends "initial" ? true : false;
-    isInvalid: T extends "invalid" ? true : false;
-    isFailure: T extends "failure" ? true : false;
-    isSuccess: T extends "success" ? true : false;
+  isInitial: T extends "initial" ? true : false;
+  isInvalid: T extends "invalid" ? true : false;
+  isFailure: T extends "failure" ? true : false;
+  isSuccess: T extends "success" ? true : false;
 };
 type ActionContextState<T extends ActionState<unknown, unknown, unknown>> = T & ActionStatusFlags<T["type"]> & {
-    /**
-     * The dispatch function returned from React.useActionState()
-     */
-    action: (payload: FormData) => void;
-    isPending: boolean;
+  /**
+   * The dispatch function returned from React.useActionState()
+   */
+  action: (payload: FormData) => void;
+  isPending: boolean;
 };
 /**
  * NOTE: ActionContextState<ActionState<...>> would not allow discriminate the union inside of the ActionState.
@@ -35,74 +36,76 @@ type SpreadActionContext<Data = unknown, Error = unknown, ValidationError = unkn
  * A hook to consume the form action state from the context.
  */
 declare function useActionContext<Data, Error, ValidationError, Args extends unknown[] = []>(action?: FormAction<Data, Error, ValidationError, FormData, Args>): SpreadActionContext<Data, Error, ValidationError>;
-declare function Action<Data, Error, ValidationError, Args extends unknown[] = []>({ children, action: formAction, initialData, args, permalink, }: ActionProps<Data, Error, ValidationError, Args>): React__default.JSX.Element;
-
+declare function Action<Data, Error, ValidationError, Args extends unknown[] = []>({ children, action: formAction, initialData, args, permalink, validate }: ActionProps<Data, Error, ValidationError, Args>): React$1.JSX.Element;
+//#endregion
+//#region src/Form.d.ts
 type FormProps = Omit<JSX.IntrinsicElements["form"], "action"> & {
-    /**
-     * Opt-in into automatic form reset by using the form "action" prop.
-     * By default, the onSubmit with a custom transition which opts-out of the implicit form reset.
-     * See for more. https://github.com/facebook/react/issues/29034
-     * @default false
-     */
-    autoReset?: boolean;
+  /**
+   * Opt-in into automatic form reset by using the form "action" prop.
+   * By default, the onSubmit with a custom transition which opts-out of the implicit form reset.
+   * See for more. https://github.com/facebook/react/issues/29034
+   * @default false
+   */
+  autoReset?: boolean;
 };
 declare function Form({ autoReset, ...props }: FormProps): JSX.Element;
-
+//#endregion
+//#region src/ZodFieldError.d.ts
 declare const SEPARATOR: ".";
-type Paths<Shape extends $ZodErrorTree<object>, Props = Required<NonNullable<Shape["properties"]>>> = {
-    [k in keyof Props]: k extends string ? NonNullable<Props[k]> extends $ZodErrorTree<object> ? "properties" extends keyof NonNullable<Props[k]> ? `${k}${typeof SEPARATOR}${Paths<NonNullable<Props[k]>>}` : k : k : never;
-}[keyof Props];
+type Paths<Shape extends $ZodErrorTree<object>, Props = Required<NonNullable<Shape["properties"]>>> = { [k in keyof Props]: k extends string ? NonNullable<Props[k]> extends $ZodErrorTree<object> ? "properties" extends keyof NonNullable<Props[k]> ? `${k}${typeof SEPARATOR}${Paths<NonNullable<Props[k]>>}` : k : k : never; }[keyof Props];
 type InferZodErrorPaths<T> = T extends $ZodErrorTree<object> ? Paths<T> : never;
 type ZodFieldErrorProps<Errors extends $ZodErrorTree<any>, Name extends "" | InferZodErrorPaths<Errors>> = {
-    errors: Errors;
-    name: Name;
-    children?: (props: ZodFieldErrorChildrenProps<Name>) => React__default.ReactNode;
+  errors: Errors;
+  name: Name;
+  children?: (props: ZodFieldErrorChildrenProps<Name>) => React$1.ReactNode;
 };
 type ZodFieldErrorChildrenProps<Name> = {
-    name: Name;
-    error?: string;
-    errors: readonly string[];
+  name: Name;
+  error?: string;
+  errors: readonly string[];
 };
 declare const noError: Readonly<{
-    errors: readonly string[];
+  errors: readonly string[];
 }>;
-declare function ZodFieldError<Errors extends $ZodErrorTree<object>, Name extends "" | InferZodErrorPaths<Errors> = "">({ errors, name, children, }: ZodFieldErrorProps<Errors, Name>): React__default.ReactNode;
-
+declare function ZodFieldError<Errors extends $ZodErrorTree<object>, Name extends "" | InferZodErrorPaths<Errors> = "">({ errors, name, children }: ZodFieldErrorProps<Errors, Name>): React$1.ReactNode;
+//#endregion
+//#region src/createComponents.d.ts
 /**
  * Creates a typed components for actions created with the formAction builder.
  */
 declare function createComponents<Data, Error, ValidationError extends $ZodErrorTree<any>, Args extends unknown[] = []>(action: FormAction<Data, Error, ValidationError, FormData, Args>): {
-    FieldError: <Name extends "" | InferZodErrorPaths<ValidationError>>({ name, children, }: {
-        name: Name;
-        children?: (props: ZodFieldErrorChildrenProps<Name>) => React__default.ReactNode;
-    }) => React__default.JSX.Element;
-    Success: ({ children, }: PropsWithChildren | {
-        children?: (props: {
-            isSuccess: false;
-            data: Data | null;
-        } | {
-            isSuccess: true;
-            data: Data;
-        }) => React__default.ReactNode;
-    }) => React__default.ReactNode;
-    Invalid: ({ children, }: PropsWithChildren | {
-        children?: (props: {
-            isInvalid: false;
-            validationError: null;
-        } | {
-            isInvalid: true;
-            validationError: ValidationError;
-        }) => React__default.ReactNode;
-    }) => React__default.ReactNode;
+  FieldError: <Name extends "" | InferZodErrorPaths<ValidationError>>({ name, children }: {
+    name: Name;
+    children?: (props: ZodFieldErrorChildrenProps<Name>) => React$1.ReactNode;
+  }) => React$1.JSX.Element;
+  Success: ({ children }: PropsWithChildren | {
+    children?: (props: {
+      isSuccess: false;
+      data: Data | null;
+    } | {
+      isSuccess: true;
+      data: Data;
+    }) => React$1.ReactNode;
+  }) => React$1.ReactNode;
+  Invalid: ({ children }: PropsWithChildren | {
+    children?: (props: {
+      isInvalid: false;
+      validationError: null;
+    } | {
+      isInvalid: true;
+      validationError: ValidationError;
+    }) => React$1.ReactNode;
+  }) => React$1.ReactNode;
 };
-
+//#endregion
+//#region src/Pending.d.ts
 /**
  * Conditionally renders the children, when the form action is in the "pending" state.
  */
-declare function Pending({ children, }: PropsWithChildren | {
-    children?: (props: {
-        isPending: boolean;
-    }) => React.ReactNode;
-}): React$1.ReactNode;
-
-export { Action, type ActionContextState, type ActionProps, Form, type FormProps, type InferZodErrorPaths, type Paths, Pending, ZodFieldError, type ZodFieldErrorChildrenProps, type ZodFieldErrorProps, createComponents, noError, useActionContext };
+declare function Pending({ children }: PropsWithChildren | {
+  children?: (props: {
+    isPending: boolean;
+  }) => React.ReactNode;
+}): import("react").ReactNode;
+//#endregion
+export { Action, ActionContextState, ActionProps, Form, FormProps, InferZodErrorPaths, Paths, Pending, ZodFieldError, ZodFieldErrorChildrenProps, ZodFieldErrorProps, createComponents, noError, useActionContext };

package/dist/client.mjs

@@ -1 +1 @@
-"use client";import{a as f}from"./chunk-LPB4R2UB.mjs";import S from"react";import{useActionState as F,createContext as P,use as y}from"react";var c={isInitial:!1,isInvalid:!1,isFailure:!1,isSuccess:!1},E=P(null);function s(e){let t=y(E);if(!t)throw new Error("ActionContext must be initialized before use. Is your useActionContext hook wrapped with an <Action> Component?");return t}function v({children:e,action:t,initialData:a,args:i,permalink:r}){let o=i?t.bind(null,...i):t,[n,l,d]=F(o,f(a),r),u=n.type==="initial"?{...n,...c,action:l,isPending:d,isInitial:!0}:n.type==="invalid"?{...n,...c,action:l,isPending:d,isInvalid:!0}:n.type==="failure"?{...n,...c,action:l,isPending:d,isFailure:!0}:{...n,...c,action:l,isPending:d,isSuccess:!0};return S.createElement(E,{value:u},e)}import h,{startTransition as g}from"react";function I({autoReset:e=!1,...t}){let{action:a}=s();return h.createElement("form",{...e?{action:a}:{onSubmit:r=>{r.preventDefault();let o=r.currentTarget;g(()=>{a(new FormData(o))})}},...t})}import m from"react";import x from"react";var k=".",p=Object.freeze({errors:Object.freeze([])});function A({errors:e,name:t,children:a=({error:i})=>x.createElement(x.Fragment,null,i)}){if(t.length===0)return a({name:t,error:e.errors[0],errors:e.errors});let i=t.split(k),r=e;for(;i.length;){let o=i.shift();if(!r.properties){r=p;break}r=r.properties[o]??p}return a({name:t,error:r.errors[0],errors:r.errors})}function J(e){function t({name:r,children:o}){let{isInvalid:n,validationError:l}=s(e);return m.createElement(A,{errors:l??p,name:r},o??(({error:u})=>n&&m.createElement(m.Fragment,null,u)))}function a({children:r}){let{isSuccess:o,data:n}=s(e);return typeof r=="function"?r(o?{isSuccess:o,data:n}:{isSuccess:o,data:n}):o&&r}function i({children:r}){let{isInvalid:o,validationError:n}=s(e);return typeof r=="function"?r(o?{isInvalid:o,validationError:n}:{isInvalid:o,validationError:n}):o&&r}return{FieldError:t,Success:a,Invalid:i}}function q({children:e}){let{isPending:t}=s();return typeof e=="function"?e({isPending:t}):t&&e}export{v as Action,I as Form,q as Pending,A as ZodFieldError,J as createComponents,p as noError,s as useActionContext};
+"use client";import{n as e,t}from"./createFormAction-BwMYAzm2.mjs";import n,{createContext as r,startTransition as i,use as a,useActionState as o}from"react";const s={isInitial:!1,isInvalid:!1,isFailure:!1,isSuccess:!1},c=r(null);function l(e){let t=a(c);if(!t)throw Error(`ActionContext must be initialized before use. Is your useActionContext hook wrapped with an <Action> Component?`);return t}function u({children:r,action:i,initialData:a,args:l,permalink:u,validate:d}){let f=l?i.bind(null,...l):i,[p,m,h]=o(async(e,n)=>{if(d){let r=await t(({invalid:e,success:t})=>async(n,r)=>{let i=d(r);return i?e(i):t(!0)})(e,n);if(r.type===`invalid`)return r}return f(e,n)},e(a),u),g=p.type===`initial`?{...p,...s,action:m,isPending:h,isInitial:!0}:p.type===`invalid`?{...p,...s,action:m,isPending:h,isInvalid:!0}:p.type===`failure`?{...p,...s,action:m,isPending:h,isFailure:!0}:{...p,...s,action:m,isPending:h,isSuccess:!0};return n.createElement(c,{value:g},r)}function d({autoReset:e=!1,...t}){let{action:r}=l(),a=e?{action:r}:{onSubmit:e=>{e.preventDefault();let t=e.currentTarget;i(()=>{r(new FormData(t))})}};return n.createElement(`form`,{...a,...t})}const f=Object.freeze({errors:Object.freeze([])});function p({errors:e,name:t,children:r=({error:e})=>n.createElement(n.Fragment,null,e)}){if(t.length===0)return r({name:t,error:e.errors[0],errors:e.errors});let i=t.split(`.`),a=e;for(;i.length;){let e=i.shift();if(!a.properties){a=f;break}a=a.properties[e]??f}return r({name:t,error:a.errors[0],errors:a.errors})}function m(e){function t({name:t,children:r}){let{isInvalid:i,validationError:a}=l(e);return n.createElement(p,{errors:a??f,name:t},r??(({error:e})=>i&&n.createElement(n.Fragment,null,e)))}function r({children:t}){let{isSuccess:n,data:r}=l(e);return typeof t==`function`?t({isSuccess:n,data:r}):n&&t}function i({children:t}){let{isInvalid:n,validationError:r}=l(e);return typeof t==`function`?t({isInvalid:n,validationError:r}):n&&t}return{FieldError:t,Success:r,Invalid:i}}function h({children:e}){let{isPending:t}=l();return typeof e==`function`?e({isPending:t}):t&&e}export{u as Action,d as Form,h as Pending,p as ZodFieldError,m as createComponents,f as noError,l as useActionContext};

package/dist/{createFormAction-DjhozgiG.d.mts → createFormAction-4p5Fvn2A.d.mts}

@@ -1,38 +1,35 @@
+//#region src/createFormAction.d.ts
 type InitialState<T> = {
-    type: "initial";
-    data: T;
-    error: null;
-    validationError: null;
+  type: "initial";
+  data: T;
+  error: null;
+  validationError: null;
 };
 type InvalidState<T> = {
-    type: "invalid";
-    data: null;
-    error: null;
-    validationError: T;
+  type: "invalid";
+  data: null;
+  error: null;
+  validationError: T;
 };
 type FailureState<T> = {
-    type: "failure";
-    data: null;
-    error: T;
-    validationError: null;
+  type: "failure";
+  data: null;
+  error: T;
+  validationError: null;
 };
 type SuccessState<T> = {
-    type: "success";
-    data: T;
-    error: null;
-    validationError: null;
+  type: "success";
+  data: T;
+  error: null;
+  validationError: null;
 };
 type ActionState<Data, Error, ValidationError = Record<string, never>> = InitialState<Data> | InvalidState<ValidationError> | FailureState<Error> | SuccessState<Data>;
-type FormAction<Data, Error = Data, ValidationError = Record<string, never>, Payload = FormData, Arguments extends unknown[] = []> = (...args: [
-    ...Arguments,
-    state: ActionState<Data, Error, ValidationError>,
-    payload: Payload
-]) => Promise<ActionState<Data, Error, ValidationError>>;
+type FormAction<Data, Error = Data, ValidationError = Record<string, never>, Payload = FormData, Arguments extends unknown[] = []> = (...args: [...Arguments, state: ActionState<Data, Error, ValidationError>, payload: Payload]) => Promise<ActionState<Data, Error, ValidationError>>;
 declare function initial<Data>(data: Data): InitialState<Data>;
 declare function createFormAction<Data, Error = Data, ValidationError = Record<string, never>, Payload = FormData, Arguments extends [...unknown[]] = []>(formAction: (params: {
-    success: (data: Data) => SuccessState<Data>;
-    failure: (error: Error) => FailureState<Error>;
-    invalid: (validationError: ValidationError) => InvalidState<ValidationError>;
+  success: (data: Data) => SuccessState<Data>;
+  failure: (error: Error) => FailureState<Error>;
+  invalid: (validationError: ValidationError) => InvalidState<ValidationError>;
 }, ...args: Arguments) => FormAction<Data, Error, ValidationError, Payload>): (...args: [...Arguments, state: ActionState<Data, Error, ValidationError>, payload: Payload]) => Promise<ActionState<Data, Error, ValidationError>>;
-
-export { type ActionState as A, type FormAction as F, type InitialState as I, type SuccessState as S, type InvalidState as a, type FailureState as b, createFormAction as c, initial as i };
+//#endregion
+export { InvalidState as a, initial as c, InitialState as i, FailureState as n, SuccessState as o, FormAction as r, createFormAction as s, ActionState as t };

package/dist/createFormAction-BwMYAzm2.mjs

@@ -0,0 +1 @@
+function e(e){return{type:`initial`,data:e,error:null,validationError:null}}function t(e){function t(e){return{type:`success`,data:e,error:null,validationError:null}}function n(e){return{type:`failure`,data:null,error:e,validationError:null}}function r(e){return{type:`invalid`,data:null,error:null,validationError:e}}return(...i)=>{let a=i.pop(),o=i.pop(),s=[...i];return e({success:t,failure:n,invalid:r},...s)(o,a)}}export{e as n,t};

package/dist/index.d.mts

@@ -1,68 +1,57 @@
-import { A as ActionState, a as InvalidState, b as FailureState, S as SuccessState } from './createFormAction-DjhozgiG.mjs';
-export { F as FormAction, I as InitialState, c as createFormAction, i as initial } from './createFormAction-DjhozgiG.mjs';
-import { ZodType, z, ZodTuple, ZodObject } from 'zod/v4';
-import { $ZodType, $ZodShape, $ZodErrorTree } from 'zod/v4/core';
-
+import { a as InvalidState, c as initial, i as InitialState, n as FailureState, o as SuccessState, r as FormAction, s as createFormAction, t as ActionState } from "./createFormAction-4p5Fvn2A.mjs";
+import { ZodObject, ZodTuple, ZodType, z } from "zod/v4";
+import { $ZodErrorTree, $ZodShape, $ZodType } from "zod/v4/core";
+//#region src/formAction.d.ts
 declare const emptyInput: unique symbol;
 type EmptyInput = typeof emptyInput;
-type Flatten<T> = Identity<{
-    [K in keyof T]: T[K];
-}>;
+type Flatten<T> = Identity<{ [K in keyof T]: T[K]; }>;
 type Identity<T> = T;
 type ErrorHandler<Context, Err, Args> = (params: {
-    error: unknown;
-    ctx: Context;
-    args: Args;
+  error: unknown;
+  ctx: Context;
+  args: Args;
 }) => Promise<Err>;
 type InitialContext = Record<"formData", FormData>;
 /**
  * Action without schema has no input.
  */
 type Action<Data, Context, Args extends unknown[]> = (params: {
-    args: Args;
-    ctx: Context;
+  args: Args;
+  ctx: Context;
 }) => Promise<Data>;
 /**
  * Action with schema will get parsed formData as the input.
  */
 type SchemaAction<Data, Context, Args extends unknown[], Schema extends ZodType> = (params: {
-    args: Args;
-    ctx: Context;
-    input: z.output<Schema>;
+  args: Args;
+  ctx: Context;
+  input: z.output<Schema>;
 }) => Promise<Data>;
 type FormActionBuilder<Schema extends ZodType | EmptyInput, Args extends $ZodType[] = [], TErr = unknown, Context = InitialContext, PlainArgs extends unknown[] = z.output<ZodTuple<Args, null>>> = {
-    args: <T extends [$ZodType, ...$ZodType[]]>(args: T) => FormActionBuilder<Schema, [...Args, ...T], TErr, Context>;
-    input: <T extends ZodObject>(newInput: T extends ZodObject ? T : "The schema output must be an object.") => FormActionBuilder<Schema extends ZodObject<infer O1 extends $ZodShape> ? T extends ZodObject<infer O2 extends $ZodShape> ? ZodObject<O1 & O2> : never : T, Args, TErr, Context>;
-    /**
-     * A finishing call on the builder completing your action.
-     * @param action async function to execute. It will receive parsed formData as input, when the builder was initialized with a schema.
-     * @returns runnable server action exportable from a module.
-     */
-    run: Schema extends ZodType ? <Data>(action: SchemaAction<Data, Flatten<Context>, PlainArgs, Schema>) => (...args: [
-        ...PlainArgs,
-        state: ActionState<Data, TErr, $ZodErrorTree<z.output<Schema>> & $ZodErrorTree<PlainArgs>>,
-        payload: FormData
-    ]) => Promise<Flatten<InvalidState<$ZodErrorTree<z.output<Schema>> & $ZodErrorTree<PlainArgs>> | FailureState<TErr> | SuccessState<Data>>> : <Data>(action: Action<Data, Flatten<Context>, PlainArgs>) => (...args: [
-        ...PlainArgs,
-        state: ActionState<Data, TErr, $ZodErrorTree<PlainArgs>>,
-        payload: FormData
-    ]) => Promise<Flatten<InvalidState<$ZodErrorTree<PlainArgs>> | FailureState<TErr> | SuccessState<Data>>>;
-    /**
-     * A chainable context enhancing helper.
-     * @param middleware A function which receives the current context, and returns an object which will be added to the context.
-     * @returns FormActionBuilder
-     */
-    use: <NewContext extends Record<string, unknown>>(middleware: ({ ctx }: {
-        ctx: Context;
-    }) => Promise<NewContext>) => FormActionBuilder<Schema, Args, TErr, Context & NewContext>;
-    /**
-     * A chainable error handler to handle errors thrown while running the action passed to .run().
-     * It does not receive errors thrown from the context/middleware.
-     * @param processError A function which receives action's errors.
-     * @returns FormActionBuilder
-     */
-    error: <TErr>(processError: ErrorHandler<Context, TErr, PlainArgs>) => FormActionBuilder<Schema, Args, TErr, Context>;
+  args: <T extends [$ZodType, ...$ZodType[]]>(args: T) => FormActionBuilder<Schema, [...Args, ...T], TErr, Context>;
+  input: <T extends ZodObject>(newInput: T extends ZodObject ? T : "The schema output must be an object.") => FormActionBuilder<Schema extends ZodObject<infer O1 extends $ZodShape> ? T extends ZodObject<infer O2 extends $ZodShape> ? ZodObject<O1 & O2> : never : T, Args, TErr, Context>;
+  /**
+   * A finishing call on the builder completing your action.
+   * @param action async function to execute. It will receive parsed formData as input, when the builder was initialized with a schema.
+   * @returns runnable server action exportable from a module.
+   */
+  run: Schema extends ZodType ? <Data>(action: SchemaAction<Data, Flatten<Context>, PlainArgs, Schema>) => (...args: [...PlainArgs, state: ActionState<Data, TErr, $ZodErrorTree<z.output<Schema>> & $ZodErrorTree<PlainArgs>>, payload: FormData]) => Promise<Flatten<InvalidState<$ZodErrorTree<z.output<Schema>> & $ZodErrorTree<PlainArgs>> | FailureState<TErr> | SuccessState<Data>>> : <Data>(action: Action<Data, Flatten<Context>, PlainArgs>) => (...args: [...PlainArgs, state: ActionState<Data, TErr, $ZodErrorTree<PlainArgs>>, payload: FormData]) => Promise<Flatten<InvalidState<$ZodErrorTree<PlainArgs>> | FailureState<TErr> | SuccessState<Data>>>;
+  /**
+   * A chainable context enhancing helper.
+   * @param middleware A function which receives the current context, and returns an object which will be added to the context.
+   * @returns FormActionBuilder
+   */
+  use: <NewContext extends Record<string, unknown>>(middleware: ({ ctx }: {
+    ctx: Context;
+  }) => Promise<NewContext>) => FormActionBuilder<Schema, Args, TErr, Context & NewContext>;
+  /**
+   * A chainable error handler to handle errors thrown while running the action passed to .run().
+   * It does not receive errors thrown from the context/middleware.
+   * @param processError A function which receives action's errors.
+   * @returns FormActionBuilder
+   */
+  error: <TErr>(processError: ErrorHandler<Context, TErr, PlainArgs>) => FormActionBuilder<Schema, Args, TErr, Context>;
 };
 declare const formAction: FormActionBuilder<typeof emptyInput, [], unknown, InitialContext, []>;
-
-export { ActionState, FailureState, InvalidState, SuccessState, formAction };
+//#endregion
+export { ActionState, FailureState, FormAction, InitialState, InvalidState, SuccessState, createFormAction, formAction, initial };

package/dist/index.mjs

@@ -1 +1 @@
-import{a as w,b as A}from"./chunk-LPB4R2UB.mjs";import{z as c}from"zod/v4";import{zfd as C}from"zod-form-data";var T=Symbol();function d(r,i=[],a,n){async function f(t){let e={formData:t};for(let p of i){let u=await p({ctx:e});e={...e,...u}}return e}return{args(t){let e=n?[...n,...t]:t;return d(r,i,a,e)},input(t){if(r===T)return d(t,i,a,n);if(r._zod.def.checks)throw new Error("Previous input is not augmentable because it contains an effect.");if(t._zod.def.checks)throw new Error("Your input contains effect which prevents merging it with the previous inputs.");if(r._zod.def.type==="object"){let e=c.object({...r.shape,...t.shape});return d(e,i)}else throw Error("Merging inputs works only for object schemas without effects.")},use(t){return d(r,[...i,t],a,n)},error(t){return d(r,i,t,n)},run:r===T?t=>A(({success:e,failure:p,invalid:u},...s)=>async(y,g)=>{let x=await f(g);if(n){let o=c.tuple(n).safeParse(s);if(!o.success)return u(c.treeifyError(o.error))}try{return e(await t({args:s,ctx:x}))}catch(o){if(a)return p(await a({args:s,error:o,ctx:x}));throw o}}):r===T?void 0:t=>A(({success:e,failure:p,invalid:u},...s)=>{let y=C.formData(r);return async(g,x)=>{let o=await f(x);if(n){let l=c.tuple(n).safeParse(s);if(!l.success)return u(c.treeifyError(l.error))}let m=y.safeParse(x);if(!m.success)return u(c.treeifyError(m.error));let E=m.data;try{return e(await t({args:s,input:E,ctx:o}))}catch(l){if(a)return p(await a({args:s,error:l,ctx:o}));throw l}}})}}var k=d(T);export{A as createFormAction,k as formAction,w as initial};
+import{n as e,t}from"./createFormAction-BwMYAzm2.mjs";import{z as n}from"zod/v4";import{zfd as r}from"zod-form-data";const i=Symbol();function a(e,o=[],s,c){async function l(e){let t={formData:e};for(let e of o){let n=await e({ctx:t});t={...t,...n}}return t}return{args(t){return a(e,o,s,c?[...c,...t]:t)},input(t){if(e===i)return a(t,o,s,c);if(e._zod.def.checks)throw Error(`Previous input is not augmentable because it contains an effect.`);if(t._zod.def.checks)throw Error(`Your input contains effect which prevents merging it with the previous inputs.`);if(e._zod.def.type===`object`)return a(n.object({...e.shape,...t.shape}),o,s,c);throw Error(`Merging inputs works only for object schemas without effects.`)},use(t){return a(e,[...o,t],s,c)},error(t){return a(e,o,t,c)},run:e===i?e=>t(({success:t,failure:r,invalid:i},...a)=>async(o,u)=>{let d=await l(u);if(c){let e=n.tuple(c).safeParse(a);if(!e.success)return i(n.treeifyError(e.error))}try{return t(await e({args:a,ctx:d}))}catch(e){if(s)return r(await s({args:a,error:e,ctx:d}));throw e}}):e===i?void 0:i=>t(({success:t,failure:a,invalid:o},...u)=>{let d=r.formData(e);return async(e,r)=>{let f=await l(r);if(c){let e=n.tuple(c).safeParse(u);if(!e.success)return o(n.treeifyError(e.error))}let p=d.safeParse(r);if(!p.success)return o(n.treeifyError(p.error));let m=p.data;try{return t(await i({args:u,input:m,ctx:f}))}catch(e){if(s)return a(await s({args:u,error:e,ctx:f}));throw e}}})}}const o=a(i);export{t as createFormAction,o as formAction,e as initial};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-form-action",
-  "version": "2.9.1",
+  "version": "2.10.0",
   "description": "State management helpers for the react form actions.",
   "repository": {
     "type": "git",
@@ -12,7 +12,7 @@
     "/dist"
   ],
   "scripts": {
-    "build": "tsup",
+    "build": "tsdown src/index.ts src/client.ts --minify",
     "test": "vitest",
     "typecheck": "vitest --typecheck",
     "format": "prettier . --write",
@@ -56,21 +56,21 @@
   },
   "devDependencies": {
     "@testing-library/dom": "^10.4.1",
-    "@testing-library/jest-dom": "^6.9.1",
-    "@testing-library/react": "^16.3.0",
+    "@testing-library/jest-dom": "^7.0.0",
+    "@testing-library/react": "^16.3.2",
     "@testing-library/user-event": "^14.6.1",
-    "@types/react": "^19.2.2",
-    "@types/react-dom": "^19.2.2",
-    "@vitejs/plugin-react": "^5.1.0",
-    "happy-dom": "^20.0.8",
-    "npm-check-updates": "^19.1.1",
-    "prettier": "^3.6.2",
-    "react": "^19.2.0",
-    "react-dom": "^19.2.0",
-    "tsup": "^8.5.0",
-    "typescript": "^5.9.3",
-    "vitest": "^4.0.4",
-    "zod": "^3.25.0",
-    "zod-form-data": "^3.0.1"
+    "@types/react": "^19.2.17",
+    "@types/react-dom": "^19.2.3",
+    "@vitejs/plugin-react": "^6.0.3",
+    "happy-dom": "^20.11.0",
+    "npm-check-updates": "^22.2.9",
+    "prettier": "^3.9.6",
+    "react": "^19.2.7",
+    "react-dom": "^19.2.7",
+    "tsdown": "^0.22.12",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.10",
+    "zod": "^4.4.3",
+    "zod-form-data": "^3.0.3"
   }
 }

package/dist/chunk-LPB4R2UB.mjs

@@ -1 +0,0 @@
-function u(a){return{type:"initial",data:a,error:null,validationError:null}}function d(a){function t(r){return{type:"success",data:r,error:null,validationError:null}}function o(r){return{type:"failure",data:null,error:r,validationError:null}}function n(r){return{type:"invalid",data:null,error:null,validationError:r}}return(...r)=>{let e=r.pop(),i=r.pop(),l=[...r];return a({success:t,failure:o,invalid:n},...l)(i,e)}}export{u as a,d as b};