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

package/dist/core/validation/validators/email.d.ts

@@ -1,12 +1,5 @@
-/**
- * Валидатор формата email
- *
- * @group Validation
- * @category Validators
- * @module validators/email
- */
-import type { ValidateOptions } from '../../types/validation-schema';
-import type { FieldPathNode } from '../../types';
+import { ValidateOptions } from '../../types/validation-schema';
+import { FieldPathNode } from '../../types';
 /**
  * Валидатор формата email
  *

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

@@ -0,0 +1,35 @@
+import { ValidateOptions } from '../../types/validation-schema';
+import { FieldPathNode } from '../../types';
+/**
+ * Проверяет, что дата находится в будущем (не в прошлом)
+ *
+ * Пустые значения и невалидные даты пропускаются (используйте `required` и `isDate`).
+ *
+ * @group Validation
+ * @category Validators
+ *
+ * @param fieldPath - Путь к полю для валидации
+ * @param options - Опции валидации (message, params)
+ *
+ * @example
+ * ```typescript
+ * // Базовое использование - дата события должна быть в будущем
+ * validationSchema: (path) => [
+ *   futureDate(path.eventDate),
+ * ]
+ *
+ * // С кастомным сообщением
+ * futureDate(path.appointmentDate, { message: 'Дата записи должна быть в будущем' })
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Ошибка валидации
+ * {
+ *   code: 'date_past',
+ *   message: 'Дата не может быть в прошлом',
+ *   params: {}
+ * }
+ * ```
+ */
+export declare function futureDate<TForm, TField extends string | Date | undefined = string | Date>(fieldPath: FieldPathNode<TForm, TField> | undefined, options?: ValidateOptions): void;

package/dist/core/validation/validators/index.d.ts

@@ -11,4 +11,10 @@ export { pattern } from './pattern';
 export { url } from './url';
 export { phone, type PhoneFormat } from './phone';
 export { number } from './number';
-export { date } from './date';
+export { isDate } from './is-date';
+export { minDate } from './min-date';
+export { maxDate } from './max-date';
+export { pastDate } from './past-date';
+export { futureDate } from './future-date';
+export { minAge } from './min-age';
+export { maxAge } from './max-age';

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

@@ -0,0 +1,36 @@
+import { ValidateOptions } from '../../types/validation-schema';
+import { FieldPathNode } from '../../types';
+/**
+ * Проверяет, что значение является валидной датой
+ *
+ * Пустые значения пропускаются (используйте `required` для обязательности).
+ *
+ * @group Validation
+ * @category Validators
+ *
+ * @param fieldPath - Путь к полю для валидации
+ * @param options - Опции валидации (message, params)
+ *
+ * @example
+ * ```typescript
+ * // Базовое использование
+ * validationSchema: (path) => [
+ *   isDate(path.birthDate),
+ *   isDate(path.eventDate),
+ * ]
+ *
+ * // С кастомным сообщением
+ * isDate(path.birthDate, { message: 'Введите корректную дату' })
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Ошибка валидации
+ * {
+ *   code: 'date_invalid',
+ *   message: 'Неверный формат даты',
+ *   params: {}
+ * }
+ * ```
+ */
+export declare function isDate<TForm, TField extends string | Date | undefined = string | Date>(fieldPath: FieldPathNode<TForm, TField> | undefined, options?: ValidateOptions): void;

package/dist/core/validation/validators/max-age.d.ts

@@ -0,0 +1,36 @@
+import { ValidateOptions } from '../../types/validation-schema';
+import { FieldPathNode } from '../../types';
+/**
+ * Проверяет, что возраст (вычисленный из даты рождения) не больше указанного
+ *
+ * Пустые значения и невалидные даты пропускаются (используйте `required` и `isDate`).
+ *
+ * @group Validation
+ * @category Validators
+ *
+ * @param fieldPath - Путь к полю для валидации (дата рождения)
+ * @param maxAgeValue - Максимально допустимый возраст в годах
+ * @param options - Опции валидации (message, params)
+ *
+ * @example
+ * ```typescript
+ * // Базовое использование - максимум 65 лет
+ * validationSchema: (path) => [
+ *   maxAge(path.birthDate, 65),
+ * ]
+ *
+ * // С кастомным сообщением
+ * maxAge(path.birthDate, 100, { message: 'Проверьте правильность даты рождения' })
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Ошибка валидации
+ * {
+ *   code: 'date_max_age',
+ *   message: 'Максимальный возраст: 65 лет',
+ *   params: { maxAge: 65, currentAge: 70 }
+ * }
+ * ```
+ */
+export declare function maxAge<TForm, TField extends string | Date | null | undefined = string | Date>(fieldPath: FieldPathNode<TForm, TField> | undefined, maxAgeValue: number, options?: ValidateOptions): void;

package/dist/core/validation/validators/max-date.d.ts

@@ -0,0 +1,36 @@
+import { ValidateOptions } from '../../types/validation-schema';
+import { FieldPathNode } from '../../types';
+/**
+ * Проверяет, что дата не позже указанной максимальной
+ *
+ * Пустые значения и невалидные даты пропускаются (используйте `required` и `isDate`).
+ *
+ * @group Validation
+ * @category Validators
+ *
+ * @param fieldPath - Путь к полю для валидации
+ * @param maxDateValue - Максимально допустимая дата (включительно)
+ * @param options - Опции валидации (message, params)
+ *
+ * @example
+ * ```typescript
+ * // Базовое использование
+ * validationSchema: (path) => [
+ *   maxDate(path.birthDate, new Date()), // Не позже сегодня
+ * ]
+ *
+ * // С кастомным сообщением
+ * maxDate(path.endDate, new Date('2025-12-31'), { message: 'Дата не может быть позже конца года' })
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Ошибка валидации
+ * {
+ *   code: 'date_max',
+ *   message: 'Дата должна быть не позднее 31.12.2025',
+ *   params: { maxDate: Date }
+ * }
+ * ```
+ */
+export declare function maxDate<TForm, TField extends string | Date | null | undefined = string | Date>(fieldPath: FieldPathNode<TForm, TField> | undefined, maxDateValue: Date, options?: ValidateOptions): void;

package/dist/core/validation/validators/max-length.d.ts

@@ -1,12 +1,5 @@
-/**
- * Валидатор максимальной длины строки
- *
- * @group Validation
- * @category Validators
- * @module validators/maxLength
- */
-import type { ValidateOptions } from '../../types/validation-schema';
-import type { FieldPathNode } from '../../types';
+import { ValidateOptions } from '../../types/validation-schema';
+import { FieldPathNode } from '../../types';
 /**
  * Валидатор максимальной длины строки
  *
@@ -42,4 +35,4 @@ import type { FieldPathNode } from '../../types';
  * }
  * ```
  */
-export declare function maxLength<TForm, TField extends string | undefined = string>(fieldPath: FieldPathNode<TForm, TField> | undefined, maxLen: number, options?: ValidateOptions): void;
+export declare function maxLength<TForm, TField extends string | null | undefined = string>(fieldPath: FieldPathNode<TForm, TField> | undefined, maxLen: number, options?: ValidateOptions): void;

package/dist/core/validation/validators/max.d.ts

@@ -1,12 +1,5 @@
-/**
- * Валидатор максимального значения
- *
- * @group Validation
- * @category Validators
- * @module validators/max
- */
-import type { ValidateOptions } from '../../types/validation-schema';
-import type { FieldPathNode } from '../../types';
+import { ValidateOptions } from '../../types/validation-schema';
+import { FieldPathNode } from '../../types';
 /**
  * Валидатор максимального числового значения
  *
@@ -42,4 +35,4 @@ import type { FieldPathNode } from '../../types';
  * }
  * ```
  */
-export declare function max<TForm, TField extends number | undefined = number>(fieldPath: FieldPathNode<TForm, TField> | undefined, maxValue: number, options?: ValidateOptions): void;
+export declare function max<TForm, TField extends number | null | undefined = number>(fieldPath: FieldPathNode<TForm, TField> | undefined, maxValue: number, options?: ValidateOptions): void;

package/dist/core/validation/validators/min-age.d.ts

@@ -0,0 +1,36 @@
+import { ValidateOptions } from '../../types/validation-schema';
+import { FieldPathNode } from '../../types';
+/**
+ * Проверяет, что возраст (вычисленный из даты рождения) не меньше указанного
+ *
+ * Пустые значения и невалидные даты пропускаются (используйте `required` и `isDate`).
+ *
+ * @group Validation
+ * @category Validators
+ *
+ * @param fieldPath - Путь к полю для валидации (дата рождения)
+ * @param minAgeValue - Минимально допустимый возраст в годах
+ * @param options - Опции валидации (message, params)
+ *
+ * @example
+ * ```typescript
+ * // Базовое использование - минимум 18 лет
+ * validationSchema: (path) => [
+ *   minAge(path.birthDate, 18),
+ * ]
+ *
+ * // С кастомным сообщением
+ * minAge(path.birthDate, 21, { message: 'Вам должно быть не менее 21 года' })
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Ошибка валидации
+ * {
+ *   code: 'date_min_age',
+ *   message: 'Минимальный возраст: 18 лет',
+ *   params: { minAge: 18, currentAge: 16 }
+ * }
+ * ```
+ */
+export declare function minAge<TForm, TField extends string | Date | null | undefined = string | Date>(fieldPath: FieldPathNode<TForm, TField> | undefined, minAgeValue: number, options?: ValidateOptions): void;

package/dist/core/validation/validators/min-date.d.ts

@@ -0,0 +1,36 @@
+import { ValidateOptions } from '../../types/validation-schema';
+import { FieldPathNode } from '../../types';
+/**
+ * Проверяет, что дата не раньше указанной минимальной
+ *
+ * Пустые значения и невалидные даты пропускаются (используйте `required` и `isDate`).
+ *
+ * @group Validation
+ * @category Validators
+ *
+ * @param fieldPath - Путь к полю для валидации
+ * @param minDateValue - Минимально допустимая дата (включительно)
+ * @param options - Опции валидации (message, params)
+ *
+ * @example
+ * ```typescript
+ * // Базовое использование
+ * validationSchema: (path) => [
+ *   minDate(path.eventDate, new Date('2024-01-01')),
+ * ]
+ *
+ * // С кастомным сообщением
+ * minDate(path.startDate, new Date(), { message: 'Дата должна быть не раньше сегодня' })
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Ошибка валидации
+ * {
+ *   code: 'date_min',
+ *   message: 'Дата должна быть не ранее 01.01.2024',
+ *   params: { minDate: Date }
+ * }
+ * ```
+ */
+export declare function minDate<TForm, TField extends string | Date | null | undefined = string | Date>(fieldPath: FieldPathNode<TForm, TField> | undefined, minDateValue: Date, options?: ValidateOptions): void;

package/dist/core/validation/validators/min-length.d.ts

@@ -1,12 +1,5 @@
-/**
- * Валидатор минимальной длины строки
- *
- * @group Validation
- * @category Validators
- * @module validators/minLength
- */
-import type { ValidateOptions } from '../../types/validation-schema';
-import type { FieldPathNode } from '../../types';
+import { ValidateOptions } from '../../types/validation-schema';
+import { FieldPathNode } from '../../types';
 /**
  * Валидатор минимальной длины строки
  *
@@ -42,4 +35,4 @@ import type { FieldPathNode } from '../../types';
  * }
  * ```
  */
-export declare function minLength<TForm, TField extends string | undefined = string>(fieldPath: FieldPathNode<TForm, TField> | undefined, minLen: number, options?: ValidateOptions): void;
+export declare function minLength<TForm, TField extends string | null | undefined = string>(fieldPath: FieldPathNode<TForm, TField> | undefined, minLen: number, options?: ValidateOptions): void;

package/dist/core/validation/validators/min.d.ts

@@ -1,12 +1,5 @@
-/**
- * Валидатор минимального значения
- *
- * @group Validation
- * @category Validators
- * @module validators/min
- */
-import type { ValidateOptions } from '../../types/validation-schema';
-import type { FieldPathNode } from '../../types';
+import { ValidateOptions } from '../../types/validation-schema';
+import { FieldPathNode } from '../../types';
 /**
  * Валидатор минимального числового значения
  *
@@ -42,4 +35,4 @@ import type { FieldPathNode } from '../../types';
  * }
  * ```
  */
-export declare function min<TForm, TField extends number | undefined = number>(fieldPath: FieldPathNode<TForm, TField> | undefined, minValue: number, options?: ValidateOptions): void;
+export declare function min<TForm, TField extends number | null | undefined = number>(fieldPath: FieldPathNode<TForm, TField> | undefined, minValue: number, options?: ValidateOptions): void;

package/dist/core/validation/validators/number.d.ts

@@ -1,12 +1,5 @@
-/**
- * Валидатор числовых значений
- *
- * @group Validation
- * @category Validators
- * @module validators/number
- */
-import type { ValidateOptions } from '../../types/validation-schema';
-import type { FieldPathNode } from '../../types';
+import { ValidateOptions } from '../../types/validation-schema';
+import { FieldPathNode } from '../../types';
 /**
  * Адаптер для number валидатора
  * Проверяет, что значение является числом и соответствует заданным ограничениям

package/dist/core/validation/validators/past-date.d.ts

@@ -0,0 +1,35 @@
+import { ValidateOptions } from '../../types/validation-schema';
+import { FieldPathNode } from '../../types';
+/**
+ * Проверяет, что дата находится в прошлом (не в будущем)
+ *
+ * Пустые значения и невалидные даты пропускаются (используйте `required` и `isDate`).
+ *
+ * @group Validation
+ * @category Validators
+ *
+ * @param fieldPath - Путь к полю для валидации
+ * @param options - Опции валидации (message, params)
+ *
+ * @example
+ * ```typescript
+ * // Базовое использование - дата рождения не может быть в будущем
+ * validationSchema: (path) => [
+ *   pastDate(path.birthDate),
+ * ]
+ *
+ * // С кастомным сообщением
+ * pastDate(path.birthDate, { message: 'Дата рождения не может быть в будущем' })
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Ошибка валидации
+ * {
+ *   code: 'date_future',
+ *   message: 'Дата не может быть в будущем',
+ *   params: {}
+ * }
+ * ```
+ */
+export declare function pastDate<TForm, TField extends string | Date | undefined = string | Date>(fieldPath: FieldPathNode<TForm, TField> | undefined, options?: ValidateOptions): void;

package/dist/core/validation/validators/pattern.d.ts

@@ -1,12 +1,5 @@
-/**
- * Валидатор паттерна (регулярного выражения)
- *
- * @group Validation
- * @category Validators
- * @module validators/pattern
- */
-import type { ValidateOptions } from '../../types/validation-schema';
-import type { FieldPathNode } from '../../types';
+import { ValidateOptions } from '../../types/validation-schema';
+import { FieldPathNode } from '../../types';
 /**
  * Валидатор паттерна (регулярного выражения)
  *

package/dist/core/validation/validators/phone.d.ts

@@ -1,12 +1,5 @@
-/**
- * Валидатор номера телефона
- *
- * @group Validation
- * @category Validators
- * @module validators/phone
- */
-import type { ValidateOptions } from '../../types/validation-schema';
-import type { FieldPathNode } from '../../types';
+import { ValidateOptions } from '../../types/validation-schema';
+import { FieldPathNode } from '../../types';
 /**
  * Формат телефона для валидации
  *

package/dist/core/validation/validators/required.d.ts

@@ -1,12 +1,5 @@
-/**
- * Валидатор обязательного поля
- *
- * @group Validation
- * @category Validators
- * @module validators/required
- */
-import type { ValidateOptions } from '../../types/validation-schema';
-import type { FieldPathNode } from '../../types';
+import { ValidateOptions } from '../../types/validation-schema';
+import { FieldPathNode } from '../../types';
 /**
  * Валидатор обязательного поля
  *

package/dist/core/validation/validators/url.d.ts

@@ -1,12 +1,5 @@
-/**
- * Валидатор URL
- *
- * @group Validation
- * @category Validators
- * @module validators/url
- */
-import type { ValidateOptions } from '../../types/validation-schema';
-import type { FieldPathNode } from '../../types';
+import { ValidateOptions } from '../../types/validation-schema';
+import { FieldPathNode } from '../../types';
 /**
  * Адаптер для URL валидатора
  * Поддерживает опциональные поля (string | undefined)

package/dist/date-utils-xUWFslTj.js

@@ -0,0 +1,29 @@
+function r(t) {
+  if (t == null || t === "")
+    return null;
+  if (t instanceof Date)
+    return isNaN(t.getTime()) ? null : t;
+  if (typeof t == "string") {
+    const n = new Date(t);
+    return isNaN(n.getTime()) ? null : n;
+  }
+  return null;
+}
+function e() {
+  const t = /* @__PURE__ */ new Date();
+  return t.setHours(0, 0, 0, 0), t;
+}
+function o(t) {
+  const n = new Date(t);
+  return n.setHours(0, 0, 0, 0), n;
+}
+function i(t) {
+  const n = e();
+  return Math.floor((n.getTime() - t.getTime()) / (365.25 * 24 * 60 * 60 * 1e3));
+}
+export {
+  i as c,
+  e as g,
+  o as n,
+  r as p
+};

package/dist/field-path-DuKdGcIE.js

@@ -0,0 +1,66 @@
+function c() {
+  return _("");
+}
+function _(t) {
+  return new Proxy({}, {
+    get(r, i) {
+      if (typeof i == "symbol")
+        return;
+      if (i === "__path" || i === "__fieldPath")
+        return t || i;
+      if (i === "__key") {
+        const n = t.split(".");
+        return n[n.length - 1] || i;
+      }
+      if (i === "then" || i === "catch" || i === "finally" || i === "constructor" || i === "toString" || i === "valueOf" || i === "toJSON")
+        return;
+      const f = t ? `${t}.${i}` : i, a = {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        __key: i,
+        __path: f,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        __formType: void 0,
+        __fieldType: void 0
+      };
+      return new Proxy(a, {
+        get(n, e) {
+          if (typeof e != "symbol") {
+            if (e === "__path" || e === "__fieldPath") return f;
+            if (e === "__key") return i;
+            if (e !== "__formType" && e !== "__fieldType" && !(e === "then" || e === "catch" || e === "finally" || e === "constructor" || e === "toString" || e === "valueOf" || e === "toJSON"))
+              return _(`${f}.${e}`);
+          }
+        }
+      });
+    }
+  });
+}
+function u(t) {
+  if (typeof t == "string")
+    return t;
+  if (t && typeof t == "object") {
+    const r = t.__path;
+    if (typeof r == "string")
+      return r;
+  }
+  throw new Error("Invalid field path node: " + JSON.stringify(t));
+}
+function y(t) {
+  const r = u(t);
+  return _(r);
+}
+function l(t) {
+  if (t && typeof t == "object" && "__key" in t)
+    return t.__key;
+  if (typeof t == "string") {
+    const r = t.split(".");
+    return r[r.length - 1];
+  }
+  throw new Error("Invalid field path node");
+}
+export {
+  l as a,
+  c,
+  u as e,
+  y as t
+};

package/dist/hooks/types.d.ts

@@ -1,4 +1,4 @@
-import type { ValidationError } from '../core/types';
+import { ValidationError } from '../core/types';
 /**
  * Состояние поля формы, возвращаемое хуком {@link useFormControl} для {@link FieldNode}.
  *

package/dist/hooks/useArrayLength.d.ts

@@ -0,0 +1,31 @@
+import { ArrayNode } from '../core/nodes/array-node';
+import { FormFields } from '../core/types';
+/**
+ * React-хук для подписки только на длину массива.
+ *
+ * Оптимизированная версия {@link useFormControl} для ArrayNode, которая
+ * подписывается только на сигнал `length`. Компонент не будет ре-рендериться
+ * при изменении значений вложенных полей.
+ *
+ * @typeParam T - Тип элемента массива
+ * @param control - ArrayNode для подписки
+ * @returns Текущая длина массива
+ *
+ * @example
+ * ```tsx
+ * function ArrayRenderer({ arrayNode }) {
+ *   const length = useArrayLength(arrayNode);
+ *
+ *   return (
+ *     <div>
+ *       {arrayNode.map((item, index) => (
+ *         <ItemRenderer key={item.id} item={item} />
+ *       ))}
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @group React Hooks
+ */
+export declare function useArrayLength<T extends FormFields>(control: ArrayNode<T>): number;

package/dist/hooks/useFormControl.d.ts

@@ -1,7 +1,7 @@
-import type { FieldNode } from '../core/nodes/field-node';
-import type { ArrayNode } from '../core/nodes/array-node';
-import type { FormValue, FormFields } from '../core/types';
-import type { FieldControlState, ArrayControlState } from './types';
+import { FieldNode } from '../core/nodes/field-node';
+import { ArrayNode } from '../core/nodes/array-node';
+import { FormValue, FormFields } from '../core/types';
+import { FieldControlState, ArrayControlState } from './types';
 /**
  * React-хук для подписки на состояние {@link ArrayNode}.
  *

package/dist/hooks/useFormControlValue.d.ts

@@ -1,5 +1,5 @@
-import type { FieldNode } from '../core/nodes/field-node';
-import type { FormValue } from '../core/types';
+import { FieldNode } from '../core/nodes/field-node';
+import { FormValue } from '../core/types';
 /**
  * React-хук для подписки только на значение поля.
  *

package/dist/hooks/useHiddenCondition.d.ts

@@ -0,0 +1,25 @@
+import { FormProxy, FieldPath } from '../core/types';
+type HiddenFn<T> = (form: FormProxy<T>, path: FieldPath<T>) => boolean;
+/**
+ * Хук для реактивной оценки функции hidden.
+ *
+ * Подписывается на изменения формы через сигналы и возвращает текущее
+ * значение hidden-условия.
+ *
+ * @param hiddenFn - Функция, определяющая скрытие.
+ * @param form - {@link FormProxy} формы.
+ * @param path - Текущий {@link FieldPath}.
+ * @returns `true`, если элемент должен быть скрыт.
+ *
+ * @example
+ * ```tsx
+ * import { useHiddenCondition } from '@reformer/core';
+ *
+ * function MaybeHidden({ form, path, children }) {
+ *   const hidden = useHiddenCondition((f) => !f.subscribeNewsletter.value, form, path);
+ *   return hidden ? null : <>{children}</>;
+ * }
+ * ```
+ */
+export declare function useHiddenCondition<T>(hiddenFn: HiddenFn<T> | undefined, form: FormProxy<T>, path: FieldPath<T>): boolean;
+export {};

package/dist/hooks/useSignalSubscription.d.ts

@@ -1,4 +1,4 @@
-import { type Signal } from '@preact/signals-core';
+import { Signal } from '@preact/signals-core';
 /** @internal */
 export type SignalMap = Record<string, Signal<unknown>>;
 /** @internal */