@playfast/reform-forms 1.2.0 → 1.2.1

package/src/form.ts

@@ -1,522 +1,53 @@
+import { type Context, Effect, Function as Fn, Layer, Option, Schema as S } from 'effect'
+import { Reducer, State } from '@playfast/reform'
+import { Bus, Reducers } from '@playfast/reform/internal'
+import { error, normalizeErrors, type FormErrors } from './validation'
 import {
-  Context,
-  Effect,
-  Either,
-  Function as Fn,
-  Layer,
-  Option,
-  Record,
-  Runtime,
-  Schema as S,
-} from 'effect'
-import { Event, Reducer, State, type Trigger } from '@playfast/reform'
-import {
-  type AnySource,
-  Bus,
-  CurrentTracker,
-  Reducers,
-  type SourceIdentifier,
-  type SourceName,
-  type SourceValue as ReformSourceValue,
-  type Store,
-} from '@playfast/reform/internal'
-import {
-  getNestedValue,
-  isPathOrParentDirty,
-  moveAt,
-  recalculateDirtyPaths,
-  replaceAt,
-  setNestedValue,
-  type ArrayItem,
-  type ArrayPath,
-  type FieldPath,
-  type PathValue,
-  type VariantPath,
-  type VariantValue,
-} from './path'
-import {
-  error,
-  errorsToRecord,
-  firstError,
-  normalizeErrors,
-  routeParseError,
-  type FormError,
-  type FormErrors,
-} from './validation'
+  appendAtPath,
+  initialState,
+  markTouched,
+  moveAtPath,
+  removeAtPath,
+  setAtPath,
+  swapAtPath,
+} from './formState'
+import type {
+  DecodedOfSchema,
+  FormClass,
+  FormLiveConfig,
+  FormState,
+  InputRecord,
+  InputsObject,
+  RuntimeConfig,
+  ValuesOfSchema,
+} from './formTypes'
 
 export { error }
-
-export interface FieldLimitationsExternalApi<A = unknown> {
-  readonly required?: boolean
-  readonly disabled?: boolean
-  readonly readonly?: boolean
-  readonly visible?: boolean
-  readonly min?: number
-  readonly max?: number
-  readonly minLength?: number
-  readonly maxLength?: number
-  readonly minItems?: number
-  readonly maxItems?: number
-  readonly options?: ReadonlyArray<A>
-  readonly meta?: Readonly<Record<string, unknown>>
-}
-
-export type FieldLimitations<A = unknown> = FieldLimitationsExternalApi<A>
-
-export type Limitations = Readonly<Record<string, FieldLimitations>>
-
-export interface FormState<Values> {
-  readonly values: Values
-  readonly initialValues: Values
-  readonly touched: Readonly<Record<string, boolean>>
-  readonly errors: FormErrors
-  readonly dirtyPaths: ReadonlyArray<string>
-  readonly submitCount: number
-  readonly validationCount: number
-  readonly lastSubmittedValues: Option.Option<Values>
-  readonly arrayKeys: Readonly<Record<string, ReadonlyArray<string>>>
-}
-
-export interface FieldBinding<A> {
-  readonly path: string
-  readonly value: A
-  readonly set: (value: A | ((prev: A) => A)) => void
-  readonly blur: () => void
-  readonly error: Option.Option<string>
-  readonly dirty: boolean
-  readonly touched: boolean
-  readonly validating: boolean
-  readonly limitations: FieldLimitations<A>
-}
-
-export interface ArrayItemView<Item> {
-  readonly key: string
-  readonly index: number
-  readonly value: Item
-  readonly remove: () => void
-  readonly move: (to: number) => void
-}
-
-export interface ArrayBinding<Item> {
-  readonly path: string
-  readonly items: ReadonlyArray<ArrayItemView<Item>>
-  readonly append: (value?: Item) => void
-  readonly remove: (index: number) => void
-  readonly move: (from: number, to: number) => void
-  readonly swap: (a: number, b: number) => void
-  readonly limitations: FieldLimitations<ReadonlyArray<Item>>
-}
-
-export interface FormView<Values, Inputs = {}> {
-  readonly values: Values
-  readonly inputs: Inputs
-  readonly errors: FormErrors
-  readonly dirty: boolean
-  readonly canSubmit: boolean
-  readonly submitCount: number
-  readonly validationCount: number
-  readonly lastSubmittedValues: Option.Option<Values>
-  readonly submit: () => void
-  readonly reset: () => void
-  readonly validate: () => void
-  readonly field: <P extends FieldPath<Values>>(path: P) => FieldBinding<PathValue<Values, P>>
-  readonly array: <P extends ArrayPath<Values>>(path: P) => ArrayBinding<ArrayItem<Values, P>>
-  readonly variantValue: <P extends VariantPath<Values>>(path: P) => VariantValue<Values, P>
-}
-
-type InputRecord = Readonly<Record<string, AnySource>>
-
-type InputsObject<Inputs extends InputRecord> = {
-  readonly [K in keyof Inputs as SourceName<Inputs[K]>]: ReformSourceValue<Inputs[K]>
-}
-
-type InputStores<Inputs extends InputRecord> = {
-  [K in keyof Inputs]: Inputs[K] extends {
-    readonly store: Context.Tag<infer Service, infer _Store>
-  }
-    ? Service
-    : never
-}[keyof Inputs]
-
-type ValuesOfSchema<Schema extends S.Schema.AnyNoContext> = S.Schema.Encoded<Schema>
-type DecodedOfSchema<Schema extends S.Schema.AnyNoContext> = S.Schema.Type<Schema>
-
-export interface RuntimeConfig<Values, Decoded, Inputs> {
-  readonly initial: Values
-  // oxlint-disable-next-line reform-rules/no-optional-fields -- optional Effect-returning config knob (not a serializable shape); Option would break external form definitions
-  readonly limit?: (ctx: { readonly values: Values; readonly inputs: Inputs }) => Limitations
-  readonly validate: (ctx: {
-    readonly values: Values
-    readonly decoded: Decoded
-    readonly inputs: Inputs
-  }) => Effect.Effect<ReadonlyArray<FormError>, never, never>
-  readonly submit: (ctx: {
-    readonly values: Values
-    readonly decoded: Decoded
-    readonly inputs: Inputs
-  }) => Effect.Effect<void, unknown, never>
-}
-
-export interface FormLiveConfig<Values, Decoded, Inputs, R = never> {
-  readonly initial: Values
-  // oxlint-disable-next-line reform-rules/no-optional-fields -- optional Effect-returning config knob; Option would break external form definitions
-  readonly limit?: (ctx: { readonly values: Values; readonly inputs: Inputs }) => Limitations
-  // oxlint-disable-next-line reform-rules/no-optional-fields -- optional Effect-returning config knob; Option would break external form definitions
-  readonly validate?: (ctx: {
-    readonly values: Values
-    readonly decoded: Decoded
-    readonly inputs: Inputs
-  }) =>
-    | void
-    | FormError
-    | ReadonlyArray<FormError>
-    | Effect.Effect<void | FormError | ReadonlyArray<FormError>, never, R>
-  // oxlint-disable-next-line reform-rules/no-optional-fields -- optional Effect-returning config knob; Option would break external form definitions
-  readonly submit?: (ctx: {
-    readonly values: Values
-    readonly decoded: Decoded
-    readonly inputs: Inputs
-  }) => void | Effect.Effect<unknown, unknown, R>
-}
-
-export interface FormSchemaReflection {
-  readonly ast: S.Schema<unknown, unknown, unknown>['ast']
-}
-
-export interface FormManifestReflection<N extends string> {
-  readonly kind: 'Form'
-  readonly name: N
-  readonly schema: FormSchemaReflection
-  readonly inputs: InputRecord
-}
-
-export interface FormManifest<
-  N extends string,
-  Schema extends S.Schema.AnyNoContext,
-  Inputs extends InputRecord,
-> extends FormManifestReflection<N> {
-  readonly schema: Schema
-  readonly inputs: Inputs
-}
-
-interface FormEvents {
-  readonly set: Event.EventClass<string, { readonly path: string; readonly value: unknown }>
-  readonly blur: Event.EventClass<string, { readonly path: string }>
-  readonly reset: Event.EventClass<string, {}>
-  readonly validationFinished: Event.EventClass<string, { readonly errors: FormErrors }>
-  readonly submitAttempted: Event.EventClass<string, {}>
-  readonly submitSucceeded: Event.EventClass<string, { readonly values: unknown }>
-  readonly append: Event.EventClass<string, { readonly path: string; readonly value: unknown }>
-  readonly remove: Event.EventClass<string, { readonly path: string; readonly index: number }>
-  readonly move: Event.EventClass<
-    string,
-    { readonly path: string; readonly from: number; readonly to: number }
-  >
-  readonly swap: Event.EventClass<
-    string,
-    { readonly path: string; readonly a: number; readonly b: number }
-  >
-}
-
-export interface FormVisitor<Result> {
-  readonly visit: <
-    N extends string,
-    Schema extends S.Schema.AnyNoContext,
-    Inputs extends InputRecord,
-  >(
-    form: FormClass<N, Schema, Inputs>,
-  ) => Result
-}
-
-export interface AnyForm {
-  new (): {}
-  readonly manifest: FormManifestReflection<string>
-  readonly capture: <Result>(visitor: FormVisitor<Result>) => Result
-}
-
-export interface FormClass<
-  N extends string,
-  Schema extends S.Schema.AnyNoContext,
-  Inputs extends InputRecord,
-> {
-  new (): {}
-  readonly manifest: FormManifest<N, Schema, Inputs>
-  readonly capture: <Result>(visitor: FormVisitor<Result>) => Result
-  readonly state: State.StateClass<`${N}/state`, FormState<ValuesOfSchema<Schema>>>
-  readonly config: Context.Tag<
-    RuntimeConfig<ValuesOfSchema<Schema>, DecodedOfSchema<Schema>, InputsObject<Inputs>>,
-    RuntimeConfig<ValuesOfSchema<Schema>, DecodedOfSchema<Schema>, InputsObject<Inputs>>
-  >
-  readonly events: FormEvents
-  readonly reducer: Reducer.StateReducerClass<
-    State.StateClass<`${N}/state`, FormState<ValuesOfSchema<Schema>>>,
-    ReadonlyArray<Event.AnyEvent>
-  >
-}
-
-export type Values<F> =
-  F extends FormClass<infer _Name, infer Schema, infer _Inputs> ? ValuesOfSchema<Schema> : never
-
-export type Decoded<F> =
-  F extends FormClass<infer _Name, infer Schema, infer _Inputs> ? DecodedOfSchema<Schema> : never
-
-export type Inputs<F> =
-  F extends FormClass<infer _Name, infer _Schema, infer Inputs> ? InputsObject<Inputs> : never
-
-export type View<F> = FormView<Values<F>, Inputs<F>>
-
-const arrayKeyCounter = { current: 0 }
-const makeArrayKey = (): string => `form-item-${arrayKeyCounter.current++}`
-
-export const arrayKeysFor = (source: unknown, path = ''): Record<string, ReadonlyArray<string>> => {
-  const out: Record<string, ReadonlyArray<string>> = {}
-  const visit = (node: KeyVisitNode): void => {
-    if (Array.isArray(node.current)) {
-      out[node.path] = node.current.map(() => makeArrayKey())
-      node.current.forEach((element, index) =>
-        visit({ current: element, path: `${node.path}[${index}]` }),
-      )
-      return
-    }
-    if (node.current !== null && typeof node.current === 'object') {
-      Record.toEntries(Fn.unsafeCoerce<unknown, Record<string, unknown>>(node.current)).forEach(
-        ([key, child]) =>
-          visit({ current: child, path: node.path.length === 0 ? key : `${node.path}.${key}` }),
-      )
-    }
-  }
-  visit({ current: source, path })
-  return out
-}
-
-const initialState = <Values>(initial: Values): FormState<Values> => ({
-  values: initial,
-  initialValues: initial,
-  touched: {},
-  errors: {},
-  dirtyPaths: [],
-  submitCount: 0,
-  validationCount: 0,
-  lastSubmittedValues: Option.none(),
-  arrayKeys: arrayKeysFor(initial),
-})
-
-const markTouched = (
-  touched: Readonly<Record<string, boolean>>,
-  path: string,
-): Readonly<Record<string, boolean>> => ({ ...touched, [path]: true })
-
-interface ArrayLookup {
-  readonly source: unknown
-  readonly path: string
-}
-
-interface KeyVisitNode {
-  readonly current: unknown
-  readonly path: string
-}
-
-interface PathInput<Values> {
-  readonly state: FormState<Values>
-  readonly path: string
-}
-
-interface SetPathInput<Values> extends PathInput<Values> {
-  readonly value: unknown
-}
-
-interface RemovePathInput<Values> extends PathInput<Values> {
-  readonly index: number
-}
-
-interface MovePathInput<Values> extends PathInput<Values> {
-  readonly from: number
-  readonly to: number
-}
-
-interface SwapPathInput<Values> extends PathInput<Values> {
-  readonly first: number
-  readonly second: number
-}
-
-const withValues = <Values>(state: FormState<Values>, nextValues: Values): FormState<Values> => ({
-  ...state,
-  values: nextValues,
-  dirtyPaths: recalculateDirtyPaths(state.initialValues, nextValues),
-})
-
-const currentArray = (input: ArrayLookup): ReadonlyArray<unknown> => {
-  const current = getNestedValue(input.source, input.path)
-  return Array.isArray(current) ? current : []
-}
-
-const updateKeys = (
-  state: FormState<unknown>,
-  path: string,
-  transform: (keys: ReadonlyArray<string>) => ReadonlyArray<string>,
-): Readonly<Record<string, ReadonlyArray<string>>> => {
-  const existing =
-    state.arrayKeys[path] ?? currentArray({ source: state.values, path }).map(() => makeArrayKey())
-  return { ...state.arrayKeys, [path]: transform(existing) }
-}
-
-const setAtPath = <Values>(input: SetPathInput<Values>): FormState<Values> =>
-  withValues(input.state, setNestedValue(input.state.values, input.path, input.value))
-
-const appendAtPath = <Values>(input: SetPathInput<Values>): FormState<Values> => {
-  const elements = currentArray({ source: input.state.values, path: input.path })
-  const nextValues = setNestedValue(input.state.values, input.path, [...elements, input.value])
-  return {
-    ...withValues(input.state, nextValues),
-    arrayKeys: updateKeys(Fn.unsafeCoerce(input.state), input.path, (keys) => [
-      ...keys,
-      makeArrayKey(),
-    ]),
-  }
-}
-
-const removeAtPath = <Values>(input: RemovePathInput<Values>): FormState<Values> => {
-  const elements = currentArray({ source: input.state.values, path: input.path })
-  if (input.index < 0 || input.index >= elements.length) {
-    return input.state
-  }
-  const nextValues = setNestedValue(
-    input.state.values,
-    input.path,
-    elements.filter((_, position) => position !== input.index),
-  )
-  return {
-    ...withValues(input.state, nextValues),
-    arrayKeys: updateKeys(Fn.unsafeCoerce(input.state), input.path, (keys) =>
-      keys.filter((_, position) => position !== input.index),
-    ),
-  }
-}
-
-const moveAtPath = <Values>(input: MovePathInput<Values>): FormState<Values> => {
-  const elements = currentArray({ source: input.state.values, path: input.path })
-  const next = moveAt(elements, input.from, input.to)
-  if (next === elements) {
-    return input.state
-  }
-  const nextValues = setNestedValue(input.state.values, input.path, next)
-  return {
-    ...withValues(input.state, nextValues),
-    arrayKeys: updateKeys(Fn.unsafeCoerce(input.state), input.path, (keys) =>
-      moveAt(keys, input.from, input.to),
-    ),
-  }
-}
-
-const swapAtPath = <Values>(input: SwapPathInput<Values>): FormState<Values> => {
-  const elements = currentArray({ source: input.state.values, path: input.path })
-  if (
-    input.first < 0 ||
-    input.second < 0 ||
-    input.first >= elements.length ||
-    input.second >= elements.length ||
-    input.first === input.second
-  ) {
-    return input.state
-  }
-  const swapped = replaceAt(
-    replaceAt(elements, input.first, elements[input.second]),
-    input.second,
-    elements[input.first],
-  )
-  const nextValues = setNestedValue(input.state.values, input.path, swapped)
-  return {
-    ...withValues(input.state, nextValues),
-    arrayKeys: updateKeys(Fn.unsafeCoerce(input.state), input.path, (keys) =>
-      replaceAt(
-        replaceAt(keys, input.first, keys[input.second] ?? makeArrayKey()),
-        input.second,
-        keys[input.first] ?? makeArrayKey(),
-      ),
-    ),
-  }
-}
-
-interface MakeConfig<Schema extends S.Schema.AnyNoContext, Inputs extends InputRecord> {
-  readonly schema: Schema
-  // oxlint-disable-next-line reform-rules/no-optional-fields -- optional source map on the public make() config; Option would break callers passing only a schema
-  readonly inputs?: Inputs
-}
-
-export const make = <
-  const N extends string,
-  Schema extends S.Schema.AnyNoContext,
-  const Inputs extends InputRecord = {},
->(
-  name: N,
-  config: MakeConfig<Schema, Inputs>,
-): FormClass<N, Schema, Inputs> => {
-  const valuesSchema = S.encodedSchema(config.schema)
-  const stringRecord = S.Record({ key: S.String, value: S.String })
-  const stateSchema = S.Struct({
-    values: valuesSchema,
-    initialValues: valuesSchema,
-    touched: S.Record({ key: S.String, value: S.Boolean }),
-    errors: stringRecord,
-    dirtyPaths: S.Array(S.String),
-    submitCount: S.Number,
-    validationCount: S.Number,
-    lastSubmittedValues: S.OptionFromSelf(valuesSchema),
-    arrayKeys: S.Record({ key: S.String, value: S.Array(S.String) }),
-  })
-  const state: State.StateClass<`${N}/state`, FormState<ValuesOfSchema<Schema>>> = State.make(
-    `${name}/state`,
-    stateSchema,
-    { title: `${name} form state` },
-  )
-  const events: FormEvents = {
-    set: Event.make(`${name}/SetField`, S.Struct({ path: S.String, value: S.Unknown })),
-    blur: Event.make(`${name}/BlurField`, S.Struct({ path: S.String })),
-    reset: Event.make(`${name}/Reset`, S.Struct({})),
-    validationFinished: Event.make(
-      `${name}/ValidationFinished`,
-      S.Struct({
-        errors: S.Record({ key: S.String, value: S.String }),
-      }),
-    ),
-    submitAttempted: Event.make(`${name}/SubmitAttempted`, S.Struct({})),
-    submitSucceeded: Event.make(`${name}/SubmitSucceeded`, S.Struct({ values: S.Unknown })),
-    append: Event.make(`${name}/AppendItem`, S.Struct({ path: S.String, value: S.Unknown })),
-    remove: Event.make(`${name}/RemoveItem`, S.Struct({ path: S.String, index: S.Number })),
-    move: Event.make(
-      `${name}/MoveItem`,
-      S.Struct({ path: S.String, from: S.Number, to: S.Number }),
-    ),
-    swap: Event.make(`${name}/SwapItems`, S.Struct({ path: S.String, a: S.Number, b: S.Number })),
-  }
-  const reducer: FormClass<N, Schema, Inputs>['reducer'] = Reducer.make(`${name}/FormReducer`, {
-    states: [state],
-    events: Object.values(events),
-  })
-  const runtimeConfig = Context.GenericTag<
-    RuntimeConfig<ValuesOfSchema<Schema>, DecodedOfSchema<Schema>, InputsObject<Inputs>>,
-    RuntimeConfig<ValuesOfSchema<Schema>, DecodedOfSchema<Schema>, InputsObject<Inputs>>
-  >(`reform/form/${name}/config`)
-  const inputs: Inputs = Fn.unsafeCoerce(
-    Option.getOrElse(Option.fromNullable(config.inputs), () => ({})),
-  )
-  class FormImpl {
-    static readonly manifest: FormManifest<N, Schema, Inputs> = {
-      kind: 'Form',
-      name,
-      schema: config.schema,
-      inputs,
-    }
-    static readonly state = state
-    static readonly config = runtimeConfig
-    static readonly events = events
-    static readonly reducer = reducer
-    static capture<Result>(visitor: FormVisitor<Result>): Result {
-      return visitor.visit(FormImpl)
-    }
-  }
-  return FormImpl
-}
+export { arrayKeysFor } from './formState'
+export { make } from './formMake'
+export { view } from './formView'
+export type {
+  AnyForm,
+  ArrayBinding,
+  ArrayItemView,
+  Decoded,
+  FieldBinding,
+  FieldLimitations,
+  FieldLimitationsExternalApi,
+  FormClass,
+  FormLiveConfig,
+  FormManifest,
+  FormManifestReflection,
+  FormSchemaReflection,
+  FormState,
+  FormView,
+  FormVisitor,
+  Inputs,
+  Limitations,
+  RuntimeConfig,
+  Values,
+  View,
+} from './formTypes'
 
 export const live = <
   N extends string,
@@ -645,193 +176,3 @@ export const live = <
     Layer.provideMerge(State.live(form.state, initialState(config.initial))),
   )
 }
-
-const readInput = Effect.fn('forms.readInput')(function* <Input extends AnySource>(
-  source: Input,
-): Effect.fn.Return<ReformSourceValue<Input>, never, SourceIdentifier<Input>> {
-  const store = yield* Context.GenericTag<SourceIdentifier<Input>, Store<ReformSourceValue<Input>>>(
-    source.store.key,
-  )
-  const tracker = yield* Effect.serviceOption(CurrentTracker)
-  if (Option.isSome(tracker)) {
-    tracker.value.add(store)
-  }
-  return store.getSnapshot()
-})
-
-const readInputs = <Inputs extends InputRecord>(
-  inputs: Inputs,
-): Effect.Effect<InputsObject<Inputs>, never, InputStores<Inputs>> =>
-  Fn.unsafeCoerce(
-    Effect.gen(function* () {
-      const pairs = yield* Effect.forEach(Object.values(inputs), (source) =>
-        Effect.map(readInput(source), (snapshot): readonly [string, unknown] => [
-          source.name,
-          snapshot,
-        ]),
-      )
-      return Record.fromEntries(pairs)
-    }),
-  )
-
-const limitationsFor = <A>(limitations: Limitations, path: string): FieldLimitations<A> =>
-  Fn.unsafeCoerce(Option.getOrElse(Option.fromNullable(limitations[path]), () => ({})))
-
-const trigger = <P>(
-  eventTrigger: Effect.Effect<Trigger<P>, never, Bus>,
-): Effect.Effect<Trigger<P>, never, Bus> => eventTrigger
-
-// oxlint-disable-next-line reform-rules/prefer-effect-fn -- public generic view preserves the exact form state/config/input requirements verbatim
-export const view = <
-  N extends string,
-  Schema extends S.Schema.AnyNoContext,
-  FormInputs extends InputRecord,
->(
-  form: FormClass<N, Schema, FormInputs>,
-): Effect.Effect<
-  FormView<ValuesOfSchema<Schema>, InputsObject<FormInputs>>,
-  never,
-  | State.StateStore<`${N}/state`, FormState<ValuesOfSchema<Schema>>>
-  | RuntimeConfig<ValuesOfSchema<Schema>, DecodedOfSchema<Schema>, InputsObject<FormInputs>>
-  | Bus
-  | InputStores<FormInputs>
-> =>
-  Effect.gen(function* () {
-    const state = yield* form.state
-    const runtimeConfig = yield* form.config
-    const inputs = yield* readInputs(form.manifest.inputs)
-    const limitations = Option.getOrElse(
-      Option.fromNullable(runtimeConfig.limit?.({ values: state.values, inputs })),
-      () => ({}),
-    )
-    const setField = yield* trigger(form.events.set.trigger)
-    const blurField = yield* trigger(form.events.blur.trigger)
-    const reset = yield* trigger(form.events.reset.trigger)
-    const append = yield* trigger(form.events.append.trigger)
-    const remove = yield* trigger(form.events.remove.trigger)
-    const move = yield* trigger(form.events.move.trigger)
-    const swap = yield* trigger(form.events.swap.trigger)
-    const runtime = yield* Effect.runtime<Bus>()
-
-    const schema = form.manifest.schema
-    const decodeEither = S.decodeUnknownEither(schema, { errors: 'all' })(state.values)
-    const canSubmit = Either.isRight(decodeEither) && Record.keys(state.errors).length === 0
-
-    // oxlint-disable-next-line reform-rules/prefer-effect-fn -- local closure whose inferred R must flow into the parent view gen; Effect.fn would force an explicit Return annotation over the erased AnyForm requirements
-    const runValidation = (publishSubmitAttempt: boolean) =>
-      Effect.gen(function* () {
-        if (publishSubmitAttempt) {
-          yield* Event.dispatch(form.events.submitAttempted, {})
-        }
-        const decoded = S.decodeUnknownEither(schema, { errors: 'all' })(state.values)
-        if (Either.isLeft(decoded)) {
-          yield* Event.dispatch(form.events.validationFinished, {
-            errors: routeParseError(decoded.left),
-          })
-          return Option.none<DecodedOfSchema<Schema>>()
-        }
-        const custom = yield* runtimeConfig.validate({
-          values: state.values,
-          decoded: decoded.right,
-          inputs,
-        })
-        const errors = errorsToRecord(custom)
-        yield* Event.dispatch(form.events.validationFinished, { errors })
-        return Record.keys(errors).length === 0
-          ? Option.some(decoded.right)
-          : Option.none<DecodedOfSchema<Schema>>()
-      })
-
-    const submit = () => {
-      Runtime.runFork(runtime)(
-        Effect.gen(function* () {
-          const decoded = yield* runValidation(true)
-          if (Option.isNone(decoded)) {
-            return
-          }
-          yield* runtimeConfig.submit({ values: state.values, decoded: decoded.value, inputs })
-          yield* Event.dispatch(form.events.submitSucceeded, { values: state.values })
-        }).pipe(
-          Effect.catchAllCause((cause) => Effect.logError('reform form submit failed', cause)),
-        ),
-      )
-    }
-
-    const validate = () => {
-      Runtime.runFork(runtime)(runValidation(false))
-    }
-
-    const field = <P extends FieldPath<ValuesOfSchema<Schema>>>(
-      path: P,
-    ): FieldBinding<PathValue<ValuesOfSchema<Schema>, P>> => {
-      const fieldValue: PathValue<ValuesOfSchema<Schema>, P> = Fn.unsafeCoerce(
-        getNestedValue(state.values, path),
-      )
-      return {
-        path,
-        value: fieldValue,
-        set: (next) => {
-          if (typeof next === 'function') {
-            const updater = Fn.unsafeCoerce<
-              typeof next,
-              (prev: PathValue<ValuesOfSchema<Schema>, P>) => PathValue<ValuesOfSchema<Schema>, P>
-            >(next)
-            setField({ path, value: updater(fieldValue) })
-            return
-          }
-          setField({ path, value: next })
-        },
-        blur: () => blurField({ path }),
-        error: firstError(state.errors, path),
-        dirty: isPathOrParentDirty(state.dirtyPaths, path),
-        touched: state.touched[path] === true,
-        validating: false,
-        limitations: limitationsFor<PathValue<ValuesOfSchema<Schema>, P>>(limitations, path),
-      }
-    }
-
-    const array = <P extends ArrayPath<ValuesOfSchema<Schema>>>(
-      path: P,
-    ): ArrayBinding<ArrayItem<ValuesOfSchema<Schema>, P>> => {
-      const arrayValues: ReadonlyArray<ArrayItem<ValuesOfSchema<Schema>, P>> = Fn.unsafeCoerce(
-        currentArray({ source: state.values, path }),
-      )
-      const keys = state.arrayKeys[path] ?? arrayValues.map((_, index) => `${path}-${index}`)
-      return {
-        path,
-        items: arrayValues.map((element, index) => ({
-          value: element,
-          index,
-          key: keys[index] ?? `${path}-${index}`,
-          remove: () => remove({ path, index }),
-          move: (to) => move({ path, from: index, to }),
-        })),
-        append: (element) => append({ path, value: element }),
-        remove: (index) => remove({ path, index }),
-        move: (from, to) => move({ path, from, to }),
-        swap: (first, second) => swap({ path, a: first, b: second }),
-        limitations: limitationsFor<ReadonlyArray<ArrayItem<ValuesOfSchema<Schema>, P>>>(
-          limitations,
-          path,
-        ),
-      }
-    }
-
-    const formView: FormView<ValuesOfSchema<Schema>, InputsObject<FormInputs>> = Fn.unsafeCoerce({
-      values: state.values,
-      inputs,
-      errors: state.errors,
-      dirty: state.dirtyPaths.length > 0,
-      canSubmit,
-      submitCount: state.submitCount,
-      validationCount: state.validationCount,
-      lastSubmittedValues: state.lastSubmittedValues,
-      submit,
-      reset: () => reset({}),
-      validate,
-      field,
-      array,
-      variantValue: (path: string) => Fn.unsafeCoerce(getNestedValue(state.values, path)),
-    })
-    return formView
-  })