remix-validated-form 4.3.1-beta.0 → 4.4.2

package/src/unreleased/formStateHooks.ts

@@ -6,16 +6,19 @@ import {
   useSetTouched,
   useDefaultValuesForForm,
   useFieldErrorsForForm,
-  useFormAtomValue,
+  useInternalIsSubmitting,
+  useInternalHasBeenSubmitted,
+  useTouchedFields,
+  useInternalIsValid,
+  useFieldErrors,
+  useValidateField,
+  useValidate,
+  useSetFieldErrors,
+  useResetFormElement,
+  useSyncedDefaultValues,
+  useFormActionProp,
+  useFormSubactionProp,
 } from "../internal/hooks";
-import {
-  fieldErrorsAtom,
-  formPropsAtom,
-  hasBeenSubmittedAtom,
-  isSubmittingAtom,
-  isValidAtom,
-  touchedFieldsAtom,
-} from "../internal/state";
 import { FieldErrors, TouchedFields } from "../validation/types";
 
 export type FormState = {
@@ -35,29 +38,27 @@ export type FormState = {
  * @param formId the id of the form. Only necessary if being used outside a ValidatedForm.
  */
 export const useFormState = (formId?: string): FormState => {
-  const formContext = useInternalFormContext(formId, "useIsValid");
-  const formProps = useFormAtomValue(formPropsAtom(formContext.formId));
-  const isSubmitting = useFormAtomValue(isSubmittingAtom(formContext.formId));
-  const hasBeenSubmitted = useFormAtomValue(
-    hasBeenSubmittedAtom(formContext.formId)
-  );
-  const touchedFields = useFormAtomValue(touchedFieldsAtom(formContext.formId));
-  const isValid = useFormAtomValue(isValidAtom(formContext.formId));
+  const formContext = useInternalFormContext(formId, "useFormState");
+  const isSubmitting = useInternalIsSubmitting(formContext.formId);
+  const hasBeenSubmitted = useInternalHasBeenSubmitted(formContext.formId);
+  const touchedFields = useTouchedFields(formContext.formId);
+  const isValid = useInternalIsValid(formContext.formId);
+  const action = useFormActionProp(formContext.formId);
+  const subaction = useFormSubactionProp(formContext.formId);
 
+  const syncedDefaultValues = useSyncedDefaultValues(formContext.formId);
   const defaultValuesToUse = useDefaultValuesForForm(formContext);
-  const hydratedDefaultValues = defaultValuesToUse.hydrateTo(
-    formProps.defaultValues
-  );
+  const hydratedDefaultValues =
+    defaultValuesToUse.hydrateTo(syncedDefaultValues);
 
-  const fieldErrorsFromState = useFormAtomValue(
-    fieldErrorsAtom(formContext.formId)
-  );
+  const fieldErrorsFromState = useFieldErrors(formContext.formId);
   const fieldErrorsToUse = useFieldErrorsForForm(formContext);
   const hydratedFieldErrors = fieldErrorsToUse.hydrateTo(fieldErrorsFromState);
 
   return useMemo(
     () => ({
-      ...formProps,
+      action,
+      subaction,
       defaultValues: hydratedDefaultValues,
       fieldErrors: hydratedFieldErrors ?? {},
       hasBeenSubmitted,
@@ -66,12 +67,13 @@ export const useFormState = (formId?: string): FormState => {
       isValid,
     }),
     [
-      formProps,
+      action,
       hasBeenSubmitted,
       hydratedDefaultValues,
       hydratedFieldErrors,
       isSubmitting,
       isValid,
+      subaction,
       touchedFields,
     ]
   );
@@ -90,6 +92,21 @@ export type FormHelpers = {
    * Change the touched state of the specified field.
    */
   setTouched: (fieldName: string, touched: boolean) => void;
+  /**
+   * Validate the whole form and populate any errors.
+   */
+  validate: () => Promise<void>;
+  /**
+   * Clears all errors on the form.
+   */
+  clearAllErrors: () => void;
+  /**
+   * Resets the form.
+   *
+   * _Note_: The equivalent behavior can be achieved by calling formElement.reset()
+   * or clicking a button element with `type="reset"`.
+   */
+  reset: () => void;
 };
 
 /**
@@ -100,14 +117,20 @@ export type FormHelpers = {
 export const useFormHelpers = (formId?: string): FormHelpers => {
   const formContext = useInternalFormContext(formId, "useFormHelpers");
   const setTouched = useSetTouched(formContext);
-  const { validateField } = useFormAtomValue(formPropsAtom(formContext.formId));
+  const validateField = useValidateField(formContext.formId);
+  const validate = useValidate(formContext.formId);
   const clearError = useClearError(formContext);
+  const setFieldErrors = useSetFieldErrors(formContext.formId);
+  const reset = useResetFormElement(formContext.formId);
   return useMemo(
     () => ({
       setTouched,
       validateField,
       clearError,
+      validate,
+      clearAllErrors: () => setFieldErrors({}),
+      reset,
     }),
-    [clearError, setTouched, validateField]
+    [clearError, reset, setFieldErrors, setTouched, validate, validateField]
   );
 };

package/src/userFacingFormContext.ts

@@ -1,6 +1,8 @@
 import { useCallback } from "react";
-import { useFormAtomValue, useInternalFormContext } from "./internal/hooks";
-import { formPropsAtom } from "./internal/state";
+import {
+  useInternalFormContext,
+  useRegisterReceiveFocus,
+} from "./internal/hooks";
 import { useFormHelpers, useFormState } from "./unreleased/formStateHooks";
 import { FieldErrors, TouchedFields } from "./validation/types";
 
@@ -56,6 +58,21 @@ export type FormContextValue = {
    * Change the touched state of the specified field.
    */
   setFieldTouched: (fieldName: string, touched: boolean) => void;
+  /**
+   * Validate the whole form and populate any errors.
+   */
+  validate: () => Promise<void>;
+  /**
+   * Clears all errors on the form.
+   */
+  clearAllErrors: () => void;
+  /**
+   * Resets the form.
+   *
+   * _Note_: The equivalent behavior can be achieved by calling formElement.reset()
+   * or clicking a button element with `type="reset"`.
+   */
+  reset: () => void;
 };
 
 /**
@@ -69,11 +86,12 @@ export const useFormContext = (formId?: string): FormContextValue => {
     clearError: internalClearError,
     setTouched,
     validateField,
+    clearAllErrors,
+    validate,
+    reset,
   } = useFormHelpers(formId);
 
-  const { registerReceiveFocus } = useFormAtomValue(
-    formPropsAtom(context.formId)
-  );
+  const registerReceiveFocus = useRegisterReceiveFocus(context.formId);
 
   const clearError = useCallback(
     (...names: string[]) => {
@@ -90,5 +108,8 @@ export const useFormContext = (formId?: string): FormContextValue => {
     validateField,
     clearError,
     registerReceiveFocus,
+    clearAllErrors,
+    validate,
+    reset,
   };
 };

package/dist/types/internal/reset.d.ts

@@ -1,28 +0,0 @@
-import { InternalFormId } from "./state/atomUtils";
-export declare const resetAtom: {
-    (param: InternalFormId): import("jotai").Atom<null> & {
-        write: (get: {
-            <Value>(atom: import("jotai").Atom<Value | Promise<Value>>): Value;
-            <Value_1>(atom: import("jotai").Atom<Promise<Value_1>>): Value_1;
-            <Value_2>(atom: import("jotai").Atom<Value_2>): Value_2 extends Promise<infer V> ? V : Value_2;
-        } & {
-            <Value_3>(atom: import("jotai").Atom<Value_3 | Promise<Value_3>>, options: {
-                unstable_promise: true;
-            }): Value_3 | Promise<Value_3>;
-            <Value_4>(atom: import("jotai").Atom<Promise<Value_4>>, options: {
-                unstable_promise: true;
-            }): Value_4 | Promise<Value_4>;
-            <Value_5>(atom: import("jotai").Atom<Value_5>, options: {
-                unstable_promise: true;
-            }): (Value_5 extends Promise<infer V> ? V : Value_5) | Promise<Value_5 extends Promise<infer V> ? V : Value_5>;
-        }, set: {
-            <Value_6, Result extends void | Promise<void>>(atom: import("jotai").WritableAtom<Value_6, undefined, Result>): Result;
-            <Value_7, Update, Result_1 extends void | Promise<void>>(atom: import("jotai").WritableAtom<Value_7, Update, Result_1>, update: Update): Result_1;
-        }, update: unknown) => void;
-        onMount?: (<S extends (update?: unknown) => void>(setAtom: S) => void | (() => void)) | undefined;
-    } & {
-        init: null;
-    };
-    remove(param: InternalFormId): void;
-    setShouldRemove(shouldRemove: ((createdAt: number, param: InternalFormId) => boolean) | null): void;
-};

package/dist/types/internal/state/atomUtils.d.ts

@@ -1,38 +0,0 @@
-import { Atom } from "jotai";
-export declare type InternalFormId = string | symbol;
-export declare const formAtomFamily: <T>(data: T) => {
-    (param: InternalFormId): Atom<T> & {
-        write: (get: {
-            <Value>(atom: Atom<Value | Promise<Value>>): Value;
-            <Value_1>(atom: Atom<Promise<Value_1>>): Value_1;
-            <Value_2>(atom: Atom<Value_2>): Value_2 extends Promise<infer V> ? V : Value_2;
-        } & {
-            <Value_3>(atom: Atom<Value_3 | Promise<Value_3>>, options: {
-                unstable_promise: true;
-            }): Value_3 | Promise<Value_3>;
-            <Value_4>(atom: Atom<Promise<Value_4>>, options: {
-                unstable_promise: true;
-            }): Value_4 | Promise<Value_4>;
-            <Value_5>(atom: Atom<Value_5>, options: {
-                unstable_promise: true;
-            }): (Value_5 extends Promise<infer V> ? V : Value_5) | Promise<Value_5 extends Promise<infer V> ? V : Value_5>;
-        }, set: {
-            <Value_6, Result extends void | Promise<void>>(atom: import("jotai").WritableAtom<Value_6, undefined, Result>): Result;
-            <Value_7, Update, Result_1 extends void | Promise<void>>(atom: import("jotai").WritableAtom<Value_7, Update, Result_1>, update: Update): Result_1;
-        }, update: T | ((prev: T) => T)) => void;
-        onMount?: (<S extends import("jotai/core/atom").SetAtom<T | ((prev: T) => T), void>>(setAtom: S) => void | (() => void)) | undefined;
-    } & {
-        init: T;
-    };
-    remove(param: InternalFormId): void;
-    setShouldRemove(shouldRemove: ((createdAt: number, param: InternalFormId) => boolean) | null): void;
-};
-export declare type FieldAtomKey = {
-    formId: InternalFormId;
-    field: string;
-};
-export declare const fieldAtomFamily: <T extends Atom<unknown>>(func: (key: FieldAtomKey) => T) => {
-    (param: FieldAtomKey): T;
-    remove(param: FieldAtomKey): void;
-    setShouldRemove(shouldRemove: ((createdAt: number, param: FieldAtomKey) => boolean) | null): void;
-};

package/dist/types/internal/state.d.ts

@@ -1,343 +0,0 @@
-import { FieldErrors, TouchedFields } from "../validation/types";
-import { InternalFormId } from "./state/atomUtils";
-export declare const ATOM_SCOPE: unique symbol;
-export declare type SyncedFormProps = {
-    formId?: string;
-    action?: string;
-    subaction?: string;
-    defaultValues: {
-        [fieldName: string]: any;
-    };
-    validateField: (fieldName: string) => Promise<string | null>;
-    registerReceiveFocus: (fieldName: string, handler: () => void) => () => void;
-};
-export declare const isHydratedAtom: {
-    (param: InternalFormId): import("jotai").Atom<boolean> & {
-        write: (get: {
-            <Value>(atom: import("jotai").Atom<Value | Promise<Value>>): Value;
-            <Value_1>(atom: import("jotai").Atom<Promise<Value_1>>): Value_1;
-            <Value_2>(atom: import("jotai").Atom<Value_2>): Value_2 extends Promise<infer V> ? V : Value_2;
-        } & {
-            <Value_3>(atom: import("jotai").Atom<Value_3 | Promise<Value_3>>, options: {
-                unstable_promise: true;
-            }): Value_3 | Promise<Value_3>;
-            <Value_4>(atom: import("jotai").Atom<Promise<Value_4>>, options: {
-                unstable_promise: true;
-            }): Value_4 | Promise<Value_4>;
-            <Value_5>(atom: import("jotai").Atom<Value_5>, options: {
-                unstable_promise: true;
-            }): (Value_5 extends Promise<infer V> ? V : Value_5) | Promise<Value_5 extends Promise<infer V> ? V : Value_5>;
-        }, set: {
-            <Value_6, Result extends void | Promise<void>>(atom: import("jotai").WritableAtom<Value_6, undefined, Result>): Result;
-            <Value_7, Update, Result_1 extends void | Promise<void>>(atom: import("jotai").WritableAtom<Value_7, Update, Result_1>, update: Update): Result_1;
-        }, update: boolean | ((prev: boolean) => boolean)) => void;
-        onMount?: (<S extends (update: boolean | ((prev: boolean) => boolean)) => void>(setAtom: S) => void | (() => void)) | undefined;
-    } & {
-        init: boolean;
-    };
-    remove(param: InternalFormId): void;
-    setShouldRemove(shouldRemove: ((createdAt: number, param: InternalFormId) => boolean) | null): void;
-};
-export declare const isSubmittingAtom: {
-    (param: InternalFormId): import("jotai").Atom<boolean> & {
-        write: (get: {
-            <Value>(atom: import("jotai").Atom<Value | Promise<Value>>): Value;
-            <Value_1>(atom: import("jotai").Atom<Promise<Value_1>>): Value_1;
-            <Value_2>(atom: import("jotai").Atom<Value_2>): Value_2 extends Promise<infer V> ? V : Value_2;
-        } & {
-            <Value_3>(atom: import("jotai").Atom<Value_3 | Promise<Value_3>>, options: {
-                unstable_promise: true;
-            }): Value_3 | Promise<Value_3>;
-            <Value_4>(atom: import("jotai").Atom<Promise<Value_4>>, options: {
-                unstable_promise: true;
-            }): Value_4 | Promise<Value_4>;
-            <Value_5>(atom: import("jotai").Atom<Value_5>, options: {
-                unstable_promise: true;
-            }): (Value_5 extends Promise<infer V> ? V : Value_5) | Promise<Value_5 extends Promise<infer V> ? V : Value_5>;
-        }, set: {
-            <Value_6, Result extends void | Promise<void>>(atom: import("jotai").WritableAtom<Value_6, undefined, Result>): Result;
-            <Value_7, Update, Result_1 extends void | Promise<void>>(atom: import("jotai").WritableAtom<Value_7, Update, Result_1>, update: Update): Result_1;
-        }, update: boolean | ((prev: boolean) => boolean)) => void;
-        onMount?: (<S extends (update: boolean | ((prev: boolean) => boolean)) => void>(setAtom: S) => void | (() => void)) | undefined;
-    } & {
-        init: boolean;
-    };
-    remove(param: InternalFormId): void;
-    setShouldRemove(shouldRemove: ((createdAt: number, param: InternalFormId) => boolean) | null): void;
-};
-export declare const hasBeenSubmittedAtom: {
-    (param: InternalFormId): import("jotai").Atom<boolean> & {
-        write: (get: {
-            <Value>(atom: import("jotai").Atom<Value | Promise<Value>>): Value;
-            <Value_1>(atom: import("jotai").Atom<Promise<Value_1>>): Value_1;
-            <Value_2>(atom: import("jotai").Atom<Value_2>): Value_2 extends Promise<infer V> ? V : Value_2;
-        } & {
-            <Value_3>(atom: import("jotai").Atom<Value_3 | Promise<Value_3>>, options: {
-                unstable_promise: true;
-            }): Value_3 | Promise<Value_3>;
-            <Value_4>(atom: import("jotai").Atom<Promise<Value_4>>, options: {
-                unstable_promise: true;
-            }): Value_4 | Promise<Value_4>;
-            <Value_5>(atom: import("jotai").Atom<Value_5>, options: {
-                unstable_promise: true;
-            }): (Value_5 extends Promise<infer V> ? V : Value_5) | Promise<Value_5 extends Promise<infer V> ? V : Value_5>;
-        }, set: {
-            <Value_6, Result extends void | Promise<void>>(atom: import("jotai").WritableAtom<Value_6, undefined, Result>): Result;
-            <Value_7, Update, Result_1 extends void | Promise<void>>(atom: import("jotai").WritableAtom<Value_7, Update, Result_1>, update: Update): Result_1;
-        }, update: boolean | ((prev: boolean) => boolean)) => void;
-        onMount?: (<S extends (update: boolean | ((prev: boolean) => boolean)) => void>(setAtom: S) => void | (() => void)) | undefined;
-    } & {
-        init: boolean;
-    };
-    remove(param: InternalFormId): void;
-    setShouldRemove(shouldRemove: ((createdAt: number, param: InternalFormId) => boolean) | null): void;
-};
-export declare const fieldErrorsAtom: {
-    (param: InternalFormId): import("jotai").Atom<FieldErrors> & {
-        write: (get: {
-            <Value>(atom: import("jotai").Atom<Value | Promise<Value>>): Value;
-            <Value_1>(atom: import("jotai").Atom<Promise<Value_1>>): Value_1;
-            <Value_2>(atom: import("jotai").Atom<Value_2>): Value_2 extends Promise<infer V> ? V : Value_2;
-        } & {
-            <Value_3>(atom: import("jotai").Atom<Value_3 | Promise<Value_3>>, options: {
-                unstable_promise: true;
-            }): Value_3 | Promise<Value_3>;
-            <Value_4>(atom: import("jotai").Atom<Promise<Value_4>>, options: {
-                unstable_promise: true;
-            }): Value_4 | Promise<Value_4>;
-            <Value_5>(atom: import("jotai").Atom<Value_5>, options: {
-                unstable_promise: true;
-            }): (Value_5 extends Promise<infer V> ? V : Value_5) | Promise<Value_5 extends Promise<infer V> ? V : Value_5>;
-        }, set: {
-            <Value_6, Result extends void | Promise<void>>(atom: import("jotai").WritableAtom<Value_6, undefined, Result>): Result;
-            <Value_7, Update, Result_1 extends void | Promise<void>>(atom: import("jotai").WritableAtom<Value_7, Update, Result_1>, update: Update): Result_1;
-        }, update: FieldErrors | ((prev: FieldErrors) => FieldErrors)) => void;
-        onMount?: (<S extends (update: FieldErrors | ((prev: FieldErrors) => FieldErrors)) => void>(setAtom: S) => void | (() => void)) | undefined;
-    } & {
-        init: FieldErrors;
-    };
-    remove(param: InternalFormId): void;
-    setShouldRemove(shouldRemove: ((createdAt: number, param: InternalFormId) => boolean) | null): void;
-};
-export declare const touchedFieldsAtom: {
-    (param: InternalFormId): import("jotai").Atom<TouchedFields> & {
-        write: (get: {
-            <Value>(atom: import("jotai").Atom<Value | Promise<Value>>): Value;
-            <Value_1>(atom: import("jotai").Atom<Promise<Value_1>>): Value_1;
-            <Value_2>(atom: import("jotai").Atom<Value_2>): Value_2 extends Promise<infer V> ? V : Value_2;
-        } & {
-            <Value_3>(atom: import("jotai").Atom<Value_3 | Promise<Value_3>>, options: {
-                unstable_promise: true;
-            }): Value_3 | Promise<Value_3>;
-            <Value_4>(atom: import("jotai").Atom<Promise<Value_4>>, options: {
-                unstable_promise: true;
-            }): Value_4 | Promise<Value_4>;
-            <Value_5>(atom: import("jotai").Atom<Value_5>, options: {
-                unstable_promise: true;
-            }): (Value_5 extends Promise<infer V> ? V : Value_5) | Promise<Value_5 extends Promise<infer V> ? V : Value_5>;
-        }, set: {
-            <Value_6, Result extends void | Promise<void>>(atom: import("jotai").WritableAtom<Value_6, undefined, Result>): Result;
-            <Value_7, Update, Result_1 extends void | Promise<void>>(atom: import("jotai").WritableAtom<Value_7, Update, Result_1>, update: Update): Result_1;
-        }, update: TouchedFields | ((prev: TouchedFields) => TouchedFields)) => void;
-        onMount?: (<S extends (update: TouchedFields | ((prev: TouchedFields) => TouchedFields)) => void>(setAtom: S) => void | (() => void)) | undefined;
-    } & {
-        init: TouchedFields;
-    };
-    remove(param: InternalFormId): void;
-    setShouldRemove(shouldRemove: ((createdAt: number, param: InternalFormId) => boolean) | null): void;
-};
-export declare const formPropsAtom: {
-    (param: InternalFormId): import("jotai").Atom<SyncedFormProps> & {
-        write: (get: {
-            <Value>(atom: import("jotai").Atom<Value | Promise<Value>>): Value;
-            <Value_1>(atom: import("jotai").Atom<Promise<Value_1>>): Value_1;
-            <Value_2>(atom: import("jotai").Atom<Value_2>): Value_2 extends Promise<infer V> ? V : Value_2;
-        } & {
-            <Value_3>(atom: import("jotai").Atom<Value_3 | Promise<Value_3>>, options: {
-                unstable_promise: true;
-            }): Value_3 | Promise<Value_3>;
-            <Value_4>(atom: import("jotai").Atom<Promise<Value_4>>, options: {
-                unstable_promise: true;
-            }): Value_4 | Promise<Value_4>;
-            <Value_5>(atom: import("jotai").Atom<Value_5>, options: {
-                unstable_promise: true;
-            }): (Value_5 extends Promise<infer V> ? V : Value_5) | Promise<Value_5 extends Promise<infer V> ? V : Value_5>;
-        }, set: {
-            <Value_6, Result extends void | Promise<void>>(atom: import("jotai").WritableAtom<Value_6, undefined, Result>): Result;
-            <Value_7, Update, Result_1 extends void | Promise<void>>(atom: import("jotai").WritableAtom<Value_7, Update, Result_1>, update: Update): Result_1;
-        }, update: SyncedFormProps | ((prev: SyncedFormProps) => SyncedFormProps)) => void;
-        onMount?: (<S extends (update: SyncedFormProps | ((prev: SyncedFormProps) => SyncedFormProps)) => void>(setAtom: S) => void | (() => void)) | undefined;
-    } & {
-        init: SyncedFormProps;
-    };
-    remove(param: InternalFormId): void;
-    setShouldRemove(shouldRemove: ((createdAt: number, param: InternalFormId) => boolean) | null): void;
-};
-export declare const formElementAtom: {
-    (param: InternalFormId): import("jotai").Atom<HTMLFormElement | null> & {
-        write: (get: {
-            <Value>(atom: import("jotai").Atom<Value | Promise<Value>>): Value;
-            <Value_1>(atom: import("jotai").Atom<Promise<Value_1>>): Value_1;
-            <Value_2>(atom: import("jotai").Atom<Value_2>): Value_2 extends Promise<infer V> ? V : Value_2;
-        } & {
-            <Value_3>(atom: import("jotai").Atom<Value_3 | Promise<Value_3>>, options: {
-                unstable_promise: true;
-            }): Value_3 | Promise<Value_3>;
-            <Value_4>(atom: import("jotai").Atom<Promise<Value_4>>, options: {
-                unstable_promise: true;
-            }): Value_4 | Promise<Value_4>;
-            <Value_5>(atom: import("jotai").Atom<Value_5>, options: {
-                unstable_promise: true;
-            }): (Value_5 extends Promise<infer V> ? V : Value_5) | Promise<Value_5 extends Promise<infer V> ? V : Value_5>;
-        }, set: {
-            <Value_6, Result extends void | Promise<void>>(atom: import("jotai").WritableAtom<Value_6, undefined, Result>): Result;
-            <Value_7, Update, Result_1 extends void | Promise<void>>(atom: import("jotai").WritableAtom<Value_7, Update, Result_1>, update: Update): Result_1;
-        }, update: HTMLFormElement | ((prev: HTMLFormElement | null) => HTMLFormElement | null) | null) => void;
-        onMount?: (<S extends (update: HTMLFormElement | ((prev: HTMLFormElement | null) => HTMLFormElement | null) | null) => void>(setAtom: S) => void | (() => void)) | undefined;
-    } & {
-        init: HTMLFormElement | null;
-    };
-    remove(param: InternalFormId): void;
-    setShouldRemove(shouldRemove: ((createdAt: number, param: InternalFormId) => boolean) | null): void;
-};
-export declare const cleanupFormState: (formId: InternalFormId) => void;
-export declare const isValidAtom: {
-    (param: InternalFormId): import("jotai").Atom<boolean>;
-    remove(param: InternalFormId): void;
-    setShouldRemove(shouldRemove: ((createdAt: number, param: InternalFormId) => boolean) | null): void;
-};
-export declare const startSubmitAtom: {
-    (param: InternalFormId): import("jotai").Atom<null> & {
-        write: (get: {
-            <Value>(atom: import("jotai").Atom<Value | Promise<Value>>): Value;
-            <Value_1>(atom: import("jotai").Atom<Promise<Value_1>>): Value_1;
-            <Value_2>(atom: import("jotai").Atom<Value_2>): Value_2 extends Promise<infer V> ? V : Value_2;
-        } & {
-            <Value_3>(atom: import("jotai").Atom<Value_3 | Promise<Value_3>>, options: {
-                unstable_promise: true;
-            }): Value_3 | Promise<Value_3>;
-            <Value_4>(atom: import("jotai").Atom<Promise<Value_4>>, options: {
-                unstable_promise: true;
-            }): Value_4 | Promise<Value_4>;
-            <Value_5>(atom: import("jotai").Atom<Value_5>, options: {
-                unstable_promise: true;
-            }): (Value_5 extends Promise<infer V> ? V : Value_5) | Promise<Value_5 extends Promise<infer V> ? V : Value_5>;
-        }, set: {
-            <Value_6, Result extends void | Promise<void>>(atom: import("jotai").WritableAtom<Value_6, undefined, Result>): Result;
-            <Value_7, Update, Result_1 extends void | Promise<void>>(atom: import("jotai").WritableAtom<Value_7, Update, Result_1>, update: Update): Result_1;
-        }, update: unknown) => void;
-        onMount?: (<S extends (update?: unknown) => void>(setAtom: S) => void | (() => void)) | undefined;
-    } & {
-        init: null;
-    };
-    remove(param: InternalFormId): void;
-    setShouldRemove(shouldRemove: ((createdAt: number, param: InternalFormId) => boolean) | null): void;
-};
-export declare const endSubmitAtom: {
-    (param: InternalFormId): import("jotai").Atom<null> & {
-        write: (get: {
-            <Value>(atom: import("jotai").Atom<Value | Promise<Value>>): Value;
-            <Value_1>(atom: import("jotai").Atom<Promise<Value_1>>): Value_1;
-            <Value_2>(atom: import("jotai").Atom<Value_2>): Value_2 extends Promise<infer V> ? V : Value_2;
-        } & {
-            <Value_3>(atom: import("jotai").Atom<Value_3 | Promise<Value_3>>, options: {
-                unstable_promise: true;
-            }): Value_3 | Promise<Value_3>;
-            <Value_4>(atom: import("jotai").Atom<Promise<Value_4>>, options: {
-                unstable_promise: true;
-            }): Value_4 | Promise<Value_4>;
-            <Value_5>(atom: import("jotai").Atom<Value_5>, options: {
-                unstable_promise: true;
-            }): (Value_5 extends Promise<infer V> ? V : Value_5) | Promise<Value_5 extends Promise<infer V> ? V : Value_5>;
-        }, set: {
-            <Value_6, Result extends void | Promise<void>>(atom: import("jotai").WritableAtom<Value_6, undefined, Result>): Result;
-            <Value_7, Update, Result_1 extends void | Promise<void>>(atom: import("jotai").WritableAtom<Value_7, Update, Result_1>, update: Update): Result_1;
-        }, update: unknown) => void;
-        onMount?: (<S extends (update?: unknown) => void>(setAtom: S) => void | (() => void)) | undefined;
-    } & {
-        init: null;
-    };
-    remove(param: InternalFormId): void;
-    setShouldRemove(shouldRemove: ((createdAt: number, param: InternalFormId) => boolean) | null): void;
-};
-export declare const setTouchedAtom: {
-    (param: InternalFormId): import("jotai").Atom<null> & {
-        write: (get: {
-            <Value>(atom: import("jotai").Atom<Value | Promise<Value>>): Value;
-            <Value_1>(atom: import("jotai").Atom<Promise<Value_1>>): Value_1;
-            <Value_2>(atom: import("jotai").Atom<Value_2>): Value_2 extends Promise<infer V> ? V : Value_2;
-        } & {
-            <Value_3>(atom: import("jotai").Atom<Value_3 | Promise<Value_3>>, options: {
-                unstable_promise: true;
-            }): Value_3 | Promise<Value_3>;
-            <Value_4>(atom: import("jotai").Atom<Promise<Value_4>>, options: {
-                unstable_promise: true;
-            }): Value_4 | Promise<Value_4>;
-            <Value_5>(atom: import("jotai").Atom<Value_5>, options: {
-                unstable_promise: true;
-            }): (Value_5 extends Promise<infer V> ? V : Value_5) | Promise<Value_5 extends Promise<infer V> ? V : Value_5>;
-        }, set: {
-            <Value_6, Result extends void | Promise<void>>(atom: import("jotai").WritableAtom<Value_6, undefined, Result>): Result;
-            <Value_7, Update, Result_1 extends void | Promise<void>>(atom: import("jotai").WritableAtom<Value_7, Update, Result_1>, update: Update): Result_1;
-        }, update: {
-            field: string;
-            touched: boolean;
-        }) => void;
-        onMount?: (<S extends (update: {
-            field: string;
-            touched: boolean;
-        }) => void>(setAtom: S) => void | (() => void)) | undefined;
-    } & {
-        init: null;
-    };
-    remove(param: InternalFormId): void;
-    setShouldRemove(shouldRemove: ((createdAt: number, param: InternalFormId) => boolean) | null): void;
-};
-export declare const setFieldErrorAtom: {
-    (param: InternalFormId): import("jotai").Atom<null> & {
-        write: (get: {
-            <Value>(atom: import("jotai").Atom<Value | Promise<Value>>): Value;
-            <Value_1>(atom: import("jotai").Atom<Promise<Value_1>>): Value_1;
-            <Value_2>(atom: import("jotai").Atom<Value_2>): Value_2 extends Promise<infer V> ? V : Value_2;
-        } & {
-            <Value_3>(atom: import("jotai").Atom<Value_3 | Promise<Value_3>>, options: {
-                unstable_promise: true;
-            }): Value_3 | Promise<Value_3>;
-            <Value_4>(atom: import("jotai").Atom<Promise<Value_4>>, options: {
-                unstable_promise: true;
-            }): Value_4 | Promise<Value_4>;
-            <Value_5>(atom: import("jotai").Atom<Value_5>, options: {
-                unstable_promise: true;
-            }): (Value_5 extends Promise<infer V> ? V : Value_5) | Promise<Value_5 extends Promise<infer V> ? V : Value_5>;
-        }, set: {
-            <Value_6, Result extends void | Promise<void>>(atom: import("jotai").WritableAtom<Value_6, undefined, Result>): Result;
-            <Value_7, Update, Result_1 extends void | Promise<void>>(atom: import("jotai").WritableAtom<Value_7, Update, Result_1>, update: Update): Result_1;
-        }, update: {
-            field: string;
-            error: string | undefined;
-        }) => void;
-        onMount?: (<S extends (update: {
-            field: string;
-            error: string | undefined;
-        }) => void>(setAtom: S) => void | (() => void)) | undefined;
-    } & {
-        init: null;
-    };
-    remove(param: InternalFormId): void;
-    setShouldRemove(shouldRemove: ((createdAt: number, param: InternalFormId) => boolean) | null): void;
-};
-export declare const fieldTouchedAtom: {
-    (param: import("./state/atomUtils").FieldAtomKey): import("jotai").WritableAtom<boolean, boolean, void>;
-    remove(param: import("./state/atomUtils").FieldAtomKey): void;
-    setShouldRemove(shouldRemove: ((createdAt: number, param: import("./state/atomUtils").FieldAtomKey) => boolean) | null): void;
-};
-export declare const fieldErrorAtom: {
-    (param: import("./state/atomUtils").FieldAtomKey): import("jotai").WritableAtom<string, string | undefined, void>;
-    remove(param: import("./state/atomUtils").FieldAtomKey): void;
-    setShouldRemove(shouldRemove: ((createdAt: number, param: import("./state/atomUtils").FieldAtomKey) => boolean) | null): void;
-};
-export declare const fieldDefaultValueAtom: {
-    (param: import("./state/atomUtils").FieldAtomKey): import("jotai").Atom<any>;
-    remove(param: import("./state/atomUtils").FieldAtomKey): void;
-    setShouldRemove(shouldRemove: ((createdAt: number, param: import("./state/atomUtils").FieldAtomKey) => boolean) | null): void;
-};

package/src/internal/reset.ts

@@ -1,26 +0,0 @@
-import { atom } from "jotai";
-import { atomFamily } from "jotai/utils";
-import lodashGet from "lodash/get";
-import {
-  fieldErrorsAtom,
-  formPropsAtom,
-  hasBeenSubmittedAtom,
-  touchedFieldsAtom,
-} from "./state";
-import { InternalFormId } from "./state/atomUtils";
-import { controlledFieldsAtom } from "./state/controlledFields";
-
-export const resetAtom = atomFamily((formId: InternalFormId) =>
-  atom(null, (get, set) => {
-    set(fieldErrorsAtom(formId), {});
-    set(touchedFieldsAtom(formId), {});
-    set(hasBeenSubmittedAtom(formId), false);
-
-    const { defaultValues } = get(formPropsAtom(formId));
-
-    const controlledFields = get(controlledFieldsAtom(formId));
-    Object.entries(controlledFields).forEach(([name, atom]) =>
-      set(atom, lodashGet(defaultValues, name))
-    );
-  })
-);

package/src/internal/state/atomUtils.ts

@@ -1,13 +0,0 @@
-import { Atom, atom } from "jotai";
-import { atomFamily } from "jotai/utils";
-import isEqual from "lodash/isEqual";
-
-export type InternalFormId = string | symbol;
-
-export const formAtomFamily = <T>(data: T) =>
-  atomFamily((_: InternalFormId) => atom(data));
-
-export type FieldAtomKey = { formId: InternalFormId; field: string };
-export const fieldAtomFamily = <T extends Atom<unknown>>(
-  func: (key: FieldAtomKey) => T
-) => atomFamily(func, isEqual);