@voila.dev/effect-form 0.27.0

package/dist/FormAtoms.js

@@ -0,0 +1,620 @@
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import { pipe } from "effect/Function";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import * as AsyncResult from "effect/unstable/reactivity/AsyncResult";
+import * as Atom from "effect/unstable/reactivity/Atom";
+import * as Field from "./Field.js";
+import * as FormBuilder from "./FormBuilder.js";
+import { recalculateDirtyFieldsForArray, recalculateDirtySubtree, } from "./internal/dirty.js";
+import * as Mode from "./Mode.js";
+import { getNestedValue, isPathOrParentDirty, setNestedValue } from "./Path.js";
+import * as Validation from "./Validation.js";
+const getStateOrThrow = (state, fieldPath) => {
+    if (Option.isNone(state)) {
+        throw new Error(`Field "${fieldPath}" was read before the form was initialized. ` +
+            "Form state does not exist until initialization: render your fields inside " +
+            "<form.Initialize defaultValues={...}> (React/Solid), or set the form state before reading field atoms. " +
+            `See the "Basic Form Setup" section of the README.`);
+    }
+    return state.value;
+};
+export const make = (config) => {
+    const { formBuilder, runtime } = config;
+    const { fields } = formBuilder;
+    const parsedMode = Mode.parse(config.mode);
+    // A zero (or absent) debounce means "fire synchronously", so only a strictly
+    // positive duration goes through `Atom.debounce`.
+    const positiveDebounce = (input) => input !== null && Duration.toMillis(Duration.fromInputUnsafe(input)) > 0
+        ? input
+        : null;
+    const validationDebounce = parsedMode.validation === "onChange" && !parsedMode.autoSubmit
+        ? positiveDebounce(parsedMode.debounce)
+        : null;
+    const autoSubmitDebounce = positiveDebounce(parsedMode.debounce);
+    const combinedSchema = FormBuilder.buildSchema(formBuilder);
+    const stateAtom = Atom.make(Option.none()).pipe(Atom.setIdleTTL(0));
+    const errorsAtom = Atom.make(new Map()).pipe(Atom.setIdleTTL(0));
+    const rootErrorAtom = Atom.readable((get) => {
+        const errors = get(errorsAtom);
+        const entry = errors.get("");
+        return entry ? Option.some(entry.message) : Option.none();
+    }).pipe(Atom.setIdleTTL(0));
+    const valuesAtom = Atom.readable((get) => Option.map(get(stateAtom), (state) => state.values)).pipe(Atom.setIdleTTL(0));
+    const dirtyFieldsAtom = Atom.readable((get) => Option.match(get(stateAtom), {
+        onNone: () => new Set(),
+        onSome: (state) => state.dirtyFields,
+    })).pipe(Atom.setIdleTTL(0));
+    const isDirtyAtom = Atom.readable((get) => Option.match(get(stateAtom), {
+        onNone: () => false,
+        onSome: (state) => state.dirtyFields.size > 0,
+    })).pipe(Atom.setIdleTTL(0));
+    const submitCountAtom = Atom.readable((get) => Option.match(get(stateAtom), {
+        onNone: () => 0,
+        onSome: (state) => state.submitCount,
+    })).pipe(Atom.setIdleTTL(0));
+    const validationCountAtom = Atom.readable((get) => Option.match(get(stateAtom), {
+        onNone: () => 0,
+        onSome: (state) => state.validationCount,
+    })).pipe(Atom.setIdleTTL(0));
+    const lastSubmittedValuesAtom = Atom.readable((get) => Option.flatMap(get(stateAtom), (state) => state.lastSubmittedValues)).pipe(Atom.setIdleTTL(0));
+    const changedSinceSubmitFieldsAtom = Atom.readable((get) => Option.match(get(stateAtom), {
+        onNone: () => new Set(),
+        onSome: (state) => Option.match(state.lastSubmittedValues, {
+            onNone: () => new Set(),
+            onSome: (lastSubmitted) => recalculateDirtySubtree(new Set(), lastSubmitted.encoded, state.values, ""),
+        }),
+    })).pipe(Atom.setIdleTTL(0));
+    const hasChangedSinceSubmitAtom = Atom.readable((get) => Option.match(get(stateAtom), {
+        onNone: () => false,
+        onSome: (state) => {
+            if (Option.isNone(state.lastSubmittedValues))
+                return false;
+            if (state.values === state.lastSubmittedValues.value.encoded)
+                return false;
+            return get(changedSinceSubmitFieldsAtom).size > 0;
+        },
+    })).pipe(Atom.setIdleTTL(0));
+    const fieldSchemasByKey = new Map();
+    for (const [key, def] of Object.entries(fields)) {
+        if (Field.isArrayFieldDef(def)) {
+            fieldSchemasByKey.set(key, Schema.Array(def.itemSchema));
+        }
+        else if (Field.isFieldDef(def)) {
+            fieldSchemasByKey.set(key, def.schema);
+        }
+    }
+    // `Atom.family` does not expose iteration, but `resetValidationAtoms` must visit
+    // every created entry. These maps record the latest key per path (paths are
+    // bounded by the form's field/array-item structure, so no GC concern) and double
+    // as the schema-identity record: `family(key)` with a recorded key returns the
+    // memoized entry, or harmlessly recreates a fresh one if it was collected.
+    const validationKeys = new Map();
+    const fieldAtomsKeys = new Map();
+    const validationAtomFamily = Atom.family(({ schema, }) => runtime
+        .fn()((value) => pipe(Schema.decodeUnknownEffect(schema)(value), Effect.asVoid))
+        .pipe(Atom.setIdleTTL(0)));
+    const getOrCreateValidationAtom = (fieldPath, schema) => {
+        const key = { path: fieldPath, schema };
+        validationKeys.set(fieldPath, key);
+        return validationAtomFamily(key);
+    };
+    const isDirtyAtomFamily = Atom.family((fieldPath) => Atom.readable((get) => isPathOrParentDirty(Option.match(get(stateAtom), {
+        onNone: () => new Set(),
+        onSome: (state) => state.dirtyFields,
+    }), fieldPath)).pipe(Atom.setIdleTTL(0)));
+    const fieldAtomsFamily = Atom.family(({ path: fieldPath, schema }) => {
+        const valueAtom = Atom.writable((get) => getNestedValue(getStateOrThrow(get(stateAtom), fieldPath).values, fieldPath), (ctx, value) => {
+            const currentState = getStateOrThrow(ctx.get(stateAtom), fieldPath);
+            ctx.set(stateAtom, Option.some(operations.setFieldValue(currentState, fieldPath, value)));
+        }).pipe(Atom.setIdleTTL(0));
+        const initialValueAtom = Atom.readable((get) => getNestedValue(getStateOrThrow(get(stateAtom), fieldPath).initialValues, fieldPath)).pipe(Atom.setIdleTTL(0));
+        const touchedAtom = Atom.writable((get) => (getNestedValue(getStateOrThrow(get(stateAtom), fieldPath).touched, fieldPath) ?? false), (ctx, value) => {
+            const currentState = getStateOrThrow(ctx.get(stateAtom), fieldPath);
+            ctx.set(stateAtom, Option.some({
+                ...currentState,
+                touched: setNestedValue(currentState.touched, fieldPath, value),
+            }));
+        }).pipe(Atom.setIdleTTL(0));
+        const errorAtom = Atom.readable((get) => {
+            const errors = get(errorsAtom);
+            const entry = errors.get(fieldPath);
+            return entry
+                ? Option.some(entry)
+                : Option.none();
+        }).pipe(Atom.setIdleTTL(0));
+        const isDirtyAtom = isDirtyAtomFamily(fieldPath);
+        const validationAtom = getOrCreateValidationAtom(fieldPath, schema);
+        const fieldValidationCountAtom = Atom.make(0).pipe(Atom.setIdleTTL(0));
+        const shouldValidateAtom = Atom.readable((get) => {
+            if (parsedMode.validation === "onChange")
+                return true;
+            if (parsedMode.validation === "onBlur")
+                return get(touchedAtom) || get(fieldValidationCountAtom) > 0;
+            return (get(submitCountAtom) > 0 ||
+                get(validationCountAtom) > 0 ||
+                get(fieldValidationCountAtom) > 0);
+        }).pipe(Atom.setIdleTTL(0));
+        const displayErrorAtom = Atom.readable((get) => {
+            const validationResult = get(validationAtom);
+            const storedError = get(errorAtom);
+            const isDirty = get(isDirtyAtom);
+            const isTouched = get(touchedAtom);
+            const submitCount = get(submitCountAtom);
+            const livePerFieldError = Option.flatMap(AsyncResult.error(validationResult), Validation.extractFirstError);
+            let validationError = Option.none();
+            if (Option.isSome(livePerFieldError)) {
+                validationError = livePerFieldError;
+            }
+            else if (Option.isSome(storedError)) {
+                const shouldHideStoredError = storedError.value.source === "field" &&
+                    (AsyncResult.isSuccess(validationResult) ||
+                        AsyncResult.isWaiting(validationResult));
+                if (!shouldHideStoredError) {
+                    validationError = Option.some(storedError.value.message);
+                }
+            }
+            const validationCount = get(validationCountAtom);
+            const fieldValidationCount = get(fieldValidationCountAtom);
+            const hasAttemptedValidation = submitCount > 0 || validationCount > 0 || fieldValidationCount > 0;
+            const shouldShowError = parsedMode.validation === "onChange"
+                ? isDirty || hasAttemptedValidation
+                : parsedMode.validation === "onBlur"
+                    ? isTouched || hasAttemptedValidation
+                    : hasAttemptedValidation;
+            return shouldShowError ? validationError : Option.none();
+        }).pipe(Atom.setIdleTTL(0));
+        // Every value change produces a fresh box, so `Atom.debounce` (which drops
+        // updates that are `Object.is`-equal to its current value) still emits when
+        // the value returns to what it was before the burst of changes.
+        const debouncedChangeAtom = validationDebounce === null
+            ? null
+            : Atom.debounce(Atom.readable((get) => ({ value: get(valueAtom) })).pipe(Atom.setIdleTTL(0)), validationDebounce);
+        const triggerValidationAtom = Atom.readable((get) => {
+            if (debouncedChangeAtom !== null) {
+                get.mount(debouncedChangeAtom);
+                get.subscribe(debouncedChangeAtom, (change) => {
+                    if (!get.once(shouldValidateAtom))
+                        return;
+                    get.set(validationAtom, change.value);
+                });
+            }
+            else {
+                let lastValue = get.once(valueAtom);
+                get.subscribe(valueAtom, (newValue) => {
+                    if (newValue === lastValue)
+                        return;
+                    lastValue = newValue;
+                    if (!get.once(shouldValidateAtom))
+                        return;
+                    get.set(validationAtom, newValue);
+                });
+            }
+            if (parsedMode.validation === "onBlur") {
+                get.subscribe(touchedAtom, (isTouched) => {
+                    if (isTouched) {
+                        const currentValue = get.once(valueAtom);
+                        get.set(validationAtom, currentValue);
+                    }
+                });
+            }
+        }).pipe(Atom.setIdleTTL(0));
+        return {
+            valueAtom,
+            initialValueAtom,
+            touchedAtom,
+            errorAtom,
+            isDirtyAtom,
+            validationAtom,
+            fieldValidationCountAtom,
+            displayErrorAtom,
+            shouldValidateAtom,
+            triggerValidationAtom,
+        };
+    });
+    const getOrCreateFieldAtoms = (fieldPath, schema) => {
+        const key = { path: fieldPath, schema };
+        fieldAtomsKeys.set(fieldPath, key);
+        return fieldAtomsFamily(key);
+    };
+    const resetValidationAtoms = (ctx) => {
+        for (const key of validationKeys.values()) {
+            ctx.set(validationAtomFamily(key), Atom.Reset);
+        }
+        for (const key of fieldAtomsKeys.values()) {
+            ctx.set(fieldAtomsFamily(key).fieldValidationCountAtom, 0);
+        }
+    };
+    const submitAtom = runtime
+        .fn()((args, get) => Effect.gen(function* () {
+        const state = get(stateAtom);
+        if (Option.isNone(state)) {
+            return yield* Effect.die(new Error("submit was called before the form was initialized — mount " +
+                "<form.Initialize defaultValues={...}> before submitting. " +
+                `See the "Basic Form Setup" section of the README.`));
+        }
+        const values = state.value.values;
+        get.set(errorsAtom, new Map());
+        const decoded = yield* pipe(Schema.decodeUnknownEffect(combinedSchema)(values, {
+            errors: "all",
+        }), Effect.tapError((parseError) => Effect.sync(() => {
+            const routedErrors = Validation.routeErrorsWithSource(parseError);
+            get.set(errorsAtom, routedErrors);
+            // Rebase onto the latest state so edits made during the in-flight
+            // async decode are preserved instead of clobbered by the snapshot.
+            const latest = get(stateAtom);
+            const base = Option.isSome(latest) ? latest.value : state.value;
+            get.set(stateAtom, Option.some(operations.createSubmitState(base)));
+        })));
+        // Rebase onto the latest state so a field edit made while the async
+        // decode was running is not silently reverted to the pre-submit snapshot.
+        const latestState = get(stateAtom);
+        const baseState = Option.isSome(latestState)
+            ? latestState.value
+            : state.value;
+        const submitState = operations.createSubmitState(baseState);
+        get.set(stateAtom, Option.some(submitState));
+        const result = config.onSubmit(args, {
+            decoded,
+            encoded: values,
+            get,
+        });
+        const output = Effect.isEffect(result)
+            ? yield* result
+            : result;
+        // Only record the values as "last submitted" once onSubmit has
+        // succeeded. A failed onSubmit must not be reported as a successful
+        // submit, otherwise revertToLastSubmit / hasChangedSinceSubmit would
+        // treat unsaved, failed values as persisted.
+        const afterSubmit = get(stateAtom);
+        if (Option.isSome(afterSubmit)) {
+            get.set(stateAtom, Option.some({
+                ...afterSubmit.value,
+                lastSubmittedValues: Option.some({ encoded: values, decoded }),
+            }));
+        }
+        return output;
+    }), config.reactivityKeys
+        ? { reactivityKeys: config.reactivityKeys }
+        : undefined)
+        .pipe(Atom.setIdleTTL(0));
+    const validateAtom = runtime
+        .fn()((_, get) => Effect.gen(function* () {
+        const state = get(stateAtom);
+        if (Option.isNone(state))
+            return;
+        const values = state.value.values;
+        get.set(errorsAtom, new Map());
+        yield* pipe(Schema.decodeUnknownEffect(combinedSchema)(values, {
+            errors: "all",
+        }), Effect.catchTag("SchemaError", (parseError) => Effect.sync(() => {
+            const routedErrors = Validation.routeErrorsWithSource(parseError);
+            get.set(errorsAtom, routedErrors);
+        })));
+        const currentState = get(stateAtom);
+        if (Option.isSome(currentState)) {
+            get.set(stateAtom, Option.some({
+                ...currentState.value,
+                validationCount: currentState.value.validationCount + 1,
+            }));
+        }
+    }))
+        .pipe(Atom.setIdleTTL(0));
+    const fieldRefs = Object.fromEntries(Object.keys(fields).map((key) => [key, FormBuilder.makeFieldRef(key)]));
+    const operations = {
+        createInitialState: (defaultValues) => ({
+            values: defaultValues,
+            initialValues: defaultValues,
+            lastSubmittedValues: Option.none(),
+            touched: Field.createTouchedRecord(fields, false),
+            submitCount: 0,
+            validationCount: 0,
+            dirtyFields: new Set(),
+        }),
+        createResetState: (state) => ({
+            values: state.initialValues,
+            initialValues: state.initialValues,
+            lastSubmittedValues: Option.none(),
+            touched: Field.createTouchedRecord(fields, false),
+            submitCount: 0,
+            validationCount: 0,
+            dirtyFields: new Set(),
+        }),
+        createSubmitState: (state) => ({
+            ...state,
+            touched: Field.createTouchedRecord(fields, true),
+            submitCount: state.submitCount + 1,
+        }),
+        setFieldValue: (state, fieldPath, value) => {
+            const newValues = setNestedValue(state.values, fieldPath, value);
+            const newDirtyFields = recalculateDirtySubtree(state.dirtyFields, state.initialValues, newValues, fieldPath);
+            return {
+                ...state,
+                values: newValues,
+                dirtyFields: newDirtyFields,
+            };
+        },
+        setFormValues: (state, values) => {
+            const newDirtyFields = recalculateDirtySubtree(state.dirtyFields, state.initialValues, values, "");
+            return {
+                ...state,
+                values,
+                dirtyFields: newDirtyFields,
+            };
+        },
+        setFieldTouched: (state, fieldPath, touched) => ({
+            ...state,
+            touched: setNestedValue(state.touched, fieldPath, touched),
+        }),
+        appendArrayItem: (state, arrayPath, itemSchema, value) => {
+            const newItem = value ?? Field.getDefaultFromSchema(itemSchema);
+            const currentItems = (getNestedValue(state.values, arrayPath) ??
+                []);
+            const newItems = [...currentItems, newItem];
+            return {
+                ...state,
+                values: setNestedValue(state.values, arrayPath, newItems),
+                dirtyFields: recalculateDirtyFieldsForArray(state.dirtyFields, state.initialValues, arrayPath, newItems),
+            };
+        },
+        removeArrayItem: (state, arrayPath, index) => {
+            const currentItems = (getNestedValue(state.values, arrayPath) ??
+                []);
+            const newItems = currentItems.filter((_, i) => i !== index);
+            return {
+                ...state,
+                values: setNestedValue(state.values, arrayPath, newItems),
+                dirtyFields: recalculateDirtyFieldsForArray(state.dirtyFields, state.initialValues, arrayPath, newItems),
+            };
+        },
+        swapArrayItems: (state, arrayPath, indexA, indexB) => {
+            const currentItems = (getNestedValue(state.values, arrayPath) ??
+                []);
+            if (indexA < 0 ||
+                indexA >= currentItems.length ||
+                indexB < 0 ||
+                indexB >= currentItems.length ||
+                indexA === indexB) {
+                return state;
+            }
+            const newItems = [...currentItems];
+            const temp = newItems[indexA];
+            newItems[indexA] = newItems[indexB];
+            newItems[indexB] = temp;
+            return {
+                ...state,
+                values: setNestedValue(state.values, arrayPath, newItems),
+                dirtyFields: recalculateDirtyFieldsForArray(state.dirtyFields, state.initialValues, arrayPath, newItems),
+            };
+        },
+        moveArrayItem: (state, arrayPath, fromIndex, toIndex) => {
+            const currentItems = (getNestedValue(state.values, arrayPath) ??
+                []);
+            if (fromIndex < 0 ||
+                fromIndex >= currentItems.length ||
+                toIndex < 0 ||
+                toIndex > currentItems.length ||
+                fromIndex === toIndex) {
+                return state;
+            }
+            const newItems = [...currentItems];
+            const [item] = newItems.splice(fromIndex, 1);
+            newItems.splice(toIndex, 0, item);
+            return {
+                ...state,
+                values: setNestedValue(state.values, arrayPath, newItems),
+                dirtyFields: recalculateDirtyFieldsForArray(state.dirtyFields, state.initialValues, arrayPath, newItems),
+            };
+        },
+        revertToLastSubmit: (state) => {
+            if (Option.isNone(state.lastSubmittedValues)) {
+                return state;
+            }
+            const lastEncoded = state.lastSubmittedValues.value.encoded;
+            if (state.values === lastEncoded) {
+                return state;
+            }
+            const newDirtyFields = recalculateDirtySubtree(state.dirtyFields, state.initialValues, lastEncoded, "");
+            return {
+                ...state,
+                values: lastEncoded,
+                dirtyFields: newDirtyFields,
+            };
+        },
+    };
+    const resetAtom = Atom.fnSync()((_, get) => {
+        const state = get(stateAtom);
+        if (Option.isNone(state))
+            return;
+        get.set(stateAtom, Option.some(operations.createResetState(state.value)));
+        get.set(errorsAtom, new Map());
+        resetValidationAtoms(get);
+        get.set(submitAtom, Atom.Reset);
+        get.set(validateAtom, Atom.Reset);
+    }, { initialValue: undefined }).pipe(Atom.setIdleTTL(0));
+    const revertToLastSubmitAtom = Atom.fnSync()((_, get) => {
+        const state = get(stateAtom);
+        if (Option.isNone(state))
+            return;
+        get.set(stateAtom, Option.some(operations.revertToLastSubmit(state.value)));
+        get.set(errorsAtom, new Map());
+    }, { initialValue: undefined }).pipe(Atom.setIdleTTL(0));
+    const setValuesAtom = Atom.writable((get) => pipe(get(stateAtom), Option.map((s) => s.values), Option.getOrElse(() => undefined)), (ctx, values) => {
+        const state = ctx.get(stateAtom);
+        if (Option.isNone(state))
+            return;
+        ctx.set(stateAtom, Option.some(operations.setFormValues(state.value, values)));
+        ctx.set(errorsAtom, new Map());
+    }).pipe(Atom.setIdleTTL(0));
+    const setValueFamily = Atom.family((fieldKey) => Atom.fnSync()((update, get) => {
+        const state = get(stateAtom);
+        if (Option.isNone(state))
+            return;
+        const currentValue = getNestedValue(state.value.values, fieldKey);
+        const newValue = typeof update === "function" ? update(currentValue) : update;
+        get.set(stateAtom, Option.some(operations.setFieldValue(state.value, fieldKey, newValue)));
+        // Don't clear errors - display logic handles showing/hiding based on source + validation state
+    }, { initialValue: undefined }).pipe(Atom.setIdleTTL(0)));
+    const publicFieldAtomsFamily = Atom.family((fieldKey) => {
+        const schema = fieldSchemasByKey.get(fieldKey);
+        if (!schema)
+            throw new Error(`No schema found for field "${fieldKey}"`);
+        const internal = getOrCreateFieldAtoms(fieldKey, schema);
+        const value = Atom.readable((get) => Option.map(get(stateAtom), (state) => getNestedValue(state.values, fieldKey))).pipe(Atom.setIdleTTL(0));
+        const error = Atom.readable((get) => Option.match(get(stateAtom), {
+            onNone: () => Option.none(),
+            onSome: () => get(internal.displayErrorAtom),
+        })).pipe(Atom.setIdleTTL(0));
+        const isDirty = isDirtyAtomFamily(fieldKey);
+        const isTouched = Atom.readable((get) => Option.match(get(stateAtom), {
+            onNone: () => false,
+            onSome: (state) => (getNestedValue(state.touched, fieldKey) ?? false),
+        })).pipe(Atom.setIdleTTL(0));
+        const isValidating = Atom.readable((get) => AsyncResult.isWaiting(get(internal.validationAtom))).pipe(Atom.setIdleTTL(0));
+        const setValueAtom = setValueFamily(fieldKey);
+        const setTouchedAtom = Atom.fnSync()((touched, get) => {
+            const state = get(stateAtom);
+            if (Option.isNone(state))
+                return;
+            get.set(stateAtom, Option.some(operations.setFieldTouched(state.value, fieldKey, touched)));
+        }, { initialValue: undefined }).pipe(Atom.setIdleTTL(0));
+        const validateFieldAtom = Atom.fnSync()((_, get) => {
+            const value = get(internal.valueAtom);
+            get.set(internal.validationAtom, value);
+            get.set(internal.fieldValidationCountAtom, get(internal.fieldValidationCountAtom) + 1);
+        }, { initialValue: undefined }).pipe(Atom.setIdleTTL(0));
+        return {
+            value,
+            error,
+            isDirty,
+            isTouched,
+            isValidating,
+            setValue: setValueAtom,
+            setTouched: setTouchedAtom,
+            validate: validateFieldAtom,
+        };
+    });
+    const getFieldAtoms = (field) => publicFieldAtomsFamily(field.key);
+    const mountAtom = Atom.readable((get) => {
+        get(stateAtom);
+        get(errorsAtom);
+        get(submitAtom);
+    }).pipe(Atom.setIdleTTL(0));
+    const keepAliveActiveAtom = Atom.make(false).pipe(Atom.setIdleTTL(0));
+    const autoSubmitAtom = parsedMode.autoSubmit && parsedMode.validation === "onChange"
+        ? (() => {
+            // Submit requests are funneled through a monotonically increasing counter
+            // so `Atom.debounce` can own the timer lifecycle: every bump restarts the
+            // trailing debounce window, and the subscriber below fires once it lands.
+            const submitRequestAtom = Atom.make(0).pipe(Atom.setIdleTTL(0));
+            const debouncedSubmitRequestAtom = autoSubmitDebounce === null
+                ? null
+                : Atom.debounce(submitRequestAtom, autoSubmitDebounce);
+            return Atom.readable((get) => {
+                const initialState = get.once(stateAtom);
+                let lastValues = Option.isSome(initialState)
+                    ? initialState.value.values
+                    : null;
+                let pendingChanges = false;
+                let wasSubmitting = false;
+                const triggerSubmit = () => {
+                    if (AsyncResult.isWaiting(get.once(submitAtom))) {
+                        pendingChanges = true;
+                        return;
+                    }
+                    get.set(submitAtom, undefined);
+                };
+                let requestSubmit;
+                if (debouncedSubmitRequestAtom === null) {
+                    requestSubmit = triggerSubmit;
+                }
+                else {
+                    get.mount(debouncedSubmitRequestAtom);
+                    get.subscribe(debouncedSubmitRequestAtom, () => {
+                        triggerSubmit();
+                    });
+                    requestSubmit = () => {
+                        get.set(submitRequestAtom, get.once(submitRequestAtom) + 1);
+                    };
+                }
+                get.subscribe(stateAtom, () => {
+                    const state = get.once(stateAtom);
+                    if (Option.isNone(state))
+                        return;
+                    const currentValues = state.value.values;
+                    if (currentValues === lastValues)
+                        return;
+                    lastValues = currentValues;
+                    const submitResult = get.once(submitAtom);
+                    if (AsyncResult.isWaiting(submitResult)) {
+                        pendingChanges = true;
+                    }
+                    else {
+                        requestSubmit();
+                    }
+                });
+                get.subscribe(submitAtom, () => {
+                    const result = get.once(submitAtom);
+                    const isSubmitting = AsyncResult.isWaiting(result);
+                    const justFinished = wasSubmitting && !isSubmitting;
+                    // Update wasSubmitting BEFORE triggering a follow-up submit. requestSubmit
+                    // (no debounce) synchronously re-enters this subscription with the new
+                    // waiting=true state; if we assigned wasSubmitting afterwards we'd clobber
+                    // that re-entrant true with the stale false, losing the next change.
+                    wasSubmitting = isSubmitting;
+                    if (justFinished && pendingChanges) {
+                        pendingChanges = false;
+                        requestSubmit();
+                    }
+                });
+            }).pipe(Atom.setIdleTTL(0));
+        })()
+        : Atom.readable(() => { }).pipe(Atom.setIdleTTL(0));
+    const onBlurSubmitAtom = parsedMode.autoSubmit && parsedMode.validation === "onBlur"
+        ? Atom.fnSync()((_, get) => {
+            if (AsyncResult.isWaiting(get(submitAtom)))
+                return;
+            const stateOption = get(stateAtom);
+            if (Option.isNone(stateOption))
+                return;
+            const { lastSubmittedValues, values } = stateOption.value;
+            if (Option.isSome(lastSubmittedValues) &&
+                values === lastSubmittedValues.value.encoded)
+                return;
+            get.set(submitAtom, undefined);
+        }, { initialValue: undefined }).pipe(Atom.setIdleTTL(0))
+        : Atom.fnSync()((_) => { }, {
+            initialValue: undefined,
+        }).pipe(Atom.setIdleTTL(0));
+    return {
+        stateAtom,
+        errorsAtom,
+        rootErrorAtom,
+        valuesAtom,
+        dirtyFieldsAtom,
+        isDirtyAtom,
+        submitCountAtom,
+        validationCountAtom,
+        lastSubmittedValuesAtom,
+        changedSinceSubmitFieldsAtom,
+        hasChangedSinceSubmitAtom,
+        submitAtom,
+        validateAtom,
+        combinedSchema,
+        fieldRefs,
+        getOrCreateValidationAtom,
+        getOrCreateFieldAtoms,
+        resetValidationAtoms,
+        operations,
+        resetAtom,
+        revertToLastSubmitAtom,
+        setValuesAtom,
+        getFieldAtoms,
+        autoSubmitAtom,
+        onBlurSubmitAtom,
+        mountAtom,
+        keepAliveActiveAtom,
+    };
+};
+//# sourceMappingURL=FormAtoms.js.map