@reformer/core 10.2.0 → 11.0.0-beta.10

package/dist/form/validation/index.d.ts

@@ -1,28 +1,24 @@
-export { required } from './validators/required';
-export { min } from './validators/min';
-export { max } from './validators/max';
-export { minLength } from './validators/min-length';
-export { maxLength } from './validators/max-length';
-export { email } from './validators/email';
-export { pattern } from './validators/pattern';
-export { url } from './validators/url';
-export { phone, type PhoneFormat } from './validators/phone';
-export { isNumber } from './validators/is-number';
-export { integer } from './validators/integer';
-export { multipleOf } from './validators/multiple-of';
-export { nonNegative } from './validators/non-negative';
-export { nonZero } from './validators/non-zero';
-export { isDate } from './validators/is-date';
-export { minDate } from './validators/min-date';
-export { maxDate } from './validators/max-date';
-export { pastDate } from './validators/past-date';
-export { futureDate } from './validators/future-date';
-export { minAge } from './validators/min-age';
-export { maxAge } from './validators/max-age';
-export { maxFileSize } from './validators/max-file-size';
-export { minFileSize } from './validators/min-file-size';
-export { fileType } from './validators/file-type';
-export { maxFiles } from './validators/max-files';
-export { minFiles } from './validators/min-files';
-export { maxTotalFileSize } from './validators/max-total-file-size';
-export { isFileLike, matchesFileAccept, toFileArray, type FileLike } from './validators/file-utils';
+/**
+ * Декларативный контракт СХЕМЫ ВАЛИДАЦИИ — `@reformer/core/validation`.
+ *
+ * Схема валидации — обычная функция `({ model, cross }) => void`. Внутри вызываются свободные операторы
+ * (`validate`/`validateAsync`/`validateWhen`/`apply`/`applyEach`) и `cross` области, которые САМИ пишут ошибки в
+ * ambient-сток текущего прогона — автор не видит ни коллектора, ни `getNodeForSignal`, ни `.push`.
+ * Раннер открывает ambient-окно на время СИНХРОННОГО прогона схемы и дожидается async-правил
+ * ({@link runValidation} — сбор результата), затем разносит ошибки по нодам формы, гася поля, ставшие
+ * валидными ({@link applyValidationResult}); {@link validateModel} делает оба шага и отвечает `boolean`.
+ *
+ * Зеркалит контракт поведения (`@reformer/core/behaviors`): тот же ambient-стиль, но отдельный слой —
+ * валидация НЕ реактивна (прогон по требованию: submit/шаг), поведение — реактивно (живые подписки).
+ *
+ * Модуль разложен по зонам ответственности: `./types` — контракт правил и схемы, `./context` —
+ * ambient-сток прогона, `./operators` — операторы схемы, `./run` — раннер, `./strategy` — КОГДА
+ * запускать (реэкспортируется отсюда, тот же сабпат).
+ *
+ * @group Validation
+ * @module form/validation
+ */
+export type { Rule, AsyncRule, ValidationDefinition, ValidationScope, ValidationStatus, ValidationFailure, ValidationResult, } from './types';
+export { validate, validateAsync, validateWhen, apply, applyEach } from './operators';
+export { defineValidation, runValidation, applyValidationResult, validateModel } from './run';
+export * from './strategy';

package/dist/form/validation/operators.d.ts

@@ -0,0 +1,101 @@
+import { FormModel, ModelArray, PathAwareSignal } from '../../model/types';
+import { AsyncRule, Rule, ValidationDefinition, ValidationScope } from './types';
+/**
+ * Синхронные правила поля.
+ *
+ * Поле — лист либо массив целиком: `model.$.<массив>` — такая же ручка значения, и правило
+ * получает массив (мультивыбор, теги, список файлов).
+ *
+ * @example
+ * ```ts
+ * validate(model.$.loanAmount, [required({ code: 'loanAmount.required' }), min(50000)]);
+ * validate(model.$.tags, [required(), maxLength(3)]); // tags: string[] — массив как значение
+ * ```
+ */
+export declare function validate<TField>(sig: PathAwareSignal<TField>, rules: Rule<TField>[]): void;
+/**
+ * Асинхронные правила поля. Раннер дожидается их и прокидывает `AbortSignal` для отмены
+ * устаревших ответов.
+ *
+ * Отклонённое правило (сеть, исключение) — сбой проверки: он попадает в `failures` результата
+ * прогона, статус прогона становится `error`, а на поле ложится блокирующая ошибка `ruleFailed`
+ * (текст — из словаря локали). Отмена устаревшего прогона сбоем не считается.
+ *
+ * @example
+ * ```ts
+ * validateAsync(model.$.username, [async (v, { signal }) => {
+ *   const r = await fetch(`/api/free?u=${v}`, { signal });
+ *   return (await r.json()).free ? null : { code: 'taken' };
+ * }]);
+ * ```
+ */
+export declare function validateAsync<TField>(sig: PathAwareSignal<TField>, rules: AsyncRule<TField>[]): void;
+/**
+ * Условная валидация: правила внутри `cb` активны, только пока `cond()` истинно; иначе их поля
+ * ГАСЯТСЯ (пустой bucket → `setIssues([])`). Не трогает включение/сброс поля — это дело поведения (`enableWhen`).
+ */
+export declare function validateWhen(cond: () => boolean, cb: () => void): void;
+/**
+ * Область схемы над моделью: сама модель и `cross`, снимок которого — эта модель.
+ *
+ * @internal
+ */
+export declare function scopeOf<T>(model: FormModel<T>): ValidationScope<T>;
+/** Привязка к группе: ручка `model.$.<группа>` (тип значения — из её `peek()`). */
+interface GroupBinding<V> {
+    peek(): V;
+}
+/** Привязка к массиву под-форм: ручка `model.$.<массив>`. */
+interface ArrayBinding<U> {
+    peek(): readonly U[] | null | undefined;
+}
+/**
+ * Применить схему к КАЖДОМУ элементу массива под-форм. Схема элемента — обычная
+ * `ValidationDefinition` над типом элемента: тот же набор правил подключается и к группе через
+ * {@link apply}.
+ *
+ * У каждого элемента своя область: `cross` внутри схемы получает снапшот элемента.
+ *
+ * @example
+ * ```ts
+ * const propertyRules = defineValidation<Property>(({ model, cross }) => {
+ *   validate(model.$.type, [required()]);
+ *   cross(model.$.estimatedValue, (property) =>
+ *     property.hasEncumbrance && property.estimatedValue < 100_000 ? tooCheap : null
+ *   );
+ * });
+ *
+ * applyEach(model.$.properties, propertyRules);
+ * ```
+ */
+export declare function applyEach<U extends object>(array: ArrayBinding<U> | ModelArray<U>, schema: ValidationDefinition<U>): void;
+/**
+ * Подключить схему подформы к группе модели — одной или нескольким.
+ *
+ * Схема запускается в области группы: `model` в ней — под-модель, `cross` получает снапшот
+ * группы. Привязка — ручка `model.$.<группа>`, как у узла-подформы схемы и у `apply` поведения.
+ *
+ * @example
+ * ```ts
+ * const addressRules = defineValidation<Address>(({ model }) => {
+ *   validate(model.$.city, [required()]);
+ * });
+ *
+ * apply(model.$.registrationAddress, addressRules);
+ * validateWhen(
+ *   () => !model.sameAsRegistration,
+ *   () => apply(model.$.residenceAddress, addressRules)
+ * );
+ * ```
+ */
+export declare function apply<V extends object | null | undefined>(group: GroupBinding<V> | GroupBinding<V>[], schema: ValidationDefinition<NonNullable<V>>): void;
+/**
+ * Композиция схем над ТОЙ ЖЕ моделью области — так форма собирается из схем шагов.
+ *
+ * @example
+ * ```ts
+ * const formRules = defineValidation<Form>(() => apply(loanRules, contactsRules));
+ * ```
+ */
+export declare function apply<T>(...schemas: ValidationDefinition<T>[]): void;
+export {};

package/dist/form/validation/run.d.ts

@@ -0,0 +1,120 @@
+import { FormModel } from '../../model/types';
+import { ValidationResult, ValidationDefinition } from './types';
+/**
+ * Тонкая identity-обёртка для типизации/discoverability (как `defineFormBehavior`). Возвращает схему как есть.
+ *
+ * @example
+ * ```ts
+ * export const step1 = defineValidation<LoanForm>(({ model }) => {
+ *   validate(model.$.loanAmount, [required(), min(50000)]);
+ * });
+ * ```
+ */
+export declare function defineValidation<T>(schema: ValidationDefinition<T>): ValidationDefinition<T>;
+/**
+ * Отменить идущий прогон пары (model, schema): его `AbortSignal` срабатывает, ожидание async-правил
+ * размыкается, результат получает статус `cancelled` и по нодам не разносится. Контроллер живой
+ * проверки зовёт это при снятии — иначе ответ правила лёг бы на ноды уже снятой формы.
+ *
+ * @internal
+ */
+export declare function cancelRun(model: object, schema: object): void;
+/**
+ * Какие поля пометить тронутыми при разносе: `false` — никакие, `true` — проверенные правилами,
+ * `'all'` — проверенные, а при отказе (`invalid`, `error`) ещё и всю форму.
+ *
+ * @internal
+ */
+export type ValidationTouch = boolean | 'all';
+/** Идёт ли сейчас касание полей от имени проверки ({@link touchByValidation}). @internal */
+export declare const isTouchByValidation: () => boolean;
+/**
+ * Собрать результат проверки модели схемой — без формы и без побочных эффектов на нодах.
+ *
+ * Открывает ambient-окно на время синхронного прогона `schema`, дожидается async-правил и
+ * возвращает {@link ValidationResult}. Нод формы не трогает: ошибки по ним разносит
+ * {@link applyValidationResult}. Подходит для проверки данных без UI (сервер, тест, предпросмотр).
+ *
+ * Статус результата:
+ *  - `cancelled` — прогон устарел: пока он шёл, для той же пары (model, schema) запущен следующий;
+ *  - `error` — хотя бы одно async-правило не вернуло результат (сеть, исключение) — см. `failures`;
+ *  - `invalid` — есть блокирующие ошибки (`severity: 'warning'` не блокирует);
+ *  - `valid` — блокирующих ошибок нет.
+ *
+ * ⚠️ `schema` должна быть СТАБИЛЬНОЙ ссылкой: отмена устаревших прогонов ключится по идентичности
+ * `schema`. Держите схемы в `const` / `defineValidation`.
+ *
+ * @param model - Модель данных формы.
+ * @param schema - Схема валидации (стабильная ссылка).
+ *
+ * @example
+ * ```ts
+ * const result = await runValidation(model, formRules);
+ * if (result.status === 'error') showToast('Не удалось проверить форму, повторите попытку');
+ * else if (result.status !== 'cancelled') applyValidationResult(result, { touch: true });
+ * ```
+ */
+export declare function runValidation<T>(model: FormModel<T>, schema: ValidationDefinition<T>): Promise<ValidationResult>;
+/**
+ * Разнести собранный результат по нодам формы: поставить ошибки проверенным полям и погасить поля,
+ * которые были с ошибкой в прошлом разнесённом прогоне той же пары (model, schema), а теперь не
+ * проверялись (удалённая строка массива, выключенная ветка).
+ *
+ * Отменённый результат (`status: 'cancelled'`) не разносится: его async-часть оборвана.
+ *
+ * `options.touch`: пометить `touched` ИМЕННО поля, которые схема проверяла (не всё поддерево):
+ * поля выключенной ветки `validateWhen` и, в проверке уровня формы, выключенные поля не метятся —
+ * пользователь их не видел, и после включения их ошибка не должна быть видна с первой проверки.
+ * Замечания становятся видимыми (`shouldShowIssues`: есть замечания и `touched || dirty`) без
+ * ручного `form.markAsTouched()`; при пошаговой валидации следующий шаг не показывается
+ * «тронутым».
+ *
+ * @param result - Результат {@link runValidation}.
+ * @param options - `{ touch }` — пометить проверенные поля `touched` для показа ошибок.
+ */
+export declare function applyValidationResult(result: ValidationResult, options?: {
+    touch?: boolean;
+}): void;
+/**
+ * Прогон с разносом и полным результатом — общий движок {@link validateModel}, контроллера
+ * стратегии и прогонов шага. На время async-правил держит ноды их полей в `pending`.
+ * `skipDisabled` — проверка уровня формы: поля выключенных нод не учитываются.
+ *
+ * `touch`: `true` — пометить тронутыми проверенные поля; `'all'` — то же, а при отказе (`invalid`,
+ * `error`) ещё и всю форму: так попытка отправки раскрывает замечания полей, которых правила не
+ * касались. Отменённый результат не разносится и ничего не трогает.
+ *
+ * @internal
+ */
+export declare function runAndApply<T>(model: FormModel<T>, schema: ValidationDefinition<T>, options?: {
+    touch?: ValidationTouch;
+    skipDisabled?: boolean;
+}): Promise<ValidationResult>;
+/**
+ * Провалидировать модель ЛЮБОЙ схемой (шаг или вся форма): собрать результат и разнести ошибки по
+ * нодам формы. Возвращает `true` только для статуса `valid`: ошибки, сбой правила и отмена дают
+ * `false` (**fail-closed**). Чтобы различить их, берите {@link runValidation} либо
+ * `bundle.validate()` / `bundle.validateStep(id)` сборки формы.
+ *
+ * Гашение — на пару (model, schema): `validateModel(model, step2)` и `validateModel(model, form)`
+ * не мешают друг другу. Устаревший прогон (быстрый повторный вызов той же (model, schema))
+ * отменяется через `AbortSignal`.
+ *
+ * ⚠️ `schema` должна быть СТАБИЛЬНОЙ ссылкой: отмена устаревших прогонов ключится по идентичности
+ * `schema`. Инлайн-стрелка (`validateModel(model, ({ model }) => …)`) каждый раз создаёт НОВЫЙ
+ * прогон без дедупликации — держите схемы в `const` / `defineValidation`.
+ *
+ * @param model - Модель данных формы.
+ * @param schema - Схема валидации (стабильная ссылка).
+ * @param options - `{ touch }` — пометить провалидированные поля `touched` для показа ошибок.
+ *
+ * @example
+ * ```ts
+ * const ok = await validateModel(model, step2Validation);              // один шаг
+ * const all = await validateModel(model, formValidation);              // вся форма
+ * const stepOk = await validateModel(model, step2Validation, { touch: true }); // + показать ошибки шага
+ * ```
+ */
+export declare function validateModel<T>(model: FormModel<T>, schema: ValidationDefinition<T>, options?: {
+    touch?: boolean;
+}): Promise<boolean>;

package/dist/form/validation/strategy.d.ts

@@ -0,0 +1,89 @@
+import { ReadonlySignal } from '@preact/signals-core';
+import { FormModel } from '../../model/types';
+import { ValidationResult, ValidationDefinition } from './types';
+/**
+ * Когда запускается schema-валидация:
+ * - `submit` (по умолчанию) — только явным прогоном (`validate()`, отправка);
+ * - `blur` — при потере фокуса поля (каждый уход из любого листа, и повторный тоже);
+ * - `change` — на каждый ввод (с опц. `debounce`);
+ * - `afterFirstSubmit` — тихо до первой попытки отправки (`run({ submit: true })`), затем live
+ *   (см. `liveAfterSubmit`). Проверка без отправки (`validate()`) фазу не переключает.
+ */
+export type ValidationStrategyKind = 'submit' | 'blur' | 'change' | 'afterFirstSubmit';
+export interface ValidationStrategyOptions {
+    /** Стратегия запуска. Default `'submit'`. */
+    strategy?: ValidationStrategyKind;
+    /** Debounce (мс) для live-фаз (`change` и live-часть `afterFirstSubmit`). Default `0`. */
+    debounce?: number;
+    /** Режим live-фазы для `afterFirstSubmit`. Default `'change'`. */
+    liveAfterSubmit?: 'change' | 'blur';
+}
+/**
+ * Опции полного прогона {@link FormValidationController.run}.
+ */
+export interface FormValidationRunOptions {
+    /**
+     * Какие поля пометить тронутыми: `true` (по умолчанию) — проверенные правилами; `'all'` — они же,
+     * а при отказе (`invalid`, `error`) ещё и вся форма.
+     */
+    touch?: true | 'all';
+    /**
+     * Прогон — попытка отправки: переводит `afterFirstSubmit` в живую фазу. Проверка без отправки
+     * (`validate()`, кнопка «Проверить») фазу не трогает.
+     */
+    submit?: boolean;
+}
+export interface FormValidationController {
+    /**
+     * Полный прогон схемы с раскрытием замечаний проверенных полей (`touch: true`). Попыткой
+     * отправки не считается: `afterFirstSubmit` остаётся в тихой фазе. Возвращает `true` только для
+     * статуса `valid`: ошибки, сбой правила и отмена дают `false`.
+     */
+    validate(): Promise<boolean>;
+    /**
+     * Полный прогон с полным результатом: по статусу отличают ошибки (`invalid`) от сбоя правила
+     * (`error`) и отмены (`cancelled`). Без опций — тот же прогон, что
+     * {@link FormValidationController.validate}; `{ submit: true }` — попытка отправки,
+     * `{ touch: 'all' }` — при отказе раскрыть всю форму.
+     */
+    run(options?: FormValidationRunOptions): Promise<ValidationResult>;
+    /**
+     * Армировать реактивные подписки стратегии. Идемпотентно. Возвращает `dispose`. НЕ звать при SSR.
+     *
+     * После {@link FormValidationController.dispose} контроллер армируется ЗАНОВО: React монтирует
+     * компоненты повторно (StrictMode в разработке, remount по роуту), и «одноразовый» контроллер
+     * после такого цикла молча оставался бы без живой валидации.
+     */
+    start(): () => void;
+    /**
+     * Снять подписки и таймеры, отменить идущий прогон (его `validate()` или `run()` получит
+     * `cancelled`). Идемпотентно; после него `start()` снова армирует стратегию.
+     */
+    dispose(): void;
+    /** Идёт ли прогон (submit или live) — снапшот. */
+    readonly isValidating: boolean;
+    /** Реактивный сигнал состояния прогона (для тонкой подписки в UI). */
+    readonly validating: ReadonlySignal<boolean>;
+}
+/**
+ * Собрать контроллер валидации формы с выбранной стратегией запуска. Движок прогона — тот же, что у
+ * `validateModel`.
+ *
+ * Фабрика ЧИСТАЯ до `start()` (никаких подписок) — безопасна для SSR/headless. Реактивные триггеры
+ * арминуются только в `start()` (в React — из `useEffect`).
+ *
+ * @typeParam T - Форма данных модели.
+ * @param model - Модель данных.
+ * @param schema - Схема валидации. **Стабильная ссылка** (иначе устаревший прогон не отменится).
+ * @param options - {@link ValidationStrategyOptions}.
+ *
+ * @example
+ * ```ts
+ * const ctrl = createFormValidation(model, schema, { strategy: 'afterFirstSubmit', debounce: 300 });
+ * const dispose = ctrl.start();               // на клиенте
+ * const ok = await ctrl.validate();           // проверка: замечания проверенных полей
+ * const sent = await ctrl.run({ touch: 'all', submit: true }); // попытка отправки: живая фаза
+ * dispose();
+ * ```
+ */
+export declare function createFormValidation<T>(model: FormModel<T>, schema: ValidationDefinition<T>, options?: ValidationStrategyOptions): FormValidationController;

package/dist/form/validation/types.d.ts

@@ -0,0 +1,83 @@
+import { FormModel, PathAwareSignal } from '../../model/types';
+import { ValidationIssue } from '../types/contracts';
+/**
+ * Синхронное правило поля типа `TField`: получает значение, возвращает ошибку или `null`.
+ *
+ * Правило, написанное для более широкого типа, подходит полю с более узким: `min()` принимает
+ * `number | null | undefined` и годится и полю `number`, и полю `number | null`; `required()`
+ * принимает любое значение. Обратное — ошибка компиляции: `validate(model.$.age, [email()])`
+ * подсветится, потому что `email` ждёт строку, а поле числовое.
+ *
+ * Правило над несколькими полями — оператор `cross` области схемы: он получает снимок модели.
+ *
+ * @example
+ * ```ts
+ * const AMOUNT_RULES: Rule<number | null>[] = [required(), min(50000)];
+ * const notReserved: Rule<string> = (value) =>
+ *   value === 'admin' ? { code: 'reserved' } : null;
+ * ```
+ */
+export type Rule<TField> = (value: TField) => ValidationIssue | null;
+/**
+ * Асинхронное правило поля. Получает `AbortSignal` для отмены устаревших ответов (быстрый повторный
+ * прогон той же схемы отменяет предыдущий).
+ *
+ * Отклонённое правило (сеть, исключение) — это сбой проверки, а не «ошибок нет»: прогон получает
+ * статус `error`, поле — блокирующую ошибку `ruleFailed`. Если недоступность сервиса не должна
+ * мешать отправке, ловите ошибку в правиле и возвращайте `null` — это решение автора правила.
+ */
+export type AsyncRule<TField> = (value: TField, ctx: {
+    signal: AbortSignal;
+}) => Promise<ValidationIssue | null>;
+/**
+ * Область схемы валидации — то, что схема получает аргументом.
+ *
+ * В корне прогона область — вся форма; в схеме, подключённой через `apply` / `applyEach`, —
+ * под-модель группы или строки массива. Поэтому правила подформы пишутся один раз и не знают, где
+ * она стоит.
+ */
+export interface ValidationScope<T> {
+    /** Модель области. Привязки правил — через её `$`: `validate(model.$.email, [...])`. */
+    readonly model: FormModel<T>;
+    /**
+     * Правило над несколькими полями: `check` получает снимок модели области (`model.get()`) и
+     * вешает ошибку на поле `handle`. Тип снимка выведен из схемы — приводить его не нужно.
+     *
+     * @example
+     * ```ts
+     * defineValidation<Loan>(({ model, cross }) => {
+     *   cross(model.$.initialPayment, (loan) =>
+     *     loan.initialPayment > loan.propertyValue ? tooHigh : null
+     *   );
+     * });
+     * ```
+     */
+    cross(handle: PathAwareSignal<unknown>, check: (snapshot: T) => ValidationIssue | null): void;
+}
+/** Схема валидации — обычная функция над областью. First-class значение (можно `apply`/тестировать/переиспользовать). */
+export type ValidationDefinition<T> = (scope: ValidationScope<T>) => void;
+/**
+ * Чем закончился прогон схемы:
+ *  - `valid` — блокирующих ошибок нет (`severity: 'warning'` не блокирует);
+ *  - `invalid` — есть блокирующие ошибки;
+ *  - `error` — хотя бы одно async-правило не вернуло результат (сеть, исключение);
+ *  - `cancelled` — прогон устарел: для той же пары (model, schema) запущен следующий.
+ *
+ * Приоритет при нескольких причинах: `cancelled` → `error` → `invalid` → `valid`.
+ */
+export type ValidationStatus = 'valid' | 'invalid' | 'cancelled' | 'error';
+/** Правило, которое не вернуло результат. */
+export interface ValidationFailure {
+    /** Ручка поля `model.$.…`, чьё правило отклонилось. */
+    readonly handle: PathAwareSignal<unknown>;
+    /** То, чем правило отклонилось (ошибка сети, исключение). */
+    readonly error: unknown;
+}
+/** Результат прогона схемы валидации — см. `runValidation`. */
+export interface ValidationResult {
+    readonly status: ValidationStatus;
+    /** Ошибки по ручке поля `model.$.…`; путь — метаданные ручки (`handle.__path`). */
+    readonly issues: ReadonlyMap<PathAwareSignal<unknown>, readonly ValidationIssue[]>;
+    /** Правила, которые не вернули результат (сеть, исключение). */
+    readonly failures: readonly ValidationFailure[];
+}

package/dist/form/validators/date-utils.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Утилиты для работы с датами в валидаторах
+ *
+ * @group Validation
+ * @category Validators
+ * @module form/validators/date-utils
+ */
+/**
+ * Парсит значение в объект Date. Строгий формат: `Date` либо строка `YYYY-MM-DD` (значение
+ * `<input type="date">`); любая другая строка — не дата. Разбор движка (`new Date(строка)`) не
+ * используется: он угадывает дату по обрывкам (`'hello 1'`, `'March 7'`), и результат зависит от
+ * движка.
+ *
+ * Строка `YYYY-MM-DD` — локальная полночь этого дня: `new Date('2024-01-01')` дал бы полночь UTC,
+ * и западнее UTC правила дат сравнивали бы предыдущий день. Несуществующая дата (`2023-02-29`)
+ * не разбирается — движок перенёс бы её на 1 марта.
+ *
+ * @param value - Значение для парсинга (Date, string или undefined)
+ * @returns Date объект или null если парсинг не удался
+ */
+export declare function parseDate(value: string | Date | null | undefined): Date | null;
+/**
+ * Возвращает сегодняшнюю дату с обнулённым временем
+ */
+export declare function getToday(): Date;
+/**
+ * Нормализует дату, обнуляя время
+ */
+export declare function normalizeDate(date: Date): Date;
+/** Дата рождения позже сегодняшнего дня. */
+export declare function isFutureBirth(birthDate: Date): boolean;
+/**
+ * Вычисляет полный возраст (в годах) по календарным полям.
+ *
+ * Считаем по годам/месяцам/дням, а не делением миллисекунд на усреднённый год (365.25 дн): усреднение
+ * даёт off-by-one на границе — в день N-летия накопленных реальных дней меньше `N * 365.25`, и `floor`
+ * роняет возраст до `N - 1` (т.е. `minAge(18)` ошибочно отклонял 18-летнего в его день рождения).
+ *
+ * Родившийся 29 февраля в невисокосный год становится на год старше 28 февраля: срок, исчисляемый
+ * годами, истекает в последний день месяца, если соответствующего числа в нём нет (ГК РФ, ст. 192).
+ */
+export declare function calculateAge(birthDate: Date): number;

package/dist/form/validators/email.d.ts

@@ -0,0 +1,23 @@
+import { RuleOptions } from '../types/validation-schema';
+import { Rule } from '../validation/types';
+/**
+ * Фабрика валидатора формата email.
+ *
+ * Проверяет по упрощённому regex `^[^\s@]+@[^\s@]+\.[^\s@]+$`. Пустые значения
+ * (`''`/`null`/`undefined`) пропускаются (используйте {@link required} для обязательности).
+ *
+ * @param options - Опции валидатора ({@link RuleOptions}): `code`, `params`
+ * @returns Правило {@link Rule} для строкового поля
+ *
+ * @example Проверка формата email
+ * ```typescript
+ * import { defineValidation, validate } from '@reformer/core/validation';
+ * import { required, email } from '@reformer/core/validators';
+ *
+ * // Правила живут в отдельной схеме над МОДЕЛЬЮ — layout-схема валидаторов не несёт.
+ * const validation = defineValidation<MyForm>(({ model }) => {
+ *   validate(model.$.email, [required(), email({ code: 'email.email' })]);
+ * });
+ * ```
+ */
+export declare function email(options?: RuleOptions): Rule<string | null | undefined>;

package/dist/form/{validation/validators → validators}/file-type.d.ts

@@ -1,4 +1,5 @@
-import { Validator, ValidateOptions } from '../../types/validation-schema';
+import { RuleOptions } from '../types/validation-schema';
+import { Rule } from '../validation/types';
 /**
  * Фабрика валидатора типа файла.
  *
@@ -12,20 +13,19 @@ import { Validator, ValidateOptions } from '../../types/validation-schema';
  * пропускаются (используйте {@link required} для обязательности).
  *
  * @param accept - Accept-строка допустимых типов, например `'image/*,.pdf'`
- * @param options - Опции валидатора ({@link ValidateOptions}). В `params` ошибки автоматически
+ * @param options - Опции валидатора ({@link RuleOptions}). В `params` ошибки автоматически
  *   попадают `accept` и `fileName` (первый нарушивший файл).
- * @returns Чистый валидатор {@link Validator} для файла или массива файлов
+ * @returns Правило {@link Rule} для файла или массива файлов
  *
  * @example Только изображения и PDF
  * ```typescript
+ * import { defineValidation, validate } from '@reformer/core/validation';
  * import { fileType } from '@reformer/core/validators';
  *
- * // Внутри FieldConfig схемы формы:
- * documents: {
- *   value: model.$.documents,
- *   component: FileUploadField,
- *   validators: [fileType('image/*,.pdf', { message: 'Только изображения или PDF' })],
- * },
+ * // Правила живут в отдельной схеме над МОДЕЛЬЮ — layout-схема валидаторов не несёт.
+ * const validation = defineValidation<MyForm>(({ model }) => {
+ *   validate(model.$.documents, [fileType('image/*,.pdf', { code: 'documents.fileType' })]);
+ * });
  * ```
  */
-export declare function fileType<TForm = unknown, TField = unknown>(accept: string, options?: ValidateOptions): Validator<TForm, TField>;
+export declare function fileType(accept: string, options?: RuleOptions): Rule<unknown>;

package/dist/form/{validation/validators → validators}/file-utils.d.ts

@@ -7,7 +7,7 @@
  *
  * @group Validation
  * @category Validators
- * @module validators/file-utils
+ * @module form/validators/file-utils
  */
 /**
  * Минимальный файлоподобный контракт, с которым работают file-валидаторы:
@@ -39,7 +39,8 @@ export declare function toFileArray(value: unknown): FileLike[] | null;
 /**
  * Проверяет файл против accept-паттерна в синтаксисе нативного атрибута
  * `<input type="file" accept>`: список через запятую из расширений (`.pdf`),
- * точных MIME (`image/png`) и wildcard-категорий (`image/*`). Регистронезависимо.
+ * точных MIME (`image/png`) и wildcard-категорий (`image/*`); шаблон «любой тип» (звёздочка,
+ * слэш, звёздочка) пропускает любой файл. Регистронезависимо.
  *
  * Нужен собственный матчер, потому что `accept` у нативного input — только подсказка
  * пикеру: на drag-and-drop и на программное значение он не действует.

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

@@ -0,0 +1,23 @@
+import { RuleOptions } from '../types/validation-schema';
+import { Rule } from '../validation/types';
+/**
+ * Фабрика валидатора, проверяющего что дата не в прошлом.
+ *
+ * Дата не должна быть раньше сегодняшнего дня (сравнение по нормализованным датам).
+ * Пустые и невалидные даты пропускаются (используйте {@link required} и {@link isDate}).
+ *
+ * @param options - Опции валидатора ({@link RuleOptions}): `code`, `params`
+ * @returns Правило {@link Rule} для поля даты (`string | Date`)
+ *
+ * @example Дата не в прошлом
+ * ```typescript
+ * import { defineValidation, validate } from '@reformer/core/validation';
+ * import { required, futureDate } from '@reformer/core/validators';
+ *
+ * // Правила живут в отдельной схеме над МОДЕЛЬЮ — layout-схема валидаторов не несёт.
+ * const validation = defineValidation<MyForm>(({ model }) => {
+ *   validate(model.$.appointmentDate, [required(), futureDate({ code: 'appointmentDate.futureDate' })]);
+ * });
+ * ```
+ */
+export declare function futureDate(options?: RuleOptions): Rule<string | Date | null | undefined>;

package/dist/form/{validation/validators → validators}/index.d.ts

@@ -1,9 +1,12 @@
 /**
- * Reusable validator factories.
+ * Точка входа сабпата `@reformer/core/validators` — все фабрики правил одним импортом.
  *
- * Все примитивы — фабрики, возвращающие чистый Validator<TForm, TField>.
- * Импортируются из `@reformer/core/validators` и передаются в массив `validators`
- * поля схемы формы: `validators: [required(), min(18)]`.
+ * Все примитивы — фабрики, возвращающие чистый `Validator<TForm, TField>`; передаются вторым
+ * аргументом оператора `validate` внутри схемы валидации: `validate(model.$.age, [required(), min(18)])`.
+ * В layout-схему формы правила НЕ кладутся — поля `validators` у узла нет.
+ *
+ * Гранулярные сабпаты (`@reformer/core/validators/required` и ещё 20) собираются отдельными
+ * entry для tree-shaking; этот модуль отдаёт полный набор для случаев, когда правил много.
  */
 export { required } from './required';
 export { min } from './min';