indicator-ui 1.0.51 → 1.1.0

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

@@ -0,0 +1,11 @@
+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'>;
+export declare function useDateRangePickerProps(props: PropsType): {
+    dateRange: string[] | undefined;
+    onChooseDateRange: (dateRange: string[]) => void;
+    onChangeDateRange: (dateRange: string[]) => void;
+};
+export {};

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

@@ -0,0 +1,43 @@
+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'>;
+export declare function useDateTimePickerController(props: PropsType): {
+    dateTimePickerRef: React.RefObject<Pick<{
+        setInput: <K extends "year" | "monthYear" | "dayMonthYear">(key: K, instance: Partial<Partial<{
+            year: number;
+            monthYear: string;
+            dayMonthYear: string;
+        }>>[K]) => void;
+        createCommitDateRange: (prev: string[] | undefined) => NonNullable<string[] | undefined>;
+        clearDateInput: () => void;
+        initViewYear: number | undefined;
+        initViewMonthYear: string | undefined;
+        initViewDayMonthYear: string | undefined;
+    }, "clearDateInput" | "setInput" | "createCommitDateRange"> & {
+        dateBaseRef: React.RefObject<{
+            daysFeedRef: React.RefObject<{
+                scrollToDayMonth: (instance: import('../../../../datePickersV2/hooks/feeds/days/useDaysFeed').Day) => Promise<void>;
+                element: HTMLDivElement;
+            }>;
+            monthsFeedRef: React.RefObject<{
+                scrollToMonth: (instance: import('../../../../datePickersV2/hooks/feeds/month/useMonthsFeed').Month) => void;
+                element: HTMLDivElement;
+            }>;
+            yearsFeedRef: React.RefObject<{
+                scrollToYear: (instance: import('../../../../datePickersV2/hooks/feeds/year/useYearsFeed').Year) => void;
+                element: HTMLDivElement;
+            }>;
+        }>;
+    }>;
+    dateTimePickerWrapperRef: React.RefObject<never>;
+    moveToInputtedDateInPicker: (instance: InputDateValue) => Promise<(void | undefined)[]>;
+    clearDateRangeInputInPicker: () => void;
+    closePicker: () => void;
+    openPicker: () => void;
+    switchingPicker: () => void;
+    getIsShowPicker: () => boolean;
+    getPickerInitStyle: () => React.CSSProperties;
+};
+export {};

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

@@ -0,0 +1,176 @@
+import { default as React } from 'react';
+import { FieldPropsType } from '../../../../../hooks';
+import { DateRangePickerV2 } from '../../../..';
+import { DoubleInputItemProps } from './useInputFieldProps';
+type DateRangePickerV2Props = React.ComponentProps<typeof DateRangePickerV2>;
+export type ValueItemType = string;
+export type ValueBaseType = Array<ValueItemType>;
+type FieldProps = FieldPropsType<ValueBaseType>;
+export type ValueType = FieldProps['value'];
+type PropsType = FieldProps & Pick<DateRangePickerV2Props, 'requestedDaysData' | 'requestDaysData'> & {
+    /**
+     * Формат даты ввода пользователя.
+     *
+     * ---
+     * Для ознакомления с обозначениями {@link DATE_IMASK_BLOCKS}
+     * */
+    inputDateFormat?: string;
+    /**
+     * Формат даты (понимаемый `date-fns`), которая будет хранится в `value`.
+     *
+     * Пример: `"yyyy-MM-dd'T'HH:mm:ssXXX"`.
+     * */
+    outFormat?: string | 'iso';
+    fromPlaceholder?: DoubleInputItemProps['placeholder'];
+    toPlaceholder?: DoubleInputItemProps['placeholder'];
+    fromHintText?: DoubleInputItemProps['hintText'];
+    toHintText?: DoubleInputItemProps['hintText'];
+    fromIcon?: DoubleInputItemProps['icon'];
+    toIcon?: DoubleInputItemProps['icon'];
+    disabled?: DoubleInputItemProps['disabled'];
+    pickerSubtitle?: DateRangePickerV2Props['subtitle'];
+};
+export declare function useFormDateRangeFieldProvider(props: PropsType): {
+    fromDateValue: string | undefined;
+    toDateValue: string | undefined;
+    onCompleteDateTo: 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>;
+    onCompleteDateFrom: 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>;
+    dateTimePickerRef: React.RefObject<Pick<{
+        setInput: <K extends "year" | "monthYear" | "dayMonthYear">(key: K, instance: Partial<Partial<{
+            year: number;
+            monthYear: string;
+            dayMonthYear: string;
+        }>>[K]) => void;
+        createCommitDateRange: (prev: string[] | undefined) => NonNullable<string[] | undefined>;
+        clearDateInput: () => void;
+        initViewYear: number | undefined;
+        initViewMonthYear: string | undefined;
+        initViewDayMonthYear: string | undefined;
+    }, "clearDateInput" | "setInput" | "createCommitDateRange"> & {
+        dateBaseRef: React.RefObject<{
+            daysFeedRef: React.RefObject<{
+                scrollToDayMonth: (instance: import('../../../../datePickersV2/hooks/feeds/days/useDaysFeed').Day) => Promise<void>;
+                element: HTMLDivElement;
+            }>;
+            monthsFeedRef: React.RefObject<{
+                scrollToMonth: (instance: import('../../../../datePickersV2/hooks/feeds/month/useMonthsFeed').Month) => void;
+                element: HTMLDivElement;
+            }>;
+            yearsFeedRef: React.RefObject<{
+                scrollToYear: (instance: import('../../../../datePickersV2/hooks/feeds/year/useYearsFeed').Year) => void;
+                element: HTMLDivElement;
+            }>;
+        }>;
+    }>;
+    dateTimePickerWrapperRef: React.RefObject<never>;
+    doubleInputRef: React.RefObject<HTMLDivElement>;
+    fromDateInputRef: React.RefObject<HTMLInputElement>;
+    toDateInputRef: React.RefObject<HTMLInputElement>;
+    inputDateFormat: string;
+    dateRange: string[] | undefined;
+    onChangeDateRange: (dateRange: string[]) => void;
+    onChooseDateRange: (dateRange: string[]) => void;
+    onClickToDateField: React.MouseEventHandler<HTMLInputElement>;
+    onClickFromDateField: React.MouseEventHandler<HTMLInputElement>;
+    clearDateRange: () => void;
+    isErrorInputFields: boolean | undefined;
+    isDisabledInputFields: boolean | undefined;
+    getPickerInitStyle: () => React.CSSProperties;
+};
+export {};

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

@@ -0,0 +1,9 @@
+export declare function useInputFieldController(): {
+    doubleInputRef: import('react').RefObject<HTMLDivElement>;
+    toDateInputRef: import('react').RefObject<HTMLInputElement>;
+    fromDateInputRef: import('react').RefObject<HTMLInputElement>;
+    focusOnFromDateField: () => void;
+    focusOnToDateField: () => void;
+    checkFocusedFromDateInput: () => boolean;
+    checkFocusedToDateInput: () => boolean;
+};

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

@@ -0,0 +1,115 @@
+import { default as React } from 'react';
+import { DoubleInputItem } from '../../../components';
+import { useDateTimePickerController } from './useDateTimePickerController';
+import { useDateRangeDraft } from './useDateRangeDraft';
+import { useFormDateRangeFieldProvider } from './useFormDateRangeFieldProvider';
+import { useInputFieldController } from './useInputFieldController';
+import { useDateRangeFormats } from './useDateRangeFormats';
+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'>;
+export declare function useInputFieldProps(props: PropsType): {
+    onCompleteDateFrom: 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>;
+    onCompleteDateTo: 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>;
+    onClickFromDateField: React.MouseEventHandler<HTMLInputElement>;
+    onClickToDateField: React.MouseEventHandler<HTMLInputElement>;
+    clearDateRange: () => void;
+    isErrorInputFields: boolean | undefined;
+    isDisabledInputFields: boolean | undefined;
+};
+export {};

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

@@ -0,0 +1,6 @@
+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'>;
+export declare function useSyncDateTimeValues(props: PropsType): void;
+export {};

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,15 @@
+import { useFormDateTimeFieldProvider } from './useFormDateTimeFieldProvider';
+import { useDateTimeFormats } from './useDateTimeFormats';
+type UseFormDateTimeFieldProps = Parameters<typeof useFormDateTimeFieldProvider>[number];
+export type DateValue = string;
+export type TimeValue = string;
+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>>;
+    clearDateTimeValue: () => void;
+    isFullDateInput: () => boolean;
+};
+export {};

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

@@ -0,0 +1,18 @@
+import { default as React } from 'react';
+import { DateTimePickerV2 } from '../../../..';
+import { useFormDateTimeFieldProvider, ValueType } from './useFormDateTimeFieldProvider';
+import { DateValue, TimeValue } 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;
+    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;
+};
+export {};

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

@@ -0,0 +1,62 @@
+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'>;
+export declare function useDateTimePickerController(props: PropsType): {
+    dateTimePickerRef: React.RefObject<Pick<{
+        pickerState: "time" | "date-main";
+        switchToDateMainPicker: () => void;
+        switchToTimePicker: () => void;
+        getPickerState: () => "time" | "date-main";
+    }, "switchToDateMainPicker" | "switchToTimePicker" | "getPickerState"> & Pick<{
+        createCommitDateTime: (prev: string | undefined) => NonNullable<string | undefined>;
+        createCommitDateTimeWithoutClearing: (prev: string | undefined) => NonNullable<string | undefined>;
+        setInput: <K extends "year" | "monthYear" | "dayMonthYear" | "hours" | "minutes">(key: K, instance: Partial<Partial<{
+            year: number;
+            monthYear: string;
+            dayMonthYear: string;
+            hours: number;
+            minutes: number;
+        }>>[K]) => void;
+        clearDateInput: () => void;
+        initViewYear: number | undefined;
+        initViewMonthYear: string | undefined;
+        initViewDayMonthYear: string | undefined;
+        initViewHours: number | undefined;
+        initViewMinutes: number | undefined;
+        getPreviewDate: (instance: string | undefined) => string | undefined;
+        getPreviewTime: (instance: string | undefined) => string | undefined;
+    }, "clearDateInput" | "setInput" | "createCommitDateTimeWithoutClearing" | "createCommitDateTime"> & {
+        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>;
+        }>;
+        dateBaseRef: React.RefObject<{
+            daysFeedRef: React.RefObject<{
+                scrollToDayMonth: (instance: import('../../../../datePickersV2/hooks/feeds/days/useDaysFeed').Day) => Promise<void>;
+                element: HTMLDivElement;
+            }>;
+            monthsFeedRef: React.RefObject<{
+                scrollToMonth: (instance: import('../../../../datePickersV2/hooks/feeds/month/useMonthsFeed').Month) => void;
+                element: HTMLDivElement;
+            }>;
+            yearsFeedRef: React.RefObject<{
+                scrollToYear: (instance: import('../../../../datePickersV2/hooks/feeds/year/useYearsFeed').Year) => void;
+                element: HTMLDivElement;
+            }>;
+        }>;
+    }>;
+    dateTimePickerWrapperRef: React.RefObject<never>;
+    moveToInputtedDateInPicker: (instance: DateValue) => Promise<(void | undefined)[]>;
+    moveToInputtedTimeInPicker: (instance: TimeValue) => Promise<(void | undefined)[]>;
+    showTimePicker: () => void;
+    showDatePicker: () => void;
+    clearDateTimeInputInPicker: () => void;
+    closePicker: () => void;
+    switchingPicker: () => void;
+    openPicker: () => void;
+    getIsShowPicker: () => boolean;
+    getPickerInitStyle: () => React.CSSProperties;
+};
+export {};

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

@@ -0,0 +1,11 @@
+import { useDateTimeDraft } from './useDateTimeDraft';
+import { useFormDateTimeFieldProvider } from './useFormDateTimeFieldProvider';
+import { useDateTimePickerController } from './useDateTimePickerController';
+import { useDateTimeFormats } from './useDateTimeFormats';
+type PropsType = Pick<Parameters<typeof useFormDateTimeFieldProvider>[number], 'value'> & Pick<ReturnType<typeof useDateTimePickerController>, 'closePicker'> & Pick<ReturnType<typeof useDateTimeDraft>, 'setDateInputValue' | 'setTimeInputValue'> & Pick<ReturnType<typeof useDateTimeFormats>, 'formatPickerValueToTimeInput' | 'formatPickerValueToDateInput'>;
+export declare function useDateTimePickerProps(props: PropsType): {
+    dateTime: string | undefined;
+    onSubmitDateTime: (dateTime: string) => void;
+    onSubmitDate: (dateTime: string) => void;
+};
+export {};