@elliemae/ds-controlled-form 1.61.0 → 2.0.0-alpha.12

package/cjs/controlled-date-time-picker/config/useControlledDateTimePicker.js

@@ -3,322 +3,307 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var _defineProperty = require('@babel/runtime/helpers/defineProperty');
-var _slicedToArray = require('@babel/runtime/helpers/slicedToArray');
+require('core-js/modules/web.dom-collections.iterator.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 controlledDateTimePicker_config_useGetPropsWithDefault = require('./useGetPropsWithDefault.js');
-var controlledDateTimePicker_config_useGetDestructuredValues = require('./useGetDestructuredValues.js');
-var controlledDateTimePicker_ControlledDateTimePickerTypes = require('../ControlledDateTimePickerTypes.js');
-var controlledDateTimePicker_config_useValidateProps = require('./useValidateProps.js');
-var controlledDateTimePicker_utils_dateHelpers = require('../utils/dateHelpers.js');
-var controlledDateTimePicker_utils_timeHelpers = require('../utils/timeHelpers.js');
-var controlledDateTimePicker_utils_stringHelpers = require('../utils/stringHelpers.js');
-var controlledDateTimePicker_utils_constants = require('../utils/constants.js');
-require('@elliemae/ds-props-helpers');
-require('../ControlledDateTimePickerCTX.js');
-require('../utils/numberHelpers.js');
-require('@babel/runtime/helpers/typeof');
-require('@babel/runtime/helpers/toConsumableArray');
+var dsPropsHelpers = require('@elliemae/ds-props-helpers');
+var useGetPropsWithDefault = require('./useGetPropsWithDefault.js');
+var useGetDestructuredValues = require('./useGetDestructuredValues.js');
+var ControlledDateTimePickerTypes = require('../ControlledDateTimePickerTypes.js');
+var useValidateProps = require('./useValidateProps.js');
+var dateHelpers = require('../utils/dateHelpers.js');
+var timeHelpers = require('../utils/timeHelpers.js');
+var stringHelpers = require('../utils/stringHelpers.js');
+var constants = require('../utils/constants.js');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
 var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
-var _slicedToArray__default = /*#__PURE__*/_interopDefaultLegacy(_slicedToArray);
 var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty__default['default'](target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-var useControlledDateTimePicker = function useControlledDateTimePicker(props) {
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty__default["default"](target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+const useControlledDateTimePicker = props => {
   // if we detect wrong props configuration we throw meaningful errors
-  controlledDateTimePicker_config_useValidateProps.useValidateProps(props); // refs are used for "auto-advance" feature
-
-  var monthInputRef = React.useRef();
-  var dayInputRef = React.useRef();
-  var yearInputRef = React.useRef();
-  var hourInputRef = React.useRef();
-  var minutesInputRef = React.useRef();
-  var meridiemInputRef = React.useRef();
-  var clearButtonRef = React.useRef();
-  var pickerButtonRef = React.useRef();
-  var prevYearBtnRef = React.useRef();
-  var prevMonthBtnRef = React.useRef();
-  var nextMonthBtnRef = React.useRef();
-  var nextYearBtnRef = React.useRef();
-  var calendarDaysWrapperRef = React.useRef();
-  var prevHourBtnRef = React.useRef();
-  var currHourBtnRef = React.useRef();
-  var nextHourBtnRef = React.useRef();
-  var prevMinutesBtnRef = React.useRef();
-  var currMinutesBtnRef = React.useRef();
-  var nextMinutesBtnRef = React.useRef();
-  var prevMeridiemBtnRef = React.useRef();
-  var currMeridiemBtnRef = React.useRef();
-  var nextMeridiemBtnRef = React.useRef();
-  var propsWithDefaults = controlledDateTimePicker_config_useGetPropsWithDefault.useGetDatePickerWithDefaultsProps(props);
-  var type = propsWithDefaults.type,
-      getIsDisabledDay = propsWithDefaults.getIsDisabledDay,
-      getIsOutOfRangeDay = propsWithDefaults.getIsOutOfRangeDay,
-      getIsDisabledTime = propsWithDefaults.getIsDisabledTime,
-      isClearable = propsWithDefaults.isClearable,
-      autoFocus = propsWithDefaults.autoFocus,
-      appOnDateChange = propsWithDefaults.onDateChange,
-      appOnDateTimeChange = propsWithDefaults.onDateTimeChange,
-      appOnTimeChange = propsWithDefaults.onTimeChange,
-      appOnMonthChange = propsWithDefaults.onMonthChange,
-      appOnDayChange = propsWithDefaults.onDayChange,
-      appOnYearChange = propsWithDefaults.onYearChange,
-      appOnHourChange = propsWithDefaults.onHourChange,
-      appOnMinuteChange = propsWithDefaults.onMinuteChange,
-      appOnMeridiemChange = propsWithDefaults.onMeridiemChange,
-      appDate = propsWithDefaults.date,
-      appTime = propsWithDefaults.time,
-      appDateTime = propsWithDefaults.dateTime;
-  var dateStringFromProps = React.useMemo(function () {
-    return propsWithDefaults.dateTime && propsWithDefaults.dateTime !== '' ? controlledDateTimePicker_utils_stringHelpers.dateTimeToDate(propsWithDefaults.dateTime) : propsWithDefaults.date && propsWithDefaults.date !== '' ? propsWithDefaults.date : '__/__/____';
-  }, [propsWithDefaults.date, propsWithDefaults.dateTime]); // don't use tempDateString to trigger useEffect for onDateChange
+  useValidateProps.useValidateProps(props); // refs are used for "auto-advance" feature
+
+  const monthInputRef = React.useRef();
+  const dayInputRef = React.useRef();
+  const yearInputRef = React.useRef();
+  const hourInputRef = React.useRef();
+  const minutesInputRef = React.useRef();
+  const meridiemInputRef = React.useRef();
+  const clearButtonRef = React.useRef();
+  const pickerButtonRef = React.useRef();
+  const prevYearBtnRef = React.useRef();
+  const prevMonthBtnRef = React.useRef();
+  const nextMonthBtnRef = React.useRef();
+  const nextYearBtnRef = React.useRef();
+  const calendarDaysWrapperRef = React.useRef();
+  const prevHourBtnRef = React.useRef();
+  const currHourBtnRef = React.useRef();
+  const nextHourBtnRef = React.useRef();
+  const prevMinutesBtnRef = React.useRef();
+  const currMinutesBtnRef = React.useRef();
+  const nextMinutesBtnRef = React.useRef();
+  const prevMeridiemBtnRef = React.useRef();
+  const currMeridiemBtnRef = React.useRef();
+  const nextMeridiemBtnRef = React.useRef();
+  const propsWithDefaults = useGetPropsWithDefault.useGetDatePickerWithDefaultsProps(props);
+  const dataAttrs = dsPropsHelpers.getDataProps(props);
+  const {
+    type,
+    getIsDisabledDay,
+    getIsOutOfRangeDay,
+    getIsDisabledTime,
+    isClearable,
+    autoFocus,
+    onDateChange: appOnDateChange,
+    onDateTimeChange: appOnDateTimeChange,
+    onTimeChange: appOnTimeChange,
+    onMonthChange: appOnMonthChange,
+    onDayChange: appOnDayChange,
+    onYearChange: appOnYearChange,
+    onHourChange: appOnHourChange,
+    onMinuteChange: appOnMinuteChange,
+    onMeridiemChange: appOnMeridiemChange,
+    date: appDate,
+    time: appTime,
+    dateTime: appDateTime
+  } = propsWithDefaults;
+  const dateStringFromProps = React.useMemo(() => propsWithDefaults.dateTime && propsWithDefaults.dateTime !== '' ? stringHelpers.dateTimeToDate(propsWithDefaults.dateTime) : propsWithDefaults.date && propsWithDefaults.date !== '' ? propsWithDefaults.date : '__/__/____', [propsWithDefaults.date, propsWithDefaults.dateTime]); // don't use tempDateString to trigger useEffect for onDateChange
   // that is an anti-pattern and leads to a lot of issue
   // if you don't believe me, check date-time-picker v1 which is doing it
 
-  var _useState = React.useState(dateStringFromProps),
-      _useState2 = _slicedToArray__default['default'](_useState, 2),
-      tempDateString = _useState2[0],
-      setTempDateString = _useState2[1];
-
-  var timeStringFromProps = React.useMemo(function () {
-    return propsWithDefaults.dateTime && propsWithDefaults.dateTime !== '' ? controlledDateTimePicker_utils_stringHelpers.dateTimeToTime(propsWithDefaults.dateTime) : propsWithDefaults.time && propsWithDefaults.time !== '' ? propsWithDefaults.time : '__:__ __';
-  }, [propsWithDefaults.time, propsWithDefaults.dateTime]); // don't use tempTimeString to trigger useEffect for onTimeChange
+  const [tempDateString, setTempDateString] = React.useState(dateStringFromProps);
+  const timeStringFromProps = React.useMemo(() => propsWithDefaults.dateTime && propsWithDefaults.dateTime !== '' ? stringHelpers.dateTimeToTime(propsWithDefaults.dateTime) : propsWithDefaults.time && propsWithDefaults.time !== '' ? propsWithDefaults.time : '__:__ __', [propsWithDefaults.time, propsWithDefaults.dateTime]); // don't use tempTimeString to trigger useEffect for onTimeChange
   // that is an anti-pattern and leads to a lot of issue
   // if you don't believe me, check date-time-picker v1 which is doing it
 
-  var _useState3 = React.useState(timeStringFromProps),
-      _useState4 = _slicedToArray__default['default'](_useState3, 2),
-      tempTimeString = _useState4[0],
-      setTimeString = _useState4[1];
-
-  var hideDate = type !== controlledDateTimePicker_ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE_TIME.FULL && type !== controlledDateTimePicker_ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE_TIME.INPUTS && type !== controlledDateTimePicker_ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE.FULL && type !== controlledDateTimePicker_ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE.INPUTS;
-  var hideTime = type !== controlledDateTimePicker_ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE_TIME.FULL && type !== controlledDateTimePicker_ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE_TIME.INPUTS && type !== controlledDateTimePicker_ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.TIME.FULL && type !== controlledDateTimePicker_ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.TIME.INPUTS;
-  var hideDateTimePicker = type !== controlledDateTimePicker_ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE_TIME.FULL && type !== controlledDateTimePicker_ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE_TIME.PICKER && type !== controlledDateTimePicker_ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE_TIME.CONTROLLER_ONLY;
-  var hideDatePicker = type !== controlledDateTimePicker_ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE.FULL && type !== controlledDateTimePicker_ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE.PICKER && type !== controlledDateTimePicker_ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE.CONTROLLER_ONLY;
-  var hideTimePicker = type !== controlledDateTimePicker_ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.TIME.FULL && type !== controlledDateTimePicker_ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.TIME.PICKER && type !== controlledDateTimePicker_ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.TIME.CONTROLLER_ONLY;
-  var isDateSelector = type === controlledDateTimePicker_ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE.FULL || type === controlledDateTimePicker_ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE.INPUTS || type === controlledDateTimePicker_ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE.PICKER || type === controlledDateTimePicker_ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE.CONTROLLER_ONLY;
-  var isTimeSelector = type === controlledDateTimePicker_ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.TIME.FULL || type === controlledDateTimePicker_ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.TIME.INPUTS || type === controlledDateTimePicker_ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.TIME.PICKER || type === controlledDateTimePicker_ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.TIME.CONTROLLER_ONLY;
-  var isDateTimeSelector = type === controlledDateTimePicker_ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE_TIME.FULL || type === controlledDateTimePicker_ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE_TIME.INPUTS || type === controlledDateTimePicker_ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE_TIME.PICKER || type === controlledDateTimePicker_ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE_TIME.CONTROLLER_ONLY;
-  var isControllerOnly = type === controlledDateTimePicker_ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE_TIME.CONTROLLER_ONLY || type === controlledDateTimePicker_ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE.CONTROLLER_ONLY || type === controlledDateTimePicker_ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.TIME.CONTROLLER_ONLY;
-  var isWithTimeWheelToo = type === controlledDateTimePicker_ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE_TIME.FULL || type === controlledDateTimePicker_ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE_TIME.PICKER || type === controlledDateTimePicker_ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE_TIME.CONTROLLER_ONLY;
-  var isWithCalendarToo = type === controlledDateTimePicker_ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE_TIME.FULL || type === controlledDateTimePicker_ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE_TIME.PICKER || type === controlledDateTimePicker_ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE_TIME.CONTROLLER_ONLY;
-  var withAnyInputs = !hideDate || !hideTime;
-  var withAnyPicker = !hideDateTimePicker || !hideTimePicker || !hideDatePicker;
-  var withClearBtn = isClearable && withAnyInputs && (dateStringFromProps !== '__/__/____' && dateStringFromProps !== '' || // date is not "empty-ish"
+  const [tempTimeString, setTimeString] = React.useState(timeStringFromProps);
+  const hideDate = type !== ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE_TIME.FULL && type !== ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE_TIME.INPUTS && type !== ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE.FULL && type !== ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE.INPUTS;
+  const hideTime = type !== ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE_TIME.FULL && type !== ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE_TIME.INPUTS && type !== ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.TIME.FULL && type !== ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.TIME.INPUTS;
+  const hideDateTimePicker = type !== ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE_TIME.FULL && type !== ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE_TIME.PICKER && type !== ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE_TIME.CONTROLLER_ONLY;
+  const hideDatePicker = type !== ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE.FULL && type !== ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE.PICKER && type !== ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE.CONTROLLER_ONLY;
+  const hideTimePicker = type !== ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.TIME.FULL && type !== ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.TIME.PICKER && type !== ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.TIME.CONTROLLER_ONLY;
+  const isDateSelector = type === ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE.FULL || type === ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE.INPUTS || type === ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE.PICKER || type === ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE.CONTROLLER_ONLY;
+  const isTimeSelector = type === ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.TIME.FULL || type === ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.TIME.INPUTS || type === ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.TIME.PICKER || type === ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.TIME.CONTROLLER_ONLY;
+  const isDateTimeSelector = type === ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE_TIME.FULL || type === ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE_TIME.INPUTS || type === ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE_TIME.PICKER || type === ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE_TIME.CONTROLLER_ONLY;
+  const isControllerOnly = type === ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE_TIME.CONTROLLER_ONLY || type === ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE.CONTROLLER_ONLY || type === ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.TIME.CONTROLLER_ONLY;
+  const isWithTimeWheelToo = type === ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE_TIME.FULL || type === ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE_TIME.PICKER || type === ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE_TIME.CONTROLLER_ONLY;
+  const isWithCalendarToo = type === ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE_TIME.FULL || type === ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE_TIME.PICKER || type === ControlledDateTimePickerTypes.CONTROLLED_DATE_TIME_PICKER_TYPES.DATE_TIME.CONTROLLER_ONLY;
+  const withAnyInputs = !hideDate || !hideTime;
+  const withAnyPicker = !hideDateTimePicker || !hideTimePicker || !hideDatePicker;
+  const withClearBtn = isClearable && withAnyInputs && (dateStringFromProps !== '__/__/____' && dateStringFromProps !== '' || // date is not "empty-ish"
   timeStringFromProps !== '__:__ __' && timeStringFromProps !== ''); // or time is not "empty-ish"
 
-  var isWithDateInputs = withAnyInputs && (isDateTimeSelector || isDateSelector);
-  var isWithDateInputsOnly = withAnyInputs && isDateSelector;
-  var isWithTimeInputs = withAnyInputs && (isDateTimeSelector || isTimeSelector);
-  var isWithTimeInputsOnly = withAnyInputs && isTimeSelector;
-  var autoFocusMonthInput = isWithDateInputs && autoFocus;
-  var autoFocusHourInput = isWithTimeInputsOnly && autoFocus;
-  var autoFocusPrevMonthArrow = isControllerOnly && autoFocus;
-  var autoFocusHourTimeWheel = isControllerOnly && isTimeSelector && autoFocus;
-  var shouldPreserveClearableSpace = isClearable && withAnyInputs;
-  var withAnyRightController = withAnyPicker || withClearBtn || shouldPreserveClearableSpace;
-
-  var _useState5 = React.useState(''),
-      _useState6 = _slicedToArray__default['default'](_useState5, 2),
-      latestInteractionRegion = _useState6[0],
-      setLatestInteractionRegion = _useState6[1];
-
-  var firstSegmentRef = React.useRef();
+  const isWithDateInputs = withAnyInputs && (isDateTimeSelector || isDateSelector);
+  const isWithDateInputsOnly = withAnyInputs && isDateSelector;
+  const isWithTimeInputs = withAnyInputs && (isDateTimeSelector || isTimeSelector);
+  const isWithTimeInputsOnly = withAnyInputs && isTimeSelector;
+  const autoFocusMonthInput = isWithDateInputs && autoFocus;
+  const autoFocusHourInput = isWithTimeInputsOnly && autoFocus;
+  const autoFocusPrevMonthArrow = isControllerOnly && autoFocus;
+  const autoFocusHourTimeWheel = isControllerOnly && isTimeSelector && autoFocus;
+  const shouldPreserveClearableSpace = isClearable && withAnyInputs;
+  const withAnyRightController = withAnyPicker || withClearBtn || shouldPreserveClearableSpace;
+  const [latestInteractionRegion, setLatestInteractionRegion] = React.useState('');
+  let firstSegmentRef = React.useRef();
   if (isWithDateInputs) firstSegmentRef = monthInputRef;else if (isWithTimeInputs) firstSegmentRef = hourInputRef;else if (withAnyPicker) firstSegmentRef = pickerButtonRef;
-  var lastSegmentRef = React.useRef();
+  let lastSegmentRef = React.useRef();
   if (withAnyPicker) lastSegmentRef = pickerButtonRef;else if (withClearBtn) lastSegmentRef = clearButtonRef;else if (isWithTimeInputs) lastSegmentRef = meridiemInputRef;else if (isWithDateInputs) lastSegmentRef = yearInputRef;
-
-  var _useGetDestructuredVa = controlledDateTimePicker_config_useGetDestructuredValues.useGetDestructuredValues({
+  const {
+    month,
+    day,
+    year,
+    monthNum,
+    dayNum,
+    yearNum,
+    announcedMonth,
+    announcedDay,
+    announcedYear,
+    announcedDateValues,
+    hours,
+    minutes,
+    meridiem,
+    hoursNum,
+    minutesNum,
+    announcedHours,
+    announcedMinutes,
+    announcedMeridiem,
+    announcedTimeValues
+  } = useGetDestructuredValues.useGetDestructuredValues({
     date: appDate,
     time: appTime,
     dateTime: appDateTime,
-    isDateTimeSelector: isDateTimeSelector
-  }),
-      month = _useGetDestructuredVa.month,
-      day = _useGetDestructuredVa.day,
-      year = _useGetDestructuredVa.year,
-      monthNum = _useGetDestructuredVa.monthNum,
-      dayNum = _useGetDestructuredVa.dayNum,
-      yearNum = _useGetDestructuredVa.yearNum,
-      announcedMonth = _useGetDestructuredVa.announcedMonth,
-      announcedDay = _useGetDestructuredVa.announcedDay,
-      announcedYear = _useGetDestructuredVa.announcedYear,
-      announcedDateValues = _useGetDestructuredVa.announcedDateValues,
-      hours = _useGetDestructuredVa.hours,
-      minutes = _useGetDestructuredVa.minutes,
-      meridiem = _useGetDestructuredVa.meridiem,
-      hoursNum = _useGetDestructuredVa.hoursNum,
-      minutesNum = _useGetDestructuredVa.minutesNum,
-      announcedHours = _useGetDestructuredVa.announcedHours,
-      announcedMinutes = _useGetDestructuredVa.announcedMinutes,
-      announcedMeridiem = _useGetDestructuredVa.announcedMeridiem,
-      announcedTimeValues = _useGetDestructuredVa.announcedTimeValues;
-
-  var ariaCurrentValueForInputs = "current values: ".concat(isWithDateInputs ? "".concat(announcedDateValues) : '').concat(isDateTimeSelector ? ', ' : '').concat(isWithTimeInputs ? "".concat(announcedTimeValues) : '');
-  var getDateMetaInfo = React.useCallback(function () {
-    var newDateString = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
-    var metaInfo = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    var finalDateString = newDateString || tempDateString;
-    return _objectSpread(_objectSpread({}, metaInfo), controlledDateTimePicker_utils_dateHelpers.getValidationDateStringMetaInfo(finalDateString, getIsOutOfRangeDay, getIsDisabledDay));
+    isDateTimeSelector
+  });
+  const ariaCurrentValueForInputs = "current values: ".concat(isWithDateInputs ? "".concat(announcedDateValues) : '').concat(isDateTimeSelector ? ', ' : '').concat(isWithTimeInputs ? "".concat(announcedTimeValues) : '');
+  const getDateMetaInfo = React.useCallback(function () {
+    let newDateString = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+    let metaInfo = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    const finalDateString = newDateString || tempDateString;
+    return _objectSpread(_objectSpread({}, metaInfo), dateHelpers.getValidationDateStringMetaInfo(finalDateString, getIsOutOfRangeDay, getIsDisabledDay));
   }, [tempDateString, getIsDisabledDay, getIsOutOfRangeDay]);
-  var getTimeMetaInfo = React.useCallback(function () {
-    var newTimeString = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
-    var metaInfo = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    var finalTimeString = newTimeString || tempTimeString;
-    return _objectSpread(_objectSpread({}, metaInfo), controlledDateTimePicker_utils_timeHelpers.getValidationTimeStringMetaInfo(finalTimeString, getIsDisabledTime));
+  const getTimeMetaInfo = React.useCallback(function () {
+    let newTimeString = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+    let metaInfo = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    const finalTimeString = newTimeString || tempTimeString;
+    return _objectSpread(_objectSpread({}, metaInfo), timeHelpers.getValidationTimeStringMetaInfo(finalTimeString, getIsDisabledTime));
   }, [tempTimeString, getIsDisabledTime]);
-  var handleChangeComposedDateTimeString = React.useCallback(function (newDateString, newTimeString, metaInfo) {
-    var appDateString = controlledDateTimePicker_utils_stringHelpers.isEmptyDateStringMask(newDateString) ? '' : newDateString;
-    var appTimeString = controlledDateTimePicker_utils_stringHelpers.isEmptyTimeStringMask(newTimeString) ? '' : newTimeString;
+  const handleChangeComposedDateTimeString = React.useCallback((newDateString, newTimeString, metaInfo) => {
+    const appDateString = stringHelpers.isEmptyDateStringMask(newDateString) ? '' : newDateString;
+    const appTimeString = stringHelpers.isEmptyTimeStringMask(newTimeString) ? '' : newTimeString;
     appOnDateChange(appDateString, metaInfo); // don't do this on useEffect to avoid complete chaos
 
     setTempDateString(newDateString);
     appOnTimeChange(appTimeString, metaInfo); // don't do this on useEffect to avoid complete chaos
 
     setTimeString(newTimeString);
-    var newDateTimeString = "".concat(newDateString, " ").concat(newTimeString);
+    const newDateTimeString = "".concat(newDateString, " ").concat(newTimeString);
 
-    var newMetaInfo = _objectSpread(_objectSpread(_objectSpread({}, getTimeMetaInfo(newTimeString, metaInfo)), getDateMetaInfo(newDateString, metaInfo)), {}, {
-      newDateString: newDateString,
-      newTimeString: newTimeString,
-      newDateTimeString: newDateTimeString
+    const newMetaInfo = _objectSpread(_objectSpread(_objectSpread({}, getTimeMetaInfo(newTimeString, metaInfo)), getDateMetaInfo(newDateString, metaInfo)), {}, {
+      newDateString,
+      newTimeString,
+      newDateTimeString
     });
 
-    var appDateTimeString = controlledDateTimePicker_utils_stringHelpers.isEmptyDateTimeStringMask(newDateTimeString) ? '' : newDateTimeString;
+    const appDateTimeString = stringHelpers.isEmptyDateTimeStringMask(newDateTimeString) ? '' : newDateTimeString;
     appOnDateTimeChange(appDateTimeString, newMetaInfo); // don't do this on useEffect to avoid complete chaos
   }, [appOnDateChange, appOnTimeChange, getTimeMetaInfo, getDateMetaInfo, appOnDateTimeChange]);
-  var handleChangeComposedDateString = React.useCallback(function (newDateString, metaInfo) {
+  const handleChangeComposedDateString = React.useCallback((newDateString, metaInfo) => {
     // if we receive an "empty" mask, we comunicate empty string to the app
-    var appDateString = controlledDateTimePicker_utils_stringHelpers.isEmptyDateStringMask(newDateString) ? '' : newDateString;
+    const appDateString = stringHelpers.isEmptyDateStringMask(newDateString) ? '' : newDateString;
     appOnDateChange(appDateString, metaInfo); // don't do this on useEffect to avoid complete chaos
 
     setTempDateString(newDateString);
-    var newDateTimeString = "".concat(newDateString, " ").concat(tempTimeString);
+    const newDateTimeString = "".concat(newDateString, " ").concat(tempTimeString);
 
-    var newMetaInfo = _objectSpread(_objectSpread(_objectSpread({}, getTimeMetaInfo(tempTimeString, metaInfo)), getDateMetaInfo(newDateString, metaInfo)), {}, {
-      newDateString: newDateString,
+    const newMetaInfo = _objectSpread(_objectSpread(_objectSpread({}, getTimeMetaInfo(tempTimeString, metaInfo)), getDateMetaInfo(newDateString, metaInfo)), {}, {
+      newDateString,
       newTimeString: tempTimeString,
-      newDateTimeString: newDateTimeString
+      newDateTimeString
     });
 
-    var appDateTimeString = controlledDateTimePicker_utils_stringHelpers.isEmptyDateTimeStringMask(newDateTimeString) ? '' : newDateTimeString;
+    const appDateTimeString = stringHelpers.isEmptyDateTimeStringMask(newDateTimeString) ? '' : newDateTimeString;
     appOnDateTimeChange(appDateTimeString, newMetaInfo); // don't do this on useEffect to avoid complete chaos
   }, [appOnDateChange, tempTimeString, getTimeMetaInfo, getDateMetaInfo, appOnDateTimeChange]);
-  var handleChangeComposedTimeString = React.useCallback(function (newTimeString, metaInfo) {
-    var appTimeString = controlledDateTimePicker_utils_stringHelpers.isEmptyTimeStringMask(newTimeString) ? '' : newTimeString;
+  const handleChangeComposedTimeString = React.useCallback((newTimeString, metaInfo) => {
+    const appTimeString = stringHelpers.isEmptyTimeStringMask(newTimeString) ? '' : newTimeString;
     appOnTimeChange(appTimeString, metaInfo); // don't do this on useEffect to avoid complete chaos
 
     setTimeString(newTimeString);
-    var newDateTimeString = "".concat(tempDateString, " ").concat(newTimeString);
+    const newDateTimeString = "".concat(tempDateString, " ").concat(newTimeString);
 
-    var newMetaInfo = _objectSpread(_objectSpread(_objectSpread({}, getTimeMetaInfo(newTimeString, metaInfo)), getDateMetaInfo(tempDateString, metaInfo)), {}, {
-      newDateTimeString: newDateTimeString,
+    const newMetaInfo = _objectSpread(_objectSpread(_objectSpread({}, getTimeMetaInfo(newTimeString, metaInfo)), getDateMetaInfo(tempDateString, metaInfo)), {}, {
+      newDateTimeString,
       newDateString: tempDateString,
-      newTimeString: newTimeString
+      newTimeString
     });
 
-    var appDateTimeString = controlledDateTimePicker_utils_stringHelpers.isEmptyDateTimeStringMask(newDateTimeString) ? '' : newDateTimeString;
+    const appDateTimeString = stringHelpers.isEmptyDateTimeStringMask(newDateTimeString) ? '' : newDateTimeString;
     appOnDateTimeChange(appDateTimeString, newMetaInfo); // don't do this on useEffect to avoid complete chaos
   }, [appOnTimeChange, tempDateString, getTimeMetaInfo, getDateMetaInfo, appOnDateTimeChange]);
-  var handleChangeMonth = React.useCallback(function (newMonth, e) {
-    var metaInfo = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : controlledDateTimePicker_utils_constants.defaultMetaInfo;
-    var newDateString = controlledDateTimePicker_utils_stringHelpers.getFormattedDateString({
+  const handleChangeMonth = React.useCallback(function (newMonth, e) {
+    let metaInfo = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : constants.defaultMetaInfo;
+    const newDateString = stringHelpers.getFormattedDateString({
       month: newMonth,
-      day: day,
-      year: year
+      day,
+      year
     });
 
-    var finalMetaInfo = _objectSpread(_objectSpread(_objectSpread({}, metaInfo), controlledDateTimePicker_utils_dateHelpers.getValidationDateStringMetaInfo(newDateString, getIsOutOfRangeDay, getIsDisabledDay)), {}, {
-      newDateString: newDateString
+    const finalMetaInfo = _objectSpread(_objectSpread(_objectSpread({}, metaInfo), dateHelpers.getValidationDateStringMetaInfo(newDateString, getIsOutOfRangeDay, getIsDisabledDay)), {}, {
+      newDateString
     });
 
     appOnMonthChange(newMonth, e, finalMetaInfo);
     handleChangeComposedDateString(newDateString, finalMetaInfo);
   }, [day, year, getIsOutOfRangeDay, getIsDisabledDay, appOnMonthChange, handleChangeComposedDateString]);
-  var handleChangeDay = React.useCallback(function (newDay, e) {
-    var metaInfo = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : controlledDateTimePicker_utils_constants.defaultMetaInfo;
-    var newDateString = controlledDateTimePicker_utils_stringHelpers.getFormattedDateString({
-      month: month,
+  const handleChangeDay = React.useCallback(function (newDay, e) {
+    let metaInfo = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : constants.defaultMetaInfo;
+    const newDateString = stringHelpers.getFormattedDateString({
+      month,
       day: newDay,
-      year: year
+      year
     });
 
-    var finalMetaInfo = _objectSpread(_objectSpread(_objectSpread({}, metaInfo), controlledDateTimePicker_utils_dateHelpers.getValidationDateStringMetaInfo(newDateString, getIsOutOfRangeDay, getIsDisabledDay)), {}, {
-      newDateString: newDateString
+    const finalMetaInfo = _objectSpread(_objectSpread(_objectSpread({}, metaInfo), dateHelpers.getValidationDateStringMetaInfo(newDateString, getIsOutOfRangeDay, getIsDisabledDay)), {}, {
+      newDateString
     });
 
     appOnDayChange(newDay, e, finalMetaInfo);
     handleChangeComposedDateString(newDateString, finalMetaInfo);
   }, [month, year, getIsOutOfRangeDay, getIsDisabledDay, appOnDayChange, handleChangeComposedDateString]);
-  var handleChangeYear = React.useCallback(function (newYear, e) {
-    var metaInfo = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : controlledDateTimePicker_utils_constants.defaultMetaInfo;
-    var newDateString = controlledDateTimePicker_utils_stringHelpers.getFormattedDateString({
-      month: month,
-      day: day,
+  const handleChangeYear = React.useCallback(function (newYear, e) {
+    let metaInfo = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : constants.defaultMetaInfo;
+    const newDateString = stringHelpers.getFormattedDateString({
+      month,
+      day,
       year: newYear
     });
 
-    var finalMetaInfo = _objectSpread(_objectSpread(_objectSpread({}, metaInfo), controlledDateTimePicker_utils_dateHelpers.getValidationDateStringMetaInfo(newDateString, getIsOutOfRangeDay, getIsDisabledDay)), {}, {
-      newDateString: newDateString
+    const finalMetaInfo = _objectSpread(_objectSpread(_objectSpread({}, metaInfo), dateHelpers.getValidationDateStringMetaInfo(newDateString, getIsOutOfRangeDay, getIsDisabledDay)), {}, {
+      newDateString
     });
 
     appOnYearChange(newYear, e, finalMetaInfo);
     handleChangeComposedDateString(newDateString, finalMetaInfo);
   }, [month, day, getIsOutOfRangeDay, getIsDisabledDay, appOnYearChange, handleChangeComposedDateString]);
-  var handleChangeHours = React.useCallback(function (newHours, e) {
-    var metaInfo = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : controlledDateTimePicker_utils_constants.defaultMetaInfo;
-    var newTimeString = controlledDateTimePicker_utils_stringHelpers.getFormattedTimeString({
+  const handleChangeHours = React.useCallback(function (newHours, e) {
+    let metaInfo = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : constants.defaultMetaInfo;
+    const newTimeString = stringHelpers.getFormattedTimeString({
       hours: newHours,
-      minutes: minutes,
+      minutes,
       // seconds,
-      meridiem: meridiem
+      meridiem
     });
 
-    var finalMetaInfo = _objectSpread(_objectSpread(_objectSpread({}, metaInfo), controlledDateTimePicker_utils_timeHelpers.getValidationTimeStringMetaInfo(newTimeString, getIsDisabledTime)), {}, {
-      newTimeString: newTimeString
+    const finalMetaInfo = _objectSpread(_objectSpread(_objectSpread({}, metaInfo), timeHelpers.getValidationTimeStringMetaInfo(newTimeString, getIsDisabledTime)), {}, {
+      newTimeString
     });
 
     appOnHourChange(newHours, e, finalMetaInfo);
     handleChangeComposedTimeString(newTimeString, finalMetaInfo);
   }, [minutes, meridiem, getIsDisabledTime, appOnHourChange, handleChangeComposedTimeString]);
-  var handleChangeMinutes = React.useCallback(function (newMinutes, e) {
-    var metaInfo = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : controlledDateTimePicker_utils_constants.defaultMetaInfo;
-    var newTimeString = controlledDateTimePicker_utils_stringHelpers.getFormattedTimeString({
-      hours: hours,
+  const handleChangeMinutes = React.useCallback(function (newMinutes, e) {
+    let metaInfo = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : constants.defaultMetaInfo;
+    const newTimeString = stringHelpers.getFormattedTimeString({
+      hours,
       minutes: newMinutes,
       // seconds,
-      meridiem: meridiem
+      meridiem
     });
 
-    var finalMetaInfo = _objectSpread(_objectSpread(_objectSpread({}, metaInfo), controlledDateTimePicker_utils_timeHelpers.getValidationTimeStringMetaInfo(newTimeString, getIsDisabledTime)), {}, {
-      newTimeString: newTimeString
+    const finalMetaInfo = _objectSpread(_objectSpread(_objectSpread({}, metaInfo), timeHelpers.getValidationTimeStringMetaInfo(newTimeString, getIsDisabledTime)), {}, {
+      newTimeString
     });
 
     appOnMinuteChange(newMinutes, e, finalMetaInfo);
     handleChangeComposedTimeString(newTimeString, finalMetaInfo);
   }, [hours, meridiem, getIsDisabledTime, appOnMinuteChange, handleChangeComposedTimeString]);
-  var handleChangeMeridiem = React.useCallback(function (newMeridiem, e) {
-    var metaInfo = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : controlledDateTimePicker_utils_constants.defaultMetaInfo;
-    var newTimeString = controlledDateTimePicker_utils_stringHelpers.getFormattedTimeString({
-      hours: hours,
-      minutes: minutes,
+  const handleChangeMeridiem = React.useCallback(function (newMeridiem, e) {
+    let metaInfo = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : constants.defaultMetaInfo;
+    const newTimeString = stringHelpers.getFormattedTimeString({
+      hours,
+      minutes,
       // seconds,
       meridiem: newMeridiem
     });
 
-    var finalMetaInfo = _objectSpread(_objectSpread(_objectSpread({}, metaInfo), controlledDateTimePicker_utils_timeHelpers.getValidationTimeStringMetaInfo(newTimeString, getIsDisabledTime)), {}, {
-      newTimeString: newTimeString
+    const finalMetaInfo = _objectSpread(_objectSpread(_objectSpread({}, metaInfo), timeHelpers.getValidationTimeStringMetaInfo(newTimeString, getIsDisabledTime)), {}, {
+      newTimeString
     });
 
     appOnMeridiemChange(newMeridiem, e, finalMetaInfo);
     handleChangeComposedTimeString(newTimeString, finalMetaInfo);
   }, [hours, minutes, getIsDisabledTime, appOnMeridiemChange, handleChangeComposedTimeString]);
-  var handleClearAll = React.useCallback(function (e) {
-    var metaInfo = {
+  const handleClearAll = React.useCallback(e => {
+    const metaInfo = {
       isAutomaticFillTrigger: false,
       isClearButtonAction: true,
       newDateString: '',
@@ -326,9 +311,9 @@ var useControlledDateTimePicker = function useControlledDateTimePicker(props) {
       newDateTimeString: ''
     };
 
-    var datePartsChangesMetainfo = _objectSpread({}, metaInfo);
+    const datePartsChangesMetainfo = _objectSpread({}, metaInfo);
 
-    var timePartsChangesMetainfo = _objectSpread({}, metaInfo);
+    const timePartsChangesMetainfo = _objectSpread({}, metaInfo);
 
     if (isDateSelector || isDateTimeSelector) {
       delete datePartsChangesMetainfo.newDateTimeString;
@@ -350,24 +335,26 @@ var useControlledDateTimePicker = function useControlledDateTimePicker(props) {
     if (isDateSelector) handleChangeComposedDateString('__/__/____', datePartsChangesMetainfo);
     if (isTimeSelector) handleChangeComposedTimeString('__:__ __', timePartsChangesMetainfo);
   }, [appOnDayChange, appOnHourChange, appOnMeridiemChange, appOnMinuteChange, appOnMonthChange, appOnYearChange, handleChangeComposedDateString, handleChangeComposedDateTimeString, handleChangeComposedTimeString, isDateSelector, isDateTimeSelector, isTimeSelector]);
-  var onFillWithCurrentDateKeys = React.useCallback(function () {
-    var metaInfo = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
+  const onFillWithCurrentDateKeys = React.useCallback(function () {
+    let metaInfo = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
       isAutomaticFillTrigger: true
     };
-    var now = new Date();
-    var nowDateString = controlledDateTimePicker_utils_dateHelpers.getDateStringFromDay(now);
-    var nowTimeString = controlledDateTimePicker_utils_dateHelpers.getTimeStringFromDay(now);
+    const now = new Date();
+    const nowDateString = dateHelpers.getDateStringFromDay(now);
+    const nowTimeString = dateHelpers.getTimeStringFromDay(now);
 
-    var finalMetaInfo = _objectSpread(_objectSpread(_objectSpread(_objectSpread({}, metaInfo), controlledDateTimePicker_utils_dateHelpers.getValidationDateStringMetaInfo(nowDateString, getIsOutOfRangeDay, getIsDisabledDay)), controlledDateTimePicker_utils_timeHelpers.getValidationTimeStringMetaInfo(nowTimeString, getIsDisabledTime)), {}, {
+    const finalMetaInfo = _objectSpread(_objectSpread(_objectSpread(_objectSpread({}, metaInfo), dateHelpers.getValidationDateStringMetaInfo(nowDateString, getIsOutOfRangeDay, getIsDisabledDay)), timeHelpers.getValidationTimeStringMetaInfo(nowTimeString, getIsDisabledTime)), {}, {
       newDateString: nowDateString
     });
 
     handleChangeComposedDateTimeString(nowDateString, nowTimeString, finalMetaInfo);
   }, [getIsDisabledDay, getIsDisabledTime, getIsOutOfRangeDay, handleChangeComposedDateTimeString]);
-  var onGlobalKeyDown = React.useCallback(function (e) {
-    var key = e.key,
-        ctrlKey = e.ctrlKey,
-        metaKey = e.metaKey;
+  const onGlobalKeyDown = React.useCallback(e => {
+    const {
+      key,
+      ctrlKey,
+      metaKey
+    } = e;
 
     if ((ctrlKey || metaKey) && key === ';') {
       onFillWithCurrentDateKeys();
@@ -375,100 +362,99 @@ var useControlledDateTimePicker = function useControlledDateTimePicker(props) {
 
     if ((ctrlKey || metaKey) && (key === 'Delete' || key === 'Backspace')) handleClearAll(e);
   }, [handleClearAll, onFillWithCurrentDateKeys]);
-  var ctx = React__default['default'].useMemo(function () {
-    return {
-      props: propsWithDefaults,
-      monthInputRef: monthInputRef,
-      dayInputRef: dayInputRef,
-      yearInputRef: yearInputRef,
-      hourInputRef: hourInputRef,
-      minutesInputRef: minutesInputRef,
-      meridiemInputRef: meridiemInputRef,
-      clearButtonRef: clearButtonRef,
-      pickerButtonRef: pickerButtonRef,
-      prevYearBtnRef: prevYearBtnRef,
-      prevMonthBtnRef: prevMonthBtnRef,
-      nextMonthBtnRef: nextMonthBtnRef,
-      nextYearBtnRef: nextYearBtnRef,
-      calendarDaysWrapperRef: calendarDaysWrapperRef,
-      prevHourBtnRef: prevHourBtnRef,
-      currHourBtnRef: currHourBtnRef,
-      nextHourBtnRef: nextHourBtnRef,
-      prevMinutesBtnRef: prevMinutesBtnRef,
-      currMinutesBtnRef: currMinutesBtnRef,
-      nextMinutesBtnRef: nextMinutesBtnRef,
-      prevMeridiemBtnRef: prevMeridiemBtnRef,
-      currMeridiemBtnRef: currMeridiemBtnRef,
-      nextMeridiemBtnRef: nextMeridiemBtnRef,
-      dateStringFromProps: dateStringFromProps,
-      firstSegmentRef: firstSegmentRef,
-      lastSegmentRef: lastSegmentRef,
-      tempDateString: tempDateString,
-      setTempDateString: setTempDateString,
-      tempTimeString: tempTimeString,
-      setTimeString: setTimeString,
-      handleChangeComposedDateTimeString: handleChangeComposedDateTimeString,
-      handleChangeComposedDateString: handleChangeComposedDateString,
-      handleChangeComposedTimeString: handleChangeComposedTimeString,
-      handleChangeMonth: handleChangeMonth,
-      handleChangeDay: handleChangeDay,
-      handleChangeYear: handleChangeYear,
-      handleChangeHours: handleChangeHours,
-      handleChangeMinutes: handleChangeMinutes,
-      handleChangeMeridiem: handleChangeMeridiem,
-      handleClearAll: handleClearAll,
-      hideDate: hideDate,
-      hideTime: hideTime,
-      hideDateTimePicker: hideDateTimePicker,
-      hideDatePicker: hideDatePicker,
-      hideTimePicker: hideTimePicker,
-      isDateSelector: isDateSelector,
-      isTimeSelector: isTimeSelector,
-      isDateTimeSelector: isDateTimeSelector,
-      isControllerOnly: isControllerOnly,
-      isWithTimeWheelToo: isWithTimeWheelToo,
-      isWithCalendarToo: isWithCalendarToo,
-      isWithDateInputs: isWithDateInputs,
-      isWithDateInputsOnly: isWithDateInputsOnly,
-      isWithTimeInputs: isWithTimeInputs,
-      isWithTimeInputsOnly: isWithTimeInputsOnly,
-      autoFocusMonthInput: autoFocusMonthInput,
-      autoFocusHourInput: autoFocusHourInput,
-      autoFocusPrevMonthArrow: autoFocusPrevMonthArrow,
-      autoFocusHourTimeWheel: autoFocusHourTimeWheel,
-      latestInteractionRegion: latestInteractionRegion,
-      setLatestInteractionRegion: setLatestInteractionRegion,
-      withAnyInputs: withAnyInputs,
-      withAnyPicker: withAnyPicker,
-      withClearBtn: withClearBtn,
-      withAnyRightController: withAnyRightController,
-      shouldPreserveClearableSpace: shouldPreserveClearableSpace,
-      month: month,
-      day: day,
-      year: year,
-      monthNum: monthNum,
-      dayNum: dayNum,
-      yearNum: yearNum,
-      announcedMonth: announcedMonth,
-      announcedDay: announcedDay,
-      announcedYear: announcedYear,
-      announcedDateValues: announcedDateValues,
-      hours: hours,
-      minutes: minutes,
-      meridiem: meridiem,
-      hoursNum: hoursNum,
-      minutesNum: minutesNum,
-      announcedHours: announcedHours,
-      announcedMinutes: announcedMinutes,
-      announcedMeridiem: announcedMeridiem,
-      announcedTimeValues: announcedTimeValues,
-      ariaCurrentValueForInputs: ariaCurrentValueForInputs,
-      onGlobalKeyDown: onGlobalKeyDown
-    };
-  }, [propsWithDefaults, dateStringFromProps, tempDateString, tempTimeString, handleChangeComposedDateTimeString, handleChangeComposedDateString, handleChangeComposedTimeString, handleChangeMonth, handleChangeDay, handleChangeYear, handleChangeHours, handleChangeMinutes, handleChangeMeridiem, handleClearAll, hideDate, hideTime, hideDateTimePicker, hideDatePicker, hideTimePicker, isDateSelector, isTimeSelector, isDateTimeSelector, isControllerOnly, isWithTimeWheelToo, isWithCalendarToo, isWithDateInputs, isWithDateInputsOnly, isWithTimeInputs, isWithTimeInputsOnly, autoFocusMonthInput, autoFocusHourInput, autoFocusPrevMonthArrow, autoFocusHourTimeWheel, latestInteractionRegion, withAnyInputs, withAnyPicker, withClearBtn, withAnyRightController, shouldPreserveClearableSpace, month, day, year, monthNum, dayNum, yearNum, announcedMonth, announcedDay, announcedYear, announcedDateValues, hours, minutes, meridiem, hoursNum, minutesNum, announcedHours, announcedMinutes, announcedMeridiem, announcedTimeValues, ariaCurrentValueForInputs, onGlobalKeyDown] // refs are mutable so we don't need to listen to them
+  const ctx = React__default["default"].useMemo(() => ({
+    props: _objectSpread(_objectSpread({}, propsWithDefaults), {}, {
+      dataAttrs
+    }),
+    monthInputRef,
+    dayInputRef,
+    yearInputRef,
+    hourInputRef,
+    minutesInputRef,
+    meridiemInputRef,
+    clearButtonRef,
+    pickerButtonRef,
+    prevYearBtnRef,
+    prevMonthBtnRef,
+    nextMonthBtnRef,
+    nextYearBtnRef,
+    calendarDaysWrapperRef,
+    prevHourBtnRef,
+    currHourBtnRef,
+    nextHourBtnRef,
+    prevMinutesBtnRef,
+    currMinutesBtnRef,
+    nextMinutesBtnRef,
+    prevMeridiemBtnRef,
+    currMeridiemBtnRef,
+    nextMeridiemBtnRef,
+    dateStringFromProps,
+    firstSegmentRef,
+    lastSegmentRef,
+    tempDateString,
+    setTempDateString,
+    tempTimeString,
+    setTimeString,
+    handleChangeComposedDateTimeString,
+    handleChangeComposedDateString,
+    handleChangeComposedTimeString,
+    handleChangeMonth,
+    handleChangeDay,
+    handleChangeYear,
+    handleChangeHours,
+    handleChangeMinutes,
+    handleChangeMeridiem,
+    handleClearAll,
+    hideDate,
+    hideTime,
+    hideDateTimePicker,
+    hideDatePicker,
+    hideTimePicker,
+    isDateSelector,
+    isTimeSelector,
+    isDateTimeSelector,
+    isControllerOnly,
+    isWithTimeWheelToo,
+    isWithCalendarToo,
+    isWithDateInputs,
+    isWithDateInputsOnly,
+    isWithTimeInputs,
+    isWithTimeInputsOnly,
+    autoFocusMonthInput,
+    autoFocusHourInput,
+    autoFocusPrevMonthArrow,
+    autoFocusHourTimeWheel,
+    latestInteractionRegion,
+    setLatestInteractionRegion,
+    withAnyInputs,
+    withAnyPicker,
+    withClearBtn,
+    withAnyRightController,
+    shouldPreserveClearableSpace,
+    month,
+    day,
+    year,
+    monthNum,
+    dayNum,
+    yearNum,
+    announcedMonth,
+    announcedDay,
+    announcedYear,
+    announcedDateValues,
+    hours,
+    minutes,
+    meridiem,
+    hoursNum,
+    minutesNum,
+    announcedHours,
+    announcedMinutes,
+    announcedMeridiem,
+    announcedTimeValues,
+    ariaCurrentValueForInputs,
+    onGlobalKeyDown
+  }), [dataAttrs, propsWithDefaults, dateStringFromProps, tempDateString, tempTimeString, handleChangeComposedDateTimeString, handleChangeComposedDateString, handleChangeComposedTimeString, handleChangeMonth, handleChangeDay, handleChangeYear, handleChangeHours, handleChangeMinutes, handleChangeMeridiem, handleClearAll, hideDate, hideTime, hideDateTimePicker, hideDatePicker, hideTimePicker, isDateSelector, isTimeSelector, isDateTimeSelector, isControllerOnly, isWithTimeWheelToo, isWithCalendarToo, isWithDateInputs, isWithDateInputsOnly, isWithTimeInputs, isWithTimeInputsOnly, autoFocusMonthInput, autoFocusHourInput, autoFocusPrevMonthArrow, autoFocusHourTimeWheel, latestInteractionRegion, withAnyInputs, withAnyPicker, withClearBtn, withAnyRightController, shouldPreserveClearableSpace, month, day, year, monthNum, dayNum, yearNum, announcedMonth, announcedDay, announcedYear, announcedDateValues, hours, minutes, meridiem, hoursNum, minutesNum, announcedHours, announcedMinutes, announcedMeridiem, announcedTimeValues, ariaCurrentValueForInputs, onGlobalKeyDown] // refs are mutable so we don't need to listen to them
   );
   return ctx;
 };
 
 exports.useControlledDateTimePicker = useControlledDateTimePicker;
-//# sourceMappingURL=useControlledDateTimePicker.js.map