@conform-to/react 1.19.4 → 1.20.0

package/README.md

@@ -7,7 +7,7 @@
  ╚══════╝  ╚═════╝  ╚═╝  ╚══╝ ╚═╝        ╚═════╝  ╚═╝   ╚═╝ ╚═╝   ╚═╝
 ```
 
-Version 1.19.4 / License MIT / Copyright (c) 2026 Edmund Hung
+Version 1.20.0 / License MIT / Copyright (c) 2026 Edmund Hung
 
 Progressively enhance HTML forms with React. Build resilient, type-safe forms with no hassle using web standards.
 

package/dist/context.d.ts

@@ -20,7 +20,7 @@ export type Metadata<Schema, FormSchema extends Record<string, unknown>, FormErr
     valid: boolean;
     dirty: boolean;
 };
-export type FormMetadata<Schema extends Record<string, unknown> = Record<string, unknown>, FormError = string[]> = Omit<Metadata<Schema, Schema, FormError>, 'id'> & Pick<FormContext<Schema, FormError>, Intent['type']> & {
+export type FormMetadata<Schema extends Record<string, unknown> = any, FormError = string[]> = Omit<Metadata<Schema, Schema, FormError>, 'id'> & Pick<FormContext<Schema, FormError>, Intent['type']> & {
     id: FormId<Schema, FormError>;
     context: Wrapped<FormContext<Schema, FormError>>;
     status?: 'success' | 'error';
@@ -37,7 +37,7 @@ type SubfieldMetadata<Schema, FormSchema extends Record<string, any>, FormError>
         [Key in keyof Combine<Schema>]: FieldMetadata<Combine<Schema>[Key], FormSchema, FormError>;
     }>;
 } : {};
-export type FieldMetadata<Schema = unknown, FormSchema extends Record<string, any> = Record<string, unknown>, FormError = string[]> = Metadata<Schema, FormSchema, FormError> & Constraint & {
+export type FieldMetadata<Schema = unknown, FormSchema extends Record<string, any> = any, FormError = string[]> = Metadata<Schema, FormSchema, FormError> & Constraint & {
     formId: FormId<FormSchema, FormError>;
 } & SubfieldMetadata<Schema, FormSchema, FormError>;
 export declare const Form: import("react").Context<FormContext<any, string[], any>[]>;

package/dist/future/dom.d.ts

@@ -1,5 +1,5 @@
 import { Serialize } from '@conform-to/dom/future';
-import type { ControlOptions, ErrorContext, FormRef, IntentDispatcher } from './types';
+import type { ControlOptions, ErrorContext, FormRef, IntentDispatcher, IntentHandler } from './types';
 export declare function getFormElement(formRef: FormRef | undefined): HTMLFormElement | null;
 export declare function getSubmitEvent(event: React.FormEvent<HTMLFormElement>): SubmitEvent;
 export declare function initializeField(element: HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement, options: {
@@ -20,7 +20,7 @@ export declare function resetFormValue(form: HTMLFormElement, defaultValue: Reco
  * Creates a proxy that dynamically generates intent dispatch functions.
  * Each property access returns a function that submits the intent to the form.
  */
-export declare function createIntentDispatcher<FormShape extends Record<string, any>>(formElement: HTMLFormElement | (() => HTMLFormElement | null), intentName: string): IntentDispatcher<FormShape>;
+export declare function createIntentDispatcher<FormShape extends Record<string, any>, IntentHandlers extends Record<string, IntentHandler<any, any>>>(formElement: HTMLFormElement | (() => HTMLFormElement | null), intentName: string): IntentDispatcher<FormShape, IntentHandlers>;
 /**
  * Restores values from preserved inputs and removes them.
  * Called when PreserveBoundary mounts.

package/dist/future/dom.js

@@ -97,7 +97,9 @@ function resolveControlPayload(input) {
       }
     }
     for (var [name, _value] of entries) {
-      future.setPathValue(result, name, _value);
+      future.setPathValue(result, name, _value, {
+        mutate: true
+      });
     }
     return future.getPathValue(result, input.name);
   }
@@ -118,7 +120,7 @@ function deriveDefaultPayload(options) {
  * Does nothing if the submission was triggered with a specific intent (e.g. validate / insert)
  */
 function focusFirstInvalidField(ctx) {
-  if (ctx.intent) {
+  if (ctx.intent && ctx.intent.type !== 'submit') {
     return;
   }
   for (var element of ctx.formElement.elements) {
@@ -182,14 +184,17 @@ function createIntentDispatcher(formElement, intentName) {
       if (typeof type === 'string') {
         var _target$type;
         // @ts-expect-error
-        (_target$type = target[type]) !== null && _target$type !== void 0 ? _target$type : target[type] = payload => {
+        (_target$type = target[type]) !== null && _target$type !== void 0 ? _target$type : target[type] = function () {
           var form = typeof formElement === 'function' ? formElement() : formElement;
           if (!form) {
             throw new Error("Dispatching \"".concat(type, "\" intent failed; No form element found."));
           }
+          for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+            args[_key] = arguments[_key];
+          }
           future.requestIntent(form, intentName, intent.serializeIntent({
             type,
-            payload
+            args
           }));
         };
       }

package/dist/future/dom.mjs

@@ -93,7 +93,9 @@ function resolveControlPayload(input) {
       }
     }
     for (var [name, _value] of entries) {
-      setPathValue(result, name, _value);
+      setPathValue(result, name, _value, {
+        mutate: true
+      });
     }
     return getPathValue(result, input.name);
   }
@@ -114,7 +116,7 @@ function deriveDefaultPayload(options) {
  * Does nothing if the submission was triggered with a specific intent (e.g. validate / insert)
  */
 function focusFirstInvalidField(ctx) {
-  if (ctx.intent) {
+  if (ctx.intent && ctx.intent.type !== 'submit') {
     return;
   }
   for (var element of ctx.formElement.elements) {
@@ -178,14 +180,17 @@ function createIntentDispatcher(formElement, intentName) {
       if (typeof type === 'string') {
         var _target$type;
         // @ts-expect-error
-        (_target$type = target[type]) !== null && _target$type !== void 0 ? _target$type : target[type] = payload => {
+        (_target$type = target[type]) !== null && _target$type !== void 0 ? _target$type : target[type] = function () {
           var form = typeof formElement === 'function' ? formElement() : formElement;
           if (!form) {
             throw new Error("Dispatching \"".concat(type, "\" intent failed; No form element found."));
           }
+          for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+            args[_key] = arguments[_key];
+          }
           requestIntent(form, intentName, serializeIntent({
             type,
-            payload
+            args
           }));
         };
       }

package/dist/future/forms.d.ts

@@ -1,31 +1,46 @@
 import { FieldName } from '@conform-to/dom';
+import { type Submission, FormValue } from '@conform-to/dom/future';
 import { StandardSchemaV1 } from './standard-schema';
-import { FormRef, FormsConfig, FormContext, FormMetadata, FormOptions, FieldMetadata, InferOutput, IntentDispatcher, InferFormShape, RequireKey, FormHandle } from './types';
-export declare function configureForms<BaseErrorShape = any, BaseSchema = StandardSchemaV1, SchemaErrorShape = string[], CustomFormMetadata extends Record<string, unknown> = {}, CustomFieldMetadata extends Record<string, unknown> = {}>(config?: Partial<FormsConfig<BaseErrorShape, BaseSchema, SchemaErrorShape, CustomFormMetadata, CustomFieldMetadata>>): {
+import type { FormRef, FormsConfig, FormContext, FormMetadata, FormOptions, FieldMetadata, FormHandle, FormCustomState, InferOutput, InferFormShape, DefaultIntentHandlers, IntentHandler, IntentDispatcher, RequireKey, FormIntent, CustomStateHandler } from './types';
+export declare function configureForms<BaseErrorShape = any, BaseSchema = StandardSchemaV1, SchemaErrorShape = string[], CustomFormMetadata extends Record<string, unknown> = {}, CustomFieldMetadata extends Record<string, unknown> = {}, GlobalIntentHandlers extends Record<string, IntentHandler<any, any>> = {}, GlobalCustomStateHandlers extends Record<string, CustomStateHandler<any, any, BaseErrorShape>> = {}>(config?: Partial<FormsConfig<BaseErrorShape, BaseSchema, SchemaErrorShape, CustomFormMetadata, CustomFieldMetadata, GlobalIntentHandlers, GlobalCustomStateHandlers>>): {
     FormProvider: (props: {
-        context: FormContext<BaseErrorShape>;
+        context: FormContext<BaseErrorShape, FormCustomState<GlobalCustomStateHandlers>>;
         children: React.ReactNode;
     }) => React.ReactElement;
     useForm: {
-        <Schema extends BaseSchema, ErrorShape extends BaseErrorShape, Value = InferOutput<Schema>>(schema: Schema, options: RequireKey<FormOptions<InferFormShape<Schema>, ErrorShape, Value, Schema, SchemaErrorShape>, "onValidate">): FormHandle<InferFormShape<Schema>, ErrorShape, CustomFormMetadata, CustomFieldMetadata>;
-        <Schema extends BaseSchema, ErrorShape extends BaseErrorShape = SchemaErrorShape extends BaseErrorShape ? SchemaErrorShape : BaseErrorShape, Value = InferOutput<Schema>>(schema: Schema, options: RequireKey<FormOptions<InferFormShape<Schema>, ErrorShape, Value, Schema, SchemaErrorShape>, SchemaErrorShape extends BaseErrorShape ? never : "onValidate">): FormHandle<InferFormShape<Schema>, ErrorShape, CustomFormMetadata, CustomFieldMetadata>;
-        <FormShape extends Record<string, any> = Record<string, any>, ErrorShape extends BaseErrorShape = BaseErrorShape, Value = undefined>(options: RequireKey<FormOptions<FormShape, ErrorShape, Value, undefined, SchemaErrorShape>, "onValidate">): FormHandle<FormShape, ErrorShape, CustomFormMetadata, CustomFieldMetadata>;
+        <Schema extends BaseSchema, ErrorShape extends BaseErrorShape, Value = InferOutput<Schema>, CustomIntentHandlers extends Record<string, IntentHandler<any, any>> = {}, CustomStateHandlers extends Record<string, CustomStateHandler<any, any, ErrorShape>> = {}>(schema: Schema, options: RequireKey<FormOptions<InferFormShape<Schema>, ErrorShape, Value, Schema, SchemaErrorShape, CustomIntentHandlers, GlobalIntentHandlers, CustomStateHandlers>, "onValidate">): FormHandle<InferFormShape<Schema>, ErrorShape, CustomFormMetadata, CustomFieldMetadata, GlobalIntentHandlers & CustomIntentHandlers, FormCustomState<GlobalCustomStateHandlers & CustomStateHandlers>>;
+        <Schema extends BaseSchema, ErrorShape extends BaseErrorShape = SchemaErrorShape extends BaseErrorShape ? SchemaErrorShape : BaseErrorShape, Value = InferOutput<Schema>, CustomIntentHandlers extends Record<string, IntentHandler<any, any>> = {}, CustomStateHandlers extends Record<string, CustomStateHandler<any, any, ErrorShape>> = {}>(schema: Schema, options: RequireKey<FormOptions<InferFormShape<Schema>, ErrorShape, Value, Schema, SchemaErrorShape, CustomIntentHandlers, GlobalIntentHandlers, CustomStateHandlers>, SchemaErrorShape extends BaseErrorShape ? never : "onValidate">): FormHandle<InferFormShape<Schema>, ErrorShape, CustomFormMetadata, CustomFieldMetadata, GlobalIntentHandlers & CustomIntentHandlers, FormCustomState<GlobalCustomStateHandlers & CustomStateHandlers>>;
+        <FormShape extends Record<string, any> = Record<string, any>, ErrorShape extends BaseErrorShape = BaseErrorShape, Value = undefined, CustomIntentHandlers extends Record<string, IntentHandler<any, any>> = {}, CustomStateHandlers extends Record<string, CustomStateHandler<any, any, ErrorShape>> = {}>(options: RequireKey<FormOptions<FormShape, ErrorShape, Value, undefined, SchemaErrorShape, CustomIntentHandlers, GlobalIntentHandlers, CustomStateHandlers>, "onValidate">): FormHandle<FormShape, ErrorShape, CustomFormMetadata, CustomFieldMetadata, GlobalIntentHandlers & CustomIntentHandlers, FormCustomState<GlobalCustomStateHandlers & CustomStateHandlers>>;
     };
     useFormMetadata: (options?: {
         formId?: string;
-    }) => FormMetadata<BaseErrorShape, CustomFormMetadata, CustomFieldMetadata>;
+    }) => FormMetadata<BaseErrorShape, CustomFormMetadata, CustomFieldMetadata, FormCustomState<GlobalCustomStateHandlers>>;
     useField: <FieldShape = any>(name: FieldName<FieldShape>, options?: {
         formId?: string;
     }) => FieldMetadata<FieldShape, BaseErrorShape, CustomFieldMetadata>;
-    useIntent: <FormShape extends Record<string, any>>(formRef: FormRef) => IntentDispatcher<FormShape>;
-    config: FormsConfig<BaseErrorShape, BaseSchema, SchemaErrorShape, CustomFormMetadata, CustomFieldMetadata>;
+    useIntent: {
+        (formRef: FormRef): IntentDispatcher<Record<string, any>, DefaultIntentHandlers & GlobalIntentHandlers>;
+        <IntentHandlers extends Record<string, IntentHandler<any, any>>>(formRef: FormRef): IntentDispatcher<Record<string, any>, DefaultIntentHandlers & GlobalIntentHandlers & IntentHandlers>;
+        <FormShape extends Record<string, any>>(formRef: FormRef): IntentDispatcher<FormShape, DefaultIntentHandlers & GlobalIntentHandlers>;
+        <FormShape extends Record<string, any>, IntentHandlers extends Record<string, IntentHandler<any, any>>>(formRef: FormRef): IntentDispatcher<FormShape, DefaultIntentHandlers & GlobalIntentHandlers & IntentHandlers>;
+    };
+    resolveSubmission: <IntentHandlers extends Record<string, IntentHandler<any, any>> = {}>(submission: Submission, options?: {
+        handlers?: IntentHandlers;
+    }) => {
+        intent: FormIntent<Record<string, any>, DefaultIntentHandlers & GlobalIntentHandlers & IntentHandlers> | {
+            type: "submit";
+            payload: undefined;
+        } | undefined;
+        targetValue: Record<string, FormValue> | undefined;
+    };
+    config: FormsConfig<BaseErrorShape, BaseSchema, SchemaErrorShape, CustomFormMetadata, CustomFieldMetadata, GlobalIntentHandlers, GlobalCustomStateHandlers>;
 };
 /**
  * Provides form context to child components.
  * Stacks contexts to support nested forms, with latest context taking priority.
  */
 export declare const FormProvider: (props: {
-    context: FormContext<any>;
+    context: FormContext<any, FormCustomState<{}>>;
     children: React.ReactNode;
 }) => React.ReactElement;
 /**
@@ -75,7 +90,7 @@ export declare const FormProvider: (props: {
  * ```
  */
 export declare const useForm: {
-    <Schema extends StandardSchemaV1<unknown, unknown>, ErrorShape extends any, Value = InferOutput<Schema>>(schema: Schema, options: {
+    <Schema extends StandardSchemaV1<unknown, unknown>, ErrorShape extends any, Value = InferOutput<Schema>, CustomIntentHandlers extends Record<string, IntentHandler<any, any>> = {}, CustomStateHandlers extends Record<string, CustomStateHandler<any, any, ErrorShape>> = {}>(schema: Schema, options: {
         id?: string | undefined | undefined;
         key?: string | undefined | undefined;
         defaultValue?: import("./types").DefaultValue<InferFormShape<Schema>> | undefined;
@@ -87,11 +102,13 @@ export declare const useForm: {
         shouldRevalidate?: "onSubmit" | "onBlur" | "onInput" | undefined | undefined;
         onSubmit?: import("./types").SubmitHandler<InferFormShape<Schema>, NoInfer<ErrorShape>, NoInfer<Value>> | undefined;
         onError?: import("./types").ErrorHandler<NoInfer<ErrorShape>> | undefined;
+        customState?: { [Key in keyof CustomStateHandlers]: CustomStateHandlers[Key] extends CustomStateHandler<any, infer RequiredIntents extends Record<string, IntentHandler<any, any>>, any> ? Exclude<keyof RequiredIntents, keyof ({} & CustomIntentHandlers)> extends never ? RequiredIntents extends Pick<{} & CustomIntentHandlers, Extract<keyof RequiredIntents, keyof ({} & CustomIntentHandlers)>> ? CustomStateHandlers[Key] : never : never : never; } | undefined;
         serialize?: import("@conform-to/dom/future").CustomSerialize | undefined;
+        intents?: CustomIntentHandlers | undefined;
         schemaOptions?: import("./types").InferOptions<Schema> | undefined;
-        onValidate: import("./types").ValidateHandler<ErrorShape, Value, InferOutput<Schema>, string[]>;
-    }): FormHandle<InferFormShape<Schema>, ErrorShape, {}, {}>;
-    <Schema extends StandardSchemaV1<unknown, unknown>, ErrorShape extends any = string[], Value = InferOutput<Schema>>(schema: Schema, options: {
+        onValidate: import("./types").ValidateHandler<ErrorShape, Value, InferOutput<Schema>, string[], FormIntent<InferFormShape<Schema>, DefaultIntentHandlers & CustomIntentHandlers> | undefined>;
+    }): FormHandle<InferFormShape<Schema>, ErrorShape, {}, {}, {} & CustomIntentHandlers, FormCustomState<{} & CustomStateHandlers>>;
+    <Schema extends StandardSchemaV1<unknown, unknown>, ErrorShape extends any = string[], Value = InferOutput<Schema>, CustomIntentHandlers extends Record<string, IntentHandler<any, any>> = {}, CustomStateHandlers extends Record<string, CustomStateHandler<any, any, ErrorShape>> = {}>(schema: Schema, options: {
         id?: string | undefined | undefined;
         key?: string | undefined | undefined;
         defaultValue?: import("./types").DefaultValue<InferFormShape<Schema>> | undefined;
@@ -101,13 +118,15 @@ export declare const useForm: {
         lastResult?: import("@conform-to/dom/future").SubmissionResult<ErrorShape> | null | undefined;
         shouldValidate?: "onSubmit" | "onBlur" | "onInput" | undefined | undefined;
         shouldRevalidate?: "onSubmit" | "onBlur" | "onInput" | undefined | undefined;
-        onValidate?: import("./types").ValidateHandler<ErrorShape, Value, InferOutput<Schema>, string[]> | undefined;
+        onValidate?: import("./types").ValidateHandler<ErrorShape, Value, InferOutput<Schema>, string[], FormIntent<InferFormShape<Schema>, DefaultIntentHandlers & CustomIntentHandlers> | undefined> | undefined;
         onSubmit?: import("./types").SubmitHandler<InferFormShape<Schema>, NoInfer<ErrorShape>, NoInfer<Value>> | undefined;
         onError?: import("./types").ErrorHandler<NoInfer<ErrorShape>> | undefined;
+        customState?: { [Key in keyof CustomStateHandlers]: CustomStateHandlers[Key] extends CustomStateHandler<any, infer RequiredIntents extends Record<string, IntentHandler<any, any>>, any> ? Exclude<keyof RequiredIntents, keyof ({} & CustomIntentHandlers)> extends never ? RequiredIntents extends Pick<{} & CustomIntentHandlers, Extract<keyof RequiredIntents, keyof ({} & CustomIntentHandlers)>> ? CustomStateHandlers[Key] : never : never : never; } | undefined;
         serialize?: import("@conform-to/dom/future").CustomSerialize | undefined;
+        intents?: CustomIntentHandlers | undefined;
         schemaOptions?: import("./types").InferOptions<Schema> | undefined;
-    }): FormHandle<InferFormShape<Schema>, ErrorShape, {}, {}>;
-    <FormShape extends Record<string, any> = Record<string, any>, ErrorShape extends any = any, Value = undefined>(options: {
+    }): FormHandle<InferFormShape<Schema>, ErrorShape, {}, {}, {} & CustomIntentHandlers, FormCustomState<{} & CustomStateHandlers>>;
+    <FormShape extends Record<string, any> = Record<string, any>, ErrorShape extends any = any, Value = undefined, CustomIntentHandlers extends Record<string, IntentHandler<any, any>> = {}, CustomStateHandlers extends Record<string, CustomStateHandler<any, any, ErrorShape>> = {}>(options: {
         id?: string | undefined | undefined;
         key?: string | undefined | undefined;
         defaultValue?: import("./types").DefaultValue<FormShape> | undefined;
@@ -119,10 +138,12 @@ export declare const useForm: {
         shouldRevalidate?: "onSubmit" | "onBlur" | "onInput" | undefined | undefined;
         onSubmit?: import("./types").SubmitHandler<FormShape, NoInfer<ErrorShape>, NoInfer<Value>> | undefined;
         onError?: import("./types").ErrorHandler<NoInfer<ErrorShape>> | undefined;
+        customState?: { [Key in keyof CustomStateHandlers]: CustomStateHandlers[Key] extends CustomStateHandler<any, infer RequiredIntents extends Record<string, IntentHandler<any, any>>, any> ? Exclude<keyof RequiredIntents, keyof ({} & CustomIntentHandlers)> extends never ? RequiredIntents extends Pick<{} & CustomIntentHandlers, Extract<keyof RequiredIntents, keyof ({} & CustomIntentHandlers)>> ? CustomStateHandlers[Key] : never : never : never; } | undefined;
         serialize?: import("@conform-to/dom/future").CustomSerialize | undefined;
+        intents?: CustomIntentHandlers | undefined;
         schemaOptions?: undefined;
-        onValidate: import("./types").ValidateHandler<ErrorShape, Value, undefined, string[]>;
-    }): FormHandle<FormShape, ErrorShape, {}, {}>;
+        onValidate: import("./types").ValidateHandler<ErrorShape, Value, undefined, string[], FormIntent<FormShape, DefaultIntentHandlers & CustomIntentHandlers> | undefined>;
+    }): FormHandle<FormShape, ErrorShape, {}, {}, {} & CustomIntentHandlers, FormCustomState<{} & CustomStateHandlers>>;
 };
 /**
  * A React hook that provides access to form-level metadata and state.
@@ -156,6 +177,7 @@ export declare const useFormMetadata: (options?: {
     errors: any;
     fieldErrors: Record<string, any>;
     defaultValue: Record<string, unknown>;
+    customState: FormCustomState<{}>;
     props: Readonly<{
         id: string;
         onSubmit: React.FormEventHandler<HTMLFormElement>;
@@ -163,7 +185,7 @@ export declare const useFormMetadata: (options?: {
         onInput: React.FormEventHandler<HTMLFormElement>;
         noValidate: boolean;
     }>;
-    context: FormContext<any>;
+    context: FormContext<any, FormCustomState<{}>>;
     getField<FieldShape>(name: import("@conform-to/dom/future").FieldName<FieldShape>): Readonly<{
         required?: boolean | undefined | undefined;
         minLength?: number | undefined | undefined;
@@ -1170,5 +1192,24 @@ export declare const useField: <FieldShape = any>(name: FieldName<FieldShape>, o
  * }
  * ```
  */
-export declare const useIntent: <FormShape extends Record<string, any>>(formRef: FormRef) => IntentDispatcher<FormShape>;
+export declare const useIntent: {
+    (formRef: FormRef): IntentDispatcher<Record<string, any>, DefaultIntentHandlers>;
+    <IntentHandlers extends Record<string, IntentHandler<any, any>>>(formRef: FormRef): IntentDispatcher<Record<string, any>, DefaultIntentHandlers & IntentHandlers>;
+    <FormShape extends Record<string, any>>(formRef: FormRef): IntentDispatcher<FormShape, DefaultIntentHandlers>;
+    <FormShape extends Record<string, any>, IntentHandlers extends Record<string, IntentHandler<any, any>>>(formRef: FormRef): IntentDispatcher<FormShape, DefaultIntentHandlers & IntentHandlers>;
+};
+/**
+ * Parses and resolves a submission payload using the default configured form intent handlers.
+ *
+ * See https://conform.guide/api/react/future/resolveSubmission
+ */
+export declare const resolveSubmission: <IntentHandlers extends Record<string, IntentHandler<any, any>> = {}>(submission: Submission, options?: {
+    handlers?: IntentHandlers | undefined;
+} | undefined) => {
+    intent: FormIntent<Record<string, any>, DefaultIntentHandlers & IntentHandlers> | {
+        type: "submit";
+        payload: undefined;
+    } | undefined;
+    targetValue: Record<string, FormValue> | undefined;
+};
 //# sourceMappingURL=forms.d.ts.map

package/dist/future/forms.js

@@ -11,6 +11,7 @@ var dom = require('./dom.js');
 var hooks = require('./hooks.js');
 var state = require('./state.js');
 var util = require('./util.js');
+var intent = require('./intent.js');
 var jsxRuntime = require('react/jsx-runtime');
 
 function configureForms() {
@@ -20,11 +21,14 @@ function configureForms() {
    * Global serializer that composes the user-provided serializer with the default serializer.
    */
   var globalSerialize = util.resolveSerialize(config.serialize, future.defaultSerialize);
+  var globalIntentHandlers = intent.mergeIntentHandlers(intent.defaultIntentHandlers, config.intents);
 
   /**
    * Global configuration with defaults applied
    */
   var globalConfig = _rollupPluginBabelHelpers.objectSpread2(_rollupPluginBabelHelpers.objectSpread2({}, config), {}, {
+    intents: config.intents,
+    customState: config.customState,
     intentName: (_config$intentName = config.intentName) !== null && _config$intentName !== void 0 ? _config$intentName : future.DEFAULT_INTENT_NAME,
     shouldValidate: (_config$shouldValidat = config.shouldValidate) !== null && _config$shouldValidat !== void 0 ? _config$shouldValidat : 'onSubmit',
     shouldRevalidate: (_ref = (_config$shouldRevalid = config.shouldRevalidate) !== null && _config$shouldRevalid !== void 0 ? _config$shouldRevalid : config.shouldValidate) !== null && _ref !== void 0 ? _ref : 'onSubmit',
@@ -109,6 +113,7 @@ function configureForms() {
 
   function useForm(schemaOrOptions, maybeOptions) {
     var _options$constraint, _globalConfig$getCons, _options$id, _options$onError;
+    // implementation signature is broader than the public overloads above
     var schema;
     var options;
     if (globalConfig.isSchema(schemaOrOptions)) {
@@ -120,15 +125,19 @@ function configureForms() {
     var constraint = (_options$constraint = options.constraint) !== null && _options$constraint !== void 0 ? _options$constraint : schema ? (_globalConfig$getCons = globalConfig.getConstraints) === null || _globalConfig$getCons === void 0 ? void 0 : _globalConfig$getCons.call(globalConfig, schema) : undefined;
     var optionsRef = hooks.useLatest(options);
     var serialize = react.useMemo(() => util.resolveSerialize(options.serialize, globalSerialize), [options.serialize]);
+    var [customStateHandlers] = react.useState(() => state.mergeCustomStateHandlers(globalConfig.customState, options.customState));
     var fallbackId = react.useId();
     var formId = (_options$id = options.id) !== null && _options$id !== void 0 ? _options$id : "form-".concat(fallbackId);
     var [state$1, handleSubmit] = hooks.useConform(formId, _rollupPluginBabelHelpers.objectSpread2(_rollupPluginBabelHelpers.objectSpread2({}, options), {}, {
+      intentHandlers: intent.mergeIntentHandlers(globalIntentHandlers, options.intents),
+      customStateHandlers,
       serialize,
       intentName: globalConfig.intentName,
       onError: (_options$onError = options.onError) !== null && _options$onError !== void 0 ? _options$onError : dom.focusFirstInvalidField,
       onValidate(ctx) {
         var _options$onValidate, _options$onValidate2, _options;
         if (schema) {
+          var _validateResult$syncR;
           var schemaResult = globalConfig.validateSchema(schema, ctx.payload, options.schemaOptions);
           if (schemaResult instanceof Promise) {
             return schemaResult.then(resolvedResult => {
@@ -149,18 +158,28 @@ function configureForms() {
           var schemaValue = schemaResult.value;
           ctx.schemaValue = schemaValue;
           var validateResult = util.resolveValidateResult(options.onValidate(ctx));
-          if (validateResult.syncResult) {
-            var _validateResult$syncR, _validateResult$syncR2;
-            (_validateResult$syncR2 = (_validateResult$syncR = validateResult.syncResult).value) !== null && _validateResult$syncR2 !== void 0 ? _validateResult$syncR2 : _validateResult$syncR.value = schemaValue;
+          if (validateResult.syncResult && typeof schemaValue !== 'undefined' && typeof validateResult.syncResult.value === 'undefined') {
+            validateResult.syncResult = _rollupPluginBabelHelpers.objectSpread2(_rollupPluginBabelHelpers.objectSpread2({}, validateResult.syncResult), {}, {
+              value: schemaValue
+            });
           }
           if (validateResult.asyncResult) {
             validateResult.asyncResult = validateResult.asyncResult.then(result => {
-              var _result$value;
-              (_result$value = result.value) !== null && _result$value !== void 0 ? _result$value : result.value = schemaValue;
+              if (typeof schemaValue !== 'undefined' && typeof result.value === 'undefined') {
+                return _rollupPluginBabelHelpers.objectSpread2(_rollupPluginBabelHelpers.objectSpread2({}, result), {}, {
+                  value: schemaValue
+                });
+              }
               return result;
             });
           }
-          return [validateResult.syncResult, validateResult.asyncResult];
+          if (validateResult.syncResult && validateResult.asyncResult) {
+            return {
+              result: validateResult.syncResult,
+              pending: validateResult.asyncResult
+            };
+          }
+          return (_validateResult$syncR = validateResult.syncResult) !== null && _validateResult$syncR !== void 0 ? _validateResult$syncR : validateResult.asyncResult;
         }
         return (_options$onValidate = (_options$onValidate2 = (_options = options).onValidate) === null || _options$onValidate2 === void 0 ? void 0 : _options$onValidate2.call(_options, ctx)) !== null && _options$onValidate !== void 0 ? _options$onValidate : {
           // To avoid conform falling back to server validation,
@@ -170,7 +189,7 @@ function configureForms() {
         };
       }
     }));
-    var intent = useIntent(formId);
+    var intent$1 = useIntent(formId);
     var context = react.useMemo(() => ({
       formId,
       state: state$1,
@@ -192,7 +211,7 @@ function configureForms() {
         var shouldValidate = (_optionsRef$current$s = optionsRef.current.shouldValidate) !== null && _optionsRef$current$s !== void 0 ? _optionsRef$current$s : globalConfig.shouldValidate;
         var shouldRevalidate = (_ref2 = (_optionsRef$current$s2 = optionsRef.current.shouldRevalidate) !== null && _optionsRef$current$s2 !== void 0 ? _optionsRef$current$s2 : optionsRef.current.shouldValidate) !== null && _ref2 !== void 0 ? _ref2 : globalConfig.shouldRevalidate;
         if (state.isTouched(state$1, event.target.name) ? shouldRevalidate === 'onInput' : shouldValidate === 'onInput') {
-          intent.validate(event.target.name);
+          intent$1.validate(event.target.name);
         }
       },
       handleBlur(event) {
@@ -210,10 +229,10 @@ function configureForms() {
         var shouldValidate = (_optionsRef$current$s3 = optionsRef.current.shouldValidate) !== null && _optionsRef$current$s3 !== void 0 ? _optionsRef$current$s3 : globalConfig.shouldValidate;
         var shouldRevalidate = (_ref3 = (_optionsRef$current$s4 = optionsRef.current.shouldRevalidate) !== null && _optionsRef$current$s4 !== void 0 ? _optionsRef$current$s4 : optionsRef.current.shouldValidate) !== null && _ref3 !== void 0 ? _ref3 : globalConfig.shouldRevalidate;
         if (state.isTouched(state$1, event.target.name) ? shouldRevalidate === 'onBlur' : shouldValidate === 'onBlur') {
-          intent.validate(event.target.name);
+          intent$1.validate(event.target.name);
         }
       }
-    }), [formId, state$1, serialize, constraint, handleSubmit, intent, optionsRef]);
+    }), [formId, state$1, serialize, constraint, handleSubmit, intent$1, optionsRef]);
     var form = react.useMemo(() => state.getFormMetadata(context, {
       extendFormMetadata: globalConfig.extendFormMetadata,
       extendFieldMetadata: globalConfig.extendFieldMetadata
@@ -224,7 +243,7 @@ function configureForms() {
     return {
       form,
       fields,
-      intent
+      intent: intent$1
     };
   }
 
@@ -309,15 +328,36 @@ function configureForms() {
    * }
    * ```
    */
+
   function useIntent(formRef) {
     return react.useMemo(() => dom.createIntentDispatcher(() => dom.getFormElement(formRef), globalConfig.intentName), [formRef]);
   }
+
+  /**
+   * Parses and resolves a submission payload using the configured default and global intent handlers.
+   * Pass `handlers` to extend or override them for a specific call.
+   */
+  function resolveSubmission(submission, options) {
+    var handlers = intent.mergeIntentHandlers(globalIntentHandlers, options === null || options === void 0 ? void 0 : options.handlers);
+    var intent$1 = intent.parseIntent(submission.intent, {
+      handlers
+    });
+    var targetValue = intent.resolveIntent(submission, {
+      handlers,
+      intent: intent$1
+    });
+    return {
+      intent: intent$1,
+      targetValue
+    };
+  }
   return {
     FormProvider,
     useForm,
     useFormMetadata,
     useField,
     useIntent,
+    resolveSubmission,
     config: globalConfig
   };
 }
@@ -444,8 +484,16 @@ var useField = defaultForms.useField;
  */
 var useIntent = defaultForms.useIntent;
 
+/**
+ * Parses and resolves a submission payload using the default configured form intent handlers.
+ *
+ * See https://conform.guide/api/react/future/resolveSubmission
+ */
+var resolveSubmission = defaultForms.resolveSubmission;
+
 exports.FormProvider = FormProvider;
 exports.configureForms = configureForms;
+exports.resolveSubmission = resolveSubmission;
 exports.useField = useField;
 exports.useForm = useForm;
 exports.useFormMetadata = useFormMetadata;

package/dist/future/forms.mjs

@@ -2,11 +2,12 @@
 import { objectSpread2 as _objectSpread2 } from '../_virtual/_rollupPluginBabelHelpers.mjs';
 import { isFieldElement } from '@conform-to/dom';
 import { DEFAULT_INTENT_NAME, defaultSerialize } from '@conform-to/dom/future';
-import { useContext, useMemo, useId, createContext } from 'react';
+import { useContext, useMemo, useState, useId, createContext } from 'react';
 import { focusFirstInvalidField, getFormElement, createIntentDispatcher } from './dom.mjs';
 import { useLatest, useConform } from './hooks.mjs';
-import { isTouched, getFormMetadata, getFieldset, getField } from './state.mjs';
+import { mergeCustomStateHandlers, isTouched, getFormMetadata, getFieldset, getField } from './state.mjs';
 import { resolveSerialize, isStandardSchemaV1, validateStandardSchemaV1, resolveValidateResult } from './util.mjs';
+import { mergeIntentHandlers, defaultIntentHandlers, parseIntent, resolveIntent } from './intent.mjs';
 import { jsx } from 'react/jsx-runtime';
 
 function configureForms() {
@@ -16,11 +17,14 @@ function configureForms() {
    * Global serializer that composes the user-provided serializer with the default serializer.
    */
   var globalSerialize = resolveSerialize(config.serialize, defaultSerialize);
+  var globalIntentHandlers = mergeIntentHandlers(defaultIntentHandlers, config.intents);
 
   /**
    * Global configuration with defaults applied
    */
   var globalConfig = _objectSpread2(_objectSpread2({}, config), {}, {
+    intents: config.intents,
+    customState: config.customState,
     intentName: (_config$intentName = config.intentName) !== null && _config$intentName !== void 0 ? _config$intentName : DEFAULT_INTENT_NAME,
     shouldValidate: (_config$shouldValidat = config.shouldValidate) !== null && _config$shouldValidat !== void 0 ? _config$shouldValidat : 'onSubmit',
     shouldRevalidate: (_ref = (_config$shouldRevalid = config.shouldRevalidate) !== null && _config$shouldRevalid !== void 0 ? _config$shouldRevalid : config.shouldValidate) !== null && _ref !== void 0 ? _ref : 'onSubmit',
@@ -105,6 +109,7 @@ function configureForms() {
 
   function useForm(schemaOrOptions, maybeOptions) {
     var _options$constraint, _globalConfig$getCons, _options$id, _options$onError;
+    // implementation signature is broader than the public overloads above
     var schema;
     var options;
     if (globalConfig.isSchema(schemaOrOptions)) {
@@ -116,15 +121,19 @@ function configureForms() {
     var constraint = (_options$constraint = options.constraint) !== null && _options$constraint !== void 0 ? _options$constraint : schema ? (_globalConfig$getCons = globalConfig.getConstraints) === null || _globalConfig$getCons === void 0 ? void 0 : _globalConfig$getCons.call(globalConfig, schema) : undefined;
     var optionsRef = useLatest(options);
     var serialize = useMemo(() => resolveSerialize(options.serialize, globalSerialize), [options.serialize]);
+    var [customStateHandlers] = useState(() => mergeCustomStateHandlers(globalConfig.customState, options.customState));
     var fallbackId = useId();
     var formId = (_options$id = options.id) !== null && _options$id !== void 0 ? _options$id : "form-".concat(fallbackId);
     var [state, handleSubmit] = useConform(formId, _objectSpread2(_objectSpread2({}, options), {}, {
+      intentHandlers: mergeIntentHandlers(globalIntentHandlers, options.intents),
+      customStateHandlers,
       serialize,
       intentName: globalConfig.intentName,
       onError: (_options$onError = options.onError) !== null && _options$onError !== void 0 ? _options$onError : focusFirstInvalidField,
       onValidate(ctx) {
         var _options$onValidate, _options$onValidate2, _options;
         if (schema) {
+          var _validateResult$syncR;
           var schemaResult = globalConfig.validateSchema(schema, ctx.payload, options.schemaOptions);
           if (schemaResult instanceof Promise) {
             return schemaResult.then(resolvedResult => {
@@ -145,18 +154,28 @@ function configureForms() {
           var schemaValue = schemaResult.value;
           ctx.schemaValue = schemaValue;
           var validateResult = resolveValidateResult(options.onValidate(ctx));
-          if (validateResult.syncResult) {
-            var _validateResult$syncR, _validateResult$syncR2;
-            (_validateResult$syncR2 = (_validateResult$syncR = validateResult.syncResult).value) !== null && _validateResult$syncR2 !== void 0 ? _validateResult$syncR2 : _validateResult$syncR.value = schemaValue;
+          if (validateResult.syncResult && typeof schemaValue !== 'undefined' && typeof validateResult.syncResult.value === 'undefined') {
+            validateResult.syncResult = _objectSpread2(_objectSpread2({}, validateResult.syncResult), {}, {
+              value: schemaValue
+            });
           }
           if (validateResult.asyncResult) {
             validateResult.asyncResult = validateResult.asyncResult.then(result => {
-              var _result$value;
-              (_result$value = result.value) !== null && _result$value !== void 0 ? _result$value : result.value = schemaValue;
+              if (typeof schemaValue !== 'undefined' && typeof result.value === 'undefined') {
+                return _objectSpread2(_objectSpread2({}, result), {}, {
+                  value: schemaValue
+                });
+              }
               return result;
             });
           }
-          return [validateResult.syncResult, validateResult.asyncResult];
+          if (validateResult.syncResult && validateResult.asyncResult) {
+            return {
+              result: validateResult.syncResult,
+              pending: validateResult.asyncResult
+            };
+          }
+          return (_validateResult$syncR = validateResult.syncResult) !== null && _validateResult$syncR !== void 0 ? _validateResult$syncR : validateResult.asyncResult;
         }
         return (_options$onValidate = (_options$onValidate2 = (_options = options).onValidate) === null || _options$onValidate2 === void 0 ? void 0 : _options$onValidate2.call(_options, ctx)) !== null && _options$onValidate !== void 0 ? _options$onValidate : {
           // To avoid conform falling back to server validation,
@@ -305,15 +324,36 @@ function configureForms() {
    * }
    * ```
    */
+
   function useIntent(formRef) {
     return useMemo(() => createIntentDispatcher(() => getFormElement(formRef), globalConfig.intentName), [formRef]);
   }
+
+  /**
+   * Parses and resolves a submission payload using the configured default and global intent handlers.
+   * Pass `handlers` to extend or override them for a specific call.
+   */
+  function resolveSubmission(submission, options) {
+    var handlers = mergeIntentHandlers(globalIntentHandlers, options === null || options === void 0 ? void 0 : options.handlers);
+    var intent = parseIntent(submission.intent, {
+      handlers
+    });
+    var targetValue = resolveIntent(submission, {
+      handlers,
+      intent
+    });
+    return {
+      intent,
+      targetValue
+    };
+  }
   return {
     FormProvider,
     useForm,
     useFormMetadata,
     useField,
     useIntent,
+    resolveSubmission,
     config: globalConfig
   };
 }
@@ -440,4 +480,11 @@ var useField = defaultForms.useField;
  */
 var useIntent = defaultForms.useIntent;
 
-export { FormProvider, configureForms, useField, useForm, useFormMetadata, useIntent };
+/**
+ * Parses and resolves a submission payload using the default configured form intent handlers.
+ *
+ * See https://conform.guide/api/react/future/resolveSubmission
+ */
+var resolveSubmission = defaultForms.resolveSubmission;
+
+export { FormProvider, configureForms, resolveSubmission, useField, useForm, useFormMetadata, useIntent };