@reformer/core 1.0.0-beta.1

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

@@ -0,0 +1,38 @@
+import { ValidateOptions } from '../../types/validation-schema';
+import { FieldPathNode } from '../../types';
+/**
+ * Валидатор минимальной длины строки
+ *
+ * Проверяет, что длина строки не меньше указанного минимума.
+ * Пустые значения пропускаются (используйте `required` для обязательности).
+ *
+ * @group Validation
+ * @category Validators
+ *
+ * @param fieldPath - Путь к полю для валидации
+ * @param minLen - Минимальная допустимая длина строки
+ * @param options - Опции валидации (message, params)
+ *
+ * @example
+ * ```typescript
+ * // Базовое использование
+ * validationSchema: (path) => [
+ *   minLength(path.name, 2),
+ *   minLength(path.password, 8),
+ * ]
+ *
+ * // С кастомным сообщением
+ * minLength(path.password, 8, { message: 'Пароль должен быть не менее 8 символов' })
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Ошибка валидации
+ * {
+ *   code: 'minLength',
+ *   message: 'Минимальная длина: 8 символов',
+ *   params: { minLength: 8, actualLength: 3 }
+ * }
+ * ```
+ */
+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

@@ -0,0 +1,38 @@
+import { ValidateOptions } from '../../types/validation-schema';
+import { FieldPathNode } from '../../types';
+/**
+ * Валидатор минимального числового значения
+ *
+ * Проверяет, что числовое значение не меньше указанного минимума.
+ * Пустые значения пропускаются (используйте `required` для обязательности).
+ *
+ * @group Validation
+ * @category Validators
+ *
+ * @param fieldPath - Путь к полю для валидации
+ * @param minValue - Минимально допустимое значение
+ * @param options - Опции валидации (message, params)
+ *
+ * @example
+ * ```typescript
+ * // Базовое использование
+ * validationSchema: (path) => [
+ *   min(path.age, 18),
+ *   min(path.quantity, 1),
+ * ]
+ *
+ * // С кастомным сообщением
+ * min(path.age, 18, { message: 'Вам должно быть не менее 18 лет' })
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Ошибка валидации
+ * {
+ *   code: 'min',
+ *   message: 'Минимальное значение: 18',
+ *   params: { min: 18, actual: 16 }
+ * }
+ * ```
+ */
+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

@@ -0,0 +1,31 @@
+import { ValidateOptions } from '../../types/validation-schema';
+import { FieldPathNode } from '../../types';
+/**
+ * Адаптер для number валидатора
+ * Проверяет, что значение является числом и соответствует заданным ограничениям
+ *
+ * @group Validation
+ * @category Validators
+ *
+ * @example
+ * ```typescript
+ * number(path.age);
+ * number(path.price, { min: 0, max: 1000000 });
+ * number(path.percentage, { min: 0, max: 100, integer: true });
+ * number(path.rating, { min: 0, max: 5, multipleOf: 0.5 });
+ * ```
+ */
+export declare function number<TForm, TField extends number | undefined = number>(fieldPath: FieldPathNode<TForm, TField> | undefined, options?: ValidateOptions & {
+    /** Минимальное значение (включительно) */
+    min?: number;
+    /** Максимальное значение (включительно) */
+    max?: number;
+    /** Требовать целое число */
+    integer?: boolean;
+    /** Значение должно быть кратно этому числу */
+    multipleOf?: number;
+    /** Разрешить отрицательные числа (по умолчанию true) */
+    allowNegative?: boolean;
+    /** Разрешить ноль (по умолчанию true) */
+    allowZero?: boolean;
+}): void;

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

@@ -0,0 +1,40 @@
+import { ValidateOptions } from '../../types/validation-schema';
+import { FieldPathNode } from '../../types';
+/**
+ * Валидатор паттерна (регулярного выражения)
+ *
+ * Проверяет, что значение соответствует указанному регулярному выражению.
+ * Пустые значения пропускаются (используйте `required` для обязательности).
+ *
+ * @group Validation
+ * @category Validators
+ *
+ * @param fieldPath - Путь к полю для валидации
+ * @param regex - Регулярное выражение для проверки
+ * @param options - Опции валидации (message, params)
+ *
+ * @example
+ * ```typescript
+ * // Только буквы
+ * pattern(path.name, /^[а-яА-Яa-zA-Z]+$/)
+ *
+ * // Только цифры
+ * pattern(path.code, /^\d+$/)
+ *
+ * // С кастомным сообщением
+ * pattern(path.username, /^[a-z0-9_]+$/i, {
+ *   message: 'Только латинские буквы, цифры и подчёркивание'
+ * })
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Ошибка валидации
+ * {
+ *   code: 'pattern',
+ *   message: 'Значение не соответствует требуемому формату',
+ *   params: { pattern: '^[a-z]+$' }
+ * }
+ * ```
+ */
+export declare function pattern<TForm, TField extends string | null | undefined = string>(fieldPath: FieldPathNode<TForm, TField> | undefined, regex: RegExp, options?: ValidateOptions): void;

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

@@ -0,0 +1,27 @@
+import { ValidateOptions } from '../../types/validation-schema';
+import { FieldPathNode } from '../../types';
+/**
+ * Формат телефона для валидации
+ *
+ * @group Validation
+ * @category Validators
+ */
+export type PhoneFormat = 'international' | 'ru' | 'us' | 'any';
+/**
+ * Адаптер для phone валидатора
+ * Поддерживает опциональные поля (string | undefined)
+ *
+ * @group Validation
+ * @category Validators
+ *
+ * @example
+ * ```typescript
+ * phone(path.phoneNumber);
+ * phone(path.phoneNumber, { format: 'ru' });
+ * phone(path.phoneNumber, { format: 'international', message: 'Неверный формат телефона' });
+ * ```
+ */
+export declare function phone<TForm, TField extends string | null | undefined = string>(fieldPath: FieldPathNode<TForm, TField> | undefined, options?: ValidateOptions & {
+    /** Формат телефона */
+    format?: PhoneFormat;
+}): void;

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

@@ -0,0 +1,41 @@
+import { ValidateOptions } from '../../types/validation-schema';
+import { FieldPathNode } from '../../types';
+/**
+ * Валидатор обязательного поля
+ *
+ * Проверяет, что поле имеет непустое значение.
+ * Пустыми считаются: `null`, `undefined`, `''` (пустая строка).
+ * Для boolean полей требуется значение `true`.
+ *
+ * @group Validation
+ * @category Validators
+ *
+ * @param fieldPath - Путь к полю для валидации
+ * @param options - Опции валидации (message, params)
+ *
+ * @example
+ * ```typescript
+ * // Базовое использование
+ * validationSchema: (path, { validate }) => [
+ *   required(path.name),
+ *   required(path.email),
+ * ]
+ *
+ * // С кастомным сообщением
+ * required(path.phone, { message: 'Укажите номер телефона' })
+ *
+ * // Для checkbox (требует true)
+ * required(path.agreeToTerms, { message: 'Необходимо принять условия' })
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Ошибка валидации
+ * {
+ *   code: 'required',
+ *   message: 'Поле обязательно для заполнения',
+ *   params: {}
+ * }
+ * ```
+ */
+export declare function required<TForm, TField>(fieldPath: FieldPathNode<TForm, TField> | undefined, options?: ValidateOptions): void;

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

@@ -0,0 +1,22 @@
+import { ValidateOptions } from '../../types/validation-schema';
+import { FieldPathNode } from '../../types';
+/**
+ * Адаптер для URL валидатора
+ * Поддерживает опциональные поля (string | undefined)
+ *
+ * @group Validation
+ * @category Validators
+ *
+ * @example
+ * ```typescript
+ * url(path.website);
+ * url(path.website, { message: 'Введите корректный URL' });
+ * url(path.website, { requireProtocol: true });
+ * ```
+ */
+export declare function url<TForm, TField extends string | null | undefined = string>(fieldPath: FieldPathNode<TForm, TField> | undefined, options?: ValidateOptions & {
+    /** Требовать наличие протокола (http:// или https://) */
+    requireProtocol?: boolean;
+    /** Разрешенные протоколы */
+    allowedProtocols?: string[];
+}): void;

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
+};