@reformer/core 2.0.0-beta.7 → 2.0.0-beta.8

package/dist/registry-helpers-Bv_BJ1s-.js

@@ -0,0 +1,615 @@
+var f = /* @__PURE__ */ ((s) => (s.THROW = "throw", s.LOG = "log", s.CONVERT = "convert", s))(f || {});
+class y {
+  /**
+   * Обработать ошибку согласно заданной стратегии
+   *
+   * @param error Ошибка для обработки (Error | string | unknown)
+   * @param context Контекст ошибки для логирования (например, 'AsyncValidator', 'BehaviorRegistry')
+   * @param strategy Стратегия обработки (THROW | LOG | CONVERT)
+   * @returns ValidationError если strategy = CONVERT, undefined если strategy = LOG, никогда не возвращается если strategy = THROW
+   *
+   * @example
+   * ```typescript
+   * // THROW - пробросить ошибку
+   * try {
+   *   riskyOperation();
+   * } catch (error) {
+   *   FormErrorHandler.handle(error, 'RiskyOperation', ErrorStrategy.THROW);
+   *   // Этот код никогда не выполнится
+   * }
+   *
+   * // LOG - залогировать и продолжить
+   * try {
+   *   nonCriticalOperation();
+   * } catch (error) {
+   *   FormErrorHandler.handle(error, 'NonCritical', ErrorStrategy.LOG);
+   *   // Продолжаем выполнение
+   * }
+   *
+   * // CONVERT - конвертировать в ValidationError
+   * try {
+   *   await validator(value);
+   * } catch (error) {
+   *   const validationError = FormErrorHandler.handle(
+   *     error,
+   *     'AsyncValidator',
+   *     ErrorStrategy.CONVERT
+   *   );
+   *   return validationError;
+   * }
+   * ```
+   */
+  static handle(t, e, i = "throw") {
+    const n = this.extractMessage(t);
+    switch (i) {
+      case "throw":
+        throw t;
+      case "log":
+        return;
+      case "convert":
+        return {
+          code: "validator_error",
+          message: n,
+          params: { field: e }
+        };
+    }
+  }
+  /**
+   * Извлечь сообщение из ошибки
+   *
+   * Обрабатывает различные типы ошибок:
+   * - Error объекты → error.message
+   * - Строки → возвращает как есть
+   * - Объекты с message → извлекает message
+   * - Другое → String(error)
+   *
+   * @param error Ошибка для извлечения сообщения
+   * @returns Сообщение ошибки
+   * @private
+   *
+   * @example
+   * ```typescript
+   * FormErrorHandler.extractMessage(new Error('Test'));
+   * // 'Test'
+   *
+   * FormErrorHandler.extractMessage('String error');
+   * // 'String error'
+   *
+   * FormErrorHandler.extractMessage({ message: 'Object error' });
+   * // 'Object error'
+   *
+   * FormErrorHandler.extractMessage(null);
+   * // 'null'
+   * ```
+   */
+  static extractMessage(t) {
+    return t instanceof Error ? t.message : typeof t == "string" ? t : typeof t == "object" && t !== null && "message" in t ? String(t.message) : String(t);
+  }
+  /**
+   * Создать ValidationError с заданными параметрами
+   *
+   * Утилитная функция для создания ValidationError объектов
+   *
+   * @param code Код ошибки
+   * @param message Сообщение ошибки
+   * @param field Поле (опционально)
+   * @returns ValidationError объект
+   *
+   * @example
+   * ```typescript
+   * const error = FormErrorHandler.createValidationError(
+   *   'required',
+   *   'This field is required',
+   *   'email'
+   * );
+   * // { code: 'required', message: 'This field is required', field: 'email' }
+   * ```
+   */
+  static createValidationError(t, e, i) {
+    return {
+      code: t,
+      message: e,
+      params: i ? { field: i } : void 0
+    };
+  }
+  /**
+   * Проверить, является ли объект ValidationError
+   *
+   * Type guard для ValidationError
+   *
+   * @param value Значение для проверки
+   * @returns true если value является ValidationError
+   *
+   * @example
+   * ```typescript
+   * if (FormErrorHandler.isValidationError(result)) {
+   *   console.log(result.code); // OK, типобезопасно
+   * }
+   * ```
+   */
+  static isValidationError(t) {
+    return typeof t == "object" && t !== null && "code" in t && "message" in t && typeof t.code == "string" && typeof t.message == "string";
+  }
+}
+class m {
+  stack = [];
+  /**
+   * Добавить элемент в стек
+   * @param item - Элемент для добавления
+   */
+  push(t) {
+    this.stack.push(t);
+  }
+  /**
+   * Извлечь элемент из стека
+   * @returns Извлеченный элемент или undefined если стек пуст
+   */
+  pop() {
+    return this.stack.pop();
+  }
+  /**
+   * Получить текущий элемент (вершину стека) без извлечения
+   * @returns Текущий элемент или null если стек пуст
+   */
+  getCurrent() {
+    return this.stack.length > 0 ? this.stack[this.stack.length - 1] : null;
+  }
+  /**
+   * Извлечь элемент из стека с проверкой
+   * Выводит предупреждение в DEV режиме если извлеченный элемент не совпадает с ожидаемым
+   *
+   * @param expected - Ожидаемый элемент
+   * @param name - Имя реестра для отладки (например, 'ValidationRegistry')
+   */
+  verify(t, e) {
+    this.pop();
+  }
+  /**
+   * Получить длину стека
+   * @returns Количество элементов в стеке
+   */
+  get length() {
+    return this.stack.length;
+  }
+  /**
+   * Проверить, пуст ли стек
+   * @returns true если стек пуст
+   */
+  isEmpty() {
+    return this.stack.length === 0;
+  }
+  /**
+   * Очистить стек
+   */
+  clear() {
+    this.stack = [];
+  }
+}
+const l = /* @__PURE__ */ new Map();
+class o {
+  /** Флаг активной регистрации */
+  isRegistering = !1;
+  /** Массив зарегистрированных элементов */
+  registrations = [];
+  /**
+   * Получить стек для конкретного класса реестра
+   * Создает новый стек если не существует
+   *
+   * @param ctor - Конструктор класса реестра
+   * @returns RegistryStack для данного класса
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static getStack(t) {
+    return l.has(t) || l.set(t, new m()), l.get(t);
+  }
+  /**
+   * Получить текущий активный реестр из стека
+   * Должен быть переопределен в наследниках как static метод
+   *
+   * @param ctor - Конструктор класса реестра
+   * @returns Текущий активный реестр или null
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static getCurrentFromStack(t) {
+    return this.getStack(t).getCurrent();
+  }
+  /**
+   * Начать регистрацию
+   *
+   * Помещает this в global stack для изоляции форм
+   * Вызывает hook onBeginRegistration()
+   */
+  beginRegistration() {
+    this.isRegistering = !0, this.registrations = [], o.getStack(this.constructor).push(this), this.onBeginRegistration();
+  }
+  /**
+   * Проверить, активна ли регистрация
+   */
+  isActive() {
+    return this.isRegistering;
+  }
+  /**
+   * Получить зарегистрированные элементы
+   */
+  getRegistrations() {
+    return this.registrations;
+  }
+  /**
+   * Hook: вызывается в начале регистрации
+   * Может быть переопределен в наследниках для инициализации
+   */
+  onBeginRegistration() {
+  }
+  /**
+   * Завершить регистрацию и извлечь из стека
+   *
+   * @param registryName - Имя реестра для отладки
+   */
+  completeRegistration(t) {
+    this.isRegistering = !1, o.getStack(this.constructor).verify(this, t);
+  }
+  /**
+   * Отменить регистрацию без применения
+   *
+   * @param registryName - Имя реестра для отладки
+   */
+  cancelRegistration(t) {
+    this.isRegistering = !1, this.registrations = [], o.getStack(this.constructor).verify(this, t);
+  }
+}
+class x {
+  validators = [];
+  conditionStack = [];
+  /**
+   * Добавить валидатор в контекст
+   */
+  addValidator(t) {
+    if (this.conditionStack.length > 0) {
+      const e = this.conditionStack[this.conditionStack.length - 1];
+      t.condition = e;
+    }
+    this.validators.push(t);
+  }
+  /**
+   * Войти в условный блок
+   */
+  enterCondition(t, e) {
+    this.conditionStack.push({ fieldPath: t, conditionFn: e });
+  }
+  /**
+   * Выйти из условного блока
+   */
+  exitCondition() {
+    this.conditionStack.pop();
+  }
+  /**
+   * Получить все зарегистрированные валидаторы
+   */
+  getValidators() {
+    return this.validators;
+  }
+}
+class d extends o {
+  /** Внутренний стек контекстов для управления condition blocks */
+  contextStack = [];
+  /** Финальные валидаторы после завершения регистрации */
+  validators = [];
+  /**
+   * Получить текущий активный реестр из global stack
+   *
+   * @returns Текущий активный реестр или null
+   *
+   * @example
+   * ```typescript
+   * // В schema-validators.ts
+   * export function required(...) {
+   *   const registry = ValidationRegistry.getCurrent();
+   *   if (registry) {
+   *     registry.registerSync(...);
+   *   }
+   * }
+   * ```
+   */
+  static getCurrent() {
+    return o.getCurrentFromStack(d);
+  }
+  /**
+   * Начать регистрацию валидаторов для формы
+   *
+   * Помещает this в global stack для изоляции форм
+   * Создает новый RegistrationContext для condition management
+   */
+  beginRegistration() {
+    super.beginRegistration();
+    const t = new x();
+    return this.contextStack.push(t), t;
+  }
+  /**
+   * Завершить регистрацию и применить валидаторы к GroupNode
+   *
+   * Извлекает this из global stack
+   *
+   * Сохраняет валидаторы в локальном состоянии (this.validators) вместо глобального WeakMap.
+   */
+  endRegistration(t) {
+    const e = this.contextStack.pop();
+    if (!e)
+      throw new Error("No active registration context");
+    this.completeRegistration("ValidationRegistry"), this.validators = e.getValidators(), this.applyArrayItemValidators(t, this.validators);
+  }
+  /**
+   * Отменить регистрацию без применения валидаторов
+   * Используется для временной валидации (например, в validateForm)
+   *
+   * Извлекает this из global stack
+   */
+  cancelRegistration() {
+    if (!this.contextStack.pop())
+      throw new Error("No active registration context to cancel");
+    super.cancelRegistration("ValidationRegistry");
+  }
+  /**
+   * Получить текущий контекст регистрации
+   */
+  getCurrentContext() {
+    return this.contextStack[this.contextStack.length - 1];
+  }
+  /**
+   * Зарегистрировать синхронный валидатор
+   */
+  registerSync(t, e, i) {
+    const n = this.getCurrentContext();
+    if (!n)
+      throw new Error("Validators can only be registered inside a validation schema function");
+    n.addValidator({
+      fieldPath: t,
+      type: "sync",
+      validator: e,
+      options: i
+    });
+  }
+  /**
+   * Зарегистрировать асинхронный валидатор
+   */
+  registerAsync(t, e, i) {
+    const n = this.getCurrentContext();
+    if (!n)
+      throw new Error("Validators can only be registered inside a validation schema function");
+    n.addValidator({
+      fieldPath: t,
+      type: "async",
+      validator: e,
+      options: i
+    });
+  }
+  /**
+   * Зарегистрировать tree валидатор
+   */
+  registerTree(t, e) {
+    const i = this.getCurrentContext();
+    if (!i)
+      throw new Error("Validators can only be registered inside a validation schema function");
+    i.addValidator({
+      fieldPath: e?.targetField || "__tree__",
+      type: "tree",
+      validator: t,
+      options: e
+    });
+  }
+  /**
+   * Войти в условный блок
+   */
+  enterCondition(t, e) {
+    const i = this.getCurrentContext();
+    if (!i)
+      throw new Error("Conditions can only be used inside a validation schema function");
+    i.enterCondition(t, e);
+  }
+  /**
+   * Выйти из условного блока
+   */
+  exitCondition() {
+    const t = this.getCurrentContext();
+    if (!t)
+      throw new Error("No active condition");
+    t.exitCondition();
+  }
+  /**
+   * Зарегистрировать validation schema для элементов массива
+   *
+   * Используется функцией validateItems() для регистрации схемы валидации,
+   * которая будет применяться к каждому элементу ArrayNode.
+   *
+   * @param fieldPath - Путь к ArrayNode полю
+   * @param itemSchemaFn - Validation schema для элемента массива
+   */
+  registerArrayItemValidation(t, e) {
+    const i = this.getCurrentContext();
+    if (!i)
+      throw new Error(
+        "Array item validators can only be registered inside a validation schema function"
+      );
+    i.addValidator({
+      fieldPath: t,
+      type: "array-items",
+      validator: e,
+      options: {}
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    });
+  }
+  /**
+   * Получить зарегистрированные валидаторы для этого реестра
+   *
+   * Возвращает локальный массив валидаторов (без аргумента form).
+   */
+  getValidators() {
+    return this.validators;
+  }
+  /**
+   * Применить array-items validators к ArrayNode элементам
+   * @private
+   */
+  applyArrayItemValidators(t, e) {
+    const i = e.filter((n) => n.type === "array-items");
+    if (i.length !== 0)
+      for (const n of i) {
+        const a = t[n.fieldPath.split(".")[0]];
+        if (a && "applyValidationSchema" in a) {
+          const r = n.validator;
+          a.applyValidationSchema(r);
+        } else
+          y.handle(
+            new Error(`Field ${n.fieldPath} is not an ArrayNode or doesn't exist`),
+            "ValidationRegistry.applyArrayItemValidators",
+            f.LOG
+          );
+      }
+  }
+}
+class C {
+  /**
+   * Форма с типизированным Proxy-доступом к полям
+   */
+  form;
+  _form;
+  constructor(t) {
+    this._form = t;
+    const e = t._proxyInstance || t;
+    this.form = e;
+  }
+  /**
+   * Безопасно установить значение поля по строковому пути или FieldPath
+   *
+   * Автоматически использует emitEvent: false для предотвращения циклов
+   *
+   * @param path - Строковый путь к полю или FieldPath объект
+   * @param value - Новое значение
+   */
+  setFieldValue(t, e) {
+    const i = typeof t == "string" ? t : t.__path, n = this._form.getFieldByPath(i);
+    n && n.setValue(e, { emitEvent: !1 });
+  }
+  /**
+   * Получить поле формы по строковому пути
+   *
+   * Используется для динамического доступа к вложенным полям, например:
+   * - `ctx.getFieldByPath('address.city')` -> FieldNode
+   * - `ctx.getFieldByPath(path.city.__path)` -> FieldNode (для nested behaviors)
+   *
+   * @param path - Строковый путь к полю (например "address.city")
+   * @returns FieldNode или undefined если поле не найдено
+   */
+  getFieldByPath(t) {
+    return this._form.getFieldByPath(t);
+  }
+}
+class h extends o {
+  /**
+   * Получить текущий активный реестр из context stack
+   *
+   * @returns Текущий активный реестр или null
+   *
+   * @example
+   * ```typescript
+   * // В schema-behaviors.ts
+   * export function copyFrom(...) {
+   *   const registry = BehaviorRegistry.getCurrent();
+   *   if (registry) {
+   *     registry.register({ ... });
+   *   }
+   * }
+   * ```
+   */
+  static getCurrent() {
+    return o.getCurrentFromStack(h);
+  }
+  /**
+   * Зарегистрировать 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, e) {
+    this.isActive() && this.registrations.push({
+      // Type assertion безопасен: handler будет вызван с правильным типом формы в createEffect
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      handler: t,
+      debounce: e?.debounce
+    });
+  }
+  /**
+   * Завершить регистрацию и применить behaviors к форме
+   * Создает effect подписки для всех зарегистрированных behaviors
+   *
+   * @param form - GroupNode формы
+   * @returns Количество зарегистрированных behaviors и функция cleanup
+   */
+  endRegistration(t) {
+    const e = this.registrations.length, i = new C(t), n = [];
+    for (const r of this.registrations) {
+      const c = this.createEffect(r, t, i);
+      c && n.push(c);
+    }
+    return this.completeRegistration("BehaviorRegistry"), { count: e, cleanup: () => {
+      n.forEach((r) => r());
+    } };
+  }
+  /**
+   * Создать effect подписку для behavior
+   * @private
+   */
+  createEffect(t, e, i) {
+    const { handler: n, debounce: a = 0 } = t;
+    let r = null;
+    const c = (u) => {
+      a > 0 ? (r && clearTimeout(r), r = setTimeout(u, a)) : u();
+    }, p = () => {
+      r && (clearTimeout(r), r = null);
+    }, g = n(e, i, c);
+    return g ? () => {
+      p(), g && g();
+    } : null;
+  }
+}
+function k() {
+  const s = d.getCurrent();
+  return s || {
+    registerSync: () => {
+    },
+    registerAsync: () => {
+    },
+    registerTree: () => {
+    },
+    enterCondition: () => {
+    },
+    exitCondition: () => {
+    },
+    registerArrayItemValidation: () => {
+    }
+  };
+}
+function V() {
+  const s = h.getCurrent();
+  return s || {
+    register: () => {
+    }
+  };
+}
+export {
+  o as A,
+  h as B,
+  f as E,
+  y as F,
+  m as R,
+  d as V,
+  C as a,
+  V as b,
+  k as g
+};

package/dist/safe-effect-Dh8uw81c.js

@@ -0,0 +1,20 @@
+function a(e) {
+  return (...u) => {
+    queueMicrotask(() => e(...u));
+  };
+}
+function t(e) {
+  queueMicrotask(e);
+}
+function c(e, u) {
+  return () => {
+    u(() => {
+      queueMicrotask(e);
+    });
+  };
+}
+export {
+  c as a,
+  t as r,
+  a as s
+};

package/dist/validate-C3XiA_zf.js

@@ -0,0 +1,10 @@
+import { e as i } from "./field-path-DuKdGcIE.js";
+import { g as o } from "./registry-helpers-Bv_BJ1s-.js";
+function c(t, r, a) {
+  if (!t) return;
+  const e = i(t);
+  o().registerSync(e, r, a);
+}
+export {
+  c as v
+};

package/dist/validators/email.d.ts

@@ -0,0 +1,2 @@
+export * from '../core/validation/validators/email'
+export {}

package/dist/validators/email.js

@@ -0,0 +1,13 @@
+import { v as m } from "../validate-C3XiA_zf.js";
+function i(e, r) {
+  if (!e) return;
+  const s = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  m(e, (a) => a ? s.test(a) ? null : {
+    code: "email",
+    message: r?.message || "Неверный формат email",
+    params: r?.params
+  } : null);
+}
+export {
+  i as email
+};

package/dist/validators/future-date.d.ts

@@ -0,0 +1,2 @@
+export * from '../core/validation/validators/future-date'
+export {}

package/dist/validators/future-date.js

@@ -0,0 +1,20 @@
+import { v as o } from "../validate-C3XiA_zf.js";
+import { p as u, n as l, g as m } from "../date-utils-xUWFslTj.js";
+function d(a, e) {
+  a && o(a, (r) => {
+    if (r == null || r === "")
+      return null;
+    const t = u(r);
+    if (t === null)
+      return null;
+    const n = l(t), s = m();
+    return n < s ? {
+      code: "date_past",
+      message: e?.message || "Дата не может быть в прошлом",
+      params: e?.params
+    } : null;
+  });
+}
+export {
+  d as futureDate
+};

package/dist/validators/is-date.d.ts

@@ -0,0 +1,2 @@
+export * from '../core/validation/validators/is-date'
+export {}

package/dist/validators/is-date.js

@@ -0,0 +1,12 @@
+import { v as s } from "../validate-C3XiA_zf.js";
+import { p as n } from "../date-utils-xUWFslTj.js";
+function p(a, e) {
+  a && s(a, (r) => r == null || r === "" ? null : n(r) === null ? {
+    code: "date_invalid",
+    message: e?.message || "Неверный формат даты",
+    params: e?.params
+  } : null);
+}
+export {
+  p as isDate
+};