@matheuspuel/state-machine 0.6.0 → 0.7.1

package/dist/machines/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/machines/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AACjC,OAAO,EAAE,EAAE,EAAE,MAAM,SAAS,CAAA;AAC5B,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AACzD,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/machines/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,OAAO,KAAK,IAAI,MAAM,iBAAiB,CAAA;AACvC,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA"}

package/dist/machines/index.test copy.js

@@ -0,0 +1,37 @@
+import { describe, expect, it } from '@effect/vitest';
+import { StateMachine } from '@matheuspuel/state-machine';
+import { Effect, pipe } from 'effect';
+describe('of', () => {
+    it('should work', () => {
+        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');
+        const data = instance.actions.get();
+        expect(data).toStrictEqual('a');
+    });
+});
+describe('Struct', () => {
+    it('should work', () => {
+        const machine = pipe(StateMachine.Struct({
+            a: StateMachine.of(0),
+            b: StateMachine.of(''),
+        }), base => StateMachine.make()({
+            ...base,
+            actions: ({ Store }) => ({
+                ...base.actions({ Store }),
+                get: () => Store.get(),
+            }),
+        }));
+        const instance = StateMachine.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' });
+    });
+});
+//# sourceMappingURL=index.test%20copy.js.map

package/dist/machines/index.test copy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test copy.js","sourceRoot":"","sources":["../../src/machines/index.test copy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAA;AACrD,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AACzD,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAErC,QAAQ,CAAC,IAAI,EAAE,GAAG,EAAE;IAClB,EAAE,CAAC,aAAa,EAAE,GAAG,EAAE;QACrB,MAAM,OAAO,GAAG,YAAY,CAAC,EAAE,CAAC,EAAE,CAAC,CAAA;QACnC,MAAM,QAAQ,GAAG,YAAY,CAAC,GAAG,CAAC,OAAO,CAAC,CAAA;QAC1C,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;QACzB,MAAM,KAAK,GAAG,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAA;QACnD,MAAM,CAAC,KAAK,CAAC,CAAC,aAAa,CAAC,GAAG,CAAC,CAAA;QAChC,MAAM,IAAI,GAAG,QAAQ,CAAC,OAAO,CAAC,GAAG,EAAE,CAAA;QACnC,MAAM,CAAC,IAAI,CAAC,CAAC,aAAa,CAAC,GAAG,CAAC,CAAA;IACjC,CAAC,CAAC,CAAA;AACJ,CAAC,CAAC,CAAA;AAEF,QAAQ,CAAC,QAAQ,EAAE,GAAG,EAAE;IACtB,EAAE,CAAC,aAAa,EAAE,GAAG,EAAE;QACrB,MAAM,OAAO,GAAG,IAAI,CAClB,YAAY,CAAC,MAAM,CAAC;YAClB,CAAC,EAAE,YAAY,CAAC,EAAE,CAAC,CAAC,CAAC;YACrB,CAAC,EAAE,YAAY,CAAC,EAAE,CAAC,EAAE,CAAC;SACvB,CAAC,EACF,IAAI,CAAC,EAAE,CACL,YAAY,CAAC,IAAI,EAAiC,CAAC;YACjD,GAAG,IAAI;YACP,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,CAAC;gBACvB,GAAG,IAAI,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,CAAC;gBAC1B,GAAG,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE;aACvB,CAAC;SACH,CAAC,CACL,CAAA;QACD,MAAM,QAAQ,GAAG,YAAY,CAAC,GAAG,CAAC,OAAO,CAAC,CAAA;QAC1C,MAAM,QAAQ,GAAG,GAAG,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAA;QAC5D,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC,aAAa,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,CAAA;QACjD,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAA;QACzB,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC,aAAa,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,CAAA;QACjD,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;QAC3B,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC,aAAa,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,CAAA;QAClD,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC,aAAa,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,CAAA;IAChE,CAAC,CAAC,CAAA;AACJ,CAAC,CAAC,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matheuspuel/state-machine",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "type": "module",
   "files": [
     "/dist",
@@ -12,50 +12,38 @@
       "types": "./dist/dts/index.d.ts",
       "default": "./dist/index.js"
     },
-    "./definition": {
-      "types": "./dist/dts/definition.d.ts",
-      "default": "./dist/definition.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"
     }
   },
   "dependencies": {
-    "@matheuspuel/optic": "^0.2.0",
-    "@matheuspuel/query-state": "^0.2.0",
-    "effect": "^3.18.1",
+    "@matheuspuel/optic": "^0.3.0",
+    "@matheuspuel/query-state": "^0.3.0",
+    "effect": "^3.19.16",
     "react": "19.1.0",
     "use-sync-external-store": "^1.5.0"
   },
   "devDependencies": {
-    "@effect/language-service": "^0.41.1",
-    "@effect/vitest": "^0.26.0",
+    "@effect/language-service": "^0.73.1",
+    "@effect/vitest": "^0.27.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/eslint-plugin": "^8.55.0",
     "@typescript-eslint/parser": "^8.55.0",
-    "@vitest/coverage-v8": "^3.2.4",
+    "@vitest/coverage-v8": "^4.0.18",
     "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",
+    "prettier": "^3.8.1",
+    "tsx": "^4.21.0",
     "typescript": "^5.9.3",
-    "vite": "^6.3.5",
-    "vitest": "^3.2.4"
+    "vite": "^7.3.1",
+    "vitest": "^4.0.18"
   },
   "scripts": {
     "build": "tsc --project tsconfig.build.json",
@@ -64,6 +52,7 @@
     "lint:fix": "eslint . --fix --config .eslintrc.production.cjs",
     "typecheck": "tsc",
     "test": "vitest",
-    "check": "pnpm build && pnpm typecheck && pnpm lint && pnpm test --run"
+    "check": "pnpm build && pnpm typecheck && pnpm lint && pnpm test --run",
+    "upload": "pnpm check && pnpm publish"
   }
 }

package/src/definition.ts

@@ -43,10 +43,14 @@ export type AnyStateMachineWithActions<Actions extends AnyStateActions> = {
   onUpdate?: (state: any) => void | Promise<void>
 }
 
-export const make =
-  <State>() =>
-  <Actions extends AnyStateActions>(args: StateMachine<State, Actions>) =>
-    args
+export const make = <State, Actions extends AnyStateActions>(
+  args: StateMachine<State, Actions>,
+) => args
+
+export const withState = <State>() => ({
+  make: <Actions extends AnyStateActions>(args: StateMachine<State, Actions>) =>
+    args,
+})
 
 export type PreparedStateActions<Actions extends AnyStateActions> = Actions
 
@@ -63,7 +67,7 @@ export const mapActions = <
   self: StateMachine<State, Actions>,
   f: (actions: Actions, machine: { Store: Store<State> }) => NextActions,
 ): StateMachine<State, NextActions> =>
-  make<State>()({
+  make({
     ...self,
     actions: machine => ({ ...f(self.actions(machine), machine) }),
   })

package/src/machines/Form/Error.ts

@@ -0,0 +1,5 @@
+import { Data } from 'effect'
+
+export class ValidationError<E> extends Data.TaggedError(
+  'FormValidationError',
+)<{ error: E }> {}

package/src/machines/Form/Field/index.ts

@@ -0,0 +1,243 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+
+import { Effect, Either, flow, Option, pipe, Schema } from 'effect'
+import { NoSuchElementException } from 'effect/Cause'
+import { ParseError } from 'effect/ParseResult'
+import * as StateMachine from '../../../definition.js'
+import { ValidationError } from '../Error.js'
+
+type FormFieldBase<A, I, E> = StateMachine.StateMachine<
+  { value: I; error: E | null },
+  {
+    set: (value: I) => void
+    update: (f: (previous: I) => I) => void
+    error: { set: (error: E | null) => void }
+    validate: () => Effect.Effect<A, ValidationError<E>>
+    check: () => Promise<Either.Either<A, ValidationError<E>>>
+    setStateFromData: (data: A) => void
+  }
+>
+
+export type FormField<A, I, E> = FormFieldBase<A, I, E> & {
+  withError: <E2>() => FormField<A, I, E2 | E>
+  parse: {
+    <A2 extends A, E2>(
+      to: (value: NoInfer<A>) => Effect.Effect<A2, E2>,
+    ): FormField<A2, I, E2 | E>
+    <A2, E2>(args: {
+      to: (value: NoInfer<A>) => Effect.Effect<A2, E2>
+      from: (data: A2) => NoInfer<A>
+    }): FormField<A2, I, E2 | E>
+  }
+  transform: {
+    <A2 extends A>(to: (value: NoInfer<A>) => A2): FormField<A2, I, E>
+    <A2>(args: {
+      to: (value: NoInfer<A>) => A2
+      from: (data: A2) => NoInfer<A>
+    }): FormField<A2, I, E>
+    <A2>(schema: Schema.Schema<A2, A>): FormField<A2, I, E | ParseError>
+    <A2, E2>(
+      schema: Schema.Schema<A2, A>,
+      makeError: (error: ParseError) => E2,
+    ): FormField<A2, I, E | E2>
+  }
+  filter: {
+    <A2 extends A, E2>(
+      refinement: (value: A) => value is A2,
+      onFail: (value: A) => E2,
+    ): FormField<A2, I, E | E2>
+    <E2>(
+      predicate: (value: A) => boolean,
+      onFail: (value: A) => E2,
+    ): FormField<A, I, E | E2>
+  }
+  required: () => FormField<NonNullable<A>, I, E | NoSuchElementException>
+}
+
+export type AnyFormField = FormField<any, any, any>
+
+const addExtraProperties = <A, I, E>(
+  self: FormFieldBase<A, I, E>,
+): FormField<A, I, E> => {
+  const withError = <E2>(): FormField<A, I, E2 | E> =>
+    self as FormField<A, I, E2 | E>
+
+  const parse: FormField<A, I, E>['parse'] = <A2, E2>(
+    args:
+      | ((value: NoInfer<A>) => Effect.Effect<A2, E2>)
+      | {
+          to: (value: NoInfer<A>) => Effect.Effect<A2, E2>
+          from: (data: A2) => NoInfer<A>
+        },
+  ): FormField<A2, I, E2 | E> => {
+    const to = typeof args === 'function' ? args : args.to
+    const from =
+      typeof args === 'function' ? (_: A2) => _ as unknown as A : args.from
+    return addExtraProperties<A2, I, E2 | E>(
+      StateMachine.mapActions(withError<E2>(), (actions, { Store }) => {
+        const validate = (): Effect.Effect<
+          A2,
+          ValidationError<E2 | E>,
+          never
+        > =>
+          actions.validate().pipe(
+            Effect.flatMap(
+              flow(
+                to,
+                Effect.tap(() =>
+                  Effect.sync(() =>
+                    Store.update(_ => ({ value: _.value, error: null })),
+                  ),
+                ),
+                Effect.tapError(error =>
+                  Effect.sync(() =>
+                    Store.update(_ => ({ value: _.value, error })),
+                  ),
+                ),
+                Effect.mapError(error => new ValidationError({ error })),
+              ),
+            ),
+          )
+        return {
+          ...actions,
+          validate,
+          check: () => validate().pipe(Effect.either, Effect.runPromise),
+          setStateFromData: data => actions.setStateFromData(from(data)),
+        }
+      }),
+    )
+  }
+
+  const transform: FormField<A, I, E>['transform'] = <A2, E2>(
+    args:
+      | ((value: NoInfer<A>) => A2)
+      | {
+          to: (value: NoInfer<A>) => A2
+          from: (data: A2) => NoInfer<A>
+        }
+      | Schema.Schema<A2, A>,
+    makeError?: (error: ParseError) => E2,
+  ): FormField<A2, I, any> => {
+    if (Schema.isSchema(args)) {
+      const schema = args as Schema.Schema<A2, A>
+      return parse({
+        to: value =>
+          Effect.mapError(Schema.decode(schema)(value), parseError =>
+            (makeError ?? (_ => _))(parseError),
+          ),
+        from: Schema.encodeSync(schema),
+      })
+    } else if (typeof args === 'function') {
+      const to = args
+      return parse({
+        to: _ => Effect.succeed(to(_)),
+        from: (_: A2) => _ as unknown as A,
+      })
+    } else if ('to' in args) {
+      const { to, from } = args
+      return parse({
+        to: _ => Effect.succeed(to(_)),
+        from: from,
+      })
+    } else {
+      throw new Error('Invalid arguments')
+    }
+  }
+
+  const filter: FormField<A, I, E>['filter'] = <A2 extends A, E2>(
+    predicate: ((value: A) => value is A2) | ((value: A) => boolean),
+    onFail: (value: A) => E2,
+  ) =>
+    parse(value =>
+      predicate(value) ? Effect.succeed(value) : Effect.fail(onFail(value)),
+    )
+
+  return {
+    ...self,
+    withError,
+    parse,
+    transform,
+    filter,
+    required: () => parse(Option.fromNullable),
+  }
+}
+
+export const make = <A, I, E>(args: {
+  initial: I
+  validate: (value: I) => Effect.Effect<A, E>
+  fromData: (data: A) => I
+}): FormField<A, I, E> =>
+  addExtraProperties(
+    StateMachine.withState<{ value: I; error: E | null }>().make({
+      initialState: { value: args.initial, error: null },
+      actions: ({ Store }) => {
+        const validate = () =>
+          pipe(
+            Store.get().value,
+            args.validate,
+            Effect.tap(() =>
+              Effect.sync(() =>
+                Store.update(_ => ({ value: _.value, error: null })),
+              ),
+            ),
+            Effect.tapError(error =>
+              Effect.sync(() => Store.update(_ => ({ value: _.value, error }))),
+            ),
+            Effect.mapError(error => new ValidationError({ error })),
+          )
+        return {
+          set: value => Store.update(() => ({ value, error: null })),
+          update: f => Store.update(_ => ({ value: f(_.value), error: null })),
+          error: {
+            set: error => Store.update(_ => ({ value: _.value, error })),
+          },
+          validate,
+          check: () => validate().pipe(Effect.either, Effect.runPromise),
+          setStateFromData: data =>
+            Store.update(_ => ({
+              ..._,
+              value: args.fromData(data),
+              error: null,
+            })),
+        }
+      },
+    }),
+  )
+
+export const of = <A>(initial: A): FormField<A, A, never> =>
+  make<A, A, never>({
+    initial: initial,
+    validate: _ => Effect.succeed(_),
+    fromData: _ => _,
+  })
+
+export const nullOr = <A>(initial?: A | null) => of<A | null>(initial ?? null)
+
+// eslint-disable-next-line @typescript-eslint/no-duplicate-type-constituents
+export const undefinedOr = <A>(initial?: A | undefined) =>
+  of<A | undefined>(initial)
+
+export const String = of('')
+
+export const TrimString = String.transform(_ => _.trim())
+
+export const TrimStringOrNull = TrimString.transform({
+  to: _ => _ || null,
+  from: _ => _ ?? '',
+})
+
+export const TrimStringOrUndefined = TrimString.transform({
+  to: _ => _ || undefined,
+  from: _ => _ ?? '',
+})
+
+export const NonEmptyString = String.parse({
+  to: _ => Schema.decodeOption(Schema.NonEmptyString)(_),
+  from: _ => _,
+})
+
+export const TrimNonEmptyString = String.parse({
+  to: _ =>
+    Schema.decodeOption(Schema.compose(Schema.Trim, Schema.NonEmptyString))(_),
+  from: _ => _,
+})

package/src/machines/{Form.test.ts → Form/index.test.ts}

@@ -2,14 +2,13 @@ import { describe, expect, it } from '@effect/vitest'
 import { Form, StateMachine } from '@matheuspuel/state-machine'
 import { Effect } from 'effect'
 import { NoSuchElementException } from 'effect/Cause'
-import { ValidationError } from './Form.js'
+import { ValidationError } from './index.js'
 
 describe('Form', () => {
   it('should work', () => {
-    const formField = Form.transformField(Form.field(0), {
-      validate: _ =>
-        _ > 1 ? Effect.succeed({ n: _ }) : Effect.fail('low' as const),
-      fromData: (data: { n: number }) => data.n,
+    const formField = Form.Field.of(0).parse({
+      to: _ => (_ > 1 ? Effect.succeed({ n: _ }) : Effect.fail('low' as const)),
+      from: (data: { n: number }) => data.n,
     })
     const machine = Form.Struct({
       a: formField,
@@ -66,8 +65,8 @@ describe('Form', () => {
 
   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('') }),
+      A: Form.Struct({ a: Form.Field.of(0), x: Form.Field.of('') }),
+      B: Form.Struct({ b: Form.Field.of(0), x: Form.Field.of('') }),
     })
     const form = StateMachine.run(stateMachine)
     const getState = () => form.ref.get.pipe(Effect.runSync)
@@ -96,7 +95,7 @@ describe('Form', () => {
 
   it('Array', () => {
     const stateMachine = Form.Struct({
-      list: Form.Array(Form.Struct({ a: Form.NonEmptyString })),
+      list: Form.Array(Form.Struct({ a: Form.Field.NonEmptyString })),
     })
     const form = StateMachine.run(stateMachine)
     const getState = () => form.ref.get.pipe(Effect.runSync)
@@ -137,11 +136,11 @@ describe('Form', () => {
 
   it('change password example', () => {
     const stateMachine = Form.Struct({
-      oldPassword: Form.field(''),
+      oldPassword: Form.Field.of(''),
       newPassword: StateMachine.mapActions(
         Form.Struct({
-          password: Form.field(''),
-          confirmation: Form.fieldWithError<'not-match'>()(Form.field('')),
+          password: Form.Field.of(''),
+          confirmation: Form.Field.of('').withError<'not-match'>(),
         }),
         actions => ({
           ...actions,

package/src/machines/{Form.ts → Form/index.ts}

@@ -1,141 +1,17 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 
-import {
-  Data,
-  Effect,
-  Either,
-  flow,
-  Option,
-  pipe,
-  Record,
-  Schema,
-} from 'effect'
-import { ParseError } from 'effect/ParseResult'
+import { Effect, Either, Option, pipe, Record } from 'effect'
 import {
   AnyStateMachineWithActions,
-  make,
   mapActions,
   StateMachine,
-} from '../definition.js'
-import { Struct as StateMachineStruct } from '../machines/Struct.js'
-
-export class ValidationError<E> extends Data.TaggedError(
-  'FormValidationError',
-)<{
-  error: E
-}> {}
-
-export type FormField<A, I, E> = StateMachine<
-  { value: I; error: E | null },
-  {
-    set: (value: I) => void
-    update: (f: (previous: I) => I) => void
-    error: { set: (error: E | null) => void }
-    validate: () => Effect.Effect<A, ValidationError<E>>
-    check: () => Promise<Either.Either<A, ValidationError<E>>>
-    setStateFromData: (data: A) => void
-  }
->
-
-export type AnyFormField = FormField<any, any, any>
-
-export const makeField = <A, I, E>(args: {
-  initial: I
-  validate: (value: I) => Effect.Effect<A, E>
-  fromData: (data: A) => I
-}): FormField<A, I, E> =>
-  make<{ value: I; error: E | null }>()({
-    initialState: { value: args.initial, error: null },
-    actions: ({ Store }) => {
-      const validate = () =>
-        pipe(
-          Store.get().value,
-          args.validate,
-          Effect.tap(() =>
-            Effect.sync(() =>
-              Store.update(_ => ({ value: _.value, error: null })),
-            ),
-          ),
-          Effect.tapError(error =>
-            Effect.sync(() => Store.update(_ => ({ value: _.value, error }))),
-          ),
-          Effect.mapError(error => new ValidationError({ error })),
-        )
-      return {
-        set: value => Store.update(() => ({ value, error: null })),
-        update: f => Store.update(_ => ({ value: f(_.value), error: null })),
-        error: { set: error => Store.update(_ => ({ value: _.value, error })) },
-        validate,
-        check: () => validate().pipe(Effect.either, Effect.runPromise),
-        setStateFromData: data =>
-          Store.update(_ => ({
-            ..._,
-            value: args.fromData(data),
-            error: null,
-          })),
-      }
-    },
-  })
+  withState,
+} from '../../definition.js'
+import { Struct as StateMachineStruct } from '../../machines/basic.js'
+import { ValidationError } from './Error.js'
 
-export const field = <A>(initial: A): FormField<A, A, never> =>
-  makeField<A, A, never>({
-    initial: initial,
-    validate: _ => Effect.succeed(_),
-    fromData: _ => _,
-  })
-
-export const fieldWithError =
-  <E>() =>
-  <A, I, E1>(self: FormField<A, I, E1>): FormField<A, I, E | E1> =>
-    self as FormField<A, I, E | E1>
-
-export const transformField = <A, A1, I, E, E1>(
-  self: FormField<A1, I, E1>,
-  args: {
-    validate: (value: NoInfer<A1>) => Effect.Effect<A, E>
-    fromData: (data: A) => NoInfer<A1>
-  },
-): FormField<A, I, E | E1> =>
-  mapActions(fieldWithError<E>()(self), (actions, { Store }) => {
-    const validate = (): Effect.Effect<A, ValidationError<E | E1>, never> =>
-      actions.validate().pipe(
-        Effect.flatMap(
-          flow(
-            args.validate,
-            Effect.tap(() =>
-              Effect.sync(() =>
-                Store.update(_ => ({ value: _.value, error: null })),
-              ),
-            ),
-            Effect.tapError(error =>
-              Effect.sync(() => Store.update(_ => ({ value: _.value, error }))),
-            ),
-            Effect.mapError(error => new ValidationError({ error })),
-          ),
-        ),
-      )
-    return {
-      ...actions,
-      validate,
-      check: () => validate().pipe(Effect.either, Effect.runPromise),
-      setStateFromData: data => actions.setStateFromData(args.fromData(data)),
-    }
-  })
-
-export const transformFieldSchema = <A, A1, I, E1>(
-  self: FormField<A1, I, E1>,
-  schema: Schema.Schema<A, A1>,
-): FormField<A, I, E1 | ParseError> =>
-  transformField(self, {
-    validate: Schema.decode(schema),
-    fromData: Schema.encodeSync(schema),
-  })
-
-export const validateField = <A1, A extends A1, I, E, E1>(
-  self: FormField<A1, I, E1>,
-  validate: (value: NoInfer<A1>) => Effect.Effect<A, E>,
-): FormField<A, I, E | E1> =>
-  transformField(self, { validate, fromData: _ => _ })
+export * from './Error.js'
+export * as Field from './Field/index.js'
 
 export const Struct = <
   Fields extends Record<
@@ -296,7 +172,7 @@ export const TaggedUnion = <
   }
 
   return mapActions(
-    make<InternalState>()({
+    withState<InternalState>().make({
       initialState: {
         [tagKey]: { value: initialTag, error: null },
         ...Object.fromEntries(
@@ -410,7 +286,7 @@ export const Array = <
     Item extends StateMachine<infer State, infer Actions> ? State : never
   type ItemActions =
     Item extends StateMachine<infer State, infer Actions> ? Actions : never
-  return make<ReadonlyArray<ItemState>>()({
+  return withState<ReadonlyArray<ItemState>>().make({
     initialState: [],
     actions: ({ Store }) => {
       const getItemActions = (index: number): ItemActions =>
@@ -452,16 +328,3 @@ export const Array = <
     },
   }) as any
 }
-
-export const String = field('')
-
-export const NonEmptyString = transformField(String, {
-  validate: _ => Schema.decodeOption(Schema.NonEmptyString)(_),
-  fromData: _ => _,
-})
-
-export const TrimNonEmptyString = transformField(String, {
-  validate: _ =>
-    Schema.decodeOption(Schema.compose(Schema.Trim, Schema.NonEmptyString))(_),
-  fromData: _ => _,
-})

package/src/machines/QueryState.ts

@@ -1,7 +1,7 @@
 import { QueryState as QueryState_ } from '@matheuspuel/query-state'
 import { DateTime, Effect, pipe, Schedule } from 'effect'
 import { make, mapActions, StateMachine } from '../definition.js'
-import { of } from './of.js'
+import { of } from './basic.js'
 
 export const QueryState = <A, E, P = undefined>() =>
   mapActions(of(QueryState_.initial<A, E, P>()), actions => ({
@@ -77,7 +77,7 @@ export const trackEffect: {
     _ =>
       options?.runOnStart
         ? pipe(options.runOnStart, options =>
-            make<typeof _.initialState>()({
+            make({
               ..._,
               start: machine =>
                 _.actions(machine)