@elliemae/ds-form 2.2.1 → 2.3.0-alpha.4

package/cjs/TimeInput/TimeInputs.js

@@ -1,372 +1,339 @@
-'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
-  };
-}); // 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);
+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;
 };
-
-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);
+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 = require("@elliemae/ds-classnames");
+var import_moment = __toESM(require("moment"));
+var import_utils = require("./utils");
+var import_constants = 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
+  };
+  (0, import_react.useEffect)(() => {
+    if (time && (0, import_moment.default)(time).isValid()) {
+      const timeValues = (0, import_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]);
-  React.useEffect(() => {
-    const selectedTime = time || moment__default["default"]();
-
+  (0, import_react.useEffect)(() => {
+    const selectedTime = time || (0, import_moment.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() === constants.AM ? hours % 12 : hours % 12 + 12;
+        const nextHours = meridiem.toLowerCase() === import_constants.AM ? hours % 12 : hours % 12 + 12;
         selectedTime.hour(nextHours);
       }
-
       onChange(selectedTime);
       setHasInputBeenTriggered(false);
     }
   }, [hours, minutes, seconds, meridiem]);
-
   const focusNextInputIfNeeded = (currentEl, max, number) => {
-    if (utils.shouldFocusNextInput(max, number, currentEl.value) && !utils.isArrowIncrementDecrement(currentKey) && !hasInputValue) {
-      utils.focusNextInput(currentEl);
+    if ((0, import_utils.shouldFocusNextInput)(max, number, currentEl.value) && !(0, import_utils.isArrowIncrementDecrement)(currentKey) && !hasInputValue) {
+      (0, import_utils.focusNextInput)(currentEl);
     }
   };
-
-  const getNextTimeValue = function (value) {
-    let incrementing = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-    const parsedValue = utils.parseTimeNumberFromText(value);
+  const getNextTimeValue = (value, incrementing = true) => {
+    const parsedValue = (0, import_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 constants.ARROW_UP:
-        {
-          event.preventDefault();
-          setCurrentKey(event.key);
-          const incrementedValue = getNextTimeValue(value);
-          utils.setNativeValue(event.target, incrementedValue);
-          break;
-        }
-
-      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 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.SHIFT:
+        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:
         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 = utils.parseTimeNumberFromText(value);
-    const nextSeconds = utils.getValidTimeNumber(constants.GENERAL_TIME_RANGE, secondsHandled, lastTypedNumber);
-    setSeconds(utils.formatSeconds(format, nextSeconds));
+  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));
     setHasInputBeenTriggered(true);
-    focusNextInputIfNeeded(e.target, constants.GENERAL_TIME_RANGE.max, value);
+    focusNextInputIfNeeded(e.target, import_constants.GENERAL_TIME_RANGE.max, value);
   };
-
-  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));
+  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));
     setHasInputBeenTriggered(true);
-    focusNextInputIfNeeded(e.target, constants.GENERAL_TIME_RANGE.max, value);
+    focusNextInputIfNeeded(e.target, import_constants.GENERAL_TIME_RANGE.max, value);
   };
-
-  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));
+  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));
     setHasInputBeenTriggered(true);
     focusNextInputIfNeeded(e.target, hoursRange.max, value);
   };
-
-  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) {
+  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) {
       setCurrentKey(e.key);
-    } else if (e.key === constants.BACKSPACE) {
-      setMeridiem('');
+    } else if (e.key === import_constants.BACKSPACE) {
+      setMeridiem("");
     }
-
     setHasInputBeenTriggered(true);
   };
-
-  const handleMeridiemBlur = e => {
-    const {
-      value
-    } = e.target;
-
-    if (value !== constants.AM && value !== constants.PM) {
-      setMeridiem('');
+  const handleMeridiemBlur = (e) => {
+    const { value } = e.target;
+    if (value !== import_constants.AM && value !== import_constants.PM) {
+      setMeridiem("");
     }
   };
-
-  const handleOnBlur = event => {
-    const selectedTime = moment__default["default"]();
-
+  const handleOnBlur = (event) => {
+    const selectedTime = (0, import_moment.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() === constants.AM ? hours % 12 : hours % 12 + 12;
+        const nextHours = meridiem.toLowerCase() === import_constants.AM ? hours % 12 : hours % 12 + 12;
         selectedTime.hour(nextHours);
       }
-
       onChange(selectedTime);
     }
   };
-
   const renderSecondsInput = () => {
-    if (!showSeconds) return null;
-    return /*#__PURE__*/React.createElement(TimeInput, _objectSpread(_objectSpread({}, utils.commonInputProps(e => onKeyDown(e, constants.GENERAL_TIME_RANGE.max), onInputFocus, onClick)), {}, {
+    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),
       key: "seconds-input",
       "data-testid": "ds-time-input__seconds",
-      "aria-label": ariaLabel || ariaLabel2 || 'Seconds Input',
-      disabled: disabled // eslint-disable-next-line no-return-assign
-      ,
-      innerRef: node => node,
+      "aria-label": ariaLabel || ariaLabel2 || "Seconds Input",
+      disabled,
+      innerRef: (node) => inputRefs.seconds = node,
       onChange: handleSecondsChange,
-      placeholder: utils.placeholderFormat(constants.PLACEHOLDER_TIME.seconds, format),
+      placeholder: (0, import_utils.placeholderFormat)(import_constants.PLACEHOLDER_TIME.seconds, format),
       value: seconds
-    }));
+    });
   };
-
   const renderMinutesInput = () => {
-    if (!showMinutes) return null;
-    return /*#__PURE__*/React.createElement(TimeInput, _objectSpread(_objectSpread({}, utils.commonInputProps(e => onKeyDown(e, constants.GENERAL_TIME_RANGE.max), onInputFocus, onClick)), {}, {
+    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),
       key: "minutes-input",
       "data-testid": "ds-time-input__minutes",
-      "aria-label": ariaLabel || ariaLabel2 || 'Minutes Input',
-      disabled: disabled // eslint-disable-next-line no-return-assign
-      ,
-      innerRef: node => node,
+      "aria-label": ariaLabel || ariaLabel2 || "Minutes Input",
+      disabled,
+      innerRef: (node) => inputRefs.minutes = node,
       onChange: handleMinutesChange,
-      placeholder: utils.placeholderFormat(constants.PLACEHOLDER_TIME.minutes, format),
+      placeholder: (0, import_utils.placeholderFormat)(import_constants.PLACEHOLDER_TIME.minutes, format),
       value: minutes
-    }));
+    });
   };
-
   const renderHoursInput = () => {
-    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)), {}, {
+    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),
       key: "hour-input",
       "data-testid": "ds-time-input__hours",
-      "aria-label": ariaLabel || ariaLabel2 || 'Hours Input',
-      disabled: disabled // eslint-disable-next-line no-return-assign
-      ,
-      innerRef: node => node,
+      "aria-label": ariaLabel || ariaLabel2 || "Hours Input",
+      disabled,
+      innerRef: (node) => inputRefs.hours = node,
       onChange: handleHoursChange,
-      placeholder: utils.placeholderFormat(constants.PLACEHOLDER_TIME.hour, format, use12Hours),
+      placeholder: (0, import_utils.placeholderFormat)(import_constants.PLACEHOLDER_TIME.hour, format, use12Hours),
       value: hours
-    }));
+    });
   };
-
   const renderMeridiemInput = () => {
-    if (!use12Hours) return null;
-    return /*#__PURE__*/React.createElement(TimeInput, _objectSpread(_objectSpread({}, utils.commonInputProps), {}, {
+    if (!use12Hours)
+      return null;
+    return /* @__PURE__ */ import_react.default.createElement(TimeInput, {
+      ...import_utils.commonInputProps,
       key: "meridiem-input",
       "data-testid": "ds-time-input__ampm",
-      "aria-label": ariaLabel || ariaLabel2 || 'Meridiem Input',
-      disabled: disabled,
+      "aria-label": ariaLabel || ariaLabel2 || "Meridiem Input",
+      disabled,
       onBlur: handleMeridiemBlur,
       onKeyDown: handleMeridiemKeyDown,
-      placeholder: utils.placeholderFormat(constants.PLACEHOLDER_TIME.meridiem, format),
+      placeholder: (0, import_utils.placeholderFormat)(import_constants.PLACEHOLDER_TIME.meridiem, format),
       value: meridiem
-    }));
+    });
   };
-
   const renderTimeInputs = () => {
-    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()];
+    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()
+    ];
   };
-
-  return /*#__PURE__*/_jsx__default["default"](InputTimesGroup, {
+  return /* @__PURE__ */ import_react.default.createElement(InputTimesGroup, {
     onBlur: handleOnBlur,
-    innerRef: innerRef
-  }, void 0, renderTimeInputs());
+    innerRef
+  }, renderTimeInputs());
 };
-
-module.exports = TimeInputs;
+var TimeInputs_default = TimeInputs;
+module.exports = __toCommonJS(TimeInputs_exports);
+//# sourceMappingURL=TimeInputs.js.map