@elliemae/ds-form 2.2.0-alpha.3 → 3.0.0-next.0

package/cjs/TimeInput/TimeInputs.js

@@ -1,339 +1,372 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __reExport = (target, module2, copyDefault, desc) => {
-  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
-    for (let key of __getOwnPropNames(module2))
-      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
-        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
-  }
-  return target;
-};
-var __toESM = (module2, isNodeMode) => {
-  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", !isNodeMode && module2 && module2.__esModule ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
-};
-var __toCommonJS = /* @__PURE__ */ ((cache) => {
-  return (module2, temp) => {
-    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
-  };
-})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
-var TimeInputs_exports = {};
-__export(TimeInputs_exports, {
-  TimeInputs: () => TimeInputs,
-  default: () => TimeInputs_default
-});
-var React = __toESM(require("react"));
-var import_react = __toESM(require("react"));
-var import_ds_classnames = __toESM(require("@elliemae/ds-classnames"));
-var import_moment = __toESM(require("moment"));
-var import_utils = __toESM(require("./utils"));
-var import_constants = __toESM(require("@elliemae/ds-shared/constants"));
-const blockName = "input-times-group";
-const InputTimesGroup = (0, import_ds_classnames.aggregatedClasses)("div")(blockName);
-const TimeInput = (0, import_ds_classnames.aggregatedClasses)("input")(blockName, "input");
-const Divider = (0, import_ds_classnames.aggregatedClasses)("span")(blockName, "divider", ({ value }) => ({
-  value
-}));
-const TimeDivider = ({ content = ":", value = "" }) => /* @__PURE__ */ import_react.default.createElement(Divider, {
-  value: !!value
-}, content);
-const TimeInputs = ({
-  time,
-  format,
-  use12Hours,
-  step = 1,
-  showHours,
-  showMinutes,
-  showSeconds,
-  onChange,
-  disabled,
-  innerRef,
-  clearable,
-  "arial-label": ariaLabel,
-  "aria-label": ariaLabel2
-}) => {
-  const [meridiem, setMeridiem] = (0, import_react.useState)("");
-  const [hours, setHours] = (0, import_react.useState)("");
-  const [minutes, setMinutes] = (0, import_react.useState)("");
-  const [hasInputValue, setHasInputValue] = (0, import_react.useState)(false);
-  const [seconds, setSeconds] = (0, import_react.useState)("");
-  const [currentKey, setCurrentKey] = (0, import_react.useState)("");
-  const [hasInputBeenTriggered, setHasInputBeenTriggered] = (0, import_react.useState)(false);
-  const [lastTypedNumber, setLastTypedNumber] = (0, import_react.useState)(null);
-  const inputRefs = {
-    hours: null,
-    minutes: null,
-    seconds: null,
-    meridiem: null
+'use strict';
+
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var _jsx = require('@babel/runtime/helpers/jsx');
+require('core-js/modules/web.dom-collections.iterator.js');
+require('core-js/modules/esnext.async-iterator.some.js');
+require('core-js/modules/esnext.iterator.constructor.js');
+require('core-js/modules/esnext.iterator.some.js');
+require('core-js/modules/esnext.async-iterator.reduce.js');
+require('core-js/modules/esnext.iterator.reduce.js');
+require('core-js/modules/esnext.async-iterator.filter.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 dsClassnames = require('@elliemae/ds-classnames');
+var moment = require('moment');
+var utils = require('./utils.js');
+var constants = require('@elliemae/ds-shared/constants');
+
+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 React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+var moment__default = /*#__PURE__*/_interopDefaultLegacy(moment);
+
+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 blockName = 'input-times-group';
+const InputTimesGroup = dsClassnames.aggregatedClasses('div')(blockName);
+const TimeInput = dsClassnames.aggregatedClasses('input')(blockName, 'input');
+const Divider = dsClassnames.aggregatedClasses('span')(blockName, 'divider', _ref => {
+  let {
+    value
+  } = _ref;
+  return {
+    value
   };
-  (0, import_react.useEffect)(() => {
-    if (time && (0, import_moment.default)(time).isValid()) {
-      const timeValues = (0, import_utils.getTimeValuesFromTime)(time, format, use12Hours);
+}); // eslint-disable-next-line react/prop-types
+
+const TimeDivider = _ref2 => {
+  let {
+    content = ':',
+    value = ''
+  } = _ref2;
+  return /*#__PURE__*/_jsx__default["default"](Divider, {
+    value: !!value
+  }, void 0, content);
+};
+
+const TimeInputs = _ref3 => {
+  let {
+    time,
+    format,
+    use12Hours,
+    step = 1,
+    showHours,
+    showMinutes,
+    showSeconds,
+    onChange,
+    disabled,
+    innerRef,
+    clearable,
+    'arial-label': ariaLabel,
+    'aria-label': ariaLabel2
+  } = _ref3;
+  const [meridiem, setMeridiem] = React.useState('');
+  const [hours, setHours] = React.useState('');
+  const [minutes, setMinutes] = React.useState('');
+  const [hasInputValue, setHasInputValue] = React.useState(false);
+  const [seconds, setSeconds] = React.useState('');
+  const [currentKey, setCurrentKey] = React.useState('');
+  const [hasInputBeenTriggered, setHasInputBeenTriggered] = React.useState(false);
+  const [lastTypedNumber, setLastTypedNumber] = React.useState(null);
+  React.useEffect(() => {
+    if (time && moment__default["default"](time).isValid()) {
+      const timeValues = utils.getTimeValuesFromTime(time, format, use12Hours);
       setMeridiem(timeValues.meridiem);
       setHours(timeValues.hours);
       setMinutes(timeValues.minutes);
       setSeconds(timeValues.seconds);
     } else {
-      setMeridiem("");
-      setHours("");
-      setMinutes("");
-      setSeconds("");
+      setMeridiem('');
+      setHours('');
+      setMinutes('');
+      setSeconds('');
     }
   }, [time, format, use12Hours]);
-  (0, import_react.useEffect)(() => {
-    const selectedTime = time || (0, import_moment.default)();
+  React.useEffect(() => {
+    const selectedTime = time || moment__default["default"]();
+
     if (isTimeCompletelySet() && selectedTime.hours && hasInputBeenTriggered) {
-      if (showHours && hours)
-        selectedTime.hours(hours);
-      if (showMinutes && minutes)
-        selectedTime.minutes(minutes);
-      if (showSeconds && seconds)
-        selectedTime.seconds(seconds);
+      if (showHours && hours) selectedTime.hours(hours);
+      if (showMinutes && minutes) selectedTime.minutes(minutes);
+      if (showSeconds && seconds) selectedTime.seconds(seconds);
+
       if (use12Hours && meridiem) {
-        const nextHours = meridiem.toLowerCase() === import_constants.AM ? hours % 12 : hours % 12 + 12;
+        const nextHours = meridiem.toLowerCase() === constants.AM ? hours % 12 : hours % 12 + 12;
         selectedTime.hour(nextHours);
       }
+
       onChange(selectedTime);
       setHasInputBeenTriggered(false);
     }
   }, [hours, minutes, seconds, meridiem]);
+
   const focusNextInputIfNeeded = (currentEl, max, number) => {
-    if ((0, import_utils.shouldFocusNextInput)(max, number, currentEl.value) && !(0, import_utils.isArrowIncrementDecrement)(currentKey) && !hasInputValue) {
-      (0, import_utils.focusNextInput)(currentEl);
+    if (utils.shouldFocusNextInput(max, number, currentEl.value) && !utils.isArrowIncrementDecrement(currentKey) && !hasInputValue) {
+      utils.focusNextInput(currentEl);
     }
   };
-  const getNextTimeValue = (value, incrementing = true) => {
-    const parsedValue = (0, import_utils.parseTimeNumberFromText)(value);
+
+  const getNextTimeValue = function (value) {
+    let incrementing = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+    const parsedValue = utils.parseTimeNumberFromText(value);
     return incrementing ? parsedValue + step : parsedValue - step;
   };
-  const onInputFocus = (e) => {
+
+  const onInputFocus = e => {
     e.preventDefault();
     e.stopPropagation();
     e.target.select();
   };
-  const onClick = (e) => {
+
+  const onClick = e => {
     if (e.target.value) {
       setHasInputValue(true);
     }
-  };
+  }; // eslint-disable-next-line max-statements
+
+
   const onKeyDown = (event, max) => {
-    const { target } = event;
-    const { value } = target;
+    const {
+      target
+    } = event;
+    const {
+      value
+    } = target;
     setLastTypedNumber(event.key);
+
     switch (event.key) {
-      case import_constants.ARROW_UP: {
-        event.preventDefault();
-        setCurrentKey(event.key);
-        const incrementedValue = getNextTimeValue(value);
-        (0, import_utils.setNativeValue)(event.target, incrementedValue);
-        break;
-      }
-      case import_constants.ARROW_DOWN: {
-        event.preventDefault();
-        setCurrentKey(event.key);
-        const decrementedValue = getNextTimeValue(value, false);
-        (0, import_utils.setNativeValue)(event.target, decrementedValue);
-        break;
-      }
-      case import_constants.BACKSPACE: {
-        event.preventDefault();
-        if (!value) {
-          (0, import_utils.focusPreviousInput)(event.target);
-        } else {
-          (0, import_utils.setNativeValue)(event.target, "");
+      case constants.ARROW_UP:
+        {
+          event.preventDefault();
+          setCurrentKey(event.key);
+          const incrementedValue = getNextTimeValue(value);
+          utils.setNativeValue(event.target, incrementedValue);
+          break;
         }
-        break;
-      }
-      case import_constants.ESCAPE: {
-        event.preventDefault();
-        event.target.blur();
-        break;
-      }
-      case import_constants.HOME: {
-        event.preventDefault();
-        (0, import_utils.setNativeValue)(event.target, String(max));
-        (0, import_utils.focusNextInput)(event.target);
-        break;
-      }
-      case import_constants.END: {
-        event.preventDefault();
-        (0, import_utils.setNativeValue)(event.target, "00");
-        (0, import_utils.focusNextInput)(event.target);
-        break;
-      }
-      case import_constants.SHIFT:
+
+      case constants.ARROW_DOWN:
+        {
+          event.preventDefault();
+          setCurrentKey(event.key);
+          const decrementedValue = getNextTimeValue(value, false);
+          utils.setNativeValue(event.target, decrementedValue);
+          break;
+        }
+
+      case constants.BACKSPACE:
+        {
+          event.preventDefault();
+
+          if (!value) {
+            utils.focusPreviousInput(event.target);
+          } else {
+            utils.setNativeValue(event.target, '');
+          }
+
+          break;
+        }
+
+      case constants.ESCAPE:
+        {
+          event.preventDefault();
+          event.target.blur();
+          break;
+        }
+
+      case constants.HOME:
+        {
+          event.preventDefault();
+          utils.setNativeValue(event.target, String(max));
+          utils.focusNextInput(event.target);
+          break;
+        }
+
+      case constants.END:
+        {
+          event.preventDefault();
+          utils.setNativeValue(event.target, '00');
+          utils.focusNextInput(event.target);
+          break;
+        }
+
+      case constants.SHIFT:
         event.preventDefault();
         setCurrentKey(event.key);
         break;
-      default:
-        break;
     }
   };
+
   const isTimeCompletelySet = () => {
     let neededValues = [];
-    if (showHours)
-      neededValues = [...neededValues, hours || null];
-    if (showMinutes)
-      neededValues = [...neededValues, minutes || null];
-    if (showSeconds)
-      neededValues = [...neededValues, seconds || null];
-    if (use12Hours)
-      neededValues = [...neededValues, meridiem || null];
-    return !neededValues.some((value) => !value);
+    if (showHours) neededValues = [...neededValues, hours || null];
+    if (showMinutes) neededValues = [...neededValues, minutes || null];
+    if (showSeconds) neededValues = [...neededValues, seconds || null];
+    if (use12Hours) neededValues = [...neededValues, meridiem || null];
+    return !neededValues.some(value => !value);
   };
-  const handleSecondsChange = (e) => {
-    const { value } = e.target;
-    const secondsHandled = (0, import_utils.parseTimeNumberFromText)(value);
-    const nextSeconds = (0, import_utils.getValidTimeNumber)(import_constants.GENERAL_TIME_RANGE, secondsHandled, lastTypedNumber);
-    setSeconds((0, import_utils.formatSeconds)(format, nextSeconds));
+
+  const handleSecondsChange = e => {
+    const {
+      value
+    } = e.target;
+    const secondsHandled = utils.parseTimeNumberFromText(value);
+    const nextSeconds = utils.getValidTimeNumber(constants.GENERAL_TIME_RANGE, secondsHandled, lastTypedNumber);
+    setSeconds(utils.formatSeconds(format, nextSeconds));
     setHasInputBeenTriggered(true);
-    focusNextInputIfNeeded(e.target, import_constants.GENERAL_TIME_RANGE.max, value);
+    focusNextInputIfNeeded(e.target, constants.GENERAL_TIME_RANGE.max, value);
   };
-  const handleMinutesChange = (e) => {
-    const { value } = e.target;
-    const minutesHandled = (0, import_utils.parseTimeNumberFromText)(value);
-    const nextMinutes = (0, import_utils.getValidTimeNumber)(import_constants.GENERAL_TIME_RANGE, minutesHandled, lastTypedNumber);
-    setMinutes((0, import_utils.formatMinutes)(format, nextMinutes));
+
+  const handleMinutesChange = e => {
+    const {
+      value
+    } = e.target;
+    const minutesHandled = utils.parseTimeNumberFromText(value);
+    const nextMinutes = utils.getValidTimeNumber(constants.GENERAL_TIME_RANGE, minutesHandled, lastTypedNumber);
+    setMinutes(utils.formatMinutes(format, nextMinutes));
     setHasInputBeenTriggered(true);
-    focusNextInputIfNeeded(e.target, import_constants.GENERAL_TIME_RANGE.max, value);
+    focusNextInputIfNeeded(e.target, constants.GENERAL_TIME_RANGE.max, value);
   };
-  const handleHoursChange = (e) => {
-    const { value } = e.target;
-    const hour = (0, import_utils.parseTimeNumberFromText)(value);
-    const hoursRange = use12Hours ? import_constants.HOUR_RANGE_12 : import_constants.HOUR_RANGE_24;
-    const nextHour = (0, import_utils.getValidTimeNumber)(hoursRange, hour, lastTypedNumber);
-    setHours((0, import_utils.formatHour)(format, nextHour));
+
+  const handleHoursChange = e => {
+    const {
+      value
+    } = e.target;
+    const hour = utils.parseTimeNumberFromText(value);
+    const hoursRange = use12Hours ? constants.HOUR_RANGE_12 : constants.HOUR_RANGE_24;
+    const nextHour = utils.getValidTimeNumber(hoursRange, hour, lastTypedNumber);
+    setHours(utils.formatHour(format, nextHour));
     setHasInputBeenTriggered(true);
     focusNextInputIfNeeded(e.target, hoursRange.max, value);
   };
-  const handleMeridiemKeyDown = (e) => {
-    if (e.key === import_constants.ARROW_UP || e.key === "a") {
-      setMeridiem((0, import_utils.formatMeridiem)(format, import_constants.AM));
-    } else if (e.key === import_constants.ARROW_DOWN || e.key === "p") {
-      setMeridiem((0, import_utils.formatMeridiem)(format, import_constants.PM));
-    } else if (e.key === import_constants.SHIFT) {
+
+  const handleMeridiemKeyDown = e => {
+    if (e.key === constants.ARROW_UP || e.key === 'a') {
+      setMeridiem(utils.formatMeridiem(format, constants.AM));
+    } else if (e.key === constants.ARROW_DOWN || e.key === 'p') {
+      setMeridiem(utils.formatMeridiem(format, constants.PM));
+    } else if (e.key === constants.SHIFT) {
       setCurrentKey(e.key);
-    } else if (e.key === import_constants.BACKSPACE) {
-      setMeridiem("");
+    } else if (e.key === constants.BACKSPACE) {
+      setMeridiem('');
     }
+
     setHasInputBeenTriggered(true);
   };
-  const handleMeridiemBlur = (e) => {
-    const { value } = e.target;
-    if (value !== import_constants.AM && value !== import_constants.PM) {
-      setMeridiem("");
+
+  const handleMeridiemBlur = e => {
+    const {
+      value
+    } = e.target;
+
+    if (value !== constants.AM && value !== constants.PM) {
+      setMeridiem('');
     }
   };
-  const handleOnBlur = (event) => {
-    const selectedTime = (0, import_moment.default)();
+
+  const handleOnBlur = event => {
+    const selectedTime = moment__default["default"]();
+
     if (clearable && !event.currentTarget.contains(event.relatedTarget)) {
-      if (showHours && hours)
-        selectedTime.hours(hours);
-      if (showMinutes && minutes)
-        selectedTime.minutes(minutes);
-      if (showSeconds && seconds)
-        selectedTime.seconds(seconds);
+      if (showHours && hours) selectedTime.hours(hours);
+      if (showMinutes && minutes) selectedTime.minutes(minutes);
+      if (showSeconds && seconds) selectedTime.seconds(seconds);
+
       if (use12Hours && meridiem) {
-        const nextHours = meridiem.toLowerCase() === import_constants.AM ? hours % 12 : hours % 12 + 12;
+        const nextHours = meridiem.toLowerCase() === constants.AM ? hours % 12 : hours % 12 + 12;
         selectedTime.hour(nextHours);
       }
+
       onChange(selectedTime);
     }
   };
+
   const renderSecondsInput = () => {
-    if (!showSeconds)
-      return null;
-    return /* @__PURE__ */ import_react.default.createElement(TimeInput, {
-      ...(0, import_utils.commonInputProps)((e) => onKeyDown(e, import_constants.GENERAL_TIME_RANGE.max), onInputFocus, onClick),
+    if (!showSeconds) return null;
+    return /*#__PURE__*/React.createElement(TimeInput, _objectSpread(_objectSpread({}, utils.commonInputProps(e => onKeyDown(e, constants.GENERAL_TIME_RANGE.max), onInputFocus, onClick)), {}, {
       key: "seconds-input",
       "data-testid": "ds-time-input__seconds",
-      "aria-label": ariaLabel || ariaLabel2 || "Seconds Input",
-      disabled,
-      innerRef: (node) => inputRefs.seconds = node,
+      "aria-label": ariaLabel || ariaLabel2 || 'Seconds Input',
+      disabled: disabled // eslint-disable-next-line no-return-assign
+      ,
+      innerRef: node => node,
       onChange: handleSecondsChange,
-      placeholder: (0, import_utils.placeholderFormat)(import_constants.PLACEHOLDER_TIME.seconds, format),
+      placeholder: utils.placeholderFormat(constants.PLACEHOLDER_TIME.seconds, format),
       value: seconds
-    });
+    }));
   };
+
   const renderMinutesInput = () => {
-    if (!showMinutes)
-      return null;
-    return /* @__PURE__ */ import_react.default.createElement(TimeInput, {
-      ...(0, import_utils.commonInputProps)((e) => onKeyDown(e, import_constants.GENERAL_TIME_RANGE.max), onInputFocus, onClick),
+    if (!showMinutes) return null;
+    return /*#__PURE__*/React.createElement(TimeInput, _objectSpread(_objectSpread({}, utils.commonInputProps(e => onKeyDown(e, constants.GENERAL_TIME_RANGE.max), onInputFocus, onClick)), {}, {
       key: "minutes-input",
       "data-testid": "ds-time-input__minutes",
-      "aria-label": ariaLabel || ariaLabel2 || "Minutes Input",
-      disabled,
-      innerRef: (node) => inputRefs.minutes = node,
+      "aria-label": ariaLabel || ariaLabel2 || 'Minutes Input',
+      disabled: disabled // eslint-disable-next-line no-return-assign
+      ,
+      innerRef: node => node,
       onChange: handleMinutesChange,
-      placeholder: (0, import_utils.placeholderFormat)(import_constants.PLACEHOLDER_TIME.minutes, format),
+      placeholder: utils.placeholderFormat(constants.PLACEHOLDER_TIME.minutes, format),
       value: minutes
-    });
+    }));
   };
+
   const renderHoursInput = () => {
-    if (!showHours)
-      return null;
-    const hourFormatRange = use12Hours ? import_constants.HOUR_RANGE_12 : import_constants.HOUR_RANGE_24;
-    return /* @__PURE__ */ import_react.default.createElement(TimeInput, {
-      ...(0, import_utils.commonInputProps)((e) => onKeyDown(e, hourFormatRange.max), onInputFocus, onClick),
+    if (!showHours) return null;
+    const hourFormatRange = use12Hours ? constants.HOUR_RANGE_12 : constants.HOUR_RANGE_24;
+    return /*#__PURE__*/React.createElement(TimeInput, _objectSpread(_objectSpread({}, utils.commonInputProps(e => onKeyDown(e, hourFormatRange.max), onInputFocus, onClick)), {}, {
       key: "hour-input",
       "data-testid": "ds-time-input__hours",
-      "aria-label": ariaLabel || ariaLabel2 || "Hours Input",
-      disabled,
-      innerRef: (node) => inputRefs.hours = node,
+      "aria-label": ariaLabel || ariaLabel2 || 'Hours Input',
+      disabled: disabled // eslint-disable-next-line no-return-assign
+      ,
+      innerRef: node => node,
       onChange: handleHoursChange,
-      placeholder: (0, import_utils.placeholderFormat)(import_constants.PLACEHOLDER_TIME.hour, format, use12Hours),
+      placeholder: utils.placeholderFormat(constants.PLACEHOLDER_TIME.hour, format, use12Hours),
       value: hours
-    });
+    }));
   };
+
   const renderMeridiemInput = () => {
-    if (!use12Hours)
-      return null;
-    return /* @__PURE__ */ import_react.default.createElement(TimeInput, {
-      ...import_utils.commonInputProps,
+    if (!use12Hours) return null;
+    return /*#__PURE__*/React.createElement(TimeInput, _objectSpread(_objectSpread({}, utils.commonInputProps), {}, {
       key: "meridiem-input",
       "data-testid": "ds-time-input__ampm",
-      "aria-label": ariaLabel || ariaLabel2 || "Meridiem Input",
-      disabled,
+      "aria-label": ariaLabel || ariaLabel2 || 'Meridiem Input',
+      disabled: disabled,
       onBlur: handleMeridiemBlur,
       onKeyDown: handleMeridiemKeyDown,
-      placeholder: (0, import_utils.placeholderFormat)(import_constants.PLACEHOLDER_TIME.meridiem, format),
+      placeholder: utils.placeholderFormat(constants.PLACEHOLDER_TIME.meridiem, format),
       value: meridiem
-    });
+    }));
   };
+
   const renderTimeInputs = () => {
-    const inputs = [
-      renderHoursInput(),
-      renderMinutesInput(),
-      renderSecondsInput()
-    ];
-    const inputsWithDividers = inputs.reduce((acc, input, index) => input ? acc.concat([
-      index ? /* @__PURE__ */ import_react.default.createElement(TimeDivider, {
-        key: index,
-        content: ":",
-        value: input.props.value
-      }) : null,
-      input
-    ]) : acc, []);
-    return [
-      inputsWithDividers,
-      import_react.default.createElement("span", { key: "span" }),
-      renderMeridiemInput()
-    ];
+    const inputs = [renderHoursInput(), renderMinutesInput(), renderSecondsInput()];
+    /* eslint-disable indent */
+
+    const inputsWithDividers = inputs.reduce((acc, input, index) => input ? acc.concat([index ? /*#__PURE__*/_jsx__default["default"](TimeDivider // eslint-disable-next-line react/no-array-index-key
+    , {
+      content: ":",
+      value: input.props.value
+    }, index) : null, input]) : acc, []);
+    /* eslint-enable indent */
+
+    return [inputsWithDividers, /*#__PURE__*/React__default["default"].createElement('span', {
+      key: 'span'
+    }), // hack for next/prev focus
+    renderMeridiemInput()];
   };
-  return /* @__PURE__ */ import_react.default.createElement(InputTimesGroup, {
+
+  return /*#__PURE__*/_jsx__default["default"](InputTimesGroup, {
     onBlur: handleOnBlur,
-    innerRef
-  }, renderTimeInputs());
+    innerRef: innerRef
+  }, void 0, renderTimeInputs());
 };
-var TimeInputs_default = TimeInputs;
-module.exports = __toCommonJS(TimeInputs_exports);
-//# sourceMappingURL=TimeInputs.js.map
+
+module.exports = TimeInputs;