remix-validated-form 5.1.5 → 5.1.6

package/browser/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/browser/internal/state.js

@@ -1,64 +0,0 @@
-import { atom } from "jotai";
-import { atomFamily, selectAtom } from "jotai/utils";
-import omit from "lodash/omit";
-import { fieldAtomFamily, formAtomFamily, } from "./state/atomUtils";
-export const ATOM_SCOPE = Symbol("remix-validated-form-scope");
-export const isHydratedAtom = formAtomFamily(false);
-export const isSubmittingAtom = formAtomFamily(false);
-export const hasBeenSubmittedAtom = formAtomFamily(false);
-export const fieldErrorsAtom = formAtomFamily({});
-export const touchedFieldsAtom = formAtomFamily({});
-export const formPropsAtom = formAtomFamily({
-    validateField: () => Promise.resolve(null),
-    registerReceiveFocus: () => () => { },
-    defaultValues: {},
-});
-export const formElementAtom = formAtomFamily(null);
-//// Everything below is derived from the above
-export const cleanupFormState = (formId) => {
-    [
-        isHydratedAtom,
-        isSubmittingAtom,
-        hasBeenSubmittedAtom,
-        fieldErrorsAtom,
-        touchedFieldsAtom,
-        formPropsAtom,
-    ].forEach((formAtom) => formAtom.remove(formId));
-};
-export const isValidAtom = atomFamily((formId) => atom((get) => Object.keys(get(fieldErrorsAtom(formId))).length === 0));
-export const startSubmitAtom = atomFamily((formId) => atom(null, (_get, set) => {
-    set(isSubmittingAtom(formId), true);
-    set(hasBeenSubmittedAtom(formId), true);
-}));
-export const endSubmitAtom = atomFamily((formId) => atom(null, (_get, set) => {
-    set(isSubmittingAtom(formId), false);
-}));
-export const setTouchedAtom = atomFamily((formId) => atom(null, (get, set, { field, touched }) => {
-    const prev = get(touchedFieldsAtom(formId));
-    if (prev[field] !== touched) {
-        set(touchedFieldsAtom(formId), {
-            ...prev,
-            [field]: touched,
-        });
-    }
-}));
-export const setFieldErrorAtom = atomFamily((formId) => atom(null, (get, set, { field, error }) => {
-    const prev = get(fieldErrorsAtom(formId));
-    if (error === undefined && field in prev) {
-        set(fieldErrorsAtom(formId), omit(prev, field));
-    }
-    if (error !== undefined && prev[field] !== error) {
-        set(fieldErrorsAtom(formId), {
-            ...get(fieldErrorsAtom(formId)),
-            [field]: error,
-        });
-    }
-}));
-//// Field specific
-export const fieldTouchedAtom = fieldAtomFamily(({ formId, field }) => atom((get) => get(touchedFieldsAtom(formId))[field], (_get, set, touched) => {
-    set(setTouchedAtom(formId), { field, touched });
-}));
-export const fieldErrorAtom = fieldAtomFamily(({ formId, field }) => atom((get) => get(fieldErrorsAtom(formId))[field], (_get, set, error) => {
-    set(setFieldErrorAtom(formId), { field, error });
-}));
-export const fieldDefaultValueAtom = fieldAtomFamily(({ formId, field }) => selectAtom(formPropsAtom(formId), (state) => state.defaultValues[field]));

package/browser/internal/submissionCallbacks.d.ts

@@ -1 +0,0 @@
-export declare function useSubmitComplete(isSubmitting: boolean, callback: () => void): void;

package/browser/internal/submissionCallbacks.js

@@ -1,13 +0,0 @@
-import { useEffect, useRef } from "react";
-export function useSubmitComplete(isSubmitting, callback) {
-    const isPending = useRef(false);
-    useEffect(() => {
-        if (isSubmitting) {
-            isPending.current = true;
-        }
-        if (!isSubmitting && isPending.current) {
-            isPending.current = false;
-            callback();
-        }
-    });
-}

package/browser/internal/util.d.ts

@@ -1,5 +0,0 @@
-import type React from "react";
-export declare const omit: (obj: any, ...keys: string[]) => any;
-export declare const mergeRefs: <T = any>(refs: (React.MutableRefObject<T> | React.LegacyRef<T> | undefined)[]) => (instance: T | null) => void;
-export declare const useIsomorphicLayoutEffect: typeof React.useEffect;
-export declare const useDeepEqualsMemo: <T>(item: T) => T;

package/browser/internal/util.js

@@ -1,32 +0,0 @@
-import { useEffect, useLayoutEffect, useRef } from "react";
-import * as R from "remeda";
-export const omit = (obj, ...keys) => {
-    const result = { ...obj };
-    for (const key of keys) {
-        delete result[key];
-    }
-    return result;
-};
-export const mergeRefs = (refs) => {
-    return (value) => {
-        refs.filter(Boolean).forEach((ref) => {
-            if (typeof ref === "function") {
-                ref(value);
-            }
-            else if (ref != null) {
-                ref.current = value;
-            }
-        });
-    };
-};
-export const useIsomorphicLayoutEffect = typeof window !== "undefined" ? useLayoutEffect : useEffect;
-export const useDeepEqualsMemo = (item) => {
-    const ref = useRef(item);
-    const areEqual = ref.current === item || R.equals(ref.current, item);
-    useEffect(() => {
-        if (!areEqual) {
-            ref.current = item;
-        }
-    });
-    return areEqual ? ref.current : item;
-};

package/browser/server.d.ts

@@ -1,21 +0,0 @@
-import { FORM_DEFAULTS_FIELD } from "./internal/constants";
-import { ValidatorError, ValidationErrorResponseData } from "./validation/types";
-/**
- * Takes the errors from a `Validator` and returns a `Response`.
- * When you return this from your action, `ValidatedForm` on the frontend will automatically
- * display the errors on the correct fields on the correct form.
- *
- * You can also provide a second argument to `validationError`
- * to specify how to repopulate the form when JS is disabled.
- *
- * @example
- * ```ts
- * const result = validator.validate(await request.formData());
- * if (result.error) return validationError(result.error, result.submittedData);
- * ```
- */
-export declare function validationError(error: ValidatorError, repopulateFields?: unknown, init?: ResponseInit): import("@remix-run/server-runtime").TypedResponse<ValidationErrorResponseData>;
-export type FormDefaults = {
-    [formDefaultsKey: `${typeof FORM_DEFAULTS_FIELD}_${string}`]: any;
-};
-export declare const setFormDefaults: <DataType = any>(formId: string, defaultValues: Partial<DataType>) => FormDefaults;

package/browser/server.js

@@ -1,27 +0,0 @@
-import { json } from "remix";
-import { formDefaultValuesKey, } from "./internal/constants";
-/**
- * Takes the errors from a `Validator` and returns a `Response`.
- * When you return this from your action, `ValidatedForm` on the frontend will automatically
- * display the errors on the correct fields on the correct form.
- *
- * You can also provide a second argument to `validationError`
- * to specify how to repopulate the form when JS is disabled.
- *
- * @example
- * ```ts
- * const result = validator.validate(await request.formData());
- * if (result.error) return validationError(result.error, result.submittedData);
- * ```
- */
-export function validationError(error, repopulateFields, init) {
-    return json({
-        fieldErrors: error.fieldErrors,
-        subaction: error.subaction,
-        repopulateFields,
-        formId: error.formId,
-    }, { status: 422, ...init });
-}
-export const setFormDefaults = (formId, defaultValues) => ({
-    [formDefaultValuesKey(formId)]: defaultValues,
-});

package/browser/unreleased/formStateHooks.d.ts

@@ -1,64 +0,0 @@
-import { FieldErrors, TouchedFields, ValidationResult } from "../validation/types";
-export type FormState = {
-    fieldErrors: FieldErrors;
-    isSubmitting: boolean;
-    hasBeenSubmitted: boolean;
-    touchedFields: TouchedFields;
-    defaultValues: {
-        [fieldName: string]: any;
-    };
-    action?: string;
-    subaction?: string;
-    isValid: boolean;
-};
-/**
- * Returns information about the form.
- *
- * @param formId the id of the form. Only necessary if being used outside a ValidatedForm.
- */
-export declare const useFormState: (formId?: string) => FormState;
-export type FormHelpers = {
-    /**
-     * Clear the error of the specified field.
-     */
-    clearError: (fieldName: string) => void;
-    /**
-     * Validate the specified field.
-     */
-    validateField: (fieldName: string) => Promise<string | null>;
-    /**
-     * Change the touched state of the specified field.
-     */
-    setTouched: (fieldName: string, touched: boolean) => void;
-    /**
-     * Validate the whole form and populate any errors.
-     */
-    validate: () => Promise<ValidationResult<unknown>>;
-    /**
-     * 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;
-    /**
-     * Submits the form, running all validations first.
-     *
-     * _Note_: This is equivalent to clicking a button element with `type="submit"` or calling formElement.submit().
-     */
-    submit: () => void;
-    /**
-     * Returns the current form values as FormData
-     */
-    getValues: () => FormData;
-};
-/**
- * Returns helpers that can be used to update the form state.
- *
- * @param formId the id of the form. Only necessary if being used outside a ValidatedForm.
- */
-export declare const useFormHelpers: (formId?: string) => FormHelpers;

package/browser/unreleased/formStateHooks.js

@@ -1,76 +0,0 @@
-import { useMemo } from "react";
-import { useInternalFormContext, useClearError, useSetTouched, useDefaultValuesForForm, useFieldErrorsForForm, useInternalIsSubmitting, useInternalHasBeenSubmitted, useTouchedFields, useInternalIsValid, useFieldErrors, useValidateField, useValidate, useSetFieldErrors, useResetFormElement, useSyncedDefaultValues, useFormActionProp, useFormSubactionProp, useSubmitForm, useFormValues, } from "../internal/hooks";
-/**
- * Returns information about the form.
- *
- * @param formId the id of the form. Only necessary if being used outside a ValidatedForm.
- */
-export const useFormState = (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(syncedDefaultValues);
-    const fieldErrorsFromState = useFieldErrors(formContext.formId);
-    const fieldErrorsToUse = useFieldErrorsForForm(formContext);
-    const hydratedFieldErrors = fieldErrorsToUse.hydrateTo(fieldErrorsFromState);
-    return useMemo(() => ({
-        action,
-        subaction,
-        defaultValues: hydratedDefaultValues,
-        fieldErrors: hydratedFieldErrors !== null && hydratedFieldErrors !== void 0 ? hydratedFieldErrors : {},
-        hasBeenSubmitted,
-        isSubmitting,
-        touchedFields,
-        isValid,
-    }), [
-        action,
-        hasBeenSubmitted,
-        hydratedDefaultValues,
-        hydratedFieldErrors,
-        isSubmitting,
-        isValid,
-        subaction,
-        touchedFields,
-    ]);
-};
-/**
- * Returns helpers that can be used to update the form state.
- *
- * @param formId the id of the form. Only necessary if being used outside a ValidatedForm.
- */
-export const useFormHelpers = (formId) => {
-    const formContext = useInternalFormContext(formId, "useFormHelpers");
-    const setTouched = useSetTouched(formContext);
-    const validateField = useValidateField(formContext.formId);
-    const validate = useValidate(formContext.formId);
-    const clearError = useClearError(formContext);
-    const setFieldErrors = useSetFieldErrors(formContext.formId);
-    const reset = useResetFormElement(formContext.formId);
-    const submit = useSubmitForm(formContext.formId);
-    const getValues = useFormValues(formContext.formId);
-    return useMemo(() => ({
-        setTouched,
-        validateField,
-        clearError,
-        validate,
-        clearAllErrors: () => setFieldErrors({}),
-        reset,
-        submit,
-        getValues,
-    }), [
-        clearError,
-        reset,
-        setFieldErrors,
-        setTouched,
-        submit,
-        validate,
-        validateField,
-        getValues,
-    ]);
-};