indicator-ui 1.1.21 → 1.1.23

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

@@ -2,7 +2,7 @@ import { ExtendFormPath, ExtendFormValue, FormErrorsType, FormErrorType, FormPat
 export declare class Form<T> {
     private data;
     private defaultValues;
-    constructor(data?: T | undefined);
+    constructor(data?: T | Form<T>);
     getFormData: () => T | undefined;
     setFormData: (data: T | undefined) => void;
     get formData(): T | undefined;

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

@@ -1,27 +1,27 @@
 import { ExtendFormPath, FormErrorsType, FormErrorType, FormPath, FormValue, UseFormServices } from '../types';
 import { Form } from '../classes';
 import { Nullable, Undefinable } from '../../../types';
-export declare function createFormServices<F, T = Nullable<Undefinable<F>>>(deps: {
+export declare function createFormServices<T, F = Nullable<Undefinable<T>>>(deps: {
     /** Form */
-    getForm: () => Form<T>;
-    setFormData: (data: T) => void;
-    getValidForm: () => Promise<F | null>;
+    getForm: () => Form<F>;
+    setFormData: (data: F) => void;
+    getValidForm: () => Promise<T | null>;
     /** Fields */
-    getField: <P extends FormPath<T>>(path: P) => FormValue<T, P> | null | undefined;
-    getFieldSync: <P extends FormPath<T>>(path: P) => FormValue<T, P> | undefined;
-    setField: <P extends FormPath<T>>(path: P, value: FormValue<T, P> | undefined) => void;
-    clearField: (path: FormPath<T> | FormPath<T>[]) => void;
+    getField: <P extends FormPath<F>>(path: P) => FormValue<F, P> | null | undefined;
+    getFieldSync: <P extends FormPath<F>>(path: P) => FormValue<F, P> | undefined;
+    setField: <P extends FormPath<F>>(path: P, value: FormValue<F, P> | undefined) => void;
+    clearField: (path: FormPath<F> | FormPath<F>[]) => void;
     /** Errors */
-    getError: <P extends FormPath<T>>(path: P) => FormErrorType | undefined;
-    setError: <P extends FormPath<T>>(path: P, error: FormErrorType) => void;
-    setErrors: (errors: FormErrorsType<T>) => void;
+    getError: <P extends FormPath<F>>(path: P) => FormErrorType | undefined;
+    setError: <P extends FormPath<F>>(path: P, error: FormErrorType) => void;
+    setErrors: (errors: FormErrorsType<F>) => void;
     clearErrors: () => void;
     /** Validation */
-    isFieldValid: <P extends ExtendFormPath<T>>(path: P) => Promise<boolean>;
-    areFieldsValid: (paths: ExtendFormPath<T>[]) => Promise<boolean>;
+    isFieldValid: <P extends ExtendFormPath<F>>(path: P) => Promise<boolean>;
+    areFieldsValid: (paths: ExtendFormPath<F>[]) => Promise<boolean>;
     isFormValid: () => Promise<boolean>;
     /** Highlight (side-effect validation) */
-    highlightField: <P extends ExtendFormPath<T>>(path: P) => Promise<boolean>;
-    highlightFields: (paths: ExtendFormPath<T>[]) => Promise<boolean>;
+    highlightField: <P extends ExtendFormPath<F>>(path: P) => Promise<boolean>;
+    highlightFields: (paths: ExtendFormPath<F>[]) => Promise<boolean>;
     highlightFormErrors: () => Promise<boolean>;
-}): UseFormServices<F, T>;
+}): UseFormServices<T, F>;

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

@@ -1,6 +1,7 @@
 import { FocusEvent, SetStateAction } from 'react';
 import { Nullable, Undefinable } from '../../../types';
 import { ExtendFormPath, ExtendFormValue, FormErrorType, FormPath, FormValue } from './formTypes';
+import { UseFormServices } from '../..';
 export type StringFieldValidators = Partial<{
     /** Минимальная длина строки */
     minStr: number;
@@ -152,6 +153,10 @@ export type FieldConfigType<T, F> = DefaultValueConfig<T, F> & BaseFieldValidato
 export type FormSchemeType<T> = Nullable<Undefinable<T>> extends infer Form ? {
     [K in ExtendFormPath<Form>]?: FieldConfigType<Form, ExtendFormValue<Form, K>>;
 } : never;
+type WatcherCallback<T, P extends FormPath<T>, F = Nullable<Undefinable<T>>> = (value: FormValue<F, P>, services: UseFormServices<T>) => any;
+export type FormWatchType<T> = {
+    [K in FormPath<T>]?: WatcherCallback<T, K>;
+};
 export type FieldChangeMode = 'change' | 'update';
 export type FieldOnChange<V, M extends FieldChangeMode> = M extends 'change' ? (action?: V | null) => void : (action: SetStateAction<V | undefined | null>) => void;
 export type FieldPropsType<V, M extends FieldChangeMode = 'change'> = {

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

@@ -1,52 +1,52 @@
 import { ExtendFormPath, FormErrorsType, FormErrorType, FormPath, FormValue } from './formTypes';
 import { Form } from '../classes';
 import { Nullable, Undefinable } from '../../../types';
-export type UseFormServices<F, T = Nullable<Undefinable<F>>> = {
+export type UseFormServices<T, F = Nullable<Undefinable<T>>> = {
     /** Работа с данными формы */
     form: {
         /** Получить актуальные данные формы */
-        getData: () => Form<T>;
+        getData: () => Form<F>;
         /** Полностью заменить данные формы */
-        setData: (data: T) => void;
-        getValidData: () => Promise<F | null>;
+        setData: (data: F) => void;
+        getValidData: () => Promise<T | null>;
     };
     /** Работа с полями */
     fields: {
         /** Получить значение поля (реактивное) */
-        get: <P extends FormPath<T>>(path: P) => FormValue<T, P> | null | undefined;
+        get: <P extends FormPath<F>>(path: P) => FormValue<F, P> | null | undefined;
         /** Получить значение поля (гарантированно актуальное) */
-        getSync: <P extends FormPath<T>>(path: P) => FormValue<T, P> | undefined;
+        getSync: <P extends FormPath<F>>(path: P) => FormValue<F, P> | undefined;
         /** Установить значение поля */
-        set: <P extends FormPath<T>>(path: P, value: FormValue<T, P> | undefined) => void;
+        set: <P extends FormPath<F>>(path: P, value: FormValue<F, P> | undefined) => void;
         /** Очистить одно или несколько полей */
-        clear: (path: FormPath<T> | FormPath<T>[]) => void;
+        clear: (path: FormPath<F> | FormPath<F>[]) => void;
     };
     /** Работа с ошибками */
     errors: {
         /** Получить ошибку поля */
-        get: <P extends FormPath<T>>(path: P) => FormErrorType | undefined;
+        get: <P extends FormPath<F>>(path: P) => FormErrorType | undefined;
         /** Установить ошибку поля */
-        set: <P extends FormPath<T>>(path: P, error: FormErrorType) => void;
+        set: <P extends FormPath<F>>(path: P, error: FormErrorType) => void;
         /** Массово установить ошибки (например, серверные) */
-        setAll: (errors: FormErrorsType<T>) => void;
+        setAll: (errors: FormErrorsType<F>) => void;
         /** Очистить все ошибки */
         clear: () => void;
     };
     /** Валидация (без мутаций ошибок) */
     validation: {
         /** Проверить валидность поля */
-        isFieldValid: <P extends ExtendFormPath<T>>(path: P) => Promise<boolean>;
+        isFieldValid: <P extends ExtendFormPath<F>>(path: P) => Promise<boolean>;
         /** Проверить несколько полей */
-        areFieldsValid: (paths: ExtendFormPath<T>[]) => Promise<boolean>;
+        areFieldsValid: (paths: ExtendFormPath<F>[]) => Promise<boolean>;
         /** Проверить валидность всей формы */
         isFormValid: () => Promise<boolean>;
     };
     /** Подсветка ошибок (side-effect валидации) */
     highlight: {
         /** Подсветить ошибку конкретного поля */
-        field: <P extends ExtendFormPath<T>>(path: P) => Promise<boolean>;
+        field: <P extends ExtendFormPath<F>>(path: P) => Promise<boolean>;
         /** Подсветить ошибки нескольких полей */
-        fields: (paths: ExtendFormPath<T>[]) => Promise<boolean>;
+        fields: (paths: ExtendFormPath<F>[]) => Promise<boolean>;
         /** Подсветить все ошибки формы */
         form: () => Promise<boolean>;
     };

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

@@ -1,23 +1,22 @@
-import { default as React, FormEvent, Ref } from 'react';
-import { ExtendFormPath, FieldPropsType, FormErrorsType, FormErrorType } from '..';
+import { default as React, Ref } from 'react';
+import { ExtendFormPath, FieldPropsType, FormErrorsType, FormErrorType, FormWatchType } from '..';
 import { InstanceRefAttributes, Nullable, Undefinable } from '../../types';
 import { FormPath, FormSchemeType, FormValue, UseFormServices } from './types';
 type FormRef = React.ComponentRef<'form'>;
 type FormInstance = Ref<FormRef> | Array<Ref<FormRef>>;
-type PropsType<T, Form> = [
-    props?: {
-        ref?: FormInstance;
-        useInstanceRefApi?: boolean;
-        initFormData?: T;
-        scheme?: FormSchemeType<T>;
-        onSubmit?: (data: Form, event: FormEvent<HTMLFormElement>, services: UseFormServices<Form, T>) => void | Promise<void>;
-        /** Callback при ошибки валидации полей */
-        onSubmitError?: (event: {
-            errors: FormErrorsType<T>;
-        }, services: UseFormServices<Form, T>) => void;
-        onSubmitAttempt?: (data: T | undefined | null, event: FormEvent<HTMLFormElement>, services: UseFormServices<Form, T>) => void;
-    }
-];
+type PropsType<Form, T> = {
+    ref?: FormInstance;
+    useInstanceRefApi?: boolean;
+    initFormData?: T;
+    scheme?: FormSchemeType<T>;
+    onSubmit?: (data: Form, event: React.SubmitEvent<HTMLFormElement>, services: UseFormServices<Form, T>) => void | Promise<void>;
+    /** Callback при ошибки валидации полей */
+    onSubmitError?: (event: {
+        errors: FormErrorsType<T>;
+    }, services: UseFormServices<Form, T>) => void;
+    onSubmitAttempt?: (data: T | undefined | null, event: React.SubmitEvent<HTMLFormElement>, services: UseFormServices<Form, T>) => void;
+    watch?: FormWatchType<Form>;
+};
 /**
  * `useForm` — типобезопасный хук для управления состоянием и валидации форм.
  *
@@ -212,7 +211,7 @@ type PropsType<T, Form> = [
  * @template Form Полный тип формы
  * @template T Тип начальных данных
  */
-export declare function useForm<Form, T extends Nullable<Undefinable<Form>> = Nullable<Undefinable<Form>>>(...args: PropsType<T, Form>): {
+export declare function useForm<F, T extends Nullable<Undefinable<F>> = Nullable<Undefinable<F>>>(props?: PropsType<F, T>): {
     formData: T | undefined;
     setFormData: (formData: T) => void;
     getFormData: () => T | undefined;
@@ -237,7 +236,7 @@ export declare function useForm<Form, T extends Nullable<Undefinable<Form>> = Nu
         <P extends FormPath<T>>(path: P, config?: FormSchemeType<T>[P]): FieldPropsType<FormValue<T, P>, "update">;
     };
     registerForm: (refsInstance?: FormInstance) => Pick<React.DetailedHTMLProps<React.FormHTMLAttributes<HTMLFormElement>, HTMLFormElement>, "ref" | "onReset" | "onSubmit" | "noValidate"> & Pick<InstanceRefAttributes<HTMLFormElement>, "instanceRef">;
-    getValidForm: () => Promise<Form | null>;
+    getValidForm: () => Promise<F | null>;
     submitForm: () => void;
     resetForm: () => void;
 };

package/dist/types/src/ui/formFields/components/InputInnerButton/ui/InputInnerButton.d.ts

@@ -1,6 +1,7 @@
 import { default as React } from 'react';
-type PropsType = Omit<React.ComponentProps<'button'>, 'className'> & {
+import { PropsForWithInstanceRef } from '../../../../../types';
+type PropsType = PropsForWithInstanceRef<'button', React.ComponentRef<'button'>, {
     color: 'gray' | 'red';
-};
+}>;
 export declare function InputInnerButton(props: PropsType): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/types/src/ui/formFields/index.d.ts

@@ -6,4 +6,4 @@ export * from './FormRadioField';
 export * from './FormTextareaField';
 export * from './FormPaginatedSelectField';
 export * from './dates';
-export * from './components/DoubleInput';
+export * from './components';

package/package.json

@@ -11,7 +11,7 @@
     "react-components",
     "ui-kit"
   ],
-  "version": "1.1.21",
+  "version": "1.1.23",
   "exports": {
     ".": {
       "types": "./dist/types/index.d.ts",