indicator-ui 0.1.46 → 0.1.48

package/dist/scss/ui/formFields/FormFieldWrapper/styles/mixins/index.scss

@@ -0,0 +1 @@
+@forward "inputFieldWrapper";

package/dist/scss/ui/formFields/FormFieldWrapper/styles/mixins/inputFieldWrapper.scss

@@ -0,0 +1,50 @@
+@use '../../../../../styles' as *;
+
+@mixin insertInputFieldWrapper() {
+  .inputFieldWrapper {
+    width: 100%;
+    min-width: 0;
+    display: flex;
+    flex-direction: column;
+    gap: 4px;
+
+    .labelText {
+      display: flex;
+      padding: 0 12px;
+      gap: 2px;
+
+      @include fnt($size: 14, $line-height: 20, $weight: 500, $color: var(--gray-700));
+
+      .required {
+        @include fnt($size: 14, $line-height: 20, $weight: 500, $color: var(--error-500));
+      }
+    }
+
+    .hintText {
+      display: flex;
+      padding: 0 12px;
+      gap: 2px;
+
+      @include fnt($size: 14, $line-height: 20, $weight: 400, $color: var(--gray-600));
+    }
+
+    .hintError {
+      display: flex;
+      padding: 0 12px;
+      gap: 2px;
+
+      @include fnt($size: 14, $line-height: 20, $weight: 400, $color: var(--error-500));
+    }
+
+    .helperLink {
+      display: flex;
+      padding: 0 12px;
+      gap: 2px;
+      cursor: pointer;
+      @include changeSvg($width: 20, $height: 20, $stroke: var(--primary-500), $flex: none);
+      @include fnt($size: 14, $line-height: 20, $weight: 400, $color: var(--primary-500));
+    }
+
+    @content;
+  }
+}

package/dist/types/src/hooks/forms/__tests__/lib/getDataByPath.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/hooks/forms/__tests__/lib/getFormDataPaths.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/hooks/forms/__tests__/lib/setDataByPath.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/hooks/forms/__tests__/lib/utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/hooks/forms/classes/index.d.ts

@@ -0,0 +1,44 @@
+import { FormErrorsType, FormErrorType, FormPath, FormValidateFunItemType, FormValidateFunListType, FormValidateFunType, FormValue, GetFormValidateFunPathType, GetFormValidateFunValueType } from "../types";
+export declare class Form<T> {
+    private data;
+    constructor(data?: T | undefined);
+    getFormData(): T | undefined;
+    setFormData(data: T | undefined): void;
+    get formData(): T | undefined;
+    set formData(data: T | undefined);
+    setField<const P extends FormPath<T>>(chain: P, value: FormValue<T, P> | undefined): void;
+    getField<const P extends FormPath<T>>(chain: P): FormValue<T, P> | undefined;
+    clear(): void;
+}
+export declare class FormError<T> {
+    private formErrors;
+    constructor(errors?: FormErrorsType<T>);
+    getErrors(): FormErrorsType<T>;
+    get errors(): FormErrorsType<T>;
+    setErrors(errors: FormErrorsType<T>): void;
+    addErrors(errors: FormErrorsType<T>): void;
+    set errors(errors: FormErrorsType<T>);
+    getError<const P extends FormPath<T>>(path: P): FormErrorType | undefined;
+    setError<const P extends FormPath<T>>(path: P, error: FormErrorType): void;
+    deleteError<const P extends FormPath<T>>(keyChain: P): void;
+    clear(): void;
+}
+type ValidateResArrayType<T> = FormErrorsType<T>;
+export declare class FormValidateFun<T> {
+    private formValidateFunctions;
+    private form;
+    constructor(form: Form<T>, formValidateFunctions?: FormValidateFunType<T>);
+    setForm(form: Form<T>): void;
+    private getValueForValidate;
+    getFormValidateFunctions(): FormValidateFunType<T>;
+    setFormValidateFunctions(newValue: FormValidateFunType<T>): void;
+    getValidateFunctions<const P extends GetFormValidateFunPathType<T>>(path: P): FormValidateFunListType<GetFormValidateFunValueType<T, P>>;
+    setValidateFunctions<const P extends GetFormValidateFunPathType<T>>(path: P, func: FormValidateFunListType<GetFormValidateFunValueType<T, P>>): void;
+    deleteValidateFunctions<const P extends GetFormValidateFunPathType<T>>(chain: P): void;
+    addValidateFunctions<const P extends GetFormValidateFunPathType<T>>(chain: P, fun: FormValidateFunItemType<GetFormValidateFunValueType<T, P>>): void;
+    validate<const P extends GetFormValidateFunPathType<T>>(path: P): Promise<ValidateResArrayType<T>>;
+    isValid<const P extends GetFormValidateFunPathType<T>>(path: P): Promise<boolean>;
+    validateAllFields(): Promise<ValidateResArrayType<T>>;
+    isFormValid(): Promise<boolean>;
+}
+export {};

package/dist/types/src/hooks/forms/index.d.ts

@@ -0,0 +1,2 @@
+export * from './useForm';
+export * from './types';

package/dist/types/src/hooks/forms/lib/fieldsProps.d.ts

@@ -0,0 +1,11 @@
+import { FieldPropsType, FormPath, FormValue } from '../types';
+import { Form, FormError } from "../classes";
+type PropsType<T, P extends FormPath<T>> = {
+    path: P;
+    form: Form<T>;
+    setField: (path: P, value: FormValue<T, P> | undefined) => void;
+    formErrors: FormError<T>;
+    highlightField: (path: P) => void;
+};
+export declare function getFieldPropsType<T, P extends FormPath<T>>(props: PropsType<T, P>): FieldPropsType<FormValue<T, P>>;
+export {};

package/dist/types/src/hooks/forms/lib/getDataByPath.d.ts

@@ -0,0 +1,4 @@
+import { FormPath, FormValue } from "../types";
+type FunReturnType<T, P extends FormPath<T>> = FormValue<T, P> | undefined;
+export declare function getDataByPath<T, P extends FormPath<T>>(formData: T, path: P): FunReturnType<T, P>;
+export {};

package/dist/types/src/hooks/forms/lib/getFormDataPaths.d.ts

@@ -0,0 +1,5 @@
+import { FormPath } from "../types";
+type PropsType<T> = [formData: T];
+type FunReturnType<T> = FormPath<T>[];
+export declare function getFormDataPaths<T>(...[formData]: PropsType<T>): FunReturnType<T>;
+export {};

package/dist/types/src/hooks/forms/lib/index.d.ts

@@ -0,0 +1,5 @@
+export * from './getDataByPath';
+export * from './setDataByPath';
+export * from './getFormDataPaths';
+export * from './scheme';
+export * from './fieldsProps';

package/dist/types/src/hooks/forms/lib/scheme.d.ts

@@ -0,0 +1,13 @@
+import { FieldConfigType, FormPath, FormSchemeType, GetFormValidateFunPathType, GetProcessArrayFieldValue } from '../types';
+import { Form, FormValidateFun } from '../classes';
+type PropsOptionsType<T> = {
+    form: Form<T>;
+    formValidateFun: FormValidateFun<T>;
+};
+/** Полностью заменяет валидаторы поля */
+export declare function processValidators<T, F>(path: FormPath<T>, config: FieldConfigType<T, F>, options: PropsOptionsType<T>): void;
+/** Полностью заменяет валидаторы полей */
+export declare function processScheme<T>(scheme: FormSchemeType<T>, options: PropsOptionsType<T>): void;
+export declare function getRealPathByArrayItemPath<T, P extends GetFormValidateFunPathType<T>>(path: P): GetProcessArrayFieldValue<T, P> | undefined;
+export declare function getArrayItemPathByRealPath<T, P extends GetFormValidateFunPathType<T>>(path: P): GetProcessArrayFieldValue<T, P> | undefined;
+export {};

package/dist/types/src/hooks/forms/lib/setDataByPath.d.ts

@@ -0,0 +1,5 @@
+import { FormPath, FormValue } from "../types";
+type PropsType<T, P extends FormPath<T>> = [formData: T, keyChain: P, value: FormValue<T, P> | undefined];
+type FunReturnType<T> = T | undefined;
+export declare function setDataByPath<T, const P extends FormPath<T>>(...[formData, path, value]: PropsType<T, P>): FunReturnType<T>;
+export {};

package/dist/types/src/hooks/forms/lib/utils.d.ts

@@ -0,0 +1,9 @@
+export declare function copyData(data: unknown): unknown;
+export declare function getBasePath(path: string): string | null;
+export declare function getBaseRest(path: string): string | null;
+export declare function getArrayIndex(path: string): number | null;
+export declare function getArrayRest(path: string): string | null;
+export declare function getObjectPath(path: string): string | null;
+export declare function getObjectRest(path: string): string | null;
+export declare function isArrayPathValue(path: string): boolean;
+export declare function isObjPathValue(path: string): boolean;

package/dist/types/src/hooks/forms/types/formTypes.d.ts

@@ -0,0 +1,51 @@
+import { BuildTuple, IsAny, IsArray, IsTuple } from '../../../../../types';
+export type ObjectFormType = Record<string, unknown>;
+export type ArrayFormType = any[];
+export type BaseFormType = Exclude<any, ObjectFormType | ArrayFormType>;
+type SafeRecursiveArr = BuildTuple<20>;
+type SafeRecursiveStep<T> = T extends [infer _, ...infer Rest] ? Rest : never;
+type CanContinueRecursive<T> = SafeRecursiveStep<T> extends never ? false : true;
+type IsObjectType<T> = T extends ObjectFormType ? true : false;
+type ClearObjectType<T> = Extract<T, ObjectFormType>;
+type ClearArrayType<T> = Extract<T, ArrayFormType>;
+type GetBaseKeyChains<P extends string, T, SafeArr> = CanContinueRecursive<SafeArr> extends false ? never : IsAny<T> extends false ? P | `${P}${GetDeepKeyChains<T, SafeRecursiveStep<SafeArr>> | GetArrayKeyChains<T, SafeRecursiveStep<SafeArr>>}` : P | `${P}${'.' | '['}${string}`;
+type GetArrayKeyChains<T, SafeArr> = CanContinueRecursive<SafeArr> extends false ? never : IsArray<T> extends false ? never : ClearArrayType<T> extends infer Arr ? IsTuple<Arr> extends true ? {
+    [K in Extract<keyof Arr, `${number}`>]: GetBaseKeyChains<`[${K}]`, Arr[K], SafeRecursiveStep<SafeArr>>;
+}[Extract<keyof Arr, `${number}`>] : Arr extends any[] ? `[${number}]` | GetBaseKeyChains<`[${number}]`, Arr[number], SafeRecursiveStep<SafeArr>> : never : never;
+type GetDeepKeyChains<T, SafeArr> = CanContinueRecursive<SafeArr> extends false ? never : IsObjectType<T> extends false ? never : ClearObjectType<T> extends infer Form ? {
+    [K in Extract<keyof Form, string>]: GetBaseKeyChains<`.${K}`, Form[K], SafeRecursiveStep<SafeArr>>;
+}[Extract<keyof Form, string>] : never;
+export type FormPath<T> = '' | (IsObjectType<T> extends false ? GetArrayKeyChains<T, SafeRecursiveArr> : ClearObjectType<T> extends infer Form ? {
+    [K in Extract<keyof Form, string>]: GetBaseKeyChains<`${K}`, Form[K], SafeRecursiveArr>;
+}[Extract<keyof Form, string>] : never);
+type HeadPart<S extends string, Acc extends string = ''> = S extends `${infer C}${infer Rest}` ? C extends '.' | '[' ? Acc : HeadPart<Rest, `${Acc}${C}`> : Acc;
+type GetPath<P> = P extends string ? HeadPart<P> : never;
+type GetArrayIndex<P> = P extends `[${`${infer NumIndex extends number}`}]${string}` ? NumIndex : never;
+type GetArrayRest<P> = P extends `[${GetArrayIndex<P>}]${infer Path}` ? Path : never;
+type GetDeepPath<P> = P extends `.${infer Rest}` ? GetPath<Rest> : never;
+type GetDeepRest<P> = P extends `.${GetDeepPath<P>}${infer Rest}` ? Rest : never;
+type GetBaseValue<T, P extends string, SafeArr> = CanContinueRecursive<SafeArr> extends false ? never : P extends '' ? T : P extends `.${string}` ? GetDeepValue<T, P, SafeRecursiveStep<SafeArr>> : P extends `[${string}` ? GetArrayValue<T, P, SafeRecursiveStep<SafeArr>> : never;
+type GetDeepValue<T, P, SafeArr> = CanContinueRecursive<SafeArr> extends false ? never : ClearObjectType<T> extends infer Form ? GetDeepPath<P> extends infer Path extends keyof Form ? GetBaseValue<Form[Path], GetDeepRest<P>, SafeRecursiveStep<SafeArr>> : never : never;
+type GetArrayValue<T, P, SafeArr> = CanContinueRecursive<SafeArr> extends false ? never : ClearArrayType<T> extends infer Form ? GetArrayIndex<P> extends infer Index extends keyof Form ? GetBaseValue<Form[Index], GetArrayRest<P>, SafeRecursiveStep<SafeArr>> : never : never;
+export type FormValue<T, P extends FormPath<T>> = IsAny<T> extends false ? T extends ObjectFormType ? P extends '' ? GetBaseValue<T, P, SafeRecursiveArr> : GetBaseValue<T, `.${P}`, SafeRecursiveArr> : GetBaseValue<T, P, SafeRecursiveArr> : any;
+export type FormErrorType = boolean | string;
+export type FormErrorsType<T> = Array<{
+    [K in FormPath<T>]: {
+        path: K;
+        error: FormErrorType;
+    };
+}[FormPath<T>]>;
+type GetOnlyArrayField<P> = P extends string ? Extract<P, `${string}]`> : never;
+export type ProcessArrayFields<P> = GetOnlyArrayField<P> extends infer T extends string ? T extends `${infer B}[${number}]` ? `${B}[*]` : never : never;
+export type GetProcessArrayFieldValue<T, P> = P extends `${infer Rest}[*]` ? Rest extends FormPath<T> ? FormValue<T, Rest> extends infer Arr extends any[] ? Arr[number] : never : never : never;
+export type GetFormValidateFunPathType<T> = FormPath<T> | ProcessArrayFields<FormPath<T>>;
+export type GetFormValidateFunValueType<T, P> = GetProcessArrayFieldValue<T, P> | (P extends FormPath<T> ? FormValue<T, P> : never);
+export type FormValidateFunItemType<T> = (value: T | undefined) => Promise<FormErrorType> | FormErrorType;
+export type FormValidateFunListType<T> = Array<FormValidateFunItemType<T>>;
+export type FormValidateFunType<T> = Array<{
+    [K in GetFormValidateFunPathType<T>]: {
+        path: K;
+        fun: FormValidateFunListType<GetFormValidateFunValueType<T, K>>;
+    };
+}[GetFormValidateFunPathType<T>]>;
+export {};

package/dist/types/src/hooks/forms/types/index.d.ts

@@ -1,3 +1,2 @@
-type FormsType = {
-    [key: string]: FormsType | unknown;
-};
+export * from './formTypes';
+export * from './scheme';

package/dist/types/src/hooks/forms/types/scheme.d.ts

@@ -0,0 +1,151 @@
+import { FormErrorType, FormPath, FormValidateFunItemType, GetFormValidateFunPathType, GetFormValidateFunValueType } from './formTypes';
+export type StringFieldValidators = Partial<{
+    /** Минимальная длина строки */
+    minStr: number;
+    /** Максимальная длина строки */
+    maxStr: number;
+    /** Регулярное выражение или функция для проверки строки */
+    pattern: RegExp | ((value: string) => boolean);
+    /** Разрешить пустую строку (""), игнорируя другие проверки */
+    allowEmpty: boolean;
+    /** Требование к регистру: верхний, нижний или любой */
+    case: 'upper' | 'lower' | 'any';
+    /** Запрет на пробелы в строке */
+    noSpace: boolean;
+    /** Разрешённые символы (строка, все остальные запрещены) */
+    allowedChars: string;
+    /** Запрещённые символы (строка, все остальные разрешены) */
+    disallowedChars: string;
+}>;
+export type DateTimeFieldValidators = Partial<{
+    /** Минимальная дата/время, значение должно быть больше или равно */
+    minDate: string | number | Date;
+    /** Максимальная дата/время, значение должно быть меньше или равно */
+    maxDate: string | number | Date;
+    /** Максимальное время (часы и минуты), значение должно быть меньше или равно */
+    maxTime: string | number | Date;
+    /** Минимальное время (часы и минуты), значение должно быть больше или равно */
+    minTime: string | number | Date;
+    /** Разрешены только даты из прошлого (не позже, чем минута назад от текущего момента) */
+    past: boolean;
+    /** Разрешены только даты из будущего (не раньше, чем через минуту от текущего момента) */
+    future: boolean;
+    /** Разрешены только даты сегодняшнего дня */
+    today: boolean;
+}>;
+export type NumberFieldValidators = Partial<{
+    /** Минимальное значение числа (включительно) */
+    minNum: number;
+    /** Максимальное значение числа (включительно) */
+    maxNum: number;
+    /** Числовое значение должно быть целым числом */
+    integer: boolean;
+    /** Числовое значение должно быть положительным (> 0) */
+    positive: boolean;
+    /** Числовое значение должно быть отрицательным (< 0) */
+    negative: boolean;
+    /** Числовое значение должно находиться в указанном диапазоне [min, max] */
+    range: [number, number];
+}>;
+export type FileFieldValidators = Partial<{
+    /** Минимальный размер файла в байтах (включительно) */
+    minFileSize: number;
+    /** Максимальный размер файла в байтах (включительно) */
+    maxFileSize: number;
+    /** Разрешённые MIME-типы файлов (например, ['image/png', 'image/jpeg']) */
+    allowedFileTypes: string[];
+}>;
+export type ArrayFieldValidators = Partial<{
+    /** Максимальное количество элементов в массиве */
+    maxItemCount: number;
+}>;
+export type BaseFieldValidators<T, F> = Partial<{
+    /** Поле обязательное */
+    required: ValidatorOption<boolean>;
+    /** Равенство другому полю */
+    equalsTo: ValidatorOption<FormPath<T>>;
+    /** Собственная функция валидации */
+    custom: FormValidateFunItemType<F> | {
+        fun: FormValidateFunItemType<F>;
+        priory?: number;
+    };
+}>;
+export type ExtendsValidatorOptions<T> = {
+    /** Значение валидотора */
+    setting: T;
+    /** Сообщение при ошибке */
+    message?: string;
+    /**
+     * Какой приоритете у проверки (чем выше, тем раньше произойдет проверка этим валидатором)
+     *
+     * По-умолчанию у всех `0`.
+     * */
+    priory?: number;
+};
+export type ValidatorOption<T> = T | ExtendsValidatorOptions<T>;
+type ProcessValidator<T> = T extends Record<string, unknown> ? {
+    [K in keyof T]: T[K] | ValidatorOption<T[K]>;
+} : never;
+type GetValidatorValue<V> = V extends ExtendsValidatorOptions<infer T> ? T : never;
+export type FieldConfigType<T, F> = BaseFieldValidators<T, F> & ProcessValidator<ArrayFieldValidators> & ProcessValidator<FileFieldValidators> & ProcessValidator<StringFieldValidators> & ProcessValidator<DateTimeFieldValidators> & ProcessValidator<NumberFieldValidators>;
+/**
+ * Тип схемы валидации формы.
+ *
+ * Каждый ключ соответствует пути к полю формы (`FormPath`) и описывает правила валидации для этого поля.
+ * Используется внутри хука {@link useForm} для автоматической проверки значений и управления ошибками.
+ *
+ * Пример использования:
+ * ```ts
+ * const scheme: FormSchemeType<TestFormType> = {
+ *   baseInput: {
+ *     minStr: { setting: 3, message: 'Минимум 3 символа' },
+ *     maxStr: 10,
+ *     required: { setting: true, message: 'Обязательное поле' },
+ *   },
+ *   textarea: {
+ *     custom: (value) => value?.includes('_') ? 'Символ _ запрещен' : false,
+ *     noSpace: true,
+ *   },
+ *   'selects.select': {
+ *     required: true
+ *   }
+ * };
+ * ```
+ *
+ * ---
+ * ### ⚙️ Поддерживаемые типы полей и валидаторы:
+ *
+ * | Тип данных | Валидаторы |
+ * |------------|------------|
+ * | Строка | {@link StringFieldValidators} |
+ * | Число | {@link NumberFieldValidators} |
+ * | Дата / Время | {@link DateTimeFieldValidators} |
+ * | Массив | {@link ArrayFieldValidators} |
+ * | Файл | {@link FileFieldValidators} |
+ * | Общие для всех полей | {@link BaseFieldValidators} (`required`, `equalsTo`, `custom`) |
+ *
+ * ---
+ * ### ⚙️ Настройки валидаторов:
+ *
+ * Каждый валидатор можно задать напрямую либо через обертку конфигурации:
+ * - {@link ValidatorOption} — либо значение валидатора, либо объект с настройкой и сообщением;
+ * - {@link ExtendsValidatorOptions} — расширенная конфигурация валидатора с полями `setting`, `message` и `priory`.
+ *
+ * Валидаторы с приоритетом `priory` выполняются раньше остальных.
+ *
+ * @template T — тип данных формы (например, интерфейс или тип объекта формы).
+ */
+export type FormSchemeType<T> = Partial<T> extends infer Form ? {
+    [K in GetFormValidateFunPathType<Form>]?: FieldConfigType<Form, GetFormValidateFunValueType<Form, K>>;
+} : never;
+export type FieldPropsType<V> = {
+    value?: V;
+    onChange?: (value?: V) => void;
+    error?: FormErrorType;
+    onBlur?: () => void;
+};
+export type AllValidatorsType = ArrayFieldValidators & FileFieldValidators & StringFieldValidators & DateTimeFieldValidators & NumberFieldValidators;
+export type ValidatorsConfigType = {
+    [K in keyof AllValidatorsType]: (value: any, setting: GetValidatorValue<AllValidatorsType[K]>) => boolean;
+};
+export {};

package/dist/types/src/hooks/forms/useForm.d.ts

@@ -0,0 +1,212 @@
+import { FieldPropsType, FormErrorsType, FormErrorType, GetFormValidateFunPathType } from "../../hooks";
+import { FormPath, FormSchemeType, FormValue } from "./types";
+type PropsType<T> = [{
+    initFormData?: T;
+    scheme?: FormSchemeType<T>;
+}];
+/**
+ * Хук `useForm` — универсальное решение для управления и валидации форм с полной статической типизацией.
+ *
+ * При указании generic-типа `Form` (например, `useForm<MyFormType>()`) вы получаете:
+ * - строгую типизацию всех полей формы;
+ * - контроль значений, ошибок и валидации;
+ * - удобную интеграцию с готовыми компонентами (`FormField`, `FormSelectField`, `FormRadioField`, `FormSwitcherField`, `FormTextareaField`);
+ * - возможность легко использовать собственные поля.
+ *
+ * ---
+ * ### 💡 Основная идея
+ * Все поля формы управляются внутри хука.
+ * Для внешнего контроля состояния формы и ошибок можно использовать `setFormData` и `setError`.
+ *
+ * При регистрации поля через `register`:
+ * - создаются функции валидации;
+ * - возвращаются пропсы (`FieldPropsType`), которые можно напрямую передавать в компонент поля.
+ *
+ * ---
+ * ### ✅ Способы задания валидации
+ *
+ * **1. Через `register`:**
+ * ```tsx
+ * <FormField
+ *   {...register('baseInput', { required: { setting: true, message: 'Обязательное поле' } })}
+ *   label="Base input"
+ *   hint="Обычная строка"
+ * />
+ * ```
+ *
+ * **2. Через схему `scheme`:**
+ * ```ts
+ * const scheme: FormSchemeType<TestFormType> = {
+ *   baseInput: {
+ *     minStr: { setting: 3, message: 'Минимум 3 символа' },
+ *     maxStr: 10,
+ *   },
+ *   textarea: {
+ *     custom: (value) =>
+ *       value?.includes('_') ? 'В тексте есть запрещенный символ' : false,
+ *     noSpace: true,
+ *   },
+ *   'selects.select': {
+ *     required: { setting: true, message: 'Поле обязательное' },
+ *   },
+ * };
+ * ```
+ *
+ * Для более подробного ознакомления с полями схемы можно ознакомиться с типом {@link FormSchemeType}.
+ *
+ * ---
+ * ### 🧩 Пример использования
+ * ```tsx
+ * type TestFormType = {
+ *   baseInput: string;
+ *   textarea: string;
+ *   selects: {
+ *     select: number;
+ *     selectMulti: number[];
+ *   };
+ *   addition: [
+ *     { switcher: boolean },
+ *     { radio: { multi: string[]; default: string } },
+ *   ];
+ * };
+ *
+ * export function FormPage() {
+ *   const { register, formData, errors, isFormValid } = useForm<TestFormType>({ scheme });
+ *
+ *   return (
+ *     <div>
+ *       <FormField
+ *         {...register('baseInput', { required: { setting: true, message: 'Обязательное поле' } })}
+ *         label="base input"
+ *         hint="Обычная строка"
+ *       />
+ *
+ *       <FormTextareaField {...register('textarea')} />
+ *
+ *       <FormSwitcherField {...register('addition[0].switcher')} />
+ *
+ *       <FormRadioField {...register('addition[1].radio.default')} options={radioOptions} />
+ *       <FormRadioField {...register('addition[1].radio.multi')} options={radioOptions} multiple />
+ *
+ *       <FormSelectField
+ *         {...register('selects.select')}
+ *         options={selectOptions}
+ *         label="selects.select"
+ *         required
+ *         hint="Select с выбором только одного элемента"
+ *       />
+ *
+ *       <FormSelectField
+ *         {...register('selects.selectMulti')}
+ *         multiple
+ *         required
+ *         options={selectOptions}
+ *         label="selects.selectMulti"
+ *         hint="Select с выбором нескольких элементов"
+ *       />
+ *
+ *       <button disabled={!isFormValid()}>Отправить</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * ---
+ * ### ⚙️ Основные методы и значения
+ *
+ * | Переменная / метод | Тип | Назначение |
+ * |---------------------|------|-------------|
+ * | `formData` | `T` | Текущее состояние формы (реактивное) |
+ * | `setFormData(data)` | `(data: T) => void` | Полностью заменяет состояние формы |
+ * | `getFormData()` | `() => T` | Возвращает актуальные данные формы |
+ * | `errors` | `FormErrorsType<T>` | Объект всех ошибок формы |
+ * | `setErrors(errors)` | `(errors: FormErrorsType<T>) => void` | Полностью заменяет состояние ошибок |
+ * | `getField(path)` | `(path) => value` | Возвращает текущее значение поля |
+ * | `setField(path, value)` | `(path, value) => void` | Устанавливает значение поля |
+ * | `getError(path)` | `(path) => FormErrorType` | Возвращает ошибку конкретного поля |
+ * | `setError(path, error)` | `(path, error) => void` | Устанавливает ошибку вручную |
+ * | `highlightField(path)` | `(path) => Promise<void>` | Проверяет конкретное поле и обновляет `errors` |
+ * | `highlightFormErrors()` | `() => Promise<void>` | Проверяет всю форму и обновляет `errors` |
+ * | `isFieldValid(path)` | `(path) => boolean` | Проверяет валидность поля (без обновления `errors`) |
+ * | `isFormValid()` | `() => boolean` | Проверяет, валидна ли вся форма (без обновления `errors`) |
+ * | `clearForm()` | `() => void` | Сбрасывает все значения формы |
+ * | `clearErrors()` | `() => void` | Очищает все ошибки |
+ * | `register(path, config?)` | `(path, config?) => FieldPropsType` | Регистрирует поле и возвращает пропсы для компонента |
+ *
+ * ---
+ * @template Form — объект, описывающий форму.
+ * @template T — частичный тип формы (используется для инициализации, по умолчанию `Partial<Form>`).
+ *
+ * @param {Object} [params]
+ * @param {T} [params.initFormData] — начальные данные формы.
+ * @param {FormSchemeType<T>} [params.scheme] — схема валидации формы.
+ *
+ * @returns {{
+ *   /** Текущее состояние формы (реактивное) *\/
+ *   formData: T;
+ *
+ *   /** Установка полного состояния формы *\/
+ *   setFormData: (data: T) => void;
+ *
+ *   /** Получение текущего состояния формы *\/
+ *   getFormData: () => T;
+ *
+ *   /** Все ошибки формы *\/
+ *   errors: FormErrorsType<T>;
+ *
+ *   /** Замена всех ошибок формы *\/
+ *   setErrors: (errors: FormErrorsType<T>) => void;
+ *
+ *   /** Получение значения поля *\/
+ *   getField: <P extends FormPath<T>>(path: P) => FormValue<T, P>;
+ *
+ *   /** Установка значения поля *\/
+ *   setField: <P extends FormPath<T>>(path: P, value: FormValue<T, P> | undefined) => void;
+ *
+ *   /** Получение ошибки конкретного поля *\/
+ *   getError: <P extends FormPath<T>>(path: P) => FormErrorType;
+ *
+ *   /** Установка ошибки поля вручную *\/
+ *   setError: <P extends FormPath<T>>(path: P, error: FormErrorType) => void;
+ *
+ *   /** Проверка конкретного поля с обновлением `errors` *\/
+ *   highlightField: <P extends GetFormValidateFunPathType<T>>(path: P) => Promise<void>;
+ *
+ *   /** Проверка всех полей формы с обновлением `errors` *\/
+ *   highlightFormErrors: () => Promise<void>;
+ *
+ *   /** Проверка валидности конкретного поля (без обновления `errors`) *\/
+ *   isFieldValid: <P extends GetFormValidateFunPathType<T>>(path: P) => boolean;
+ *
+ *   /** Проверка валидности всей формы (без обновления `errors`) *\/
+ *   isFormValid: () => boolean;
+ *
+ *   /** Сброс всех значений формы *\/
+ *   clearForm: () => void;
+ *
+ *   /** Очистка всех ошибок *\/
+ *   clearErrors: () => void;
+ *
+ *   /** Регистрация поля с привязкой валидации и значений *\/
+ *   register: <P extends FormPath<T>>(path: P, config?: FormSchemeType<T>[P]) => FieldPropsType<FormValue<T, P>>;
+ * }}
+ */
+export declare function useForm<Form, T extends Partial<Form> = Partial<Form>>(...args: PropsType<T>): {
+    formData: T | undefined;
+    setFormData: (formData: T) => void;
+    getFormData: () => T | undefined;
+    errors: FormErrorsType<T>;
+    setErrors: (errors: FormErrorsType<T>) => void;
+    getField: <P extends FormPath<T>>(path: P) => FormValue<T, P> | undefined;
+    setField: <P extends FormPath<T>>(path: P, value: FormValue<T, P> | undefined) => void;
+    getError: <P extends FormPath<T>>(path: P) => FormErrorType | undefined;
+    setError: <P extends FormPath<T>>(path: P, error: FormErrorType) => void;
+    highlightField: <P extends GetFormValidateFunPathType<T>>(path: P) => Promise<void>;
+    highlightFormErrors: () => Promise<void>;
+    isFieldValid: <P extends GetFormValidateFunPathType<T>>(path: P) => Promise<boolean>;
+    isFormValid: () => Promise<boolean>;
+    clearForm: () => void;
+    clearErrors: () => void;
+    register: <P extends FormPath<T>>(path: P, config?: FormSchemeType<T>[P]) => FieldPropsType<FormValue<T, P>>;
+};
+export {};

package/dist/types/src/hooks/forms/validateFunctions/config.d.ts

@@ -0,0 +1,2 @@
+import { ValidatorsConfigType } from "../types";
+export declare const ValidatorsConfig: ValidatorsConfigType;

package/dist/types/src/hooks/forms/validateFunctions/index.d.ts

@@ -0,0 +1,8 @@
+export * from './validateRequired';
+export * from './validateEqualsTo';
+export * from './validateArray';
+export * from './validateDateTime';
+export * from './validateNum';
+export * from './validateFile';
+export * from './validateStr';
+export * from './config';

package/dist/types/src/hooks/forms/validateFunctions/validateArray.d.ts

@@ -0,0 +1 @@
+export declare function validateArrayMaxCount(value: unknown, maxCount: number): boolean;

package/dist/types/src/hooks/forms/validateFunctions/validateDateTime.d.ts

@@ -0,0 +1,7 @@
+export declare function validateDateTimeMinDate(value: unknown, min: string | number | Date): boolean;
+export declare function validateDateTimeMaxDate(value: unknown, max: string | number | Date): boolean;
+export declare function validateDateTimeMinTime(value: unknown, min: string | number | Date): boolean;
+export declare function validateDateTimeMaxTime(value: unknown, max: string | number | Date): boolean;
+export declare function validateDateTimePast(value: unknown): boolean;
+export declare function validateDateTimeFuture(value: unknown): boolean;
+export declare function validateDateTimeToday(value: unknown): boolean;

package/dist/types/src/hooks/forms/validateFunctions/validateEqualsTo.d.ts

@@ -0,0 +1 @@
+export declare function validateEqualsTo<T>(currentValue: T, getExpectedValue: () => T): boolean;

package/dist/types/src/hooks/forms/validateFunctions/validateFile.d.ts

@@ -0,0 +1,3 @@
+export declare function validateFileMinSize(file: unknown, minSize: number): boolean;
+export declare function validateFileMaxSize(file: unknown, maxSize: number): boolean;
+export declare function validateFileAllowedTypes(file: unknown, allowedTypes: string[]): boolean;

package/dist/types/src/hooks/forms/validateFunctions/validateNum.d.ts

@@ -0,0 +1,6 @@
+export declare function validateNumMin(value: unknown, min: number): boolean;
+export declare function validateNumMax(value: unknown, max: number): boolean;
+export declare function validateNumInteger(value: unknown): boolean;
+export declare function validateNumPositive(value: unknown): boolean;
+export declare function validateNumNegative(value: unknown): boolean;
+export declare function validateNumRange(value: unknown, range: [number, number]): boolean;