indicator-ui 1.1.0 → 1.1.2

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

@@ -236,7 +236,7 @@ export declare function useForm<Form, T extends Nullable<Undefinable<Form>> = Nu
         (): FieldPropsType<FormValue<T, "">, "update">;
         <P extends FormPath<T>>(path: P, config?: FormSchemeType<T>[P]): FieldPropsType<FormValue<T, P>, "update">;
     };
-    registerForm: (refsInstance?: FormInstance) => Pick<React.ComponentProps<"form">, "onSubmit" | "onReset" | "noValidate" | "ref"> & Pick<InstanceRefAttributes<React.ComponentRef<"form">>, "instanceRef">;
+    registerForm: (refsInstance?: FormInstance) => Pick<React.DetailedHTMLProps<React.FormHTMLAttributes<HTMLFormElement>, HTMLFormElement>, "ref" | "onReset" | "onSubmit" | "noValidate"> & Pick<InstanceRefAttributes<HTMLFormElement>, "instanceRef">;
     getValidForm: () => Promise<Form | null>;
     submitForm: () => void;
     resetForm: () => void;

package/dist/types/src/types/mixins.d.ts

@@ -28,7 +28,7 @@ export type AsProps<T extends ElementType, P extends ComponentAttributes = {}, I
 } & (IR extends never ? {} : InstanceRefAttributes<IR>) & P>;
 export type ComponentPropsWithoutInstanceRef<T extends ElementType> = Omit<React.ComponentProps<T>, keyof InstanceRefAttributes<T>>;
 export type InstanceRefAttributes<T> = {
-    instanceRef?: React.RefObject<T> | React.RefCallback<T> | null;
+    instanceRef?: React.Ref<T>;
 };
 export type ComponentInstanceRef<T extends ElementType> = React.ComponentProps<T> extends InstanceRefAttributes<infer Method> ? Method : never;
 export type AcceptsComponentProps<T extends ElementType, P extends ComponentAttributes> = React.ComponentPropsWithoutRef<T> extends P ? T : never;

package/dist/types/src/ui/InputFields/DateTimeField/ui/TimeField.d.ts

@@ -1,2 +1,2 @@
 import { TimeFieldPropsType } from '../../..';
-export declare function TimeField({ value, onChange, timeFormat, outFormat, additionStyle, timePlaceholder, iconTime, textTime, clearButton, isError, disabled, onFocus, onBlur, width, position, theme, ...props }: TimeFieldPropsType): import("react/jsx-runtime").JSX.Element;
+export declare function TimeField({ value, onChange, timeFormat, outFormat, timePlaceholder, iconTime, textTime, isError, disabled, onBlur, }: TimeFieldPropsType): import("react/jsx-runtime").JSX.Element;

package/dist/types/src/ui/datePickersV2/hooks/dateManagers/index.d.ts

@@ -1,3 +1,4 @@
 export * from './useDateManager';
 export * from './useDateRangeManager';
 export * from './useDateTimeManager';
+export * from './useTimeManager';

package/dist/types/src/ui/datePickersV2/hooks/dateManagers/useTimeManager.d.ts

@@ -0,0 +1,14 @@
+type CommitedDate = string | undefined;
+export declare function useTimeManager(): {
+    setInput: <K extends "hours" | "minutes">(key: K, instance: Partial<Partial<{
+        hours: number;
+        minutes: number;
+    }>>[K]) => void;
+    clearDateInput: () => void;
+    initViewHours: number | undefined;
+    initViewMinutes: number | undefined;
+    createCommitTime: (prev: CommitedDate) => NonNullable<CommitedDate>;
+    createCommitTimeWithoutClearing: (prev: CommitedDate) => NonNullable<CommitedDate>;
+    getPreviewTime: (instance: CommitedDate) => string | undefined;
+};
+export {};

package/dist/types/src/ui/datePickersV2/hooks/pickers/time/index.d.ts

@@ -0,0 +1 @@
+export * from './useTimePickerV2Provider';

package/dist/types/src/ui/datePickersV2/hooks/pickers/time/useTimePickerV2Provider.d.ts

@@ -0,0 +1,31 @@
+import { default as React } from 'react';
+import { ComponentInstanceRef, InstanceRefAttributes } from '../../../../../types';
+import { Footer, Header, Wrapper } from '../../../ui/pickers/components';
+import { TimeFeed } from '../../../ui/feeds/time';
+import { useTimeManager } from '../../dateManagers';
+type WrapperRef = ComponentInstanceRef<typeof Wrapper>;
+type TimeFeedRef = ComponentInstanceRef<typeof TimeFeed>;
+type TimeValue = string;
+type RefType = Pick<ReturnType<typeof useTimeManager>, 'createCommitTimeWithoutClearing' | 'createCommitTime' | 'clearDateInput' | 'setInput'> & {
+    timeFeedRef: React.RefObject<TimeFeedRef>;
+};
+type PropsType = Pick<React.ComponentProps<typeof Wrapper>, 'style'> & Pick<React.ComponentProps<typeof Header>, 'title' | 'subtitle'> & Pick<React.ComponentProps<typeof Footer>, 'isShowFooter' | 'onClose'> & InstanceRefAttributes<RefType> & {
+    wrapperRef?: React.RefObject<WrapperRef>;
+    time?: TimeValue;
+    onSubmitTime?: (dateTime: TimeValue) => void;
+};
+export declare function useTimePickerV2Provider(props: PropsType): {
+    time: string | undefined;
+    onChangeHours: (instance: number) => void;
+    onChangeMinutes: (instance: number) => void;
+    onChooseTime: (instance: string) => void;
+    onSubmit: () => void;
+    viewHoursValue: number | undefined;
+    viewMinutesValue: number | undefined;
+    timeFeedRef: React.RefObject<{
+        scrollToHour: (item: import('../../feeds/time/feed/utils').ElementItem, behavior?: ScrollBehavior) => Promise<void>;
+        scrollToMinute: (item: import('../../feeds/time/feed/utils').ElementItem, behavior?: ScrollBehavior) => Promise<void>;
+    }>;
+    previewTime: string | undefined;
+};
+export {};

package/dist/types/src/ui/datePickersV2/ui/pickers/TimePickerV2.d.ts

@@ -0,0 +1,4 @@
+import { useTimePickerV2Provider } from '../../hooks/pickers/time';
+type PropsType = Parameters<typeof useTimePickerV2Provider>[number];
+export declare function TimePickerV2(props: PropsType): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/src/ui/datePickersV2/ui/pickers/index.d.ts

@@ -1,3 +1,4 @@
 export * from './DateTimePickerV2';
 export * from './DatePickerV2';
 export * from './DateRangePickerV2';
+export * from './TimePickerV2';

package/dist/types/src/ui/formFields/dates/FormDateField/hooks/useDatePickerController.d.ts

@@ -2,7 +2,9 @@ import { default as React } from 'react';
 import { InputDateValue } from './useDateDraft';
 import { useInputFieldController } from './useInputFieldController';
 import { useDateFormats } from './useDateFormats';
-type PropsType = Pick<ReturnType<typeof useDateFormats>, 'parseDateInput'> & Pick<ReturnType<typeof useInputFieldController>, 'doubleInputRef'>;
+type PropsType = Pick<ReturnType<typeof useDateFormats>, 'parseDateInput'> & Pick<ReturnType<typeof useInputFieldController>, 'doubleInputRef'> & {
+    disablePicker?: boolean;
+};
 export declare function useDatePickerController(props: PropsType): {
     datePickerRef: React.RefObject<Pick<{
         dateInput: Partial<Partial<Partial<{
@@ -39,9 +41,8 @@ export declare function useDatePickerController(props: PropsType): {
     datePickerWrapperRef: React.RefObject<never>;
     moveToInputtedDateInPicker: (instance: InputDateValue) => Promise<(void | undefined)[]>;
     clearDateInputInPicker: () => void;
-    closePicker: () => void;
-    openPicker: () => void;
     switchingPicker: () => void;
+    closePicker: () => void;
     getPickerInitStyle: () => React.CSSProperties;
 };
 export {};

package/dist/types/src/ui/formFields/dates/FormDateField/hooks/useFormDateFieldProvider.d.ts

@@ -25,6 +25,7 @@ type PropsType = FieldProps & Pick<DatePickerV2Props, 'requestDaysData' | 'reque
     datePlaceholder?: DoubleInputItemProps['placeholder'];
     disabled?: DoubleInputItemProps['disabled'];
     pickerSubtitle?: DatePickerV2Props['subtitle'];
+    disablePicker?: boolean;
 };
 export declare function useFormDateFieldProvider(props: PropsType): {
     dateInputValue: string | undefined;

package/dist/types/src/ui/formFields/dates/FormDateField/hooks/useSyncDateValues.d.ts

@@ -1,6 +1,7 @@
 import { useDateDraft } from './useDateDraft';
 import { useDateFormats } from './useDateFormats';
 import { useFormDateFieldProvider } from './useFormDateFieldProvider';
-type PropsType = Pick<Parameters<typeof useFormDateFieldProvider>[number], 'onChange' | 'value'> & Pick<ReturnType<typeof useDateDraft>, 'setDateInputValue' | 'dateInputValue'> & Pick<ReturnType<typeof useDateFormats>, 'formatDateInputToValue' | 'formatValueToDateInput'>;
+import { useDatePickerController } from './useDatePickerController';
+type PropsType = Pick<Parameters<typeof useFormDateFieldProvider>[number], 'onChange' | 'value'> & Pick<ReturnType<typeof useDateDraft>, 'setDateInputValue' | 'dateInputValue'> & Pick<ReturnType<typeof useDateFormats>, 'formatDateInputToValue' | 'formatValueToDateInput'> & Pick<ReturnType<typeof useDatePickerController>, 'moveToInputtedDateInPicker'>;
 export declare function useSyncDateValues(props: PropsType): void;
 export {};

package/dist/types/src/ui/formFields/dates/FormDateRangeField/hooks/useDateTimePickerController.d.ts

@@ -2,7 +2,9 @@ import { default as React } from 'react';
 import { InputDateValue } from './useDateRangeDraft';
 import { useInputFieldController } from './useInputFieldController';
 import { useDateRangeFormats } from './useDateRangeFormats';
-type PropsType = Pick<ReturnType<typeof useDateRangeFormats>, 'parseInputDate'> & Pick<ReturnType<typeof useInputFieldController>, 'doubleInputRef'>;
+type PropsType = Pick<ReturnType<typeof useDateRangeFormats>, 'parseInputDate'> & Pick<ReturnType<typeof useInputFieldController>, 'doubleInputRef'> & {
+    disablePicker?: boolean;
+};
 export declare function useDateTimePickerController(props: PropsType): {
     dateTimePickerRef: React.RefObject<Pick<{
         setInput: <K extends "year" | "monthYear" | "dayMonthYear">(key: K, instance: Partial<Partial<{

package/dist/types/src/ui/formFields/dates/FormDateRangeField/hooks/useFormDateRangeFieldProvider.d.ts

@@ -29,6 +29,7 @@ type PropsType = FieldProps & Pick<DateRangePickerV2Props, 'requestedDaysData' |
     toIcon?: DoubleInputItemProps['icon'];
     disabled?: DoubleInputItemProps['disabled'];
     pickerSubtitle?: DateRangePickerV2Props['subtitle'];
+    disablePicker?: boolean;
 };
 export declare function useFormDateRangeFieldProvider(props: PropsType): {
     fromDateValue: string | undefined;

package/dist/types/src/ui/formFields/dates/FormDateRangeField/hooks/useSyncDateTimeValues.d.ts

@@ -1,6 +1,7 @@
 import { useDateRangeDraft } from './useDateRangeDraft';
 import { useDateRangeFormats } from './useDateRangeFormats';
 import { useFormDateRangeFieldProvider } from './useFormDateRangeFieldProvider';
-type PropsType = Pick<Parameters<typeof useFormDateRangeFieldProvider>[number], 'onChange' | 'value'> & Pick<ReturnType<typeof useDateRangeDraft>, 'setFromDateValue' | 'setToDateValue' | 'fromDateValue' | 'toDateValue'> & Pick<ReturnType<typeof useDateRangeFormats>, 'formatDateInputToValue' | 'formatValueItemToDateInput'>;
+import { useDateTimePickerController } from './useDateTimePickerController';
+type PropsType = Pick<Parameters<typeof useFormDateRangeFieldProvider>[number], 'onChange' | 'value'> & Pick<ReturnType<typeof useDateRangeDraft>, 'setFromDateValue' | 'setToDateValue' | 'fromDateValue' | 'toDateValue'> & Pick<ReturnType<typeof useDateRangeFormats>, 'formatDateInputToValue' | 'formatValueItemToDateInput'> & Pick<ReturnType<typeof useDateTimePickerController>, 'moveToInputtedDateInPicker'>;
 export declare function useSyncDateTimeValues(props: PropsType): void;
 export {};

package/dist/types/src/ui/formFields/dates/FormDateTimeField/hooks/useDateTimePickerController.d.ts

@@ -2,7 +2,9 @@ import { default as React } from 'react';
 import { DateValue, TimeValue } from './useDateTimeDraft';
 import { useInputFieldController } from './useInputFieldController';
 import { useDateTimeFormats } from './useDateTimeFormats';
-type PropsType = Pick<ReturnType<typeof useDateTimeFormats>, 'parseTimeInput' | 'parseDateInput'> & Pick<ReturnType<typeof useInputFieldController>, 'doubleInputRef'>;
+type PropsType = Pick<ReturnType<typeof useDateTimeFormats>, 'parseTimeInput' | 'parseDateInput'> & Pick<ReturnType<typeof useInputFieldController>, 'doubleInputRef'> & {
+    disablePicker?: boolean;
+};
 export declare function useDateTimePickerController(props: PropsType): {
     dateTimePickerRef: React.RefObject<Pick<{
         pickerState: "time" | "date-main";

package/dist/types/src/ui/formFields/dates/FormDateTimeField/hooks/useFormDateTimeFieldProvider.d.ts

@@ -35,6 +35,7 @@ type PropsType = FieldProps & Pick<DateTimePickerV2Props, 'requestDaysData' | 'r
     timeIcon?: DoubleInputItemProps['icon'];
     disabled?: DoubleInputItemProps['disabled'];
     pickerSubtitle?: DateTimePickerV2Props['subtitle'];
+    disablePicker?: boolean;
 };
 export declare function useFormDateTimeFieldProvider(props: PropsType): {
     dateValue: string | undefined;

package/dist/types/src/ui/formFields/dates/FormDateTimeField/hooks/useSyncDateTimeValues.d.ts

@@ -1,6 +1,7 @@
 import { useDateTimeDraft } from './useDateTimeDraft';
 import { useDateTimeFormats } from './useDateTimeFormats';
 import { useFormDateTimeFieldProvider } from './useFormDateTimeFieldProvider';
-type PropsType = Pick<Parameters<typeof useFormDateTimeFieldProvider>[number], 'onChange' | 'value'> & Pick<ReturnType<typeof useDateTimeDraft>, 'setDateInputValue' | 'setTimeInputValue' | 'timeInputValue' | 'dateInputValue'> & Pick<ReturnType<typeof useDateTimeFormats>, 'formatDateTimeInputToValue' | 'formatValueToDateInput' | 'formatValueToTimeInput'>;
+import { useDateTimePickerController } from './useDateTimePickerController';
+type PropsType = Pick<Parameters<typeof useFormDateTimeFieldProvider>[number], 'onChange' | 'value'> & Pick<ReturnType<typeof useDateTimeDraft>, 'setDateInputValue' | 'setTimeInputValue' | 'timeInputValue' | 'dateInputValue'> & Pick<ReturnType<typeof useDateTimeFormats>, 'formatDateTimeInputToValue' | 'formatValueToDateInput' | 'formatValueToTimeInput'> & Pick<ReturnType<typeof useDateTimePickerController>, 'moveToInputtedDateInPicker' | 'moveToInputtedTimeInPicker'>;
 export declare function useSyncDateTimeValues(props: PropsType): void;
 export {};

package/dist/types/src/ui/formFields/dates/FormTimeField/hooks/index.d.ts

@@ -0,0 +1 @@
+export * from './useFormTimeFieldProvider';

package/dist/types/src/ui/formFields/dates/FormTimeField/hooks/useFormTimeFieldProvider.d.ts

@@ -0,0 +1,109 @@
+import { default as React } from 'react';
+import { FieldPropsType } from '../../../../../hooks';
+import { TimePickerV2 } from '../../../..';
+import { DoubleInputItemProps } from './useInputFieldProps';
+type TimePickerV2Props = React.ComponentProps<typeof TimePickerV2>;
+type ValueBaseType = string;
+type FieldProps = FieldPropsType<ValueBaseType>;
+export type ValueType = FieldProps['value'];
+type PropsType = FieldProps & {
+    /**
+     * Формат даты ввода пользователя.
+     *
+     * ---
+     * Для ознакомления с обозначениями {@link DATE_IMASK_BLOCKS}
+     * */
+    inputTimeFormat?: string;
+    /**
+     * Формат даты (понимаемый `date-fns`), которая будет хранится в `value`.
+     *
+     * Пример: `"HH:mm:ssXXX"`.
+     * */
+    outFormat?: string | 'iso';
+    timePlaceholder?: DoubleInputItemProps['placeholder'];
+    timeHintText?: DoubleInputItemProps['hintText'];
+    timeIcon?: DoubleInputItemProps['icon'];
+    disabled?: DoubleInputItemProps['disabled'];
+    pickerSubtitle?: TimePickerV2Props['subtitle'];
+    disablePicker?: boolean;
+};
+export declare function useFormTimeFieldProvider(props: PropsType): {
+    timeInputValue: string | undefined;
+    onCompleteTime: NonNullable<((value: string, maskRef: import('imask').InputMask<{
+        [x: string]: unknown;
+    }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{
+        [x: string]: unknown;
+    }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{
+        [x: string]: unknown;
+    }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{
+        [x: string]: unknown;
+    }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{
+        [x: string]: unknown;
+    }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{
+        [x: string]: unknown;
+    }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{
+        [x: string]: unknown;
+    }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{
+        [x: string]: unknown;
+    }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{
+        [x: string]: unknown;
+    }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{
+        [x: string]: unknown;
+    }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{
+        [x: string]: unknown;
+    }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{
+        [x: string]: unknown;
+    }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{
+        [x: string]: unknown;
+    }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{
+        [x: string]: unknown;
+    }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{
+        [x: string]: unknown;
+    }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{
+        [x: string]: unknown;
+    }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{
+        [x: string]: unknown;
+    }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{
+        [x: string]: unknown;
+    }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{
+        [x: string]: unknown;
+    }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{
+        [x: string]: unknown;
+    }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{
+        [x: string]: unknown;
+    }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{
+        [x: string]: unknown;
+    }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{
+        [x: string]: unknown;
+    }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{
+        [x: string]: unknown;
+    }>, e?: InputEvent) => void) | undefined>;
+    timePickerRef: React.RefObject<Pick<{
+        setInput: <K extends "hours" | "minutes">(key: K, instance: Partial<Partial<{
+            hours: number;
+            minutes: number;
+        }>>[K]) => void;
+        clearDateInput: () => void;
+        initViewHours: number | undefined;
+        initViewMinutes: number | undefined;
+        createCommitTime: (prev: string | undefined) => NonNullable<string | undefined>;
+        createCommitTimeWithoutClearing: (prev: string | undefined) => NonNullable<string | undefined>;
+        getPreviewTime: (instance: string | undefined) => string | undefined;
+    }, "clearDateInput" | "setInput" | "createCommitTimeWithoutClearing" | "createCommitTime"> & {
+        timeFeedRef: React.RefObject<{
+            scrollToHour: (item: import('../../../../datePickersV2/hooks/feeds/time/feed/utils').ElementItem, behavior?: ScrollBehavior) => Promise<void>;
+            scrollToMinute: (item: import('../../../../datePickersV2/hooks/feeds/time/feed/utils').ElementItem, behavior?: ScrollBehavior) => Promise<void>;
+        }>;
+    }>;
+    timePickerWrapperRef: React.RefObject<never>;
+    doubleInputRef: React.RefObject<HTMLDivElement>;
+    inputTimeFormat: string;
+    time: string | undefined;
+    onSubmitTime: (dateTime: string) => void;
+    onClickTimeField: React.MouseEventHandler<HTMLInputElement>;
+    clearTime: () => void;
+    isErrorInputFields: boolean | undefined;
+    isDisabledInputFields: boolean | undefined;
+    getPickerInitStyle: () => React.CSSProperties;
+};
+export {};

package/dist/types/src/ui/formFields/dates/FormTimeField/hooks/useInputFieldController.d.ts

@@ -0,0 +1,4 @@
+export declare function useInputFieldController(): {
+    doubleInputRef: import('react').RefObject<HTMLDivElement>;
+    timeInputRef: import('react').RefObject<HTMLInputElement>;
+};

package/dist/types/src/ui/formFields/dates/FormTimeField/hooks/useInputFieldProps.d.ts

@@ -0,0 +1,63 @@
+import { default as React } from 'react';
+import { DoubleInputItem } from '../../../components';
+import { useTimePickerController } from './useTimePickerController';
+import { useTimeDraft } from './useTimeDraft';
+import { useFormTimeFieldProvider } from './useFormTimeFieldProvider';
+export type DoubleInputItemProps = React.ComponentProps<typeof DoubleInputItem>;
+type PropsType = Pick<Parameters<typeof useFormTimeFieldProvider>[number], 'error' | 'disabled'> & Pick<ReturnType<typeof useTimePickerController>, 'moveToInputtedTimeInPicker' | 'clearTimeInputInPicker' | 'closePicker' | 'switchingPicker'> & Pick<ReturnType<typeof useTimeDraft>, 'setTimeInputValue' | 'clearTimeValue' | 'isFullDateInput'>;
+export declare function useInputFieldProps(props: PropsType): {
+    onCompleteTime: NonNullable<((value: string, maskRef: import('imask').InputMask<{
+        [x: string]: unknown;
+    }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{
+        [x: string]: unknown;
+    }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{
+        [x: string]: unknown;
+    }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{
+        [x: string]: unknown;
+    }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{
+        [x: string]: unknown;
+    }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{
+        [x: string]: unknown;
+    }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{
+        [x: string]: unknown;
+    }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{
+        [x: string]: unknown;
+    }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{
+        [x: string]: unknown;
+    }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{
+        [x: string]: unknown;
+    }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{
+        [x: string]: unknown;
+    }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{
+        [x: string]: unknown;
+    }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{
+        [x: string]: unknown;
+    }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{
+        [x: string]: unknown;
+    }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{
+        [x: string]: unknown;
+    }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{
+        [x: string]: unknown;
+    }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{
+        [x: string]: unknown;
+    }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{
+        [x: string]: unknown;
+    }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{
+        [x: string]: unknown;
+    }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{
+        [x: string]: unknown;
+    }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{
+        [x: string]: unknown;
+    }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{
+        [x: string]: unknown;
+    }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{
+        [x: string]: unknown;
+    }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{
+        [x: string]: unknown;
+    }>, e?: InputEvent) => void) | undefined>;
+    onClickTimeField: React.MouseEventHandler<HTMLInputElement>;
+    clearTime: () => void;
+    isErrorInputFields: boolean | undefined;
+    isDisabledInputFields: boolean | undefined;
+};
+export {};

package/dist/types/src/ui/formFields/dates/FormTimeField/hooks/useSyncTimeValues.d.ts

@@ -0,0 +1,7 @@
+import { useTimeDraft } from './useTimeDraft';
+import { useTimeFormats } from './useTimeFormats';
+import { useFormTimeFieldProvider } from './useFormTimeFieldProvider';
+import { useTimePickerController } from './useTimePickerController';
+type PropsType = Pick<Parameters<typeof useFormTimeFieldProvider>[number], 'onChange' | 'value'> & Pick<ReturnType<typeof useTimeDraft>, 'setTimeInputValue' | 'timeInputValue'> & Pick<ReturnType<typeof useTimeFormats>, 'formatDateTimeInputToValue' | 'formatValueToTimeInput'> & Pick<ReturnType<typeof useTimePickerController>, 'moveToInputtedTimeInPicker'>;
+export declare function useSyncTimeValues(props: PropsType): void;
+export {};

package/dist/types/src/ui/formFields/dates/FormTimeField/hooks/useTimeDraft.d.ts

@@ -0,0 +1,13 @@
+import { useFormTimeFieldProvider } from './useFormTimeFieldProvider';
+import { useTimeFormats } from './useTimeFormats';
+type UseFormDateTimeFieldProps = Parameters<typeof useFormTimeFieldProvider>[number];
+export type DateValue = string;
+export type TimeValue = string;
+type PropsType = Pick<UseFormDateTimeFieldProps, 'value'> & Pick<ReturnType<typeof useTimeFormats>, 'formatValueToTimeInput'>;
+export declare function useTimeDraft(props: PropsType): {
+    timeInputValue: string | undefined;
+    setTimeInputValue: import('react').Dispatch<import('react').SetStateAction<string | undefined>>;
+    clearTimeValue: () => void;
+    isFullDateInput: () => boolean;
+};
+export {};

package/dist/types/src/ui/formFields/dates/FormTimeField/hooks/useTimeFormats.d.ts

@@ -0,0 +1,14 @@
+import { default as React } from 'react';
+import { TimePickerV2 } from '../../../..';
+import { useFormTimeFieldProvider, ValueType } from './useFormTimeFieldProvider';
+import { TimeValue } from './useTimeDraft';
+type TimePickerV2Props = React.ComponentProps<typeof TimePickerV2>;
+type DateTimePickerValue = Parameters<NonNullable<TimePickerV2Props['onSubmitTime']>>[0];
+type PropsType = Required<Pick<Parameters<typeof useFormTimeFieldProvider>[number], 'outFormat' | 'inputTimeFormat'>>;
+export declare function useTimeFormats(props: PropsType): {
+    formatDateTimeInputToValue: (timeValue: TimeValue) => ValueType;
+    parseTimeInput: (instance: TimeValue) => Date;
+    formatPickerValueToTimeInput: (instance: DateTimePickerValue) => TimeValue | undefined;
+    formatValueToTimeInput: (instance: ValueType) => TimeValue | undefined;
+};
+export {};

package/dist/types/src/ui/formFields/dates/FormTimeField/hooks/useTimePickerController.d.ts

@@ -0,0 +1,33 @@
+import { default as React } from 'react';
+import { TimeValue } from './useTimeDraft';
+import { useInputFieldController } from './useInputFieldController';
+import { useTimeFormats } from './useTimeFormats';
+type PropsType = Pick<ReturnType<typeof useTimeFormats>, 'parseTimeInput'> & Pick<ReturnType<typeof useInputFieldController>, 'doubleInputRef'> & {
+    disablePicker?: boolean;
+};
+export declare function useTimePickerController(props: PropsType): {
+    timePickerRef: React.RefObject<Pick<{
+        setInput: <K extends "hours" | "minutes">(key: K, instance: Partial<Partial<{
+            hours: number;
+            minutes: number;
+        }>>[K]) => void;
+        clearDateInput: () => void;
+        initViewHours: number | undefined;
+        initViewMinutes: number | undefined;
+        createCommitTime: (prev: string | undefined) => NonNullable<string | undefined>;
+        createCommitTimeWithoutClearing: (prev: string | undefined) => NonNullable<string | undefined>;
+        getPreviewTime: (instance: string | undefined) => string | undefined;
+    }, "clearDateInput" | "setInput" | "createCommitTimeWithoutClearing" | "createCommitTime"> & {
+        timeFeedRef: React.RefObject<{
+            scrollToHour: (item: import('../../../../datePickersV2/hooks/feeds/time/feed/utils').ElementItem, behavior?: ScrollBehavior) => Promise<void>;
+            scrollToMinute: (item: import('../../../../datePickersV2/hooks/feeds/time/feed/utils').ElementItem, behavior?: ScrollBehavior) => Promise<void>;
+        }>;
+    }>;
+    timePickerWrapperRef: React.RefObject<never>;
+    moveToInputtedTimeInPicker: (instance: TimeValue) => Promise<(void | undefined)[]>;
+    clearTimeInputInPicker: () => void;
+    closePicker: () => void;
+    switchingPicker: () => void;
+    getPickerInitStyle: () => React.CSSProperties;
+};
+export {};

package/dist/types/src/ui/formFields/dates/FormTimeField/hooks/useTimePickerProps.d.ts

@@ -0,0 +1,10 @@
+import { useTimeDraft } from './useTimeDraft';
+import { useFormTimeFieldProvider } from './useFormTimeFieldProvider';
+import { useTimePickerController } from './useTimePickerController';
+import { useTimeFormats } from './useTimeFormats';
+type PropsType = Pick<Parameters<typeof useFormTimeFieldProvider>[number], 'value'> & Pick<ReturnType<typeof useTimePickerController>, 'closePicker'> & Pick<ReturnType<typeof useTimeDraft>, 'setTimeInputValue'> & Pick<ReturnType<typeof useTimeFormats>, 'formatPickerValueToTimeInput'>;
+export declare function useTimePickerProps(props: PropsType): {
+    time: string | undefined;
+    onSubmitTime: (dateTime: string) => void;
+};
+export {};

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

@@ -0,0 +1 @@
+export * from './ui';

package/dist/types/src/ui/formFields/dates/FormTimeField/ui/FormTimeField.d.ts

@@ -0,0 +1,6 @@
+import { default as React } from 'react';
+import { FormFieldWrapper } from '../../../FormFieldWrapper';
+import { FormTimeFieldBase } from './FormTimeFieldBase';
+type PropsType = Omit<React.ComponentProps<typeof FormTimeFieldBase>, 'pickerSubtitle'> & Pick<React.ComponentProps<typeof FormFieldWrapper>, 'error' | 'hint' | 'helperLink' | 'label' | 'required' | 'typeDisplay'>;
+export declare function FormTimeField(props: PropsType): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/src/ui/formFields/dates/FormTimeField/ui/FormTimeFieldBase.d.ts

@@ -0,0 +1,4 @@
+import { useFormTimeFieldProvider } from '../hooks';
+type PropsType = Parameters<typeof useFormTimeFieldProvider>[number];
+export declare function FormTimeFieldBase(props: PropsType): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,2 @@
+export * from './FormTimeFieldBase';
+export * from './FormTimeField';

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

@@ -1,3 +1,4 @@
 export * from './FormDateField';
 export * from './FormDateRangeField';
 export * from './FormDateTimeField';
+export * from './FormTimeField';

package/package.json

@@ -11,7 +11,7 @@
     "react-components",
     "ui-kit"
   ],
-  "version": "1.1.0",
+  "version": "1.1.2",
   "exports": {
     ".": {
       "types": "./dist/types/index.d.ts",
@@ -46,8 +46,8 @@
     "@types/mathjs": "^9.4.1",
     "@types/node": "^22.13.13",
     "@types/object-hash": "^3.0.6",
-    "@types/react": "^18.2.0",
-    "@types/react-dom": "^18.2.0",
+    "@types/react": ">=18.0.0",
+    "@types/react-dom": ">=18.0.0",
     "@vitejs/plugin-react": "^5.1.2",
     "ajv": "^8.17.1",
     "clsx": "^2.1.1",
@@ -70,13 +70,13 @@
     "vite-plugin-dts": "^4.5.4",
     "vite-plugin-static-copy": "^3.1.4",
     "vite-plugin-svgr": "^4.5.0",
-    "vite-plugin-virtual-html": "^1.2.7"
+    "vite-plugin-virtual-html": "^1.2.7",
+    "gl-matrix": "^3.4.4",
+    "uuid": "^13.0.0"
   },
   "peerDependencies": {
     "react": ">=18.0.0",
-    "react-dom": ">=18.0.0",
-    "gl-matrix": "^3.4.4",
-    "uuid": "^13.0.0"
+    "react-dom": ">=18.0.0"
   },
   "dependencies": {}
 }