@svgrid/grid 2.6.16 → 2.6.17

package/src/createForm.svelte.ts

@@ -1,386 +1,386 @@
-/**
- * createForm - the HEADLESS core behind <SvForm>: values / errors / touched
- * state, required + rule + custom validation (validate-on-blur-then-live), and a
- * submit that validates every field first. No markup, no controls - you render
- * the fields however you like and read/write through the core.
- *
- * ```svelte
- * <script lang="ts">
- *   import { createForm } from '@svgrid/grid'
- *   const form = createForm({ fields: () => fields, onSubmit: (v) => save(v) })
- * </script>
- * <form onsubmit={(e) => { e.preventDefault(); form.submit() }}>
- *   {#each fields as f}
- *     <input value={form.value(f.name) ?? ''}
- *       oninput={(e) => form.setValue(f.name, e.currentTarget.value)}
- *       onblur={() => form.handleBlur(f.name)} />
- *     {#if form.error(f.name)}<span>{form.error(f.name)}</span>{/if}
- *   {/each}
- * </form>
- * ```
- */
-import { flattenFields, type FormField, type FormEntry } from './form-field'
-import { runRules } from './validators'
-
-/** Localizable strings the form generates itself (override via `messages`). */
-export type FormMessages = {
-  required: (label: string) => string
-  minItems: (label: string, n: number) => string
-  maxItems: (label: string, n: number) => string
-  /** Shown by SvForm while an async validator runs. */
-  checking: string
-}
-
-const DEFAULT_FORM_MESSAGES: FormMessages = {
-  required: (l) => `${l} is required`,
-  minItems: (_l, n) => `Add at least ${n} item(s)`,
-  maxItems: (_l, n) => `At most ${n} item(s)`,
-  checking: 'Checking…',
-}
-
-export type FormConfig = {
-  /** The schema - a mix of flat fields and titled sections. */
-  fields: () => ReadonlyArray<FormEntry>
-  /** Seed values on creation. */
-  initial?: Record<string, any>
-  /** Called with the (visible-field) values on a valid submit. May be async;
-   *  `submitting` stays true until the returned promise settles. */
-  onSubmit?: (values: Record<string, any>) => void | Promise<void>
-  onChange?: (values: Record<string, any>) => void
-  /** Override the built-in generated strings (required / min-max items / checking). */
-  messages?: Partial<FormMessages>
-}
-
-/** Deep-ish equality for dirty tracking: identity for primitives, structural
- *  (JSON) for arrays/objects. Good enough for form values. */
-function eq(a: unknown, b: unknown): boolean {
-  if (Object.is(a, b)) return true
-  if (a && b && typeof a === 'object' && typeof b === 'object') {
-    try { return JSON.stringify(a) === JSON.stringify(b) } catch { return false }
-  }
-  return false
-}
-
-/** Resolve a `boolean | (values) => boolean` field flag. */
-function resolveFlag(
-  flag: boolean | ((values: Record<string, any>) => boolean) | undefined,
-  dflt: boolean,
-  values: Record<string, any>,
-): boolean {
-  if (flag == null) return dflt
-  return typeof flag === 'function' ? !!flag(values) : !!flag
-}
-
-export function createForm(config: FormConfig) {
-  const M: FormMessages = { ...DEFAULT_FORM_MESSAGES, ...(config.messages ?? {}) }
-  let values = $state<Record<string, any>>({ ...(config.initial ?? {}) })
-  let errors = $state<Record<string, string>>({})
-  let touched = $state<Record<string, boolean>>({})
-  let submitting = $state(false)
-  let validating = $state<Record<string, boolean>>({})
-  // Baseline for dirty tracking + reset. Rebased when `reset(next)` is passed.
-  let baseline = { ...(config.initial ?? {}) }
-  // Async-validation bookkeeping: debounce timers + a per-field run sequence so
-  // only the latest response wins (stale responses are dropped).
-  const asyncTimers = new Map<string, ReturnType<typeof setTimeout>>()
-  const asyncSeq = new Map<string, number>()
-
-  // The flat field list (sections flattened) drives all values/validation.
-  const flat = () => flattenFields(config.fields())
-  const fieldOf = (name: string) => flat().find((f) => f.name === name)
-  const isVisible = (name: string) => resolveFlag(fieldOf(name)?.visible, true, values)
-  const isDisabled = (name: string) => resolveFlag(fieldOf(name)?.disabled, false, values)
-
-  function setError(name: string, err: string | null | undefined) {
-    const next = { ...errors }
-    if (err) next[name] = err
-    else delete next[name]
-    errors = next
-  }
-
-  /** The synchronous checks: required, then declarative rules, then a sync
-   *  `validate`. Returns the first error message, or null. `ctx` is the values
-   *  object rules/validate see - the form values, or a single item for array
-   *  rows (so within-row cross-field rules work). */
-  function syncError(field: FormField, v: any, ctx: Record<string, any> = values): string | null {
-    if (field.required && (v == null || v === '' || (Array.isArray(v) && !v.length)))
-      return M.required(field.label)
-    if (field.rules) { const e = runRules(v, field.rules, ctx); if (e) return e }
-    if (field.validate) { const e = field.validate(v, ctx); if (e) return e }
-    return null
-  }
-
-  function cancelAsync(name: string) {
-    const t = asyncTimers.get(name)
-    if (t) { clearTimeout(t); asyncTimers.delete(name) }
-    // Bump the sequence so any in-flight response is treated as stale.
-    asyncSeq.set(name, (asyncSeq.get(name) ?? 0) + 1)
-    if (validating[name]) validating = { ...validating, [name]: false }
-  }
-
-  /** Run a field's async validator now (guarded against stale responses). */
-  async function runAsync(name: string): Promise<boolean> {
-    const field = fieldOf(name)
-    if (!field?.asyncValidate || !isVisible(name)) return true
-    if (syncError(field, values[name])) return false // sync error already shown
-    const seq = (asyncSeq.get(name) ?? 0) + 1
-    asyncSeq.set(name, seq)
-    validating = { ...validating, [name]: true }
-    try {
-      const err = await field.asyncValidate(values[name], values)
-      if (asyncSeq.get(name) !== seq) return true // superseded - ignore
-      setError(name, err ?? null)
-      return !err
-    } finally {
-      if (asyncSeq.get(name) === seq) validating = { ...validating, [name]: false }
-    }
-  }
-
-  function scheduleAsync(name: string) {
-    const field = fieldOf(name)
-    if (!field?.asyncValidate) return
-    const prev = asyncTimers.get(name)
-    if (prev) clearTimeout(prev)
-    asyncTimers.set(name, setTimeout(() => { asyncTimers.delete(name); runAsync(name) }, field.asyncDebounce ?? 300))
-  }
-
-  function validateField(name: string): boolean {
-    const field = fieldOf(name)
-    if (!field) return true
-    // Computed fields are derived + read-only - never validated, never block submit.
-    if (field.computed) { setError(name, null); return true }
-    // Hidden fields never block submit; clear any stale error + pending check.
-    if (!isVisible(name)) { setError(name, null); cancelAsync(name); return true }
-    if (field.type === 'array') return validateArray(field)
-    const err = syncError(field, values[name])
-    setError(name, err)
-    if (err) { cancelAsync(name); return false }
-    // Sync passed - kick off the debounced async check if there is one.
-    if (field.asyncValidate) scheduleAsync(name)
-    return true
-  }
-
-  // --- Field arrays (repeatable groups) -----------------------------------
-  const arrayItems = (name: string): Record<string, any>[] =>
-    Array.isArray(values[name]) ? values[name] : []
-  const itemValue = (name: string, i: number, field: string) => arrayItems(name)[i]?.[field]
-  const itemError = (name: string, i: number, field: string) => errors[`${name}.${i}.${field}`]
-
-  function clearNamespacedErrors(name: string) {
-    const prefix = `${name}.`
-    const next = { ...errors }
-    let changed = false
-    for (const k of Object.keys(next)) if (k.startsWith(prefix)) { delete next[k]; changed = true }
-    if (changed) errors = next
-  }
-
-  function setItems(name: string, next: Record<string, any>[]) {
-    values = { ...values, [name]: next }
-    config.onChange?.(values)
-  }
-
-  function addItem(name: string, item?: Record<string, any>) {
-    const seed = item ?? Object.fromEntries((fieldOf(name)?.itemFields ?? []).map((f) => [f.name, undefined]))
-    setItems(name, [...arrayItems(name), seed])
-  }
-  function removeItem(name: string, i: number) {
-    const items = arrayItems(name).slice()
-    items.splice(i, 1)
-    clearNamespacedErrors(name) // item indices shift - drop stale keys
-    setItems(name, items)
-  }
-  function moveItem(name: string, from: number, to: number) {
-    const items = arrayItems(name).slice()
-    if (from < 0 || from >= items.length || to < 0 || to >= items.length) return
-    const [it] = items.splice(from, 1)
-    items.splice(to, 0, it as Record<string, any>)
-    clearNamespacedErrors(name)
-    setItems(name, items)
-  }
-  function setItemValue(name: string, i: number, field: string, v: any) {
-    setItems(name, arrayItems(name).map((it, ix) => (ix === i ? { ...it, [field]: v } : it)))
-    if (touched[`${name}.${i}.${field}`]) validateItemField(name, i, field)
-  }
-  function handleItemBlur(name: string, i: number, field: string) {
-    touched = { ...touched, [`${name}.${i}.${field}`]: true }
-    validateItemField(name, i, field)
-  }
-  function validateItemField(name: string, i: number, fieldName: string): boolean {
-    const itemField = fieldOf(name)?.itemFields?.find((f) => f.name === fieldName)
-    if (!itemField) return true
-    const item = arrayItems(name)[i] ?? {}
-    const err = syncError(itemField, item[fieldName], item)
-    setError(`${name}.${i}.${fieldName}`, err)
-    return !err
-  }
-  function validateArray(field: FormField): boolean {
-    const name = field.name
-    const items = arrayItems(name)
-    let arrErr: string | null = null
-    if (field.required && items.length === 0) arrErr = M.required(field.label)
-    else if (field.minItems != null && items.length < field.minItems) arrErr = M.minItems(field.label, field.minItems)
-    else if (field.maxItems != null && items.length > field.maxItems) arrErr = M.maxItems(field.label, field.maxItems)
-    setError(name, arrErr)
-    let ok = !arrErr
-    clearNamespacedErrors(name) // rebuild fresh per-item errors
-    for (let i = 0; i < items.length; i++)
-      for (const itf of field.itemFields ?? [])
-        if (!validateItemField(name, i, itf.name)) ok = false
-    return ok
-  }
-
-  /** True when `field` depends on `name` (cascading). */
-  function dependsOnName(field: FormField, name: string): boolean {
-    const dep = field.dependsOn
-    return dep == null ? false : Array.isArray(dep) ? dep.includes(name) : dep === name
-  }
-
-  function setValue(name: string, v: any) {
-    let next = { ...values, [name]: v }
-    // Cascading: clear any fields that depend on this one so a stale child
-    // selection (e.g. a city under the old country) does not linger.
-    for (const f of flat()) {
-      if (dependsOnName(f, name) && next[f.name] != null) {
-        next = { ...next, [f.name]: null }
-        setError(f.name, null)
-      }
-    }
-    values = next
-    config.onChange?.(values)
-    // Re-validate live once the field has been blurred at least once.
-    if (touched[name]) validateField(name)
-  }
-
-  function handleBlur(name: string) {
-    touched = { ...touched, [name]: true }
-    validateField(name)
-  }
-
-  async function submit(): Promise<boolean> {
-    let ok = true
-    const t: Record<string, boolean> = { ...touched }
-    for (const f of flat()) {
-      if (!isVisible(f.name)) continue
-      t[f.name] = true
-      if (!validateField(f.name)) ok = false
-    }
-    touched = t
-    if (!ok) return false
-    // Await async validators (run now, skipping their debounce). Any failure blocks.
-    const asyncFields = flat().filter((f) => f.asyncValidate && isVisible(f.name))
-    if (asyncFields.length) {
-      for (const f of asyncFields) { const timer = asyncTimers.get(f.name); if (timer) { clearTimeout(timer); asyncTimers.delete(f.name) } }
-      const results = await Promise.all(asyncFields.map((f) => runAsync(f.name)))
-      if (results.some((r) => !r)) return false
-    }
-    // Exclude hidden fields from the submitted payload; keep any non-field keys.
-    const payload = { ...values }
-    for (const f of flat()) if (!isVisible(f.name)) delete payload[f.name]
-    // Inject computed (derived) values so the payload carries them.
-    for (const f of flat()) if (f.computed && isVisible(f.name)) payload[f.name] = f.computed(values)
-    submitting = true
-    try {
-      await config.onSubmit?.(payload)
-    } finally {
-      submitting = false
-    }
-    return true
-  }
-
-  /** Validate a subset of fields by name (sync + their async validators). Used
-   *  to gate a wizard step before advancing. Returns true when all pass. */
-  async function validateFields(names: string[]): Promise<boolean> {
-    let ok = true
-    const t = { ...touched }
-    for (const name of names) {
-      if (!isVisible(name)) continue
-      t[name] = true
-      if (!validateField(name)) ok = false
-    }
-    touched = t
-    if (!ok) return false
-    const asyncNames = names.filter((n) => fieldOf(n)?.asyncValidate && isVisible(n))
-    if (asyncNames.length) {
-      for (const n of asyncNames) { const timer = asyncTimers.get(n); if (timer) { clearTimeout(timer); asyncTimers.delete(n) } }
-      const results = await Promise.all(asyncNames.map((n) => runAsync(n)))
-      if (results.some((r) => !r)) return false
-    }
-    return true
-  }
-
-  /** Restore values to the baseline (or a new one), clearing errors + touched. */
-  function reset(next?: Record<string, any>) {
-    if (next) baseline = { ...next }
-    values = { ...baseline }
-    errors = {}
-    touched = {}
-    config.onChange?.(values)
-  }
-
-  /** Inject errors (e.g. server-side validation after submit) and mark those
-   *  fields touched so the messages show. Empty message clears a field's error. */
-  function setErrors(map: Record<string, string>) {
-    const nextErr = { ...errors }
-    const nextTouched = { ...touched }
-    for (const [k, msg] of Object.entries(map)) {
-      if (msg) { nextErr[k] = msg; nextTouched[k] = true }
-      else delete nextErr[k]
-    }
-    errors = nextErr
-    touched = nextTouched
-  }
-
-  const isFieldDirty = (name: string) => !eq(values[name], baseline[name])
-
-  /** Top-level field errors (visible fields only), for a form-level summary. */
-  function errorList(): { name: string; label: string; message: string }[] {
-    const out: { name: string; label: string; message: string }[] = []
-    for (const f of flat()) {
-      const m = errors[f.name]
-      if (m && isVisible(f.name)) out.push({ name: f.name, label: f.label, message: m })
-    }
-    return out
-  }
-  const firstErrorField = (): string | undefined => errorList()[0]?.name
-
-  return {
-    get values() { return values },
-    get submitting() { return submitting },
-    get isDirty() {
-      const keys = new Set([...Object.keys(values), ...Object.keys(baseline)])
-      for (const k of keys) if (!eq(values[k], baseline[k])) return true
-      return false
-    },
-    value: (name: string) => { const f = fieldOf(name); return f?.computed ? f.computed(values) : values[name] },
-    error: (name: string): string | undefined => errors[name],
-    isTouched: (name: string) => !!touched[name],
-    hasError: (name: string) => !!errors[name],
-    isValidating: (name: string) => !!validating[name],
-    isFieldDirty,
-    isVisible,
-    isDisabled,
-    entries: () => config.fields(),
-    // Field arrays
-    arrayItems,
-    itemValue,
-    itemError,
-    addItem,
-    removeItem,
-    moveItem,
-    setItemValue,
-    handleItemBlur,
-    setValue,
-    handleBlur,
-    validateField,
-    validateFields,
-    submit,
-    reset,
-    setErrors,
-    errorList,
-    firstErrorField,
-    /** The resolved message strings (defaults merged with `config.messages`). */
-    messages: M,
-  }
-}
-
-export type Form = ReturnType<typeof createForm>
+/**
+ * createForm - the HEADLESS core behind <SvForm>: values / errors / touched
+ * state, required + rule + custom validation (validate-on-blur-then-live), and a
+ * submit that validates every field first. No markup, no controls - you render
+ * the fields however you like and read/write through the core.
+ *
+ * ```svelte
+ * <script lang="ts">
+ *   import { createForm } from '@svgrid/grid'
+ *   const form = createForm({ fields: () => fields, onSubmit: (v) => save(v) })
+ * </script>
+ * <form onsubmit={(e) => { e.preventDefault(); form.submit() }}>
+ *   {#each fields as f}
+ *     <input value={form.value(f.name) ?? ''}
+ *       oninput={(e) => form.setValue(f.name, e.currentTarget.value)}
+ *       onblur={() => form.handleBlur(f.name)} />
+ *     {#if form.error(f.name)}<span>{form.error(f.name)}</span>{/if}
+ *   {/each}
+ * </form>
+ * ```
+ */
+import { flattenFields, type FormField, type FormEntry } from './form-field'
+import { runRules } from './validators'
+
+/** Localizable strings the form generates itself (override via `messages`). */
+export type FormMessages = {
+  required: (label: string) => string
+  minItems: (label: string, n: number) => string
+  maxItems: (label: string, n: number) => string
+  /** Shown by SvForm while an async validator runs. */
+  checking: string
+}
+
+const DEFAULT_FORM_MESSAGES: FormMessages = {
+  required: (l) => `${l} is required`,
+  minItems: (_l, n) => `Add at least ${n} item(s)`,
+  maxItems: (_l, n) => `At most ${n} item(s)`,
+  checking: 'Checking…',
+}
+
+export type FormConfig = {
+  /** The schema - a mix of flat fields and titled sections. */
+  fields: () => ReadonlyArray<FormEntry>
+  /** Seed values on creation. */
+  initial?: Record<string, any>
+  /** Called with the (visible-field) values on a valid submit. May be async;
+   *  `submitting` stays true until the returned promise settles. */
+  onSubmit?: (values: Record<string, any>) => void | Promise<void>
+  onChange?: (values: Record<string, any>) => void
+  /** Override the built-in generated strings (required / min-max items / checking). */
+  messages?: Partial<FormMessages>
+}
+
+/** Deep-ish equality for dirty tracking: identity for primitives, structural
+ *  (JSON) for arrays/objects. Good enough for form values. */
+function eq(a: unknown, b: unknown): boolean {
+  if (Object.is(a, b)) return true
+  if (a && b && typeof a === 'object' && typeof b === 'object') {
+    try { return JSON.stringify(a) === JSON.stringify(b) } catch { return false }
+  }
+  return false
+}
+
+/** Resolve a `boolean | (values) => boolean` field flag. */
+function resolveFlag(
+  flag: boolean | ((values: Record<string, any>) => boolean) | undefined,
+  dflt: boolean,
+  values: Record<string, any>,
+): boolean {
+  if (flag == null) return dflt
+  return typeof flag === 'function' ? !!flag(values) : !!flag
+}
+
+export function createForm(config: FormConfig) {
+  const M: FormMessages = { ...DEFAULT_FORM_MESSAGES, ...(config.messages ?? {}) }
+  let values = $state<Record<string, any>>({ ...(config.initial ?? {}) })
+  let errors = $state<Record<string, string>>({})
+  let touched = $state<Record<string, boolean>>({})
+  let submitting = $state(false)
+  let validating = $state<Record<string, boolean>>({})
+  // Baseline for dirty tracking + reset. Rebased when `reset(next)` is passed.
+  let baseline = { ...(config.initial ?? {}) }
+  // Async-validation bookkeeping: debounce timers + a per-field run sequence so
+  // only the latest response wins (stale responses are dropped).
+  const asyncTimers = new Map<string, ReturnType<typeof setTimeout>>()
+  const asyncSeq = new Map<string, number>()
+
+  // The flat field list (sections flattened) drives all values/validation.
+  const flat = () => flattenFields(config.fields())
+  const fieldOf = (name: string) => flat().find((f) => f.name === name)
+  const isVisible = (name: string) => resolveFlag(fieldOf(name)?.visible, true, values)
+  const isDisabled = (name: string) => resolveFlag(fieldOf(name)?.disabled, false, values)
+
+  function setError(name: string, err: string | null | undefined) {
+    const next = { ...errors }
+    if (err) next[name] = err
+    else delete next[name]
+    errors = next
+  }
+
+  /** The synchronous checks: required, then declarative rules, then a sync
+   *  `validate`. Returns the first error message, or null. `ctx` is the values
+   *  object rules/validate see - the form values, or a single item for array
+   *  rows (so within-row cross-field rules work). */
+  function syncError(field: FormField, v: any, ctx: Record<string, any> = values): string | null {
+    if (field.required && (v == null || v === '' || (Array.isArray(v) && !v.length)))
+      return M.required(field.label)
+    if (field.rules) { const e = runRules(v, field.rules, ctx); if (e) return e }
+    if (field.validate) { const e = field.validate(v, ctx); if (e) return e }
+    return null
+  }
+
+  function cancelAsync(name: string) {
+    const t = asyncTimers.get(name)
+    if (t) { clearTimeout(t); asyncTimers.delete(name) }
+    // Bump the sequence so any in-flight response is treated as stale.
+    asyncSeq.set(name, (asyncSeq.get(name) ?? 0) + 1)
+    if (validating[name]) validating = { ...validating, [name]: false }
+  }
+
+  /** Run a field's async validator now (guarded against stale responses). */
+  async function runAsync(name: string): Promise<boolean> {
+    const field = fieldOf(name)
+    if (!field?.asyncValidate || !isVisible(name)) return true
+    if (syncError(field, values[name])) return false // sync error already shown
+    const seq = (asyncSeq.get(name) ?? 0) + 1
+    asyncSeq.set(name, seq)
+    validating = { ...validating, [name]: true }
+    try {
+      const err = await field.asyncValidate(values[name], values)
+      if (asyncSeq.get(name) !== seq) return true // superseded - ignore
+      setError(name, err ?? null)
+      return !err
+    } finally {
+      if (asyncSeq.get(name) === seq) validating = { ...validating, [name]: false }
+    }
+  }
+
+  function scheduleAsync(name: string) {
+    const field = fieldOf(name)
+    if (!field?.asyncValidate) return
+    const prev = asyncTimers.get(name)
+    if (prev) clearTimeout(prev)
+    asyncTimers.set(name, setTimeout(() => { asyncTimers.delete(name); runAsync(name) }, field.asyncDebounce ?? 300))
+  }
+
+  function validateField(name: string): boolean {
+    const field = fieldOf(name)
+    if (!field) return true
+    // Computed fields are derived + read-only - never validated, never block submit.
+    if (field.computed) { setError(name, null); return true }
+    // Hidden fields never block submit; clear any stale error + pending check.
+    if (!isVisible(name)) { setError(name, null); cancelAsync(name); return true }
+    if (field.type === 'array') return validateArray(field)
+    const err = syncError(field, values[name])
+    setError(name, err)
+    if (err) { cancelAsync(name); return false }
+    // Sync passed - kick off the debounced async check if there is one.
+    if (field.asyncValidate) scheduleAsync(name)
+    return true
+  }
+
+  // --- Field arrays (repeatable groups) -----------------------------------
+  const arrayItems = (name: string): Record<string, any>[] =>
+    Array.isArray(values[name]) ? values[name] : []
+  const itemValue = (name: string, i: number, field: string) => arrayItems(name)[i]?.[field]
+  const itemError = (name: string, i: number, field: string) => errors[`${name}.${i}.${field}`]
+
+  function clearNamespacedErrors(name: string) {
+    const prefix = `${name}.`
+    const next = { ...errors }
+    let changed = false
+    for (const k of Object.keys(next)) if (k.startsWith(prefix)) { delete next[k]; changed = true }
+    if (changed) errors = next
+  }
+
+  function setItems(name: string, next: Record<string, any>[]) {
+    values = { ...values, [name]: next }
+    config.onChange?.(values)
+  }
+
+  function addItem(name: string, item?: Record<string, any>) {
+    const seed = item ?? Object.fromEntries((fieldOf(name)?.itemFields ?? []).map((f) => [f.name, undefined]))
+    setItems(name, [...arrayItems(name), seed])
+  }
+  function removeItem(name: string, i: number) {
+    const items = arrayItems(name).slice()
+    items.splice(i, 1)
+    clearNamespacedErrors(name) // item indices shift - drop stale keys
+    setItems(name, items)
+  }
+  function moveItem(name: string, from: number, to: number) {
+    const items = arrayItems(name).slice()
+    if (from < 0 || from >= items.length || to < 0 || to >= items.length) return
+    const [it] = items.splice(from, 1)
+    items.splice(to, 0, it as Record<string, any>)
+    clearNamespacedErrors(name)
+    setItems(name, items)
+  }
+  function setItemValue(name: string, i: number, field: string, v: any) {
+    setItems(name, arrayItems(name).map((it, ix) => (ix === i ? { ...it, [field]: v } : it)))
+    if (touched[`${name}.${i}.${field}`]) validateItemField(name, i, field)
+  }
+  function handleItemBlur(name: string, i: number, field: string) {
+    touched = { ...touched, [`${name}.${i}.${field}`]: true }
+    validateItemField(name, i, field)
+  }
+  function validateItemField(name: string, i: number, fieldName: string): boolean {
+    const itemField = fieldOf(name)?.itemFields?.find((f) => f.name === fieldName)
+    if (!itemField) return true
+    const item = arrayItems(name)[i] ?? {}
+    const err = syncError(itemField, item[fieldName], item)
+    setError(`${name}.${i}.${fieldName}`, err)
+    return !err
+  }
+  function validateArray(field: FormField): boolean {
+    const name = field.name
+    const items = arrayItems(name)
+    let arrErr: string | null = null
+    if (field.required && items.length === 0) arrErr = M.required(field.label)
+    else if (field.minItems != null && items.length < field.minItems) arrErr = M.minItems(field.label, field.minItems)
+    else if (field.maxItems != null && items.length > field.maxItems) arrErr = M.maxItems(field.label, field.maxItems)
+    setError(name, arrErr)
+    let ok = !arrErr
+    clearNamespacedErrors(name) // rebuild fresh per-item errors
+    for (let i = 0; i < items.length; i++)
+      for (const itf of field.itemFields ?? [])
+        if (!validateItemField(name, i, itf.name)) ok = false
+    return ok
+  }
+
+  /** True when `field` depends on `name` (cascading). */
+  function dependsOnName(field: FormField, name: string): boolean {
+    const dep = field.dependsOn
+    return dep == null ? false : Array.isArray(dep) ? dep.includes(name) : dep === name
+  }
+
+  function setValue(name: string, v: any) {
+    let next = { ...values, [name]: v }
+    // Cascading: clear any fields that depend on this one so a stale child
+    // selection (e.g. a city under the old country) does not linger.
+    for (const f of flat()) {
+      if (dependsOnName(f, name) && next[f.name] != null) {
+        next = { ...next, [f.name]: null }
+        setError(f.name, null)
+      }
+    }
+    values = next
+    config.onChange?.(values)
+    // Re-validate live once the field has been blurred at least once.
+    if (touched[name]) validateField(name)
+  }
+
+  function handleBlur(name: string) {
+    touched = { ...touched, [name]: true }
+    validateField(name)
+  }
+
+  async function submit(): Promise<boolean> {
+    let ok = true
+    const t: Record<string, boolean> = { ...touched }
+    for (const f of flat()) {
+      if (!isVisible(f.name)) continue
+      t[f.name] = true
+      if (!validateField(f.name)) ok = false
+    }
+    touched = t
+    if (!ok) return false
+    // Await async validators (run now, skipping their debounce). Any failure blocks.
+    const asyncFields = flat().filter((f) => f.asyncValidate && isVisible(f.name))
+    if (asyncFields.length) {
+      for (const f of asyncFields) { const timer = asyncTimers.get(f.name); if (timer) { clearTimeout(timer); asyncTimers.delete(f.name) } }
+      const results = await Promise.all(asyncFields.map((f) => runAsync(f.name)))
+      if (results.some((r) => !r)) return false
+    }
+    // Exclude hidden fields from the submitted payload; keep any non-field keys.
+    const payload = { ...values }
+    for (const f of flat()) if (!isVisible(f.name)) delete payload[f.name]
+    // Inject computed (derived) values so the payload carries them.
+    for (const f of flat()) if (f.computed && isVisible(f.name)) payload[f.name] = f.computed(values)
+    submitting = true
+    try {
+      await config.onSubmit?.(payload)
+    } finally {
+      submitting = false
+    }
+    return true
+  }
+
+  /** Validate a subset of fields by name (sync + their async validators). Used
+   *  to gate a wizard step before advancing. Returns true when all pass. */
+  async function validateFields(names: string[]): Promise<boolean> {
+    let ok = true
+    const t = { ...touched }
+    for (const name of names) {
+      if (!isVisible(name)) continue
+      t[name] = true
+      if (!validateField(name)) ok = false
+    }
+    touched = t
+    if (!ok) return false
+    const asyncNames = names.filter((n) => fieldOf(n)?.asyncValidate && isVisible(n))
+    if (asyncNames.length) {
+      for (const n of asyncNames) { const timer = asyncTimers.get(n); if (timer) { clearTimeout(timer); asyncTimers.delete(n) } }
+      const results = await Promise.all(asyncNames.map((n) => runAsync(n)))
+      if (results.some((r) => !r)) return false
+    }
+    return true
+  }
+
+  /** Restore values to the baseline (or a new one), clearing errors + touched. */
+  function reset(next?: Record<string, any>) {
+    if (next) baseline = { ...next }
+    values = { ...baseline }
+    errors = {}
+    touched = {}
+    config.onChange?.(values)
+  }
+
+  /** Inject errors (e.g. server-side validation after submit) and mark those
+   *  fields touched so the messages show. Empty message clears a field's error. */
+  function setErrors(map: Record<string, string>) {
+    const nextErr = { ...errors }
+    const nextTouched = { ...touched }
+    for (const [k, msg] of Object.entries(map)) {
+      if (msg) { nextErr[k] = msg; nextTouched[k] = true }
+      else delete nextErr[k]
+    }
+    errors = nextErr
+    touched = nextTouched
+  }
+
+  const isFieldDirty = (name: string) => !eq(values[name], baseline[name])
+
+  /** Top-level field errors (visible fields only), for a form-level summary. */
+  function errorList(): { name: string; label: string; message: string }[] {
+    const out: { name: string; label: string; message: string }[] = []
+    for (const f of flat()) {
+      const m = errors[f.name]
+      if (m && isVisible(f.name)) out.push({ name: f.name, label: f.label, message: m })
+    }
+    return out
+  }
+  const firstErrorField = (): string | undefined => errorList()[0]?.name
+
+  return {
+    get values() { return values },
+    get submitting() { return submitting },
+    get isDirty() {
+      const keys = new Set([...Object.keys(values), ...Object.keys(baseline)])
+      for (const k of keys) if (!eq(values[k], baseline[k])) return true
+      return false
+    },
+    value: (name: string) => { const f = fieldOf(name); return f?.computed ? f.computed(values) : values[name] },
+    error: (name: string): string | undefined => errors[name],
+    isTouched: (name: string) => !!touched[name],
+    hasError: (name: string) => !!errors[name],
+    isValidating: (name: string) => !!validating[name],
+    isFieldDirty,
+    isVisible,
+    isDisabled,
+    entries: () => config.fields(),
+    // Field arrays
+    arrayItems,
+    itemValue,
+    itemError,
+    addItem,
+    removeItem,
+    moveItem,
+    setItemValue,
+    handleItemBlur,
+    setValue,
+    handleBlur,
+    validateField,
+    validateFields,
+    submit,
+    reset,
+    setErrors,
+    errorList,
+    firstErrorField,
+    /** The resolved message strings (defaults merged with `config.messages`). */
+    messages: M,
+  }
+}
+
+export type Form = ReturnType<typeof createForm>