indicator-ui 1.1.8 → 1.1.10

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

@@ -1,11 +1,11 @@
 import { useFormDateFieldProvider } from './useFormDateFieldProvider';
 import { useDateFormats } from './useDateFormats';
 type UseFormDateFieldProps = Parameters<typeof useFormDateFieldProvider>[number];
-export type InputDateValue = string;
+export type DateInputValue = string | undefined;
 type PropsType = Pick<UseFormDateFieldProps, 'value'> & Pick<ReturnType<typeof useDateFormats>, 'formatValueToDateInput'>;
 export declare function useDateDraft(props: PropsType): {
-    dateInputValue: string | undefined;
-    setDateInputValue: import('react').Dispatch<import('react').SetStateAction<string | undefined>>;
+    dateInputValue: DateInputValue;
+    setDateInputValue: import('react').Dispatch<import('react').SetStateAction<DateInputValue>>;
     isFullDateInput: () => boolean;
     clearDateValue: () => void;
 };

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

@@ -1,21 +1,22 @@
 import { default as React } from 'react';
 import { DatePickerV2 } from '../../../..';
 import { useFormDateFieldProvider, ValueType } from './useFormDateFieldProvider';
-import { InputDateValue } from './useDateDraft';
+import { DateInputValue } from './useDateDraft';
+type ParsedDate = Date | undefined;
 type DatePickerV2Props = React.ComponentProps<typeof DatePickerV2>;
-type DatePickerValue = Parameters<NonNullable<DatePickerV2Props['onChangeDate']>>[0];
+type DatePickerValue = DatePickerV2Props['date'];
 type PropsType = Required<Pick<Parameters<typeof useFormDateFieldProvider>[number], 'outFormat' | 'inputDateFormat'>>;
 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) => {
+    formatDateInputToValue: (instance: DateInputValue) => ValueType;
+    parseDateInput: (instance: DateInputValue) => ParsedDate;
+    parseValue: (instance: ValueType) => ParsedDate;
+    formatValueToDateInput: (instance: ValueType) => DateInputValue;
+    formatPickerValueToDateInput: (instance: DatePickerValue) => DateInputValue;
+    formatValueToDatePickerValue: (instance: ValueType) => DatePickerValue;
+    extractDateInputToPickerInputs: (instance: DateInputValue) => {
         year: number;
         monthYear: string;
         dayMonthYear: string;
-    };
+    } | undefined;
 };
 export {};

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

@@ -1,5 +1,5 @@
 import { default as React } from 'react';
-import { InputDateValue } from './useDateDraft';
+import { DateInputValue } from './useDateDraft';
 import { useInputFieldController } from './useInputFieldController';
 import { useDateFormats } from './useDateFormats';
 type PropsType = Pick<ReturnType<typeof useDateFormats>, 'extractDateInputToPickerInputs'> & Pick<ReturnType<typeof useInputFieldController>, 'doubleInputRef'> & {
@@ -39,7 +39,7 @@ export declare function useDatePickerController(props: PropsType): {
         }>;
     }>;
     datePickerWrapperRef: React.RefObject<never>;
-    moveToInputtedDateInPicker: (instance: InputDateValue) => Promise<(void | undefined)[]>;
+    moveToInputtedDateInPicker: (instance: DateInputValue) => Promise<(void | undefined)[]> | undefined;
     clearDateInputInPicker: () => void;
     switchingPicker: () => void;
     closePicker: () => void;

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

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

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

@@ -29,7 +29,7 @@ type PropsType = FieldProps & Pick<DatePickerV2Props, 'requestDaysData' | 'reque
     disablePicker?: boolean;
 };
 export declare function useFormDateFieldProvider(props: PropsType): {
-    dateInputValue: string | undefined;
+    dateInputValue: import('./useDateDraft').DateInputValue;
     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/FormDateRangeField/hooks/useDateRangeDraft.d.ts

@@ -1,17 +1,17 @@
 import { useFormDateRangeFieldProvider } from './useFormDateRangeFieldProvider';
 import { useDateRangeFormats } from './useDateRangeFormats';
-export type InputDateValue = string | undefined;
+export type DateRangeInputValue = 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: InputDateValue;
-    toDateValue: InputDateValue;
-    setFromDateValue: import('react').Dispatch<import('react').SetStateAction<InputDateValue>>;
-    setToDateValue: import('react').Dispatch<import('react').SetStateAction<InputDateValue>>;
-    getFromDateValue: () => InputDateValue;
-    getToDateValue: () => InputDateValue;
+    fromDateValue: DateRangeInputValue;
+    toDateValue: DateRangeInputValue;
+    setFromDateValue: import('react').Dispatch<import('react').SetStateAction<DateRangeInputValue>>;
+    setToDateValue: import('react').Dispatch<import('react').SetStateAction<DateRangeInputValue>>;
+    getFromDateValue: () => DateRangeInputValue;
+    getToDateValue: () => DateRangeInputValue;
     clearDateRangeValue: () => void;
-    isFullDateInput: (fromDate: InputDateValue, toDate: InputDateValue) => boolean;
+    isFullDateInput: (fromDate: DateRangeInputValue, toDate: DateRangeInputValue) => boolean;
     isFullCurrentDateInput: () => boolean;
 };
 export {};

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

@@ -1,15 +1,17 @@
 import { default as React } from 'react';
-import { DatePickerV2 } from '../../../..';
+import { DateRangePickerV2 } 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];
+import { DateRangeInputValue } from './useDateRangeDraft';
+type ParsedDate = Date | undefined;
+type DatePickerValue = React.ComponentProps<typeof DateRangePickerV2>['dateRange'];
+type DatePickerValueItem = NonNullable<DatePickerValue>[number];
 type PropsType = Required<Pick<Parameters<typeof useFormDateRangeFieldProvider>[number], 'outFormat' | 'inputDateFormat'>>;
 export declare function useDateRangeFormats(props: PropsType): {
-    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;
+    formatDateInputToValue: (instance: NonNullable<DateRangeInputValue>) => ValueItemType | undefined;
+    formatValueItemToDateInput: (instance: ValueItemType) => DateRangeInputValue;
+    formatValueToDatePickerValue: (instance: ValueType) => DatePickerValue;
+    parseInputDate: (instance: NonNullable<DateRangeInputValue>) => ParsedDate;
+    parseValue: (instance: ValueItemType) => ParsedDate;
+    formatDatePickerToDateInput: (instance?: DatePickerValueItem) => DateRangeInputValue;
 };
 export {};

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

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

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

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

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

@@ -33,8 +33,8 @@ type PropsType = FieldProps & Pick<DateRangePickerV2Props, 'requestedDaysData' |
     disablePicker?: boolean;
 };
 export declare function useFormDateRangeFieldProvider(props: PropsType): {
-    fromDateValue: import('./useDateRangeDraft').InputDateValue;
-    toDateValue: import('./useDateRangeDraft').InputDateValue;
+    fromDateValue: import('./useDateRangeDraft').DateRangeInputValue;
+    toDateValue: import('./useDateRangeDraft').DateRangeInputValue;
     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/FormDateTimeField/hooks/useDateTimeDraft.d.ts

@@ -1,14 +1,14 @@
 import { useFormDateTimeFieldProvider } from './useFormDateTimeFieldProvider';
 import { useDateTimeFormats } from './useDateTimeFormats';
 type UseFormDateTimeFieldProps = Parameters<typeof useFormDateTimeFieldProvider>[number];
-export type DateInputValue = string;
-export type TimeInputValue = string;
+export type DateInputValue = string | undefined;
+export type TimeInputValue = string | undefined;
 type PropsType = Pick<UseFormDateTimeFieldProps, 'value'> & Pick<ReturnType<typeof useDateTimeFormats>, 'formatValueToDateInput' | 'formatValueToTimeInput'>;
 export declare function useDateTimeDraft(props: PropsType): {
-    dateInputValue: string | undefined;
-    timeInputValue: string | undefined;
-    setDateInputValue: import('react').Dispatch<import('react').SetStateAction<string | undefined>>;
-    setTimeInputValue: import('react').Dispatch<import('react').SetStateAction<string | undefined>>;
+    dateInputValue: DateInputValue;
+    timeInputValue: TimeInputValue;
+    setDateInputValue: import('react').Dispatch<import('react').SetStateAction<DateInputValue>>;
+    setTimeInputValue: import('react').Dispatch<import('react').SetStateAction<TimeInputValue>>;
     clearDateTimeValue: () => void;
     isFullDateInput: () => boolean;
 };

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

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

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

@@ -51,8 +51,8 @@ export declare function useDateTimePickerController(props: PropsType): {
         }>;
     }>;
     dateTimePickerWrapperRef: React.RefObject<never>;
-    moveToInputtedDateInPicker: (instance: DateInputValue) => Promise<(void | undefined)[]>;
-    moveToInputtedTimeInPicker: (instance: TimeInputValue) => Promise<(void | undefined)[]>;
+    moveToInputtedDateInPicker: (instance: DateInputValue) => Promise<(void | undefined)[]> | undefined;
+    moveToInputtedTimeInPicker: (instance: TimeInputValue) => Promise<(void | undefined)[]> | undefined;
     showTimePicker: () => void;
     showDatePicker: () => void;
     clearDateTimeInputInPicker: () => void;

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

@@ -6,12 +6,12 @@ export declare function useDateUtils(props: PropsType): {
         year: number;
         monthYear: string;
         dayMonthYear: string;
-    };
+    } | undefined;
     extractTimeInputValue: (instance: TimeInputValue) => {
         hours: number;
         minutes: number;
-    };
-    isValidDateInput: (instance: string) => boolean;
-    isValidTimeInput: (instance: string) => boolean;
+    } | undefined;
+    isValidDateInput: (instance: DateInputValue) => boolean;
+    isValidTimeInput: (instance: TimeInputValue) => boolean;
 };
 export {};

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

@@ -39,8 +39,8 @@ type PropsType = FieldProps & Pick<DateTimePickerV2Props, 'requestDaysData' | 'r
     disablePicker?: boolean;
 };
 export declare function useFormDateTimeFieldProvider(props: PropsType): {
-    dateInputValue: string | undefined;
-    timeInputValue: string | undefined;
+    dateInputValue: import('./useDateTimeDraft').DateInputValue;
+    timeInputValue: import('./useDateTimeDraft').TimeInputValue;
     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/FormTimeField/hooks/useDateUtils.d.ts

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

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

@@ -29,7 +29,7 @@ type PropsType = FieldProps & {
     disablePicker?: boolean;
 };
 export declare function useFormTimeFieldProvider(props: PropsType): {
-    timeInputValue: string | undefined;
+    timeInputValue: import('./useTimeDraft').TimeInputValue;
     onCompleteTime: 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/FormTimeField/hooks/useTimeDraft.d.ts

@@ -1,11 +1,11 @@
 import { useFormTimeFieldProvider } from './useFormTimeFieldProvider';
 import { useTimeFormats } from './useTimeFormats';
 type UseFormDateTimeFieldProps = Parameters<typeof useFormTimeFieldProvider>[number];
-export type TimeInputValue = string;
+export type TimeInputValue = string | undefined;
 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>>;
+    timeInputValue: TimeInputValue;
+    setTimeInputValue: import('react').Dispatch<import('react').SetStateAction<TimeInputValue>>;
     clearTimeValue: () => void;
     isFullDateInput: () => boolean;
 };

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

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

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

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

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

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

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

@@ -28,8 +28,8 @@ type PropsType = FieldProps & {
     onDismissClick?: DoubleInputItemProps['onDismissClick'] | false;
 };
 export declare function useFormTimeRangeFieldProvider(props: PropsType): {
-    fromTimeValue: string | undefined;
-    toTimeValue: string | undefined;
+    fromTimeValue: import('./useTimeRangeDraft').TimeInputValue;
+    toTimeValue: import('./useTimeRangeDraft').TimeInputValue;
     onCompleteTimeTo: 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/FormTimeRangeField/hooks/{useSyncDateTimeValues.d.ts → useSyncTimeRangeValues.d.ts}

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

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

@@ -1,17 +1,17 @@
 import { useFormTimeRangeFieldProvider } from './useFormTimeRangeFieldProvider';
 import { useTimeRangeFormats } from './useTimeRangeFormats';
-export type InputDateValue = string;
+export type TimeInputValue = string | undefined;
 type UseFormDateRangeFieldProps = Parameters<typeof useFormTimeRangeFieldProvider>[number];
 type PropsType = Pick<ReturnType<typeof useTimeRangeFormats>, 'formatValueItemToTimeInput'> & Pick<UseFormDateRangeFieldProps, 'value'>;
 export declare function useTimeRangeDraft(props: PropsType): {
-    fromTimeValue: string | undefined;
-    toTimeValue: string | undefined;
-    setFromTimeValue: import('react').Dispatch<import('react').SetStateAction<string | undefined>>;
-    setToTimeValue: import('react').Dispatch<import('react').SetStateAction<string | undefined>>;
-    getFromTimeValue: () => string | undefined;
-    getToTimeValue: () => string | undefined;
+    fromTimeValue: TimeInputValue;
+    toTimeValue: TimeInputValue;
+    setFromTimeValue: import('react').Dispatch<import('react').SetStateAction<TimeInputValue>>;
+    setToTimeValue: import('react').Dispatch<import('react').SetStateAction<TimeInputValue>>;
+    getFromTimeValue: () => TimeInputValue;
+    getToTimeValue: () => TimeInputValue;
     clearTimeRangeValue: () => void;
-    isFullDateInput: (fromDate?: InputDateValue, toDate?: InputDateValue) => boolean;
+    isFullDateInput: (fromDate: TimeInputValue, toDate: TimeInputValue) => boolean;
     isFullCurrentDateInput: () => boolean;
 };
 export {};

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

@@ -1,10 +1,11 @@
 import { useFormTimeRangeFieldProvider, ValueItemType } from './useFormTimeRangeFieldProvider';
-import { InputDateValue } from './useTimeRangeDraft';
+import { TimeInputValue } from './useTimeRangeDraft';
+type ParsedDate = Date | undefined;
 type PropsType = Required<Pick<Parameters<typeof useFormTimeRangeFieldProvider>[number], 'outFormat' | 'inputTimeFormat'>>;
 export declare function useTimeRangeFormats(props: PropsType): {
-    formatTimeInputToValue: (instance: InputDateValue) => string;
-    formatValueItemToTimeInput: (instance?: ValueItemType) => string | undefined;
-    parseInputTime: (instance: InputDateValue) => Date;
-    parseTimeValue: (instance?: ValueItemType) => Date | undefined;
+    formatTimeInputToValue: (instance: TimeInputValue) => ValueItemType | undefined;
+    formatValueItemToTimeInput: (instance: ValueItemType) => TimeInputValue;
+    parseTimeInputValue: (instance: TimeInputValue) => ParsedDate;
+    parseTimeValue: (instance: ValueItemType) => ParsedDate;
 };
 export {};

package/dist/types/src/ui/formFields/dates/utils/safeDate.d.ts

@@ -0,0 +1,5 @@
+import { DateArg } from 'date-fns';
+export declare function safeParse(str: string, fmt: string, ref: Date): Date | undefined;
+export declare function safeParseISO(str: string): Date | undefined;
+export declare function safeFormat(date: DateArg<Date>, fmt: string): string | undefined;
+export declare function safeFormatISO(date: DateArg<Date>): string | undefined;

package/package.json

@@ -11,7 +11,7 @@
     "react-components",
     "ui-kit"
   ],
-  "version": "1.1.8",
+  "version": "1.1.10",
   "exports": {
     ".": {
       "types": "./dist/types/index.d.ts",
@@ -50,9 +50,11 @@
     "@types/react-dom": ">=18.0.0",
     "@vitejs/plugin-react": "^5.1.2",
     "ajv": "^8.17.1",
+    "baseline-browser-mapping": "^2.10.9",
     "clsx": "^2.1.1",
     "date-fns": "^4.1.0",
     "date-fns-tz": "^3.2.0",
+    "gl-matrix": "^3.4.4",
     "gsap": "^3.13.0",
     "jest": "^29.7.0",
     "mathjs": "^14.5.3",
@@ -66,17 +68,15 @@
     "tsc-alias": "^1.8.10",
     "tslib": "^2.8.1",
     "typescript": "^5.9.3",
+    "uuid": "^13.0.0",
     "vite": "^7.2.7",
     "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",
-    "gl-matrix": "^3.4.4",
-    "uuid": "^13.0.0"
+    "vite-plugin-virtual-html": "^1.2.7"
   },
   "peerDependencies": {
     "react": ">=18.0.0",
     "react-dom": ">=18.0.0"
-  },
-  "dependencies": {}
+  }
 }