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

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

@@ -1,10 +1,15 @@
-import * as React from "react";
-import React2, { useContext, useMemo } from "react";
-import { BUTTON_VARIANT, BUTTON_SIZES } from "@elliemae/ds-button";
-import { DatePicker } from "@elliemae/ds-icons";
-import { CalendarWithTimeWheelContext } from "./CalendarWithTimeWheelContext";
-import { StyledIconTriggerButton } from "./Styleds";
-import { ControlledDateTimePickerDatatestid } from "../../../ControlledDateTimePickerDatatestid";
+import _jsx from '@babel/runtime/helpers/esm/jsx';
+import { useContext, useMemo } from 'react';
+import { BUTTON_SIZES, BUTTON_VARIANT } from '@elliemae/ds-button';
+import { DatePicker } from '@elliemae/ds-icons';
+import { CalendarWithTimeWheelContext } from './CalendarWithTimeWheelContext.js';
+import { StyledIconTriggerButton } from './Styleds.js';
+import { ControlledDateTimePickerDatatestid } from '../../../ControlledDateTimePickerDatatestid.js';
+
+var _DatePicker;
+// this is particularly useful due to how usePopper needs to check the references
+// since references are saved in a immutable way, we make sure to shortcircuit useless-re-renders
+
 const CalendarWithTimeWheelIconTrigger = () => {
   const {
     handleSetTriggerRef,
@@ -13,8 +18,8 @@ const CalendarWithTimeWheelIconTrigger = () => {
     ariaCurrentValueForInputs,
     disabled
   } = useContext(CalendarWithTimeWheelContext);
-  return useMemo(() => /* @__PURE__ */ React2.createElement(StyledIconTriggerButton, {
-    "aria-label": `date time picker context menu trigger, ${ariaCurrentValueForInputs}`,
+  return useMemo(() => /*#__PURE__*/_jsx(StyledIconTriggerButton, {
+    "aria-label": "date time picker context menu trigger, ".concat(ariaCurrentValueForInputs),
     buttonType: "icon",
     size: BUTTON_SIZES.M,
     variant: BUTTON_VARIANT.DEFAULT,
@@ -22,16 +27,8 @@ const CalendarWithTimeWheelIconTrigger = () => {
     onClick: handleToggleCalendarWithTimeWheel,
     onKeyDown: handlePickerIconKeyDown,
     "data-testid": ControlledDateTimePickerDatatestid.PICKER_ICONS.CALENDAR_TIMEWHEEL,
-    disabled
-  }, /* @__PURE__ */ React2.createElement(DatePicker, null)), [
-    ariaCurrentValueForInputs,
-    disabled,
-    handlePickerIconKeyDown,
-    handleSetTriggerRef,
-    handleToggleCalendarWithTimeWheel
-  ]);
-};
-export {
-  CalendarWithTimeWheelIconTrigger
+    disabled: disabled
+  }, void 0, _DatePicker || (_DatePicker = /*#__PURE__*/_jsx(DatePicker, {}))), [ariaCurrentValueForInputs, disabled, handlePickerIconKeyDown, handleSetTriggerRef, handleToggleCalendarWithTimeWheel]);
 };
-//# sourceMappingURL=CalendarWithTimeWheelIconTrigger.js.map
+
+export { CalendarWithTimeWheelIconTrigger };

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

@@ -1,28 +1,45 @@
-import * as React from "react";
-import React2, { useContext } from "react";
-import { ControlledDateTimePickerDatatestid } from "../../../ControlledDateTimePickerDatatestid";
-import { CalendarWithTimeWheelContent } from "./CalendarWithTimeWheelContent";
-import { CalendarWithTimeWheelContext } from "./CalendarWithTimeWheelContext";
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+import _jsx from '@babel/runtime/helpers/esm/jsx';
+import { useContext } from 'react';
+import { ControlledDateTimePickerDatatestid } from '../../../ControlledDateTimePickerDatatestid.js';
+import { CalendarWithTimeWheelContent } from './CalendarWithTimeWheelContent.js';
+import { CalendarWithTimeWheelContext } from './CalendarWithTimeWheelContext.js';
+import { jsxs, jsx } from 'react/jsx-runtime';
+
+var _CalendarWithTimeWhee, _CalendarWithTimeWhee2;
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 const CalendarWithTimeWheelWrapper = () => {
   const {
     setPopperElement,
     setArrowElement,
-    usePopperHelpers: { attributes, styles },
+    usePopperHelpers: {
+      attributes,
+      styles
+    },
     isControllerOnly
   } = useContext(CalendarWithTimeWheelContext);
-  if (isControllerOnly)
-    return /* @__PURE__ */ React2.createElement(CalendarWithTimeWheelContent, null);
-  return /* @__PURE__ */ React2.createElement("div", {
+  if (isControllerOnly) return _CalendarWithTimeWhee || (_CalendarWithTimeWhee = /*#__PURE__*/_jsx(CalendarWithTimeWheelContent, {}));
+  return /*#__PURE__*/jsxs("div", _objectSpread(_objectSpread({
     ref: setPopperElement,
-    style: { ...styles.popper, background: "white", zIndex: 110 },
-    ...attributes.popper,
-    "data-testid": ControlledDateTimePickerDatatestid.CONTEXTUAL_MENU.CALENDAR_TIMEWHEEL
-  }, /* @__PURE__ */ React2.createElement(CalendarWithTimeWheelContent, null), /* @__PURE__ */ React2.createElement("div", {
-    ref: setArrowElement,
-    style: styles.arrow
+    style: _objectSpread(_objectSpread({}, styles.popper), {}, {
+      background: 'white',
+      zIndex: 110
+    })
+  }, attributes.popper), {}, {
+    "data-testid": ControlledDateTimePickerDatatestid.CONTEXTUAL_MENU.CALENDAR_TIMEWHEEL,
+    children: [_CalendarWithTimeWhee2 || (_CalendarWithTimeWhee2 = /*#__PURE__*/_jsx(CalendarWithTimeWheelContent, {})), /*#__PURE__*/jsx("div", {
+      ref: setArrowElement,
+      style: styles.arrow
+    })]
   }));
 };
-export {
-  CalendarWithTimeWheelWrapper
-};
-//# sourceMappingURL=CalendarWithTimeWheelWrapper.js.map
+
+export { CalendarWithTimeWheelWrapper };

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

@@ -1,43 +1,68 @@
-import * as React from "react";
-import styled from "styled-components";
-import { DSButtonV2 } from "@elliemae/ds-button";
-import { CalendarContent } from "../Calendar/CalendarContent";
-const StyledIconTriggerButton = styled(DSButtonV2)`
-  color: ${({ theme }) => theme.colors.brand["600"]};
-  width: 26px;
-  height: 26px;
-`;
-const StyledCalendarWithTimeWheelWrapper = styled.div`
-  background: ${({ theme }) => theme.colors.neutral["000"]};
-  ${({ isControllerOnly }) => isControllerOnly ? void 0 : "box-shadow: 0 6px 20px 0 rgb(0 0 0 / 24%), 0 8px 17px 0 rgb(0 0 0 / 19%);"}
-  display: grid;
-  grid-template-columns: 260px 192px;
-  grid-template-rows: 1fr;
-  column-gap: 0;
+import styled from 'styled-components';
+import { DSButtonV2 } from '@elliemae/ds-button';
+import { CalendarContent } from '../Calendar/CalendarContent.js';
 
-  & > div:last-of-type {
-    box-shadow: -1px 0 0 0 ${({ theme }) => theme.colors.neutral[200]};
-    margin-left: 1px;
-  }
-`;
-const StyledCalendar = styled(CalendarContent)`
-  box-shadow: none;
-`;
-const CalendarWithTimeWheelFooterMessage = styled.footer`
-  border-top: solid 1px ${({ theme }) => theme.colors.neutral[300]};
-  margin: 0 ${({ theme }) => theme.space.xxs2};
-  padding: ${({ theme }) => theme.space.xxs2} 0;
-  color: ${({ theme }) => theme.colors.danger[900]};
-  font-style: italic;
-  font-weight: ${({ theme }) => theme.fontWeights.thin};
-  font-size: ${({ theme }) => theme.fontSizes.microText[200]};
-  text-align: right;
-  grid-column: 1/3;
-`;
-export {
-  CalendarWithTimeWheelFooterMessage,
-  StyledCalendar,
-  StyledCalendarWithTimeWheelWrapper,
-  StyledIconTriggerButton
-};
-//# sourceMappingURL=Styleds.js.map
+const StyledIconTriggerButton = /*#__PURE__*/styled(DSButtonV2).withConfig({
+  componentId: "sc-h2xj8r-0"
+})(["color:", ";width:26px;height:26px;"], _ref => {
+  let {
+    theme
+  } = _ref;
+  return theme.colors.brand['600'];
+});
+const StyledCalendarWithTimeWheelWrapper = /*#__PURE__*/styled.div.withConfig({
+  componentId: "sc-h2xj8r-1"
+})(["background:", ";", " display:grid;grid-template-columns:260px 192px;grid-template-rows:1fr;column-gap:0;& > div:last-of-type{box-shadow:-1px 0 0 0 ", ";margin-left:1px;}"], _ref2 => {
+  let {
+    theme
+  } = _ref2;
+  return theme.colors.neutral['000'];
+}, _ref3 => {
+  let {
+    isControllerOnly
+  } = _ref3;
+  return isControllerOnly ? undefined : 'box-shadow: 0 6px 20px 0 rgb(0 0 0 / 24%), 0 8px 17px 0 rgb(0 0 0 / 19%);';
+}, _ref4 => {
+  let {
+    theme
+  } = _ref4;
+  return theme.colors.neutral[200];
+});
+const StyledCalendar = /*#__PURE__*/styled(CalendarContent).withConfig({
+  componentId: "sc-h2xj8r-2"
+})(["box-shadow:none;"]);
+const CalendarWithTimeWheelFooterMessage = /*#__PURE__*/styled.footer.withConfig({
+  componentId: "sc-h2xj8r-3"
+})(["border-top:solid 1px ", ";margin:0 ", ";padding:", " 0;color:", ";font-style:italic;font-weight:", ";font-size:", ";text-align:right;grid-column:1/3;"], _ref5 => {
+  let {
+    theme
+  } = _ref5;
+  return theme.colors.neutral[300];
+}, _ref6 => {
+  let {
+    theme
+  } = _ref6;
+  return theme.space.xxs2;
+}, _ref7 => {
+  let {
+    theme
+  } = _ref7;
+  return theme.space.xxs2;
+}, _ref8 => {
+  let {
+    theme
+  } = _ref8;
+  return theme.colors.danger[900];
+}, _ref9 => {
+  let {
+    theme
+  } = _ref9;
+  return theme.fontWeights.thin;
+}, _ref10 => {
+  let {
+    theme
+  } = _ref10;
+  return theme.fontSizes.microText[200];
+});
+
+export { CalendarWithTimeWheelFooterMessage, StyledCalendar, StyledCalendarWithTimeWheelWrapper, StyledIconTriggerButton };

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

@@ -1,16 +1,22 @@
-import * as React from "react";
-import { useMemo, useState, useCallback, useContext } from "react";
-import { usePopper } from "react-popper";
-import { CONTROLLED_DATE_TIME_PICKER_TYPES } from "../../../ControlledDateTimePickerTypes";
-import { ControlledDateTimePickerContext } from "../../../ControlledDateTimePickerCTX";
-import { useOnClickOutside } from "../../../utils/hooks/useOnClickOutside";
-import { CalendarContext } from "../Calendar/CalendarContext";
-import { TimeWheelContext } from "../TimeWheel/TimeWheelContext";
-import { homeEndKeys } from "../../../utils/constants";
+import 'core-js/modules/web.dom-collections.iterator.js';
+import { useContext, useState, useCallback, useMemo } from 'react';
+import { usePopper } from 'react-popper';
+import { CONTROLLED_DATE_TIME_PICKER_TYPES } from '../../../ControlledDateTimePickerTypes.js';
+import { ControlledDateTimePickerContext } from '../../../ControlledDateTimePickerCTX.js';
+import { useOnClickOutside } from '../../../utils/hooks/useOnClickOutside.js';
+import { CalendarContext } from '../Calendar/CalendarContext.js';
+import { TimeWheelContext } from '../TimeWheel/TimeWheelContext.js';
+import { homeEndKeys } from '../../../utils/constants.js';
+
 const useConfigCalendarWithTimeWheelCTX = () => {
   const {
     pickerButtonRef,
-    props: { type, onPickerOpen, onPickerClose, disabled },
+    props: {
+      type,
+      onPickerOpen,
+      onPickerClose,
+      disabled
+    },
     hideDate,
     hideTime,
     monthInputRef,
@@ -21,67 +27,77 @@ const useConfigCalendarWithTimeWheelCTX = () => {
     yearInputRef,
     ariaCurrentValueForInputs
   } = useContext(ControlledDateTimePickerContext);
-  const { handleToggleCalendar } = useContext(CalendarContext);
-  const { handleToggleTimePicker } = useContext(TimeWheelContext);
+  const {
+    handleToggleCalendar
+  } = useContext(CalendarContext);
+  const {
+    handleToggleTimePicker
+  } = useContext(TimeWheelContext);
   const [showCalendarWithTimeWheel, setShowCalendarWithTimeWheel] = useState(false);
   const onHomeKeyDown = 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")
-      onHomeKeyDown();
-    if (key === "Backspace" && withAnyInputs) {
-      if (isWithTimeInputs)
-        meridiemInputRef?.current?.focus?.();
-      else
-        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') onHomeKeyDown();
+
+    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 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);
     }
   }, [isWithTimeInputs, meridiemInputRef, onHomeKeyDown, withAnyInputs, yearInputRef]);
   const [referenceElement, setReferenceElement] = useState(null);
   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
+      }
+    }]
   });
-  const openCalendar = useCallback((e) => {
+  const openCalendar = useCallback(e => {
     setShowCalendarWithTimeWheel(true);
     onPickerOpen();
     setTimeout(() => handleToggleCalendar(e));
     setTimeout(() => handleToggleTimePicker(e));
   }, [handleToggleCalendar, handleToggleTimePicker, onPickerOpen]);
-  const closeCalendar = useCallback((e) => {
+  const closeCalendar = useCallback(e => {
     setShowCalendarWithTimeWheel(false);
     onPickerClose();
     setTimeout(() => handleToggleCalendar(e));
     setTimeout(() => handleToggleTimePicker(e));
   }, [handleToggleCalendar, handleToggleTimePicker, onPickerClose]);
-  const handleToggleCalendarWithTimeWheel = useCallback((e) => {
-    if (!showCalendarWithTimeWheel)
-      openCalendar(e);
-    else
-      closeCalendar(e);
+  const handleToggleCalendarWithTimeWheel = useCallback(e => {
+    if (!showCalendarWithTimeWheel) openCalendar(e);else closeCalendar(e);
   }, [closeCalendar, openCalendar, showCalendarWithTimeWheel]);
-  useOnClickOutside(popperElement, (e) => {
-    if (!pickerButtonRef?.current?.contains?.(e?.target))
-      closeCalendar(e);
+  useOnClickOutside(popperElement, e => {
+    var _pickerButtonRef$curr, _pickerButtonRef$curr2;
+
+    if (!(pickerButtonRef !== null && pickerButtonRef !== void 0 && (_pickerButtonRef$curr = pickerButtonRef.current) !== null && _pickerButtonRef$curr !== void 0 && (_pickerButtonRef$curr2 = _pickerButtonRef$curr.contains) !== null && _pickerButtonRef$curr2 !== void 0 && _pickerButtonRef$curr2.call(_pickerButtonRef$curr, e === null || e === void 0 ? void 0 : e.target))) closeCalendar(e);
   });
-  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(e);
-      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]);
   const isControllerOnly = useMemo(() => type === CONTROLLED_DATE_TIME_PICKER_TYPES.DATE_TIME.CONTROLLER_ONLY, [type]);
@@ -97,19 +113,7 @@ const useConfigCalendarWithTimeWheelCTX = () => {
     isControllerOnly,
     disabled,
     ariaCurrentValueForInputs
-  }), [
-    showCalendarWithTimeWheel,
-    usePopperHelpers,
-    handleToggleCalendarWithTimeWheel,
-    handleSetTriggerRef,
-    handleMenuWrapperKeyDown,
-    handlePickerIconKeyDown,
-    isControllerOnly,
-    disabled,
-    ariaCurrentValueForInputs
-  ]);
-};
-export {
-  useConfigCalendarWithTimeWheelCTX
+  }), [showCalendarWithTimeWheel, usePopperHelpers, handleToggleCalendarWithTimeWheel, handleSetTriggerRef, handleMenuWrapperKeyDown, handlePickerIconKeyDown, isControllerOnly, disabled, ariaCurrentValueForInputs]);
 };
-//# sourceMappingURL=useConfigCalendarWithTimeWheelCTX.js.map
+
+export { useConfigCalendarWithTimeWheelCTX };

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

@@ -1,24 +1,26 @@
-import * as React from "react";
-import React2 from "react";
-import { ControlledDateTimePickerContext } from "../../ControlledDateTimePickerCTX";
-import { StyledPickersIconsWrapperGrid } from "../Styleds";
-import { CalendarWithTimeWheel } from "./CalendarWithTimeWheel/CalendarWithTimeWheel";
-import { Calendar } from "./Calendar/Calendar";
-import { TimeWheel } from "./TimeWheel/TimeWheel";
+import _jsx from '@babel/runtime/helpers/esm/jsx';
+import React from 'react';
+import { ControlledDateTimePickerContext } from '../../ControlledDateTimePickerCTX.js';
+import { StyledPickersIconsWrapperGrid } from '../Styleds.js';
+import { CalendarWithTimeWheel } from './CalendarWithTimeWheel/CalendarWithTimeWheel.js';
+import { Calendar } from './Calendar/Calendar.js';
+import { TimeWheel } from './TimeWheel/TimeWheel.js';
+
+var _Calendar, _TimeWheel, _CalendarWithTimeWhee;
 const PickersIcons = () => {
   const {
     hideDatePicker,
     hideTimePicker,
     hideDateTimePicker,
     isControllerOnly,
-    props: { hasError }
-  } = React2.useContext(ControlledDateTimePickerContext);
-  return /* @__PURE__ */ React2.createElement(StyledPickersIconsWrapperGrid, {
-    hasError,
-    isControllerOnly
-  }, !hideDatePicker && hideTimePicker && hideDateTimePicker ? /* @__PURE__ */ React2.createElement(Calendar, null) : null, hideDatePicker && !hideTimePicker && hideDateTimePicker ? /* @__PURE__ */ React2.createElement(TimeWheel, null) : null, hideDatePicker && hideTimePicker && !hideDateTimePicker ? /* @__PURE__ */ React2.createElement(CalendarWithTimeWheel, null) : null);
+    props: {
+      hasError
+    }
+  } = React.useContext(ControlledDateTimePickerContext);
+  return /*#__PURE__*/_jsx(StyledPickersIconsWrapperGrid, {
+    hasError: hasError,
+    isControllerOnly: isControllerOnly
+  }, void 0, !hideDatePicker && hideTimePicker && hideDateTimePicker ? _Calendar || (_Calendar = /*#__PURE__*/_jsx(Calendar, {})) : null, hideDatePicker && !hideTimePicker && hideDateTimePicker ? _TimeWheel || (_TimeWheel = /*#__PURE__*/_jsx(TimeWheel, {})) : null, hideDatePicker && hideTimePicker && !hideDateTimePicker ? _CalendarWithTimeWhee || (_CalendarWithTimeWhee = /*#__PURE__*/_jsx(CalendarWithTimeWheel, {})) : null);
 };
-export {
-  PickersIcons
-};
-//# sourceMappingURL=PickersIcons.js.map
+
+export { PickersIcons };

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

@@ -1,10 +1,25 @@
-import * as React from "react";
-import React2, { useContext } from "react";
-import { ChevronSmallUp, ChevronSmallDown } from "@elliemae/ds-icons";
-import { ControlledDateTimePickerDatatestid } from "../../../ControlledDateTimePickerDatatestid";
-import { convertToPositiveNumberIfPossible } from "../../../utils/numberHelpers";
-import { StyledWheelList, StyledWheelListItem, StyledTimeBtn, StyledWheelChangeTimeBtn } from "./Styleds";
-import { TimeWheelContext } from "./TimeWheelContext";
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+import _jsx from '@babel/runtime/helpers/esm/jsx';
+import 'core-js/modules/esnext.async-iterator.map.js';
+import 'core-js/modules/esnext.iterator.map.js';
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
+import { useContext } from 'react';
+import { ChevronSmallUp, ChevronSmallDown } from '@elliemae/ds-icons';
+import { ControlledDateTimePickerDatatestid } from '../../../ControlledDateTimePickerDatatestid.js';
+import { convertToPositiveNumberIfPossible } from '../../../utils/numberHelpers.js';
+import { StyledWheelList, StyledWheelListItem, StyledWheelChangeTimeBtn, StyledTimeBtn } from './Styleds.js';
+import { TimeWheelContext } from './TimeWheelContext.js';
+import { jsx } from 'react/jsx-runtime';
+
+var _ChevronSmallUp, _ChevronSmallDown;
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 const HoursList = () => {
   const {
     currHourNum,
@@ -24,7 +39,7 @@ const HoursList = () => {
     getIsDisabledTime,
     autoFocusHourTimeWheel
   } = useContext(TimeWheelContext);
-  return /* @__PURE__ */ React2.createElement(StyledWheelList, null, /* @__PURE__ */ React2.createElement(StyledWheelListItem, null, /* @__PURE__ */ React2.createElement(StyledWheelChangeTimeBtn, {
+  return /*#__PURE__*/_jsx(StyledWheelList, {}, void 0, /*#__PURE__*/_jsx(StyledWheelListItem, {}, void 0, /*#__PURE__*/_jsx(StyledWheelChangeTimeBtn, {
     "aria-label": "subtract one hour",
     buttonType: "raw",
     size: "m",
@@ -33,44 +48,41 @@ const HoursList = () => {
     innerRef: prevHourBtnRef,
     "data-testid": ControlledDateTimePickerDatatestid.TIMEWHEEL.PREV_HOUR,
     tabIndex: -1
-  }, /* @__PURE__ */ React2.createElement(ChevronSmallUp, null))), visibleHours.map((hourString) => {
-    const key = `timewheel-hour-${hourString}`;
-    if (!hourString)
-      return /* @__PURE__ */ React2.createElement(StyledWheelListItem, {
-        key
-      });
-    const currHourTimeString = `${hourString}:${minutes || "00"} ${meridiem || "AM"}`;
+  }, void 0, _ChevronSmallUp || (_ChevronSmallUp = /*#__PURE__*/_jsx(ChevronSmallUp, {})))), visibleHours.map(hourString => {
+    const key = "timewheel-hour-".concat(hourString);
+    if (!hourString) return /*#__PURE__*/_jsx(StyledWheelListItem, {}, key);
+    const currHourTimeString = "".concat(hourString, ":").concat(minutes || '00', " ").concat(meridiem || 'AM');
     const isEmptyCurrValueCurrentListItem = !hours && convertToPositiveNumberIfPossible(hourString) === currHourNum;
     const isCurrentListItem = isEmptyCurrValueCurrentListItem || hours === hourString;
     const isDisabled = getIsDisabledTime(currHourTimeString);
     const tabIndex = isCurrentListItem ? 0 : -1;
     const btnProps = {
-      onKeyDown: isCurrentListItem ? handleCurrHourOnKeyDown : void 0,
-      innerRef: isCurrentListItem ? currHourBtnRef : void 0
+      onKeyDown: isCurrentListItem ? handleCurrHourOnKeyDown : undefined,
+      innerRef: isCurrentListItem ? currHourBtnRef : undefined
     };
-    return /* @__PURE__ */ React2.createElement(StyledWheelListItem, {
-      isCurrentListItem,
-      key
-    }, /* @__PURE__ */ React2.createElement(StyledTimeBtn, {
-      isCurrentListItem,
+    return /*#__PURE__*/_jsx(StyledWheelListItem, {
+      isCurrentListItem: isCurrentListItem
+    }, key, /*#__PURE__*/jsx(StyledTimeBtn, _objectSpread(_objectSpread({
+      isCurrentListItem: isCurrentListItem,
       autoFocus: autoFocusHourTimeWheel && isCurrentListItem,
-      "data-testid": ControlledDateTimePickerDatatestid.TIMEWHEEL[isCurrentListItem ? "CURRENT_HOUR" : "HOUR"],
+      "data-testid": ControlledDateTimePickerDatatestid.TIMEWHEEL[isCurrentListItem ? 'CURRENT_HOUR' : 'HOUR'],
       selected: hours.length === 2 && convertToPositiveNumberIfPossible(hourString) === currHourNum,
-      "aria-label": `${hourString} hours`,
+      "aria-label": "".concat(hourString, " hours"),
       "aria-disabled": isDisabled,
-      isDisabled,
+      isDisabled: isDisabled,
       buttonType: "raw",
       size: "m",
-      onClick: (e) => handleTimeWheelBtnChangeHours(hourString, e),
-      tabIndex,
+      onClick: e => handleTimeWheelBtnChangeHours(hourString, e),
+      tabIndex: tabIndex,
       role: "spinbutton",
       "aria-valuemax": "12",
       "aria-valuemin": "1",
       "aria-valuenow": currHourNum,
-      "aria-valuetext": `${hourString} hours`,
-      ...btnProps
-    }, hourString));
-  }), /* @__PURE__ */ React2.createElement(StyledWheelListItem, null, /* @__PURE__ */ React2.createElement(StyledWheelChangeTimeBtn, {
+      "aria-valuetext": "".concat(hourString, " hours")
+    }, btnProps), {}, {
+      children: hourString
+    })));
+  }), /*#__PURE__*/_jsx(StyledWheelListItem, {}, void 0, /*#__PURE__*/_jsx(StyledWheelChangeTimeBtn, {
     "aria-label": "add one hour",
     buttonType: "raw",
     size: "m",
@@ -79,9 +91,7 @@ const HoursList = () => {
     innerRef: nextHourBtnRef,
     tabIndex: -1,
     "data-testid": ControlledDateTimePickerDatatestid.TIMEWHEEL.NEXT_HOUR
-  }, /* @__PURE__ */ React2.createElement(ChevronSmallDown, null))));
+  }, void 0, _ChevronSmallDown || (_ChevronSmallDown = /*#__PURE__*/_jsx(ChevronSmallDown, {})))));
 };
-export {
-  HoursList
-};
-//# sourceMappingURL=HoursList.js.map
+
+export { HoursList };