@matheuspuel/state-machine 0.2.0 → 0.3.0

package/package.json

@@ -1,24 +1,47 @@
 {
   "name": "@matheuspuel/state-machine",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "type": "module",
-  "module": "index.ts",
+  "files": [
+    "/dist",
+    "/src"
+  ],
   "exports": {
     "./package.json": "./package.json",
-    ".": "./src/index.ts",
-    "./definition": "./src/definition.ts",
-    "./machines": "./src/machines/index.ts",
-    "./react": "./src/react/index.ts",
-    "./runtime": "./src/runtime/index.ts"
+    ".": {
+      "types": "./dist/dts/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./definition": {
+      "types": "./dist/dts/definition.d.ts",
+      "default": "./dist/definition.js"
+    },
+    "./form": {
+      "types": "./dist/dts/form/index.d.ts",
+      "default": "./dist/form/index.js"
+    },
+    "./machines": {
+      "types": "./dist/dts/machines/index.d.ts",
+      "default": "./dist/machines/index.js"
+    },
+    "./react": {
+      "types": "./dist/dts/react/index.d.ts",
+      "default": "./dist/react/index.js"
+    },
+    "./runtime": {
+      "types": "./dist/dts/runtime/index.d.ts",
+      "default": "./dist/runtime/index.js"
+    }
   },
   "scripts": {
+    "build": "tsc -b tsconfig.build.json",
     "lint": "eslint . --max-warnings 0 --config .eslintrc.production.js",
     "lint:fix": "eslint . --fix --config .eslintrc.production.js",
     "typecheck": "tsc",
     "test": "vitest"
   },
   "dependencies": {
-    "@matheuspuel/optic": "^0.1.0",
+    "@matheuspuel/optic": "^0.2.0",
     "effect": "^3.18.1",
     "react": "19.1.0",
     "use-sync-external-store": "^1.5.0"
@@ -26,6 +49,8 @@
   "devDependencies": {
     "@effect/language-service": "^0.41.1",
     "@effect/vitest": "^0.26.0",
+    "@matheuspuel/state-machine": "file:.",
+    "@types/node": "^25.0.8",
     "@types/react": "~19.1.17",
     "@types/use-sync-external-store": "^1.5.0",
     "@typescript-eslint/parser": "^8.29.1",

package/src/StateMachine.ts

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

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.js'

package/src/index.ts

@@ -1 +1 @@
-export * as StateMachine from './StateMachine'
+export * as StateMachine from './StateMachine.js'

package/src/machines/Form.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, it } from '@effect/vitest'
+import { StateMachine } from '@matheuspuel/state-machine'
+import { Form } from '@matheuspuel/state-machine/form'
+import { Effect } from 'effect'
+
+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 = StateMachine.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.js'
+import { AnyForm, FormField } from '../form/definition.js'
+
+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

@@ -1,12 +1,11 @@
 import { describe, expect, it } from '@effect/vitest'
+import { StateMachine } from '@matheuspuel/state-machine'
 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 machine = StateMachine.FormValue<number, string>(0)
+    const instance = StateMachine.run(machine)
     const getState = () => instance.ref.get.pipe(Effect.runSync)
     expect(getState()).toStrictEqual({ value: 0, error: null })
     instance.actions.set(1)

package/src/machines/FormValue.ts

@@ -1,4 +1,4 @@
-import { make } from '../definition'
+import { make } from '../definition.js'
 
 export type FormValue<A, E> = { value: A; error: E | null }
 

package/src/machines/Struct.test.ts

@@ -1,23 +1,24 @@
 import { describe, expect, it } from '@effect/vitest'
-import { Effect } from 'effect'
-import { run } from '../runtime'
-import { Struct } from './Struct'
-import { of } from './of'
+import { StateMachine } from '@matheuspuel/state-machine'
+import { Effect, pipe } from 'effect'
 
 describe('Struct', () => {
   it('should work', () => {
-    const machine = Struct(
-      {
-        a: of(0),
-        b: of(''),
-      },
-      {
-        extraActions: ({ Store }) => ({
-          get: () => Store.get(),
+    const machine = pipe(
+      StateMachine.Struct({
+        a: StateMachine.of(0),
+        b: StateMachine.of(''),
+      }),
+      base =>
+        StateMachine.make<(typeof base)['initialState']>()({
+          ...base,
+          actions: ({ Store }) => ({
+            ...base.actions({ Store }),
+            get: () => Store.get(),
+          }),
         }),
-      },
     )
-    const instance = run(machine)
+    const instance = StateMachine.run(machine)
     const getState = () => instance.ref.get.pipe(Effect.runSync)
     expect(getState()).toStrictEqual({ a: 0, b: '' })
     instance.actions.a.set(1)

package/src/machines/Struct.ts

@@ -4,33 +4,20 @@ import {
   make,
   makeStore,
   StateMachine,
-  Store,
-} from '../definition'
+} from '../definition.js'
 
 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
-  >({
+  }>()<{
+    [K in keyof A]: A[K] extends StateMachine<any, infer Actions>
+      ? Actions
+      : never
+  }>({
     initialState: Record.map(fields, _ => _.initialState) as any,
     actions: ({ Store }) => ({
       ...(Record.map(fields, (_, key) =>
@@ -41,7 +28,6 @@ export const Struct = <
           }) as any,
         }),
       ) as any),
-      ...options?.extraActions?.({ Store }),
     }),
     // TODO implement other options
   })

package/src/machines/index.ts

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

package/src/machines/of.test.ts

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

package/src/machines/of.ts

@@ -1,4 +1,4 @@
-import { make } from '../definition'
+import { make } from '../definition.js'
 
 export const of = <A>(initialState: A) =>
   make<A>()({

package/src/react/context.tsx

@@ -3,8 +3,8 @@ import {
   AnyStateActions,
   PreparedStateActions,
   StateMachine,
-} from '../definition'
-import { useStateMachine } from './useStateMachine'
+} from '../definition.js'
+import { useStateMachine } from './useStateMachine.js'
 
 export const makeStateMachineContext = <State, Actions extends AnyStateActions>(
   machine: StateMachine<State, Actions>,

package/src/react/index.ts

@@ -1,3 +1,3 @@
-export * from './context'
-export * from './useSelector'
-export * from './useStateMachine'
+export * from './context.js'
+export * from './useSelector.js'
+export * from './useStateMachine.js'

package/src/react/useSelector.ts

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

package/src/react/useStateMachine.ts

@@ -4,7 +4,7 @@ import {
   makeStore,
   prepareActions,
   StateMachine,
-} from '../definition'
+} from '../definition.js'
 
 export const useStateMachine = <State, Actions extends AnyStateActions>(
   stateMachine:

package/src/runtime/index.ts

@@ -5,7 +5,7 @@ import {
   prepareActions,
   PreparedStateActions,
   StateMachine,
-} from '../definition'
+} from '../definition.js'
 
 type SubscriptionTask<State> = (state: State) => Effect.Effect<void>
 

package/.eslintrc.js

@@ -1,34 +0,0 @@
-module.exports = {
-  extends: [
-    'eslint:recommended',
-    'plugin:@typescript-eslint/recommended',
-    'plugin:@typescript-eslint/recommended-requiring-type-checking',
-    'plugin:@typescript-eslint/strict',
-  ],
-  parserOptions: {
-    tsconfigRootDir: __dirname,
-    project: ['./tsconfig.json'],
-    ecmaVersion: 'latest',
-    sourceType: 'module',
-  },
-  ignorePatterns: [
-    '/.vscode/*',
-    '/coverage/*',
-    '/dist/*',
-    '/experiments/*',
-    '/node_modules/*',
-    '.eslintrc.js',
-    '.eslintrc.production.js',
-  ],
-  rules: {
-    // already checked by typescript
-    '@typescript-eslint/no-redeclare': 'off',
-    // warn instead of error
-    '@typescript-eslint/no-unused-vars': 'warn',
-    // allow namespace declaration for types
-    '@typescript-eslint/no-namespace': ['error', { allowDeclarations: true }],
-    // warn instead of error to prevent covering more specific errors
-    '@typescript-eslint/no-unsafe-return': 'warn',
-    '@typescript-eslint/no-unsafe-call': 'warn',
-  },
-}

package/.eslintrc.production.js

@@ -1,11 +0,0 @@
-const base = require('./.eslintrc.js')
-
-module.exports = {
-  ...base,
-  extends: [...base.extends, 'prettier'],
-  plugins: [...(base.plugins ?? []), 'prettier'],
-  rules: {
-    ...base.rules,
-    'prettier/prettier': ['warn'],
-  },
-}

package/.prettierrc

@@ -1,9 +0,0 @@
-{
-  "semi": false,
-  "trailingComma": "all",
-  "arrowParens": "avoid",
-  "singleQuote": true,
-  "printWidth": 80,
-  "tabWidth": 2,
-  "endOfLine": "lf"
-}

package/pnpm-workspace.yaml

@@ -1,2 +0,0 @@
-onlyBuiltDependencies:
-  - esbuild

package/tsconfig.json

@@ -1,14 +0,0 @@
-{
-  "compilerOptions": {
-    "noEmit": true,
-    "skipLibCheck": true,
-    "moduleResolution": "bundler",
-    "target": "ESNext",
-    "jsx": "preserve",
-    "strict": true,
-    "noUncheckedIndexedAccess": true,
-    "noFallthroughCasesInSwitch": true,
-    "plugins": [{ "name": "@effect/language-service" }]
-  },
-  "include": ["**/*.ts", "**/*.tsx"]
-}

package/vitest.config.ts

@@ -1,5 +0,0 @@
-import { defineConfig } from 'vitest/config'
-
-export default defineConfig({
-  test: {},
-})