@reformer/core 1.0.0-beta.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Alexandr Bukhtatyy
+
+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,143 @@
+# @reformer/core
+
+[![npm version](https://img.shields.io/npm/v/@reformer/core.svg)](https://www.npmjs.com/package/@reformer/core)
+[![npm downloads](https://img.shields.io/npm/dm/@reformer/core.svg)](https://www.npmjs.com/package/@reformer/core)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+
+Reactive form state management library for React with signals-based architecture.
+
+## Playground
+
+[![Open in StackBlitz](https://developer.stackblitz.com/img/open_in_stackblitz_small.svg)](https://stackblitz.com/~/github.com/AlexandrBukhtatyy/ReFormer/tree/main/projects/react-playground?file=projects/react-playground/src/App.tsx)
+
+## Documentation
+
+Full documentation is available at [https://alexandrbukhtatyy.github.io/ReFormer/](https://alexandrbukhtatyy.github.io/ReFormer/)
+
+## Features
+
+- Signals-based reactive state management
+- Declarative form validation
+- Dynamic form behaviors
+- TypeScript support
+- Tree-shakeable exports
+
+## Installation
+
+```bash
+npm install @reformer/core@beta # Active development is underway, so you can try beta
+```
+
+## Quick Start
+
+```tsx
+import { useMemo } from 'react';
+import {
+  createForm,
+  useFormControl,
+  required,
+  email,
+  validate,
+  watchField,
+  FieldNode,
+} from '@reformer/core';
+
+// 0. Simple FormField component
+function FormField({ label, control }: { label: string; control: FieldNode<string> }) {
+  const { value, errors } = useFormControl(control);
+
+  return (
+    <div>
+      <label>{label}</label>
+      <input
+        value={value}
+        onChange={(e) => control.setValue(e.target.value)}
+        onBlur={() => control.markAsTouched()}
+      />
+      {errors.length > 0 && <span className="error">{errors[0].message}</span>}
+    </div>
+  );
+}
+
+// 1. Define form interface
+interface RegistrationForm {
+  username: string;
+  email: string;
+  password: string;
+  confirmPassword: string;
+}
+
+// 2. Form schema
+const formSchema = {
+  username: { value: '' },
+  email: { value: '' },
+  password: { value: '' },
+  confirmPassword: { value: '' },
+};
+
+// 3. Validation schema
+validationSchema = (path) => {
+  required(path.username);
+
+  required(path.email);
+  email(path.email);
+
+  required(path.password);
+  required(path.confirmPassword);
+
+  // Cross-field validation: passwords must match
+  validate(path.confirmPassword, (value, ctx) => {
+    const password = ctx.form.password.value.value;
+    if (value && password && value !== password) {
+      return { code: 'mismatch', message: 'Passwords do not match' };
+    }
+    return null;
+  });
+};
+
+// 4. Behavior schema
+behavior = (path) => {
+  // Clear confirmPassword when password changes (if not empty)
+  watchField(path.password, (_, ctx) => {
+    const confirmValue = ctx.form.confirmPassword.value.value;
+    if (confirmValue) {
+      ctx.form.confirmPassword.setValue('', { emitEvent: false });
+    }
+  });
+};
+
+// 5. Registration form component
+function RegistrationFormExample() {
+  const form = useMemo(
+    () =>
+      createForm<RegistrationForm>({
+        form: formSchema,
+        validation: validationSchema,
+        behavior: behaviorSchema,
+      }),
+    []
+  );
+
+  const handleSubmit = async (e: React.FormEvent) => {
+    e.preventDefault();
+    await form.validate();
+    if (form.valid.value) {
+      console.log('Form data:', form.value.value);
+    }
+  };
+
+  return (
+    <form onSubmit={handleSubmit}>
+      <FormField label="Username" control={form.username} />
+      <FormField label="Email" control={form.email} />
+      <FormField label="Password" control={form.password} />
+      <FormField label="Confirm Password" control={form.confirmPassword} />
+      <button type="submit">Register</button>
+    </form>
+  );
+}
+```
+
+## License
+
+MIT

package/dist/behaviors/compute-from.d.ts

@@ -0,0 +1,2 @@
+export * from '../core/behavior/behaviors/compute-from'
+export {}

package/dist/behaviors/compute-from.js

@@ -0,0 +1,31 @@
+import { effect as _ } from "@preact/signals-core";
+import { b as v } from "../registry-helpers-Bv_BJ1s-.js";
+import { r as V } from "../safe-effect-Dh8uw81c.js";
+function N(n, i, s, f) {
+  const { debounce: p, condition: u } = f || {}, h = (r, E, m) => {
+    const a = r.getFieldByPath(i.__path);
+    if (!a) return null;
+    const o = n.map((e) => r.getFieldByPath(e.__path)).filter((e) => e !== void 0);
+    return o.length === 0 ? null : _(() => {
+      o.forEach((e) => e.value.value), m(() => {
+        if (u) {
+          const t = r.getValue();
+          if (!u(t)) return;
+        }
+        const e = o.map((t) => t.value.value), l = {};
+        n.forEach((t, d) => {
+          const g = t.__path.split(".").pop() || t.__path;
+          l[g] = e[d];
+        });
+        const c = s(l);
+        a.value.peek() !== c && V(() => {
+          a.setValue(c, { emitEvent: !1 });
+        });
+      });
+    });
+  };
+  v().register(h, { debounce: p });
+}
+export {
+  N as computeFrom
+};

package/dist/behaviors/copy-from.d.ts

@@ -0,0 +1,2 @@
+export * from '../core/behavior/behaviors/copy-from'
+export {}

package/dist/behaviors/copy-from.js

@@ -0,0 +1,29 @@
+import { r as s } from "../safe-effect-Dh8uw81c.js";
+import { watchField as d } from "./watch-field.js";
+function E(l, c, m) {
+  const { when: a, fields: o = "all", transform: i, debounce: p } = m || {};
+  d(
+    l,
+    (t, n) => {
+      if (a) {
+        const f = n.form.getValue();
+        if (!a(f)) return;
+      }
+      const h = i ? i(t) : t, e = n.form.getFieldByPath(c.__path);
+      e && s(() => {
+        if (o === "all" || !o)
+          e.setValue(h, { emitEvent: !1 });
+        else {
+          const f = {};
+          o.forEach((r) => {
+            t && typeof t == "object" && (f[r] = t[r]);
+          }), "patchValue" in e && e.patchValue(f);
+        }
+      });
+    },
+    { debounce: p }
+  );
+}
+export {
+  E as copyFrom
+};

package/dist/behaviors/enable-when.d.ts

@@ -0,0 +1,2 @@
+export * from '../core/behavior/behaviors/enable-when'
+export {}

package/dist/behaviors/enable-when.js

@@ -0,0 +1,25 @@
+import { effect as c } from "@preact/signals-core";
+import { b } from "../registry-helpers-Bv_BJ1s-.js";
+import { r as d } from "../safe-effect-Dh8uw81c.js";
+function h(t, n, r) {
+  const { debounce: o, resetOnDisable: a = !1 } = r || {}, i = (s, m, l) => {
+    const e = s.getFieldByPath(t.__path);
+    return e ? c(() => {
+      const f = s.value.value;
+      l(() => {
+        const u = n(f);
+        d(() => {
+          u ? e.enable() : (e.disable(), a && e.reset());
+        });
+      });
+    }) : null;
+  };
+  b().register(i, { debounce: o });
+}
+function _(t, n, r) {
+  h(t, (o) => !n(o), r);
+}
+export {
+  _ as disableWhen,
+  h as enableWhen
+};

package/dist/behaviors/reset-when.d.ts

@@ -0,0 +1,2 @@
+export * from '../core/behavior/behaviors/reset-when'
+export {}

package/dist/behaviors/reset-when.js

@@ -0,0 +1,24 @@
+import { effect as c } from "@preact/signals-core";
+import { b as d } from "../registry-helpers-Bv_BJ1s-.js";
+import { r as h } from "../safe-effect-Dh8uw81c.js";
+function R(r, n, o) {
+  const { debounce: s, resetValue: u = null, onlyIfDirty: a = !1 } = o || {}, i = (t, m, l) => {
+    const e = t.getFieldByPath(r.__path);
+    return e ? c(() => {
+      const f = t.value.value;
+      l(() => {
+        if (n(f)) {
+          if (a && !e.dirty.value)
+            return;
+          h(() => {
+            e.setValue(u), e.markAsPristine(), e.markAsUntouched();
+          });
+        }
+      });
+    }) : null;
+  };
+  d().register(i, { debounce: s });
+}
+export {
+  R as resetWhen
+};

package/dist/behaviors/revalidate-when.d.ts

@@ -0,0 +1,2 @@
+export * from '../core/behavior/behaviors/revalidate-when'
+export {}

package/dist/behaviors/revalidate-when.js

@@ -0,0 +1,18 @@
+import { effect as d } from "@preact/signals-core";
+import { b as h } from "../registry-helpers-Bv_BJ1s-.js";
+function p(o, a, i) {
+  const { debounce: l } = i || {}, u = (t, s, c) => {
+    const r = t.getFieldByPath(o.__path);
+    if (!r) return null;
+    const n = a.map((e) => t.getFieldByPath(e.__path)).filter((e) => e !== void 0);
+    return n.length === 0 ? null : d(() => {
+      n.forEach((e) => e.value.value), c(() => {
+        r.validate();
+      });
+    });
+  };
+  h().register(u, { debounce: l });
+}
+export {
+  p as revalidateWhen
+};

package/dist/behaviors/sync-fields.d.ts

@@ -0,0 +1,2 @@
+export * from '../core/behavior/behaviors/sync-fields'
+export {}

package/dist/behaviors/sync-fields.js

@@ -0,0 +1,41 @@
+import { effect as o } from "@preact/signals-core";
+import { b as v } from "../registry-helpers-Bv_BJ1s-.js";
+import { r as i } from "../safe-effect-Dh8uw81c.js";
+function E(u, f, c) {
+  const { debounce: d, transform: a } = c || {}, p = (n, h, l) => {
+    const r = n.getFieldByPath(u.__path), s = n.getFieldByPath(f.__path);
+    if (!r || !s) return null;
+    let e = !1;
+    const g = o(() => {
+      const t = r.value.value;
+      e || l(() => {
+        e = !0, i(() => {
+          try {
+            const y = a ? a(t) : t;
+            s.setValue(y, { emitEvent: !1 });
+          } finally {
+            e = !1;
+          }
+        });
+      });
+    }), m = o(() => {
+      const t = s.value.value;
+      e || l(() => {
+        e = !0, i(() => {
+          try {
+            r.setValue(t, { emitEvent: !1 });
+          } finally {
+            e = !1;
+          }
+        });
+      });
+    });
+    return () => {
+      g(), m();
+    };
+  };
+  v().register(p, { debounce: d });
+}
+export {
+  E as syncFields
+};

package/dist/behaviors/transform-value.d.ts

@@ -0,0 +1,2 @@
+export * from '../core/behavior/behaviors/transform-value'
+export {}

package/dist/behaviors/transform-value.js

@@ -0,0 +1,45 @@
+import { watchField as p } from "./watch-field.js";
+function u(e, t, o) {
+  const { onUserChangeOnly: n = !1, emitEvent: m = !0, debounce: c } = o || {};
+  p(
+    e,
+    (s, i) => {
+      const a = i.form.getFieldByPath(e.__path);
+      if (!a || n && !a.touched.value)
+        return;
+      const f = t(s);
+      f !== s && a.setValue(f, { emitEvent: m });
+    },
+    { debounce: c }
+  );
+}
+function r(e, t) {
+  return (o, n) => {
+    u(o, e, { ...t, ...n });
+  };
+}
+const h = {
+  /** Перевести в верхний регистр */
+  toUpperCase: r((e) => e?.toUpperCase()),
+  /** Перевести в нижний регистр */
+  toLowerCase: r((e) => e?.toLowerCase()),
+  /** Удалить пробелы с краев */
+  trim: r((e) => e?.trim()),
+  /** Удалить все пробелы */
+  removeSpaces: r((e) => e?.replace(/\s/g, "")),
+  /** Оставить только цифры */
+  digitsOnly: r((e) => e?.replace(/\D/g, "")),
+  /** Округлить число */
+  round: r(
+    (e) => typeof e == "number" ? Math.round(e) : e
+  ),
+  /** Округлить до 2 знаков после запятой */
+  roundTo2: r(
+    (e) => typeof e == "number" ? Math.round(e * 100) / 100 : e
+  )
+};
+export {
+  r as createTransformer,
+  u as transformValue,
+  h as transformers
+};

package/dist/behaviors/watch-field.d.ts

@@ -0,0 +1,2 @@
+export * from '../core/behavior/behaviors/watch-field'
+export {}

package/dist/behaviors/watch-field.js

@@ -0,0 +1,21 @@
+import { effect as c } from "@preact/signals-core";
+import { b as d } from "../registry-helpers-Bv_BJ1s-.js";
+import { r as i } from "../safe-effect-Dh8uw81c.js";
+function g(n, r, u) {
+  const { debounce: a, immediate: f = !1 } = u || {}, s = (l, o, m) => {
+    const e = l.getFieldByPath(n.__path);
+    return e ? (f && i(() => {
+      const t = e.value.value;
+      r(t, o);
+    }), c(() => {
+      const t = e.value.value;
+      m(() => {
+        i(() => r(t, o));
+      });
+    })) : null;
+  };
+  d().register(s, { debounce: a });
+}
+export {
+  g as watchField
+};

package/dist/behaviors.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Re-export behaviors from the main index to ensure single module instance.
+ * This prevents static registry isolation issues when consuming the library.
+ */
+export { behaviors as default } from './index';
+export * from './core/behavior';

package/dist/behaviors.js

@@ -0,0 +1,29 @@
+import { a as o, b as a, i as t, t as m } from "./index-D25LsbRm.js";
+import { a as s, B as f } from "./registry-helpers-Bv_BJ1s-.js";
+import { copyFrom as n } from "./behaviors/copy-from.js";
+import { disableWhen as h, enableWhen as i } from "./behaviors/enable-when.js";
+import { computeFrom as c } from "./behaviors/compute-from.js";
+import { watchField as F } from "./behaviors/watch-field.js";
+import { revalidateWhen as v } from "./behaviors/revalidate-when.js";
+import { syncFields as b } from "./behaviors/sync-fields.js";
+import { resetWhen as g } from "./behaviors/reset-when.js";
+import { createTransformer as C, transformValue as I, transformers as P } from "./behaviors/transform-value.js";
+export {
+  s as BehaviorContextImpl,
+  f as BehaviorRegistry,
+  o as apply,
+  a as applyWhen,
+  c as computeFrom,
+  n as copyFrom,
+  C as createTransformer,
+  t as default,
+  h as disableWhen,
+  i as enableWhen,
+  g as resetWhen,
+  v as revalidateWhen,
+  b as syncFields,
+  m as toBehaviorFieldPath,
+  I as transformValue,
+  P as transformers,
+  F as watchField
+};

package/dist/core/behavior/behavior-context.d.ts

@@ -0,0 +1,47 @@
+import { GroupNode } from '../nodes/group-node';
+import { FormProxy } from '../types/form-proxy';
+import { FormContext } from '../types/form-context';
+import { FieldPathNode } from '../types/field-path';
+/**
+ * Реализация {@link FormContext} для behaviors. Создаётся фреймворком и передаётся
+ * в callback'и behaviors (`watchField`, `computeFrom`, …) — напрямую инстанцировать
+ * не нужно.
+ *
+ * @example
+ * ```typescript
+ * import { watchField } from '@reformer/core/behaviors/watch-field';
+ *
+ * watchField(path.country, (value, ctx) => {
+ *   // ctx — экземпляр BehaviorContextImpl
+ *   ctx.setFieldValue(path.city, '');
+ * });
+ * ```
+ */
+export declare class BehaviorContextImpl<TForm> implements FormContext<TForm> {
+    /**
+     * Форма с типизированным Proxy-доступом к полям
+     */
+    readonly form: FormProxy<TForm>;
+    private _form;
+    constructor(form: GroupNode<TForm>);
+    /**
+     * Безопасно установить значение поля по строковому пути или FieldPath
+     *
+     * Автоматически использует emitEvent: false для предотвращения циклов
+     *
+     * @param path - Строковый путь к полю или FieldPath объект
+     * @param value - Новое значение
+     */
+    setFieldValue(path: string | FieldPathNode<TForm, unknown>, value: unknown): void;
+    /**
+     * Получить поле формы по строковому пути
+     *
+     * Используется для динамического доступа к вложенным полям, например:
+     * - `ctx.getFieldByPath('address.city')` -> FieldNode
+     * - `ctx.getFieldByPath(path.city.__path)` -> FieldNode (для nested behaviors)
+     *
+     * @param path - Строковый путь к полю (например "address.city")
+     * @returns FieldNode или undefined если поле не найдено
+     */
+    getFieldByPath(path: string): import('../..').FormNode<import('../types').FormValue> | undefined;
+}

package/dist/core/behavior/behavior-registry.d.ts

@@ -0,0 +1,85 @@
+import { GroupNode } from '../nodes/group-node';
+import { BehaviorHandlerFn, BehaviorOptions } from './types';
+import { AbstractRegistry } from '../utils/abstract-registry';
+import { FormFields } from '../types';
+/**
+ * Зарегистрированный behavior с опциями
+ */
+export interface RegisteredBehavior {
+    /** Handler функция behavior */
+    handler: BehaviorHandlerFn<FormFields>;
+    /** Debounce в миллисекундах */
+    debounce?: number;
+}
+/**
+ * Реестр behaviors для формы
+ *
+ * Каждый экземпляр GroupNode создает собственный реестр (композиция).
+ * Устраняет race conditions и изолирует формы друг от друга.
+ *
+ * Наследует AbstractRegistry для унификации:
+ * - Управления global stack
+ * - Template methods begin/end registration
+ *
+ * @example
+ * ```typescript
+ * class GroupNode {
+ *   private readonly behaviorRegistry = new BehaviorRegistry();
+ *
+ *   applyBehaviorSchema(schemaFn) {
+ *     this.behaviorRegistry.beginRegistration(); // Pushes this to stack
+ *     schemaFn(createBehaviorFieldPath(this));   // Uses getCurrent()
+ *     return this.behaviorRegistry.endRegistration(this); // Pops from stack
+ *   }
+ * }
+ * ```
+ */
+export declare class BehaviorRegistry extends AbstractRegistry<RegisteredBehavior> {
+    /**
+     * Получить текущий активный реестр из context stack
+     *
+     * @returns Текущий активный реестр или null
+     *
+     * @example
+     * ```typescript
+     * // В schema-behaviors.ts
+     * export function copyFrom(...) {
+     *   const registry = BehaviorRegistry.getCurrent();
+     *   if (registry) {
+     *     registry.register({ ... });
+     *   }
+     * }
+     * ```
+     */
+    static getCurrent(): BehaviorRegistry | null;
+    /**
+     * Зарегистрировать behavior handler
+     * Вызывается функциями из schema-behaviors.ts
+     *
+     * @param handler - BehaviorHandlerFn функция
+     * @param options - Опции behavior (debounce)
+     *
+     * @example
+     * ```typescript
+     * const handler = createCopyBehavior(target, source, { when: ... });
+     * registry.register(handler, { debounce: 300 });
+     * ```
+     */
+    register<T extends FormFields>(handler: BehaviorHandlerFn<T>, options?: BehaviorOptions): void;
+    /**
+     * Завершить регистрацию и применить behaviors к форме
+     * Создает effect подписки для всех зарегистрированных behaviors
+     *
+     * @param form - GroupNode формы
+     * @returns Количество зарегистрированных behaviors и функция cleanup
+     */
+    endRegistration<T extends FormFields>(form: GroupNode<T>): {
+        count: number;
+        cleanup: () => void;
+    };
+    /**
+     * Создать effect подписку для behavior
+     * @private
+     */
+    private createEffect;
+}