indicator-ui 1.1.3 → 1.1.4

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

@@ -8,8 +8,14 @@ type PropsType = Required<Pick<Parameters<typeof useFormDateFieldProvider>[numbe
 export declare function useDateFormats(props: PropsType): {
     formatDateInputToValue: (instance: InputDateValue) => string;
     parseDateInput: (instance: InputDateValue) => Date;
+    parseValue: (instance: ValueType) => Date | undefined;
     formatValueToDateInput: (instance: ValueType) => string | undefined;
     formatPickerValueToDateInput: (instance: DatePickerValue) => string | undefined;
     formatValueToDatePickerValue: (instance: ValueType) => string | undefined;
+    extractDateInputToPickerInputs: (instance: InputDateValue) => {
+        year: number;
+        monthYear: string;
+        dayMonthYear: string;
+    };
 };
 export {};

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

@@ -2,7 +2,7 @@ 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>, 'extractDateInputToPickerInputs'> & Pick<ReturnType<typeof useInputFieldController>, 'doubleInputRef'> & {
     disablePicker?: boolean;
 };
 export declare function useDatePickerController(props: PropsType): {

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

@@ -0,0 +1,6 @@
+import { useDateFormats } from './useDateFormats';
+type PropsType = Pick<ReturnType<typeof useDateFormats>, 'parseDateInput'>;
+export declare function useDateUtils(props: PropsType): {
+    isValidDateInput: (instance: string) => boolean;
+};
+export {};

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

@@ -4,8 +4,9 @@ import { useDatePickerController } from './useDatePickerController';
 import { useDateDraft } from './useDateDraft';
 import { useFormDateFieldProvider } from './useFormDateFieldProvider';
 import { useInputFieldController } from './useInputFieldController';
+import { useDateUtils } from './useDateUtils';
 export type DoubleInputItemProps = React.ComponentProps<typeof DoubleInputItem>;
-type PropsType = Pick<Parameters<typeof useFormDateFieldProvider>[number], 'error' | 'disabled'> & Pick<ReturnType<typeof useDatePickerController>, 'moveToInputtedDateInPicker' | 'clearDateInputInPicker' | 'closePicker' | 'switchingPicker'> & Pick<ReturnType<typeof useInputFieldController>, 'focusOnDateField'> & Pick<ReturnType<typeof useDateDraft>, 'setDateInputValue' | 'clearDateValue' | 'isFullDateInput'>;
+type PropsType = Pick<Parameters<typeof useFormDateFieldProvider>[number], 'error' | 'disabled'> & Pick<ReturnType<typeof useDatePickerController>, 'moveToInputtedDateInPicker' | 'clearDateInputInPicker' | 'closePicker' | 'switchingPicker'> & Pick<ReturnType<typeof useInputFieldController>, 'focusOnDateField'> & Pick<ReturnType<typeof useDateDraft>, 'setDateInputValue' | 'clearDateValue' | 'isFullDateInput'> & Pick<ReturnType<typeof useDateUtils>, 'isValidDateInput'>;
 export declare function useInputFieldProps(props: PropsType): {
     onCompleteDate: NonNullable<((value: string, maskRef: import('imask').InputMask<{
         [x: string]: unknown;

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

@@ -1,17 +1,17 @@
 import { useFormDateRangeFieldProvider } from './useFormDateRangeFieldProvider';
 import { useDateRangeFormats } from './useDateRangeFormats';
-export type InputDateValue = string;
+export type InputDateValue = string | undefined;
 type UseFormDateRangeFieldProps = Parameters<typeof useFormDateRangeFieldProvider>[number];
 type PropsType = Pick<ReturnType<typeof useDateRangeFormats>, 'formatValueItemToDateInput'> & Pick<UseFormDateRangeFieldProps, 'value'>;
 export declare function useDateRangeDraft(props: PropsType): {
-    fromDateValue: string | undefined;
-    toDateValue: string | undefined;
-    setFromDateValue: import('react').Dispatch<import('react').SetStateAction<string | undefined>>;
-    setToDateValue: import('react').Dispatch<import('react').SetStateAction<string | undefined>>;
-    getFromDateValue: () => string | undefined;
-    getToDateValue: () => string | undefined;
+    fromDateValue: InputDateValue;
+    toDateValue: InputDateValue;
+    setFromDateValue: import('react').Dispatch<import('react').SetStateAction<InputDateValue>>;
+    setToDateValue: import('react').Dispatch<import('react').SetStateAction<InputDateValue>>;
+    getFromDateValue: () => InputDateValue;
+    getToDateValue: () => InputDateValue;
     clearDateRangeValue: () => void;
-    isFullDateInput: (fromDate?: InputDateValue, toDate?: InputDateValue) => boolean;
+    isFullDateInput: (fromDate: InputDateValue, toDate: InputDateValue) => boolean;
     isFullCurrentDateInput: () => boolean;
 };
 export {};

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

@@ -1,10 +1,15 @@
+import { default as React } from 'react';
+import { DatePickerV2 } from '../../../..';
 import { useFormDateRangeFieldProvider, ValueItemType, ValueType } from './useFormDateRangeFieldProvider';
 import { InputDateValue } from './useDateRangeDraft';
+type DatePickerValue = Parameters<NonNullable<React.ComponentProps<typeof DatePickerV2>['onChangeDate']>>[number] & Parameters<NonNullable<React.ComponentProps<typeof DatePickerV2>['onSubmitDate']>>[number];
 type PropsType = Required<Pick<Parameters<typeof useFormDateRangeFieldProvider>[number], 'outFormat' | 'inputDateFormat'>>;
 export declare function useDateRangeFormats(props: PropsType): {
-    formatDateInputToValue: (instance: InputDateValue) => string;
-    formatValueItemToDateInput: (instance?: ValueItemType) => string | undefined;
-    formatValueToDatePickerValue: (instance: ValueType) => import('./useFormDateRangeFieldProvider').ValueBaseType | undefined;
-    parseInputDate: (instance: InputDateValue) => Date;
+    formatDateInputToValue: (instance: NonNullable<InputDateValue>) => string;
+    formatValueItemToDateInput: (instance: ValueItemType) => string;
+    formatValueToDatePickerValue: (instance: ValueType) => string[] | undefined;
+    parseInputDate: (instance: NonNullable<InputDateValue>) => Date;
+    parseValue: (instance: ValueItemType) => Date;
+    formatDatePickerToDateInput: (instance?: DatePickerValue) => string | undefined;
 };
 export {};

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

@@ -2,7 +2,7 @@ import { useDateRangeDraft } from './useDateRangeDraft';
 import { useFormDateRangeFieldProvider } from './useFormDateRangeFieldProvider';
 import { useDateTimePickerController } from './useDateTimePickerController';
 import { useDateRangeFormats } from './useDateRangeFormats';
-type PropsType = Pick<Parameters<typeof useFormDateRangeFieldProvider>[number], 'value'> & Pick<ReturnType<typeof useDateTimePickerController>, 'closePicker'> & Pick<ReturnType<typeof useDateRangeDraft>, 'setFromDateValue' | 'setToDateValue'> & Pick<ReturnType<typeof useDateRangeFormats>, 'formatValueItemToDateInput' | 'formatValueToDatePickerValue'>;
+type PropsType = Pick<Parameters<typeof useFormDateRangeFieldProvider>[number], 'value'> & Pick<ReturnType<typeof useDateTimePickerController>, 'closePicker'> & Pick<ReturnType<typeof useDateRangeDraft>, 'setFromDateValue' | 'setToDateValue'> & Pick<ReturnType<typeof useDateRangeFormats>, 'formatDatePickerToDateInput' | 'formatValueToDatePickerValue'>;
 export declare function useDateRangePickerProps(props: PropsType): {
     dateRange: string[] | undefined;
     onChooseDateRange: (dateRange: string[]) => void;

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

@@ -1,8 +1,8 @@
 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'> & {
+import { useDateUtils } from './useDateUtils';
+type PropsType = Pick<ReturnType<typeof useInputFieldController>, 'doubleInputRef'> & Pick<ReturnType<typeof useDateUtils>, 'extractDateInputToPickerData'> & {
     disablePicker?: boolean;
 };
 export declare function useDateTimePickerController(props: PropsType): {
@@ -34,7 +34,7 @@ export declare function useDateTimePickerController(props: PropsType): {
         }>;
     }>;
     dateTimePickerWrapperRef: React.RefObject<never>;
-    moveToInputtedDateInPicker: (instance: InputDateValue) => Promise<(void | undefined)[]>;
+    moveToInputtedDateInPicker: (instance: NonNullable<InputDateValue>) => Promise<(void | undefined)[]>;
     clearDateRangeInputInPicker: () => void;
     closePicker: () => void;
     openPicker: () => void;

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

@@ -0,0 +1,15 @@
+import { ValueType } from './useFormDateRangeFieldProvider';
+import { useDateRangeFormats } from './useDateRangeFormats';
+import { InputDateValue } from './useDateRangeDraft';
+type PropsType = Pick<ReturnType<typeof useDateRangeFormats>, 'parseInputDate' | 'parseValue'>;
+export declare function useDateUtils(props: PropsType): {
+    extractDateInputToPickerData: (instance: NonNullable<InputDateValue>) => {
+        year: number;
+        monthYear: string;
+        dayMonthYear: string;
+    };
+    isAfterInputDate: (a: NonNullable<InputDateValue>, b: NonNullable<InputDateValue>) => boolean;
+    sortDateValue: (instance: ValueType) => string[];
+    isValidDateInput: (instance: string) => boolean;
+};
+export {};

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

@@ -32,8 +32,8 @@ type PropsType = FieldProps & Pick<DateRangePickerV2Props, 'requestedDaysData' |
     disablePicker?: boolean;
 };
 export declare function useFormDateRangeFieldProvider(props: PropsType): {
-    fromDateValue: string | undefined;
-    toDateValue: string | undefined;
+    fromDateValue: import('./useDateRangeDraft').InputDateValue;
+    toDateValue: import('./useDateRangeDraft').InputDateValue;
     onCompleteDateTo: NonNullable<((value: string, maskRef: import('imask').InputMask<{
         [x: string]: unknown;
     }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{

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

@@ -4,9 +4,9 @@ import { useDateTimePickerController } from './useDateTimePickerController';
 import { useDateRangeDraft } from './useDateRangeDraft';
 import { useFormDateRangeFieldProvider } from './useFormDateRangeFieldProvider';
 import { useInputFieldController } from './useInputFieldController';
-import { useDateRangeFormats } from './useDateRangeFormats';
+import { useDateUtils } from './useDateUtils';
 export type DoubleInputItemProps = React.ComponentProps<typeof DoubleInputItem>;
-type PropsType = Pick<Parameters<typeof useFormDateRangeFieldProvider>[number], 'error' | 'disabled'> & Pick<ReturnType<typeof useDateTimePickerController>, 'moveToInputtedDateInPicker' | 'clearDateRangeInputInPicker' | 'openPicker' | 'switchingPicker' | 'getIsShowPicker' | 'closePicker'> & Pick<ReturnType<typeof useInputFieldController>, 'focusOnFromDateField' | 'focusOnToDateField' | 'checkFocusedFromDateInput' | 'checkFocusedToDateInput'> & Pick<ReturnType<typeof useDateRangeFormats>, 'parseInputDate'> & Pick<ReturnType<typeof useDateRangeDraft>, 'setToDateValue' | 'setFromDateValue' | 'clearDateRangeValue' | 'isFullDateInput' | 'isFullCurrentDateInput' | 'getFromDateValue' | 'getToDateValue'>;
+type PropsType = Pick<Parameters<typeof useFormDateRangeFieldProvider>[number], 'error' | 'disabled'> & Pick<ReturnType<typeof useDateTimePickerController>, 'moveToInputtedDateInPicker' | 'clearDateRangeInputInPicker' | 'openPicker' | 'switchingPicker' | 'getIsShowPicker' | 'closePicker'> & Pick<ReturnType<typeof useInputFieldController>, 'focusOnFromDateField' | 'focusOnToDateField' | 'checkFocusedFromDateInput' | 'checkFocusedToDateInput'> & Pick<ReturnType<typeof useDateRangeDraft>, 'setToDateValue' | 'setFromDateValue' | 'clearDateRangeValue' | 'isFullDateInput' | 'isFullCurrentDateInput' | 'getFromDateValue' | 'getToDateValue'> & Pick<ReturnType<typeof useDateUtils>, 'isAfterInputDate' | 'isValidDateInput'>;
 export declare function useInputFieldProps(props: PropsType): {
     onCompleteDateFrom: NonNullable<((value: string, maskRef: import('imask').InputMask<{
         [x: string]: unknown;

package/dist/types/src/ui/formFields/dates/FormDateRangeField/hooks/{useSyncDateTimeValues.d.ts → useSyncDateRangeValues.d.ts}

@@ -2,6 +2,7 @@ import { useDateRangeDraft } from './useDateRangeDraft';
 import { useDateRangeFormats } from './useDateRangeFormats';
 import { useFormDateRangeFieldProvider } from './useFormDateRangeFieldProvider';
 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;
+import { useDateUtils } from './useDateUtils';
+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'> & Pick<ReturnType<typeof useDateUtils>, 'sortDateValue'>;
+export declare function useSyncDateRangeValues(props: PropsType): void;
 export {};

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

@@ -1,8 +1,8 @@
 import { useFormDateTimeFieldProvider } from './useFormDateTimeFieldProvider';
 import { useDateTimeFormats } from './useDateTimeFormats';
 type UseFormDateTimeFieldProps = Parameters<typeof useFormDateTimeFieldProvider>[number];
-export type DateValue = string;
-export type TimeValue = string;
+export type DateInputValue = string;
+export type TimeInputValue = string;
 type PropsType = Pick<UseFormDateTimeFieldProps, 'value'> & Pick<ReturnType<typeof useDateTimeFormats>, 'formatValueToDateInput' | 'formatValueToTimeInput'>;
 export declare function useDateTimeDraft(props: PropsType): {
     dateInputValue: string | undefined;

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

@@ -1,18 +1,19 @@
 import { default as React } from 'react';
 import { DateTimePickerV2 } from '../../../..';
 import { useFormDateTimeFieldProvider, ValueType } from './useFormDateTimeFieldProvider';
-import { DateValue, TimeValue } from './useDateTimeDraft';
+import { DateInputValue, TimeInputValue } from './useDateTimeDraft';
 type DateTimePickerV2Props = React.ComponentProps<typeof DateTimePickerV2>;
 type DateTimePickerValue = Parameters<NonNullable<DateTimePickerV2Props['onSubmitDateTime']>>[0] | Parameters<NonNullable<DateTimePickerV2Props['onSubmitDate']>>[0];
 type PropsType = Required<Pick<Parameters<typeof useFormDateTimeFieldProvider>[number], 'outFormat' | 'inputDateFormat' | 'inputTimeFormat'>>;
 export declare function useDateTimeFormats(props: PropsType): {
-    formatDateTimeInputToValue: (dateValue: DateValue, timeValue: TimeValue) => ValueType;
-    parseDateInput: (instance: DateValue) => Date;
-    parseTimeInput: (instance: TimeValue) => Date;
+    formatDateTimeInputToValue: (dateValue: DateInputValue, timeValue: TimeInputValue) => ValueType;
+    parseDateInput: (instance: DateInputValue) => Date;
+    parseTimeInput: (instance: TimeInputValue) => Date;
     formatValueToDatePickerValue: (instance: ValueType) => DateTimePickerValue | undefined;
-    formatPickerValueToDateInput: (instance: DateTimePickerValue) => DateValue | undefined;
-    formatPickerValueToTimeInput: (instance: DateTimePickerValue) => TimeValue | undefined;
-    formatValueToDateInput: (instance: ValueType) => DateValue | undefined;
-    formatValueToTimeInput: (instance: ValueType) => TimeValue | undefined;
+    formatPickerValueToDateInput: (instance: DateTimePickerValue) => DateInputValue | undefined;
+    formatPickerValueToTimeInput: (instance: DateTimePickerValue) => TimeInputValue | undefined;
+    formatValueToDateInput: (instance: ValueType) => DateInputValue | undefined;
+    formatValueToTimeInput: (instance: ValueType) => TimeInputValue | undefined;
+    parseValue: (instance: ValueType) => Date | undefined;
 };
 export {};

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

@@ -1,8 +1,9 @@
 import { default as React } from 'react';
-import { DateValue, TimeValue } from './useDateTimeDraft';
+import { DateInputValue, TimeInputValue } from './useDateTimeDraft';
 import { useInputFieldController } from './useInputFieldController';
 import { useDateTimeFormats } from './useDateTimeFormats';
-type PropsType = Pick<ReturnType<typeof useDateTimeFormats>, 'parseTimeInput' | 'parseDateInput'> & Pick<ReturnType<typeof useInputFieldController>, 'doubleInputRef'> & {
+import { useDateUtils } from './useDateUtils';
+type PropsType = Pick<ReturnType<typeof useDateTimeFormats>, 'parseTimeInput' | 'parseDateInput'> & Pick<ReturnType<typeof useInputFieldController>, 'doubleInputRef'> & Pick<ReturnType<typeof useDateUtils>, 'extractDateInputValue' | 'extractTimeInputValue'> & {
     disablePicker?: boolean;
 };
 export declare function useDateTimePickerController(props: PropsType): {
@@ -50,8 +51,8 @@ export declare function useDateTimePickerController(props: PropsType): {
         }>;
     }>;
     dateTimePickerWrapperRef: React.RefObject<never>;
-    moveToInputtedDateInPicker: (instance: DateValue) => Promise<(void | undefined)[]>;
-    moveToInputtedTimeInPicker: (instance: TimeValue) => Promise<(void | undefined)[]>;
+    moveToInputtedDateInPicker: (instance: DateInputValue) => Promise<(void | undefined)[]>;
+    moveToInputtedTimeInPicker: (instance: TimeInputValue) => Promise<(void | undefined)[]>;
     showTimePicker: () => void;
     showDatePicker: () => void;
     clearDateTimeInputInPicker: () => void;

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

@@ -0,0 +1,17 @@
+import { DateInputValue, TimeInputValue } from './useDateTimeDraft';
+import { useDateTimeFormats } from './useDateTimeFormats';
+type PropsType = Pick<ReturnType<typeof useDateTimeFormats>, 'parseDateInput' | 'parseTimeInput'>;
+export declare function useDateUtils(props: PropsType): {
+    extractDateInputValue: (instance: DateInputValue) => {
+        year: number;
+        monthYear: string;
+        dayMonthYear: string;
+    };
+    extractTimeInputValue: (instance: TimeInputValue) => {
+        hours: number;
+        minutes: number;
+    };
+    isValidDateInput: (instance: string) => boolean;
+    isValidTimeInput: (instance: string) => boolean;
+};
+export {};

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

@@ -38,8 +38,8 @@ type PropsType = FieldProps & Pick<DateTimePickerV2Props, 'requestDaysData' | 'r
     disablePicker?: boolean;
 };
 export declare function useFormDateTimeFieldProvider(props: PropsType): {
-    dateValue: string | undefined;
-    timeValue: string | undefined;
+    dateInputValue: string | undefined;
+    timeInputValue: string | undefined;
     onCompleteDate: NonNullable<((value: string, maskRef: import('imask').InputMask<{
         [x: string]: unknown;
     }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{

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

@@ -4,8 +4,9 @@ import { useDateTimePickerController } from './useDateTimePickerController';
 import { useDateTimeDraft } from './useDateTimeDraft';
 import { useFormDateTimeFieldProvider } from './useFormDateTimeFieldProvider';
 import { useInputFieldController } from './useInputFieldController';
+import { useDateUtils } from './useDateUtils';
 export type DoubleInputItemProps = React.ComponentProps<typeof DoubleInputItem>;
-type PropsType = Pick<Parameters<typeof useFormDateTimeFieldProvider>[number], 'error' | 'disabled'> & Pick<ReturnType<typeof useDateTimePickerController>, 'moveToInputtedDateInPicker' | 'moveToInputtedTimeInPicker' | 'clearDateTimeInputInPicker' | 'openPicker' | 'closePicker' | 'switchingPicker' | 'getIsShowPicker' | 'showTimePicker' | 'showDatePicker'> & Pick<ReturnType<typeof useInputFieldController>, 'focusOnTimeField' | 'focusOnDateField' | 'checkFocusedDateInput' | 'checkFocusedTimeInput'> & Pick<ReturnType<typeof useDateTimeDraft>, 'setTimeInputValue' | 'setDateInputValue' | 'clearDateTimeValue' | 'isFullDateInput'>;
+type PropsType = Pick<Parameters<typeof useFormDateTimeFieldProvider>[number], 'error' | 'disabled'> & Pick<ReturnType<typeof useDateTimePickerController>, 'moveToInputtedDateInPicker' | 'moveToInputtedTimeInPicker' | 'clearDateTimeInputInPicker' | 'openPicker' | 'closePicker' | 'switchingPicker' | 'getIsShowPicker' | 'showTimePicker' | 'showDatePicker'> & Pick<ReturnType<typeof useInputFieldController>, 'focusOnTimeField' | 'focusOnDateField' | 'checkFocusedDateInput' | 'checkFocusedTimeInput'> & Pick<ReturnType<typeof useDateTimeDraft>, 'setTimeInputValue' | 'setDateInputValue' | 'clearDateTimeValue' | 'isFullDateInput'> & Pick<ReturnType<typeof useDateUtils>, 'isValidTimeInput' | 'isValidDateInput'>;
 export declare function useInputFieldProps(props: PropsType): {
     onCompleteDate: NonNullable<((value: string, maskRef: import('imask').InputMask<{
         [x: string]: unknown;

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

@@ -0,0 +1,11 @@
+import { TimeInputValue } from './useTimeDraft';
+import { useTimeFormats } from './useTimeFormats';
+type PropsType = Pick<ReturnType<typeof useTimeFormats>, 'parseTimeInput'>;
+export declare function useDateUtils(props: PropsType): {
+    extractTimeData: (instance: TimeInputValue) => {
+        hours: number;
+        minutes: number;
+    };
+    isValidTimeInput: (instance: string) => boolean;
+};
+export {};

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

@@ -3,8 +3,9 @@ import { DoubleInputItem } from '../../../components';
 import { useTimePickerController } from './useTimePickerController';
 import { useTimeDraft } from './useTimeDraft';
 import { useFormTimeFieldProvider } from './useFormTimeFieldProvider';
+import { useDateUtils } from './useDateUtils';
 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'>;
+type PropsType = Pick<Parameters<typeof useFormTimeFieldProvider>[number], 'error' | 'disabled'> & Pick<ReturnType<typeof useTimePickerController>, 'moveToInputtedTimeInPicker' | 'clearTimeInputInPicker' | 'closePicker' | 'switchingPicker'> & Pick<ReturnType<typeof useTimeDraft>, 'setTimeInputValue' | 'clearTimeValue'> & Pick<ReturnType<typeof useDateUtils>, 'isValidTimeInput'>;
 export declare function useInputFieldProps(props: PropsType): {
     onCompleteTime: NonNullable<((value: string, maskRef: import('imask').InputMask<{
         [x: string]: unknown;

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

@@ -1,8 +1,7 @@
 import { useFormTimeFieldProvider } from './useFormTimeFieldProvider';
 import { useTimeFormats } from './useTimeFormats';
 type UseFormDateTimeFieldProps = Parameters<typeof useFormTimeFieldProvider>[number];
-export type DateValue = string;
-export type TimeValue = string;
+export type TimeInputValue = string;
 type PropsType = Pick<UseFormDateTimeFieldProps, 'value'> & Pick<ReturnType<typeof useTimeFormats>, 'formatValueToTimeInput'>;
 export declare function useTimeDraft(props: PropsType): {
     timeInputValue: string | undefined;

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

@@ -1,14 +1,15 @@
 import { default as React } from 'react';
 import { TimePickerV2 } from '../../../..';
 import { useFormTimeFieldProvider, ValueType } from './useFormTimeFieldProvider';
-import { TimeValue } from './useTimeDraft';
+import { TimeInputValue } 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;
+    formatDateTimeInputToValue: (timeValue: TimeInputValue) => ValueType;
+    parseTimeInput: (instance: TimeInputValue) => Date;
+    parseValueTime: (instance: ValueType) => Date | undefined;
+    formatPickerValueToTimeInput: (instance: DateTimePickerValue) => TimeInputValue | undefined;
+    formatValueToTimeInput: (instance: ValueType) => TimeInputValue | undefined;
 };
 export {};

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

@@ -1,8 +1,8 @@
 import { default as React } from 'react';
-import { TimeValue } from './useTimeDraft';
+import { TimeInputValue } from './useTimeDraft';
 import { useInputFieldController } from './useInputFieldController';
-import { useTimeFormats } from './useTimeFormats';
-type PropsType = Pick<ReturnType<typeof useTimeFormats>, 'parseTimeInput'> & Pick<ReturnType<typeof useInputFieldController>, 'doubleInputRef'> & {
+import { useDateUtils } from './useDateUtils';
+type PropsType = Pick<ReturnType<typeof useInputFieldController>, 'doubleInputRef'> & Pick<ReturnType<typeof useDateUtils>, 'extractTimeData'> & {
     disablePicker?: boolean;
 };
 export declare function useTimePickerController(props: PropsType): {
@@ -24,7 +24,7 @@ export declare function useTimePickerController(props: PropsType): {
         }>;
     }>;
     timePickerWrapperRef: React.RefObject<never>;
-    moveToInputtedTimeInPicker: (instance: TimeValue) => Promise<(void | undefined)[]>;
+    moveToInputtedTimeInPicker: (instance: TimeInputValue) => Promise<(void | undefined)[]>;
     clearTimeInputInPicker: () => void;
     closePicker: () => void;
     switchingPicker: () => void;

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

@@ -2,7 +2,7 @@ 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'>;
+type PropsType = Pick<Parameters<typeof useFormTimeFieldProvider>[number], 'value'> & Pick<ReturnType<typeof useTimePickerController>, 'closePicker'> & Pick<ReturnType<typeof useTimeDraft>, 'setTimeInputValue'> & Pick<ReturnType<typeof useTimeFormats>, 'formatPickerValueToTimeInput' | 'parseValueTime'>;
 export declare function useTimePickerProps(props: PropsType): {
     time: string | undefined;
     onSubmitTime: (dateTime: string) => void;

package/dist/types/src/ui/formFields/dates/FormTimeRangeField/hooks/useDateUtils.d.ts

@@ -0,0 +1,10 @@
+import { useTimeRangeFormats } from './useTimeRangeFormats';
+import { ValueType } from './useFormTimeRangeFieldProvider';
+import { InputDateValue } from './useTimeRangeDraft';
+type PropsType = Pick<ReturnType<typeof useTimeRangeFormats>, 'parseTimeValue' | 'parseInputTime'>;
+export declare function useDateUtils(props: PropsType): {
+    sortValue: (instance: ValueType) => string[];
+    isAfterInputTime: (a: InputDateValue, b: InputDateValue) => boolean;
+    isValidTimeInput: (instance: string) => boolean;
+};
+export {};

package/dist/types/src/ui/formFields/dates/FormTimeRangeField/hooks/useFormTimeRangeFieldProvider.d.ts

@@ -228,7 +228,7 @@ export declare function useFormTimeRangeFieldProvider(props: PropsType): {
     fromDateInputRef: import('react').RefObject<HTMLInputElement>;
     toDateInputRef: import('react').RefObject<HTMLInputElement>;
     inputTimeFormat: string;
-    clearDateRange: () => void;
+    clearTimeRange: () => void;
     isErrorInputFields: boolean | undefined;
     isDisabledInputFields: boolean | undefined;
 };

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

@@ -3,9 +3,9 @@ import { DoubleInputItem } from '../../../components';
 import { useTimeRangeDraft } from './useTimeRangeDraft';
 import { useFormTimeRangeFieldProvider } from './useFormTimeRangeFieldProvider';
 import { useInputFieldController } from './useInputFieldController';
-import { useTimeRangeFormats } from './useTimeRangeFormats';
+import { useDateUtils } from './useDateUtils';
 export type DoubleInputItemProps = React.ComponentProps<typeof DoubleInputItem>;
-type PropsType = Pick<Parameters<typeof useFormTimeRangeFieldProvider>[number], 'error' | 'disabled'> & Pick<ReturnType<typeof useInputFieldController>, 'focusOnFromDateField' | 'focusOnToDateField'> & Pick<ReturnType<typeof useTimeRangeFormats>, 'parseInputTime'> & Pick<ReturnType<typeof useTimeRangeDraft>, 'setToTimeValue' | 'setFromTimeValue' | 'clearDateRangeValue' | 'isFullDateInput' | 'isFullCurrentDateInput' | 'getFromTimeValue' | 'getToTimeValue'>;
+type PropsType = Pick<Parameters<typeof useFormTimeRangeFieldProvider>[number], 'error' | 'disabled'> & Pick<ReturnType<typeof useInputFieldController>, 'focusOnFromDateField' | 'focusOnToDateField'> & Pick<ReturnType<typeof useTimeRangeDraft>, 'setToTimeValue' | 'setFromTimeValue' | 'clearTimeRangeValue' | 'isFullDateInput' | 'isFullCurrentDateInput' | 'getFromTimeValue' | 'getToTimeValue'> & Pick<ReturnType<typeof useDateUtils>, 'isAfterInputTime' | 'isValidTimeInput'>;
 export declare function useInputFieldProps(props: PropsType): {
     onCompleteTimeFrom: NonNullable<((value: string, maskRef: import('imask').InputMask<{
         [x: string]: unknown;
@@ -203,7 +203,7 @@ export declare function useInputFieldProps(props: PropsType): {
     }>, e?: InputEvent) => void) | ((value: string, maskRef: import('imask').InputMask<{
         [x: string]: unknown;
     }>, e?: InputEvent) => void) | undefined>;
-    clearDateRange: () => void;
+    clearTimeRange: () => void;
     isErrorInputFields: boolean | undefined;
     isDisabledInputFields: boolean | undefined;
 };

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

@@ -1,6 +1,7 @@
 import { useTimeRangeDraft } from './useTimeRangeDraft';
 import { useTimeRangeFormats } from './useTimeRangeFormats';
 import { useFormTimeRangeFieldProvider } from './useFormTimeRangeFieldProvider';
-type PropsType = Pick<Parameters<typeof useFormTimeRangeFieldProvider>[number], 'onChange' | 'value'> & Pick<ReturnType<typeof useTimeRangeDraft>, 'setFromTimeValue' | 'setToTimeValue' | 'fromTimeValue' | 'toTimeValue'> & Pick<ReturnType<typeof useTimeRangeFormats>, 'formatTimeInputToValue' | 'formatValueItemToTimeInput'>;
+import { useDateUtils } from './useDateUtils';
+type PropsType = Pick<Parameters<typeof useFormTimeRangeFieldProvider>[number], 'onChange' | 'value'> & Pick<ReturnType<typeof useTimeRangeDraft>, 'setFromTimeValue' | 'setToTimeValue' | 'fromTimeValue' | 'toTimeValue'> & Pick<ReturnType<typeof useTimeRangeFormats>, 'formatTimeInputToValue' | 'formatValueItemToTimeInput' | 'parseTimeValue'> & Pick<ReturnType<typeof useDateUtils>, 'sortValue'>;
 export declare function useSyncDateTimeValues(props: PropsType): void;
 export {};

package/dist/types/src/ui/formFields/dates/FormTimeRangeField/hooks/useTimeRangeDraft.d.ts

@@ -10,7 +10,7 @@ export declare function useTimeRangeDraft(props: PropsType): {
     setToTimeValue: import('react').Dispatch<import('react').SetStateAction<string | undefined>>;
     getFromTimeValue: () => string | undefined;
     getToTimeValue: () => string | undefined;
-    clearDateRangeValue: () => void;
+    clearTimeRangeValue: () => void;
     isFullDateInput: (fromDate?: InputDateValue, toDate?: InputDateValue) => boolean;
     isFullCurrentDateInput: () => boolean;
 };

package/dist/types/src/ui/formFields/dates/FormTimeRangeField/hooks/useTimeRangeFormats.d.ts

@@ -5,5 +5,6 @@ export declare function useTimeRangeFormats(props: PropsType): {
     formatTimeInputToValue: (instance: InputDateValue) => string;
     formatValueItemToTimeInput: (instance?: ValueItemType) => string | undefined;
     parseInputTime: (instance: InputDateValue) => Date;
+    parseTimeValue: (instance?: ValueItemType) => Date | undefined;
 };
 export {};

package/package.json

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