@elliemae/ds-controlled-form 2.3.0-alpha.9 → 2.3.0-next.11

package/cjs/controlled-date-time-picker/parts/Pickers/TimeWheel/SecondsList.js

@@ -0,0 +1,92 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var _jsx = require('@babel/runtime/helpers/jsx');
+require('core-js/modules/esnext.async-iterator.map.js');
+require('core-js/modules/esnext.iterator.map.js');
+require('core-js/modules/esnext.async-iterator.filter.js');
+require('core-js/modules/esnext.iterator.constructor.js');
+require('core-js/modules/esnext.iterator.filter.js');
+require('core-js/modules/esnext.async-iterator.for-each.js');
+require('core-js/modules/esnext.iterator.for-each.js');
+var React = require('react');
+var DSButton = require('@elliemae/ds-button');
+var dsIcons = require('@elliemae/ds-icons');
+var numberHelpers = require('../../../utils/numberHelpers.js');
+var Styleds = require('./Styleds.js');
+var TimeWheelContext = require('./TimeWheelContext.js');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
+var _jsx__default = /*#__PURE__*/_interopDefaultLegacy(_jsx);
+var DSButton__default = /*#__PURE__*/_interopDefaultLegacy(DSButton);
+
+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__default["default"](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 SecondsList = () => {
+  const {
+    currSecondNum,
+    seconds,
+    visibleSeconds,
+    handlePrevSecond,
+    handleNextSecond,
+    handleTimeWheelBtnChangeSeconds,
+    handlePrevSecondBtnOnKeyDown,
+    handleCurrSecondsOnKeyDown,
+    handleNextSecondBtnOnKeyDown,
+    prevSecondsBtnRef,
+    currSecondsBtnRef,
+    nextSecondsBtnRef
+  } = React.useContext(TimeWheelContext.TimeWheelContext);
+  return /*#__PURE__*/_jsx__default["default"](Styleds.StyledWheelList, {}, void 0, /*#__PURE__*/_jsx__default["default"](Styleds.StyledWheelListItem, {}, void 0, /*#__PURE__*/_jsx__default["default"](Styleds.StyledWheelChangeTimeBtn, {
+    "aria-label": "subtract one minute",
+    buttonType: "raw",
+    size: "m",
+    variant: DSButton.BUTTON_VARIANT.DEFAULT,
+    onClick: handlePrevSecond,
+    onKeyDown: handlePrevSecondBtnOnKeyDown,
+    innerRef: prevSecondsBtnRef,
+    tabIndex: -1
+  }, void 0, _ChevronSmallUp || (_ChevronSmallUp = /*#__PURE__*/_jsx__default["default"](dsIcons.ChevronSmallUp, {})))), visibleSeconds.map(secondsString => {
+    const key = "timewheel-seconds-".concat(secondsString);
+    if (!secondsString) return /*#__PURE__*/_jsx__default["default"](Styleds.StyledWheelListItem, {}, key);
+    const isEmptyCurrValueCurrentListItem = !seconds && numberHelpers.convertToPositiveNumberIfPossible(secondsString) === currSecondNum;
+    const isCurrentListItem = isEmptyCurrValueCurrentListItem || seconds === secondsString;
+    const tabIndex = isCurrentListItem ? 0 : -1;
+    const btnProps = {
+      onKeyDown: isCurrentListItem ? handleCurrSecondsOnKeyDown : undefined,
+      innerRef: isCurrentListItem ? currSecondsBtnRef : undefined
+    };
+    return /*#__PURE__*/_jsx__default["default"](Styleds.StyledWheelListItem, {
+      isCurrentListItem: isCurrentListItem
+    }, key, /*#__PURE__*/jsxRuntime.jsx(DSButton__default["default"], _objectSpread(_objectSpread({
+      "aria-label": "set ".concat(secondsString, " seconds"),
+      buttonType: "raw",
+      size: "l",
+      variant: DSButton.BUTTON_VARIANT.DEFAULT,
+      onClick: e => handleTimeWheelBtnChangeSeconds(secondsString, e),
+      tabIndex: tabIndex
+    }, btnProps), {}, {
+      children: secondsString
+    })));
+  }), /*#__PURE__*/_jsx__default["default"](Styleds.StyledWheelListItem, {}, void 0, /*#__PURE__*/_jsx__default["default"](Styleds.StyledWheelChangeTimeBtn, {
+    "aria-label": "add one minute",
+    buttonType: "raw",
+    size: "m",
+    variant: DSButton.BUTTON_VARIANT.DEFAULT,
+    onClick: handleNextSecond,
+    onKeyDown: handleNextSecondBtnOnKeyDown,
+    innerRef: nextSecondsBtnRef,
+    tabIndex: -1
+  }, void 0, _ChevronSmallDown || (_ChevronSmallDown = /*#__PURE__*/_jsx__default["default"](dsIcons.ChevronSmallDown, {})))));
+};
+
+exports.SecondsList = SecondsList;
+exports["default"] = SecondsList;

package/cjs/controlled-date-time-picker/parts/Pickers/TimeWheel/Styleds.js

@@ -0,0 +1,241 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _taggedTemplateLiteral = require('@babel/runtime/helpers/taggedTemplateLiteral');
+var styled = require('styled-components');
+var dsSystem = require('@elliemae/ds-system');
+var dsGrid = require('@elliemae/ds-grid');
+var DSButton = require('@elliemae/ds-button');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _taggedTemplateLiteral__default = /*#__PURE__*/_interopDefaultLegacy(_taggedTemplateLiteral);
+var styled__default = /*#__PURE__*/_interopDefaultLegacy(styled);
+
+var _templateObject, _templateObject2, _templateObject3, _templateObject4, _templateObject5, _templateObject6;
+const focusBorder = dsSystem.css(_templateObject || (_templateObject = _taggedTemplateLiteral__default["default"](["\n  &:after {\n    position: absolute;\n    content: '';\n    top: -2px;\n    left: -2px;\n    width: calc(100% + 4px);\n    height: calc(100% + 4px);\n    border-radius: 50%;\n    border: 2px solid ", ";\n  }\n"])), _ref => {
+  let {
+    theme,
+    isDisabled
+  } = _ref;
+  return isDisabled ? theme.colors.danger[900] : theme.colors.brand[700];
+});
+const diagonalLine = dsSystem.css(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral__default["default"](["\n  &:before {\n    position: absolute;\n    content: '';\n    top: 48%;\n    left: -1px;\n    height: 1px;\n    width: calc(100% + 2px);\n    transform: rotate(45deg);\n    background-color: ", ";\n  }\n"])), _ref2 => {
+  let {
+    theme,
+    isCurrentListItem,
+    selected
+  } = _ref2;
+  if (selected) return theme.colors.neutral['000'];
+  if (isCurrentListItem) return theme.colors.danger[900];
+  return theme.colors.neutral[500];
+});
+const fontColorPerStatus = dsSystem.css(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral__default["default"](["\n  ", ";\n"])), _ref3 => {
+  let {
+    theme,
+    isDisabled,
+    isCurrentListItem,
+    selected
+  } = _ref3;
+  if (selected) return theme.colors.neutral['000'];
+  if (isDisabled && isCurrentListItem) return theme.colors.danger[900];
+  if (isDisabled) return theme.colors.neutral[500];
+  if (isCurrentListItem) return theme.colors.brand[600];
+  return theme.colors.neutral[800];
+});
+const hoverBgPerStatus = dsSystem.css(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral__default["default"](["\n  ", "\n"])), _ref4 => {
+  let {
+    theme,
+    selected,
+    isDisabled
+  } = _ref4;
+  if (isDisabled && selected) return theme.colors.danger[900];
+  if (selected) return theme.colors.brand[700];
+  return theme.colors.neutral['000'];
+});
+const StyledIconTriggerButton = /*#__PURE__*/styled__default["default"](DSButton.DSButtonV2).withConfig({
+  componentId: "sc-1nsw31l-0"
+})(["color:", ";width:26px;height:26px;"], _ref5 => {
+  let {
+    theme
+  } = _ref5;
+  return theme.colors.brand['600'];
+});
+const StyledWheelList = /*#__PURE__*/styled__default["default"].div.withConfig({
+  componentId: "sc-1nsw31l-1"
+})(["width:100%;height:100%;margin:auto;padding:0;position:relative;display:flex;flex-direction:column;align-items:center;&:focus-within{&:before{content:'';position:absolute;top:0;left:0;width:100%;height:100%;border-radius:2px;border:2px solid ", ";box-shadow:0 0 2px ", ";}}"], _ref6 => {
+  let {
+    theme
+  } = _ref6;
+  return theme.colors.brand[700];
+}, _ref7 => {
+  let {
+    theme
+  } = _ref7;
+  return theme.colors.brand[700];
+});
+const StyledTimePickerContainer = /*#__PURE__*/styled__default["default"].div.withConfig({
+  componentId: "sc-1nsw31l-2"
+})(["display:grid;position:relative;grid-template-columns:192px;grid-template-rows:36px 30px auto;grid-template-areas:'TimePickerHead' 'TimePickerWheelsLegend' 'VerticalWheelWrapper';", ""], _ref8 => {
+  let {
+    showShadow,
+    isControllerOnly
+  } = _ref8;
+  return showShadow && !isControllerOnly ? "\n  box-shadow: 0 6px 20px 0 rgb(0 0 0 / 24%), 0 8px 17px 0 rgb(0 0 0 / 19%);\n  " : '';
+});
+const StyledTimePickerHead = /*#__PURE__*/styled__default["default"](dsGrid.Grid).withConfig({
+  componentId: "sc-1nsw31l-3"
+})(["width:100%;grid-area:TimePickerHead;justify-content:center;align-items:center;background:", ";"], _ref9 => {
+  let {
+    theme
+  } = _ref9;
+  return theme.colors.neutral['050'];
+});
+const StyledTimePickerWheelsLegend = /*#__PURE__*/styled__default["default"].div.withConfig({
+  componentId: "sc-1nsw31l-4"
+})(["width:100%;height:100;grid-area:TimePickerWheelsLegend;display:grid;grid-template-columns:", " ", " ", ";align-items:center;justify-content:center;text-align:center;background:", ";"], _ref10 => {
+  let {
+    theme
+  } = _ref10;
+  return theme.space.xl;
+}, _ref11 => {
+  let {
+    theme
+  } = _ref11;
+  return theme.space.xl;
+}, _ref12 => {
+  let {
+    theme
+  } = _ref12;
+  return theme.space.xl;
+}, _ref13 => {
+  let {
+    theme
+  } = _ref13;
+  return theme.colors.neutral['050'];
+});
+const StyledTimePickerWheelWrapper = /*#__PURE__*/styled__default["default"].div.withConfig({
+  componentId: "sc-1nsw31l-5"
+})(["width:100%;background:", ";grid-area:VerticalWheelWrapper;display:grid;grid-template-columns:", " ", " ", ";grid-template-rows:100%;& ul:not(:last-child){position:relative;&:after{content:'';position:absolute;left:100%;top:5%;height:90%;width:1px;background:", ";}}"], _ref14 => {
+  let {
+    theme
+  } = _ref14;
+  return theme.colors.neutral['000'];
+}, _ref15 => {
+  let {
+    theme
+  } = _ref15;
+  return theme.space.xl;
+}, _ref16 => {
+  let {
+    theme
+  } = _ref16;
+  return theme.space.xl;
+}, _ref17 => {
+  let {
+    theme
+  } = _ref17;
+  return theme.space.xl;
+}, _ref18 => {
+  let {
+    theme
+  } = _ref18;
+  return theme.colors.neutral[200];
+});
+const StyledTimeBtn = /*#__PURE__*/styled__default["default"](DSButton.DSButtonV2).withConfig({
+  componentId: "sc-1nsw31l-6"
+})(["position:relative;height:", ";width:", ";border-radius:50%;&:hover{background-color:", ";}color:", ";", " ", " ", ";"], _ref19 => {
+  let {
+    theme
+  } = _ref19;
+  return theme.space.s;
+}, _ref20 => {
+  let {
+    theme
+  } = _ref20;
+  return theme.space.s;
+}, hoverBgPerStatus, fontColorPerStatus, _ref21 => {
+  let {
+    selected,
+    isCurrentListItem
+  } = _ref21;
+  return isCurrentListItem && !selected ? focusBorder : "";
+}, _ref22 => {
+  let {
+    isDisabled
+  } = _ref22;
+  return isDisabled ? dsSystem.css(_templateObject5 || (_templateObject5 = _taggedTemplateLiteral__default["default"](["\n          cursor: not-allowed;\n          ", ";\n        "])), diagonalLine) : "";
+}, _ref23 => {
+  let {
+    theme,
+    selected,
+    isDisabled
+  } = _ref23;
+  return selected ? dsSystem.css(_templateObject6 || (_templateObject6 = _taggedTemplateLiteral__default["default"](["\n    font-weight: ", ";\n    background-color ", ";\n    "])), theme.fontWeights.semibold, isDisabled ? theme.colors.danger[900] : theme.colors.brand[700]) : "";
+});
+const StyledWheelListItem = /*#__PURE__*/styled__default["default"].div.withConfig({
+  componentId: "sc-1nsw31l-7"
+})(["margin:auto;width:36px;height:36px;display:flex;align-items:center;justify-content:center;position:relative;"]);
+const StyledWheelChangeTimeBtn = /*#__PURE__*/styled__default["default"](DSButton.DSButtonV2).withConfig({
+  componentId: "sc-1nsw31l-8"
+})(["height:", ";width:", ";min-width:", ";border-radius:50%;"], _ref24 => {
+  let {
+    theme
+  } = _ref24;
+  return theme.space.s;
+}, _ref25 => {
+  let {
+    theme
+  } = _ref25;
+  return theme.space.s;
+}, _ref26 => {
+  let {
+    theme
+  } = _ref26;
+  return theme.space.s;
+});
+const TimeWheelFooterMessage = /*#__PURE__*/styled__default["default"].footer.withConfig({
+  componentId: "sc-1nsw31l-9"
+})(["border-top:solid 1px ", ";margin:0 ", ";padding:", " 0;color:", ";font-style:italic;font-weight:", ";font-size:", ";text-align:right;"], _ref27 => {
+  let {
+    theme
+  } = _ref27;
+  return theme.colors.neutral[300];
+}, _ref28 => {
+  let {
+    theme
+  } = _ref28;
+  return theme.space.xxs2;
+}, _ref29 => {
+  let {
+    theme
+  } = _ref29;
+  return theme.space.xxs2;
+}, _ref30 => {
+  let {
+    theme
+  } = _ref30;
+  return theme.colors.danger[900];
+}, _ref31 => {
+  let {
+    theme
+  } = _ref31;
+  return theme.fontWeights.thin;
+}, _ref32 => {
+  let {
+    theme
+  } = _ref32;
+  return theme.fontSizes.microText[200];
+});
+
+exports.StyledIconTriggerButton = StyledIconTriggerButton;
+exports.StyledTimeBtn = StyledTimeBtn;
+exports.StyledTimePickerContainer = StyledTimePickerContainer;
+exports.StyledTimePickerHead = StyledTimePickerHead;
+exports.StyledTimePickerWheelWrapper = StyledTimePickerWheelWrapper;
+exports.StyledTimePickerWheelsLegend = StyledTimePickerWheelsLegend;
+exports.StyledWheelChangeTimeBtn = StyledWheelChangeTimeBtn;
+exports.StyledWheelList = StyledWheelList;
+exports.StyledWheelListItem = StyledWheelListItem;
+exports.TimeWheelFooterMessage = TimeWheelFooterMessage;

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

@@ -0,0 +1,52 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _jsx = require('@babel/runtime/helpers/jsx');
+var React = require('react');
+var TimeWheelIconTrigger = require('./TimeWheelIconTrigger.js');
+var TimeWheelWrapper = require('./TimeWheelWrapper.js');
+var TimeWheelContext = require('./TimeWheelContext.js');
+var useConfigTimePickerCTX = require('./useConfigTimePickerCTX.js');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _jsx__default = /*#__PURE__*/_interopDefaultLegacy(_jsx);
+
+var _TimeWheelIconTrigger, _TimeWheelWrapper;
+
+const WrappedTimeWheelContext = _ref => {
+  let {
+    children
+  } = _ref;
+  const ctx = useConfigTimePickerCTX.useConfigTimePickerCTX();
+  return /*#__PURE__*/_jsx__default["default"](TimeWheelContext.TimeWheelContext.Provider, {
+    value: ctx
+  }, void 0, children);
+};
+
+const WrapWithTimeWheelContext = Component => {
+  var _WrappedTimeWheelCont;
+
+  return () => _WrappedTimeWheelCont || (_WrappedTimeWheelCont = /*#__PURE__*/_jsx__default["default"](WrappedTimeWheelContext, {}, void 0, /*#__PURE__*/_jsx__default["default"](Component, {})));
+}; // we use the HoC to be able to use the useContext and be sure it's correctly initialized
+// the HoC is Reused in CalendarWithTimeWheel
+
+const TimeWheel = WrapWithTimeWheelContext(() => {
+  const {
+    showTimePicker,
+    isControllerOnly,
+    handleMenuWrapperKeyDown
+  } = React.useContext(TimeWheelContext.TimeWheelContext);
+  return /*#__PURE__*/jsxRuntime.jsxs(jsxRuntime.Fragment, {
+    children: [isControllerOnly ? null : _TimeWheelIconTrigger || (_TimeWheelIconTrigger = /*#__PURE__*/_jsx__default["default"](TimeWheelIconTrigger.TimeWheelIconTrigger, {})), isControllerOnly || showTimePicker ? /*#__PURE__*/jsxRuntime.jsx(jsxRuntime.Fragment, {
+      children: /*#__PURE__*/_jsx__default["default"]("div", {
+        onKeyDown: handleMenuWrapperKeyDown
+      }, void 0, _TimeWheelWrapper || (_TimeWheelWrapper = /*#__PURE__*/_jsx__default["default"](TimeWheelWrapper.TimeWheelWrapper, {})))
+    }) : null]
+  });
+});
+
+exports.TimeWheel = TimeWheel;
+exports.WrapWithTimeWheelContext = WrapWithTimeWheelContext;

package/cjs/controlled-date-time-picker/parts/Pickers/TimeWheel/TimeWheelContent.js

@@ -0,0 +1,38 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _jsx = require('@babel/runtime/helpers/jsx');
+var React = require('react');
+var ControlledDateTimePickerDatatestid = require('../../../ControlledDateTimePickerDatatestid.js');
+var Styleds = require('./Styleds.js');
+var HoursList = require('./HoursList.js');
+var MinutesList = require('./MinutesList.js');
+var MeridiemList = require('./MeridiemList.js');
+var TimeWheelFooter = require('./TimeWheelFooter.js');
+var TimeWheelContext = require('./TimeWheelContext.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _jsx__default = /*#__PURE__*/_interopDefaultLegacy(_jsx);
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+
+var _StyledTimePickerWhee, _StyledTimePickerWhee2, _TimeWheelFooter;
+const TimeWheelContent = /*#__PURE__*/React__default["default"].memo(_ref => {
+  let {
+    showShadow
+  } = _ref;
+  const {
+    hours,
+    minutes,
+    meridiem,
+    isControllerOnly
+  } = React.useContext(TimeWheelContext.TimeWheelContext);
+  return /*#__PURE__*/_jsx__default["default"](Styleds.StyledTimePickerContainer, {
+    showShadow: showShadow,
+    isControllerOnly: isControllerOnly,
+    "data-testid": ControlledDateTimePickerDatatestid.ControlledDateTimePickerDatatestid.CONTROLLER_COMPONENT.TIMEWHEEL
+  }, void 0, /*#__PURE__*/_jsx__default["default"](Styleds.StyledTimePickerHead, {}, void 0, "".concat(hours || '__', ":").concat(minutes || '__', " ").concat(meridiem || '__')), _StyledTimePickerWhee || (_StyledTimePickerWhee = /*#__PURE__*/_jsx__default["default"](Styleds.StyledTimePickerWheelsLegend, {}, void 0, /*#__PURE__*/_jsx__default["default"]("div", {}, void 0, "H"), /*#__PURE__*/_jsx__default["default"]("div", {}, void 0, "M"), /*#__PURE__*/_jsx__default["default"]("div", {}, void 0, "A"))), _StyledTimePickerWhee2 || (_StyledTimePickerWhee2 = /*#__PURE__*/_jsx__default["default"](Styleds.StyledTimePickerWheelWrapper, {}, void 0, /*#__PURE__*/_jsx__default["default"](HoursList.HoursList, {}), /*#__PURE__*/_jsx__default["default"](MinutesList.MinutesList, {}), /*#__PURE__*/_jsx__default["default"](MeridiemList.MeridiemList, {}))), _TimeWheelFooter || (_TimeWheelFooter = /*#__PURE__*/_jsx__default["default"](TimeWheelFooter.TimeWheelFooter, {})));
+});
+
+exports.TimeWheelContent = TimeWheelContent;

package/cjs/controlled-date-time-picker/parts/Pickers/TimeWheel/TimeWheelContext.js

@@ -0,0 +1,79 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+
+/* eslint-disable @typescript-eslint/indent */
+
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+const noop = () => {};
+
+const defaultTimePickerContext = {
+  ariaCurrentValueForInputs: '',
+  tempTimeString: '',
+  showTimePicker: false,
+  setShowTimePicker: noop,
+  setPopperElement: noop,
+  setArrowElement: noop,
+  usePopperHelpers: null,
+  handleToggleTimePicker: noop,
+  handleSetTriggerRef: noop,
+  handleMenuWrapperKeyDown: noop,
+  currHourNum: 1,
+  hours: '01',
+  visibleHours: [''],
+  handlePrevHour: noop,
+  handleNextHour: noop,
+  handleTimeWheelBtnChangeHours: noop,
+  currMinuteNum: 1,
+  minutes: '00',
+  visibleMinutes: [''],
+  handlePrevMinute: noop,
+  handleNextMinute: noop,
+  handleTimeWheelBtnChangeMinutes: noop,
+  // currSecondNum: 1,
+  // seconds: '00',
+  // visibleSeconds: [''],
+  // handlePrevSecond: noop,
+  // handleNextSecond: noop,
+  // handleTimeWheelBtnChangeSeconds: noop,
+  meridiem: 'AM',
+  handleTimeWheelBtnChangeMeridiem: noop,
+  isControllerOnly: false,
+  autoFocusHourTimeWheel: false,
+  handlePrevHourBtnOnKeyDown: noop,
+  handleCurrHourOnKeyDown: noop,
+  handleNextHourBtnOnKeyDown: noop,
+  handlePrevMinuteBtnOnKeyDown: noop,
+  handleCurrMinutesOnKeyDown: noop,
+  handleNextMinuteBtnOnKeyDown: noop,
+  // handlePrevSecondBtnOnKeyDown: noop,
+  // handleCurrSecondsOnKeyDown: noop,
+  // handleNextSecondBtnOnKeyDown: noop,
+  handlePrevMeridiemBtnOnKeyDown: noop,
+  handleCurrMeridiemOnKeyDown: noop,
+  handleNextMeridiemBtnOnKeyDown: noop,
+  handlePickerIconKeyDown: noop,
+  prevHourBtnRef: /*#__PURE__*/React.createRef(),
+  currHourBtnRef: /*#__PURE__*/React.createRef(),
+  nextHourBtnRef: /*#__PURE__*/React.createRef(),
+  prevMinutesBtnRef: /*#__PURE__*/React.createRef(),
+  currMinutesBtnRef: /*#__PURE__*/React.createRef(),
+  nextMinutesBtnRef: /*#__PURE__*/React.createRef(),
+  // prevSecondsBtnRef: createRef<HTMLButtonElement>(),
+  // currSecondsBtnRef: createRef<HTMLButtonElement>(),
+  // nextSecondsBtnRef: createRef<HTMLButtonElement>(),
+  prevMeridiemBtnRef: /*#__PURE__*/React.createRef(),
+  currMeridiemBtnRef: /*#__PURE__*/React.createRef(),
+  nextMeridiemBtnRef: /*#__PURE__*/React.createRef(),
+  getIsDisabledTime: () => false,
+  disabled: false
+};
+/** Context for cross component communication */
+
+const TimeWheelContext = /*#__PURE__*/React.createContext(defaultTimePickerContext);
+
+exports.TimeWheelContext = TimeWheelContext;
+exports["default"] = TimeWheelContext;
+exports.defaultTimePickerContext = defaultTimePickerContext;

package/cjs/controlled-date-time-picker/parts/Pickers/TimeWheel/TimeWheelFooter.js

@@ -0,0 +1,28 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _jsx = require('@babel/runtime/helpers/jsx');
+var React = require('react');
+var ControlledDateTimePickerCTX = require('../../../ControlledDateTimePickerCTX.js');
+var Styleds = require('./Styleds.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _jsx__default = /*#__PURE__*/_interopDefaultLegacy(_jsx);
+
+const TimeWheelFooter = () => {
+  const {
+    props: {
+      pickerFooterMsg,
+      hasError
+    },
+    isWithCalendarToo
+  } = React.useContext(ControlledDateTimePickerCTX.ControlledDateTimePickerContext);
+  if (!isWithCalendarToo && pickerFooterMsg !== undefined && hasError) return /*#__PURE__*/_jsx__default["default"](Styleds.TimeWheelFooterMessage, {
+    role: "alert"
+  }, void 0, pickerFooterMsg);
+  return null;
+};
+
+exports.TimeWheelFooter = TimeWheelFooter;

package/cjs/controlled-date-time-picker/parts/Pickers/TimeWheel/TimeWheelIconTrigger.js

@@ -0,0 +1,40 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _jsx = require('@babel/runtime/helpers/jsx');
+var React = require('react');
+var DSButton = require('@elliemae/ds-button');
+var dsIcons = require('@elliemae/ds-icons');
+var TimeWheelContext = require('./TimeWheelContext.js');
+var ControlledDateTimePickerDatatestid = require('../../../ControlledDateTimePickerDatatestid.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _jsx__default = /*#__PURE__*/_interopDefaultLegacy(_jsx);
+
+var _RecentDocuments;
+// 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 TimeWheelIconTrigger = () => {
+  const {
+    handleSetTriggerRef,
+    handleToggleTimePicker,
+    handlePickerIconKeyDown,
+    ariaCurrentValueForInputs,
+    disabled
+  } = React.useContext(TimeWheelContext.TimeWheelContext);
+  return React.useMemo(() => /*#__PURE__*/_jsx__default["default"](DSButton.DSButtonV2, {
+    "aria-label": "time picker context menu trigger, ".concat(ariaCurrentValueForInputs),
+    buttonType: "icon",
+    size: DSButton.BUTTON_SIZES.M,
+    innerRef: handleSetTriggerRef,
+    onClick: handleToggleTimePicker,
+    onKeyDown: handlePickerIconKeyDown,
+    "data-testid": ControlledDateTimePickerDatatestid.ControlledDateTimePickerDatatestid.PICKER_ICONS.TIMEWHEEL,
+    disabled: disabled
+  }, void 0, _RecentDocuments || (_RecentDocuments = /*#__PURE__*/_jsx__default["default"](dsIcons.RecentDocuments, {}))), [ariaCurrentValueForInputs, disabled, handlePickerIconKeyDown, handleSetTriggerRef, handleToggleTimePicker]);
+};
+
+exports.TimeWheelIconTrigger = TimeWheelIconTrigger;

package/cjs/controlled-date-time-picker/parts/Pickers/TimeWheel/TimeWheelWrapper.js

@@ -0,0 +1,58 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('core-js/modules/esnext.async-iterator.filter.js');
+require('core-js/modules/esnext.iterator.constructor.js');
+require('core-js/modules/esnext.iterator.filter.js');
+require('core-js/modules/esnext.async-iterator.for-each.js');
+require('core-js/modules/esnext.iterator.for-each.js');
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var _jsx = require('@babel/runtime/helpers/jsx');
+var React = require('react');
+var ControlledDateTimePickerDatatestid = require('../../../ControlledDateTimePickerDatatestid.js');
+var TimeWheelContent = require('./TimeWheelContent.js');
+var TimeWheelContext = require('./TimeWheelContext.js');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
+var _jsx__default = /*#__PURE__*/_interopDefaultLegacy(_jsx);
+
+var _TimeWheelContent, _TimeWheelContent2;
+
+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__default["default"](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 TimeWheelWrapper = () => {
+  const {
+    setArrowElement,
+    setPopperElement,
+    usePopperHelpers: {
+      styles,
+      attributes
+    },
+    isControllerOnly
+  } = React.useContext(TimeWheelContext.TimeWheelContext);
+  if (isControllerOnly) return _TimeWheelContent || (_TimeWheelContent = /*#__PURE__*/_jsx__default["default"](TimeWheelContent.TimeWheelContent, {
+    showShadow: true
+  }));
+  return /*#__PURE__*/jsxRuntime.jsxs("div", _objectSpread(_objectSpread({
+    ref: setPopperElement,
+    style: _objectSpread(_objectSpread({}, styles.popper), {}, {
+      background: 'white',
+      zIndex: 110
+    })
+  }, attributes.popper), {}, {
+    "data-testid": ControlledDateTimePickerDatatestid.ControlledDateTimePickerDatatestid.CONTEXTUAL_MENU.TIMEWHEEL,
+    children: [_TimeWheelContent2 || (_TimeWheelContent2 = /*#__PURE__*/_jsx__default["default"](TimeWheelContent.TimeWheelContent, {
+      showShadow: true
+    })), /*#__PURE__*/jsxRuntime.jsx("div", {
+      ref: setArrowElement,
+      style: styles.arrow
+    })]
+  }));
+};
+
+exports.TimeWheelWrapper = TimeWheelWrapper;