@conform-to/react 1.19.4 → 1.20.0

package/dist/future/state.d.ts

@@ -1,20 +1,37 @@
-import { type FieldName, FormError } from '@conform-to/dom/future';
-import type { FieldMetadata, Fieldset, FormContext, FormMetadata, FormState, FormAction, UnknownIntent, IntentHandler, BaseFieldMetadata, BaseFormMetadata, DefineConditionalField } from './types';
-export declare function initializeState<ErrorShape>(options?: {
+import { type FieldName, FormError, type SubmissionResult } from '@conform-to/dom/future';
+import type { FieldMetadata, Fieldset, FormContext, FormMetadata, FormState, FormAction, UnknownIntent, IntentHandler, BaseFieldMetadata, BaseFormMetadata, DefineConditionalField, ApplyStatus, CustomStateHandler, FormCustomState } from './types';
+export declare function initializeState<ErrorShape = any, CustomStateHandlers extends Record<string, CustomStateHandler<any, any, ErrorShape>> = {}>(options?: {
     defaultValue?: Record<string, unknown> | null | undefined;
     resetKey?: string | undefined;
-}): FormState<ErrorShape>;
+    customStateHandlers?: CustomStateHandlers | undefined;
+    lastCustomState?: FormCustomState<CustomStateHandlers> | undefined;
+    result?: SubmissionResult<ErrorShape> | undefined;
+}): FormState<ErrorShape, FormCustomState<CustomStateHandlers>>;
 /**
  * Updates form state based on action type:
  * - Client actions: update target value and client errors
  * - Server actions: update server errors and clear client errors, with optional target value
  * - Initialize: set initial server value
  */
-export declare function updateState<ErrorShape>(state: FormState<ErrorShape>, action: FormAction<ErrorShape, UnknownIntent | null, {
-    handlers: Record<string, IntentHandler>;
-    cancelled: boolean;
-    reset: (defaultValue?: Record<string, unknown> | null | undefined) => FormState<ErrorShape>;
-}>): FormState<ErrorShape>;
+export declare function updateState<ErrorShape, CustomStateHandlers extends Record<string, CustomStateHandler<any, any, ErrorShape>> = {}>(state: FormState<ErrorShape, FormCustomState<CustomStateHandlers>>, action: FormAction<ErrorShape, UnknownIntent, {
+    intentHandlers: Record<string, IntentHandler<any, any>>;
+    customStateHandlers: CustomStateHandlers | undefined;
+    status: ApplyStatus;
+    reset: () => FormState<ErrorShape, FormCustomState<CustomStateHandlers>>;
+}>): FormState<ErrorShape, FormCustomState<CustomStateHandlers>>;
+export declare function getFields<ErrorShape>(result: SubmissionResult<ErrorShape>): string[];
+export declare function getApplyStatus(baseTargetValue: Record<string, unknown> | undefined, finalTargetValue: Record<string, unknown> | undefined): ApplyStatus;
+/**
+ * Fallback state transition for intents that change the payload shape without
+ * providing a `move()` mapping. It drops list keys and touched fields under
+ * changed paths so stale client state does not point at the wrong fields.
+ */
+export declare function invalidateState<ErrorShape, CustomState extends Record<string, unknown> = Record<string, unknown>>(state: FormState<ErrorShape, CustomState>, previousValue: Record<string, unknown>, nextValue: Record<string, unknown>): FormState<ErrorShape, CustomState>;
+/**
+ * Preserves list keys and touched fields for intents that can map old field
+ * paths to new ones, such as insert, remove, and reorder.
+ */
+export declare function moveState<ErrorShape, CustomState extends Record<string, unknown> = Record<string, unknown>>(state: FormState<ErrorShape, CustomState>, previousValue: Record<string, unknown>, nextValue: Record<string, unknown>, move: (name: string) => string | null): FormState<ErrorShape, CustomState>;
 /**
  * Removes list keys where array length has changed to force regeneration.
  * Minimizes UI state loss by only invalidating keys when necessary.
@@ -40,43 +57,53 @@ export declare function getFieldErrors<ErrorShape>(state: FormState<ErrorShape>,
  */
 export declare function hasFieldError<ErrorShape>(error: FormError<ErrorShape>, name: string): boolean;
 export declare function isValid(state: FormState<any>, name?: string): boolean;
-export declare function getFormMetadata<ErrorShape, CustomFormMetadata extends Record<string, unknown> = {}, CustomFieldMetadata extends Record<string, unknown> = {}>(context: FormContext<ErrorShape>, options?: {
-    extendFormMetadata?: ((metadata: BaseFormMetadata<ErrorShape>) => CustomFormMetadata) | undefined;
+export declare function getFormMetadata<ErrorShape, CustomFormMetadata extends Record<string, unknown> = {}, CustomFieldMetadata extends Record<string, unknown> = {}, CustomState extends Record<string, unknown> = {}>(context: FormContext<ErrorShape, CustomState>, options?: {
+    extendFormMetadata?: ((metadata: BaseFormMetadata<ErrorShape, CustomState>) => CustomFormMetadata) | undefined;
     extendFieldMetadata?: (<FieldShape>(metadata: BaseFieldMetadata<FieldShape, ErrorShape>, ctx: {
-        form: BaseFormMetadata<ErrorShape>;
+        form: BaseFormMetadata<ErrorShape, CustomState>;
         when: DefineConditionalField;
     }) => CustomFieldMetadata) | undefined;
-}): FormMetadata<ErrorShape, CustomFormMetadata, CustomFieldMetadata>;
-export declare function getField<FieldShape, ErrorShape = string, CustomFieldMetadata extends Record<string, unknown> = {}>(context: FormContext<ErrorShape>, options: {
+}): FormMetadata<ErrorShape, CustomFormMetadata, CustomFieldMetadata, CustomState>;
+export declare function getField<FieldShape, ErrorShape = string, CustomFieldMetadata extends Record<string, unknown> = {}>(context: FormContext<ErrorShape, any>, options: {
     name: FieldName<FieldShape>;
     extendFieldMetadata?: (<F>(metadata: BaseFieldMetadata<F, ErrorShape>, ctx: {
-        form: BaseFormMetadata<ErrorShape>;
+        form: BaseFormMetadata<ErrorShape, any>;
         when: DefineConditionalField;
     }) => CustomFieldMetadata) | undefined;
-    form?: BaseFormMetadata<ErrorShape, CustomFieldMetadata> | undefined;
+    form?: BaseFormMetadata<ErrorShape, any> | undefined;
     key?: string | undefined;
 }): FieldMetadata<FieldShape, ErrorShape, CustomFieldMetadata>;
 /**
  * Creates a proxy that dynamically generates field objects when properties are accessed.
  */
-export declare function getFieldset<FieldShape = Record<string, any>, ErrorShape = string, CustomFieldMetadata extends Record<string, unknown> = {}>(context: FormContext<ErrorShape>, options: {
+export declare function getFieldset<FieldShape = Record<string, any>, ErrorShape = string, CustomFieldMetadata extends Record<string, unknown> = {}>(context: FormContext<ErrorShape, any>, options: {
     name?: FieldName<FieldShape> | undefined;
     extendFieldMetadata?: (<F>(metadata: BaseFieldMetadata<F, ErrorShape>, ctx: {
-        form: BaseFormMetadata<ErrorShape>;
+        form: BaseFormMetadata<ErrorShape, any>;
         when: DefineConditionalField;
     }) => CustomFieldMetadata) | undefined;
-    form?: BaseFormMetadata<ErrorShape, CustomFieldMetadata> | undefined;
+    form?: BaseFormMetadata<ErrorShape, any> | undefined;
 }): Fieldset<FieldShape, ErrorShape, CustomFieldMetadata>;
 /**
  * Creates an array of field objects for list/array inputs
  */
-export declare function getFieldList<FieldShape = Array<any>, ErrorShape = string, CustomFieldMetadata extends Record<string, unknown> = {}>(context: FormContext<ErrorShape>, options: {
+export declare function getFieldList<FieldShape = Array<any>, ErrorShape = string, CustomFieldMetadata extends Record<string, unknown> = {}>(context: FormContext<ErrorShape, any>, options: {
     name: FieldName<FieldShape>;
     extendFieldMetadata?: (<F>(metadata: BaseFieldMetadata<F, ErrorShape>, ctx: {
-        form: BaseFormMetadata<ErrorShape>;
+        form: BaseFormMetadata<ErrorShape, any>;
         when: DefineConditionalField;
     }) => CustomFieldMetadata) | undefined;
 }): FieldMetadata<[
     FieldShape
 ] extends [Array<infer ItemShape> | null | undefined] ? ItemShape : unknown, ErrorShape, CustomFieldMetadata>[];
+export declare function defineCustomState<State, CustomIntentHandlers extends Record<string, IntentHandler<any, any>> = {}, ErrorShape = any>(definition: CustomStateHandler<State, CustomIntentHandlers, ErrorShape>): CustomStateHandler<State, CustomIntentHandlers, ErrorShape>;
+export declare function mergeCustomStateHandlers<GlobalCustomState extends Record<string, CustomStateHandler<any, any, any>> | undefined, InlineCustomState extends Record<string, CustomStateHandler<any, any, any>> | undefined>(globalCustomState: GlobalCustomState, inlineCustomState: InlineCustomState): GlobalCustomState & InlineCustomState;
+export declare function initializeCustomState<ErrorShape, CustomStateHandlers extends Record<string, CustomStateHandler<any, any, ErrorShape>>>(options: {
+    handlers: CustomStateHandlers | undefined;
+    currentState?: FormCustomState<CustomStateHandlers> | undefined;
+    result?: SubmissionResult<ErrorShape> | undefined;
+}): FormCustomState<CustomStateHandlers>;
+export declare function updateCustomState<ErrorShape, CustomStateHandlers extends Record<string, CustomStateHandler<any, any, ErrorShape>>>(state: FormCustomState<CustomStateHandlers>, action: FormAction<ErrorShape, UnknownIntent>, options: {
+    handlers: CustomStateHandlers | undefined;
+}): FormCustomState<CustomStateHandlers>;
 //# sourceMappingURL=state.d.ts.map

package/dist/future/state.js

@@ -16,7 +16,12 @@ function initializeState(options) {
     serverValue: null,
     serverError: null,
     clientError: null,
-    touchedFields: []
+    touchedFields: [],
+    customState: initializeCustomState({
+      handlers: options === null || options === void 0 ? void 0 : options.customStateHandlers,
+      currentState: options === null || options === void 0 ? void 0 : options.lastCustomState,
+      result: options === null || options === void 0 ? void 0 : options.result
+    })
   };
 }
 
@@ -27,28 +32,30 @@ function initializeState(options) {
  * - Initialize: set initial server value
  */
 function updateState(state, action) {
-  var _action$targetValue, _action$targetValue2, _action$intent, _action$ctx$handlers;
-  if (action.reset) {
-    return action.ctx.reset(action.targetValue);
+  var _action$result$target, _action$result$target2, _action$intent, _action$ctx$intentHan;
+  if (action.result.reset) {
+    return action.ctx.reset();
   }
-  var value = (_action$targetValue = action.targetValue) !== null && _action$targetValue !== void 0 ? _action$targetValue : action.submission.payload;
+  var value = (_action$result$target = action.result.targetValue) !== null && _action$result$target !== void 0 ? _action$result$target : action.result.submission.payload;
+  var isClientAction = action.type === 'client' || action.type === 'client:async';
+  var hasIntentEffects = action.type !== 'server' && action.type !== 'client:async';
 
   // Apply the form error and target value from the result first
-  state = action.type === 'client' ? util.merge(state, {
-    targetValue: (_action$targetValue2 = action.targetValue) !== null && _action$targetValue2 !== void 0 ? _action$targetValue2 : state.targetValue,
-    serverValue: action.targetValue ? null : state.serverValue,
+  state = isClientAction ? util.merge(state, {
+    targetValue: action.type === 'client' ? (_action$result$target2 = action.result.targetValue) !== null && _action$result$target2 !== void 0 ? _action$result$target2 : state.targetValue : state.targetValue,
+    serverValue: action.type === 'client' && action.result.targetValue ? null : state.serverValue,
     // Update client error only if the error is different from the previous one to minimize unnecessary re-renders
-    clientError: typeof action.error !== 'undefined' && !future.deepEqual(state.clientError, action.error) ? action.error : state.clientError,
+    clientError: typeof action.result.error !== 'undefined' && !future.deepEqual(state.clientError, action.result.error) ? action.result.error : state.clientError,
     // Reset server error if form value is changed
-    serverError: typeof action.error !== 'undefined' && !future.deepEqual(state.serverValue, value) ? null : state.serverError
+    serverError: typeof action.result.error !== 'undefined' && !future.deepEqual(state.serverValue, value) ? null : state.serverError
   }) : util.merge(state, {
     // Clear client error to avoid showing stale errors
     clientError: null,
     // Update server error if the error is defined.
     // There is no need to check if the error is different as we are updating other states as well
-    serverError: typeof action.error !== 'undefined' ? action.error : state.serverError,
-    listKeys: action.type === 'server' && action.targetValue ? pruneListKeys(state.listKeys, action.targetValue) : state.listKeys,
-    targetValue: action.type === 'server' && action.targetValue ? action.targetValue : state.targetValue,
+    serverError: typeof action.result.error !== 'undefined' ? action.result.error : state.serverError,
+    listKeys: action.type === 'server' && action.result.targetValue ? pruneListKeys(state.listKeys, action.result.targetValue) : state.listKeys,
+    targetValue: action.type === 'server' && action.result.targetValue ? action.result.targetValue : state.targetValue,
     // Keep track of the value that the serverError is based on
     serverValue: !future.deepEqual(state.serverValue, value) ? value : state.serverValue
   });
@@ -56,23 +63,250 @@ function updateState(state, action) {
   var intent = (_action$intent = action.intent) !== null && _action$intent !== void 0 ? _action$intent : {
     type: 'validate'
   };
-  var handler = (_action$ctx$handlers = action.ctx.handlers) === null || _action$ctx$handlers === void 0 ? void 0 : _action$ctx$handlers[intent.type];
-  if (typeof (handler === null || handler === void 0 ? void 0 : handler.update) === 'function') {
-    var _handler$validate, _handler$validate2;
-    if ((_handler$validate = (_handler$validate2 = handler.validate) === null || _handler$validate2 === void 0 ? void 0 : _handler$validate2.call(handler, intent.payload)) !== null && _handler$validate !== void 0 ? _handler$validate : true) {
-      return handler.update(state, _rollupPluginBabelHelpers.objectSpread2(_rollupPluginBabelHelpers.objectSpread2({}, action), {}, {
-        ctx: {
-          reset: action.ctx.reset,
-          cancelled: action.ctx.cancelled
-        },
-        intent: {
-          type: intent.type,
-          payload: intent.payload
-        }
+  var handler = (_action$ctx$intentHan = action.ctx.intentHandlers) === null || _action$ctx$intentHan === void 0 ? void 0 : _action$ctx$intentHan[intent.type];
+  if (handler && action.type === 'client' && hasIntentEffects) {
+    if (typeof handler.move === 'function') {
+      var handleMove = handler.move;
+      state = moveState(state, action.result.submission.payload, value, name => handleMove({
+        name,
+        payload: intent.payload,
+        status: action.ctx.status,
+        targetValue: action.result.targetValue
       }));
+    } else if (typeof handler.resolve === 'function') {
+      state = invalidateState(state, action.result.submission.payload, value);
+    }
+  }
+  if (handler && action.type !== 'server' && hasIntentEffects && typeof handler.touch === 'function') {
+    var touchedFields = state.touchedFields;
+    for (var _name of getFields(action.result)) {
+      if (handler.touch({
+        name: _name,
+        payload: intent.payload
+      })) {
+        touchedFields = util.appendUniqueItem(touchedFields, _name);
+      }
+    }
+    state = util.merge(state, {
+      touchedFields
+    });
+  }
+  return util.merge(state, {
+    customState: updateCustomState(state.customState, action, {
+      handlers: action.ctx.customStateHandlers
+    })
+  });
+}
+function getFields(result) {
+  var fields = result.submission.fields;
+  if (result.error) {
+    fields = fields.concat(Object.keys(result.error.fieldErrors));
+  }
+  var fieldsSet = new Set(['']);
+  for (var field of fields) {
+    var paths = future.parsePath(field);
+    for (var index = 1; index <= paths.length; index++) {
+      fieldsSet.add(future.formatPath(paths.slice(0, index)));
+    }
+  }
+  return Array.from(fieldsSet);
+}
+function getApplyStatus(baseTargetValue, finalTargetValue) {
+  if (baseTargetValue === finalTargetValue) {
+    return 'applied';
+  }
+  return typeof finalTargetValue === 'undefined' ? 'reverted' : 'modified';
+}
+
+/**
+ * Fallback state transition for intents that change the payload shape without
+ * providing a `move()` mapping. It drops list keys and touched fields under
+ * changed paths so stale client state does not point at the wrong fields.
+ */
+function invalidateState(state, previousValue, nextValue) {
+  if (previousValue === nextValue) {
+    return state;
+  }
+  var changedNames = [];
+  var stack = [{
+    previousValue,
+    nextValue,
+    name: ''
+  }];
+  var _loop = function _loop() {
+      var current = stack.pop();
+      if (!current) {
+        return 0; // break
+      }
+      if (Object.is(current.previousValue, current.nextValue)) {
+        return 1; // continue
+      }
+      if (Array.isArray(current.previousValue) && Array.isArray(current.nextValue)) {
+        changedNames = changedNames.concat(current.name);
+        return 1; // continue
+      }
+      if (future.isPlainObject(current.previousValue) && future.isPlainObject(current.nextValue)) {
+        for (var key of new Set([...Object.keys(current.previousValue), ...Object.keys(current.nextValue)])) {
+          stack.push({
+            previousValue: current.previousValue[key],
+            nextValue: current.nextValue[key],
+            name: future.appendPath(current.name, key)
+          });
+        }
+        return 1; // continue
+      }
+      var basePath = future.parsePath(current.name);
+      if (changedNames.some(existingName => future.getRelativePath(current.name, future.parsePath(existingName)) !== null)) {
+        return 1; // continue
+      }
+      changedNames = changedNames.filter(existingName => future.getRelativePath(existingName, basePath) === null).concat(current.name);
+    },
+    _ret;
+  while (stack.length > 0) {
+    _ret = _loop();
+    if (_ret === 0) break;
+    if (_ret === 1) continue;
+  }
+  var basePaths = changedNames.map(future.parsePath);
+  if (basePaths.length === 0) {
+    return state;
+  }
+  var listKeys = state.listKeys;
+  var touchedFields = state.touchedFields;
+  if (Object.keys(state.listKeys).length > 0) {
+    var changed = false;
+    var entries = Object.entries(state.listKeys).filter(_ref => {
+      var [name] = _ref;
+      var keep = !basePaths.some(basePath => future.getRelativePath(name, basePath) !== null);
+      changed || (changed = !keep);
+      return keep;
+    });
+    if (changed) {
+      listKeys = Object.fromEntries(entries);
+    }
+  }
+  if (state.touchedFields.length > 0) {
+    var _changed = false;
+    var nextTouchedFields = state.touchedFields.filter(name => {
+      var keep = !basePaths.some(basePath => future.getRelativePath(name, basePath) !== null);
+      _changed || (_changed = !keep);
+      return keep;
+    });
+    if (_changed) {
+      touchedFields = nextTouchedFields;
     }
   }
-  return state;
+  return util.merge(state, {
+    listKeys,
+    touchedFields
+  });
+}
+
+/**
+ * Preserves list keys and touched fields for intents that can map old field
+ * paths to new ones, such as insert, remove, and reorder.
+ */
+function moveState(state, previousValue, nextValue, move) {
+  if (previousValue === nextValue) {
+    return state;
+  }
+  function collectListEntries(value) {
+    var name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+    var entries = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+    if (Array.isArray(value)) {
+      entries.push(name);
+      for (var index = 0; index < value.length; index++) {
+        collectListEntries(value[index], future.appendPath(name, index), entries);
+      }
+    } else if (future.isPlainObject(value)) {
+      for (var [key, childValue] of Object.entries(value)) {
+        collectListEntries(childValue, future.appendPath(name, key), entries);
+      }
+    }
+    return entries;
+  }
+  function getListEntry(name) {
+    if (name === null) {
+      return null;
+    }
+    var paths = future.parsePath(name);
+    var index = paths[paths.length - 1];
+    if (typeof index !== 'number') {
+      return null;
+    }
+    return {
+      name: future.formatPath(paths.slice(0, -1)),
+      index
+    };
+  }
+  var targetSlots = {};
+  var getTargetSlots = listName => {
+    var _targetSlots$listName;
+    return (_targetSlots$listName = targetSlots[listName]) !== null && _targetSlots$listName !== void 0 ? _targetSlots$listName : targetSlots[listName] = Array.from({
+      length: util.getPathArray(nextValue, listName).length
+    }, () => undefined);
+  };
+  for (var listName of collectListEntries(previousValue)) {
+    var _state$listKeys$listN;
+    var sourceKeys = (_state$listKeys$listN = state.listKeys[listName]) !== null && _state$listKeys$listN !== void 0 ? _state$listKeys$listN : getDefaultListKey(state.resetKey, previousValue, listName);
+    for (var index = 0; index < sourceKeys.length; index++) {
+      var _entry$index, _target$_entry$index;
+      var entry = getListEntry(move(future.appendPath(listName, index)));
+      if (!entry) {
+        continue;
+      }
+      var target = getTargetSlots(entry.name);
+      if (entry.index >= target.length) {
+        continue;
+      }
+      (_target$_entry$index = target[_entry$index = entry.index]) !== null && _target$_entry$index !== void 0 ? _target$_entry$index : target[_entry$index] = sourceKeys[index];
+    }
+  }
+  var touchedFields = state.touchedFields;
+  for (var [_index, currentName] of state.touchedFields.entries()) {
+    var movedName = move(currentName);
+    if (movedName === currentName) {
+      continue;
+    }
+    touchedFields = state.touchedFields.slice(0, _index);
+    if (movedName !== null) {
+      touchedFields.push(movedName);
+    }
+    for (var nextName of state.touchedFields.slice(_index + 1)) {
+      var _movedName = move(nextName);
+      if (_movedName !== null) {
+        touchedFields.push(_movedName);
+      }
+    }
+    break;
+  }
+  var changed = false;
+  var result = {};
+  var listNames = new Set([...Object.keys(state.listKeys), ...Object.keys(targetSlots)]);
+  for (var _listName of listNames) {
+    var keys = targetSlots[_listName];
+    var currentKeys = state.listKeys[_listName];
+    if (!keys) {
+      changed = true;
+      continue;
+    }
+    var nextKeys = keys.map(key => key !== null && key !== void 0 ? key : util.generateUniqueKey());
+    var defaultKeys = getDefaultListKey(state.resetKey, nextValue, _listName);
+    if (future.deepEqual(nextKeys, defaultKeys)) {
+      changed || (changed = typeof currentKeys !== 'undefined');
+      continue;
+    }
+    if (currentKeys && future.deepEqual(currentKeys, nextKeys)) {
+      result[_listName] = currentKeys;
+      continue;
+    }
+    result[_listName] = nextKeys;
+    changed = true;
+  }
+  return util.merge(state, {
+    listKeys: changed ? result : state.listKeys,
+    touchedFields
+  });
 }
 
 /**
@@ -81,8 +315,8 @@ function updateState(state, action) {
  */
 function pruneListKeys(listKeys, targetValue) {
   var result = listKeys;
-  for (var [name, keys] of Object.entries(listKeys)) {
-    var list = util.getPathArray(targetValue, name);
+  for (var [_name2, keys] of Object.entries(listKeys)) {
+    var list = util.getPathArray(targetValue, _name2);
 
     // Reset list keys only if the length has changed
     // to minimize potential UI state loss due to key changes
@@ -93,22 +327,26 @@ function pruneListKeys(listKeys, targetValue) {
       }
 
       // Remove the list key to force regeneration
-      delete result[name];
+      delete result[_name2];
     }
   }
   return result;
 }
 function getDefaultPayload(context, name) {
-  var _ref, _context$state$server;
-  var value = future.getPathValue((_ref = (_context$state$server = context.state.serverValue) !== null && _context$state$server !== void 0 ? _context$state$server : context.state.targetValue) !== null && _ref !== void 0 ? _ref : context.state.defaultValue, name);
+  var _ref2, _context$state$server;
+  var value = future.getPathValue((_ref2 = (_context$state$server = context.state.serverValue) !== null && _context$state$server !== void 0 ? _context$state$server : context.state.targetValue) !== null && _ref2 !== void 0 ? _ref2 : context.state.defaultValue, name);
   if (value === null) {
     return null;
   }
-  return future.normalize(value, context.serialize, name);
+  return future.normalize(value, {
+    serialize: context.serialize,
+    stripEmptyValue: false,
+    name
+  });
 }
 function getDefaultValue(context, name) {
-  var _ref2, _context$state$server2;
-  var value = future.getPathValue((_ref2 = (_context$state$server2 = context.state.serverValue) !== null && _context$state$server2 !== void 0 ? _context$state$server2 : context.state.targetValue) !== null && _ref2 !== void 0 ? _ref2 : context.state.defaultValue, name);
+  var _ref3, _context$state$server2;
+  var value = future.getPathValue((_ref3 = (_context$state$server2 = context.state.serverValue) !== null && _context$state$server2 !== void 0 ? _context$state$server2 : context.state.targetValue) !== null && _ref3 !== void 0 ? _ref3 : context.state.defaultValue, name);
   var serializedValue = context.serialize(value, {
     name
   });
@@ -118,8 +356,8 @@ function getDefaultValue(context, name) {
   return '';
 }
 function getDefaultOptions(context, name) {
-  var _ref3, _context$state$server3;
-  var value = future.getPathValue((_ref3 = (_context$state$server3 = context.state.serverValue) !== null && _context$state$server3 !== void 0 ? _context$state$server3 : context.state.targetValue) !== null && _ref3 !== void 0 ? _ref3 : context.state.defaultValue, name);
+  var _ref4, _context$state$server3;
+  var value = future.getPathValue((_ref4 = (_context$state$server3 = context.state.serverValue) !== null && _context$state$server3 !== void 0 ? _context$state$server3 : context.state.targetValue) !== null && _ref4 !== void 0 ? _ref4 : context.state.defaultValue, name);
   var serializedValue = context.serialize(value, {
     name
   });
@@ -132,8 +370,8 @@ function getDefaultOptions(context, name) {
   return [];
 }
 function isDefaultChecked(context, name) {
-  var _ref4, _context$state$server4;
-  var value = future.getPathValue((_ref4 = (_context$state$server4 = context.state.serverValue) !== null && _context$state$server4 !== void 0 ? _context$state$server4 : context.state.targetValue) !== null && _ref4 !== void 0 ? _ref4 : context.state.defaultValue, name);
+  var _ref5, _context$state$server4;
+  var value = future.getPathValue((_ref5 = (_context$state$server4 = context.state.serverValue) !== null && _context$state$server4 !== void 0 ? _context$state$server4 : context.state.targetValue) !== null && _ref5 !== void 0 ? _ref5 : context.state.defaultValue, name);
   var serializedValue = context.serialize(value, {
     name
   });
@@ -163,8 +401,8 @@ function getDefaultListKey(prefix, initialValue, name) {
   return util.getPathArray(initialValue, name).map((_, index) => "".concat(prefix, "-").concat(future.appendPath(name, index)));
 }
 function getListKey(context, name) {
-  var _context$state$listKe, _context$state$listKe2, _ref5, _context$state$server5;
-  return (_context$state$listKe = (_context$state$listKe2 = context.state.listKeys) === null || _context$state$listKe2 === void 0 ? void 0 : _context$state$listKe2[name]) !== null && _context$state$listKe !== void 0 ? _context$state$listKe : getDefaultListKey(context.state.resetKey, (_ref5 = (_context$state$server5 = context.state.serverValue) !== null && _context$state$server5 !== void 0 ? _context$state$server5 : context.state.targetValue) !== null && _ref5 !== void 0 ? _ref5 : context.state.defaultValue, name);
+  var _context$state$listKe, _context$state$listKe2, _ref6, _context$state$server5;
+  return (_context$state$listKe = (_context$state$listKe2 = context.state.listKeys) === null || _context$state$listKe2 === void 0 ? void 0 : _context$state$listKe2[name]) !== null && _context$state$listKe !== void 0 ? _context$state$listKe : getDefaultListKey(context.state.resetKey, (_ref6 = (_context$state$server5 = context.state.serverValue) !== null && _context$state$server5 !== void 0 ? _context$state$server5 : context.state.targetValue) !== null && _ref6 !== void 0 ? _ref6 : context.state.defaultValue, name);
 }
 function getErrors(state, name) {
   var _state$serverError;
@@ -204,8 +442,8 @@ function getFieldErrors(state, name) {
  */
 function hasFieldError(error, name) {
   var basePath = future.parsePath(name);
-  return Object.entries(error.fieldErrors).some(_ref6 => {
-    var [field, fieldError] = _ref6;
+  return Object.entries(error.fieldErrors).some(_ref7 => {
+    var [field, fieldError] = _ref7;
     return future.getRelativePath(field, basePath) !== null && fieldError !== null;
   });
 }
@@ -245,6 +483,9 @@ function getFormMetadata(context, options) {
     errorId: "".concat(context.formId, "-form-error"),
     descriptionId: "".concat(context.formId, "-form-description"),
     defaultValue: context.state.defaultValue,
+    get customState() {
+      return context.state.customState;
+    },
     get errors() {
       return getErrors(context.state);
     },
@@ -414,7 +655,61 @@ function getFieldList(context, options) {
     });
   });
 }
+function defineCustomState(definition) {
+  return definition;
+}
+function mergeCustomStateHandlers(globalCustomState, inlineCustomState) {
+  if (globalCustomState && inlineCustomState) {
+    for (var key of Object.keys(inlineCustomState)) {
+      if (Object.prototype.hasOwnProperty.call(globalCustomState, key)) {
+        throw new Error("Duplicate custom state key \"".concat(key, "\""));
+      }
+    }
+  }
+  return _rollupPluginBabelHelpers.objectSpread2(_rollupPluginBabelHelpers.objectSpread2({}, globalCustomState), inlineCustomState);
+}
+function initializeCustomState(options) {
+  var _options$handlers;
+  return Object.fromEntries(Object.entries((_options$handlers = options.handlers) !== null && _options$handlers !== void 0 ? _options$handlers : {}).map(_ref8 => {
+    var [key, handler] = _ref8;
+    if (!options.currentState || !Object.prototype.hasOwnProperty.call(options.currentState, key) || handler.reset === undefined || handler.reset === true) {
+      return [key, handler.initialize()];
+    }
+    var currentState = options.currentState[key];
+    if (typeof handler.reset === 'function') {
+      return [key, handler.reset(currentState, {
+        result: options.result
+      })];
+    }
+    return [key, currentState];
+  }));
+}
+function updateCustomState(state, action, options) {
+  if (!options.handlers) {
+    return state;
+  }
+  return Object.fromEntries(Object.entries(options.handlers).map(_ref9 => {
+    var [key, handler] = _ref9;
+    var nextState = state[key];
+    if (action.type !== 'server' && action.type !== 'client:async' && handler.handleIntent) {
+      nextState = handler.handleIntent(nextState, {
+        intent: action.intent,
+        submission: action.result.submission
+      });
+    }
+    if (handler.handleResult && typeof action.result.error !== 'undefined') {
+      nextState = handler.handleResult(nextState, {
+        intent: action.intent,
+        result: action.result,
+        phase: action.type === 'client' || action.type === 'client:async' ? 'client' : 'server'
+      });
+    }
+    return [key, nextState];
+  }));
+}
 
+exports.defineCustomState = defineCustomState;
+exports.getApplyStatus = getApplyStatus;
 exports.getDefaultListKey = getDefaultListKey;
 exports.getDefaultOptions = getDefaultOptions;
 exports.getDefaultPayload = getDefaultPayload;
@@ -423,13 +718,19 @@ exports.getErrors = getErrors;
 exports.getField = getField;
 exports.getFieldErrors = getFieldErrors;
 exports.getFieldList = getFieldList;
+exports.getFields = getFields;
 exports.getFieldset = getFieldset;
 exports.getFormMetadata = getFormMetadata;
 exports.getListKey = getListKey;
 exports.hasFieldError = hasFieldError;
+exports.initializeCustomState = initializeCustomState;
 exports.initializeState = initializeState;
+exports.invalidateState = invalidateState;
 exports.isDefaultChecked = isDefaultChecked;
 exports.isTouched = isTouched;
 exports.isValid = isValid;
+exports.mergeCustomStateHandlers = mergeCustomStateHandlers;
+exports.moveState = moveState;
 exports.pruneListKeys = pruneListKeys;
+exports.updateCustomState = updateCustomState;
 exports.updateState = updateState;