@matheuspuel/state-machine 0.2.0 → 0.2.2

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@matheuspuel/state-machine",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "type": "module",
   "module": "index.ts",
   "exports": {
     "./package.json": "./package.json",
     ".": "./src/index.ts",
     "./definition": "./src/definition.ts",
+    "./form": "./src/form/index.ts",
     "./machines": "./src/machines/index.ts",
     "./react": "./src/react/index.ts",
     "./runtime": "./src/runtime/index.ts"

package/src/form/definition.ts

@@ -0,0 +1,33 @@
+import { Effect, Schema } from 'effect'
+import { ParseError } from 'effect/ParseResult'
+
+export type AnyForm = {
+  [key: string]: AnyForm | FormField<any, any, any>
+}
+
+export type FormField<A, I, E> = {
+  initial: I
+  validate: (value: I) => Effect.Effect<A, E>
+  fromData: (data: A) => I
+}
+
+export const field = <A, I, E>(args: FormField<A, I, E>) => args
+
+export const fieldSchema = <A, I>(args: {
+  initial: I
+  schema: Schema.Schema<A, I>
+}) =>
+  field<A, I, ParseError>({
+    initial: args.initial,
+    validate: Schema.decode(args.schema),
+    fromData: Schema.encodeSync(args.schema),
+  })
+
+export const fieldSuccess = <A>(args: { initial: A }) =>
+  field<A, A, never>({
+    initial: args.initial,
+    validate: Effect.succeed,
+    fromData: _ => _,
+  })
+
+export const Struct = <Fields extends AnyForm>(fields: Fields) => fields

package/src/form/index.ts

@@ -0,0 +1 @@
+export * as Form from './definition'

package/src/machines/Form.test.ts

@@ -0,0 +1,68 @@
+import { describe, expect, it } from '@effect/vitest'
+import { Effect } from 'effect'
+import { StateMachine } from '..'
+import { Form } from '../form'
+import { run } from '../runtime'
+
+describe('Form', () => {
+  it('should work', () => {
+    const formField = Form.field({
+      initial: 0,
+      validate: _ =>
+        _ > 1 ? Effect.succeed({ n: _ }) : Effect.fail('low' as const),
+      fromData: (data: { n: number }) => data.n,
+    })
+    const form = Form.Struct({
+      a: formField,
+      b: Form.Struct({ c: formField }),
+    })
+    const machine = StateMachine.Form(form)
+    const instance = run(machine)
+    const getState = () => instance.ref.get.pipe(Effect.runSync)
+    expect(getState()).toStrictEqual<ReturnType<typeof getState>>({
+      a: { value: 0, error: null },
+      b: { c: { value: 0, error: null } },
+    })
+    instance.actions.a.set(1)
+    expect(getState()).toStrictEqual<ReturnType<typeof getState>>({
+      a: { value: 1, error: null },
+      b: { c: { value: 0, error: null } },
+    })
+    instance.actions.validate().pipe(Effect.runSyncExit)
+    expect(getState()).toStrictEqual<ReturnType<typeof getState>>({
+      a: { value: 1, error: 'low' },
+      b: { c: { value: 0, error: 'low' } },
+    })
+    instance.actions.a.update(_ => _ + 1)
+    expect(getState()).toStrictEqual<ReturnType<typeof getState>>({
+      a: { value: 2, error: null },
+      b: { c: { value: 0, error: 'low' } },
+    })
+    instance.actions.b.c.set(1)
+    expect(getState()).toStrictEqual<ReturnType<typeof getState>>({
+      a: { value: 2, error: null },
+      b: { c: { value: 1, error: null } },
+    })
+    instance.actions.validate().pipe(Effect.runSyncExit)
+    expect(getState()).toStrictEqual<ReturnType<typeof getState>>({
+      a: { value: 2, error: null },
+      b: { c: { value: 1, error: 'low' } },
+    })
+    instance.actions.b.c.update(_ => _ + 1)
+    expect(getState()).toStrictEqual<ReturnType<typeof getState>>({
+      a: { value: 2, error: null },
+      b: { c: { value: 2, error: null } },
+    })
+    const data = instance.actions.validate().pipe(Effect.runSync)
+    expect(data).toStrictEqual<typeof data>({ a: { n: 2 }, b: { c: { n: 2 } } })
+    expect(getState()).toStrictEqual<ReturnType<typeof getState>>({
+      a: { value: 2, error: null },
+      b: { c: { value: 2, error: null } },
+    })
+    instance.actions.setStateFromData({ a: { n: 3 }, b: { c: { n: 3 } } })
+    expect(getState()).toStrictEqual<ReturnType<typeof getState>>({
+      a: { value: 3, error: null },
+      b: { c: { value: 3, error: null } },
+    })
+  })
+})

package/src/machines/Form.ts

@@ -0,0 +1,132 @@
+import { Effect, Either, Option, Record } from 'effect'
+import { make, makeStore, Store } from '../definition'
+import { AnyForm, FormField } from '../form/definition'
+
+export type FormState<Form extends AnyForm> = {
+  [K in keyof Form]: Form[K] extends FormField<infer A, infer I, infer E>
+    ? { value: I; error: E | null }
+    : Form[K] extends AnyForm
+      ? FormState<Form[K]>
+      : never
+}
+
+export type FormData<Form extends AnyForm> = {
+  [K in keyof Form]: Form[K] extends FormField<infer A, infer I, infer E>
+    ? A
+    : Form[K] extends AnyForm
+      ? FormData<Form[K]>
+      : never
+}
+
+export type FormError<Form extends AnyForm> = {
+  [K in keyof Form]: Form[K] extends FormField<infer A, infer I, infer E>
+    ? Option.Option<E>
+    : Form[K] extends AnyForm
+      ? FormError<Form[K]>
+      : never
+}
+
+export type FormActions<Form extends AnyForm> = {
+  [K in keyof Form]: Form[K] extends FormField<infer A, infer I, infer E>
+    ? {
+        set: (value: I) => void
+        update: (f: (previous: I) => I) => void
+        error: { set: (error: E | null) => void }
+      }
+    : Form[K] extends AnyForm
+      ? FormActions<Form[K]>
+      : never
+}
+
+const isField = (
+  value: AnyForm | FormField<any, any, any>,
+): value is FormField<any, any, any> => typeof value.validate === 'function'
+
+export const Form = <F extends AnyForm>(form: F) => {
+  const getInitialState = <F extends AnyForm>(form: F): FormState<F> =>
+    Record.map(form, _ =>
+      isField(_) ? { value: _.initial, error: null } : getInitialState(_),
+    ) as any
+  const getActions = <F extends AnyForm>(
+    form: F,
+    Store: Store<FormState<F>>,
+  ): FormActions<F> =>
+    Record.map(form, (_, key) =>
+      isField(_)
+        ? {
+            update: (f: (previous: any) => any) =>
+              Store.update(_ => ({
+                ..._,
+                [key]: { value: f(_[key]!.value), error: null },
+              })),
+            set: (value: any) =>
+              Store.update(_ => ({ ..._, [key]: { value, error: null } })),
+            error: {
+              set: (error: any) =>
+                Store.update(_ => ({ ..._, [key]: { value: _.value, error } })),
+            },
+          }
+        : getActions(
+            _,
+            makeStore({
+              get: () => Store.get()[key],
+              update: f => Store.update(_ => ({ ..._, [key]: f(_[key]) })),
+            }) as any,
+          ),
+    ) as any
+  const validate = <F extends AnyForm>(
+    form: F,
+    Store: Store<FormState<F>>,
+  ): any =>
+    Effect.all(
+      Record.map(form, (_, key) =>
+        isField(_)
+          ? _.validate(Store.get()[key]!.value).pipe(
+              Effect.either,
+              Effect.tap(e =>
+                Store.update(_ => ({
+                  ..._,
+                  [key]: {
+                    value: _[key]!.value,
+                    error: Option.getOrNull(Either.getLeft(e)),
+                  },
+                })),
+              ),
+              Effect.flatten,
+            )
+          : validate(
+              _,
+              makeStore({
+                get: () => Store.get()[key],
+                update: f => Store.update(_ => ({ ..._, [key]: f(_[key]) })),
+              }) as any,
+            ),
+      ),
+      { mode: 'validate' },
+    ) as any
+  return make<FormState<F>>()<
+    FormActions<F> & {
+      validate: () => Effect.Effect<FormData<F>, FormError<F>>
+      setStateFromData: (data: FormData<F>) => void
+    }
+  >({
+    initialState: getInitialState(form),
+    actions: ({ Store }) => ({
+      ...getActions(form, Store),
+      validate: () => validate(form, Store),
+      setStateFromData: (data: FormData<F>) =>
+        Store.update(() => {
+          const updateState = <F extends AnyForm>(
+            form: F,
+            data: FormData<F>,
+          ): any =>
+            Record.map(form, (_, key) =>
+              isField(_)
+                ? { value: _.fromData(data[key]), error: null }
+                : updateState(_, data[key]!),
+            )
+          return updateState(form, data)
+        }),
+    }),
+  })
+}

package/src/machines/index.ts

@@ -1,3 +1,4 @@
+export { Form } from './Form'
 export { FormValue } from './FormValue'
 export { of } from './of'
 export { Struct } from './Struct'