@reaxon/hook-form-effector 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dovran Jorayev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,91 @@
+# @reaxon/hook-form-effector
+
+[Effector](https://effector.dev) bindings for
+[react-hook-form](https://react-hook-form.com)'s headless `createFormControl`.
+Form logic (fields, validation, submit) stays in react-hook-form; this package
+lets Effector models read derived form state and drive the control with
+effects, scope-safe.
+
+```sh
+pnpm add @reaxon/hook-form-effector effector react-hook-form
+```
+
+## API
+
+### `formState({ form, setup, teardown? })`
+
+Mirrors a form control into a store of `{ values, ...FormState }`. `setup`
+starts the subscription (fire it under a scope, e.g. on dialog open);
+`teardown` stops it. The store is seeded on attach, so a `reset` that ran in
+the same wave as `setup` is never missed.
+
+```ts
+import { createEvent, fork, allSettled } from 'effector';
+import { createFormControl } from 'react-hook-form';
+import { formState } from '@reaxon/hook-form-effector';
+
+const form = createFormControl<{ name: string }>({ defaultValues: { name: '' } });
+const opened = createEvent();
+const $form = formState({ form, setup: opened });
+
+const scope = fork();
+await allSettled(opened, { scope });
+scope.getState($form).values.name; // ''
+```
+
+### Effect factories over the control
+
+- `formResetApi(form, emptyValues)` — `form.reset(emptyValues)`; pins the
+  pristine values because RHF's `reset(values)` replaces `defaultValues`.
+- `formPrefillApi(form)` — `form.reset(payload)`, e.g. an edit prefill.
+- `formSetApi(form)` — `form.setValue(name, value, options)`.
+- `formSetErrorApi(form)` — `form.setError(name, error, options)` for each
+  entry of a `FormFieldError[]` payload, e.g. to attach a server's field
+  errors after a failed submit.
+
+Each accepts either a form control or a `Store` holding one.
+
+## Effector plugin setup (SSR / `fork`)
+
+Every export of this package is a factory: it creates stores, events and
+effects on each call. For those units to get stable SIDs, which `fork` and
+`serialize` need for SSR and for hydration, list the package in the
+`factories` option of the Effector compiler plugin. Client-only apps that
+never serialize a scope can skip this.
+
+Babel (`effector/babel-plugin`):
+
+```json
+{
+  "plugins": [
+    ["effector/babel-plugin", { "factories": ["@reaxon/hook-form-effector"] }]
+  ]
+}
+```
+
+SWC (`@effector/swc-plugin`), e.g. in `.swcrc` or Next.js `experimental.swcPlugins`:
+
+```json
+["@effector/swc-plugin", { "factories": ["@reaxon/hook-form-effector"] }]
+```
+
+Vite with `@vitejs/plugin-react`:
+
+```ts
+react({
+  babel: {
+    plugins: [
+      ["effector/babel-plugin", { factories: ["@reaxon/hook-form-effector"] }],
+    ],
+  },
+});
+```
+
+## Peer dependencies
+
+- `effector` `^23`
+- `react-hook-form` `^7.72` (`createFormControl` exists since 7.55, but the `form.*` error names and the `isSubmitted` subscription flag this package relies on typecheck from 7.72.0)
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,121 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let effector = require("effector");
+//#region src/lib.ts
+var storify = (value, config = { serialize: "ignore" }) => effector.is.store(value) ? value : (0, effector.createStore)(value, config);
+//#endregion
+//#region src/form-state.ts
+var noop = () => {};
+/**
+* Mirror a react-hook-form `createFormControl` instance into an Effector store.
+*
+* The form control itself is a client-only UI controller (held in a
+* `serialize: "ignore"` store). `setup` starts the subscription — fire it under
+* a scope, e.g. on dialog open — and the optional `teardown` stops it. The
+* returned store always holds the latest form state plus current `values`.
+*
+* Form *logic* (fields, validation, submit) stays in the UI via RHF; this store
+* exists so Effector can read derived state such as `isValid`/`isSubmitting`
+* (e.g. to drive a submit button's disabled state) without duplicating logic.
+*/
+var formState = (config) => {
+	const $form = storify(config.form, {
+		serialize: "ignore",
+		name: "form"
+	});
+	const $unsubscribe = (0, effector.createStore)(noop, { serialize: "ignore" });
+	const $formState = (0, effector.createStore)({ values: $form.defaultState.getValues() });
+	const updated = (0, effector.createEvent)();
+	const subscribeFx = (0, effector.attach)({
+		name: "formSubscribeFx",
+		source: $unsubscribe,
+		effect: (unsubscribe, form) => {
+			const onUpdate = (0, effector.scopeBind)(updated, { safe: true });
+			unsubscribe();
+			queueMicrotask(() => onUpdate({ values: form.getValues() }));
+			return form.subscribe({
+				formState: {
+					values: true,
+					errors: true,
+					isDirty: true,
+					isValid: true,
+					isValidating: true,
+					isSubmitted: true,
+					touchedFields: true,
+					dirtyFields: true
+				},
+				callback: (updates) => queueMicrotask(() => onUpdate(updates))
+			});
+		}
+	});
+	const unsubscribeFx = (0, effector.attach)({
+		name: "formUnsubscribeFx",
+		source: $unsubscribe,
+		effect: (unsubscribe) => unsubscribe()
+	});
+	(0, effector.sample)({
+		clock: [config.setup, $form],
+		source: $form,
+		target: subscribeFx
+	});
+	(0, effector.sample)({
+		clock: subscribeFx.doneData,
+		target: $unsubscribe
+	});
+	(0, effector.sample)({
+		clock: updated,
+		target: $formState
+	});
+	if (config.teardown) (0, effector.sample)({
+		clock: config.teardown,
+		target: unsubscribeFx
+	});
+	return $formState;
+};
+//#endregion
+//#region src/form-api.ts
+/**
+* form.reset(emptyValues) — back to the pristine form. The empty values
+* are pinned at creation instead of using a bare form.reset(): RHF's
+* reset(values) REPLACES defaultValues, so after a prefill
+* ([[formPrefillApi]]) a bare reset() would restore the prefilled values,
+* not the pristine form.
+*/
+var formResetApi = (form, emptyValues) => (0, effector.attach)({
+	name: "formResetFx",
+	source: storify(form),
+	effect: (form) => form.reset(emptyValues)
+});
+/**
+* form.reset(values) with the payload — e.g. an edit prefill. Replaces
+* RHF defaultValues (RHF semantics), which is why formResetApi exists.
+*/
+var formPrefillApi = (form) => (0, effector.attach)({
+	name: "formPrefillFx",
+	source: storify(form),
+	effect: (form, values) => form.reset(values)
+});
+/** form.setValue(name, value, options) with the payload. */
+var formSetApi = (form) => (0, effector.attach)({
+	name: "formSetFx",
+	source: storify(form),
+	effect: (form, { name, value, options }) => form.setValue(name, value, options)
+});
+/**
+* `form.setError` bound to the form: apply a list of field errors, e.g. a
+* server's 422 response mapped to `type: "server"` input errors.
+*/
+var formSetErrorApi = (form) => (0, effector.attach)({
+	name: "formSetErrorFx",
+	source: storify(form),
+	effect: (form, fields) => {
+		for (const fieldError of fields) form.setError(fieldError.name, fieldError.error, fieldError.options);
+	}
+});
+//#endregion
+exports.formPrefillApi = formPrefillApi;
+exports.formResetApi = formResetApi;
+exports.formSetApi = formSetApi;
+exports.formSetErrorApi = formSetErrorApi;
+exports.formState = formState;
+
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":[],"sources":["../src/lib.ts","../src/form-state.ts","../src/form-api.ts"],"sourcesContent":["import { createStore, is, Json, Store } from \"effector\";\n\nexport const storify = <V, SerializedState extends Json = Json>(\n  value: V | Store<V>,\n  config: {\n    skipVoid?: boolean;\n    name?: string;\n    sid?: string;\n    updateFilter?: (update: V, current: V) => boolean;\n    serialize?:\n      | \"ignore\"\n      | {\n          write: (state: V) => SerializedState;\n          read: (json: SerializedState) => V;\n        };\n  } = { serialize: \"ignore\" },\n): Store<V> => (is.store(value) ? value : createStore(value, config));\n","import {\n  attach,\n  createEvent,\n  createStore,\n  sample,\n  scopeBind,\n  type Event,\n  type Store\n} from \"effector\";\nimport {\n  createFormControl,\n  type FieldValues,\n  type FormState,\n} from \"react-hook-form\";\nimport { storify } from \"./lib\";\n\n/** Flattens an intersection so hovers and error messages show one object type. */\nexport type Prettify<T> = {\n  [K in keyof T]: T[K];\n} & {};\n\nconst noop = () => {};\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype AnyFormContext = any;\n\nexport type FormControl<\n  TFieldValues extends FieldValues = FieldValues,\n  TContext = AnyFormContext,\n  TTransformedValues = TFieldValues,\n> = Prettify<\n  ReturnType<\n    typeof createFormControl<TFieldValues, TContext, TTransformedValues>\n  >\n>;\n\nexport type FormStateWithValues<\n  TFieldValues extends FieldValues = FieldValues,\n> = Prettify<{ values: TFieldValues } & Partial<FormState<TFieldValues>>>;\n\n/**\n * Mirror a react-hook-form `createFormControl` instance into an Effector store.\n *\n * The form control itself is a client-only UI controller (held in a\n * `serialize: \"ignore\"` store). `setup` starts the subscription — fire it under\n * a scope, e.g. on dialog open — and the optional `teardown` stops it. The\n * returned store always holds the latest form state plus current `values`.\n *\n * Form *logic* (fields, validation, submit) stays in the UI via RHF; this store\n * exists so Effector can read derived state such as `isValid`/`isSubmitting`\n * (e.g. to drive a submit button's disabled state) without duplicating logic.\n */\nexport const formState = <\n  TFieldValues extends FieldValues = FieldValues,\n  TContext = AnyFormContext,\n  TTransformedValues = TFieldValues,\n>(config: {\n  form:\n    | FormControl<TFieldValues, TContext, TTransformedValues>\n    | Store<FormControl<TFieldValues, TContext, TTransformedValues>>;\n  setup: Event<unknown>;\n  teardown?: Event<unknown>;\n}) => {\n  const $form = storify(config.form, { serialize: \"ignore\", name: \"form\" });\n\n  const $unsubscribe = createStore(noop, { serialize: \"ignore\" });\n  const $formState = createStore<FormStateWithValues<TFieldValues>>({\n    values: $form.defaultState.getValues() as TFieldValues,\n  });\n\n  const updated = createEvent<FormStateWithValues<TFieldValues>>();\n\n  const subscribeFx = attach({\n    name: \"formSubscribeFx\",\n    source: $unsubscribe,\n    effect: (\n      unsubscribe,\n      form: FormControl<TFieldValues, TContext, TTransformedValues>,\n    ) => {\n      const onUpdate = scopeBind(updated, { safe: true });\n\n      unsubscribe();\n\n      // Attach snapshot: a reset that ran BEFORE this subscription attached\n      // notified nobody — read the current values so the mirror can never\n      // start stale. Values only: the control exposes no derived flags;\n      // those arrive with RHF's next real notification.\n      queueMicrotask(() => onUpdate({ values: form.getValues() }));\n\n      return form.subscribe({\n        // Opt into the slices we mirror — `subscribe` only invokes the callback\n        // for formState parts it is told to track (`values` included).\n        formState: {\n          values: true,\n          errors: true,\n          isDirty: true,\n          isValid: true,\n          isValidating: true,\n          isSubmitted: true,\n          touchedFields: true,\n          dirtyFields: true,\n        },\n        // RHF notifies subscribers SYNCHRONOUSLY, including from <Controller>\n        // field registration which runs during React render. Forwarding into\n        // effector right there makes every useUnit subscriber setState during\n        // another component's render (React error). One microtask defers the\n        // mirror out of the render phase; ordering between updates is kept.\n        callback: (updates) => queueMicrotask(() => onUpdate(updates)),\n      });\n    },\n  });\n  const unsubscribeFx = attach({\n    name: \"formUnsubscribeFx\",\n    source: $unsubscribe,\n    effect: (unsubscribe) => unsubscribe(),\n  });\n\n  sample({ clock: [config.setup, $form], source: $form, target: subscribeFx });\n  sample({ clock: subscribeFx.doneData, target: $unsubscribe });\n  sample({ clock: updated, target: $formState });\n\n  if (config.teardown) {\n    sample({ clock: config.teardown, target: unsubscribeFx });\n  }\n\n  return $formState;\n};\n","import { attach, type Store } from \"effector\";\nimport type {\n  ErrorOption,\n  FieldPath,\n  FieldValues,\n  Path,\n  PathValue,\n  SetValueConfig,\n} from \"react-hook-form\";\nimport type { FormControl } from \"./form-state\";\nimport { storify } from \"./lib\";\n\n/**\n * One `formSetApi` write. The name/value pairing is deliberately as loose\n * as RHF's own runtime (the value type is the union over all paths), so\n * callsites that pick the field dynamically stay cast-free.\n */\nexport type SetValuePayload<Values extends FieldValues> = {\n  name: Path<Values>;\n  value: PathValue<Values, Path<Values>>;\n  options?: SetValueConfig;\n};\n\n/*\n * One factory per RHF call models actually make — each returns a single\n * effect over the form control, replacing the per-model\n * `attach({ source: $form, ... })` boilerplate. Granular on purpose: a\n * model declares exactly the effects it uses, under its own names, and\n * two forms in one module never fight over destructure aliases. Extend\n * the set when a new call pattern becomes common.\n */\n\n\n/**\n * form.reset(emptyValues) — back to the pristine form. The empty values\n * are pinned at creation instead of using a bare form.reset(): RHF's\n * reset(values) REPLACES defaultValues, so after a prefill\n * ([[formPrefillApi]]) a bare reset() would restore the prefilled values,\n * not the pristine form.\n */\nexport const formResetApi = <Values extends FieldValues>(\n  form: FormControl<Values> | Store<FormControl<Values>>,\n  emptyValues?: Values,\n) =>\n  attach({\n    name: \"formResetFx\",\n    source: storify(form),\n    effect: (form) => form.reset(emptyValues),\n  });\n\n/**\n * form.reset(values) with the payload — e.g. an edit prefill. Replaces\n * RHF defaultValues (RHF semantics), which is why formResetApi exists.\n */\nexport const formPrefillApi = <Values extends FieldValues>(\n  form: FormControl<Values> | Store<FormControl<Values>>,\n) =>\n  attach({\n    name: \"formPrefillFx\",\n    source: storify(form),\n    effect: (form, values: Values) => form.reset(values),\n  });\n\n/** form.setValue(name, value, options) with the payload. */\nexport const formSetApi = <Values extends FieldValues>(\n  form: FormControl<Values> | Store<FormControl<Values>>,\n) =>\n  attach({\n    name: \"formSetFx\",\n    source: storify(form),\n    effect: (form, { name, value, options }: SetValuePayload<Values>) =>\n      form.setValue(name, value, options),\n  });\n\n\nexport type FormFieldError<Values extends FieldValues> = {\n  name:\n    | \"form\"\n    | \"root\"\n    | `root.${string}`\n    | FieldPath<Values>\n    | `form.${string}`;\n  error: ErrorOption;\n  options?: { shouldFocus: boolean };\n};\n\n\n/**\n * `form.setError` bound to the form: apply a list of field errors, e.g. a\n * server's 422 response mapped to `type: \"server\"` input errors.\n */\nexport const formSetErrorApi = <Values extends FieldValues>(\n  form: FormControl<Values> | Store<FormControl<Values>>,\n) =>\n  attach({\n    name: \"formSetErrorFx\",\n    source: storify(form),\n    effect: (form, fields: FormFieldError<Values>[]) => {\n      for (const fieldError of fields) {\n        form.setError(fieldError.name, fieldError.error, fieldError.options);\n      }\n    },\n  });\n\n"],"mappings":";;;AAEA,IAAa,WACX,OACA,SAWI,EAAE,WAAW,SAAS,MACZ,SAAA,GAAG,MAAM,KAAK,IAAI,SAAA,GAAQ,SAAA,YAAA,CAAY,OAAO,MAAM;;;ACKnE,IAAM,aAAa,CAAC;;;;;;;;;;;;;AA+BpB,IAAa,aAIX,WAMI;CACJ,MAAM,QAAQ,QAAQ,OAAO,MAAM;EAAE,WAAW;EAAU,MAAM;CAAO,CAAC;CAExE,MAAM,gBAAA,GAAe,SAAA,YAAA,CAAY,MAAM,EAAE,WAAW,SAAS,CAAC;CAC9D,MAAM,cAAA,GAAa,SAAA,YAAA,CAA+C,EAChE,QAAQ,MAAM,aAAa,UAAU,EACvC,CAAC;CAED,MAAM,WAAA,GAAU,SAAA,YAAA,CAA+C;CAE/D,MAAM,eAAA,GAAc,SAAA,OAAA,CAAO;EACzB,MAAM;EACN,QAAQ;EACR,SACE,aACA,SACG;GACH,MAAM,YAAA,GAAW,SAAA,UAAA,CAAU,SAAS,EAAE,MAAM,KAAK,CAAC;GAElD,YAAY;GAMZ,qBAAqB,SAAS,EAAE,QAAQ,KAAK,UAAU,EAAE,CAAC,CAAC;GAE3D,OAAO,KAAK,UAAU;IAGpB,WAAW;KACT,QAAQ;KACR,QAAQ;KACR,SAAS;KACT,SAAS;KACT,cAAc;KACd,aAAa;KACb,eAAe;KACf,aAAa;IACf;IAMA,WAAW,YAAY,qBAAqB,SAAS,OAAO,CAAC;GAC/D,CAAC;EACH;CACF,CAAC;CACD,MAAM,iBAAA,GAAgB,SAAA,OAAA,CAAO;EAC3B,MAAM;EACN,QAAQ;EACR,SAAS,gBAAgB,YAAY;CACvC,CAAC;CAED,CAAA,GAAA,SAAA,OAAA,CAAO;EAAE,OAAO,CAAC,OAAO,OAAO,KAAK;EAAG,QAAQ;EAAO,QAAQ;CAAY,CAAC;CAC3E,CAAA,GAAA,SAAA,OAAA,CAAO;EAAE,OAAO,YAAY;EAAU,QAAQ;CAAa,CAAC;CAC5D,CAAA,GAAA,SAAA,OAAA,CAAO;EAAE,OAAO;EAAS,QAAQ;CAAW,CAAC;CAE7C,IAAI,OAAO,UACT,CAAA,GAAA,SAAA,OAAA,CAAO;EAAE,OAAO,OAAO;EAAU,QAAQ;CAAc,CAAC;CAG1D,OAAO;AACT;;;;;;;;;;ACtFA,IAAa,gBACX,MACA,iBAAA,GAEA,SAAA,OAAA,CAAO;CACL,MAAM;CACN,QAAQ,QAAQ,IAAI;CACpB,SAAS,SAAS,KAAK,MAAM,WAAW;AAC1C,CAAC;;;;;AAMH,IAAa,kBACX,UAAA,GAEA,SAAA,OAAA,CAAO;CACL,MAAM;CACN,QAAQ,QAAQ,IAAI;CACpB,SAAS,MAAM,WAAmB,KAAK,MAAM,MAAM;AACrD,CAAC;;AAGH,IAAa,cACX,UAAA,GAEA,SAAA,OAAA,CAAO;CACL,MAAM;CACN,QAAQ,QAAQ,IAAI;CACpB,SAAS,MAAM,EAAE,MAAM,OAAO,cAC5B,KAAK,SAAS,MAAM,OAAO,OAAO;AACtC,CAAC;;;;;AAmBH,IAAa,mBACX,UAAA,GAEA,SAAA,OAAA,CAAO;CACL,MAAM;CACN,QAAQ,QAAQ,IAAI;CACpB,SAAS,MAAM,WAAqC;EAClD,KAAK,MAAM,cAAc,QACvB,KAAK,SAAS,WAAW,MAAM,WAAW,OAAO,WAAW,OAAO;CAEvE;AACF,CAAC"}

package/dist/index.d.cts

@@ -0,0 +1,108 @@
+import { createFormControl } from 'react-hook-form';
+import { DeepMap } from 'react-hook-form';
+import { DeepPartial } from 'react-hook-form';
+import { Effect } from 'effector';
+import { ErrorOption } from 'react-hook-form';
+import { Event as Event_2 } from 'effector';
+import { FieldErrors } from 'react-hook-form';
+import { FieldPath } from 'react-hook-form';
+import { FieldValues } from 'react-hook-form';
+import { FormState } from 'react-hook-form';
+import { Path } from 'react-hook-form';
+import { PathValue } from 'react-hook-form';
+import { SetValueConfig } from 'react-hook-form';
+import { Store } from 'effector';
+import { StoreWritable } from 'effector';
+
+declare type AnyFormContext = any;
+
+export declare type FormControl<TFieldValues extends FieldValues = FieldValues, TContext = AnyFormContext, TTransformedValues = TFieldValues> = Prettify<ReturnType<typeof createFormControl<TFieldValues, TContext, TTransformedValues>>>;
+
+export declare type FormFieldError<Values extends FieldValues> = {
+    name: "form" | "root" | `root.${string}` | FieldPath<Values> | `form.${string}`;
+    error: ErrorOption;
+    options?: {
+        shouldFocus: boolean;
+    };
+};
+
+/**
+ * form.reset(values) with the payload — e.g. an edit prefill. Replaces
+ * RHF defaultValues (RHF semantics), which is why formResetApi exists.
+ */
+export declare const formPrefillApi: <Values extends FieldValues>(form: FormControl<Values> | Store<FormControl<Values>>) => Effect<Values, void, Error>;
+
+/**
+ * form.reset(emptyValues) — back to the pristine form. The empty values
+ * are pinned at creation instead of using a bare form.reset(): RHF's
+ * reset(values) REPLACES defaultValues, so after a prefill
+ * ([[formPrefillApi]]) a bare reset() would restore the prefilled values,
+ * not the pristine form.
+ */
+export declare const formResetApi: <Values extends FieldValues>(form: FormControl<Values> | Store<FormControl<Values>>, emptyValues?: Values) => Effect<void, void, Error>;
+
+/** form.setValue(name, value, options) with the payload. */
+export declare const formSetApi: <Values extends FieldValues>(form: FormControl<Values> | Store<FormControl<Values>>) => Effect<SetValuePayload<Values>, void, Error>;
+
+/**
+ * `form.setError` bound to the form: apply a list of field errors, e.g. a
+ * server's 422 response mapped to `type: "server"` input errors.
+ */
+export declare const formSetErrorApi: <Values extends FieldValues>(form: FormControl<Values> | Store<FormControl<Values>>) => Effect<FormFieldError<Values>[], void, Error>;
+
+/**
+ * Mirror a react-hook-form `createFormControl` instance into an Effector store.
+ *
+ * The form control itself is a client-only UI controller (held in a
+ * `serialize: "ignore"` store). `setup` starts the subscription — fire it under
+ * a scope, e.g. on dialog open — and the optional `teardown` stops it. The
+ * returned store always holds the latest form state plus current `values`.
+ *
+ * Form *logic* (fields, validation, submit) stays in the UI via RHF; this store
+ * exists so Effector can read derived state such as `isValid`/`isSubmitting`
+ * (e.g. to drive a submit button's disabled state) without duplicating logic.
+ */
+export declare const formState: <TFieldValues extends FieldValues = FieldValues, TContext = AnyFormContext, TTransformedValues = TFieldValues>(config: {
+    form: FormControl<TFieldValues, TContext, TTransformedValues> | Store<FormControl<TFieldValues, TContext, TTransformedValues>>;
+    setup: Event_2<unknown>;
+    teardown?: Event_2<unknown>;
+}) => StoreWritable<{
+    values: TFieldValues;
+    isDirty?: boolean | undefined;
+    isLoading?: boolean | undefined;
+    isSubmitted?: boolean | undefined;
+    isSubmitSuccessful?: boolean | undefined;
+    isSubmitting?: boolean | undefined;
+    isValidating?: boolean | undefined;
+    isValid?: boolean | undefined;
+    disabled?: boolean | undefined;
+    submitCount?: number | undefined;
+    defaultValues?: Readonly< DeepPartial<TFieldValues>> | undefined;
+    dirtyFields?: Partial<Readonly< DeepMap<DeepPartial<TFieldValues>, boolean>>> | undefined;
+    touchedFields?: Partial<Readonly< DeepMap<DeepPartial<TFieldValues>, boolean>>> | undefined;
+    validatingFields?: Partial<Readonly< DeepMap<DeepPartial<TFieldValues>, boolean>>> | undefined;
+    errors?: FieldErrors<TFieldValues> | undefined;
+    isReady?: boolean | undefined;
+}>;
+
+export declare type FormStateWithValues<TFieldValues extends FieldValues = FieldValues> = Prettify<{
+    values: TFieldValues;
+} & Partial<FormState<TFieldValues>>>;
+
+/** Flattens an intersection so hovers and error messages show one object type. */
+declare type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+
+/**
+ * One `formSetApi` write. The name/value pairing is deliberately as loose
+ * as RHF's own runtime (the value type is the union over all paths), so
+ * callsites that pick the field dynamically stay cast-free.
+ */
+export declare type SetValuePayload<Values extends FieldValues> = {
+    name: Path<Values>;
+    value: PathValue<Values, Path<Values>>;
+    options?: SetValueConfig;
+};
+
+export { }

package/dist/index.d.ts

@@ -0,0 +1,108 @@
+import { createFormControl } from 'react-hook-form';
+import { DeepMap } from 'react-hook-form';
+import { DeepPartial } from 'react-hook-form';
+import { Effect } from 'effector';
+import { ErrorOption } from 'react-hook-form';
+import { Event as Event_2 } from 'effector';
+import { FieldErrors } from 'react-hook-form';
+import { FieldPath } from 'react-hook-form';
+import { FieldValues } from 'react-hook-form';
+import { FormState } from 'react-hook-form';
+import { Path } from 'react-hook-form';
+import { PathValue } from 'react-hook-form';
+import { SetValueConfig } from 'react-hook-form';
+import { Store } from 'effector';
+import { StoreWritable } from 'effector';
+
+declare type AnyFormContext = any;
+
+export declare type FormControl<TFieldValues extends FieldValues = FieldValues, TContext = AnyFormContext, TTransformedValues = TFieldValues> = Prettify<ReturnType<typeof createFormControl<TFieldValues, TContext, TTransformedValues>>>;
+
+export declare type FormFieldError<Values extends FieldValues> = {
+    name: "form" | "root" | `root.${string}` | FieldPath<Values> | `form.${string}`;
+    error: ErrorOption;
+    options?: {
+        shouldFocus: boolean;
+    };
+};
+
+/**
+ * form.reset(values) with the payload — e.g. an edit prefill. Replaces
+ * RHF defaultValues (RHF semantics), which is why formResetApi exists.
+ */
+export declare const formPrefillApi: <Values extends FieldValues>(form: FormControl<Values> | Store<FormControl<Values>>) => Effect<Values, void, Error>;
+
+/**
+ * form.reset(emptyValues) — back to the pristine form. The empty values
+ * are pinned at creation instead of using a bare form.reset(): RHF's
+ * reset(values) REPLACES defaultValues, so after a prefill
+ * ([[formPrefillApi]]) a bare reset() would restore the prefilled values,
+ * not the pristine form.
+ */
+export declare const formResetApi: <Values extends FieldValues>(form: FormControl<Values> | Store<FormControl<Values>>, emptyValues?: Values) => Effect<void, void, Error>;
+
+/** form.setValue(name, value, options) with the payload. */
+export declare const formSetApi: <Values extends FieldValues>(form: FormControl<Values> | Store<FormControl<Values>>) => Effect<SetValuePayload<Values>, void, Error>;
+
+/**
+ * `form.setError` bound to the form: apply a list of field errors, e.g. a
+ * server's 422 response mapped to `type: "server"` input errors.
+ */
+export declare const formSetErrorApi: <Values extends FieldValues>(form: FormControl<Values> | Store<FormControl<Values>>) => Effect<FormFieldError<Values>[], void, Error>;
+
+/**
+ * Mirror a react-hook-form `createFormControl` instance into an Effector store.
+ *
+ * The form control itself is a client-only UI controller (held in a
+ * `serialize: "ignore"` store). `setup` starts the subscription — fire it under
+ * a scope, e.g. on dialog open — and the optional `teardown` stops it. The
+ * returned store always holds the latest form state plus current `values`.
+ *
+ * Form *logic* (fields, validation, submit) stays in the UI via RHF; this store
+ * exists so Effector can read derived state such as `isValid`/`isSubmitting`
+ * (e.g. to drive a submit button's disabled state) without duplicating logic.
+ */
+export declare const formState: <TFieldValues extends FieldValues = FieldValues, TContext = AnyFormContext, TTransformedValues = TFieldValues>(config: {
+    form: FormControl<TFieldValues, TContext, TTransformedValues> | Store<FormControl<TFieldValues, TContext, TTransformedValues>>;
+    setup: Event_2<unknown>;
+    teardown?: Event_2<unknown>;
+}) => StoreWritable<{
+    values: TFieldValues;
+    isDirty?: boolean | undefined;
+    isLoading?: boolean | undefined;
+    isSubmitted?: boolean | undefined;
+    isSubmitSuccessful?: boolean | undefined;
+    isSubmitting?: boolean | undefined;
+    isValidating?: boolean | undefined;
+    isValid?: boolean | undefined;
+    disabled?: boolean | undefined;
+    submitCount?: number | undefined;
+    defaultValues?: Readonly< DeepPartial<TFieldValues>> | undefined;
+    dirtyFields?: Partial<Readonly< DeepMap<DeepPartial<TFieldValues>, boolean>>> | undefined;
+    touchedFields?: Partial<Readonly< DeepMap<DeepPartial<TFieldValues>, boolean>>> | undefined;
+    validatingFields?: Partial<Readonly< DeepMap<DeepPartial<TFieldValues>, boolean>>> | undefined;
+    errors?: FieldErrors<TFieldValues> | undefined;
+    isReady?: boolean | undefined;
+}>;
+
+export declare type FormStateWithValues<TFieldValues extends FieldValues = FieldValues> = Prettify<{
+    values: TFieldValues;
+} & Partial<FormState<TFieldValues>>>;
+
+/** Flattens an intersection so hovers and error messages show one object type. */
+declare type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+
+/**
+ * One `formSetApi` write. The name/value pairing is deliberately as loose
+ * as RHF's own runtime (the value type is the union over all paths), so
+ * callsites that pick the field dynamically stay cast-free.
+ */
+export declare type SetValuePayload<Values extends FieldValues> = {
+    name: Path<Values>;
+    value: PathValue<Values, Path<Values>>;
+    options?: SetValueConfig;
+};
+
+export { }

package/dist/index.js

@@ -0,0 +1,116 @@
+import { attach, createEvent, createStore, is, sample, scopeBind } from "effector";
+//#region src/lib.ts
+var storify = (value, config = { serialize: "ignore" }) => is.store(value) ? value : createStore(value, config);
+//#endregion
+//#region src/form-state.ts
+var noop = () => {};
+/**
+* Mirror a react-hook-form `createFormControl` instance into an Effector store.
+*
+* The form control itself is a client-only UI controller (held in a
+* `serialize: "ignore"` store). `setup` starts the subscription — fire it under
+* a scope, e.g. on dialog open — and the optional `teardown` stops it. The
+* returned store always holds the latest form state plus current `values`.
+*
+* Form *logic* (fields, validation, submit) stays in the UI via RHF; this store
+* exists so Effector can read derived state such as `isValid`/`isSubmitting`
+* (e.g. to drive a submit button's disabled state) without duplicating logic.
+*/
+var formState = (config) => {
+	const $form = storify(config.form, {
+		serialize: "ignore",
+		name: "form"
+	});
+	const $unsubscribe = createStore(noop, { serialize: "ignore" });
+	const $formState = createStore({ values: $form.defaultState.getValues() });
+	const updated = createEvent();
+	const subscribeFx = attach({
+		name: "formSubscribeFx",
+		source: $unsubscribe,
+		effect: (unsubscribe, form) => {
+			const onUpdate = scopeBind(updated, { safe: true });
+			unsubscribe();
+			queueMicrotask(() => onUpdate({ values: form.getValues() }));
+			return form.subscribe({
+				formState: {
+					values: true,
+					errors: true,
+					isDirty: true,
+					isValid: true,
+					isValidating: true,
+					isSubmitted: true,
+					touchedFields: true,
+					dirtyFields: true
+				},
+				callback: (updates) => queueMicrotask(() => onUpdate(updates))
+			});
+		}
+	});
+	const unsubscribeFx = attach({
+		name: "formUnsubscribeFx",
+		source: $unsubscribe,
+		effect: (unsubscribe) => unsubscribe()
+	});
+	sample({
+		clock: [config.setup, $form],
+		source: $form,
+		target: subscribeFx
+	});
+	sample({
+		clock: subscribeFx.doneData,
+		target: $unsubscribe
+	});
+	sample({
+		clock: updated,
+		target: $formState
+	});
+	if (config.teardown) sample({
+		clock: config.teardown,
+		target: unsubscribeFx
+	});
+	return $formState;
+};
+//#endregion
+//#region src/form-api.ts
+/**
+* form.reset(emptyValues) — back to the pristine form. The empty values
+* are pinned at creation instead of using a bare form.reset(): RHF's
+* reset(values) REPLACES defaultValues, so after a prefill
+* ([[formPrefillApi]]) a bare reset() would restore the prefilled values,
+* not the pristine form.
+*/
+var formResetApi = (form, emptyValues) => attach({
+	name: "formResetFx",
+	source: storify(form),
+	effect: (form) => form.reset(emptyValues)
+});
+/**
+* form.reset(values) with the payload — e.g. an edit prefill. Replaces
+* RHF defaultValues (RHF semantics), which is why formResetApi exists.
+*/
+var formPrefillApi = (form) => attach({
+	name: "formPrefillFx",
+	source: storify(form),
+	effect: (form, values) => form.reset(values)
+});
+/** form.setValue(name, value, options) with the payload. */
+var formSetApi = (form) => attach({
+	name: "formSetFx",
+	source: storify(form),
+	effect: (form, { name, value, options }) => form.setValue(name, value, options)
+});
+/**
+* `form.setError` bound to the form: apply a list of field errors, e.g. a
+* server's 422 response mapped to `type: "server"` input errors.
+*/
+var formSetErrorApi = (form) => attach({
+	name: "formSetErrorFx",
+	source: storify(form),
+	effect: (form, fields) => {
+		for (const fieldError of fields) form.setError(fieldError.name, fieldError.error, fieldError.options);
+	}
+});
+//#endregion
+export { formPrefillApi, formResetApi, formSetApi, formSetErrorApi, formState };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/lib.ts","../src/form-state.ts","../src/form-api.ts"],"sourcesContent":["import { createStore, is, Json, Store } from \"effector\";\n\nexport const storify = <V, SerializedState extends Json = Json>(\n  value: V | Store<V>,\n  config: {\n    skipVoid?: boolean;\n    name?: string;\n    sid?: string;\n    updateFilter?: (update: V, current: V) => boolean;\n    serialize?:\n      | \"ignore\"\n      | {\n          write: (state: V) => SerializedState;\n          read: (json: SerializedState) => V;\n        };\n  } = { serialize: \"ignore\" },\n): Store<V> => (is.store(value) ? value : createStore(value, config));\n","import {\n  attach,\n  createEvent,\n  createStore,\n  sample,\n  scopeBind,\n  type Event,\n  type Store\n} from \"effector\";\nimport {\n  createFormControl,\n  type FieldValues,\n  type FormState,\n} from \"react-hook-form\";\nimport { storify } from \"./lib\";\n\n/** Flattens an intersection so hovers and error messages show one object type. */\nexport type Prettify<T> = {\n  [K in keyof T]: T[K];\n} & {};\n\nconst noop = () => {};\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype AnyFormContext = any;\n\nexport type FormControl<\n  TFieldValues extends FieldValues = FieldValues,\n  TContext = AnyFormContext,\n  TTransformedValues = TFieldValues,\n> = Prettify<\n  ReturnType<\n    typeof createFormControl<TFieldValues, TContext, TTransformedValues>\n  >\n>;\n\nexport type FormStateWithValues<\n  TFieldValues extends FieldValues = FieldValues,\n> = Prettify<{ values: TFieldValues } & Partial<FormState<TFieldValues>>>;\n\n/**\n * Mirror a react-hook-form `createFormControl` instance into an Effector store.\n *\n * The form control itself is a client-only UI controller (held in a\n * `serialize: \"ignore\"` store). `setup` starts the subscription — fire it under\n * a scope, e.g. on dialog open — and the optional `teardown` stops it. The\n * returned store always holds the latest form state plus current `values`.\n *\n * Form *logic* (fields, validation, submit) stays in the UI via RHF; this store\n * exists so Effector can read derived state such as `isValid`/`isSubmitting`\n * (e.g. to drive a submit button's disabled state) without duplicating logic.\n */\nexport const formState = <\n  TFieldValues extends FieldValues = FieldValues,\n  TContext = AnyFormContext,\n  TTransformedValues = TFieldValues,\n>(config: {\n  form:\n    | FormControl<TFieldValues, TContext, TTransformedValues>\n    | Store<FormControl<TFieldValues, TContext, TTransformedValues>>;\n  setup: Event<unknown>;\n  teardown?: Event<unknown>;\n}) => {\n  const $form = storify(config.form, { serialize: \"ignore\", name: \"form\" });\n\n  const $unsubscribe = createStore(noop, { serialize: \"ignore\" });\n  const $formState = createStore<FormStateWithValues<TFieldValues>>({\n    values: $form.defaultState.getValues() as TFieldValues,\n  });\n\n  const updated = createEvent<FormStateWithValues<TFieldValues>>();\n\n  const subscribeFx = attach({\n    name: \"formSubscribeFx\",\n    source: $unsubscribe,\n    effect: (\n      unsubscribe,\n      form: FormControl<TFieldValues, TContext, TTransformedValues>,\n    ) => {\n      const onUpdate = scopeBind(updated, { safe: true });\n\n      unsubscribe();\n\n      // Attach snapshot: a reset that ran BEFORE this subscription attached\n      // notified nobody — read the current values so the mirror can never\n      // start stale. Values only: the control exposes no derived flags;\n      // those arrive with RHF's next real notification.\n      queueMicrotask(() => onUpdate({ values: form.getValues() }));\n\n      return form.subscribe({\n        // Opt into the slices we mirror — `subscribe` only invokes the callback\n        // for formState parts it is told to track (`values` included).\n        formState: {\n          values: true,\n          errors: true,\n          isDirty: true,\n          isValid: true,\n          isValidating: true,\n          isSubmitted: true,\n          touchedFields: true,\n          dirtyFields: true,\n        },\n        // RHF notifies subscribers SYNCHRONOUSLY, including from <Controller>\n        // field registration which runs during React render. Forwarding into\n        // effector right there makes every useUnit subscriber setState during\n        // another component's render (React error). One microtask defers the\n        // mirror out of the render phase; ordering between updates is kept.\n        callback: (updates) => queueMicrotask(() => onUpdate(updates)),\n      });\n    },\n  });\n  const unsubscribeFx = attach({\n    name: \"formUnsubscribeFx\",\n    source: $unsubscribe,\n    effect: (unsubscribe) => unsubscribe(),\n  });\n\n  sample({ clock: [config.setup, $form], source: $form, target: subscribeFx });\n  sample({ clock: subscribeFx.doneData, target: $unsubscribe });\n  sample({ clock: updated, target: $formState });\n\n  if (config.teardown) {\n    sample({ clock: config.teardown, target: unsubscribeFx });\n  }\n\n  return $formState;\n};\n","import { attach, type Store } from \"effector\";\nimport type {\n  ErrorOption,\n  FieldPath,\n  FieldValues,\n  Path,\n  PathValue,\n  SetValueConfig,\n} from \"react-hook-form\";\nimport type { FormControl } from \"./form-state\";\nimport { storify } from \"./lib\";\n\n/**\n * One `formSetApi` write. The name/value pairing is deliberately as loose\n * as RHF's own runtime (the value type is the union over all paths), so\n * callsites that pick the field dynamically stay cast-free.\n */\nexport type SetValuePayload<Values extends FieldValues> = {\n  name: Path<Values>;\n  value: PathValue<Values, Path<Values>>;\n  options?: SetValueConfig;\n};\n\n/*\n * One factory per RHF call models actually make — each returns a single\n * effect over the form control, replacing the per-model\n * `attach({ source: $form, ... })` boilerplate. Granular on purpose: a\n * model declares exactly the effects it uses, under its own names, and\n * two forms in one module never fight over destructure aliases. Extend\n * the set when a new call pattern becomes common.\n */\n\n\n/**\n * form.reset(emptyValues) — back to the pristine form. The empty values\n * are pinned at creation instead of using a bare form.reset(): RHF's\n * reset(values) REPLACES defaultValues, so after a prefill\n * ([[formPrefillApi]]) a bare reset() would restore the prefilled values,\n * not the pristine form.\n */\nexport const formResetApi = <Values extends FieldValues>(\n  form: FormControl<Values> | Store<FormControl<Values>>,\n  emptyValues?: Values,\n) =>\n  attach({\n    name: \"formResetFx\",\n    source: storify(form),\n    effect: (form) => form.reset(emptyValues),\n  });\n\n/**\n * form.reset(values) with the payload — e.g. an edit prefill. Replaces\n * RHF defaultValues (RHF semantics), which is why formResetApi exists.\n */\nexport const formPrefillApi = <Values extends FieldValues>(\n  form: FormControl<Values> | Store<FormControl<Values>>,\n) =>\n  attach({\n    name: \"formPrefillFx\",\n    source: storify(form),\n    effect: (form, values: Values) => form.reset(values),\n  });\n\n/** form.setValue(name, value, options) with the payload. */\nexport const formSetApi = <Values extends FieldValues>(\n  form: FormControl<Values> | Store<FormControl<Values>>,\n) =>\n  attach({\n    name: \"formSetFx\",\n    source: storify(form),\n    effect: (form, { name, value, options }: SetValuePayload<Values>) =>\n      form.setValue(name, value, options),\n  });\n\n\nexport type FormFieldError<Values extends FieldValues> = {\n  name:\n    | \"form\"\n    | \"root\"\n    | `root.${string}`\n    | FieldPath<Values>\n    | `form.${string}`;\n  error: ErrorOption;\n  options?: { shouldFocus: boolean };\n};\n\n\n/**\n * `form.setError` bound to the form: apply a list of field errors, e.g. a\n * server's 422 response mapped to `type: \"server\"` input errors.\n */\nexport const formSetErrorApi = <Values extends FieldValues>(\n  form: FormControl<Values> | Store<FormControl<Values>>,\n) =>\n  attach({\n    name: \"formSetErrorFx\",\n    source: storify(form),\n    effect: (form, fields: FormFieldError<Values>[]) => {\n      for (const fieldError of fields) {\n        form.setError(fieldError.name, fieldError.error, fieldError.options);\n      }\n    },\n  });\n\n"],"mappings":";;AAEA,IAAa,WACX,OACA,SAWI,EAAE,WAAW,SAAS,MACZ,GAAG,MAAM,KAAK,IAAI,QAAQ,YAAY,OAAO,MAAM;;;ACKnE,IAAM,aAAa,CAAC;;;;;;;;;;;;;AA+BpB,IAAa,aAIX,WAMI;CACJ,MAAM,QAAQ,QAAQ,OAAO,MAAM;EAAE,WAAW;EAAU,MAAM;CAAO,CAAC;CAExE,MAAM,eAAe,YAAY,MAAM,EAAE,WAAW,SAAS,CAAC;CAC9D,MAAM,aAAa,YAA+C,EAChE,QAAQ,MAAM,aAAa,UAAU,EACvC,CAAC;CAED,MAAM,UAAU,YAA+C;CAE/D,MAAM,cAAc,OAAO;EACzB,MAAM;EACN,QAAQ;EACR,SACE,aACA,SACG;GACH,MAAM,WAAW,UAAU,SAAS,EAAE,MAAM,KAAK,CAAC;GAElD,YAAY;GAMZ,qBAAqB,SAAS,EAAE,QAAQ,KAAK,UAAU,EAAE,CAAC,CAAC;GAE3D,OAAO,KAAK,UAAU;IAGpB,WAAW;KACT,QAAQ;KACR,QAAQ;KACR,SAAS;KACT,SAAS;KACT,cAAc;KACd,aAAa;KACb,eAAe;KACf,aAAa;IACf;IAMA,WAAW,YAAY,qBAAqB,SAAS,OAAO,CAAC;GAC/D,CAAC;EACH;CACF,CAAC;CACD,MAAM,gBAAgB,OAAO;EAC3B,MAAM;EACN,QAAQ;EACR,SAAS,gBAAgB,YAAY;CACvC,CAAC;CAED,OAAO;EAAE,OAAO,CAAC,OAAO,OAAO,KAAK;EAAG,QAAQ;EAAO,QAAQ;CAAY,CAAC;CAC3E,OAAO;EAAE,OAAO,YAAY;EAAU,QAAQ;CAAa,CAAC;CAC5D,OAAO;EAAE,OAAO;EAAS,QAAQ;CAAW,CAAC;CAE7C,IAAI,OAAO,UACT,OAAO;EAAE,OAAO,OAAO;EAAU,QAAQ;CAAc,CAAC;CAG1D,OAAO;AACT;;;;;;;;;;ACtFA,IAAa,gBACX,MACA,gBAEA,OAAO;CACL,MAAM;CACN,QAAQ,QAAQ,IAAI;CACpB,SAAS,SAAS,KAAK,MAAM,WAAW;AAC1C,CAAC;;;;;AAMH,IAAa,kBACX,SAEA,OAAO;CACL,MAAM;CACN,QAAQ,QAAQ,IAAI;CACpB,SAAS,MAAM,WAAmB,KAAK,MAAM,MAAM;AACrD,CAAC;;AAGH,IAAa,cACX,SAEA,OAAO;CACL,MAAM;CACN,QAAQ,QAAQ,IAAI;CACpB,SAAS,MAAM,EAAE,MAAM,OAAO,cAC5B,KAAK,SAAS,MAAM,OAAO,OAAO;AACtC,CAAC;;;;;AAmBH,IAAa,mBACX,SAEA,OAAO;CACL,MAAM;CACN,QAAQ,QAAQ,IAAI;CACpB,SAAS,MAAM,WAAqC;EAClD,KAAK,MAAM,cAAc,QACvB,KAAK,SAAS,WAAW,MAAM,WAAW,OAAO,WAAW,OAAO;CAEvE;AACF,CAAC"}

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@reaxon/hook-form-effector",
+  "version": "0.1.0",
+  "description": "Effector bindings for react-hook-form: mirror form state into stores and drive the form control with effects",
+  "keywords": [
+    "effector",
+    "react-hook-form",
+    "forms",
+    "state-management"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dovranJorayev/reaxon.git",
+    "directory": "packages/hook-form-effector"
+  },
+  "homepage": "https://github.com/dovranJorayev/reaxon/tree/main/packages/hook-form-effector#readme",
+  "bugs": "https://github.com/dovranJorayev/reaxon/issues",
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "peerDependencies": {
+    "effector": "^23",
+    "react-hook-form": "^7.72.0"
+  },
+  "devDependencies": {
+    "@types/react": "19.2.18",
+    "effector": "23.4.4",
+    "react": "19.2.8",
+    "react-hook-form": "7.79.0"
+  },
+  "scripts": {
+    "build": "vite build",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  }
+}