@playfast/reform-forms 1.2.0 → 1.2.1

package/src/formView.ts

@@ -0,0 +1,236 @@
+import {
+  Context,
+  Effect,
+  Either,
+  Function as Fn,
+  Option,
+  Record,
+  Runtime,
+  Schema as S,
+} from 'effect'
+import { Event, type Trigger } from '@playfast/reform'
+import {
+  type AnySource,
+  Bus,
+  CurrentTracker,
+  type SourceIdentifier,
+  type SourceValue as ReformSourceValue,
+  type Store,
+} from '@playfast/reform/internal'
+import { State } from '@playfast/reform'
+import {
+  getNestedValue,
+  isPathOrParentDirty,
+  type ArrayItem,
+  type ArrayPath,
+  type FieldPath,
+  type PathValue,
+} from './path'
+import { errorsToRecord, firstError, routeParseError } from './validation'
+import { currentArray } from './formState'
+import type {
+  ArrayBinding,
+  DecodedOfSchema,
+  FieldLimitations,
+  FieldBinding,
+  FormClass,
+  FormState,
+  FormView,
+  InputRecord,
+  InputsObject,
+  InputStores,
+  Limitations,
+  RuntimeConfig,
+  ValuesOfSchema,
+} from './formTypes'
+
+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
+  })
+