@elliemae/ds-controlled-form 2.2.0-alpha.4 → 3.0.0-next.2

package/esm/controlled-date-time-picker/parts/Pickers/Calendar/useKeyboardHandlers.js

@@ -1,17 +1,21 @@
-import * as React from "react";
-import { useMemo, useContext, useCallback } from "react";
-import { ControlledDateTimePickerContext } from "../../../ControlledDateTimePickerCTX";
-import { sumValuesToDate } from "../../../utils/dateHelpers";
-import { homeEndAllArrowKeys, homeEndKeys } from "../../../utils/constants";
-const useKeyboardHandlers = ({
-  focusedDay,
-  daysArray,
-  handlePrevMonth,
-  handleNextMonth,
-  handleFocusMetaDay,
-  handleFocusMetaDayByDay,
-  tryToFocusCurrentlyDataIsFocusedDay
-}) => {
+import 'core-js/modules/esnext.async-iterator.find.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.find.js';
+import { useContext, useCallback, useMemo } from 'react';
+import { ControlledDateTimePickerContext } from '../../../ControlledDateTimePickerCTX.js';
+import { sumValuesToDate } from '../../../utils/dateHelpers.js';
+import { homeEndKeys, homeEndAllArrowKeys } from '../../../utils/constants.js';
+
+const useKeyboardHandlers = _ref => {
+  let {
+    focusedDay,
+    daysArray,
+    handlePrevMonth,
+    handleNextMonth,
+    handleFocusMetaDay,
+    handleFocusMetaDayByDay,
+    tryToFocusCurrentlyDataIsFocusedDay
+  } = _ref;
   const {
     hideDate,
     hideTime,
@@ -32,181 +36,213 @@ const useKeyboardHandlers = ({
     yearInputRef
   } = useContext(ControlledDateTimePickerContext);
   const tryToFocusDayRegion = useCallback(() => {
-    setLatestInteractionRegion("calendar-days");
+    setLatestInteractionRegion('calendar-days');
+
     if (!focusedDay) {
-      const newFocusDay = daysArray.find(({ isCurrMonthDay }) => isCurrMonthDay);
-      if (newFocusDay)
-        setTimeout(() => {
-          handleFocusMetaDay(newFocusDay);
-        });
+      const newFocusDay = daysArray.find(_ref2 => {
+        let {
+          isCurrMonthDay
+        } = _ref2;
+        return isCurrMonthDay;
+      });
+      if (newFocusDay) setTimeout(() => {
+        handleFocusMetaDay(newFocusDay);
+      });
     } else {
       tryToFocusCurrentlyDataIsFocusedDay();
     }
   }, [daysArray, focusedDay, handleFocusMetaDay, setLatestInteractionRegion, tryToFocusCurrentlyDataIsFocusedDay]);
   const onHomeKeyDownInsideCalendar = useCallback(() => {
-    prevMonthBtnRef?.current?.focus?.();
+    var _prevMonthBtnRef$curr, _prevMonthBtnRef$curr2;
+
+    prevMonthBtnRef === null || prevMonthBtnRef === void 0 ? void 0 : (_prevMonthBtnRef$curr = prevMonthBtnRef.current) === null || _prevMonthBtnRef$curr === void 0 ? void 0 : (_prevMonthBtnRef$curr2 = _prevMonthBtnRef$curr.focus) === null || _prevMonthBtnRef$curr2 === void 0 ? void 0 : _prevMonthBtnRef$curr2.call(_prevMonthBtnRef$curr);
   }, [prevMonthBtnRef]);
   const onEndKeyDownInsideCalendar = useCallback(() => {
-    if (isWithTimeWheelToo)
-      currMeridiemBtnRef?.current?.focus?.();
-    else
-      tryToFocusDayRegion();
+    var _currMeridiemBtnRef$c, _currMeridiemBtnRef$c2;
+
+    if (isWithTimeWheelToo) currMeridiemBtnRef === null || currMeridiemBtnRef === void 0 ? void 0 : (_currMeridiemBtnRef$c = currMeridiemBtnRef.current) === null || _currMeridiemBtnRef$c === void 0 ? void 0 : (_currMeridiemBtnRef$c2 = _currMeridiemBtnRef$c.focus) === null || _currMeridiemBtnRef$c2 === void 0 ? void 0 : _currMeridiemBtnRef$c2.call(_currMeridiemBtnRef$c);else tryToFocusDayRegion();
   }, [currMeridiemBtnRef, isWithTimeWheelToo, tryToFocusDayRegion]);
   const onHomeKeyDownTriggerIcon = useCallback(() => {
-    if (!hideDate)
-      monthInputRef?.current?.focus?.();
-    else if (!hideTime)
-      hourInputRef?.current?.focus?.();
+    var _monthInputRef$curren, _monthInputRef$curren2, _hourInputRef$current, _hourInputRef$current2;
+
+    if (!hideDate) monthInputRef === null || monthInputRef === void 0 ? void 0 : (_monthInputRef$curren = monthInputRef.current) === null || _monthInputRef$curren === void 0 ? void 0 : (_monthInputRef$curren2 = _monthInputRef$curren.focus) === null || _monthInputRef$curren2 === void 0 ? void 0 : _monthInputRef$curren2.call(_monthInputRef$curren);else if (!hideTime) hourInputRef === null || hourInputRef === void 0 ? void 0 : (_hourInputRef$current = hourInputRef.current) === null || _hourInputRef$current === void 0 ? void 0 : (_hourInputRef$current2 = _hourInputRef$current.focus) === null || _hourInputRef$current2 === void 0 ? void 0 : _hourInputRef$current2.call(_hourInputRef$current);
   }, [hideDate, hideTime, monthInputRef, hourInputRef]);
-  const handlePickerIconKeyDown = useCallback((e) => {
-    const { key } = e;
-    if (homeEndKeys.includes(key))
-      e.preventDefault();
-    if (homeEndKeys.includes(key))
-      e.stopPropagation();
-    if (key === "Home")
-      onHomeKeyDownTriggerIcon();
-    if (key === "Backspace" && withAnyInputs) {
-      if (isWithTimeInputs)
-        meridiemInputRef?.current?.focus?.();
-      else if (isWithDateInputs)
-        yearInputRef?.current?.focus?.();
+  const handlePickerIconKeyDown = useCallback(e => {
+    const {
+      key
+    } = e;
+    if (homeEndKeys.includes(key)) e.preventDefault();
+    if (homeEndKeys.includes(key)) e.stopPropagation();
+    if (key === 'Home') onHomeKeyDownTriggerIcon();
+
+    if (key === 'Backspace' && withAnyInputs) {
+      var _meridiemInputRef$cur, _meridiemInputRef$cur2, _yearInputRef$current, _yearInputRef$current2;
+
+      if (isWithTimeInputs) meridiemInputRef === null || meridiemInputRef === void 0 ? void 0 : (_meridiemInputRef$cur = meridiemInputRef.current) === null || _meridiemInputRef$cur === void 0 ? void 0 : (_meridiemInputRef$cur2 = _meridiemInputRef$cur.focus) === null || _meridiemInputRef$cur2 === void 0 ? void 0 : _meridiemInputRef$cur2.call(_meridiemInputRef$cur);else if (isWithDateInputs) yearInputRef === null || yearInputRef === void 0 ? void 0 : (_yearInputRef$current = yearInputRef.current) === null || _yearInputRef$current === void 0 ? void 0 : (_yearInputRef$current2 = _yearInputRef$current.focus) === null || _yearInputRef$current2 === void 0 ? void 0 : _yearInputRef$current2.call(_yearInputRef$current);
     }
   }, [isWithDateInputs, isWithTimeInputs, meridiemInputRef, onHomeKeyDownTriggerIcon, withAnyInputs, yearInputRef]);
   const handleDayOnKeyDown = useCallback((e, metaDay) => {
     let newFocusedDayDate;
-    const { day } = metaDay;
-    const { key, shiftKey } = e;
-    if (homeEndAllArrowKeys.includes(key))
-      e.preventDefault();
-    if (homeEndAllArrowKeys.includes(key))
-      e.stopPropagation();
-    if (key === "ArrowUp")
-      newFocusedDayDate = sumValuesToDate(day, { daysToSum: -7 });
-    if (key === "ArrowDown")
-      newFocusedDayDate = sumValuesToDate(day, { daysToSum: 7 });
-    if (key === "ArrowLeft") {
-      newFocusedDayDate = sumValuesToDate(day, { daysToSum: -1 });
+    const {
+      day
+    } = metaDay;
+    const {
+      key,
+      shiftKey
+    } = e;
+    if (homeEndAllArrowKeys.includes(key)) e.preventDefault();
+    if (homeEndAllArrowKeys.includes(key)) e.stopPropagation();
+    if (key === 'ArrowUp') newFocusedDayDate = sumValuesToDate(day, {
+      daysToSum: -7
+    });
+    if (key === 'ArrowDown') newFocusedDayDate = sumValuesToDate(day, {
+      daysToSum: 7
+    });
+
+    if (key === 'ArrowLeft') {
+      newFocusedDayDate = sumValuesToDate(day, {
+        daysToSum: -1
+      });
+
       if (metaDay === daysArray[1]) {
         handlePrevMonth();
       }
     }
-    if (key === "ArrowRight") {
-      newFocusedDayDate = sumValuesToDate(day, { daysToSum: 1 });
+
+    if (key === 'ArrowRight') {
+      newFocusedDayDate = sumValuesToDate(day, {
+        daysToSum: 1
+      });
+
       if (metaDay === daysArray[daysArray.length - 2]) {
         handleNextMonth();
       }
     }
+
     if (newFocusedDayDate) {
       handleFocusMetaDayByDay(newFocusedDayDate);
       setTimeout(tryToFocusCurrentlyDataIsFocusedDay);
     }
-    if (key === "Home")
-      onHomeKeyDownInsideCalendar();
-    if (key === "End")
-      onEndKeyDownInsideCalendar();
-    if (key === "Tab" && !shiftKey && isControllerOnly === false && !isWithTimeWheelToo) {
+
+    if (key === 'Home') onHomeKeyDownInsideCalendar();
+    if (key === 'End') onEndKeyDownInsideCalendar(); // TAB CYCLE IMPLEMENTATION
+
+    if (key === 'Tab' && !shiftKey && isControllerOnly === false && !isWithTimeWheelToo) {
+      var _prevMonthBtnRef$curr3, _prevMonthBtnRef$curr4;
+
+      // MUST prevent default since this is a custom focus switch
+      // NOT preventing the default event will cause unexpected result
       e.preventDefault();
-      prevMonthBtnRef?.current?.focus?.();
+      prevMonthBtnRef === null || prevMonthBtnRef === void 0 ? void 0 : (_prevMonthBtnRef$curr3 = prevMonthBtnRef.current) === null || _prevMonthBtnRef$curr3 === void 0 ? void 0 : (_prevMonthBtnRef$curr4 = _prevMonthBtnRef$curr3.focus) === null || _prevMonthBtnRef$curr4 === void 0 ? void 0 : _prevMonthBtnRef$curr4.call(_prevMonthBtnRef$curr3);
     }
-  }, [
-    daysArray,
-    handleFocusMetaDayByDay,
-    handleNextMonth,
-    handlePrevMonth,
-    isControllerOnly,
-    isWithTimeWheelToo,
-    onEndKeyDownInsideCalendar,
-    onHomeKeyDownInsideCalendar,
-    prevMonthBtnRef,
-    tryToFocusCurrentlyDataIsFocusedDay
-  ]);
-  const handlePrevYearKeyDown = useCallback((e) => {
-    const { key, shiftKey } = e;
-    if (key === "Tab") {
+  }, [daysArray, handleFocusMetaDayByDay, handleNextMonth, handlePrevMonth, isControllerOnly, isWithTimeWheelToo, onEndKeyDownInsideCalendar, onHomeKeyDownInsideCalendar, prevMonthBtnRef, tryToFocusCurrentlyDataIsFocusedDay]);
+  const handlePrevYearKeyDown = useCallback(e => {
+    const {
+      key,
+      shiftKey
+    } = e;
+
+    if (key === 'Tab') {
       e.preventDefault();
+
       if (shiftKey) {
         nextMonthBtnRef.current.focus();
       } else {
         nextYearBtnRef.current.focus();
       }
     }
-    if (key === "Home") {
+
+    if (key === 'Home') {
       onHomeKeyDownInsideCalendar();
       e.preventDefault();
     }
-    if (key === "End") {
+
+    if (key === 'End') {
       onEndKeyDownInsideCalendar();
       e.preventDefault();
     }
   }, [nextMonthBtnRef, nextYearBtnRef, onEndKeyDownInsideCalendar, onHomeKeyDownInsideCalendar]);
-  const handlePrevMonthKeyDown = useCallback((e) => {
-    const { key, shiftKey } = e;
-    if (key === "Tab") {
+  const handlePrevMonthKeyDown = useCallback(e => {
+    const {
+      key,
+      shiftKey
+    } = e;
+
+    if (key === 'Tab') {
       if (shiftKey) {
+        // TAB CYCLE IMPLEMENTATION
         if (!isControllerOnly) {
+          var _currMeridiemBtnRef$c3, _currMeridiemBtnRef$c4;
+
           e.preventDefault();
-          if (isWithTimeWheelToo)
-            currMeridiemBtnRef?.current?.focus?.();
-          else
-            tryToFocusDayRegion();
+          if (isWithTimeWheelToo) currMeridiemBtnRef === null || currMeridiemBtnRef === void 0 ? void 0 : (_currMeridiemBtnRef$c3 = currMeridiemBtnRef.current) === null || _currMeridiemBtnRef$c3 === void 0 ? void 0 : (_currMeridiemBtnRef$c4 = _currMeridiemBtnRef$c3.focus) === null || _currMeridiemBtnRef$c4 === void 0 ? void 0 : _currMeridiemBtnRef$c4.call(_currMeridiemBtnRef$c3);else tryToFocusDayRegion();
         }
       } else {
         e.preventDefault();
         nextMonthBtnRef.current.focus();
       }
     }
-    if (key === "Home") {
+
+    if (key === 'Home') {
       onHomeKeyDownInsideCalendar();
       e.preventDefault();
     }
-    if (key === "End") {
+
+    if (key === 'End') {
       onEndKeyDownInsideCalendar();
       e.preventDefault();
     }
-  }, [
-    currMeridiemBtnRef,
-    isControllerOnly,
-    isWithTimeWheelToo,
-    nextMonthBtnRef,
-    onEndKeyDownInsideCalendar,
-    onHomeKeyDownInsideCalendar,
-    tryToFocusDayRegion
-  ]);
-  const handleNextMonthKeyDown = useCallback((e) => {
-    const { key, shiftKey } = e;
-    if (key === "Tab") {
+  }, [currMeridiemBtnRef, isControllerOnly, isWithTimeWheelToo, nextMonthBtnRef, onEndKeyDownInsideCalendar, onHomeKeyDownInsideCalendar, tryToFocusDayRegion]);
+  const handleNextMonthKeyDown = useCallback(e => {
+    const {
+      key,
+      shiftKey
+    } = e;
+
+    if (key === 'Tab') {
       e.preventDefault();
+
       if (shiftKey) {
         prevMonthBtnRef.current.focus();
       } else {
         prevYearBtnRef.current.focus();
       }
     }
-    if (key === "Home") {
+
+    if (key === 'Home') {
       onHomeKeyDownInsideCalendar();
       e.preventDefault();
     }
-    if (key === "End") {
+
+    if (key === 'End') {
       onEndKeyDownInsideCalendar();
       e.preventDefault();
     }
   }, [onEndKeyDownInsideCalendar, onHomeKeyDownInsideCalendar, prevMonthBtnRef, prevYearBtnRef]);
-  const handleNextYearKeyDown = useCallback((e) => {
-    const { key, shiftKey } = e;
-    if (key === "Tab") {
+  const handleNextYearKeyDown = useCallback(e => {
+    const {
+      key,
+      shiftKey
+    } = e;
+
+    if (key === 'Tab') {
       e.preventDefault();
+
       if (shiftKey) {
-        prevYearBtnRef?.current?.focus?.();
+        var _prevYearBtnRef$curre, _prevYearBtnRef$curre2;
+
+        prevYearBtnRef === null || prevYearBtnRef === void 0 ? void 0 : (_prevYearBtnRef$curre = prevYearBtnRef.current) === null || _prevYearBtnRef$curre === void 0 ? void 0 : (_prevYearBtnRef$curre2 = _prevYearBtnRef$curre.focus) === null || _prevYearBtnRef$curre2 === void 0 ? void 0 : _prevYearBtnRef$curre2.call(_prevYearBtnRef$curre);
       }
-      if (!shiftKey)
-        tryToFocusDayRegion();
+
+      if (!shiftKey) tryToFocusDayRegion();
     }
-    if (key === "Home") {
+
+    if (key === 'Home') {
       onHomeKeyDownInsideCalendar();
       e.preventDefault();
     }
-    if (key === "End") {
+
+    if (key === 'End') {
       onEndKeyDownInsideCalendar();
       e.preventDefault();
     }
@@ -218,16 +254,7 @@ const useKeyboardHandlers = ({
     handleNextMonthKeyDown,
     handleNextYearKeyDown,
     handlePickerIconKeyDown
-  }), [
-    handleDayOnKeyDown,
-    handlePrevYearKeyDown,
-    handlePrevMonthKeyDown,
-    handleNextMonthKeyDown,
-    handleNextYearKeyDown,
-    handlePickerIconKeyDown
-  ]);
-};
-export {
-  useKeyboardHandlers
+  }), [handleDayOnKeyDown, handlePrevYearKeyDown, handlePrevMonthKeyDown, handleNextMonthKeyDown, handleNextYearKeyDown, handlePickerIconKeyDown]);
 };
-//# sourceMappingURL=useKeyboardHandlers.js.map
+
+export { useKeyboardHandlers };

package/esm/controlled-date-time-picker/parts/Pickers/Calendar/usePopperTriggerLogic.js

@@ -1,17 +1,22 @@
-import * as React from "react";
-import { useMemo, useCallback, useState, useContext } from "react";
-import { usePopper } from "react-popper";
-import { ControlledDateTimePickerContext } from "../../../ControlledDateTimePickerCTX";
-import { useOnClickOutside } from "../../../utils/hooks/useOnClickOutside";
-const usePopperTriggerLogic = ({
-  focusedDay,
-  resetFocusedDayToStartDate,
-  showCalendar,
-  setShowCalendar,
-  tryToFocusCurrentlyDataIsFocusedDay
-}) => {
+import 'core-js/modules/web.dom-collections.iterator.js';
+import { useContext, useState, useCallback, useMemo } from 'react';
+import { usePopper } from 'react-popper';
+import { ControlledDateTimePickerContext } from '../../../ControlledDateTimePickerCTX.js';
+import { useOnClickOutside } from '../../../utils/hooks/useOnClickOutside.js';
+
+const usePopperTriggerLogic = _ref => {
+  let {
+    focusedDay,
+    resetFocusedDayToStartDate,
+    showCalendar,
+    setShowCalendar,
+    tryToFocusCurrentlyDataIsFocusedDay
+  } = _ref;
   const {
-    props: { onPickerOpen, onPickerClose },
+    props: {
+      onPickerOpen,
+      onPickerClose
+    },
     prevMonthBtnRef,
     pickerButtonRef
   } = useContext(ControlledDateTimePickerContext);
@@ -19,47 +24,63 @@ const usePopperTriggerLogic = ({
   const [popperElement, setPopperElement] = useState(null);
   const [arrowElement, setArrowElement] = useState(null);
   const usePopperHelpers = usePopper(referenceElement, popperElement, {
-    modifiers: [{ name: "arrow", options: { element: arrowElement } }]
-  });
+    modifiers: [{
+      name: 'arrow',
+      options: {
+        element: arrowElement
+      }
+    }]
+  }); // onOpen we try to focus the day we should focus, if we should focus one
+
   const handleOnPickerOpen = useCallback(() => {
     onPickerOpen();
     tryToFocusCurrentlyDataIsFocusedDay();
   }, [onPickerOpen, tryToFocusCurrentlyDataIsFocusedDay]);
   const openCalendar = useCallback(() => {
-    if (focusedDay)
-      setTimeout(() => focusedDay?.dayBtnRef?.current?.focus?.(), 100);
-    else
-      setTimeout(() => prevMonthBtnRef?.current?.focus?.(), 100);
+    if (focusedDay) setTimeout(() => {
+      var _focusedDay$dayBtnRef, _focusedDay$dayBtnRef2, _focusedDay$dayBtnRef3;
+
+      return focusedDay === null || focusedDay === void 0 ? void 0 : (_focusedDay$dayBtnRef = focusedDay.dayBtnRef) === null || _focusedDay$dayBtnRef === void 0 ? void 0 : (_focusedDay$dayBtnRef2 = _focusedDay$dayBtnRef.current) === null || _focusedDay$dayBtnRef2 === void 0 ? void 0 : (_focusedDay$dayBtnRef3 = _focusedDay$dayBtnRef2.focus) === null || _focusedDay$dayBtnRef3 === void 0 ? void 0 : _focusedDay$dayBtnRef3.call(_focusedDay$dayBtnRef2);
+    }, 100);else setTimeout(() => {
+      var _prevMonthBtnRef$curr, _prevMonthBtnRef$curr2;
+
+      return prevMonthBtnRef === null || prevMonthBtnRef === void 0 ? void 0 : (_prevMonthBtnRef$curr = prevMonthBtnRef.current) === null || _prevMonthBtnRef$curr === void 0 ? void 0 : (_prevMonthBtnRef$curr2 = _prevMonthBtnRef$curr.focus) === null || _prevMonthBtnRef$curr2 === void 0 ? void 0 : _prevMonthBtnRef$curr2.call(_prevMonthBtnRef$curr);
+    }, 100);
     setShowCalendar(true);
     handleOnPickerOpen();
   }, [focusedDay, handleOnPickerOpen, prevMonthBtnRef, setShowCalendar]);
   const closeCalendar = useCallback(() => {
+    var _pickerButtonRef$curr, _pickerButtonRef$curr2;
+
     setShowCalendar(false);
     onPickerClose();
     resetFocusedDayToStartDate();
-    pickerButtonRef?.current?.focus?.();
+    pickerButtonRef === null || pickerButtonRef === void 0 ? void 0 : (_pickerButtonRef$curr = pickerButtonRef.current) === null || _pickerButtonRef$curr === void 0 ? void 0 : (_pickerButtonRef$curr2 = _pickerButtonRef$curr.focus) === null || _pickerButtonRef$curr2 === void 0 ? void 0 : _pickerButtonRef$curr2.call(_pickerButtonRef$curr);
   }, [setShowCalendar, onPickerClose, resetFocusedDayToStartDate, pickerButtonRef]);
   const handleToggleCalendar = useCallback(() => {
     const isOpening = !showCalendar;
-    if (isOpening)
-      openCalendar();
-    else
-      closeCalendar();
+    if (isOpening) openCalendar();else closeCalendar();
   }, [closeCalendar, openCalendar, showCalendar]);
-  const handleSetTriggerRef = useCallback((newRef) => {
+  const handleSetTriggerRef = useCallback(newRef => {
     pickerButtonRef.current = newRef;
     setReferenceElement(newRef);
   }, [pickerButtonRef]);
-  const handleMenuWrapperKeyDown = useCallback((e) => {
-    const { key } = e;
-    if (key === "Escape") {
+  const handleMenuWrapperKeyDown = useCallback(e => {
+    const {
+      key
+    } = e;
+
+    if (key === 'Escape') {
+      var _pickerButtonRef$curr3, _pickerButtonRef$curr4;
+
       closeCalendar();
-      pickerButtonRef?.current?.focus?.();
+      pickerButtonRef === null || pickerButtonRef === void 0 ? void 0 : (_pickerButtonRef$curr3 = pickerButtonRef.current) === null || _pickerButtonRef$curr3 === void 0 ? void 0 : (_pickerButtonRef$curr4 = _pickerButtonRef$curr3.focus) === null || _pickerButtonRef$curr4 === void 0 ? void 0 : _pickerButtonRef$curr4.call(_pickerButtonRef$curr3);
     }
   }, [closeCalendar, pickerButtonRef]);
-  useOnClickOutside(popperElement, (e) => {
-    if (!pickerButtonRef?.current?.contains?.(e?.target))
-      closeCalendar();
+  useOnClickOutside(popperElement, e => {
+    var _pickerButtonRef$curr5, _pickerButtonRef$curr6;
+
+    if (!(pickerButtonRef !== null && pickerButtonRef !== void 0 && (_pickerButtonRef$curr5 = pickerButtonRef.current) !== null && _pickerButtonRef$curr5 !== void 0 && (_pickerButtonRef$curr6 = _pickerButtonRef$curr5.contains) !== null && _pickerButtonRef$curr6 !== void 0 && _pickerButtonRef$curr6.call(_pickerButtonRef$curr5, e === null || e === void 0 ? void 0 : e.target))) closeCalendar();
   });
   return useMemo(() => ({
     closeCalendar,
@@ -71,7 +92,5 @@ const usePopperTriggerLogic = ({
     handleMenuWrapperKeyDown
   }), [closeCalendar, handleMenuWrapperKeyDown, handleSetTriggerRef, handleToggleCalendar, usePopperHelpers]);
 };
-export {
-  usePopperTriggerLogic
-};
-//# sourceMappingURL=usePopperTriggerLogic.js.map
+
+export { usePopperTriggerLogic };

package/esm/controlled-date-time-picker/parts/Pickers/CalendarWithTimeWheel/CalendarWithTimeWheel.js

@@ -1,21 +1,28 @@
-import * as React from "react";
-import React2 from "react";
-import { CalendarWithTimeWheelIconTrigger } from "./CalendarWithTimeWheelIconTrigger";
-import { CalendarWithTimeWheelWrapper } from "./CalendarWithTimeWheelWrapper";
-import { CalendarWithTimeWheelContext } from "./CalendarWithTimeWheelContext";
-import { useConfigCalendarWithTimeWheelCTX } from "./useConfigCalendarWithTimeWheelCTX";
-import { WrapWithCalendarContext } from "../Calendar/Calendar";
-import { WrapWithTimeWheelContext } from "../TimeWheel/TimeWheel";
+import _jsx from '@babel/runtime/helpers/esm/jsx';
+import 'react';
+import { CalendarWithTimeWheelIconTrigger } from './CalendarWithTimeWheelIconTrigger.js';
+import { CalendarWithTimeWheelWrapper } from './CalendarWithTimeWheelWrapper.js';
+import { CalendarWithTimeWheelContext } from './CalendarWithTimeWheelContext.js';
+import { useConfigCalendarWithTimeWheelCTX } from './useConfigCalendarWithTimeWheelCTX.js';
+import { WrapWithCalendarContext } from '../Calendar/Calendar.js';
+import { WrapWithTimeWheelContext } from '../TimeWheel/TimeWheel.js';
+import { jsx, Fragment } from 'react/jsx-runtime';
+
+var _CalendarWithTimeWhee, _CalendarWithTimeWhee2;
 const CalendarWithTimeWheel = WrapWithCalendarContext(WrapWithTimeWheelContext(() => {
   const ctx = useConfigCalendarWithTimeWheelCTX();
-  const { showCalendarWithTimeWheel, isControllerOnly, handleMenuWrapperKeyDown } = ctx;
-  return /* @__PURE__ */ React2.createElement(CalendarWithTimeWheelContext.Provider, {
+  const {
+    showCalendarWithTimeWheel,
+    isControllerOnly,
+    handleMenuWrapperKeyDown
+  } = ctx;
+  return /*#__PURE__*/_jsx(CalendarWithTimeWheelContext.Provider, {
     value: ctx
-  }, isControllerOnly ? null : /* @__PURE__ */ React2.createElement(CalendarWithTimeWheelIconTrigger, null), isControllerOnly || showCalendarWithTimeWheel ? /* @__PURE__ */ React2.createElement(React2.Fragment, null, /* @__PURE__ */ React2.createElement("div", {
-    onKeyDown: handleMenuWrapperKeyDown
-  }, /* @__PURE__ */ React2.createElement(CalendarWithTimeWheelWrapper, null))) : null);
+  }, void 0, isControllerOnly ? null : _CalendarWithTimeWhee || (_CalendarWithTimeWhee = /*#__PURE__*/_jsx(CalendarWithTimeWheelIconTrigger, {})), isControllerOnly || showCalendarWithTimeWheel ? /*#__PURE__*/jsx(Fragment, {
+    children: /*#__PURE__*/_jsx("div", {
+      onKeyDown: handleMenuWrapperKeyDown
+    }, void 0, _CalendarWithTimeWhee2 || (_CalendarWithTimeWhee2 = /*#__PURE__*/_jsx(CalendarWithTimeWheelWrapper, {})))
+  }) : null);
 }));
-export {
-  CalendarWithTimeWheel
-};
-//# sourceMappingURL=CalendarWithTimeWheel.js.map
+
+export { CalendarWithTimeWheel };

package/esm/controlled-date-time-picker/parts/Pickers/CalendarWithTimeWheel/CalendarWithTimeWheelContent.js

@@ -1,18 +1,20 @@
-import * as React from "react";
-import React2, { useContext } from "react";
-import { ControlledDateTimePickerDatatestid } from "../../../ControlledDateTimePickerDatatestid";
-import { StyledCalendarWithTimeWheelWrapper, StyledCalendar } from "./Styleds";
-import { CalendarWithTimeWheelFooter } from "./CalendarWithTimeWheelFooter";
-import { TimeWheelContent } from "../TimeWheel/TimeWheelContent";
-import { ControlledDateTimePickerContext } from "../../../ControlledDateTimePickerCTX";
+import _jsx from '@babel/runtime/helpers/esm/jsx';
+import { useContext } from 'react';
+import { ControlledDateTimePickerDatatestid } from '../../../ControlledDateTimePickerDatatestid.js';
+import { StyledCalendarWithTimeWheelWrapper, StyledCalendar } from './Styleds.js';
+import { CalendarWithTimeWheelFooter } from './CalendarWithTimeWheelFooter.js';
+import { TimeWheelContent } from '../TimeWheel/TimeWheelContent.js';
+import { ControlledDateTimePickerContext } from '../../../ControlledDateTimePickerCTX.js';
+
+var _StyledCalendar, _TimeWheelContent, _CalendarWithTimeWhee;
 const CalendarWithTimeWheelContent = () => {
-  const { isControllerOnly } = useContext(ControlledDateTimePickerContext);
-  return /* @__PURE__ */ React2.createElement(StyledCalendarWithTimeWheelWrapper, {
-    isControllerOnly,
+  const {
+    isControllerOnly
+  } = useContext(ControlledDateTimePickerContext);
+  return /*#__PURE__*/_jsx(StyledCalendarWithTimeWheelWrapper, {
+    isControllerOnly: isControllerOnly,
     "data-testid": ControlledDateTimePickerDatatestid.CONTROLLER_COMPONENT.CALENDAR_TIMEWHEEL
-  }, /* @__PURE__ */ React2.createElement(StyledCalendar, null), /* @__PURE__ */ React2.createElement(TimeWheelContent, null), /* @__PURE__ */ React2.createElement(CalendarWithTimeWheelFooter, null));
+  }, void 0, _StyledCalendar || (_StyledCalendar = /*#__PURE__*/_jsx(StyledCalendar, {})), _TimeWheelContent || (_TimeWheelContent = /*#__PURE__*/_jsx(TimeWheelContent, {})), _CalendarWithTimeWhee || (_CalendarWithTimeWhee = /*#__PURE__*/_jsx(CalendarWithTimeWheelFooter, {})));
 };
-export {
-  CalendarWithTimeWheelContent
-};
-//# sourceMappingURL=CalendarWithTimeWheelContent.js.map
+
+export { CalendarWithTimeWheelContent };

package/esm/controlled-date-time-picker/parts/Pickers/CalendarWithTimeWheel/CalendarWithTimeWheelContext.js

@@ -1,9 +1,10 @@
-import * as React from "react";
-import { createContext } from "react";
-const noop = () => {
-};
+import { createContext } from 'react';
+
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+const noop = () => {};
+
 const defaultCalendarWithTimeWheelContext = {
-  ariaCurrentValueForInputs: "",
+  ariaCurrentValueForInputs: '',
   showCalendarWithTimeWheel: false,
   setPopperElement: noop,
   setArrowElement: noop,
@@ -15,11 +16,8 @@ const defaultCalendarWithTimeWheelContext = {
   isControllerOnly: false,
   disabled: false
 };
-const CalendarWithTimeWheelContext = createContext(defaultCalendarWithTimeWheelContext);
-var CalendarWithTimeWheelContext_default = CalendarWithTimeWheelContext;
-export {
-  CalendarWithTimeWheelContext,
-  CalendarWithTimeWheelContext_default as default,
-  defaultCalendarWithTimeWheelContext
-};
-//# sourceMappingURL=CalendarWithTimeWheelContext.js.map
+/** Context for cross component communication */
+
+const CalendarWithTimeWheelContext = /*#__PURE__*/createContext(defaultCalendarWithTimeWheelContext);
+
+export { CalendarWithTimeWheelContext, CalendarWithTimeWheelContext as default, defaultCalendarWithTimeWheelContext };

package/esm/controlled-date-time-picker/parts/Pickers/CalendarWithTimeWheel/CalendarWithTimeWheelFooter.js

@@ -1,16 +1,18 @@
-import * as React from "react";
-import React2, { useContext } from "react";
-import { ControlledDateTimePickerContext } from "../../../ControlledDateTimePickerCTX";
-import { CalendarWithTimeWheelFooterMessage } from "./Styleds";
+import _jsx from '@babel/runtime/helpers/esm/jsx';
+import { useContext } from 'react';
+import { ControlledDateTimePickerContext } from '../../../ControlledDateTimePickerCTX.js';
+import { CalendarWithTimeWheelFooterMessage } from './Styleds.js';
+
 const CalendarWithTimeWheelFooter = () => {
   const {
-    props: { pickerFooterMsg, hasError }
+    props: {
+      pickerFooterMsg,
+      hasError
+    }
   } = useContext(ControlledDateTimePickerContext);
-  return pickerFooterMsg !== void 0 && hasError ? /* @__PURE__ */ React2.createElement(CalendarWithTimeWheelFooterMessage, {
+  return pickerFooterMsg !== undefined && hasError ? /*#__PURE__*/_jsx(CalendarWithTimeWheelFooterMessage, {
     role: "alert"
-  }, pickerFooterMsg) : null;
+  }, void 0, pickerFooterMsg) : null;
 };
-export {
-  CalendarWithTimeWheelFooter
-};
-//# sourceMappingURL=CalendarWithTimeWheelFooter.js.map
+
+export { CalendarWithTimeWheelFooter };