@playfast/reform-forms 1.2.0 → 1.2.1

package/src/formMake.ts

@@ -0,0 +1,95 @@
+import { Context, Function as Fn, Option, Schema as S } from 'effect'
+import { Event, Reducer, State } from '@playfast/reform'
+import type {
+  DecodedOfSchema,
+  FormClass,
+  FormEvents,
+  FormManifest,
+  FormState,
+  FormVisitor,
+  InputRecord,
+  InputsObject,
+  RuntimeConfig,
+  ValuesOfSchema,
+} from './formTypes'
+
+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
+}

package/src/formState.ts

@@ -0,0 +1,181 @@
+import { Function as Fn, Option, Record } from 'effect'
+import {
+  getNestedValue,
+  moveAt,
+  recalculateDirtyPaths,
+  replaceAt,
+  setNestedValue,
+} from './path'
+import type { FormState } from './formTypes'
+
+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
+}
+
+export const initialState = <Values>(initial: Values): FormState<Values> => ({
+  values: initial,
+  initialValues: initial,
+  touched: {},
+  errors: {},
+  dirtyPaths: [],
+  submitCount: 0,
+  validationCount: 0,
+  lastSubmittedValues: Option.none(),
+  arrayKeys: arrayKeysFor(initial),
+})
+
+export 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),
+})
+
+export 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) }
+}
+
+export const setAtPath = <Values>(input: SetPathInput<Values>): FormState<Values> =>
+  withValues(input.state, setNestedValue(input.state.values, input.path, input.value))
+
+export 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(),
+    ]),
+  }
+}
+
+export 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),
+    ),
+  }
+}
+
+export 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),
+    ),
+  }
+}
+
+export 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(),
+      ),
+    ),
+  }
+}

package/src/formTypes.ts

@@ -0,0 +1,235 @@
+import type { Context, Effect, Option, Schema as S } from 'effect'
+import type { Event, Reducer, State } from '@playfast/reform'
+import type {
+  AnySource,
+  SourceName,
+  SourceValue as ReformSourceValue,
+} from '@playfast/reform/internal'
+import type {
+  ArrayItem,
+  ArrayPath,
+  FieldPath,
+  PathValue,
+  VariantPath,
+  VariantValue,
+} from './path'
+import type { FormError, FormErrors } from './validation'
+
+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>
+}
+
+export type InputRecord = Readonly<Record<string, AnySource>>
+
+export type InputsObject<Inputs extends InputRecord> = {
+  readonly [K in keyof Inputs as SourceName<Inputs[K]>]: ReformSourceValue<Inputs[K]>
+}
+
+export type InputStores<Inputs extends InputRecord> = {
+  [K in keyof Inputs]: Inputs[K] extends {
+    readonly store: Context.Tag<infer Service, infer _Store>
+  }
+    ? Service
+    : never
+}[keyof Inputs]
+
+export type ValuesOfSchema<Schema extends S.Schema.AnyNoContext> = S.Schema.Encoded<Schema>
+export 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
+}
+
+export 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>>