@lucas-barake/effect-form 0.4.0 → 0.6.0

package/src/FormAtoms.ts

@@ -1,13 +1,4 @@
-/**
- * Atom infrastructure for form state management.
- *
- * This module provides the core atom infrastructure that framework adapters
- * (React, Vue, Svelte, Solid) can use to build reactive form components.
- *
- * @since 1.0.0
- */
 import * as Atom from "@effect-atom/atom/Atom"
-import type * as Registry from "@effect-atom/atom/Registry"
 import * as Effect from "effect/Effect"
 import { pipe } from "effect/Function"
 import * as Option from "effect/Option"
@@ -16,8 +7,9 @@ import * as Schema from "effect/Schema"
 import * as Field from "./Field.js"
 import * as FormBuilder from "./FormBuilder.js"
 import { recalculateDirtyFieldsForArray, recalculateDirtySubtree } from "./internal/dirty.js"
-import { getNestedValue, setNestedValue } from "./internal/path.js"
+import { getNestedValue, isPathUnderRoot, setNestedValue } from "./internal/path.js"
 import { createWeakRegistry, type WeakRegistry } from "./internal/weak-registry.js"
+import * as Validation from "./Validation.js"
 
 /**
  * Atoms for a single field.
@@ -38,9 +30,10 @@ export interface FieldAtoms {
  * @since 1.0.0
  * @category Models
  */
-export interface FormAtomsConfig<TFields extends Field.FieldsRecord, R> {
+export interface FormAtomsConfig<TFields extends Field.FieldsRecord, R, A, E> {
   readonly runtime: Atom.AtomRuntime<R, any>
   readonly formBuilder: FormBuilder.FormBuilder<TFields, R>
+  readonly onSubmit: (decoded: Field.DecodedFromFields<TFields>, get: Atom.FnContext) => A | Effect.Effect<A, E, R>
 }
 
 /**
@@ -63,7 +56,7 @@ export type FieldRefs<TFields extends Field.FieldsRecord> = {
  * @since 1.0.0
  * @category Models
  */
-export interface FormAtoms<TFields extends Field.FieldsRecord, R> {
+export interface FormAtoms<TFields extends Field.FieldsRecord, R, A = void, E = never> {
   readonly stateAtom: Atom.Writable<
     Option.Option<FormBuilder.FormState<TFields>>,
     Option.Option<FormBuilder.FormState<TFields>>
@@ -72,15 +65,11 @@ export interface FormAtoms<TFields extends Field.FieldsRecord, R> {
   readonly dirtyFieldsAtom: Atom.Atom<ReadonlySet<string>>
   readonly isDirtyAtom: Atom.Atom<boolean>
   readonly submitCountAtom: Atom.Atom<number>
-  readonly lastSubmittedValuesAtom: Atom.Atom<Option.Option<Field.EncodedFromFields<TFields>>>
+  readonly lastSubmittedValuesAtom: Atom.Atom<Option.Option<FormBuilder.SubmittedValues<TFields>>>
   readonly changedSinceSubmitFieldsAtom: Atom.Atom<ReadonlySet<string>>
   readonly hasChangedSinceSubmitAtom: Atom.Atom<boolean>
-  readonly onSubmitAtom: Atom.Writable<
-    Atom.AtomResultFn<Field.DecodedFromFields<TFields>, unknown, unknown> | null,
-    Atom.AtomResultFn<Field.DecodedFromFields<TFields>, unknown, unknown> | null
-  >
 
-  readonly decodeAndSubmit: Atom.AtomResultFn<Field.EncodedFromFields<TFields>, unknown, unknown>
+  readonly submitAtom: Atom.AtomResultFn<void, A, E | ParseResult.ParseError>
 
   readonly combinedSchema: Schema.Schema<Field.DecodedFromFields<TFields>, Field.EncodedFromFields<TFields>, R>
 
@@ -96,9 +85,14 @@ export interface FormAtoms<TFields extends Field.FieldsRecord, R> {
 
   readonly getOrCreateFieldAtoms: (fieldPath: string) => FieldAtoms
 
-  readonly resetValidationAtoms: (registry: Registry.Registry) => void
+  readonly resetValidationAtoms: (ctx: { set: <R, W>(atom: Atom.Writable<R, W>, value: W) => void }) => void
 
   readonly operations: FormOperations<TFields>
+
+  readonly resetAtom: Atom.Writable<void, void>
+  readonly revertToLastSubmitAtom: Atom.Writable<void, void>
+  readonly setValuesAtom: Atom.Writable<void, Field.EncodedFromFields<TFields>>
+  readonly setValue: <S>(field: FormBuilder.FieldRef<S>) => Atom.Writable<void, S | ((prev: S) => S)>
 }
 
 /**
@@ -191,9 +185,9 @@ export interface FormOperations<TFields extends Field.FieldsRecord> {
  * @since 1.0.0
  * @category Constructors
  */
-export const make = <TFields extends Field.FieldsRecord, R>(
-  config: FormAtomsConfig<TFields, R>,
-): FormAtoms<TFields, R> => {
+export const make = <TFields extends Field.FieldsRecord, R, A, E>(
+  config: FormAtomsConfig<TFields, R, A, E>,
+): FormAtoms<TFields, R, A, E> => {
   const { formBuilder, runtime } = config
   const { fields } = formBuilder
 
@@ -222,21 +216,17 @@ export const make = <TFields extends Field.FieldsRecord, R>(
     const state = Option.getOrThrow(get(stateAtom))
     return Option.match(state.lastSubmittedValues, {
       onNone: () => new Set<string>(),
-      onSome: (lastSubmitted) => recalculateDirtySubtree(new Set(), lastSubmitted, state.values, ""),
+      onSome: (lastSubmitted) => recalculateDirtySubtree(new Set(), lastSubmitted.encoded, state.values, ""),
     })
   }).pipe(Atom.setIdleTTL(0))
 
   const hasChangedSinceSubmitAtom = Atom.readable((get) => {
     const state = Option.getOrThrow(get(stateAtom))
     if (Option.isNone(state.lastSubmittedValues)) return false
-    if (state.values === state.lastSubmittedValues.value) return false
+    if (state.values === state.lastSubmittedValues.value.encoded) return false
     return get(changedSinceSubmitFieldsAtom).size > 0
   }).pipe(Atom.setIdleTTL(0))
 
-  const onSubmitAtom = Atom.make<Atom.AtomResultFn<Field.DecodedFromFields<TFields>, unknown, unknown> | null>(
-    null,
-  ).pipe(Atom.setIdleTTL(0))
-
   const validationAtomsRegistry = createWeakRegistry<Atom.AtomResultFn<unknown, void, ParseResult.ParseError>>()
   const fieldAtomsRegistry = createWeakRegistry<FieldAtoms>()
 
@@ -266,20 +256,7 @@ export const make = <TFields extends Field.FieldsRecord, R>(
       (get) => getNestedValue(Option.getOrThrow(get(stateAtom)).values, fieldPath),
       (ctx, value) => {
         const currentState = Option.getOrThrow(ctx.get(stateAtom))
-        const newValues = setNestedValue(currentState.values, fieldPath, value)
-        ctx.set(
-          stateAtom,
-          Option.some({
-            ...currentState,
-            values: newValues,
-            dirtyFields: recalculateDirtySubtree(
-              currentState.dirtyFields,
-              currentState.initialValues,
-              newValues,
-              fieldPath,
-            ),
-          }),
-        )
+        ctx.set(stateAtom, Option.some(operations.setFieldValue(currentState, fieldPath, value)))
       },
     ).pipe(Atom.setIdleTTL(0))
 
@@ -312,26 +289,49 @@ export const make = <TFields extends Field.FieldsRecord, R>(
     return atoms
   }
 
-  const resetValidationAtoms = (registry: Registry.Registry) => {
+  const resetValidationAtoms = (ctx: { set: <R, W>(atom: Atom.Writable<R, W>, value: W) => void }) => {
     for (const validationAtom of validationAtomsRegistry.values()) {
-      registry.set(validationAtom, Atom.Reset)
+      ctx.set(validationAtom, Atom.Reset)
     }
     validationAtomsRegistry.clear()
     fieldAtomsRegistry.clear()
   }
 
-  const decodeAndSubmit = runtime.fn<Field.EncodedFromFields<TFields>>()((values, get) =>
+  const submitAtom = runtime.fn<void>()((_void, get) =>
     Effect.gen(function*() {
-      const decoded = yield* Schema.decodeUnknown(combinedSchema)(values) as Effect.Effect<
-        Field.DecodedFromFields<TFields>,
-        ParseResult.ParseError,
-        R
-      >
-      const onSubmit = get(onSubmitAtom)!
-      get.set(onSubmit, decoded)
-      return yield* get.result(onSubmit, { suspendOnWaiting: true })
+      const state = get(stateAtom)
+      if (Option.isNone(state)) return yield* Effect.die("Form not initialized")
+      const values = state.value.values
+      get.set(crossFieldErrorsAtom, new Map())
+      const decoded = yield* pipe(
+        Schema.decodeUnknown(combinedSchema)(values) as Effect.Effect<
+          Field.DecodedFromFields<TFields>,
+          ParseResult.ParseError,
+          R
+        >,
+        Effect.tapError((parseError) =>
+          Effect.sync(() => {
+            const routedErrors = Validation.routeErrors(parseError)
+            get.set(crossFieldErrorsAtom, routedErrors)
+            get.set(stateAtom, Option.some(operations.createSubmitState(state.value)))
+          })
+        ),
+      )
+      const submitState = operations.createSubmitState(state.value)
+      get.set(
+        stateAtom,
+        Option.some({
+          ...submitState,
+          lastSubmittedValues: Option.some({ encoded: values, decoded }),
+        }),
+      )
+      const result = config.onSubmit(decoded, get)
+      if (Effect.isEffect(result)) {
+        return yield* (result as Effect.Effect<A, E, R>)
+      }
+      return result as A
     })
-  ).pipe(Atom.setIdleTTL(0)) as Atom.AtomResultFn<Field.EncodedFromFields<TFields>, unknown, unknown>
+  ).pipe(Atom.setIdleTTL(0)) as Atom.AtomResultFn<void, A, E | ParseResult.ParseError>
 
   const fieldRefs = Object.fromEntries(
     Object.keys(fields).map((key) => [key, FormBuilder.makeFieldRef(key)]),
@@ -358,7 +358,6 @@ export const make = <TFields extends Field.FieldsRecord, R>(
 
     createSubmitState: (state) => ({
       ...state,
-      lastSubmittedValues: Option.some(state.values),
       touched: Field.createTouchedRecord(fields, true) as { readonly [K in keyof TFields]: boolean },
       submitCount: state.submitCount + 1,
     }),
@@ -462,25 +461,82 @@ export const make = <TFields extends Field.FieldsRecord, R>(
         return state
       }
 
-      if (state.values === state.lastSubmittedValues.value) {
+      const lastEncoded = state.lastSubmittedValues.value.encoded
+      if (state.values === lastEncoded) {
         return state
       }
 
       const newDirtyFields = recalculateDirtySubtree(
         state.dirtyFields,
         state.initialValues,
-        state.lastSubmittedValues.value,
+        lastEncoded,
         "",
       )
 
       return {
         ...state,
-        values: state.lastSubmittedValues.value,
+        values: lastEncoded,
         dirtyFields: newDirtyFields,
       }
     },
   }
 
+  const resetAtom = Atom.fnSync<void>()((_: void, get) => {
+    const state = get(stateAtom)
+    if (Option.isNone(state)) return
+    get.set(stateAtom, Option.some(operations.createResetState(state.value)))
+    get.set(crossFieldErrorsAtom, new Map())
+    resetValidationAtoms(get)
+    get.set(submitAtom, Atom.Reset)
+  }, { initialValue: undefined as void }).pipe(Atom.setIdleTTL(0))
+
+  const revertToLastSubmitAtom = Atom.fnSync<void>()((_: void, get) => {
+    const state = get(stateAtom)
+    if (Option.isNone(state)) return
+    get.set(stateAtom, Option.some(operations.revertToLastSubmit(state.value)))
+    get.set(crossFieldErrorsAtom, new Map())
+  }, { initialValue: undefined as void }).pipe(Atom.setIdleTTL(0))
+
+  const setValuesAtom = Atom.fnSync<Field.EncodedFromFields<TFields>>()((_values, get) => {
+    const state = get(stateAtom)
+    if (Option.isNone(state)) return
+    get.set(stateAtom, Option.some(operations.setFormValues(state.value, _values)))
+    get.set(crossFieldErrorsAtom, new Map())
+  }, { initialValue: undefined as void }).pipe(Atom.setIdleTTL(0))
+
+  const setValueAtomsRegistry = createWeakRegistry<Atom.Writable<void, any>>()
+
+  const setValue = <S>(field: FormBuilder.FieldRef<S>): Atom.Writable<void, S | ((prev: S) => S)> => {
+    const cached = setValueAtomsRegistry.get(field.key)
+    if (cached) return cached
+
+    const atom = Atom.fnSync<S | ((prev: S) => S)>()((update, get) => {
+      const state = get(stateAtom)
+      if (Option.isNone(state)) return
+
+      const currentValue = getNestedValue(state.value.values, field.key) as S
+      const newValue = typeof update === "function"
+        ? (update as (prev: S) => S)(currentValue)
+        : update
+
+      get.set(stateAtom, Option.some(operations.setFieldValue(state.value, field.key, newValue)))
+
+      const currentErrors = get(crossFieldErrorsAtom)
+      const nextErrors = new Map<string, string>()
+      for (const [errorPath, message] of currentErrors) {
+        if (!isPathUnderRoot(errorPath, field.key)) {
+          nextErrors.set(errorPath, message)
+        }
+      }
+      if (nextErrors.size !== currentErrors.size) {
+        get.set(crossFieldErrorsAtom, nextErrors)
+      }
+    }, { initialValue: undefined as void }).pipe(Atom.setIdleTTL(0))
+
+    setValueAtomsRegistry.set(field.key, atom)
+    return atom
+  }
+
   return {
     stateAtom,
     crossFieldErrorsAtom,
@@ -490,8 +546,7 @@ export const make = <TFields extends Field.FieldsRecord, R>(
     lastSubmittedValuesAtom,
     changedSinceSubmitFieldsAtom,
     hasChangedSinceSubmitAtom,
-    onSubmitAtom,
-    decodeAndSubmit,
+    submitAtom,
     combinedSchema,
     fieldRefs,
     validationAtomsRegistry,
@@ -500,5 +555,9 @@ export const make = <TFields extends Field.FieldsRecord, R>(
     getOrCreateFieldAtoms,
     resetValidationAtoms,
     operations,
-  } as FormAtoms<TFields, R>
+    resetAtom,
+    revertToLastSubmitAtom,
+    setValuesAtom,
+    setValue,
+  } as FormAtoms<TFields, R, A, E>
 }

package/src/FormBuilder.ts

@@ -16,6 +16,15 @@ import type {
 } from "./Field.js"
 import { isArrayFieldDef, isFieldDef } from "./Field.js"
 
+/**
+ * @since 1.0.0
+ * @category Models
+ */
+export interface SubmittedValues<TFields extends FieldsRecord> {
+  readonly encoded: EncodedFromFields<TFields>
+  readonly decoded: DecodedFromFields<TFields>
+}
+
 /**
  * Unique identifier for Field references.
  *
@@ -84,7 +93,7 @@ export type TypeId = typeof TypeId
 export interface FormState<TFields extends FieldsRecord> {
   readonly values: EncodedFromFields<TFields>
   readonly initialValues: EncodedFromFields<TFields>
-  readonly lastSubmittedValues: Option.Option<EncodedFromFields<TFields>>
+  readonly lastSubmittedValues: Option.Option<SubmittedValues<TFields>>
   readonly touched: { readonly [K in keyof TFields]: boolean }
   readonly submitCount: number
   readonly dirtyFields: ReadonlySet<string>

package/src/index.ts

@@ -6,12 +6,10 @@
 export * as Field from "./Field.js"
 
 /**
- * Atom infrastructure for form state management.
- *
- * This module provides the core atom infrastructure that framework adapters
- * (React, Vue, Svelte, Solid) can use to build reactive form components.
+ * Atoms for a single field.
  *
  * @since 1.0.0
+ * @category Models
  */
 export * as FormAtoms from "./FormAtoms.js"
 

package/src/internal/dirty.ts

@@ -5,7 +5,7 @@
  */
 import * as Equal from "effect/Equal"
 import * as Utils from "effect/Utils"
-import { getNestedValue } from "./path.js"
+import { getNestedValue, isPathUnderRoot } from "./path.js"
 
 /**
  * Recalculates dirty fields for an array after mutation.
@@ -17,20 +17,24 @@ export const recalculateDirtyFieldsForArray = (
   arrayPath: string,
   newItems: ReadonlyArray<unknown>,
 ): ReadonlySet<string> => {
+  const initialItems = (getNestedValue(initialValues, arrayPath) ?? []) as ReadonlyArray<unknown>
+
+  if (newItems === initialItems) {
+    return dirtyFields
+  }
+
   const nextDirty = new Set(
-    Array.from(dirtyFields).filter(
-      (path) => path !== arrayPath && !path.startsWith(arrayPath + ".") && !path.startsWith(arrayPath + "["),
-    ),
+    Array.from(dirtyFields).filter((path) => !isPathUnderRoot(path, arrayPath)),
   )
 
-  const initialItems = (getNestedValue(initialValues, arrayPath) ?? []) as ReadonlyArray<unknown>
-
   const loopLength = Math.max(newItems.length, initialItems.length)
   for (let i = 0; i < loopLength; i++) {
     const itemPath = `${arrayPath}[${i}]`
     const newItem = newItems[i]
     const initialItem = initialItems[i]
 
+    if (newItem === initialItem) continue
+
     const isEqual = Utils.structuralRegion(() => Equal.equals(newItem, initialItem))
     if (!isEqual) {
       nextDirty.add(itemPath)
@@ -58,22 +62,40 @@ export const recalculateDirtySubtree = (
   allValues: unknown,
   rootPath: string = "",
 ): ReadonlySet<string> => {
+  const targetValue = rootPath ? getNestedValue(allValues, rootPath) : allValues
+  const targetInitial = rootPath ? getNestedValue(allInitial, rootPath) : allInitial
+
+  if (targetValue === targetInitial) {
+    if (rootPath === "") {
+      return new Set()
+    }
+
+    let changed = false
+    const nextDirty = new Set(currentDirty)
+    for (const path of currentDirty) {
+      if (isPathUnderRoot(path, rootPath)) {
+        nextDirty.delete(path)
+        changed = true
+      }
+    }
+    return changed ? nextDirty : currentDirty
+  }
+
   const nextDirty = new Set(currentDirty)
 
   if (rootPath === "") {
     nextDirty.clear()
   } else {
     for (const path of nextDirty) {
-      if (path === rootPath || path.startsWith(rootPath + ".") || path.startsWith(rootPath + "[")) {
+      if (isPathUnderRoot(path, rootPath)) {
         nextDirty.delete(path)
       }
     }
   }
 
-  const targetValue = rootPath ? getNestedValue(allValues, rootPath) : allValues
-  const targetInitial = rootPath ? getNestedValue(allInitial, rootPath) : allInitial
-
   const recurse = (current: unknown, initial: unknown, path: string): void => {
+    if (current === initial) return
+
     if (Array.isArray(current)) {
       const initialArr = (initial ?? []) as ReadonlyArray<unknown>
       for (let i = 0; i < Math.max(current.length, initialArr.length); i++) {
@@ -81,10 +103,14 @@ export const recalculateDirtySubtree = (
       }
     } else if (current !== null && typeof current === "object") {
       const initialObj = (initial ?? {}) as Record<string, unknown>
-      const allKeys = new Set([...Object.keys(current as object), ...Object.keys(initialObj)])
-      for (const key of allKeys) {
+      for (const key in current as object) {
         recurse((current as Record<string, unknown>)[key], initialObj[key], path ? `${path}.${key}` : key)
       }
+      for (const key in initialObj) {
+        if (!(key in (current as object))) {
+          recurse(undefined, initialObj[key], path ? `${path}.${key}` : key)
+        }
+      }
     } else {
       const isEqual = Utils.structuralRegion(() => Equal.equals(current, initial))
       if (!isEqual && path) nextDirty.add(path)

package/src/internal/path.ts

@@ -27,6 +27,18 @@ export const schemaPathToFieldPath = (path: ReadonlyArray<PropertyKey>): string
   return result
 }
 
+/**
+ * Checks if a path matches a root path or is a descendant of it.
+ * Handles both dot notation (root.child) and bracket notation (root[0]).
+ *
+ * @example
+ * isPathUnderRoot("items[0].name", "items[0]") // true
+ * isPathUnderRoot("items[0].name", "items") // true
+ * isPathUnderRoot("other", "items") // false
+ */
+export const isPathUnderRoot = (path: string, rootPath: string): boolean =>
+  path === rootPath || path.startsWith(rootPath + ".") || path.startsWith(rootPath + "[")
+
 /**
  * Checks if a field path or any of its parent paths are in the dirty set.
  */