@reformer/core 1.0.0-beta.3

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,53 @@
+# @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.
+
+## Installation
+
+```bash
+npm install @reformer/core
+```
+
+## Features
+
+- Signals-based reactive state management
+- Declarative form validation
+- Dynamic form behaviors
+- TypeScript support
+- Tree-shakeable exports
+
+## Quick Start
+
+```tsx
+import { createForm, useFormControl } from '@reformer/core';
+
+const form = createForm({
+  schema: {
+    name: { initialValue: '' },
+    email: { initialValue: '' }
+  }
+});
+
+function MyForm() {
+  const name = useFormControl(form.controls.name);
+
+  return (
+    <input
+      value={name.value}
+      onChange={(e) => name.setValue(e.target.value)}
+    />
+  );
+}
+```
+
+## Documentation
+
+Full documentation is available at [https://alexandrbukhtatyy.github.io/ReFormer/](https://alexandrbukhtatyy.github.io/ReFormer/)
+
+## License
+
+MIT

package/dist/behaviors.d.ts

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

package/dist/behaviors.js

@@ -0,0 +1,230 @@
+import { a as y, E as p, c as b } from "./create-field-path-CdPF3lIK.js";
+import { b as M, B as T } from "./create-field-path-CdPF3lIK.js";
+function v(e, t, r) {
+  const { debounce: a, immediate: s = !1 } = r || {}, l = (u, i, c) => {
+    const o = u.getFieldByPath(e.__path);
+    if (!o) return null;
+    if (s) {
+      const n = o.value.value;
+      t(n, i);
+    }
+    return p(() => {
+      const n = o.value.value;
+      c(() => {
+        t(n, i);
+      });
+    });
+  };
+  y().register(l, { debounce: a });
+}
+function A(e, t, r) {
+  const { when: a, fields: s = "all", transform: l, debounce: u } = r || {};
+  v(
+    e,
+    (i, c) => {
+      if (a) {
+        const f = c.form.getValue();
+        if (!a(f)) return;
+      }
+      const o = l ? l(i) : i, n = c.form.getFieldByPath(t.__path);
+      if (n)
+        if (s === "all" || !s)
+          n.setValue(o, { emitEvent: !1 });
+        else {
+          const f = {};
+          s.forEach((d) => {
+            i && typeof i == "object" && (f[d] = i[d]);
+          }), "patchValue" in n && n.patchValue(f);
+        }
+    },
+    { debounce: u }
+  );
+}
+function V(e, t, r) {
+  const { debounce: a, resetOnDisable: s = !1 } = r || {}, l = (u, i, c) => {
+    const o = u.getFieldByPath(e.__path);
+    return o ? p(() => {
+      const n = u.value.value;
+      c(() => {
+        t(n) ? o.enable() : (o.disable(), s && o.reset());
+      });
+    }) : null;
+  };
+  y().register(l, { debounce: a });
+}
+function C(e, t, r) {
+  V(e, (a) => !t(a), r);
+}
+function R(e, t, r, a) {
+  const { debounce: s, condition: l } = a || {}, u = (i, c, o) => {
+    const n = i.getFieldByPath(t.__path);
+    if (!n) return null;
+    const f = e.map((d) => i.getFieldByPath(d.__path)).filter((d) => d !== void 0);
+    return f.length === 0 ? null : p(() => {
+      const d = f.map((g) => g.value.value);
+      o(() => {
+        if (l) {
+          const m = i.getValue();
+          if (!l(m)) return;
+        }
+        const g = {};
+        e.forEach((m, P) => {
+          const B = m.__path.split(".").pop() || m.__path;
+          g[B] = d[P];
+        });
+        const _ = r(g);
+        n.setValue(_, { emitEvent: !1 });
+      });
+    });
+  };
+  y().register(u, { debounce: s });
+}
+function U(e, t, r) {
+  const { debounce: a } = r || {}, s = (l, u, i) => {
+    const c = l.getFieldByPath(e.__path);
+    if (!c) return null;
+    const o = t.map((n) => l.getFieldByPath(n.__path)).filter((n) => n !== void 0);
+    return o.length === 0 ? null : p(() => {
+      o.forEach((n) => n.value.value), i(() => {
+        c.validate();
+      });
+    });
+  };
+  y().register(s, { debounce: a });
+}
+function W(e, t, r) {
+  const { debounce: a, transform: s } = r || {}, l = (u, i, c) => {
+    const o = u.getFieldByPath(e.__path), n = u.getFieldByPath(t.__path);
+    if (!o || !n) return null;
+    let f = !1;
+    const d = p(() => {
+      const _ = o.value.value;
+      f || c(() => {
+        f = !0;
+        const m = s ? s(_) : _;
+        n.setValue(m, { emitEvent: !1 }), f = !1;
+      });
+    }), g = p(() => {
+      const _ = n.value.value;
+      f || c(() => {
+        f = !0, o.setValue(_, { emitEvent: !1 }), f = !1;
+      });
+    });
+    return () => {
+      d(), g();
+    };
+  };
+  y().register(l, { debounce: a });
+}
+function w(e, t, r) {
+  const { debounce: a, resetValue: s = null, onlyIfDirty: l = !1 } = r || {}, u = (i, c, o) => {
+    const n = i.getFieldByPath(e.__path);
+    return n ? p(() => {
+      const f = i.value.value;
+      o(() => {
+        if (t(f)) {
+          if (l && !n.dirty.value)
+            return;
+          n.setValue(s), n.markAsPristine(), n.markAsUntouched();
+        }
+      });
+    }) : null;
+  };
+  y().register(u, { debounce: a });
+}
+function F(e, t, r) {
+  const { onUserChangeOnly: a = !1, emitEvent: s = !0, debounce: l } = r || {};
+  v(
+    e,
+    (u, i) => {
+      const c = i.form.getFieldByPath(e.__path);
+      if (!c || a && !c.touched.value)
+        return;
+      const o = t(u);
+      o !== u && c.setValue(o, { emitEvent: s });
+    },
+    { debounce: l }
+  );
+}
+function h(e, t) {
+  return (r, a) => {
+    F(r, e, { ...t, ...a });
+  };
+}
+const O = {
+  /** Перевести в верхний регистр */
+  toUpperCase: h((e) => e?.toUpperCase()),
+  /** Перевести в нижний регистр */
+  toLowerCase: h((e) => e?.toLowerCase()),
+  /** Удалить пробелы с краев */
+  trim: h((e) => e?.trim()),
+  /** Удалить все пробелы */
+  removeSpaces: h((e) => e?.replace(/\s/g, "")),
+  /** Оставить только цифры */
+  digitsOnly: h((e) => e?.replace(/\D/g, "")),
+  /** Округлить число */
+  round: h(
+    (e) => typeof e == "number" ? Math.round(e) : e
+  ),
+  /** Округлить до 2 знаков после запятой */
+  roundTo2: h(
+    (e) => typeof e == "number" ? Math.round(e * 100) / 100 : e
+  )
+};
+function N(e) {
+  if (!e)
+    return b();
+  const t = e.__path;
+  return E(t);
+}
+function E(e) {
+  return new Proxy({}, {
+    get(t, r) {
+      return typeof r == "symbol" ? void 0 : {
+        __path: e ? `${e}.${r}` : r,
+        __key: r
+      };
+    }
+  });
+}
+function j(e, t) {
+  const r = (Array.isArray(e) ? e : [e]).filter(Boolean), a = Array.isArray(t) ? t : [t];
+  for (const s of r) {
+    const l = N(s);
+    for (const u of a)
+      u(l);
+  }
+}
+function D(e, t, r) {
+  if (!e) return;
+  let a = !1;
+  v(
+    e,
+    (s, l) => {
+      if (!a && t(s)) {
+        const u = b();
+        r(u), a = !0;
+      }
+    },
+    { immediate: !0 }
+  );
+}
+export {
+  M as BehaviorContextImpl,
+  T as BehaviorRegistry,
+  j as apply,
+  D as applyWhen,
+  R as computeFrom,
+  A as copyFrom,
+  b as createFieldPath,
+  h as createTransformer,
+  C as disableWhen,
+  V as enableWhen,
+  w as resetWhen,
+  U as revalidateWhen,
+  W as syncFields,
+  N as toBehaviorFieldPath,
+  F as transformValue,
+  O as transformers,
+  v as watchField
+};

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

@@ -0,0 +1,71 @@
+/**
+ * Применение behavior схемы к форме
+ *
+ * Извлечено из GroupNode для соблюдения SRP (Single Responsibility Principle).
+ * Управляет процессом регистрации и применения behaviors.
+ *
+ * @template T Тип формы
+ *
+ * @example
+ * ```typescript
+ * class GroupNode {
+ *   private readonly behaviorApplicator = new BehaviorApplicator(this);
+ *
+ *   applyBehaviorSchema(schemaFn: BehaviorSchemaFn<T>): () => void {
+ *     return this.behaviorApplicator.apply(schemaFn);
+ *   }
+ * }
+ * ```
+ */
+import type { GroupNode } from '../nodes/group-node';
+import type { BehaviorSchemaFn } from './types';
+import { BehaviorRegistry } from './behavior-registry';
+/**
+ * Класс для применения behavior схемы к форме
+ *
+ * Выполняет:
+ * 1. Начало регистрации behaviors (beginRegistration)
+ * 2. Выполнение схемы (регистрация behaviors)
+ * 3. Завершение регистрации (endRegistration) - применение behaviors
+ * 4. Возврат функции cleanup для отписки
+ *
+ * @template T Тип формы (объект)
+ */
+export declare class BehaviorApplicator<T> {
+    private readonly form;
+    private readonly behaviorRegistry;
+    constructor(form: GroupNode<T>, behaviorRegistry: BehaviorRegistry);
+    /**
+     * Применить behavior схему к форме
+     *
+     * Этапы:
+     * 1. Начать регистрацию (beginRegistration)
+     * 2. Выполнить схему (регистрация behaviors)
+     * 3. Завершить регистрацию (endRegistration) - применить behaviors
+     * 4. Вернуть функцию cleanup для отписки
+     *
+     * @param schemaFn Функция-схема behavior
+     * @returns Функция отписки от всех behaviors
+     *
+     * @example
+     * ```typescript
+     * const cleanup = behaviorApplicator.apply((path) => {
+     *   copyFrom(path.residenceAddress, path.registrationAddress, {
+     *     when: (form) => form.sameAsRegistration === true
+     *   });
+     *
+     *   enableWhen(path.propertyValue, (form) => form.loanType === 'mortgage');
+     *
+     *   computeFrom(
+     *     path.initialPayment,
+     *     [path.propertyValue],
+     *     (propertyValue) => propertyValue ? propertyValue * 0.2 : null
+     *   );
+     * });
+     *
+     * // Cleanup при unmount
+     * useEffect(() => cleanup, []);
+     * ```
+     */
+    apply(schemaFn: BehaviorSchemaFn<T>): () => void;
+}

package/dist/core/behavior/behavior-applicator.js

@@ -0,0 +1,92 @@
+/**
+ * Применение behavior схемы к форме
+ *
+ * Извлечено из GroupNode для соблюдения SRP (Single Responsibility Principle).
+ * Управляет процессом регистрации и применения behaviors.
+ *
+ * @template T Тип формы
+ *
+ * @example
+ * ```typescript
+ * class GroupNode {
+ *   private readonly behaviorApplicator = new BehaviorApplicator(this);
+ *
+ *   applyBehaviorSchema(schemaFn: BehaviorSchemaFn<T>): () => void {
+ *     return this.behaviorApplicator.apply(schemaFn);
+ *   }
+ * }
+ * ```
+ */
+import { createFieldPath as createBehaviorFieldPath } from './create-field-path';
+import { FormErrorHandler, ErrorStrategy } from '../utils/error-handler';
+/**
+ * Класс для применения behavior схемы к форме
+ *
+ * Выполняет:
+ * 1. Начало регистрации behaviors (beginRegistration)
+ * 2. Выполнение схемы (регистрация behaviors)
+ * 3. Завершение регистрации (endRegistration) - применение behaviors
+ * 4. Возврат функции cleanup для отписки
+ *
+ * @template T Тип формы (объект)
+ */
+export class BehaviorApplicator {
+    form;
+    behaviorRegistry;
+    constructor(form, behaviorRegistry) {
+        this.form = form;
+        this.behaviorRegistry = behaviorRegistry;
+    }
+    /**
+     * Применить behavior схему к форме
+     *
+     * Этапы:
+     * 1. Начать регистрацию (beginRegistration)
+     * 2. Выполнить схему (регистрация behaviors)
+     * 3. Завершить регистрацию (endRegistration) - применить behaviors
+     * 4. Вернуть функцию cleanup для отписки
+     *
+     * @param schemaFn Функция-схема behavior
+     * @returns Функция отписки от всех behaviors
+     *
+     * @example
+     * ```typescript
+     * const cleanup = behaviorApplicator.apply((path) => {
+     *   copyFrom(path.residenceAddress, path.registrationAddress, {
+     *     when: (form) => form.sameAsRegistration === true
+     *   });
+     *
+     *   enableWhen(path.propertyValue, (form) => form.loanType === 'mortgage');
+     *
+     *   computeFrom(
+     *     path.initialPayment,
+     *     [path.propertyValue],
+     *     (propertyValue) => propertyValue ? propertyValue * 0.2 : null
+     *   );
+     * });
+     *
+     * // Cleanup при unmount
+     * useEffect(() => cleanup, []);
+     * ```
+     */
+    apply(schemaFn) {
+        this.behaviorRegistry.beginRegistration();
+        try {
+            // 1. Создать field path для type-safe доступа к полям
+            const path = createBehaviorFieldPath();
+            // 2. Выполнить схему (регистрация behaviors)
+            schemaFn(path);
+            // 3. Завершить регистрацию и применить behaviors
+            //  Используем публичный метод getProxy() для получения proxy-инстанса
+            const formToUse = this.form.getProxy();
+            const result = this.behaviorRegistry.endRegistration(formToUse);
+            // 4. Вернуть функцию cleanup
+            return result.cleanup;
+        }
+        catch (error) {
+            FormErrorHandler.handle(error, 'BehaviorApplicator', ErrorStrategy.THROW);
+            // TypeScript требует return, но код никогда не дойдет сюда
+            throw error;
+        }
+    }
+}

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

@@ -0,0 +1,29 @@
+/**
+ * BehaviorContext - контекст для behavior callback функций
+ *
+ * Реализует FormContext для behavior схем
+ */
+import type { GroupNode } from '../nodes/group-node';
+import type { GroupNodeWithControls } from '../types/group-node-proxy';
+import type { FormContext } from '../types/form-context';
+/**
+ * Реализация BehaviorContext (FormContext)
+ *
+ * Предоставляет:
+ * - `form` - прямой типизированный доступ к форме
+ * - `setFieldValue` - безопасная установка значения (emitEvent: false)
+ */
+export declare class BehaviorContextImpl<TForm> implements FormContext<TForm> {
+    /**
+     * Форма с типизированным Proxy-доступом к полям
+     */
+    readonly form: GroupNodeWithControls<TForm>;
+    private _form;
+    constructor(form: GroupNode<TForm>);
+    /**
+     * Безопасно установить значение поля по строковому пути
+     *
+     * Автоматически использует emitEvent: false для предотвращения циклов
+     */
+    setFieldValue(path: string, value: unknown): void;
+}

package/dist/core/behavior/behavior-context.js

@@ -0,0 +1,38 @@
+/**
+ * BehaviorContext - контекст для behavior callback функций
+ *
+ * Реализует FormContext для behavior схем
+ */
+/**
+ * Реализация BehaviorContext (FormContext)
+ *
+ * Предоставляет:
+ * - `form` - прямой типизированный доступ к форме
+ * - `setFieldValue` - безопасная установка значения (emitEvent: false)
+ */
+export class BehaviorContextImpl {
+    /**
+     * Форма с типизированным Proxy-доступом к полям
+     */
+    form;
+    _form;
+    constructor(form) {
+        this._form = form;
+        // Используем _proxyInstance если доступен, иначе fallback на form
+        const proxy = (form
+            ._proxyInstance || form);
+        this.form = proxy;
+    }
+    /**
+     * Безопасно установить значение поля по строковому пути
+     *
+     * Автоматически использует emitEvent: false для предотвращения циклов
+     */
+    setFieldValue(path, value) {
+        const node = this._form.getFieldByPath(path);
+        if (node) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            node.setValue(value, { emitEvent: false });
+        }
+    }
+}

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

@@ -0,0 +1,97 @@
+/**
+ * BehaviorRegistry - регистрация и управление behavior схемами
+ *
+ * Аналогично ValidationRegistry, но для реактивного поведения форм
+ */
+import type { GroupNode } from '../nodes/group-node';
+import type { BehaviorHandlerFn, BehaviorOptions } from './types';
+import { FormFields } from '../types';
+/**
+ * Реестр behaviors для формы
+ *
+ * Каждый экземпляр GroupNode создает собственный реестр (композиция).
+ * Устраняет race conditions и изолирует формы друг от друга.
+ *
+ * Context stack используется для tracking текущего активного реестра:
+ * - beginRegistration() помещает this в stack
+ * - endRegistration() извлекает из stack
+ * - getCurrent() возвращает текущий активный реестр
+ *
+ * @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 {
+    /**
+     * Stack активных контекстов регистрации
+     * Используется для изоляции форм друг от друга
+     */
+    private static contextStack;
+    private registrations;
+    private isRegistering;
+    /**
+     * Получить текущий активный реестр из context stack
+     *
+     * @returns Текущий активный реестр или null
+     *
+     * @example
+     * ```typescript
+     * // В schema-behaviors.ts
+     * export function copyFrom(...) {
+     *   const registry = BehaviorRegistry.getCurrent();
+     *   if (registry) {
+     *     registry.register({ ... });
+     *   }
+     * }
+     * ```
+     */
+    static getCurrent(): BehaviorRegistry | null;
+    /**
+     * Начать регистрацию behaviors
+     * Вызывается перед применением схемы
+     *
+     * Помещает this в context stack для изоляции форм
+     */
+    beginRegistration(): void;
+    /**
+     * Зарегистрировать 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
+     *
+     * Извлекает this из context stack
+     *
+     * @param form - GroupNode формы
+     * @returns Количество зарегистрированных behaviors и функция cleanup
+     */
+    endRegistration<T extends FormFields>(form: GroupNode<T>): {
+        count: number;
+        cleanup: () => void;
+    };
+    /**
+     * Создать effect подписку для behavior
+     * @private
+     */
+    private createEffect;
+}