@wavemaker/react-runtime 11.14.1-16.6404

package/components/input/epoch/time/index.js

@@ -0,0 +1,412 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _material = require("@mui/material");
+var _xDatePickers = require("@mui/x-date-pickers");
+var _momentTimezone = _interopRequireDefault(require("moment-timezone"));
+var _clsx = _interopRequireDefault(require("clsx"));
+var _BaseDateTime = _interopRequireDefault(require("@wavemaker/react-runtime/higherOrder/BaseDateTime"));
+var _utils = require("./utils");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t2 in e) "default" !== _t2 && {}.hasOwnProperty.call(e, _t2) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t2)) && (i.get || i.set) ? o(f, _t2, i) : f[_t2] = e[_t2]); return f; })(e, t); }
+var __jsx = _react["default"].createElement;
+var WmTime = function WmTime(props) {
+  // Destructure props with defaults
+  var name = props.name,
+    _props$required = props.required,
+    required = _props$required === void 0 ? false : _props$required,
+    _props$placeholder = props.placeholder,
+    placeholder = _props$placeholder === void 0 ? "Select time" : _props$placeholder,
+    hint = props.hint,
+    arialabel = props.arialabel,
+    _props$tabindex = props.tabindex,
+    tabindex = _props$tabindex === void 0 ? 0 : _props$tabindex,
+    shortcutkey = props.shortcutkey,
+    datavalue = props.datavalue,
+    _props$timepattern = props.timepattern,
+    timepattern = _props$timepattern === void 0 ? _utils.DEFAULT_TIMEPATTERN : _props$timepattern,
+    _props$hourstep = props.hourstep,
+    hourstep = _props$hourstep === void 0 ? 1 : _props$hourstep,
+    _props$minutestep = props.minutestep,
+    minutestep = _props$minutestep === void 0 ? 1 : _props$minutestep,
+    _props$outputformat = props.outputformat,
+    outputformat = _props$outputformat === void 0 ? _utils.DEFAULT_OUTPUT_FORMAT : _props$outputformat,
+    mintime = props.mintime,
+    maxtime = props.maxtime,
+    _props$autofocus = props.autofocus,
+    autofocus = _props$autofocus === void 0 ? false : _props$autofocus,
+    _props$readonly = props.readonly,
+    readonly = _props$readonly === void 0 ? false : _props$readonly,
+    _props$disabled = props.disabled,
+    disabled = _props$disabled === void 0 ? false : _props$disabled,
+    _props$showdropdownon = props.showdropdownon,
+    showdropdownon = _props$showdropdownon === void 0 ? "default" : _props$showdropdownon,
+    _props$secondsstep = props.secondsstep,
+    secondsstep = _props$secondsstep === void 0 ? 1 : _props$secondsstep,
+    _props$dataentrymode = props.dataentrymode,
+    dataentrymode = _props$dataentrymode === void 0 ? "default" : _props$dataentrymode,
+    className = props.className,
+    invokeOnChange = props.invokeOnChange,
+    setShowPicker = props.setShowPicker,
+    showPicker = props.showPicker,
+    listener = props.listener,
+    onChange = props.onChange,
+    onClick = props.onClick,
+    _onFocus = props.onFocus,
+    _onBlur = props.onBlur,
+    _onMouseEnter = props.onMouseEnter,
+    _onMouseLeave = props.onMouseLeave,
+    onBeforeload = props.onBeforeload;
+
+  // State
+  var _useState = (0, _react.useState)(null),
+    internalValue = _useState[0],
+    setInternalValue = _useState[1];
+  var _useState2 = (0, _react.useState)(""),
+    displayValue = _useState2[0],
+    setDisplayValue = _useState2[1];
+  var _useState3 = (0, _react.useState)(false),
+    isCurrentTime = _useState3[0],
+    setIsCurrentTime = _useState3[1];
+  var _useState4 = (0, _react.useState)({
+      isValid: true
+    }),
+    validationResult = _useState4[0],
+    setValidationResult = _useState4[1];
+
+  // Refs
+  var onBeforeloadExecutedRef = (0, _react.useRef)(false);
+  var timeIntervalRef = (0, _react.useRef)(null);
+  var anchorRef = (0, _react.useRef)(null);
+
+  // Computed values
+  var isReadOnly = (0, _react.useMemo)(function () {
+    return readonly || dataentrymode !== "undefined" && dataentrymode !== "default";
+  }, [readonly, dataentrymode]);
+  var timeFormatOptions = (0, _react.useMemo)(function () {
+    return (0, _utils.parseTimeFormat)(timepattern);
+  }, [timepattern]);
+  var minTimeObj = (0, _react.useMemo)(function () {
+    return (0, _utils.parseTimeObj)(mintime);
+  }, [mintime]);
+  var maxTimeObj = (0, _react.useMemo)(function () {
+    return (0, _utils.parseTimeObj)(maxtime);
+  }, [maxtime]);
+  // Helper functions
+  var isDropDownDisplayEnabledOnInput = (0, _react.useCallback)(function (dropdownvalue) {
+    return dropdownvalue === "default";
+  }, []);
+  var handleTimeChange = (0, _react.useCallback)(function (newTime, event) {
+    var shouldClosePicker = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    if (!newTime) {
+      setInternalValue(null);
+      setDisplayValue("");
+      setValidationResult({
+        isValid: true
+      });
+      if (shouldClosePicker) setShowPicker === null || setShowPicker === void 0 || setShowPicker(false);
+      return;
+    }
+    var validation = (0, _utils.validateTimeRange)(newTime, minTimeObj, maxTimeObj);
+    setValidationResult(validation);
+    if (validation.isValid) {
+      setInternalValue((0, _momentTimezone["default"])(newTime));
+      var formattedValue = (0, _utils.formatDisplayTimeValue)(newTime, timepattern);
+      setDisplayValue(formattedValue);
+      invokeOnChange === null || invokeOnChange === void 0 || invokeOnChange(newTime, {
+        $event: event,
+        type: "change"
+      });
+      if (name && listener !== null && listener !== void 0 && listener.Widgets[name]) {
+        listener.Widgets[name].displayValue = formattedValue;
+      }
+      (0, _utils.updateListener)(name, listener, props, formattedValue, (0, _utils.formatDisplayTimeValue)(newTime, "timestamp"), (0, _utils.formatDisplayTimeValue)(newTime, outputformat));
+      if (onChange && name && listener !== null && listener !== void 0 && listener.Widgets[name]) {
+        onChange({}, name && (listener === null || listener === void 0 ? void 0 : listener.Widgets[name]), formattedValue, displayValue);
+      }
+    }
+    if (shouldClosePicker) setShowPicker === null || setShowPicker === void 0 || setShowPicker(false);
+  }, [minTimeObj, maxTimeObj, timepattern, invokeOnChange, setShowPicker]);
+  var handlePickerAccept = (0, _react.useCallback)(function (value) {
+    if (value && value.isValid()) {
+      handleTimeChange(value.toDate(), undefined, true);
+    }
+  }, [handleTimeChange]);
+  var handlePickerClose = (0, _react.useCallback)(function () {
+    setShowPicker === null || setShowPicker === void 0 || setShowPicker(false);
+  }, [setShowPicker]);
+  var handleInputChange = (0, _react.useCallback)(function (event) {
+    try {
+      var inputValue = event.target.value;
+      if (!inputValue) {
+        handleTimeChange(null, event, false);
+        return;
+      }
+      var formatValidation = (0, _utils.validateTimeFormat)(inputValue, timepattern, required);
+      if (!formatValidation.isValid) {
+        setValidationResult(formatValidation);
+        setDisplayValue(inputValue);
+        return;
+      }
+      var parsedTime = (0, _utils.parseTimeValue)(inputValue, timepattern);
+      if (parsedTime && parsedTime.isValid()) {
+        var rangeValidation = (0, _utils.validateTimeRange)(parsedTime.toDate(), minTimeObj, maxTimeObj);
+        setValidationResult(rangeValidation);
+        if (rangeValidation.isValid) {
+          handleTimeChange(parsedTime.toDate(), event, false);
+        } else {
+          setDisplayValue(inputValue);
+        }
+      } else {
+        if (required) {
+          setValidationResult({
+            isValid: false,
+            errorType: "format",
+            message: "Invalid time format. Expected: ".concat(timepattern)
+          });
+        }
+        setDisplayValue(inputValue);
+      }
+    } catch (error) {
+      console.error("Error in handleInputChange:", error);
+      setValidationResult({
+        isValid: false,
+        errorType: "format",
+        message: "Error processing input"
+      });
+    }
+  }, [handleTimeChange, timepattern, minTimeObj, maxTimeObj]);
+  var handleClick = (0, _react.useCallback)(function (event) {
+    try {
+      if (disabled || readonly || isCurrentTime) return;
+
+      // Ensure the input gets focus on click
+      if (anchorRef.current && !anchorRef.current.contains(document.activeElement)) {
+        anchorRef.current.focus();
+      }
+      if (isDropDownDisplayEnabledOnInput(showdropdownon)) {
+        setShowPicker === null || setShowPicker === void 0 || setShowPicker(true);
+      }
+      if (onClick && name) {
+        onClick(event, listener === null || listener === void 0 ? void 0 : listener.Widgets[name]);
+      }
+    } catch (error) {
+      console.error("Error in handleClick:", error);
+    }
+  }, [disabled, readonly, isCurrentTime, showdropdownon, isDropDownDisplayEnabledOnInput, setShowPicker]);
+  var handleInputKeyDown = (0, _react.useCallback)(function (event) {
+    try {
+      if (shortcutkey && event.altKey && event.key.toLowerCase() === shortcutkey.toLowerCase()) {
+        var _anchorRef$current;
+        event.preventDefault();
+        (_anchorRef$current = anchorRef.current) === null || _anchorRef$current === void 0 || _anchorRef$current.focus();
+        return;
+      }
+      if (isDropDownDisplayEnabledOnInput(showdropdownon)) {
+        if (event.key === "Enter" || event.key === "ArrowDown") {
+          event.preventDefault();
+          setShowPicker === null || setShowPicker === void 0 || setShowPicker(true);
+        } else if (event.key === "Escape") {
+          setShowPicker === null || setShowPicker === void 0 || setShowPicker(false);
+        }
+      }
+    } catch (error) {
+      console.error("Error in handleInputKeyDown:", error);
+    }
+  }, [shortcutkey, showdropdownon, isDropDownDisplayEnabledOnInput, setShowPicker]);
+  var handleTimePickerChange = (0, _react.useCallback)(function (newValue) {
+    if (newValue && newValue.isValid()) {
+      var newDate = newValue.toDate();
+      setInternalValue((0, _momentTimezone["default"])(newDate));
+      setDisplayValue((0, _utils.formatDisplayTimeValue)(newDate, timepattern));
+    } else {
+      setInternalValue(null);
+      setDisplayValue("");
+    }
+  }, [timepattern]);
+
+  // Data value effect
+  (0, _react.useEffect)(function () {
+    if (datavalue === "CURRENT_TIME") {
+      setIsCurrentTime(true);
+      var now = (0, _momentTimezone["default"])();
+      setInternalValue(now);
+      setDisplayValue((0, _utils.formatDisplayTimeValue)(now, timepattern));
+      timeIntervalRef.current = setInterval(function () {
+        var current = (0, _momentTimezone["default"])();
+        setInternalValue(current);
+        setDisplayValue((0, _utils.formatDisplayTimeValue)(current, timepattern));
+        (0, _utils.updateListener)(name, listener, props, (0, _utils.formatDisplayTimeValue)(current, timepattern), (0, _utils.formatDisplayTimeValue)(current, "timestamp"), (0, _utils.formatDisplayTimeValue)(current, outputformat));
+      }, 1000);
+    } else {
+      if (timeIntervalRef.current) {
+        clearInterval(timeIntervalRef.current);
+        timeIntervalRef.current = null;
+      }
+      setIsCurrentTime(false);
+      if (datavalue) {
+        var parsed;
+        if (typeof datavalue === "string" && /^\d+$/.test(datavalue)) {
+          parsed = (0, _momentTimezone["default"])(parseInt(datavalue, 10));
+        } else if (typeof datavalue === "number") {
+          parsed = (0, _momentTimezone["default"])(datavalue);
+        } else if (datavalue instanceof Date) {
+          parsed = (0, _momentTimezone["default"])(datavalue);
+        } else {
+          parsed = (0, _momentTimezone["default"])(datavalue, timepattern);
+        }
+        setInternalValue(parsed);
+        setDisplayValue((0, _utils.formatDisplayTimeValue)(parsed, timepattern));
+        (0, _utils.updateListener)(name, listener, props, (0, _utils.formatDisplayTimeValue)(parsed, timepattern), (0, _utils.formatDisplayTimeValue)(parsed, "timestamp"), (0, _utils.formatDisplayTimeValue)(parsed, outputformat));
+      } else {
+        setInternalValue(null);
+        setDisplayValue("");
+      }
+    }
+    return function () {
+      if (timeIntervalRef.current) {
+        clearInterval(timeIntervalRef.current);
+        timeIntervalRef.current = null;
+      }
+    };
+  }, [datavalue, timepattern]);
+
+  // Shortcut key setup
+  (0, _react.useEffect)(function () {
+    if (!shortcutkey) return;
+    var handleGlobalKeyDown = function handleGlobalKeyDown(event) {
+      if (event.altKey && event.key.toLowerCase() === shortcutkey.toLowerCase()) {
+        var _anchorRef$current2;
+        event.preventDefault();
+        (_anchorRef$current2 = anchorRef.current) === null || _anchorRef$current2 === void 0 || _anchorRef$current2.focus();
+      }
+    };
+    document.addEventListener("keydown", handleGlobalKeyDown);
+    return function () {
+      return document.removeEventListener("keydown", handleGlobalKeyDown);
+    };
+  }, [shortcutkey]);
+  (0, _react.useEffect)(function () {
+    var _props$listener;
+    if (onBeforeload && name && (_props$listener = props.listener) !== null && _props$listener !== void 0 && (_props$listener = _props$listener.Widgets) !== null && _props$listener !== void 0 && _props$listener[name] && !onBeforeloadExecutedRef.current) {
+      var _props$listener2;
+      var syntheticEvent = {};
+      onBeforeload(syntheticEvent, (_props$listener2 = props.listener) === null || _props$listener2 === void 0 || (_props$listener2 = _props$listener2.Widgets) === null || _props$listener2 === void 0 ? void 0 : _props$listener2[name]);
+      onBeforeloadExecutedRef.current = true;
+    }
+  }, [onBeforeload, name, props.listener]);
+
+  // Render the main TextField component
+  var renderTextField = (0, _react.useCallback)(function () {
+    return __jsx(_material.TextField, {
+      inputRef: anchorRef,
+      autoFocus: autofocus && !disabled && !readonly && !isReadOnly,
+      fullWidth: true,
+      name: name,
+      required: required,
+      disabled: disabled || readonly,
+      "aria-readonly": readonly || isCurrentTime,
+      value: displayValue,
+      onChange: handleInputChange,
+      onClick: handleClick,
+      onFocus: function onFocus(event) {
+        return _onFocus && name && _onFocus(event, listener === null || listener === void 0 ? void 0 : listener.Widgets[name]);
+      },
+      onBlur: function onBlur(event) {
+        var _listener$Widgets;
+        return _onBlur && name && listener !== null && listener !== void 0 && (_listener$Widgets = listener.Widgets) !== null && _listener$Widgets !== void 0 && _listener$Widgets[name] ? _onBlur(event, listener.Widgets[name]) : undefined;
+      },
+      onMouseEnter: function onMouseEnter(event) {
+        var _listener$Widgets2;
+        return _onMouseEnter && name && listener !== null && listener !== void 0 && (_listener$Widgets2 = listener.Widgets) !== null && _listener$Widgets2 !== void 0 && _listener$Widgets2[name] ? _onMouseEnter(event, listener.Widgets[name]) : undefined;
+      },
+      onMouseLeave: function onMouseLeave(event) {
+        var _listener$Widgets3;
+        return _onMouseLeave && name && listener !== null && listener !== void 0 && (_listener$Widgets3 = listener.Widgets) !== null && _listener$Widgets3 !== void 0 && _listener$Widgets3[name] ? _onMouseLeave(event, listener.Widgets[name]) : undefined;
+      },
+      onKeyDown: handleInputKeyDown,
+      placeholder: placeholder,
+      error: !validationResult.isValid,
+      helperText: validationResult.message || "",
+      slotProps: {
+        htmlInput: {
+          tabIndex: readonly || isReadOnly || isCurrentTime ? -1 : tabindex,
+          readOnly: isReadOnly || readonly || isCurrentTime,
+          className: "form-control app-textbox app-dateinput display-input",
+          "aria-label": arialabel || placeholder,
+          accessKey: shortcutkey,
+          role: "timer",
+          "aria-atomic": isCurrentTime ? "true" : "false",
+          title: hint,
+          onFocus: readonly || isReadOnly || isCurrentTime ? function (e) {
+            return e.target.blur();
+          } : undefined
+        }
+      },
+      InputProps: {
+        className: readonly || isReadOnly ? "readonly" : "",
+        endAdornment: __jsx(_material.Box, {
+          component: "span",
+          className: "input-group-btn dropdown-toggle"
+        }, __jsx(_material.Button, {
+          className: "btn btn-default btn-date",
+          variant: "contained",
+          disableRipple: false,
+          onClick: function onClick() {
+            return setShowPicker === null || setShowPicker === void 0 ? void 0 : setShowPicker(true);
+          },
+          "aria-label": "Select time",
+          "aria-haspopup": "true",
+          "aria-expanded": showPicker ? "true" : "false",
+          tabIndex: readonly || isReadOnly || isCurrentTime ? -1 : tabindex,
+          disableTouchRipple: true,
+          disabled: disabled || readonly || isCurrentTime
+        }, __jsx("span", {
+          className: "app-icon wm-sl-l sl-time",
+          "aria-hidden": "true"
+        })))
+      }
+    });
+  }, [name, required, disabled, isCurrentTime, displayValue, handleInputChange, handleClick, handleInputKeyDown, placeholder, tabindex, arialabel, shortcutkey, isReadOnly, readonly, validationResult, setShowPicker, showPicker, hint]);
+  var views = ["hours", "minutes"];
+  if (timeFormatOptions.hasSeconds) views.push("seconds");
+  return __jsx(_material.Box, {
+    className: (0, _clsx["default"])(_utils.DEFAULT_CLASS, className)
+  }, renderTextField(), showPicker && __jsx(_xDatePickers.TimePicker, {
+    disableIgnoringDatePartForTimeValidation: true,
+    open: showPicker,
+    onClose: handlePickerClose,
+    onAccept: handlePickerAccept,
+    value: internalValue,
+    onChange: handleTimePickerChange,
+    timeSteps: {
+      minutes: minutestep,
+      hours: hourstep,
+      seconds: secondsstep
+    },
+    minTime: minTimeObj ? (0, _momentTimezone["default"])(minTimeObj) : undefined,
+    maxTime: maxTimeObj ? (0, _momentTimezone["default"])(maxTimeObj) : undefined,
+    ampm: timeFormatOptions.is12Hour,
+    views: views,
+    skipDisabled: true,
+    ampmInClock: timeFormatOptions.is12Hour,
+    format: timepattern,
+    slotProps: {
+      textField: {
+        hidden: true
+      },
+      popper: {
+        anchorEl: anchorRef.current,
+        placement: "bottom-start",
+        sx: _utils.TIME_PICKER_STYLES
+      }
+    }
+  }));
+};
+WmTime.displayName = "WmTime";
+var _default = exports["default"] = (0, _BaseDateTime["default"])(WmTime);

package/components/input/epoch/time/props.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/components/input/epoch/time/utils.js

@@ -0,0 +1,209 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TIME_PICKER_STYLES = exports.READONLY_STYLES = exports.DEFAULT_TIMEPATTERN = exports.DEFAULT_OUTPUT_FORMAT = exports.DEFAULT_CLASS = void 0;
+exports.formatDisplayTimeValue = formatDisplayTimeValue;
+exports.getSupportedTimeFormats = getSupportedTimeFormats;
+exports.parseTimeFormat = parseTimeFormat;
+exports.parseTimeObj = parseTimeObj;
+exports.parseTimeValue = parseTimeValue;
+exports.updateListener = updateListener;
+exports.validateTimeFormat = validateTimeFormat;
+exports.validateTimeRange = validateTimeRange;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _momentTimezone = _interopRequireDefault(require("moment-timezone"));
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function parseTimeFormat() {
+  var timepattern = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "hh:mm a";
+  var hasSeconds = timepattern.toLowerCase().includes("s");
+  var is12Hour = timepattern.includes("h");
+  return {
+    format: timepattern,
+    hasSeconds: hasSeconds,
+    is12Hour: is12Hour
+  };
+}
+function getSupportedTimeFormats() {
+  return ["HH:mm:ss", "HH:mm", "H:mm:ss", "H:mm", "hh:mm:ss a", "hh:mm a", "h:mm:ss a", "h:mm a", "HH:mm:ss.SSS"];
+}
+function parseTimeValue(value, timepattern) {
+  if (!value) return null;
+  try {
+    if (value === "CURRENT_TIME") {
+      return (0, _momentTimezone["default"])();
+    }
+    if (typeof value === "number") {
+      return (0, _momentTimezone["default"])(value);
+    }
+    if (value instanceof Date) {
+      return (0, _momentTimezone["default"])(value);
+    }
+    if (typeof value === "string") {
+      var parsed = (0, _momentTimezone["default"])(value, timepattern, true);
+      if (parsed.isValid()) return parsed;
+      var formats = getSupportedTimeFormats();
+      var _iterator = _createForOfIteratorHelper(formats),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var format = _step.value;
+          parsed = (0, _momentTimezone["default"])(value, format, true);
+          if (parsed.isValid()) return parsed;
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      parsed = (0, _momentTimezone["default"])(value);
+      if (parsed.isValid()) return parsed;
+    }
+    return null;
+  } catch (error) {
+    console.warn("Error parsing time value:", error);
+    return null;
+  }
+}
+function formatDisplayTimeValue(value, pattern) {
+  if (!value) return "";
+  try {
+    var momentObj = _momentTimezone["default"].isMoment(value) ? value : (0, _momentTimezone["default"])(value);
+    if (pattern === "timestamp") {
+      return momentObj.valueOf().toString();
+    }
+    return momentObj.isValid() ? momentObj.format(pattern) : "";
+  } catch (error) {
+    console.warn("Error formatting display value:", error);
+    return "";
+  }
+}
+function validateTimeRange(timeValue, minTime, maxTime) {
+  if (!timeValue) return {
+    isValid: true
+  };
+  try {
+    var timeToCheck = _momentTimezone["default"].isMoment(timeValue) ? timeValue : (0, _momentTimezone["default"])(timeValue);
+    if (!timeToCheck.isValid()) {
+      return {
+        isValid: false,
+        errorType: "format",
+        message: "Invalid time format"
+      };
+    }
+    var timeToCheckMinutes = timeToCheck.hours() * 60 + timeToCheck.minutes();
+    if (minTime) {
+      var minMoment = typeof minTime === "string" ? (0, _momentTimezone["default"])(minTime, ["HH:mm", "H:mm", "hh:mm a", "h:mm a"], true) : (0, _momentTimezone["default"])(minTime);
+      if (minMoment.isValid()) {
+        var minMinutes = minMoment.hours() * 60 + minMoment.minutes();
+        if (timeToCheckMinutes < minMinutes) {
+          return {
+            isValid: false,
+            errorType: "mintime",
+            message: "Time must be later than ".concat(minMoment.format("HH:mm"))
+          };
+        }
+      }
+    }
+    if (maxTime) {
+      var maxMoment = typeof maxTime === "string" ? (0, _momentTimezone["default"])(maxTime, ["HH:mm", "H:mm", "hh:mm a", "h:mm a"], true) : (0, _momentTimezone["default"])(maxTime);
+      if (maxMoment.isValid()) {
+        var maxMinutes = maxMoment.hours() * 60 + maxMoment.minutes();
+        if (timeToCheckMinutes > maxMinutes) {
+          return {
+            isValid: false,
+            errorType: "maxtime",
+            message: "Time must be earlier than ".concat(maxMoment.format("HH:mm"))
+          };
+        }
+      }
+    }
+    return {
+      isValid: true
+    };
+  } catch (error) {
+    console.warn("Error validating time range:", error);
+    return {
+      isValid: false,
+      errorType: "format",
+      message: "Validation error"
+    };
+  }
+}
+function validateTimeFormat(inputValue, pattern, required) {
+  if (!inputValue.trim()) return {
+    isValid: true
+  };
+  try {
+    var parsed = (0, _momentTimezone["default"])(inputValue, pattern, true);
+    if (!parsed.isValid() && required) {
+      return {
+        isValid: false,
+        errorType: "format",
+        message: "Invalid time format. Expected: ".concat(pattern)
+      };
+    }
+    return {
+      isValid: true
+    };
+  } catch (error) {
+    return {
+      isValid: false,
+      errorType: "format",
+      message: "Invalid time format"
+    };
+  }
+}
+function parseTimeObj(timeValue) {
+  if (!timeValue) return null;
+  try {
+    return typeof timeValue === "string" ? (0, _momentTimezone["default"])(timeValue, getSupportedTimeFormats(), true).toDate() : timeValue instanceof Date ? timeValue : null;
+  } catch (error) {
+    console.warn("Error parsing time object:", error);
+    return null;
+  }
+}
+
+// Constants
+var DEFAULT_CLASS = exports.DEFAULT_CLASS = "input-group app-timeinput";
+var DEFAULT_TIMEPATTERN = exports.DEFAULT_TIMEPATTERN = "h:mm:ss a";
+var DEFAULT_OUTPUT_FORMAT = exports.DEFAULT_OUTPUT_FORMAT = "HH:mm:ss";
+
+// Styling constants
+var READONLY_STYLES = exports.READONLY_STYLES = {
+  cursor: "not-allowed"
+};
+var TIME_PICKER_STYLES = exports.TIME_PICKER_STYLES = {
+  "& .MuiPaper-root": {
+    background: "var(--wm-timepicker-background)",
+    padding: "var(--wm-timepicker-padding)",
+    borderRadius: "var(--wm-timepicker-border-radius)",
+    width: "auto",
+    boxShadow: "none"
+  },
+  "& .Mui-selected": {
+    backgroundColor: "var(--wm-btn-secondary-background) !important",
+    color: "var(--wm-btn-secondary-color) !important"
+  },
+  "& .Mui-selected:hover": {
+    backgroundColor: "var(--wm-btn-secondary-background) !important",
+    color: "var(--wm-btn-secondary-color) !important"
+  }
+};
+function updateListener(name, listener, props, displayValue, timestamp, datavalue) {
+  // Update listener widget display value
+
+  if (listener !== null && listener !== void 0 && listener.onChange) {
+    listener.onChange(name || "", _objectSpread(_objectSpread({}, props), {}, {
+      displayValue: displayValue,
+      timestamp: timestamp,
+      datavalue: datavalue
+    }));
+  }
+}