@elliemae/ds-controlled-form 2.4.1-rc.5 → 2.4.1-rc.9

package/types/date-time-picker/config/useControlledDateTimePicker.d.ts

@@ -1,2 +1,18 @@
-import type { DateTimePickerPropsT, ControlledDateTimePickerContextT } from '../index.d';
-export declare const useControlledDateTimePicker: (props: Partial<DateTimePickerPropsT>) => ControlledDateTimePickerContextT;
+import React from 'react';
+import { useGetFlags } from './useGetFlags';
+import { useGetReferences } from './useGetReferences';
+import { useRelevantValueFromProps } from './useRelevantValueFromProps';
+import { useGetPropsBasedOnType } from './useGetPropsBasedOnType';
+import { useGetDestructuredValues } from './useGetDestructuredValues';
+import { useChangeHandlers } from './useChangeHandlers';
+import { useGlobalKeyHandlers } from './useGlobalKeyHandlers';
+import type { DSControlledDateTimePickerT } from '../propTypes';
+export declare type LatestInteractionRegion = 'calendar-days' | 'calendar-head' | 'timewheel' | 'date-inputs' | 'time-inputs' | 'clear-btn' | '';
+export declare type ControlledDateTimePickerContextT = ReturnType<typeof useGetFlags> & ReturnType<typeof useGetReferences> & ReturnType<typeof useGetPropsBasedOnType> & ReturnType<typeof useRelevantValueFromProps> & ReturnType<typeof useGetDestructuredValues> & ReturnType<typeof useChangeHandlers> & ReturnType<typeof useGlobalKeyHandlers> & {
+    props: DSControlledDateTimePickerT.InternalProps;
+    ariaCurrentValueForInputs: string;
+    dataAttrs: Record<string, string>;
+    latestInteractionRegion: LatestInteractionRegion;
+    setLatestInteractionRegion: React.Dispatch<React.SetStateAction<LatestInteractionRegion>>;
+};
+export declare const useControlledDateTimePicker: (props: DSControlledDateTimePickerT.Props) => ControlledDateTimePickerContextT;

package/types/date-time-picker/config/useGetDestructuredValues.d.ts

@@ -1,4 +1,30 @@
-import type { useGetDestructuredDateValuesAT, useGetDestructuredDateValuesRT, useGetDestructuredTimeValuesAT, useGetDestructuredTimeValuesRT, useGetDestructuredValuesAT, useGetDestructuredValuesRT } from '../index.d';
-export declare const useGetDestructuredDateValues: ({ date, dateTime, isDateTimeSelector, }: useGetDestructuredDateValuesAT) => useGetDestructuredDateValuesRT;
-export declare const useGetDestructuredTimeValues: ({ time, dateTime, isDateTimeSelector, }: useGetDestructuredTimeValuesAT) => useGetDestructuredTimeValuesRT;
-export declare const useGetDestructuredValues: ({ date, time, dateTime, isDateTimeSelector, }: useGetDestructuredValuesAT) => useGetDestructuredValuesRT;
+import { useGetFlags } from './useGetFlags';
+import { useGetPropsBasedOnType } from './useGetPropsBasedOnType';
+declare type UseGetDestructuredDateValues = (config: ReturnType<typeof useGetPropsBasedOnType> & ReturnType<typeof useGetFlags>) => {
+    month: string;
+    day: string;
+    year: string;
+    monthNum: number;
+    dayNum: number;
+    yearNum: number;
+    announcedMonth: string;
+    announcedDay: string;
+    announcedYear: string;
+    announcedDateValues: string;
+};
+export declare const useGetDestructuredDateValues: UseGetDestructuredDateValues;
+declare type UseGetDestructuredTimeValues = (config: ReturnType<typeof useGetPropsBasedOnType> & ReturnType<typeof useGetFlags>) => {
+    hours: string;
+    minutes: string;
+    meridiem: string;
+    hoursNum: number;
+    minutesNum: number;
+    announcedHours: string;
+    announcedMinutes: string;
+    announcedMeridiem: string;
+    announcedTimeValues: string;
+};
+export declare const useGetDestructuredTimeValues: UseGetDestructuredTimeValues;
+declare type UseGetDestructuredValues = (config: ReturnType<typeof useGetPropsBasedOnType> & ReturnType<typeof useGetFlags>) => ReturnType<typeof useGetDestructuredDateValues> & ReturnType<typeof useGetDestructuredTimeValues>;
+export declare const useGetDestructuredValues: UseGetDestructuredValues;
+export {};

package/types/date-time-picker/config/useGetFlags.d.ts

@@ -0,0 +1,27 @@
+import type { DSControlledDateTimePickerT } from '../propTypes';
+export declare const useGetFlags: (props: DSControlledDateTimePickerT.InternalProps) => {
+    hideDatePicker: boolean;
+    hideTimePicker: boolean;
+    isDateSelector: boolean;
+    isTimeSelector: boolean;
+    isDateTimeSelector: boolean;
+    isWithDateInputsOnly: boolean;
+    isWithTimeInputsOnly: boolean;
+    autoFocusHourInput: boolean;
+    autoFocusHourTimeWheel: boolean;
+    hideDate: boolean;
+    hideTime: boolean;
+    hideDateTimePicker: boolean;
+    isControllerOnly: boolean;
+    isWithTimeWheelToo: boolean;
+    isWithCalendarToo: boolean;
+    withAnyInputs: boolean;
+    withAnyPicker: boolean;
+    withClearBtn: boolean;
+    isWithDateInputs: boolean;
+    isWithTimeInputs: boolean;
+    autoFocusMonthInput: boolean;
+    autoFocusPrevMonthArrow: boolean;
+    shouldPreserveClearableSpace: boolean;
+    withAnyRightController: boolean;
+};

package/types/date-time-picker/config/useGetPropsBasedOnType.d.ts

@@ -0,0 +1,28 @@
+import type { DSControlledDateTimePickerT } from '../propTypes';
+export declare const useGetPropsBasedOnType: (propsWithDefaults: DSControlledDateTimePickerT.InternalProps) => {
+    getIsDisabledDay: any;
+    getIsOutOfRangeDay: any;
+    getIsStartRangeDay: any;
+    getIsDayInRange: any;
+    getIsEndRangeDay: any;
+    appOnDateChange: DSControlledDateTimePickerT.OnDateChange;
+    appOnMonthChange: DSControlledDateTimePickerT.OnInternalInputsChange;
+    appOnDayChange: DSControlledDateTimePickerT.OnInternalInputsChange;
+    appOnYearChange: DSControlledDateTimePickerT.OnInternalInputsChange;
+    appDate: string;
+    getIsDisabledTime: any;
+    appOnTimeChange: DSControlledDateTimePickerT.OnTimeChange;
+    appOnHourChange: DSControlledDateTimePickerT.OnInternalInputsChange;
+    appOnMinuteChange: DSControlledDateTimePickerT.OnInternalInputsChange;
+    appOnMeridiemChange: DSControlledDateTimePickerT.OnInternalInputsChange;
+    appTime: string;
+    appDateTime: string;
+    appOnDateTimeChange: DSControlledDateTimePickerT.OnDateTimeChange;
+    emptyPickerStartingMonth: string;
+    onCalendarOpenFocusedDay: string | undefined;
+    minutesInterval: number;
+    onTimeWheelOpenStartingTime: string;
+    isDate: boolean;
+    isTime: boolean;
+    isDateTime: boolean;
+};

package/types/date-time-picker/config/useGetPropsWithDefault.d.ts

@@ -1,2 +1,2 @@
-import { PropsWithDefaultsT } from '../index.d';
-export declare const useGetDatePickerWithDefaultsProps: (props: Partial<PropsWithDefaultsT>) => PropsWithDefaultsT;
+import { DSControlledDateTimePickerT } from '../propTypes';
+export declare const useGetDatePickerWithDefaultsProps: (props: DSControlledDateTimePickerT.Props) => DSControlledDateTimePickerT.InternalProps;

package/types/date-time-picker/config/useGetReferences.d.ts

@@ -0,0 +1,39 @@
+/// <reference types="react" />
+import { useGetFlags } from './useGetFlags';
+export declare const useGetReferences: ({ isWithDateInputs, isWithTimeInputs, withAnyPicker, withClearBtn, }: ReturnType<typeof useGetFlags>) => {
+    monthInputRef: import("react").RefObject<HTMLInputElement>;
+    dayInputRef: import("react").RefObject<HTMLInputElement>;
+    yearInputRef: import("react").RefObject<HTMLInputElement>;
+    hourInputRef: import("react").RefObject<HTMLInputElement>;
+    minutesInputRef: import("react").RefObject<HTMLInputElement>;
+    meridiemInputRef: import("react").RefObject<HTMLInputElement>;
+    clearButtonRef: import("react").RefObject<HTMLButtonElement>;
+    pickerButtonRef: import("react").RefObject<HTMLButtonElement>;
+    prevYearBtnRef: import("react").RefObject<HTMLButtonElement>;
+    prevMonthBtnRef: import("react").RefObject<HTMLButtonElement>;
+    nextMonthBtnRef: import("react").RefObject<HTMLButtonElement>;
+    nextYearBtnRef: import("react").RefObject<HTMLButtonElement>;
+    calendarDaysWrapperRef: import("react").RefObject<HTMLDivElement>;
+    prevHourBtnRef: import("react").RefObject<HTMLButtonElement>;
+    currHourBtnRef: import("react").RefObject<HTMLButtonElement>;
+    nextHourBtnRef: import("react").RefObject<HTMLButtonElement>;
+    prevMinutesBtnRef: import("react").RefObject<HTMLButtonElement>;
+    currMinutesBtnRef: import("react").RefObject<HTMLButtonElement>;
+    nextMinutesBtnRef: import("react").RefObject<HTMLButtonElement>;
+    prevMeridiemBtnRef: import("react").RefObject<HTMLButtonElement>;
+    currMeridiemBtnRef: import("react").RefObject<HTMLButtonElement>;
+    nextMeridiemBtnRef: import("react").RefObject<HTMLButtonElement>;
+    firstSegmentRef: import("react").RefObject<HTMLInputElement | HTMLButtonElement>;
+    lastSegmentRef: import("react").RefObject<HTMLInputElement | HTMLButtonElement>;
+    firstFragmentRefUpdateDeps: {
+        isWithDateInputs: boolean;
+        isWithTimeInputs: boolean;
+        withAnyPicker: boolean;
+    };
+    lastFragmentRefUpdateDeps: {
+        withAnyPicker: boolean;
+        withClearBtn: boolean;
+        isWithTimeInputs: boolean;
+        isWithDateInputs: boolean;
+    };
+};

package/types/date-time-picker/config/useGlobalKeyHandlers.d.ts

@@ -0,0 +1,16 @@
+import { useChangeHandlers } from './useChangeHandlers';
+import { useGetPropsBasedOnType } from './useGetPropsBasedOnType';
+import { useGetReferences } from './useGetReferences';
+import { useGetFlags } from './useGetFlags';
+import type { DSControlledDateTimePickerT } from '../propTypes';
+interface Config {
+    propsBasedOnType: ReturnType<typeof useGetPropsBasedOnType>;
+    changeHandlers: ReturnType<typeof useChangeHandlers>;
+    DOMRefs: ReturnType<typeof useGetReferences>;
+    flags: ReturnType<typeof useGetFlags>;
+}
+export declare const useGlobalKeyHandlers: ({ propsBasedOnType, changeHandlers, DOMRefs, flags }: Config) => {
+    onFillWithCurrentDateKeys: (e: React.KeyboardEvent<HTMLInputElement | HTMLButtonElement>, metaInfo?: Partial<DSControlledDateTimePickerT.InternalInputsChangeMetaInfo>) => void;
+    onGlobalKeyDown: (e: React.KeyboardEvent<HTMLInputElement | HTMLButtonElement>) => void;
+};
+export {};

package/types/date-time-picker/config/useRelevantValueFromProps.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import type { DSControlledDateTimePickerT } from '../propTypes';
+export declare const useRelevantValueFromProps: (props: DSControlledDateTimePickerT.InternalProps) => {
+    dateStringFromProps: string;
+    timeStringFromProps: string;
+    tempDateString: string;
+    setTempDateString: import("react").Dispatch<import("react").SetStateAction<string>>;
+    tempTimeString: string;
+    setTimeString: import("react").Dispatch<import("react").SetStateAction<string>>;
+};

package/types/date-time-picker/config/useValidateProps.d.ts

@@ -1,2 +1,2 @@
-import { PropsWithDefaultsT } from '../index.d';
-export declare const useValidateProps: (props: Partial<PropsWithDefaultsT>) => void;
+import { DSControlledDateTimePickerT } from '../propTypes';
+export declare const useValidateProps: (props: DSControlledDateTimePickerT.Props) => void;

package/types/date-time-picker/parts/ClearButton/useClearButton.d.ts

@@ -1,11 +1,11 @@
 /// <reference types="react" />
-import type { onClearClickT, onKeyDownT } from '../../index.d';
-interface useOnClearClickRT {
-    onClearClick: onClearClickT;
-    onClearButtonKeyDown: onKeyDownT<HTMLButtonElement>;
-    clearButtonRef: React.MutableRefObject<HTMLButtonElement>;
+import type { DSControlledDateTimePickerInternalsT } from '../../sharedTypes';
+interface UseOnClearClickR {
+    onClearClick: DSControlledDateTimePickerInternalsT.OnDSBtnClick;
+    onClearButtonKeyDown: DSControlledDateTimePickerInternalsT.OnKeyDown<HTMLButtonElement>;
+    clearButtonRef: React.MutableRefObject<HTMLButtonElement | null>;
     withAnyPicker: boolean;
     withClearBtn: boolean;
 }
-export declare const useClearButton: () => useOnClearClickRT;
+export declare const useClearButton: () => UseOnClearClickR;
 export {};

package/types/date-time-picker/parts/DateInputs/DDInput.d.ts

@@ -1,15 +1,15 @@
 import React from 'react';
-import type { onChangeFuncT, onBlurFuncT, onFocusFuncT, onKeyDownT } from '../../index.d';
+import type { DSControlledDateTimePickerInternalsT } from '../../sharedTypes';
 interface DDInputsPropsT {
-    onChange: onChangeFuncT;
-    onBlur: onBlurFuncT;
-    onFocus: onFocusFuncT;
-    onKeyDown: onKeyDownT;
+    onChange: DSControlledDateTimePickerInternalsT.OnChangeFunc;
+    onBlur: DSControlledDateTimePickerInternalsT.OnBlurFunc;
+    onFocus: DSControlledDateTimePickerInternalsT.OnFocusFunc;
+    onKeyDown: DSControlledDateTimePickerInternalsT.OnKeyDown;
     value: string;
     disabled: boolean;
     placeholder: string;
     ariaCurrentValueForInputs: string;
-    contextRef: React.RefObject<HTMLInputElement>;
+    contextRef: React.MutableRefObject<HTMLInputElement | null>;
 }
 export declare const DDInput: React.MemoExoticComponent<({ onChange, onBlur, onFocus, onKeyDown, value, disabled, contextRef, placeholder, ariaCurrentValueForInputs, }: DDInputsPropsT) => JSX.Element>;
 export {};

package/types/date-time-picker/parts/DateInputs/MMInput.d.ts

@@ -1,14 +1,14 @@
 import React from 'react';
-import type { onChangeFuncT, onBlurFuncT, onFocusFuncT, onKeyDownT } from '../../index.d';
+import type { DSControlledDateTimePickerInternalsT } from '../../sharedTypes';
 interface MMInputsPropsT {
-    onChange: onChangeFuncT;
-    onBlur: onBlurFuncT;
-    onFocus: onFocusFuncT;
-    onKeyDown: onKeyDownT;
+    onChange: DSControlledDateTimePickerInternalsT.OnChangeFunc;
+    onBlur: DSControlledDateTimePickerInternalsT.OnBlurFunc;
+    onFocus: DSControlledDateTimePickerInternalsT.OnFocusFunc;
+    onKeyDown: DSControlledDateTimePickerInternalsT.OnKeyDown;
     autoFocusMonthInput: boolean;
     value: string;
     disabled: boolean;
-    contextRef: React.RefObject<HTMLInputElement>;
+    contextRef: React.MutableRefObject<HTMLInputElement | null>;
     placeholder: string;
     ariaCurrentValueForInputs: string;
 }

package/types/date-time-picker/parts/DateInputs/YYYYInput.d.ts

@@ -1,13 +1,13 @@
 import React from 'react';
-import type { onChangeFuncT, onBlurFuncT, onFocusFuncT, onKeyDownT } from '../../index.d';
+import type { DSControlledDateTimePickerInternalsT } from '../../sharedTypes';
 interface YYYYInputsPropsT {
-    onChange: onChangeFuncT;
-    onBlur: onBlurFuncT;
-    onFocus: onFocusFuncT;
-    onKeyDown: onKeyDownT;
+    onChange: DSControlledDateTimePickerInternalsT.OnChangeFunc;
+    onBlur: DSControlledDateTimePickerInternalsT.OnBlurFunc;
+    onFocus: DSControlledDateTimePickerInternalsT.OnFocusFunc;
+    onKeyDown: DSControlledDateTimePickerInternalsT.OnKeyDown;
     value: string;
     disabled: boolean;
-    contextRef: React.RefObject<HTMLInputElement>;
+    contextRef: React.MutableRefObject<HTMLInputElement | null>;
     placeholder: string;
     ariaCurrentValueForInputs: string;
 }

package/types/date-time-picker/parts/DateInputs/useDateInputs.d.ts

@@ -1,2 +1,2 @@
-import type { useDateInputsRT } from '../../index.d';
-export declare const useDateInputs: () => useDateInputsRT;
+import type { DSControlledDateTimePickerInternalsT } from '../../sharedTypes';
+export declare const useDateInputs: () => DSControlledDateTimePickerInternalsT.UseDateInputsR;

package/types/date-time-picker/parts/Pickers/Calendar/Calendar.d.ts

@@ -1,3 +1,5 @@
-import React from 'react';
-export declare const WrapWithCalendarContext: (Component: React.ComponentType) => () => JSX.Element;
+/// <reference types="react" />
+export declare const WrappedCalendarContext: ({ children }: {
+    children: JSX.Element;
+}) => JSX.Element;
 export declare const Calendar: () => JSX.Element;

package/types/date-time-picker/parts/Pickers/Calendar/CalendarContext.d.ts

@@ -1,66 +1,6 @@
-import React from 'react';
-import type { DateMonth, metaMonthDayT, onFocusFuncT } from '../../../index.d';
-export declare type handleDayOnKeyDownT = (e: React.KeyboardEvent, day: metaMonthDayT) => void;
-export interface KeyboardHandlersT {
-    handleDayOnKeyDown: handleDayOnKeyDownT;
-    handlePrevYearKeyDown: (e: React.KeyboardEvent) => void;
-    handlePrevMonthKeyDown: (e: React.KeyboardEvent) => void;
-    handleNextMonthKeyDown: (e: React.KeyboardEvent) => void;
-    handleNextYearKeyDown: (e: React.KeyboardEvent) => void;
-    handlePickerIconKeyDown: (e: React.KeyboardEvent<HTMLButtonElement>) => void;
-}
-export interface FocusLogicT {
-    focusedDay?: metaMonthDayT;
-    tryToFocusCurrentlyDataIsFocusedDay: () => void;
-    resetFocusedDayToStartDate: () => void;
-    handleFocusMetaDay: (metaDayToFocus: metaMonthDayT) => void;
-    handleFocusMetaDayByDay: (day: Date) => void;
-}
-export interface HeaderButtonsRefsT {
-    prevYearBtnRef: React.RefObject<HTMLButtonElement>;
-    prevMonthBtnRef: React.RefObject<HTMLButtonElement>;
-    nextMonthBtnRef: React.RefObject<HTMLButtonElement>;
-    nextYearBtnRef: React.RefObject<HTMLButtonElement>;
-    calendarDaysWrapperRef: React.RefObject<HTMLDivElement>;
-}
-export interface PopperTriggerLogicT {
-    closeCalendar: () => void;
-    setPopperElement: React.Dispatch<React.SetStateAction<HTMLDivElement>>;
-    setArrowElement: React.Dispatch<React.SetStateAction<HTMLDivElement>>;
-    usePopperHelpers?: {
-        attributes: Record<string, unknown>;
-        styles: Record<string, React.CSSProperties>;
-    };
-    handleToggleCalendar: (e?: React.MouseEvent<HTMLButtonElement>) => void;
-    handleSetTriggerRef: (instance: HTMLButtonElement) => void;
-    handleMenuWrapperKeyDown: (e?: React.KeyboardEvent<HTMLElement>) => void;
-}
-export interface useCurrentDisplayedMonthYearLogicT {
-    currentMonth?: DateMonth;
-    currentYear?: number;
-    daysArray: metaMonthDayT[];
-    invisibleFirstDay?: metaMonthDayT;
-    daysMatrixByWeekday?: metaMonthDayT[][];
-    invisibleLastDay?: metaMonthDayT;
-    handlePrevMonth: () => void;
-    handlePrevYear: () => void;
-    handleNextMonth: () => void;
-    handleNextYear: () => void;
-}
-export interface CalendarContextT extends KeyboardHandlersT, HeaderButtonsRefsT, FocusLogicT, PopperTriggerLogicT, useCurrentDisplayedMonthYearLogicT {
-    ariaCurrentValueForInputs: string;
-    showCalendar: boolean;
-    setShowCalendar: React.Dispatch<React.SetStateAction<boolean>>;
-    isControllerOnly: boolean;
-    isWithTimeWheelToo: boolean;
-    autoFocusPrevMonthArrow: boolean;
-    disabled: boolean;
-    onPrevYearFocus: onFocusFuncT;
-    onPrevMonthFocus: onFocusFuncT;
-    onNextMonthFocus: onFocusFuncT;
-    onNextYearFocus: onFocusFuncT;
-}
+/// <reference types="react" />
+import type { CalendarContextT } from './useConfigCalendarCTX';
 export declare const defaultCalendarContext: CalendarContextT;
 /** Context for cross component communication */
-export declare const CalendarContext: React.Context<CalendarContextT>;
+export declare const CalendarContext: import("react").Context<CalendarContextT>;
 export default CalendarContext;

package/types/date-time-picker/parts/Pickers/Calendar/CalendarDaysList.d.ts

@@ -1,9 +1,9 @@
 import React from 'react';
-import type { metaMonthDayT } from '../../../index.d';
+import type { DSControlledDateTimePickerInternalsT } from '../../../sharedTypes';
 export declare const CalendarDaysList: React.MemoExoticComponent<({ invisibleFirstDay, daysMatrixByWeekday, invisibleLastDay, innerRef }: CalendarDaysListPropsT) => JSX.Element>;
 export interface CalendarDaysListPropsT {
-    invisibleFirstDay: metaMonthDayT;
-    daysMatrixByWeekday: metaMonthDayT[][];
-    invisibleLastDay: metaMonthDayT;
+    invisibleFirstDay?: DSControlledDateTimePickerInternalsT.MetaMonthDay;
+    daysMatrixByWeekday: DSControlledDateTimePickerInternalsT.MetaMonthDay[][];
+    invisibleLastDay?: DSControlledDateTimePickerInternalsT.MetaMonthDay;
     innerRef: React.RefObject<HTMLDivElement>;
 }

package/types/date-time-picker/parts/Pickers/Calendar/CalendarFooter.d.ts

@@ -1,2 +1,2 @@
-/// <reference types="react" />
-export declare const CalendarFooter: () => JSX.Element;
+import React from 'react';
+export declare const CalendarFooter: React.ComponentType;

package/types/date-time-picker/parts/Pickers/Calendar/Day.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="react" />
-import type { metaMonthDayT } from '../../../index.d';
+import type { DSControlledDateTimePickerInternalsT } from '../../../sharedTypes';
 interface CalendarDayPropsT {
-    metaDay: metaMonthDayT;
+    metaDay: DSControlledDateTimePickerInternalsT.MetaMonthDay;
     colIndex?: number;
     isInvisible?: boolean;
 }

package/types/date-time-picker/parts/Pickers/Calendar/useCurrentDisplayedMonthYearLogic.d.ts

@@ -1,2 +1,15 @@
-import type { useCurrentDisplayedMonthYearLogicT } from './CalendarContext';
-export declare const useCurrentDisplayedMonthYearLogic: () => useCurrentDisplayedMonthYearLogicT;
+import type { DSControlledDateTimePickerInternalsT } from '../../../sharedTypes';
+interface UseCurrentDisplayedMonthYearLogicT {
+    currentMonth: DSControlledDateTimePickerInternalsT.DateMonth;
+    currentYear: number;
+    daysArray: DSControlledDateTimePickerInternalsT.MetaMonthDay[];
+    invisibleFirstDay?: DSControlledDateTimePickerInternalsT.MetaMonthDay;
+    daysMatrixByWeekday: DSControlledDateTimePickerInternalsT.MetaMonthDay[][];
+    invisibleLastDay?: DSControlledDateTimePickerInternalsT.MetaMonthDay;
+    handlePrevMonth: () => void;
+    handlePrevYear: () => void;
+    handleNextMonth: () => void;
+    handleNextYear: () => void;
+}
+export declare const useCurrentDisplayedMonthYearLogic: () => UseCurrentDisplayedMonthYearLogicT;
+export {};

package/types/date-time-picker/parts/Pickers/Calendar/useFocusLogic.d.ts

@@ -1,8 +1,15 @@
-import type { metaMonthDayT } from '../../../index.d';
-import type { FocusLogicT } from './CalendarContext';
-interface useFocusLogicArgsT {
-    daysArray: metaMonthDayT[];
+import { useCurrentDisplayedMonthYearLogic } from './useCurrentDisplayedMonthYearLogic';
+import type { DSControlledDateTimePickerInternalsT } from '../../../sharedTypes';
+interface UseFocusLogicArgsT {
+    currentDisplayedMonthLogic: ReturnType<typeof useCurrentDisplayedMonthYearLogic>;
     showCalendar: boolean;
 }
-export declare const useFocusLogic: ({ daysArray, showCalendar }: useFocusLogicArgsT) => FocusLogicT;
+interface FocusLogicT {
+    focusedDay?: DSControlledDateTimePickerInternalsT.MetaMonthDay;
+    tryToFocusCurrentlyDataIsFocusedDay: () => void;
+    resetFocusedDayToStartDate: () => void;
+    handleFocusMetaDay: (metaDayToFocus: DSControlledDateTimePickerInternalsT.MetaMonthDay) => void;
+    handleFocusMetaDayByDay: (day: Date) => void;
+}
+export declare const useFocusLogic: ({ currentDisplayedMonthLogic, showCalendar }: UseFocusLogicArgsT) => FocusLogicT;
 export {};

package/types/date-time-picker/parts/Pickers/Calendar/useKeyboardHandlers.d.ts

@@ -1,13 +1,19 @@
-import type { metaMonthDayT } from '../../../index.d';
-import type { KeyboardHandlersT, HeaderButtonsRefsT } from './CalendarContext';
-interface useKeyboardHandlersArgsT extends Partial<HeaderButtonsRefsT> {
-    focusedDay: metaMonthDayT;
-    daysArray: metaMonthDayT[];
-    handlePrevMonth: () => void;
-    handleNextMonth: () => void;
-    handleFocusMetaDay: (metaDayToFocus: metaMonthDayT) => void;
-    handleFocusMetaDayByDay: (dayToFocus: Date) => void;
-    tryToFocusCurrentlyDataIsFocusedDay: () => void;
+/// <reference types="react" />
+import type { DSControlledDateTimePickerInternalsT } from '../../../sharedTypes';
+import { useFocusLogic } from './useFocusLogic';
+import { useCurrentDisplayedMonthYearLogic } from './useCurrentDisplayedMonthYearLogic';
+interface UseKeyboardHandlersArgsT {
+    currentDisplayedMonthLogic: ReturnType<typeof useCurrentDisplayedMonthYearLogic>;
+    focusLogic: ReturnType<typeof useFocusLogic>;
 }
-export declare const useKeyboardHandlers: ({ focusedDay, daysArray, handlePrevMonth, handleNextMonth, handleFocusMetaDay, handleFocusMetaDayByDay, tryToFocusCurrentlyDataIsFocusedDay, }: useKeyboardHandlersArgsT) => KeyboardHandlersT;
+declare type HandleDayOnKeyDownT = (e: React.KeyboardEvent, day: DSControlledDateTimePickerInternalsT.MetaMonthDay) => void;
+interface KeyboardHandlersT {
+    handleDayOnKeyDown: HandleDayOnKeyDownT;
+    handlePrevYearKeyDown: (e: React.KeyboardEvent) => void;
+    handlePrevMonthKeyDown: (e: React.KeyboardEvent) => void;
+    handleNextMonthKeyDown: (e: React.KeyboardEvent) => void;
+    handleNextYearKeyDown: (e: React.KeyboardEvent) => void;
+    handlePickerIconKeyDown: (e: React.KeyboardEvent<HTMLButtonElement>) => void;
+}
+export declare const useKeyboardHandlers: ({ currentDisplayedMonthLogic, focusLogic, }: UseKeyboardHandlersArgsT) => KeyboardHandlersT;
 export {};

package/types/date-time-picker/parts/Pickers/CalendarWithTimeWheel/CalendarWithTimeWheelContext.d.ts

@@ -1,20 +1,5 @@
 /// <reference types="react" />
-export interface CalendarWithTimeWheelContextT {
-    ariaCurrentValueForInputs: string;
-    showCalendarWithTimeWheel: boolean;
-    setPopperElement: (instance: HTMLDivElement) => void;
-    setArrowElement: (instance: HTMLDivElement) => void;
-    usePopperHelpers: {
-        attributes: Record<string, unknown>;
-        styles: Record<string, React.CSSProperties>;
-    };
-    handleToggleCalendarWithTimeWheel: (e: React.MouseEvent<HTMLButtonElement>) => void;
-    handleSetTriggerRef: (instance: HTMLButtonElement) => void;
-    handleMenuWrapperKeyDown: (e?: React.KeyboardEvent<HTMLElement>) => void;
-    handlePickerIconKeyDown: (e?: React.KeyboardEvent<HTMLButtonElement>) => void;
-    isControllerOnly: boolean;
-    disabled: boolean;
-}
+import type { CalendarWithTimeWheelContextT } from './useConfigCalendarWithTimeWheelCTX';
 export declare const defaultCalendarWithTimeWheelContext: CalendarWithTimeWheelContextT;
 /** Context for cross component communication */
 export declare const CalendarWithTimeWheelContext: import("react").Context<CalendarWithTimeWheelContextT>;

package/types/date-time-picker/parts/Pickers/CalendarWithTimeWheel/CalendarWithTimeWheelFooter.d.ts

@@ -1,2 +1,2 @@
-/// <reference types="react" />
-export declare const CalendarWithTimeWheelFooter: () => JSX.Element;
+import React from 'react';
+export declare const CalendarWithTimeWheelFooter: React.ComponentType;

package/types/date-time-picker/parts/Pickers/CalendarWithTimeWheel/useConfigCalendarWithTimeWheelCTX.d.ts

@@ -1,2 +1,16 @@
-import type { CalendarWithTimeWheelContextT } from './CalendarWithTimeWheelContext';
+import React from 'react';
+import { usePopper } from 'react-popper';
+export interface CalendarWithTimeWheelContextT {
+    ariaCurrentValueForInputs: string;
+    showCalendarWithTimeWheel: boolean;
+    setPopperElement: (instance: HTMLDivElement) => void;
+    setArrowElement: (instance: HTMLDivElement) => void;
+    usePopperHelpers: ReturnType<typeof usePopper>;
+    handleToggleCalendarWithTimeWheel: (e: React.MouseEvent<HTMLButtonElement>) => void;
+    handleSetTriggerRef: (instance: HTMLButtonElement) => void;
+    handleMenuWrapperKeyDown: (e: React.KeyboardEvent<HTMLElement>) => void;
+    handlePickerIconKeyDown: (e: React.KeyboardEvent<HTMLButtonElement>) => void;
+    isControllerOnly: boolean;
+    disabled: boolean;
+}
 export declare const useConfigCalendarWithTimeWheelCTX: () => CalendarWithTimeWheelContextT;

package/types/date-time-picker/parts/Pickers/TimeWheel/TimeWheel.d.ts

@@ -1,3 +1,5 @@
-import React from 'react';
-export declare const WrapWithTimeWheelContext: (Component: React.ComponentType) => () => JSX.Element;
+/// <reference types="react" />
+export declare const WrappedTimeWheelContext: ({ children }: {
+    children: JSX.Element;
+}) => JSX.Element;
 export declare const TimeWheel: () => JSX.Element;

package/types/date-time-picker/parts/Pickers/TimeWheel/TimeWheelContext.d.ts

@@ -1,65 +1,6 @@
-import React from 'react';
-export interface WheelsButtonsRefsT {
-    prevHourBtnRef: React.RefObject<HTMLButtonElement>;
-    currHourBtnRef: React.RefObject<HTMLButtonElement>;
-    nextHourBtnRef: React.RefObject<HTMLButtonElement>;
-    prevMinutesBtnRef: React.RefObject<HTMLButtonElement>;
-    currMinutesBtnRef: React.RefObject<HTMLButtonElement>;
-    nextMinutesBtnRef: React.RefObject<HTMLButtonElement>;
-    prevMeridiemBtnRef: React.RefObject<HTMLButtonElement>;
-    currMeridiemBtnRef: React.RefObject<HTMLButtonElement>;
-    nextMeridiemBtnRef: React.RefObject<HTMLButtonElement>;
-}
-export interface KeyboardHandlersT {
-    handlePrevHourBtnOnKeyDown: (e: React.KeyboardEvent) => void;
-    handleCurrHourOnKeyDown: (e: React.KeyboardEvent) => void;
-    handleNextHourBtnOnKeyDown: (e: React.KeyboardEvent) => void;
-    handlePrevMinuteBtnOnKeyDown: (e: React.KeyboardEvent) => void;
-    handleCurrMinutesOnKeyDown: (e: React.KeyboardEvent) => void;
-    handleNextMinuteBtnOnKeyDown: (e: React.KeyboardEvent) => void;
-    handlePrevMeridiemBtnOnKeyDown: (e: React.KeyboardEvent) => void;
-    handleCurrMeridiemOnKeyDown: (e: React.KeyboardEvent) => void;
-    handleNextMeridiemBtnOnKeyDown: (e: React.KeyboardEvent) => void;
-    handlePickerIconKeyDown: (e: React.KeyboardEvent<HTMLButtonElement>) => void;
-}
-export interface PopperTriggerLogicT {
-    showTimePicker: boolean;
-    setShowTimePicker: React.Dispatch<React.SetStateAction<boolean>>;
-    setPopperElement: React.Dispatch<React.SetStateAction<HTMLDivElement>>;
-    setArrowElement: React.Dispatch<React.SetStateAction<HTMLDivElement>>;
-    usePopperHelpers: {
-        attributes: Record<string, unknown>;
-        styles: Record<string, React.CSSProperties>;
-    };
-    handleToggleTimePicker: (e?: React.MouseEvent<HTMLButtonElement>) => void;
-    handleSetTriggerRef: (instance: HTMLButtonElement) => void;
-    handleMenuWrapperKeyDown: (e?: React.KeyboardEvent<HTMLElement>) => void;
-}
-export interface useCurrentDisplayedWheelsLogicT {
-    currHourNum: number;
-    hours: string;
-    visibleHours: string[];
-    handlePrevHour: (e: React.MouseEvent) => void;
-    handleNextHour: (e: React.MouseEvent) => void;
-    handleTimeWheelBtnChangeHours: (newVal: string, e: React.MouseEvent<HTMLButtonElement>) => void;
-    currMinuteNum: number;
-    minutes: string;
-    visibleMinutes: string[];
-    handlePrevMinute: (e: React.MouseEvent) => void;
-    handleNextMinute: (e: React.MouseEvent) => void;
-    handleTimeWheelBtnChangeMinutes: (newVal: string, e: React.MouseEvent<HTMLButtonElement>) => void;
-    meridiem: string;
-    handleTimeWheelBtnChangeMeridiem: (newMeridiem: string, e: React.MouseEvent) => void;
-}
-export interface TimeWheelContextT extends PopperTriggerLogicT, useCurrentDisplayedWheelsLogicT, KeyboardHandlersT, WheelsButtonsRefsT {
-    ariaCurrentValueForInputs: string;
-    tempTimeString: string;
-    isControllerOnly: boolean;
-    autoFocusHourTimeWheel: boolean;
-    disabled: boolean;
-    getIsDisabledTime: (val: string) => boolean;
-}
+/// <reference types="react" />
+import type { TimeWheelContextT } from './useConfigTimePickerCTX';
 export declare const defaultTimePickerContext: TimeWheelContextT;
 /** Context for cross component communication */
-export declare const TimeWheelContext: React.Context<TimeWheelContextT>;
+export declare const TimeWheelContext: import("react").Context<TimeWheelContextT>;
 export default TimeWheelContext;

package/types/date-time-picker/parts/Pickers/TimeWheel/TimeWheelFooter.d.ts

@@ -1,2 +1,2 @@
-/// <reference types="react" />
-export declare const TimeWheelFooter: () => JSX.Element;
+import React from 'react';
+export declare const TimeWheelFooter: React.ComponentType;

package/types/date-time-picker/parts/Pickers/TimeWheel/useConfigTimePickerCTX.d.ts

@@ -1,2 +1,5 @@
-import { TimeWheelContextT } from './TimeWheelContext';
+import { usePopperTriggerLogic } from './usePopperTriggerLogic';
+import { useCurrentDisplayedWheelsLogic } from './useCurrentDisplayedWheelsLogic';
+import { useKeyboardHandlers } from './useKeyboardHandlers';
+export declare type TimeWheelContextT = ReturnType<typeof useCurrentDisplayedWheelsLogic> & ReturnType<typeof usePopperTriggerLogic> & ReturnType<typeof useKeyboardHandlers>;
 export declare const useConfigTimePickerCTX: () => TimeWheelContextT;