@matheuspuel/state-machine 0.4.0 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matheuspuel/state-machine",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "type": "module",
   "files": [
     "/dist",
@@ -16,10 +16,6 @@
       "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"
@@ -33,15 +29,9 @@
       "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.2.0",
+    "@matheuspuel/query-state": "^0.2.0",
     "effect": "^3.18.1",
     "react": "19.1.0",
     "use-sync-external-store": "^1.5.0"
@@ -53,16 +43,27 @@
     "@types/node": "^25.0.8",
     "@types/react": "~19.1.17",
     "@types/use-sync-external-store": "^1.5.0",
-    "@typescript-eslint/parser": "^8.29.1",
+    "@typescript-eslint/eslint-plugin": "^8.55.0",
+    "@typescript-eslint/parser": "^8.55.0",
     "@vitest/coverage-v8": "^3.2.4",
     "cross-env": "^7.0.3",
     "eslint": "^8.57.1",
     "eslint-config-prettier": "^10.1.1",
     "eslint-plugin-prettier": "^5.2.6",
+    "eslint-plugin-react-hooks": "^7.0.1",
     "prettier": "^3.6.2",
     "tsx": "^4.20.6",
     "typescript": "^5.9.3",
     "vite": "^6.3.5",
     "vitest": "^3.2.4"
+  },
+  "scripts": {
+    "build": "tsc --project tsconfig.build.json",
+    "build:watch": "tsc --project tsconfig.build.json --watch",
+    "lint": "eslint . --max-warnings 0 --config .eslintrc.production.cjs",
+    "lint:fix": "eslint . --fix --config .eslintrc.production.cjs",
+    "typecheck": "tsc",
+    "test": "vitest",
+    "check": "pnpm build && pnpm typecheck && pnpm lint && pnpm test --run"
   }
-}
+}

package/src/definition.ts

@@ -36,6 +36,13 @@ export type StateMachine<State, Actions extends AnyStateActions> = {
   onUpdate?: (state: State) => void | Promise<void>
 }
 
+export type AnyStateMachineWithActions<Actions extends AnyStateActions> = {
+  initialState: any
+  actions: (machine: { Store: any }) => Actions
+  start?: (machine: { Store: any }) => undefined | Promise<unknown>
+  onUpdate?: (state: any) => void | Promise<void>
+}
+
 export const make =
   <State>() =>
   <Actions extends AnyStateActions>(args: StateMachine<State, Actions>) =>

package/src/index.ts

@@ -1 +1,3 @@
 export * as StateMachine from './StateMachine.js'
+
+export { Form } from './StateMachine.js'

package/src/machines/Form.test.ts

@@ -1,21 +1,20 @@
 import { describe, expect, it } from '@effect/vitest'
-import { StateMachine } from '@matheuspuel/state-machine'
-import { Form } from '@matheuspuel/state-machine/form'
+import { Form, StateMachine } from '@matheuspuel/state-machine'
 import { Effect } from 'effect'
+import { NoSuchElementException } from 'effect/Cause'
+import { ValidationError } from './Form.js'
 
 describe('Form', () => {
   it('should work', () => {
-    const formField = Form.field({
-      initial: 0,
+    const formField = Form.transformField(Form.field(0), {
       validate: _ =>
         _ > 1 ? Effect.succeed({ n: _ }) : Effect.fail('low' as const),
       fromData: (data: { n: number }) => data.n,
     })
-    const form = Form.Struct({
+    const machine = 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>>({
@@ -64,4 +63,122 @@ describe('Form', () => {
       b: { c: { value: 3, error: null } },
     })
   })
+
+  it('TaggedUnion', () => {
+    const stateMachine = Form.TaggedUnion('_tag', {
+      A: Form.Struct({ a: Form.field(0), x: Form.field('') }),
+      B: Form.Struct({ b: Form.field(0), x: Form.field('') }),
+    })
+    const form = StateMachine.run(stateMachine)
+    const getState = () => form.ref.get.pipe(Effect.runSync)
+
+    form.actions.A.a.set(1)
+    form.actions.A.x.set('a')
+    expect(getState()).toStrictEqual<ReturnType<typeof getState>>({
+      _tag: { value: 'A', error: null },
+      A: { a: { value: 1, error: null }, x: { value: 'a', error: null } },
+      B: { b: { value: 0, error: null }, x: { value: '', error: null } },
+    })
+    const dataA = form.actions.validate().pipe(Effect.runSync)
+    expect(dataA).toStrictEqual<typeof dataA>({
+      _tag: 'A',
+      a: 1,
+      x: 'a',
+    })
+    form.actions._tag.set('B')
+    const dataB = form.actions.validate().pipe(Effect.runSync)
+    expect(dataB).toStrictEqual<typeof dataB>({
+      _tag: 'B',
+      b: 0,
+      x: '',
+    })
+  })
+
+  it('Array', () => {
+    const stateMachine = Form.Struct({
+      list: Form.Array(Form.Struct({ a: Form.NonEmptyString })),
+    })
+    const form = StateMachine.run(stateMachine)
+    const getState = () => form.ref.get.pipe(Effect.runSync)
+
+    form.actions.validate().pipe(Effect.runSyncExit)
+    expect(getState()).toStrictEqual<ReturnType<typeof getState>>({
+      list: [],
+    })
+    form.actions.list.addItem()
+    expect(getState()).toStrictEqual<ReturnType<typeof getState>>({
+      list: [{ a: { value: '', error: null } }],
+    })
+    form.actions.validate().pipe(Effect.runSyncExit)
+    expect(getState()).toStrictEqual<ReturnType<typeof getState>>({
+      list: [{ a: { value: '', error: new NoSuchElementException() } }],
+    })
+    form.actions.list.index(0).a.set('aaa')
+    const data = form.actions.validate().pipe(Effect.runSync)
+    expect(getState()).toStrictEqual<ReturnType<typeof getState>>({
+      list: [{ a: { value: 'aaa', error: null } }],
+    })
+    expect(data).toStrictEqual<typeof data>({
+      list: [{ a: 'aaa' }],
+    })
+    form.actions.list.addItem()
+    form.actions.list.removeItem(0)
+    expect(getState()).toStrictEqual<ReturnType<typeof getState>>({
+      list: [{ a: { value: '', error: null } }],
+    })
+    form.actions.setStateFromData({ list: [{ a: '1' }, { a: '2' }] })
+    expect(getState()).toStrictEqual<ReturnType<typeof getState>>({
+      list: [
+        { a: { value: '1', error: null } },
+        { a: { value: '2', error: null } },
+      ],
+    })
+  })
+
+  it('change password example', () => {
+    const stateMachine = Form.Struct({
+      oldPassword: Form.field(''),
+      newPassword: StateMachine.mapActions(
+        Form.Struct({
+          password: Form.field(''),
+          confirmation: Form.fieldWithError<'not-match'>()(Form.field('')),
+        }),
+        actions => ({
+          ...actions,
+          validate: () =>
+            Effect.gen(function* () {
+              const result = yield* actions.validate()
+              if (result.password !== result.confirmation) {
+                actions.confirmation.error.set('not-match' as const)
+                return yield* new ValidationError({
+                  error: 'not-match' as const,
+                })
+              }
+              return result.password
+            }),
+          setStateFromData: (password: string) =>
+            actions.setStateFromData({ password, confirmation: password }),
+        }),
+      ),
+    })
+    const form = StateMachine.run(stateMachine)
+    const getState = () => form.ref.get.pipe(Effect.runSync)
+
+    form.actions.newPassword.password.set('123456')
+    form.actions.newPassword.confirmation.set('1234567')
+    form.actions.validate().pipe(Effect.runSyncExit)
+    expect(getState()).toStrictEqual<ReturnType<typeof getState>>({
+      oldPassword: { value: '', error: null },
+      newPassword: {
+        password: { value: '123456', error: null },
+        confirmation: { value: '1234567', error: 'not-match' },
+      },
+    })
+    form.actions.newPassword.confirmation.set('123456')
+    const data = form.actions.validate().pipe(Effect.runSync)
+    expect(data).toStrictEqual<typeof data>({
+      oldPassword: '',
+      newPassword: '123456',
+    })
+  })
 })