@elliemae/ds-time-picker 2.2.0-alpha.2 → 2.2.0-next.1

package/esm/TimePickerImpl.js

@@ -1,154 +1,165 @@
-import * as React from "react";
-import React2, { useState, useEffect, useRef } from "react";
-import PropTypes from "prop-types";
-import moment from "moment";
-import memoizeOne from "memoize-one";
-import { getVisibleTimeByFormat } from "@elliemae/ds-utilities";
-import { aggregatedClasses, convertPropToCssClassName } from "@elliemae/ds-classnames";
-import { DSInput, DSInputGroup, TimeInputImpl } from "@elliemae/ds-form";
-import { TimePickerMenu } from "./TimePickerMenu";
-import { TimePickerDropdown } from "./TimePickerDropdown";
-import { convertTimeString } from "./utils";
-const blockName = "time-picker";
-const TimePickerContainer = aggregatedClasses(DSInputGroup)(blockName, null, ({ isMenuOpened }) => ({
-  isMenuOpened
-}));
-const TimePickerImpl = ({
-  value,
-  onChange,
-  onOpen,
-  format,
-  disabled,
-  hasHeader,
-  hasHeaderDisplay,
-  className,
-  containerProps,
-  placement,
-  zIndex,
-  disabledTimes,
-  minutesInterval
-}) => {
+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 _objectWithoutProperties from '@babel/runtime/helpers/esm/objectWithoutProperties';
+import _jsx from '@babel/runtime/helpers/esm/jsx';
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import { useState, useRef, useEffect } from 'react';
+import moment from 'moment';
+import memoizeOne from 'memoize-one';
+import { getVisibleTimeByFormat } from '@elliemae/ds-utilities';
+import { aggregatedClasses, convertPropToCssClassName } from '@elliemae/ds-classnames';
+import { DSInputGroup, DSInput, TimeInputImpl } from '@elliemae/ds-form';
+import { TimePickerMenu } from './TimePickerMenu.js';
+import TimePickerDropdown from './TimePickerDropdown.js';
+import { convertTimeString } from './utils.js';
+import { jsx } from 'react/jsx-runtime';
+
+const _excluded = ["onChange"];
+
+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 blockName = 'time-picker';
+const TimePickerContainer = aggregatedClasses(DSInputGroup)(blockName, null, _ref => {
+  let {
+    isMenuOpened
+  } = _ref;
+  return {
+    isMenuOpened
+  };
+});
+
+const TimePickerImpl = _ref2 => {
+  let {
+    value,
+    onChange,
+    onOpen,
+    format,
+    disabled,
+    hasHeader,
+    hasHeaderDisplay,
+    className,
+    containerProps,
+    placement,
+    zIndex,
+    disabledTimes,
+    minutesInterval
+  } = _ref2;
   const [time, setTime] = useState();
   const [isMenuOpened, setIsMenuOpened] = useState(false);
   const [focusedColumn, setFocusedColumn] = useState(null);
   const timePickerRef = useRef();
   useEffect(() => {
-    if (moment(value).isValid())
-      setTime(moment(value));
-    else if (value === null)
-      setTime(void 0);
+    if (moment(value).isValid()) setTime(moment(value));else if (value === null) setTime(undefined);
   }, [value]);
   useEffect(() => {
-    window.addEventListener("click", handleClickOutside, false);
-    return () => window.removeEventListener("click", handleClickOutside, false);
+    window.addEventListener('click', handleClickOutside, false);
+    return () => window.removeEventListener('click', handleClickOutside, false);
   }, []);
   useEffect(() => {
-    window.addEventListener("keydown", handleKeyDown, false);
-    return () => window.removeEventListener("keydown", handleKeyDown, false);
+    window.addEventListener('keydown', handleKeyDown, false);
+    return () => window.removeEventListener('keydown', handleKeyDown, false);
   }, []);
   useEffect(() => {
-    if (isMenuOpened)
-      handleChangeFocus();
+    if (isMenuOpened) handleChangeFocus();
   }, [isMenuOpened]);
+
   const handleClickOutside = () => {
-    if (isMenuOpened)
-      setIsMenuOpened(false);
+    if (isMenuOpened) setIsMenuOpened(false);
   };
-  const handleKeyDown = (event) => {
-    const { key } = event;
-    const menuOpenKeys = ["Escape", " ", "Enter"];
-    if (menuOpenKeys.includes(key))
-      setIsMenuOpened(false);
+
+  const handleKeyDown = event => {
+    const {
+      key
+    } = event;
+    const menuOpenKeys = ['Escape', ' ', 'Enter'];
+    if (menuOpenKeys.includes(key)) setIsMenuOpened(false);
   };
+
   const handleChangeFocus = () => {
-    const [firstColumn] = document.getElementsByClassName("em-ds-time-picker-panel");
+    const [firstColumn] = document.getElementsByClassName('em-ds-time-picker-panel');
+
     if (firstColumn && !focusedColumn) {
       setFocusedColumn(firstColumn);
       firstColumn.focus();
     }
   };
-  const handlePickerChange = (newTime) => {
+
+  const handlePickerChange = newTime => {
     setTime(moment(newTime));
     onChange(moment(newTime));
   };
-  const handleInputChange = (newTime) => {
+
+  const handleInputChange = newTime => {
     setTime(newTime);
     onChange(newTime);
   };
-  const handleMenuOpen = (isOpen) => {
+
+  const handleMenuOpen = isOpen => {
     onOpen(isOpen);
     setIsMenuOpened(isOpen);
-    if (!isOpen)
-      setFocusedColumn(null);
+    if (!isOpen) setFocusedColumn(null);
   };
-  const getVisibleTimePanels = memoizeOne((format2) => getVisibleTimeByFormat(format2));
+
+  const getVisibleTimePanels = memoizeOne(format => getVisibleTimeByFormat(format));
   const timePickerBlockName = convertPropToCssClassName(blockName);
   const visiblePanels = getVisibleTimePanels(format);
   const disabledTimeRange = disabledTimes && {
     from: convertTimeString(disabledTimes.from),
     to: convertTimeString(disabledTimes.to)
   };
-  return /* @__PURE__ */ React2.createElement(TimePickerContainer, {
-    className: `${className} variant-${!disabled ? "default" : "disabled"}`,
-    containerProps,
-    disabled,
-    rightAddon: /* @__PURE__ */ React2.createElement(TimePickerDropdown, {
+  return /*#__PURE__*/_jsx(TimePickerContainer, {
+    className: "".concat(className, " variant-").concat(!disabled ? 'default' : 'disabled'),
+    containerProps: containerProps,
+    disabled: disabled,
+    rightAddon: /*#__PURE__*/_jsx(TimePickerDropdown, {
       blockName: timePickerBlockName,
-      disabled,
+      disabled: disabled,
       isOpen: isMenuOpened,
-      zIndex,
-      placement,
+      zIndex: zIndex,
+      placement: placement,
       onOpen: handleMenuOpen,
-      onClick: (e) => {
+      onClick: e => {
         e.preventDefault();
         handleMenuOpen(!isMenuOpened);
       },
-      menu: /* @__PURE__ */ React2.createElement("div", {
-        ref: timePickerRef
-      }, /* @__PURE__ */ React2.createElement(TimePickerMenu, {
-        disabled,
-        disabledTimes: disabledTimeRange,
-        format,
-        hasHeader,
-        hasHeaderDisplay,
-        onTimeChange: handlePickerChange,
-        minutesInterval,
-        time,
-        ...visiblePanels
-      }))
+      menu: /*#__PURE__*/jsx("div", {
+        ref: timePickerRef,
+        children: /*#__PURE__*/jsx(TimePickerMenu, _objectSpread({
+          disabled: disabled,
+          disabledTimes: disabledTimeRange,
+          format: format,
+          hasHeader: hasHeader,
+          hasHeaderDisplay: hasHeaderDisplay,
+          onTimeChange: handlePickerChange,
+          minutesInterval: minutesInterval,
+          time: time
+        }, visiblePanels))
+      })
     })
-  }, /* @__PURE__ */ React2.createElement(DSInput, {
-    customInputType: ({ onChange: handleChange, ...restInputProps }) => /* @__PURE__ */ React2.createElement(TimeInputImpl, {
-      clearable: true,
-      disabled,
-      format,
-      onChange: handleChange,
-      ...restInputProps
-    }),
+  }, void 0, /*#__PURE__*/_jsx(DSInput, {
+    customInputType: _ref3 => {
+      let {
+        onChange: handleChange
+      } = _ref3,
+          restInputProps = _objectWithoutProperties(_ref3, _excluded);
+
+      return /*#__PURE__*/jsx(TimeInputImpl, _objectSpread({
+        clearable: true,
+        disabled: disabled,
+        format: format,
+        onChange: handleChange
+      }, restInputProps));
+    },
     isShowElipsisActive: false,
-    disabled,
+    disabled: disabled,
     onChange: handleInputChange,
     value: time
   }));
 };
-TimePickerImpl.propTypes = {
-  value: PropTypes.instanceOf(Date, moment),
-  onChange: PropTypes.func,
-  onOpen: PropTypes.func,
-  format: PropTypes.string,
-  disabled: PropTypes.bool,
-  hasHeader: PropTypes.bool,
-  hasHeaderDisplay: PropTypes.bool,
-  className: PropTypes.string,
-  containerProps: PropTypes.object,
-  placement: PropTypes.string,
-  zIndex: PropTypes.number,
-  disabledTimes: PropTypes.object,
-  minutesInterval: PropTypes.number
-};
-var TimePickerImpl_default = TimePickerImpl;
-export {
-  TimePickerImpl,
-  TimePickerImpl_default as default
-};
-//# sourceMappingURL=TimePickerImpl.js.map
+
+export { TimePickerImpl as default };

package/esm/TimePickerMenu.js

@@ -1,189 +1,292 @@
-import * as React from "react";
-import React2, { Component } from "react";
-import PropTypes from "prop-types";
-import { aggregatedClasses } from "@elliemae/ds-classnames";
-import moment from "moment";
-import { range, addLeadingZeros } from "@elliemae/ds-utilities";
-import { isAM } from "./utils";
-import { PickerPanel } from "./PickerPanel";
-const blockName = "time-picker-menu";
-const TimePickerContainer = aggregatedClasses("div")(blockName);
-const TimePickerHeader = aggregatedClasses("div")(blockName, "header");
-const TimePickerPanelContainer = aggregatedClasses("div")(blockName, "panel-container");
-const generateOption = (format) => (option) => ({
+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 'core-js/modules/esnext.async-iterator.map.js';
+import 'core-js/modules/esnext.iterator.map.js';
+import { Component } from 'react';
+import { aggregatedClasses } from '@elliemae/ds-classnames';
+import moment from 'moment';
+import { range, addLeadingZeros } from '@elliemae/ds-utilities';
+import { isAM } from './utils.js';
+import PickerPanel from './PickerPanel.js';
+
+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 blockName = 'time-picker-menu';
+const TimePickerContainer = aggregatedClasses('div')(blockName);
+const TimePickerHeader = aggregatedClasses('div')(blockName, 'header');
+const TimePickerPanelContainer = aggregatedClasses('div')(blockName, 'panel-container');
+
+const generateOption = format => option => ({
   value: option,
-  label: typeof format === "function" ? format(option) : option
+  label: typeof format === 'function' ? format(option) : option
 });
+
 class TimePickerMenu extends Component {
   constructor(props) {
     super(props);
+
     this.renderHeader = () => {
-      const { time } = this.state;
-      return /* @__PURE__ */ React2.createElement(TimePickerHeader, null, time.format("hh:mma"));
+      const {
+        time
+      } = this.state;
+      return /*#__PURE__*/_jsx(TimePickerHeader, {}, void 0, time.format('hh:mma'));
     };
+
     this.state = {
-      time: moment(props.time || "", props.format) || moment()
+      time: moment(props.time || '', props.format) || moment()
     };
+    this.handleHoursChange = this.handleHoursChange.bind(this);
+    this.handleMinuteChange = this.handleMinuteChange.bind(this);
+    this.handleSecondsChange = this.handleSecondsChange.bind(this);
+    this.handleAMPMChange = this.handleAMPMChange.bind(this);
   }
+
   static getDerivedStateFromProps(props, state) {
     if (props.time) {
-      return { ...state, time: moment(props.time) };
+      return _objectSpread(_objectSpread({}, state), {}, {
+        time: moment(props.time)
+      });
     }
-    return { ...state, time: void 0 };
+
+    return _objectSpread(_objectSpread({}, state), {}, {
+      time: undefined
+    });
   }
+
   componentDidMount() {
-    const { time } = this.state;
-    this.setState({ time });
+    const {
+      time
+    } = this.state;
+    this.setState({
+      time
+    });
   }
+
   handleMinuteChange(value) {
-    const { time } = this.state;
+    const {
+      time
+    } = this.state;
     this.updateTime(time.minute(value));
   }
+
   handleHoursChange(value) {
-    const { time } = this.state;
-    const { use12Hours } = this.props;
+    const {
+      time
+    } = this.state;
+    const {
+      use12Hours
+    } = this.props;
     let nextHour = value;
+
     if (use12Hours) {
       if (!isAM(time)) {
         nextHour = value % 12 + 12;
       }
     }
+
     this.updateTime(time.hour(nextHour));
   }
+
   handleSecondsChange(value) {
-    const { time } = this.state;
+    const {
+      time
+    } = this.state;
     this.updateTime(time.second(value));
   }
+
   handleAMPMChange(value) {
-    const { time } = this.state;
+    const {
+      time
+    } = this.state;
     const hour = time.hour();
-    const nextHour = value.toLowerCase() === "am" ? hour % 12 : hour % 12 + 12;
+    const nextHour = value.toLowerCase() === 'am' ? hour % 12 : hour % 12 + 12;
     this.updateTime(time.hour(nextHour));
   }
+
   updateTime(time) {
-    const { onTimeChange } = this.props;
+    const {
+      onTimeChange
+    } = this.props;
     onTimeChange(time);
-    this.setState({ time });
+    this.setState({
+      time
+    });
   }
+
   renderHoursPanel() {
-    const { time } = this.state;
-    const { showHours, use12Hours, format, hasHeader, disabledTimes } = this.props;
-    if (!showHours)
-      return null;
-    const hour = time.hour();
+    const {
+      time
+    } = this.state;
+    const {
+      showHours,
+      use12Hours,
+      format,
+      hasHeader,
+      disabledTimes
+    } = this.props;
+    if (!showHours) return null;
+    const hour = time.hour(); // in 24 format
+
     let selectedHour = use12Hours ? hour % 12 || 12 : hour;
+
     if (disabledTimes) {
-      const { from, to } = disabledTimes;
+      const {
+        from,
+        to
+      } = disabledTimes;
+
       if (hour > from.hour && hour < to.hour) {
         if (to.hour < 24) {
           const toFormatted = to.hour % 12 || 12;
-          if (selectedHour !== toFormatted)
-            this.handleHoursChange(toFormatted);
+          if (selectedHour !== toFormatted) this.handleHoursChange(toFormatted);
           selectedHour = toFormatted;
         } else if (from) {
           selectedHour = (from.hour - 1) % 12 || 12;
         }
       }
     }
-    const meridiem = hour >= 12 ? "PM" : "AM";
-    const withLeadingZeros = format.indexOf("hh") > -1;
+
+    const meridiem = hour >= 12 ? 'PM' : 'AM';
+    const withLeadingZeros = format.indexOf('hh') > -1;
     const rangeHours = use12Hours ? range(1, 13) : range(24);
     const hoursOptions = rangeHours.map(generateOption(withLeadingZeros && addLeadingZeros(2)));
-    return /* @__PURE__ */ React2.createElement(PickerPanel, {
+    return /*#__PURE__*/_jsx(PickerPanel, {
       type: "hour",
-      time,
-      meridiem,
-      hasHeader,
+      time: time,
+      meridiem: meridiem,
+      hasHeader: hasHeader,
       header: "H",
       onChange: this.handleHoursChange,
       options: hoursOptions,
       selected: selectedHour,
-      disabledTimes
+      disabledTimes: disabledTimes
     });
   }
+
   renderMinutesPanel() {
-    const { time } = this.state;
-    const { showMinutes, format, hasHeader, disabledTimes, minutesInterval } = this.props;
-    if (!showMinutes)
-      return null;
-    const withLeadingZeros = format.indexOf("mm") > -1;
+    const {
+      time
+    } = this.state;
+    const {
+      showMinutes,
+      format,
+      hasHeader,
+      disabledTimes,
+      minutesInterval
+    } = this.props;
+    if (!showMinutes) return null;
+    const withLeadingZeros = format.indexOf('mm') > -1;
     const rangeMinutes = range(0, 60, minutesInterval).map(generateOption(withLeadingZeros && addLeadingZeros(2)));
     let selectedMinute = time.minute();
     const selectedHour = time.hour();
+
     if (disabledTimes) {
-      const { from, to } = disabledTimes;
+      const {
+        from,
+        to
+      } = disabledTimes;
+
       if (selectedHour <= to.hour && selectedHour > from.hour) {
         if (to) {
-          if (selectedMinute < to.min)
-            this.handleMinuteChange(to.min);
+          if (selectedMinute < to.min) this.handleMinuteChange(to.min);
         } else if (from) {
-          if (selectedMinute > from.min)
-            this.handleMinuteChange(from.min - 1);
+          if (selectedMinute > from.min) this.handleMinuteChange(from.min - 1);
         }
       } else {
         selectedMinute = time.minute();
       }
     }
-    return /* @__PURE__ */ React2.createElement(PickerPanel, {
+
+    return /*#__PURE__*/_jsx(PickerPanel, {
       type: "minutes",
-      time,
-      hasHeader,
+      time: time,
+      hasHeader: hasHeader,
       header: "M",
       onChange: this.handleMinuteChange,
       options: rangeMinutes,
       selected: selectedMinute,
-      disabledTimes
+      disabledTimes: disabledTimes
     });
   }
+
   renderSecondsPanel() {
-    const { time } = this.state;
-    const { showSeconds, format, hasHeader } = this.props;
-    if (!showSeconds)
-      return null;
-    const withLeadingZeros = format.indexOf("ss") > -1;
+    const {
+      time
+    } = this.state;
+    const {
+      showSeconds,
+      format,
+      hasHeader
+    } = this.props;
+    if (!showSeconds) return null;
+    const withLeadingZeros = format.indexOf('ss') > -1;
     const rangeSeconds = range(60).map(generateOption(withLeadingZeros && addLeadingZeros(2)));
-    return /* @__PURE__ */ React2.createElement(PickerPanel, {
+    return /*#__PURE__*/_jsx(PickerPanel, {
       type: "seconds",
-      hasHeader,
+      hasHeader: hasHeader,
       header: "S",
       onChange: this.handleSecondsChange,
       options: rangeSeconds,
       selected: time.second()
     });
   }
+
   renderAMPMPanel() {
-    const { time } = this.state;
-    const { use12Hours, hasHeader, disabledTimes } = this.props;
-    if (!use12Hours)
-      return null;
-    let meridiemSelected = !isAM(time) ? "pm" : "am";
-    if (disabledTimes && disabledTimes.to && meridiemSelected === "am") {
-      meridiemSelected = disabledTimes.to.hour >= 12 ? "pm" : "am";
-      if (meridiemSelected === "am" && time.hour() > 12) {
-        this.handleAMPMChange("am");
+    const {
+      time
+    } = this.state;
+    const {
+      use12Hours,
+      hasHeader,
+      disabledTimes
+    } = this.props;
+    if (!use12Hours) return null;
+    let meridiemSelected = !isAM(time) ? 'pm' : 'am';
+
+    if (disabledTimes && disabledTimes.to && meridiemSelected === 'am') {
+      meridiemSelected = disabledTimes.to.hour >= 12 ? 'pm' : 'am';
+
+      if (meridiemSelected === 'am' && time.hour() > 12) {
+        this.handleAMPMChange('am');
       }
-      if (meridiemSelected === "pm" && time.hour() <= 12) {
-        this.handleAMPMChange("pm");
+
+      if (meridiemSelected === 'pm' && time.hour() <= 12) {
+        this.handleAMPMChange('pm');
       }
     }
-    return /* @__PURE__ */ React2.createElement(PickerPanel, {
+
+    return /*#__PURE__*/_jsx(PickerPanel, {
       type: "meridiem",
-      hasHeader,
+      hasHeader: hasHeader,
       header: "",
       onChange: this.handleAMPMChange,
-      options: [
-        { value: "am", label: "am" },
-        { value: "pm", label: "pm" }
-      ],
+      options: [{
+        value: 'am',
+        label: 'am'
+      }, {
+        value: 'pm',
+        label: 'pm'
+      }],
       selected: meridiemSelected,
-      disabledTimes
+      disabledTimes: disabledTimes
     });
   }
+
   render() {
-    const { hasHeaderDisplay } = this.props;
-    return /* @__PURE__ */ React2.createElement(TimePickerContainer, null, hasHeaderDisplay && this.renderHeader(), /* @__PURE__ */ React2.createElement(TimePickerPanelContainer, null, this.renderHoursPanel(), this.renderMinutesPanel(), this.renderSecondsPanel(), this.renderAMPMPanel()));
+    const {
+      hasHeaderDisplay
+    } = this.props;
+    return /*#__PURE__*/_jsx(TimePickerContainer, {}, void 0, hasHeaderDisplay && this.renderHeader(), /*#__PURE__*/_jsx(TimePickerPanelContainer, {}, void 0, this.renderHoursPanel(), this.renderMinutesPanel(), this.renderSecondsPanel(), this.renderAMPMPanel()));
   }
+
 }
+
 TimePickerMenu.defaultProps = {
   time: moment(),
   hasHeader: false,
@@ -191,22 +294,8 @@ TimePickerMenu.defaultProps = {
   showSeconds: true,
   showMinutes: true,
   showHours: true,
-  disabledTimes: void 0,
+  disabledTimes: undefined,
   onTimeChange: () => null
 };
-TimePickerMenu.propTypes = {
-  time: PropTypes.instanceOf(moment),
-  hasHeader: PropTypes.bool,
-  use12Hours: PropTypes.bool,
-  showSeconds: PropTypes.bool,
-  showMinutes: PropTypes.bool,
-  showHours: PropTypes.bool,
-  onTimeChange: PropTypes.func,
-  disabledTimes: PropTypes.object
-};
-var TimePickerMenu_default = TimePickerMenu;
-export {
-  TimePickerMenu,
-  TimePickerMenu_default as default
-};
-//# sourceMappingURL=TimePickerMenu.js.map
+
+export { TimePickerMenu, TimePickerMenu as default };