@reformer/core 9.1.1 → 10.0.0-beta.1

package/README.md

@@ -30,19 +30,21 @@ npm install @reformer/core@beta # Active development is underway, so you can try
 
 ## Quick Start
 
-ReFormer is built around the **M1 architecture**: a reactive `FormModel` owns the values, a single
-schema binds field config (component / validators) to the model's signals, and `createForm({ model, schema })`
-wires them into a typed form.
+ReFormer is built around the **M1 architecture**: a reactive `FormModel` owns the values, a layout
+schema binds field config (component / props) to the model's signals, and `createForm({ model, schema })`
+wires them into a typed form. Validation is a **separate** ambient contract — `defineValidationSchema`,
+run on demand by `validateModel(model, schema)` — so the layout schema carries no validators.
 
 ```tsx
 import { useMemo } from 'react';
 import {
   createModel,
   createForm,
-  validateFormModel,
   useFormControl,
   type FieldNode,
+  type ValidationError,
 } from '@reformer/core';
+import { validate, cross, defineValidationSchema, validateModel } from '@reformer/core/validation';
 import { required, email, minLength } from '@reformer/core/validators';
 import { defineFormBehavior, onChange } from '@reformer/core/behaviors';
 
@@ -79,45 +81,54 @@ const model = createModel<RegistrationForm>({
   confirmPassword: '',
 });
 
-// 3. Single schema — binds field config to model signals (`model.$.<field>`).
-//    Validators are inline factories from `@reformer/core/validators`.
-//    Cross-field validation is a ModelValidator `(value, model) => error | null`.
+// 3. Layout schema — binds field config (component / props) to model signals
+//    (`model.$.<field>`). Layout carries NO validators; rules live in the
+//    validation schema below.
 const schema = {
   children: [
-    { value: model.$.username, component: Input, validators: [required(), minLength(2)] },
-    { value: model.$.email, component: Input, validators: [required(), email()] },
-    { value: model.$.password, component: Input, validators: [required(), minLength(8)] },
-    {
-      value: model.$.confirmPassword,
-      component: Input,
-      validators: [
-        required(),
-        (value, m) =>
-          value && m.password && value !== m.password
-            ? { code: 'mismatch', message: 'Passwords do not match' }
-            : null,
-      ],
-    },
+    { value: model.$.username, component: Input },
+    { value: model.$.email, component: Input },
+    { value: model.$.password, component: Input },
+    { value: model.$.confirmPassword, component: Input },
   ],
 };
 
-// 4. Behavior — declarative reactive logic, run by `createForm({ behavior })`.
-//    Clear confirmPassword whenever password changes.
-const behavior = defineFormBehavior<RegistrationForm>(({ model }) => {
+// 4. Validation schema — a separate ambient contract from `@reformer/core/validation`,
+//    run on demand (not reactive). Field rules go through `validate(sig, [rules])`;
+//    cross-field rules through `cross(sig, snapshot => error | null)` where the snapshot
+//    is `model.get()`. Rule factories (`required()`/…) come from `@reformer/core/validators`.
+const passwordsMatch = (f: RegistrationForm): ValidationError | null =>
+  f.confirmPassword && f.password && f.confirmPassword !== f.password
+    ? { code: 'mismatch', message: 'Passwords do not match' }
+    : null;
+
+const validationSchema = defineValidationSchema<RegistrationForm>(({ model }) => {
+  validate(model.$.username, [required(), minLength(2)]);
+  validate(model.$.email, [required(), email()]);
+  validate(model.$.password, [required(), minLength(8)]);
+  validate(model.$.confirmPassword, [required()]);
+  cross(model.$.confirmPassword, passwordsMatch);
+});
+
+// 5. Behavior — declarative reactive logic, run by `createForm({ behavior })`.
+//    Validation runs on demand, so the stale cross-field error on `confirmPassword`
+//    is cleared the moment `password` changes — a behavior→validation bridge.
+const behavior = defineFormBehavior<RegistrationForm>(({ model, form }) => {
   onChange(model.$.password, () => {
-    if (model.confirmPassword) model.confirmPassword = '';
+    form.confirmPassword.clearErrors();
   });
 });
 
-// 5. Registration form component
+// 6. Registration form component
 function RegistrationFormExample() {
   const form = useMemo(() => createForm<RegistrationForm>({ model, schema, behavior }), []);
 
   const handleSubmit = async (e: React.FormEvent) => {
     e.preventDefault();
     form.touchAll();
-    // Validate the whole model against the schema (sync + async); errors route into the form.
-    const { valid } = await validateFormModel(model, schema);
+    // Validate the whole model against the validation schema (sync + async) on demand;
+    // errors route into the form nodes, so the UI highlights the offending fields.
+    const valid = await validateModel(model, validationSchema);
     if (valid) {
       console.log('Form data:', model.get());
     }

package/dist/behaviors-node-DUrqAqp1.js

@@ -0,0 +1,18 @@
+import { effect as i } from "@preact/signals-core";
+import { g as s } from "./signal-node-registry-tiwel-TV.js";
+import { d as f } from "./behaviors-value-lCpqicfa.js";
+function a(n, r, t) {
+  return i(() => {
+    const o = r(), e = s(n);
+    e && f(() => {
+      o ? e.enable() : (e.disable(), t?.resetOnDisable && e.reset());
+    });
+  });
+}
+function b(n, r, t) {
+  return a(n, () => !r(), t);
+}
+export {
+  b as d,
+  a as e
+};

package/dist/behaviors.js

@@ -1,6 +1,6 @@
 import { effect as O } from "@preact/signals-core";
 import { d as $, m as k, u as x, a as S, w as F, t as A, r as C, s as D, b as M } from "./behaviors-value-lCpqicfa.js";
-import { e as G } from "./behaviors-node-BMOI2JJF.js";
+import { e as G } from "./behaviors-node-DUrqAqp1.js";
 let p = null;
 function P(e) {
   if (!p)

package/dist/form/create-form.d.ts

@@ -73,12 +73,13 @@ export declare function createFormFromModel<T>(args: CreateFormFromModelArgs<T>)
  *
  * @group Utilities
  *
- * @param args - Модель данных, единая схема (component/componentProps/validators) и (опционально) поведение
+ * @param args - Модель данных, layout-схема (component/componentProps) и (опционально) поведение
  * @returns Типизированная форма с Proxy-доступом к полям
  *
- * @example Архитектура M1: `createModel` + единая схема + `createForm({ model, schema })`
+ * @example Архитектура M1: `createModel` + layout-схема + `createForm({ model, schema })`
  * ```typescript
- * import { createModel, createForm, validateFormModel } from '@reformer/core';
+ * import { createModel, createForm } from '@reformer/core';
+ * import { defineValidationSchema, validate, validateModel } from '@reformer/core/validation';
  * import { required, email, minLength } from '@reformer/core/validators';
  *
  * interface UserForm {
@@ -88,28 +89,23 @@ export declare function createFormFromModel<T>(args: CreateFormFromModelArgs<T>)
  *
  * const model = createModel<UserForm>({ email: '', password: '' });
  *
+ * // Layout-схема НЕ несёт validators — только component/componentProps.
  * const schema = {
  *   children: [
- *     {
- *       value: model.$.email,
- *       component: Input,
- *       validators: [required(), email()],
- *     },
- *     {
- *       value: model.$.password,
- *       component: Input,
- *       validators: [required(), minLength(8)],
- *     },
+ *     { value: model.$.email, component: Input },
+ *     { value: model.$.password, component: Input },
  *   ],
  * };
  *
  * const form = createForm<UserForm>({ model, schema });
- *
- * // TypeScript знает о полях (нода привязана к сигналу модели):
  * form.email.setValue('test@mail.com');
  *
- * // Валидация всей модели по схеме (sync + async):
- * const { valid } = await validateFormModel(model, schema);
+ * // Валидация — ОТДЕЛЬНАЯ схема, прогон внешним раннером (ошибки сами доезжают до нод):
+ * const validation = defineValidationSchema<UserForm>(({ model }) => {
+ *   validate(model.$.email, [required(), email()]);
+ *   validate(model.$.password, [required(), minLength(8)]);
+ * });
+ * const ok = await validateModel(model, validation);
  * ```
  */
 export declare function createForm<T>(args: CreateFormFromModelArgs<T>): FormProxy<T>;

package/dist/form/index.d.ts

@@ -2,9 +2,10 @@
  * Модуль `form` — доменный слой формы поверх state-субстрата (`model`).
  *
  * Ноды (value/touched/dirty/status/errors/componentProps), сборка формы из модели по идентичности
- * сигнала (`createForm`), state-операции над нодами (`enableWhen`/`disableWhen`), in-form роутинг
- * валидации (`validateFormModel`), submit/статус, React-хуки. Зависит от `model` (form→state
- * разрешено); обратной зависимости нет.
+ * сигнала (`createForm`), state-операции над нодами (`enableWhen`/`disableWhen`), submit/статус,
+ * React-хуки. Schema-валидация — внешний контракт `@reformer/core/validation` (`validateModel`),
+ * роутит ошибки в ноды через реестр сигнал→нода. Зависит от `model` (form→state разрешено);
+ * обратной зависимости нет.
  *
  * @group Form
  * @module form
@@ -18,9 +19,6 @@ export { ModelArrayNode } from './nodes/model-array-node';
 export type { ModelArrayControl } from './nodes/model-array-node';
 export { createForm, createFormFromModel } from './create-form';
 export type { CreateFormFromModelArgs } from './create-form';
-export { validateModel, validateModelSync } from './validate-model-core';
-export type { ModelValidator, ModelValidationResult } from './validate-model-core';
-export { validateFormModel } from './validate-model';
 export { enableWhen, disableWhen } from './behaviors-node';
 export { FormErrorHandler, ErrorStrategy } from './error-handler';
 export { registerSignalNode, getNodeForSignal } from './signal-node-registry';

package/dist/form/nodes/group-node.d.ts

@@ -7,8 +7,8 @@ import { SubmitOptions, SubmitResult } from '../form-submitter';
  * GroupNode - узел для группы полей
  *
  * Создаётся из {@link FormSchema} (дерево field-конфигов). Обычно строится через `createForm`
- * (M1: `createForm({ model, schema })`); валидация/behavior живут на слое модели
- * (`validateFormModel`, `computeFrom`/`enableWhen`/…), а не на ноде.
+ * (M1: `createForm({ model, schema })`); schema-валидация/behavior живут на слое модели
+ * (`validateModel` из `@reformer/core/validation`, `computeFrom`/`enableWhen`/…), а не на ноде.
  *
  * @group Nodes
  *
@@ -54,12 +54,6 @@ export declare class GroupNode<T> extends FormNode<T> {
     private readonly _disabled;
     /** Form-level validation errors */
     private readonly _formErrors;
-    /**
-     * M1: валидация уровня модели/схемы (`validateFormModel(model, schema)`). Привязывается
-     * `createForm({ model, schema })`, т.к. под M1 валидаторы срезаны с FieldNode и живут на слое
-     * модели. Без неё `validate()`/`submit()` пропускали бы все schema-валидаторы. @internal
-     */
-    private _modelValidate?;
     /**
      * M1: связь листовой ноды-ребёнка → её сигнал модели (тот, что помечает `markDerived`).
      * Нужна bulk-сеттерам (`setValue`/`patchValue`), чтобы корректно определять derived-поля:
@@ -281,13 +275,6 @@ export declare class GroupNode<T> extends FormNode<T> {
      * @internal
      */
     attachBehaviorCleanup(cleanup: () => void): void;
-    /**
-     * Прикрепить валидацию уровня модели/схемы (M1). Вызывается `createForm({ model, schema })`,
-     * чтобы `validate()`/`submit()` прогоняли schema-валидаторы (`validateFormModel`), а не только
-     * пустые FieldNode. Возвращаемый флаг — валидна ли модель по схеме.
-     * @internal
-     */
-    attachModelValidator(validate: () => Promise<boolean>): void;
     /**
      * Связать листовую ноду-ребёнка с её сигналом модели (M1). Вызывается `createForm` для каждого
      * листового поля на его владеющей группе — используется bulk-сеттерами для derived-guard (F9).

package/dist/form/types/schema-node.d.ts

@@ -1,10 +1,10 @@
-import { ComponentType } from 'react';
+import { ElementType } from 'react';
 import { ValidationError } from './contracts';
 /**
- * Валидатор поля схемы. Узел хранит validators гетерогенно: движок `validate*` вызывает их как
- * `(value, scope, root)`, но сюда кладут любой контракт — `ValidatorFn` (value),
- * `Validator` (value, control, root) или `ModelValidator` (value, model, root). Поэтому тип
- * намеренно широкий по параметрам.
+ * Валидатор поля схемы (legacy). Дерево-движок, вызывавший `validators` узла как
+ * `(value, scope, root)`, удалён — живые правила это `Rule<T>` в `validate(sig, [...])`
+ * (`@reformer/core/validation`). Тип остаётся широким по параметрам для совместимости
+ * узлов, всё ещё несущих `validators` (гетерогенные контракты `ValidatorFn`/`Validator`).
  *
  * @group Types
  */
@@ -26,8 +26,8 @@ export interface SchemaArrayControl {
     removeAt(index: number): void;
 }
 /**
- * Узел единой схемы M1 — дерево, обходимое `createForm({ model, schema })`,
- * `validateModel`/`validateFormModel` и рендерерами.
+ * Узел единой схемы M1 — layout-дерево, обходимое `createForm({ model, schema })`
+ * и рендерерами (schema-валидация живёт отдельно — `@reformer/core/validation`).
  *
  * Узел совмещает несколько ролей (различаются рантаймом по форме):
  *  - **поле** — несёт `value: Signal` (сигнал модели `model.$.x`) + `component`/`validators`;
@@ -47,8 +47,12 @@ export interface FormSchemaNode {
      * `Signal`). Движок разбирает узел как поле рантаймом по `value instanceof Signal`.
      */
     value?: unknown;
-    /** UI-компонент. Опционален: core-часть работает без UI (значение/валидация). */
-    component?: ComponentType<any>;
+    /**
+     * UI-компонент либо нативный HTML-тег (`'div'`, `'p'`, `'h3'`) для презентационной вёрстки
+     * прямо в схеме. Опционален: core-часть работает без UI (значение/валидация) и `component`
+     * не интерпретирует — он доезжает до рендерера как есть.
+     */
+    component?: ElementType;
     /** Props компонента. Также «клапан» для вложенности под-узлов (напр. steps визарда). */
     componentProps?: Record<string, unknown>;
     validators?: SchemaValidator[];

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

@@ -1,36 +1,14 @@
 import { FormValue, ValidationError } from './index';
 import { FormModel } from '../../state/types';
 /**
- * Чистый синхронный валидатор поля.
+ * Чистый синхронный валидатор поля (legacy-сигнатура `(value, scope, root)`).
  *
- * Сигнатура зеркалит то, что реально вызывает движок M1
- * (`validateModel`/`validateFormModel`/`validateModelSync`): `validator(value, scope, root)`.
- * - `value` — значение поля (`TField`);
- * - `scope` — ближайшая scope-**модель** (под-модель элемента массива или корень). Из `TForm`/`TField`
- *   её тип не выводится, поэтому `unknown` — потребитель сужает сам (для типизированного scope
- *   используйте {@link ModelValidator}`<TField, TScope, TForm>`);
- * - `root` — корневая модель формы `FormModel<TForm>` (реактивный value-proxy: `root.field` читает
- *   значение). Возвращает `ValidationError` либо `null`. Не знает про реестр валидации.
- *
- * Совместим с полем `validators` узла схемы (см. `SchemaValidator`) — там же лежат `ModelValidator`
- * и `ValidatorFn`. Встроенные фабрики (`required()`/`email()`/…) возвращают `(value) => …` и
- * дополнительные аргументы игнорируют.
- *
- * @example Кастомный валидатор в массиве `validators` поля схемы
- * ```typescript
- * const isAdult: Validator<MyForm, number> = (value, _scope, root) => {
- *   if (value < 18) return { code: 'tooYoung', message: '18+' };
- *   // root — FormModel<MyForm>: root.someOtherField читается как значение
- *   return null;
- * };
- *
- * // Фабрики и кастомные валидаторы кладутся в `validators: [...]` поля:
- * const schema = {
- *   children: [
- *     { value: model.$.age, component: Input, validators: [required(), isAdult] },
- *   ],
- * };
- * ```
+ * @deprecated Осиротевший остаток удалённого дерево-движка (`validateFormModel`). Живой контракт —
+ * `Rule<T> = (value) => ValidationError | null` из `@reformer/core/validation`: правила
+ * передаются в `validate(sig, [rules])` внутри `defineValidationSchema` и запускаются
+ * `validateModel(model, schema)`. Cross-field — оператор `cross(sig, (f) => …)` над снапшотом
+ * `model.get()` (третий аргумент `root` больше не нужен). Тип экспортируется только ради
+ * обратной совместимости (`SchemaValidator`-union).
  */
 export type Validator<TForm, TField> = (value: TField, scope: unknown, root: FormModel<TForm>) => ValidationError | null;
 /**

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

@@ -19,3 +19,10 @@ 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';

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

@@ -20,4 +20,4 @@ import { Validator, ValidateOptions } from '../../types/validation-schema';
  * },
  * ```
  */
-export declare function email<TForm = unknown, TField extends string | undefined = string>(options?: ValidateOptions): Validator<TForm, TField>;
+export declare function email<TForm = unknown, TField extends string | null | undefined = string>(options?: ValidateOptions): Validator<TForm, TField>;

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

@@ -0,0 +1,31 @@
+import { Validator, ValidateOptions } from '../../types/validation-schema';
+/**
+ * Фабрика валидатора типа файла.
+ *
+ * Проверяет каждый файл против accept-строки в синтаксисе нативного атрибута
+ * `<input type="file" accept>`: расширения (`.pdf`), точные MIME (`image/png`),
+ * wildcard-категории (`image/*`), список через запятую. Матчинг регистронезависимый,
+ * по `type` и/или расширению из `name` ({@link matchesFileAccept}).
+ *
+ * Нужен потому, что нативный `accept` — только подсказка пикеру: на drag-and-drop
+ * и «All files» он не действует. Пустые значения (`null`/`undefined`/`''`/`[]`)
+ * пропускаются (используйте {@link required} для обязательности).
+ *
+ * @param accept - Accept-строка допустимых типов, например `'image/*,.pdf'`
+ * @param options - Опции валидатора ({@link ValidateOptions}). В `params` ошибки автоматически
+ *   попадают `accept` и `fileName` (первый нарушивший файл).
+ * @returns Чистый валидатор {@link Validator} для файла или массива файлов
+ *
+ * @example Только изображения и PDF
+ * ```typescript
+ * import { fileType } from '@reformer/core/validators';
+ *
+ * // Внутри FieldConfig схемы формы:
+ * documents: {
+ *   value: model.$.documents,
+ *   component: FileUploadField,
+ *   validators: [fileType('image/*,.pdf', { message: 'Только изображения или PDF' })],
+ * },
+ * ```
+ */
+export declare function fileType<TForm = unknown, TField = unknown>(accept: string, options?: ValidateOptions): Validator<TForm, TField>;

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

@@ -0,0 +1,51 @@
+/**
+ * Утилиты для работы с файлами в валидаторах.
+ *
+ * Duck-typing вместо `instanceof File` — SSR-безопасность (в Node может не быть глобального
+ * `File`) и поддержка сериализуемых дескрипторов загруженных файлов (`RemoteFileRef` из
+ * `@reformer/cdk/file-upload`) наравне с нативными `File`.
+ *
+ * @group Validation
+ * @category Validators
+ * @module validators/file-utils
+ */
+/**
+ * Минимальный файлоподобный контракт, с которым работают file-валидаторы:
+ * нативный `File`, сериализуемый дескриптор загруженного файла и т.п.
+ */
+export interface FileLike {
+    name: string;
+    size?: number;
+    type?: string;
+}
+/**
+ * Проверяет, что значение файлоподобно: объект со строковым `name` и опциональными
+ * числовым `size` / строковым `type`.
+ *
+ * @param value - Проверяемое значение
+ * @returns `true`, если значение соответствует {@link FileLike}
+ */
+export declare function isFileLike(value: unknown): value is FileLike;
+/**
+ * Нормализует значение file-поля в массив файлоподобных элементов.
+ *
+ * Одиночный {@link FileLike} оборачивается в массив; из массива отбираются только
+ * файлоподобные элементы. Для прочих значений — `null` (валидатор пропускает).
+ *
+ * @param value - Значение поля (`FileLike`, `FileLike[]` или что-то ещё)
+ * @returns Массив файлоподобных элементов или `null`
+ */
+export declare function toFileArray(value: unknown): FileLike[] | null;
+/**
+ * Проверяет файл против accept-паттерна в синтаксисе нативного атрибута
+ * `<input type="file" accept>`: список через запятую из расширений (`.pdf`),
+ * точных MIME (`image/png`) и wildcard-категорий (`image/*`). Регистронезависимо.
+ *
+ * Нужен собственный матчер, потому что `accept` у нативного input — только подсказка
+ * пикеру: на drag-and-drop и на программное значение он не действует.
+ *
+ * @param file - Файлоподобное значение (`name` + опциональный `type`)
+ * @param accept - Accept-строка; пустая/пробельная строка матчит всё
+ * @returns `true`, если файл подходит хотя бы под один паттерн
+ */
+export declare function matchesFileAccept(file: Pick<FileLike, 'name' | 'type'>, accept: string): boolean;

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

@@ -20,4 +20,4 @@ import { Validator, ValidateOptions } from '../../types/validation-schema';
  * },
  * ```
  */
-export declare function futureDate<TForm = unknown, TField extends string | Date | undefined = string | Date>(options?: ValidateOptions): Validator<TForm, TField>;
+export declare function futureDate<TForm = unknown, TField extends string | Date | null | undefined = string | Date>(options?: ValidateOptions): Validator<TForm, TField>;

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

@@ -26,3 +26,10 @@ export { pastDate } from './past-date';
 export { futureDate } from './future-date';
 export { minAge } from './min-age';
 export { maxAge } from './max-age';
+export { maxFileSize } from './max-file-size';
+export { minFileSize } from './min-file-size';
+export { fileType } from './file-type';
+export { maxFiles } from './max-files';
+export { minFiles } from './min-files';
+export { maxTotalFileSize } from './max-total-file-size';
+export { isFileLike, matchesFileAccept, toFileArray, type FileLike } from './file-utils';

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

@@ -20,4 +20,4 @@ import { Validator, ValidateOptions } from '../../types/validation-schema';
  * },
  * ```
  */
-export declare function isDate<TForm = unknown, TField extends string | Date | undefined = string | Date>(options?: ValidateOptions): Validator<TForm, TField>;
+export declare function isDate<TForm = unknown, TField extends string | Date | null | undefined = string | Date>(options?: ValidateOptions): Validator<TForm, TField>;

package/dist/form/validation/validators/max-file-size.d.ts

@@ -0,0 +1,28 @@
+import { Validator, ValidateOptions } from '../../types/validation-schema';
+/**
+ * Фабрика валидатора максимального размера файла.
+ *
+ * Работает с одиночным файлом или массивом (`File` либо файлоподобный дескриптор с
+ * `name`/`size`). Проверяется каждый файл; в ошибку попадает первый нарушивший.
+ * Пустые значения (`null`/`undefined`/`''`/`[]`) и элементы без числового `size`
+ * (например, дескриптор загруженного файла без размера) пропускаются
+ * (используйте {@link required} для обязательности).
+ *
+ * @param maxSize - Максимально допустимый размер файла в байтах (включительно)
+ * @param options - Опции валидатора ({@link ValidateOptions}). В `params` ошибки автоматически
+ *   попадают `maxFileSize`, `fileName` и `actualSize`.
+ * @returns Чистый валидатор {@link Validator} для файла или массива файлов
+ *
+ * @example Ограничение размера вложений
+ * ```typescript
+ * import { maxFileSize } from '@reformer/core/validators';
+ *
+ * // Внутри FieldConfig схемы формы:
+ * documents: {
+ *   value: model.$.documents,
+ *   component: FileUploadField,
+ *   validators: [maxFileSize(5 * 1024 * 1024, { message: 'Файл больше 5 МБ' })],
+ * },
+ * ```
+ */
+export declare function maxFileSize<TForm = unknown, TField = unknown>(maxSize: number, options?: ValidateOptions): Validator<TForm, TField>;

package/dist/form/validation/validators/max-files.d.ts

@@ -0,0 +1,26 @@
+import { Validator, ValidateOptions } from '../../types/validation-schema';
+/**
+ * Фабрика валидатора максимального количества файлов.
+ *
+ * Работает с массивом файлов (одиночный файл считается как 1). Пустые значения
+ * (`null`/`undefined`/`''`/`[]`) пропускаются (используйте {@link required}
+ * для обязательности).
+ *
+ * @param max - Максимально допустимое количество файлов (включительно)
+ * @param options - Опции валидатора ({@link ValidateOptions}). В `params` ошибки автоматически
+ *   попадают `maxFiles` и `actualCount`.
+ * @returns Чистый валидатор {@link Validator} для файла или массива файлов
+ *
+ * @example Не более трёх вложений
+ * ```typescript
+ * import { maxFiles } from '@reformer/core/validators';
+ *
+ * // Внутри FieldConfig схемы формы:
+ * documents: {
+ *   value: model.$.documents,
+ *   component: FileUploadField,
+ *   validators: [maxFiles(3, { message: 'Максимум 3 файла' })],
+ * },
+ * ```
+ */
+export declare function maxFiles<TForm = unknown, TField = unknown>(max: number, options?: ValidateOptions): Validator<TForm, TField>;

package/dist/form/validation/validators/max-total-file-size.d.ts

@@ -0,0 +1,26 @@
+import { Validator, ValidateOptions } from '../../types/validation-schema';
+/**
+ * Фабрика валидатора суммарного размера всех файлов.
+ *
+ * Складывает `size` всех файлов значения (элементы без числового `size` в сумму
+ * не входят). Пустые значения (`null`/`undefined`/`''`/`[]`) пропускаются
+ * (используйте {@link required} для обязательности).
+ *
+ * @param maxTotal - Максимально допустимый суммарный размер в байтах (включительно)
+ * @param options - Опции валидатора ({@link ValidateOptions}). В `params` ошибки автоматически
+ *   попадают `maxTotalFileSize` и `actualTotal`.
+ * @returns Чистый валидатор {@link Validator} для файла или массива файлов
+ *
+ * @example Суммарно не более 20 МБ
+ * ```typescript
+ * import { maxTotalFileSize } from '@reformer/core/validators';
+ *
+ * // Внутри FieldConfig схемы формы:
+ * documents: {
+ *   value: model.$.documents,
+ *   component: FileUploadField,
+ *   validators: [maxTotalFileSize(20 * 1024 * 1024, { message: 'Суммарно не более 20 МБ' })],
+ * },
+ * ```
+ */
+export declare function maxTotalFileSize<TForm = unknown, TField = unknown>(maxTotal: number, options?: ValidateOptions): Validator<TForm, TField>;

package/dist/form/validation/validators/min-file-size.d.ts

@@ -0,0 +1,28 @@
+import { Validator, ValidateOptions } from '../../types/validation-schema';
+/**
+ * Фабрика валидатора минимального размера файла.
+ *
+ * Работает с одиночным файлом или массивом (`File` либо файлоподобный дескриптор с
+ * `name`/`size`). Проверяется каждый файл; в ошибку попадает первый нарушивший.
+ * Типовой сценарий — отсев пустых (0-байтовых) файлов: `minFileSize(1)`.
+ * Пустые значения (`null`/`undefined`/`''`/`[]`) и элементы без числового `size`
+ * пропускаются (используйте {@link required} для обязательности).
+ *
+ * @param minSize - Минимально допустимый размер файла в байтах (включительно)
+ * @param options - Опции валидатора ({@link ValidateOptions}). В `params` ошибки автоматически
+ *   попадают `minFileSize`, `fileName` и `actualSize`.
+ * @returns Чистый валидатор {@link Validator} для файла или массива файлов
+ *
+ * @example Отсев пустых файлов
+ * ```typescript
+ * import { minFileSize } from '@reformer/core/validators';
+ *
+ * // Внутри FieldConfig схемы формы:
+ * documents: {
+ *   value: model.$.documents,
+ *   component: FileUploadField,
+ *   validators: [minFileSize(1, { message: 'Файл пустой' })],
+ * },
+ * ```
+ */
+export declare function minFileSize<TForm = unknown, TField = unknown>(minSize: number, options?: ValidateOptions): Validator<TForm, TField>;

package/dist/form/validation/validators/min-files.d.ts

@@ -0,0 +1,26 @@
+import { Validator, ValidateOptions } from '../../types/validation-schema';
+/**
+ * Фабрика валидатора минимального количества файлов.
+ *
+ * Работает с массивом файлов (одиночный файл считается как 1). Пустые значения
+ * (`null`/`undefined`/`''`/`[]`) пропускаются — «нужен хотя бы один файл» выражается
+ * связкой `required()` + `minFiles(n)`, как и у {@link minLength}.
+ *
+ * @param min - Минимально допустимое количество файлов (включительно)
+ * @param options - Опции валидатора ({@link ValidateOptions}). В `params` ошибки автоматически
+ *   попадают `minFiles` и `actualCount`.
+ * @returns Чистый валидатор {@link Validator} для файла или массива файлов
+ *
+ * @example Не менее двух документов
+ * ```typescript
+ * import { required, minFiles } from '@reformer/core/validators';
+ *
+ * // Внутри FieldConfig схемы формы:
+ * documents: {
+ *   value: model.$.documents,
+ *   component: FileUploadField,
+ *   validators: [required(), minFiles(2, { message: 'Приложите минимум 2 документа' })],
+ * },
+ * ```
+ */
+export declare function minFiles<TForm = unknown, TField = unknown>(min: number, options?: ValidateOptions): Validator<TForm, TField>;

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

@@ -20,4 +20,4 @@ import { Validator, ValidateOptions } from '../../types/validation-schema';
  * },
  * ```
  */
-export declare function pastDate<TForm = unknown, TField extends string | Date | undefined = string | Date>(options?: ValidateOptions): Validator<TForm, TField>;
+export declare function pastDate<TForm = unknown, TField extends string | Date | null | undefined = string | Date>(options?: ValidateOptions): Validator<TForm, TField>;

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

@@ -30,4 +30,4 @@ import { Validator, ValidateOptions } from '../../types/validation-schema';
  * },
  * ```
  */
-export declare function pattern<TForm = unknown, TField extends string | undefined = string>(regex: RegExp, options?: ValidateOptions): Validator<TForm, TField>;
+export declare function pattern<TForm = unknown, TField extends string | null | undefined = string>(regex: RegExp, options?: ValidateOptions): Validator<TForm, TField>;