@matheuspuel/state-machine 0.1.0 → 0.2.2

package/package.json

@@ -1,12 +1,14 @@
 {
   "name": "@matheuspuel/state-machine",
-  "version": "0.1.0",
+  "version": "0.2.2",
   "type": "module",
   "module": "index.ts",
   "exports": {
     "./package.json": "./package.json",
     ".": "./src/index.ts",
-    "./mahcines": "./src/machines/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/StateMachine.ts

@@ -0,0 +1,3 @@
+export { make, StateMachine } from './definition'
+export * from './machines'
+export { Instance, run } from './runtime'

package/src/definition.ts

@@ -0,0 +1,49 @@
+import { Optic } from '@matheuspuel/optic'
+
+export type StoreBase<State> = {
+  get: () => State
+  update: (stateUpdate: (_: State) => State) => void
+}
+
+export type Store<State> = StoreBase<State> & {
+  zoom: <A, Optional extends boolean>(
+    f: (optic: Optic<State, State>) => Optic<A, State, Optional>,
+  ) => StoreBase<A>
+}
+
+export const makeStore = <State>(base: StoreBase<State>): Store<State> => ({
+  ...base,
+  zoom: zoomF => ({
+    get: () => (zoomF(Optic.id<State>()) as any).get(base.get()),
+    getOption: () => zoomF(Optic.id<State>()).getOption(base.get()),
+    update: f => base.update(zoomF(Optic.id<State>()).update(f)),
+  }),
+})
+
+export type StateAction<A extends unknown[], B> = (...args: A) => B
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type AnyStateAction = StateAction<any[], unknown>
+
+export type AnyStateActions = {
+  [key: string]: AnyStateAction | AnyStateActions
+}
+
+export type StateMachine<State, Actions extends AnyStateActions> = {
+  initialState: State
+  actions: (machine: { Store: Store<State> }) => Actions
+  start?: (machine: { Store: Store<State> }) => undefined | Promise<unknown>
+  onUpdate?: (state: State) => void | Promise<void>
+}
+
+export const make =
+  <State>() =>
+  <Actions extends AnyStateActions>(args: StateMachine<State, Actions>) =>
+    args
+
+export type PreparedStateActions<Actions extends AnyStateActions> = Actions
+
+export const prepareActions = <State, Actions extends AnyStateActions>(
+  machine: StateMachine<State, Actions>,
+  store: Store<State>,
+): PreparedStateActions<Actions> => machine.actions({ Store: store })

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/index.ts

@@ -1,54 +1 @@
-import { Optic } from '@matheuspuel/optic'
-
-export type MachineStoreBase<State> = {
-  get: () => State
-  update: (stateUpdate: (_: State) => State) => void
-}
-
-export type MachineStore<State> = MachineStoreBase<State> & {
-  zoom: <A, Optional extends boolean>(
-    f: (optic: Optic<State, State>) => Optic<A, State, Optional>,
-  ) => MachineStoreBase<A>
-}
-
-export const makeMachineStore = <State>(
-  base: MachineStoreBase<State>,
-): MachineStore<State> => ({
-  ...base,
-  zoom: zoomF => ({
-    get: () => (zoomF(Optic.id<State>()) as any).get(base.get()),
-    getOption: () => zoomF(Optic.id<State>()).getOption(base.get()),
-    update: f => base.update(zoomF(Optic.id<State>()).update(f)),
-  }),
-})
-
-export type StateAction<A extends unknown[], B> = (...args: A) => B
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type AnyStateAction = StateAction<any[], unknown>
-
-export type AnyStateActions = Record<string, AnyStateAction>
-
-export type StateMachine<State, Actions extends AnyStateActions> = {
-  initialState: State
-  actions: (machine: { Store: MachineStore<State> }) => Actions
-  start?: (machine: {
-    Store: MachineStore<State>
-  }) => undefined | Promise<unknown>
-  onUpdate?: (state: State) => void | Promise<void>
-}
-
-export const makeStateMachine =
-  <State>() =>
-  <Actions extends AnyStateActions>(args: StateMachine<State, Actions>) =>
-    args
-
-export type PreparedStateActions<Actions extends AnyStateActions> = Actions
-
-export const prepareStateMachineActions = <
-  State,
-  Actions extends AnyStateActions,
->(
-  machine: StateMachine<State, Actions>,
-  store: MachineStore<State>,
-): PreparedStateActions<Actions> => machine.actions({ Store: store })
+export * as StateMachine from './StateMachine'

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/FormValue.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, it } from '@effect/vitest'
+import { Effect } from 'effect'
+import { run } from '../runtime'
+import { FormValue } from './FormValue'
+
+describe('FormValue', () => {
+  it('should work', () => {
+    const machine = FormValue<number, string>(0)
+    const instance = run(machine)
+    const getState = () => instance.ref.get.pipe(Effect.runSync)
+    expect(getState()).toStrictEqual({ value: 0, error: null })
+    instance.actions.set(1)
+    expect(getState()).toStrictEqual({ value: 1, error: null })
+    instance.actions.error.set('a')
+    expect(getState()).toStrictEqual({ value: 1, error: 'a' })
+    instance.actions.set(2)
+    expect(getState()).toStrictEqual({ value: 2, error: null })
+  })
+})

package/src/machines/FormValue.ts

@@ -0,0 +1,17 @@
+import { make } from '../definition'
+
+export type FormValue<A, E> = { value: A; error: E | null }
+
+export const FormValue = <A, E>(initialValue: A) =>
+  make<FormValue<A, E>>()({
+    initialState: { value: initialValue, error: null },
+    actions: ({ Store }) => ({
+      update: (f: (previous: A) => A) =>
+        Store.update(_ => ({ value: f(_.value), error: null })),
+      set: (value: A) => Store.update(() => ({ value, error: null })),
+      error: {
+        set: (error: E | null) =>
+          Store.update(_ => ({ value: _.value, error })),
+      },
+    }),
+  })

package/src/machines/Struct.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, it } from '@effect/vitest'
+import { Effect } from 'effect'
+import { run } from '../runtime'
+import { Struct } from './Struct'
+import { of } from './of'
+
+describe('Struct', () => {
+  it('should work', () => {
+    const machine = Struct(
+      {
+        a: of(0),
+        b: of(''),
+      },
+      {
+        extraActions: ({ Store }) => ({
+          get: () => Store.get(),
+        }),
+      },
+    )
+    const instance = run(machine)
+    const getState = () => instance.ref.get.pipe(Effect.runSync)
+    expect(getState()).toStrictEqual({ a: 0, b: '' })
+    instance.actions.a.set(1)
+    expect(getState()).toStrictEqual({ a: 1, b: '' })
+    instance.actions.b.set('a')
+    expect(getState()).toStrictEqual({ a: 1, b: 'a' })
+    expect(instance.actions.get()).toStrictEqual({ a: 1, b: 'a' })
+  })
+})

package/src/machines/Struct.ts

@@ -0,0 +1,47 @@
+import { Record } from 'effect'
+import {
+  AnyStateActions,
+  make,
+  makeStore,
+  StateMachine,
+  Store,
+} from '../definition'
+
+export const Struct = <
+  A extends Record<string, StateMachine<any, AnyStateActions>>,
+  ExtraActions extends AnyStateActions = {},
+>(
+  fields: A,
+  options?: {
+    extraActions?: (machine: {
+      Store: Store<{
+        [K in keyof A]: A[K] extends StateMachine<infer State, any>
+          ? State
+          : never
+      }>
+    }) => ExtraActions
+  },
+) =>
+  make<{
+    [K in keyof A]: A[K] extends StateMachine<infer State, any> ? State : never
+  }>()<
+    {
+      [K in keyof A]: A[K] extends StateMachine<any, infer Actions>
+        ? Actions
+        : never
+    } & ExtraActions
+  >({
+    initialState: Record.map(fields, _ => _.initialState) as any,
+    actions: ({ Store }) => ({
+      ...(Record.map(fields, (_, key) =>
+        _.actions({
+          Store: makeStore({
+            get: () => Store.get()[key],
+            update: f => Store.update(_ => ({ ..._, [key]: f(_[key]) })),
+          }) as any,
+        }),
+      ) as any),
+      ...options?.extraActions?.({ Store }),
+    }),
+    // TODO implement other options
+  })

package/src/machines/index.ts

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

package/src/machines/of.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, it } from '@effect/vitest'
+import { Effect } from 'effect'
+import { run } from '../runtime'
+import { of } from './of'
+
+describe('of', () => {
+  it('should work', () => {
+    const machine = of('')
+    const instance = run(machine)
+    instance.actions.set('a')
+    const state = instance.ref.get.pipe(Effect.runSync)
+    expect(state).toStrictEqual('a')
+    const data = instance.actions.get()
+    expect(data).toStrictEqual('a')
+  })
+})

package/src/machines/of.ts

@@ -0,0 +1,11 @@
+import { make } from '../definition'
+
+export const of = <A>(initialState: A) =>
+  make<A>()({
+    initialState,
+    actions: ({ Store }) => ({
+      get: Store.get,
+      update: (f: (previous: A) => A) => Store.update(f),
+      set: (value: A) => Store.update(() => value),
+    }),
+  })

package/src/react/context.tsx

@@ -1,5 +1,9 @@
 import * as React from 'react'
-import { AnyStateActions, PreparedStateActions, StateMachine } from '..'
+import {
+  AnyStateActions,
+  PreparedStateActions,
+  StateMachine,
+} from '../definition'
 import { useStateMachine } from './useStateMachine'
 
 export const makeStateMachineContext = <State, Actions extends AnyStateActions>(

package/src/react/useSelector.ts

@@ -1,11 +1,11 @@
 import { Effect, Equal, Equivalence } from 'effect'
 import { useSyncExternalStoreWithSelector } from 'use-sync-external-store/with-selector'
-import { AnyStateActions } from '../index.js'
-import { RunningStateMachine } from '../runtime'
+import { AnyStateActions } from '../definition.js'
+import { Instance } from '../runtime'
 
 export const makeUseSelector =
   <State, Actions extends AnyStateActions>(
-    stateMachine: RunningStateMachine<State, Actions>,
+    stateMachine: Instance<State, Actions>,
   ) =>
   <A>(
     selector: (state: State) => A,

package/src/react/useStateMachine.ts

@@ -1,10 +1,10 @@
 import * as React from 'react'
 import {
   AnyStateActions,
-  makeMachineStore,
-  prepareStateMachineActions,
+  makeStore,
+  prepareActions,
   StateMachine,
-} from '..'
+} from '../definition'
 
 export const useStateMachine = <State, Actions extends AnyStateActions>(
   stateMachine:
@@ -18,7 +18,7 @@ export const useStateMachine = <State, Actions extends AnyStateActions>(
   const getState = React.useMemo(() => () => stateRef.current, [])
   const store = React.useMemo(
     () =>
-      makeMachineStore<State>({
+      makeStore<State>({
         get: getState,
         update: fn => {
           const previousState = getState()
@@ -31,7 +31,7 @@ export const useStateMachine = <State, Actions extends AnyStateActions>(
     [machine, getState],
   )
   const actions = React.useMemo(
-    () => prepareStateMachineActions(machine, store),
+    () => prepareActions(machine, store),
     [machine, store],
   )
   React.useEffect(() => {

package/src/runtime/index.ts

@@ -1,15 +1,15 @@
 import { Array, Effect, Ref } from 'effect'
 import {
   AnyStateActions,
-  makeMachineStore,
+  makeStore,
+  prepareActions,
   PreparedStateActions,
-  prepareStateMachineActions,
   StateMachine,
-} from '..'
+} from '../definition'
 
 type SubscriptionTask<State> = (state: State) => Effect.Effect<void>
 
-export type RunningStateMachine<State, Actions extends AnyStateActions> = {
+export type Instance<State, Actions extends AnyStateActions> = {
   ref: Ref.Ref<State>
   actions: PreparedStateActions<Actions>
   startPromise: Promise<unknown> | undefined
@@ -22,12 +22,12 @@ export type RunningStateMachine<State, Actions extends AnyStateActions> = {
   >
 }
 
-export const runStateMachine = <State, Actions extends AnyStateActions>(
+export const run = <State, Actions extends AnyStateActions>(
   machine: StateMachine<State, Actions>,
-): RunningStateMachine<State, Actions> => {
+): Instance<State, Actions> => {
   const subscriptionsRef = Ref.unsafeMake<SubscriptionTask<State>[]>([])
   const ref = Ref.unsafeMake(machine.initialState)
-  const store = makeMachineStore<State>({
+  const store = makeStore<State>({
     get: () => ref.get.pipe(Effect.runSync),
     update: fn =>
       Effect.gen(function* () {
@@ -40,7 +40,7 @@ export const runStateMachine = <State, Actions extends AnyStateActions>(
         void machine.onUpdate?.(state)
       }).pipe(Effect.runSync),
   })
-  const actions = prepareStateMachineActions(machine, store)
+  const actions = prepareActions(machine, store)
   const subscribe = (task: SubscriptionTask<State>) =>
     Effect.gen(function* () {
       yield* Ref.update(subscriptionsRef, Array.append(task))

package/src/machines/simple.ts

@@ -1,7 +0,0 @@
-import { makeStateMachine } from '..'
-
-export const simpleStateMachine = <A>(initialState: A) =>
-  makeStateMachine<A>()({
-    initialState,
-    actions: ({ Store }) => ({ set: (value: A) => Store.update(() => value) }),
-  })