@wavemaker-ai/react-runtime 1.0.0-next.27766

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

@@ -0,0 +1,742 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useState, useRef, useEffect, useCallback, useMemo, forwardRef } from "react";
+import moment from "moment-timezone";
+import { TextField, Box } from "@mui/material";
+import withBaseDateTime from "../../../../higherOrder/BaseDateTime";
+import {
+  convertToMomentFormat,
+  formatDate,
+  parseExcludedDays,
+  parseExcludedDates,
+  defaultGetDateObj,
+  getWidthStyle,
+  validateDate
+} from "./utils";
+import DatePickerPopover from "./components/DatePickerPopover";
+import withFormController from "../../../data/form/form-controller/withFormController";
+import { WmButton } from "../../../form/button";
+import withStandalone from "../../../../higherOrder/withStandalone";
+import withBaseWrapper from "../../../../higherOrder/withBaseWrapper";
+const WmDate = forwardRef((props, ref) => {
+  var _b;
+  const _a = props, {
+    name,
+    hint,
+    shortcutkey,
+    datavalue,
+    width,
+    arialabel,
+    invokeOnChange,
+    handleKeyDown,
+    getDateObj = defaultGetDateObj,
+    updatePrevDatavalue,
+    updateBoundVariable,
+    onChange,
+    onClick,
+    onFocus,
+    onBlur,
+    onMouseEnter,
+    onMouseLeave,
+    onBeforeload,
+    placeholder = "Select Date",
+    tabindex = 0,
+    datepattern: datepatternProp,
+    outputformat = "yyyy-MM-dd",
+    defaultDateFormat,
+    selectedLocale,
+    required = false,
+    excludedays = "",
+    excludedates = "",
+    showweeks = false,
+    showbuttonbar = true,
+    autofocus = false,
+    readonly = false,
+    disabled = false,
+    showdropdownon = "default",
+    adaptiveposition = true,
+    selectfromothermonth = true,
+    todaybutton = true,
+    clearbutton = true,
+    todaybuttonlabel = "Today",
+    clearbuttonlabel = "Clear",
+    showcustompicker = false,
+    showdateformatasplaceholder = false,
+    viewmode = "day",
+    dataentrymode = "default",
+    listener,
+    className,
+    styles,
+    validators = [],
+    validationmessage
+  } = _a, restProps = __objRest(_a, [
+    "name",
+    "hint",
+    "shortcutkey",
+    "datavalue",
+    "width",
+    "arialabel",
+    "invokeOnChange",
+    "handleKeyDown",
+    "getDateObj",
+    "updatePrevDatavalue",
+    "updateBoundVariable",
+    "onChange",
+    "onClick",
+    "onFocus",
+    "onBlur",
+    "onMouseEnter",
+    "onMouseLeave",
+    "onBeforeload",
+    "placeholder",
+    "tabindex",
+    "datepattern",
+    "outputformat",
+    "defaultDateFormat",
+    "selectedLocale",
+    "required",
+    "excludedays",
+    "excludedates",
+    "showweeks",
+    "showbuttonbar",
+    "autofocus",
+    "readonly",
+    "disabled",
+    "showdropdownon",
+    "adaptiveposition",
+    "selectfromothermonth",
+    "todaybutton",
+    "clearbutton",
+    "todaybuttonlabel",
+    "clearbuttonlabel",
+    "showcustompicker",
+    "showdateformatasplaceholder",
+    "viewmode",
+    "dataentrymode",
+    "listener",
+    "className",
+    "styles",
+    "validators",
+    "validationmessage"
+  ]);
+  const [resolvedDateFormat, currentLocale] = useMemo(
+    () => {
+      var _a2;
+      return [
+        defaultDateFormat || ((_a2 = listener == null ? void 0 : listener.localeFormats) == null ? void 0 : _a2.date) || "MMM d, y",
+        selectedLocale || (listener == null ? void 0 : listener.selectedLocale) || "en"
+      ];
+    },
+    [defaultDateFormat, selectedLocale, (_b = listener == null ? void 0 : listener.localeFormats) == null ? void 0 : _b.date, listener == null ? void 0 : listener.selectedLocale]
+  );
+  const datepattern = useMemo(
+    () => datepatternProp != null ? datepatternProp : resolvedDateFormat,
+    [datepatternProp, resolvedDateFormat]
+  );
+  const [showPicker, setShowPicker] = useState(false);
+  const [inputValue, setInputValue] = useState("");
+  const [anchorEl, setAnchorEl] = useState(null);
+  const [invalidDateTimeFormat, setInvalidDateTimeFormat] = useState(false);
+  const [dateNotInRange, setDateNotInRange] = useState(false);
+  const [validationFailureMessage, setValidationFailureMessage] = useState("");
+  const [calendarViewMode, setCalendarViewMode] = useState(
+    viewmode
+  );
+  const [calendarDate, setCalendarDate] = useState(moment());
+  const [selectedDate, setSelectedDate] = useState(null);
+  const [isCurrentDate, setIsCurrentDate] = useState(false);
+  const datepickerRef = useRef(null);
+  const inputRef = useRef(null);
+  const onBeforeloadExecutedRef = useRef(false);
+  const excludedDaysToDisable = useMemo(() => parseExcludedDays(excludedays), [excludedays]);
+  const excludedDatesToDisable = useMemo(
+    () => parseExcludedDates(excludedates, getDateObj),
+    [excludedates, getDateObj]
+  );
+  const dateValue = useMemo(() => {
+    if (datavalue === "CURRENT_DATE") {
+      setIsCurrentDate(true);
+    }
+    return getDateObj(datavalue);
+  }, [datavalue, getDateObj]);
+  const minDateObj = useMemo(() => {
+    return restProps.mindate ? getDateObj(restProps.mindate) : null;
+  }, [restProps.mindate, getDateObj]);
+  const maxDateObj = useMemo(() => {
+    return restProps.maxdate ? getDateObj(restProps.maxdate) : null;
+  }, [restProps.maxdate, getDateObj]);
+  const validateDateWithProps = useCallback(
+    (date) => {
+      if (!date) return true;
+      const validation = validateDate(
+        date,
+        minDateObj,
+        maxDateObj,
+        excludedDaysToDisable,
+        excludedDatesToDisable,
+        validators,
+        validationmessage
+      );
+      setDateNotInRange(validation.isOutOfRange);
+      setValidationFailureMessage(validation.validationMessage || "");
+      setInvalidDateTimeFormat(false);
+      return validation.isValid;
+    },
+    [
+      minDateObj,
+      maxDateObj,
+      excludedDaysToDisable,
+      excludedDatesToDisable,
+      validators,
+      validationmessage
+    ]
+  );
+  const isDateDisabled = useCallback(
+    (date) => {
+      if (!(date == null ? void 0 : date.isValid())) return false;
+      const validation = validateDate(
+        date,
+        minDateObj,
+        maxDateObj,
+        excludedDaysToDisable,
+        excludedDatesToDisable,
+        validators,
+        validationmessage
+      );
+      return validation.isDisabled || false;
+    },
+    [
+      minDateObj,
+      maxDateObj,
+      excludedDaysToDisable,
+      excludedDatesToDisable,
+      validators,
+      validationmessage
+    ]
+  );
+  const isNavigationDisabled = useMemo(() => {
+    if (!restProps.mindate || !restProps.maxdate) return false;
+    const minMoment = moment(getDateObj(restProps.mindate));
+    const maxMoment = moment(getDateObj(restProps.maxdate));
+    return minMoment.isValid() && maxMoment.isValid() && minMoment.isSame(maxMoment, "day");
+  }, [restProps.mindate, restProps.maxdate, getDateObj]);
+  const shouldOpenOnInput = showdropdownon === "default" || dataentrymode === "picker" && showdropdownon !== "button";
+  const getDisplayValue = useCallback(() => {
+    if (!dateValue) return "";
+    try {
+      const momentDate = moment(dateValue).locale(currentLocale);
+      const momentPattern = convertToMomentFormat(datepattern);
+      return momentDate.format(momentPattern);
+    } catch (e) {
+      return "";
+    }
+  }, [dateValue, datepattern, currentLocale]);
+  const getPlaceholderText = useCallback(() => {
+    return showdateformatasplaceholder ? datepattern.toUpperCase() : placeholder;
+  }, [showdateformatasplaceholder, datepattern, placeholder]);
+  useEffect(() => {
+    if (invalidDateTimeFormat) return;
+    const displayValue = getDisplayValue();
+    setInputValue(displayValue);
+    if (dateValue) {
+      const momentDateValue = moment(dateValue);
+      setSelectedDate(momentDateValue);
+      setCalendarDate(momentDateValue);
+      if (listener == null ? void 0 : listener.onChange) {
+        listener.onChange(name || props.fieldName, {
+          displayValue,
+          datavalue: formatDate(momentDateValue.toDate(), outputformat),
+          timestamp: formatDate(momentDateValue.toDate(), "timestamp")
+        });
+      }
+    } else if (props.maxdate) {
+      const maxDate = moment(props.maxdate);
+      const currentDate = moment();
+      if (maxDate.isValid() && maxDate.isBefore(currentDate)) {
+        setSelectedDate(maxDate);
+        setCalendarDate(maxDate);
+      }
+    } else {
+      setSelectedDate(null);
+      setCalendarDate(moment());
+    }
+  }, [dateValue, getDisplayValue, datavalue, props.maxdate]);
+  useEffect(() => {
+    if (autofocus && inputRef.current) {
+      const timer = setTimeout(() => {
+        var _a2;
+        return (_a2 = inputRef.current) == null ? void 0 : _a2.focus();
+      }, 0);
+      return () => clearTimeout(timer);
+    }
+  }, [autofocus]);
+  useEffect(() => {
+    setCalendarViewMode(viewmode);
+  }, [viewmode]);
+  useEffect(() => {
+    if (dateValue && !invalidDateTimeFormat) {
+      const newDisplayValue = getDisplayValue();
+      setInputValue(newDisplayValue);
+      if (name && (listener == null ? void 0 : listener.Widgets[name])) {
+        listener.Widgets[name].displayValue = newDisplayValue;
+      }
+    }
+  }, [currentLocale, getDisplayValue, dateValue, name, invalidDateTimeFormat]);
+  useEffect(() => {
+    var _a2, _b2, _c, _d;
+    if (onBeforeload && name && ((_b2 = (_a2 = props.listener) == null ? void 0 : _a2.Widgets) == null ? void 0 : _b2[name]) && !onBeforeloadExecutedRef.current) {
+      const syntheticEvent = {};
+      onBeforeload(syntheticEvent, (_d = (_c = props.listener) == null ? void 0 : _c.Widgets) == null ? void 0 : _d[name]);
+      onBeforeloadExecutedRef.current = true;
+    }
+  }, [onBeforeload, name]);
+  const handleOpen = useCallback(
+    (event) => {
+      if (disabled || readonly) return;
+      setAnchorEl(event.currentTarget);
+      setShowPicker(true);
+      const targetDate = (selectedDate == null ? void 0 : selectedDate.isValid()) ? selectedDate : dateValue ? moment(dateValue) : moment();
+      setCalendarDate(targetDate);
+      if (dateValue && !selectedDate) {
+        setSelectedDate(moment(dateValue));
+      }
+      setCalendarViewMode(viewmode === "month" ? "month" : viewmode);
+    },
+    [disabled, readonly, selectedDate, dateValue, viewmode]
+  );
+  const clearDateValue = useCallback(
+    (invokeOnChange2, updatePrevDatavalue2, updateBoundVariable2, setInputValue2, setSelectedDate2, setInvalidDateTimeFormat2, setDateNotInRange2) => {
+      var _a2, _b2;
+      const oldValue = inputValue;
+      invokeOnChange2 == null ? void 0 : invokeOnChange2("");
+      updatePrevDatavalue2 == null ? void 0 : updatePrevDatavalue2("");
+      updateBoundVariable2 == null ? void 0 : updateBoundVariable2("");
+      setInputValue2 == null ? void 0 : setInputValue2("");
+      setSelectedDate2 == null ? void 0 : setSelectedDate2(null);
+      setInvalidDateTimeFormat2 == null ? void 0 : setInvalidDateTimeFormat2(false);
+      setDateNotInRange2 == null ? void 0 : setDateNotInRange2(false);
+      setValidationFailureMessage == null ? void 0 : setValidationFailureMessage("");
+      if (listener == null ? void 0 : listener.onChange) {
+        listener.onChange(props.fieldName || name, __spreadProps(__spreadValues({}, props), {
+          datavalue: "",
+          timestamp: null
+        }));
+      }
+      if (onChange && name && (((_a2 = listener == null ? void 0 : listener.Widgets) == null ? void 0 : _a2[name]) || props.standalone)) {
+        onChange({}, (_b2 = listener == null ? void 0 : listener.Widgets) == null ? void 0 : _b2[name], "", oldValue);
+      }
+    },
+    [name, onChange, props, inputValue]
+  );
+  const handleDateSelection = (date, shouldClose = false) => {
+    const dateObj = date.toDate();
+    if (!validateDateWithProps(dateObj)) {
+      return;
+    }
+    setDateNotInRange(false);
+    setInvalidDateTimeFormat(false);
+    setValidationFailureMessage("");
+    setSelectedDate(date.clone());
+    updateDateValue(date);
+    setCalendarDate(date);
+    if (shouldClose) {
+      handleClose();
+    }
+  };
+  const handleValidationError = (errorType, isRequired = false) => {
+    if (errorType === "dateNotInRange") {
+      setDateNotInRange(true);
+      setValidationFailureMessage(validationmessage || "Date not in range");
+    } else if (errorType === "invalidFormat" && isRequired) {
+      setInvalidDateTimeFormat(true);
+      setValidationFailureMessage(validationmessage || "Invalid date format");
+    }
+  };
+  const handleClose = useCallback(() => {
+    setAnchorEl(null);
+    setShowPicker(false);
+    setTimeout(() => {
+      if (inputRef.current && !disabled && !readonly) {
+        inputRef.current.focus();
+      }
+    }, 0);
+  }, [disabled, readonly]);
+  const updateDateValue = useCallback(
+    (date) => {
+      var _a2, _b2, _c;
+      const outputValue = formatDate(date.toDate(), outputformat);
+      const displayValue = moment(date.toDate()).locale(currentLocale).format(convertToMomentFormat(datepattern));
+      invokeOnChange == null ? void 0 : invokeOnChange(outputValue);
+      updatePrevDatavalue == null ? void 0 : updatePrevDatavalue(outputValue);
+      updateBoundVariable == null ? void 0 : updateBoundVariable(outputValue);
+      setInputValue(displayValue);
+      const oldValue = inputValue;
+      if (name && ((_a2 = listener == null ? void 0 : listener.Widgets) == null ? void 0 : _a2[name])) {
+        listener.Widgets[name].displayValue = displayValue;
+      }
+      if (listener == null ? void 0 : listener.onChange) {
+        listener.onChange(props.fieldName || name, __spreadProps(__spreadValues({}, props), {
+          datavalue: outputValue,
+          timestamp: formatDate(date.toDate(), "timestamp")
+        }));
+      }
+      if (onChange && name && (((_b2 = listener == null ? void 0 : listener.Widgets) == null ? void 0 : _b2[name]) || props.standalone)) {
+        onChange(
+          {},
+          name && ((_c = listener == null ? void 0 : listener.Widgets) == null ? void 0 : _c[name]),
+          outputValue,
+          oldValue
+        );
+      }
+    },
+    [
+      outputformat,
+      datepattern,
+      currentLocale,
+      invokeOnChange,
+      updatePrevDatavalue,
+      updateBoundVariable,
+      inputValue,
+      props.formfield,
+      name,
+      onChange,
+      listener
+    ]
+  );
+  const handleCalendarChange = useCallback(
+    (date) => {
+      if (!(date == null ? void 0 : date.isValid())) return;
+      setCalendarDate(date);
+      const isMonthOrYearView = viewmode === "month" || viewmode === "year";
+      if (!isMonthOrYearView) {
+        const dateObj = date.toDate();
+        if (!validateDateWithProps(dateObj)) {
+          return;
+        }
+      }
+      handleDateSelection(date, true);
+    },
+    [viewmode, validateDateWithProps, handleDateSelection]
+  );
+  const handleMonthChange = useCallback(
+    (value) => {
+      if (!(value == null ? void 0 : value.isValid())) return;
+      if (viewmode === "month") {
+        handleCalendarChange(value);
+      } else {
+        const newDate = calendarDate.clone().month(value.month()).year(value.year());
+        setCalendarDate(newDate);
+        setCalendarViewMode("day");
+      }
+    },
+    [viewmode, calendarDate, handleCalendarChange]
+  );
+  const handleYearChange = useCallback(
+    (value) => {
+      if (!(value == null ? void 0 : value.isValid())) return;
+      if (viewmode === "year") {
+        handleCalendarChange(value);
+      } else if (viewmode === "month") {
+        const newDate = calendarDate.clone().year(value.year());
+        setCalendarDate(newDate);
+        setCalendarViewMode("month");
+      } else {
+        const newDate = calendarDate.clone().year(value.year());
+        setCalendarDate(newDate);
+        setCalendarViewMode("month");
+      }
+    },
+    [viewmode, calendarDate, handleCalendarChange]
+  );
+  const handleInputChange = useCallback(
+    (event) => {
+      var _a2, _b2, _c, _d;
+      if (dataentrymode === "picker") return;
+      const value = event.target.value;
+      setInputValue(value);
+      if (!value) {
+        clearDateValue(
+          invokeOnChange,
+          updatePrevDatavalue,
+          updateBoundVariable,
+          void 0,
+          setSelectedDate,
+          setInvalidDateTimeFormat,
+          setDateNotInRange
+        );
+        return;
+      }
+      const parsedDate = datepattern === "timestamp" ? moment(parseInt(value, 10)) : moment(value, convertToMomentFormat(datepattern), true);
+      if (!parsedDate.isValid()) {
+        handleValidationError("invalidFormat", props.required);
+        if (onChange && name && (((_a2 = listener == null ? void 0 : listener.Widgets) == null ? void 0 : _a2[name]) || props.standalone) && props.formfield) {
+          onChange({}, (_b2 = listener == null ? void 0 : listener.Widgets) == null ? void 0 : _b2[name], value, inputValue);
+        }
+        return;
+      }
+      setInvalidDateTimeFormat(false);
+      const dateObj = parsedDate.toDate();
+      if (!validateDateWithProps(dateObj)) {
+        if (onChange && name && (((_c = listener == null ? void 0 : listener.Widgets) == null ? void 0 : _c[name]) || props.standalone) && props.formfield) {
+          onChange({}, (_d = listener == null ? void 0 : listener.Widgets) == null ? void 0 : _d[name], value, inputValue);
+        }
+        return;
+      }
+      handleDateSelection(parsedDate, false);
+    },
+    [
+      dataentrymode,
+      datepattern,
+      validateDateWithProps,
+      invokeOnChange,
+      updatePrevDatavalue,
+      updateBoundVariable,
+      inputValue
+    ]
+  );
+  const handleInputKeyDown = useCallback(
+    (event) => {
+      const allowedKeys = [
+        "Tab",
+        "Escape",
+        "Enter",
+        "ArrowUp",
+        "ArrowDown",
+        "ArrowLeft",
+        "ArrowRight"
+      ];
+      if (dataentrymode === "picker" && !allowedKeys.includes(event.key)) {
+        event.preventDefault();
+        return;
+      }
+      handleKeyDown == null ? void 0 : handleKeyDown(event);
+      switch (event.key) {
+        case "Enter":
+          event.preventDefault();
+          if (!inputValue) {
+            clearDateValue(
+              invokeOnChange,
+              updatePrevDatavalue,
+              updateBoundVariable,
+              void 0,
+              setSelectedDate,
+              void 0,
+              void 0
+            );
+            return;
+          }
+          const parsedDate = moment(inputValue, datepattern, true);
+          if (parsedDate.isValid()) {
+            const dateObj = parsedDate.toDate();
+            if (!validateDateWithProps(dateObj)) {
+              return;
+            }
+            handleCalendarChange(parsedDate);
+          } else {
+            handleValidationError("invalidFormat", props.required);
+          }
+          break;
+        case "Escape":
+          handleClose();
+          break;
+        case "Tab":
+          if (showPicker) handleClose();
+          break;
+      }
+    },
+    [
+      dataentrymode,
+      datepattern,
+      inputValue,
+      showPicker,
+      handleKeyDown,
+      handleCalendarChange,
+      handleClose,
+      validateDateWithProps,
+      invokeOnChange,
+      updatePrevDatavalue,
+      updateBoundVariable
+    ]
+  );
+  const handleTodayClick = useCallback(() => {
+    handleCalendarChange(moment());
+  }, [handleCalendarChange]);
+  const handleClearClick = useCallback(() => {
+    clearDateValue(
+      invokeOnChange,
+      updatePrevDatavalue,
+      updateBoundVariable,
+      setInputValue,
+      setSelectedDate,
+      void 0,
+      void 0
+    );
+    handleClose();
+  }, [invokeOnChange, updatePrevDatavalue, updateBoundVariable, handleClose]);
+  const handleIconButtonClick = useCallback(
+    (event) => {
+      if (!disabled && !readonly && event) {
+        handleOpen(event);
+      }
+    },
+    [disabled, readonly, handleOpen]
+  );
+  const handleInputClick = useCallback(
+    (event) => {
+      var _a2;
+      if (onClick && name) {
+        onClick(event, (_a2 = listener == null ? void 0 : listener.Widgets) == null ? void 0 : _a2[name]);
+      }
+      if (shouldOpenOnInput && !readonly && !disabled) {
+        handleIconButtonClick(event);
+      }
+    },
+    [shouldOpenOnInput, readonly, disabled, handleIconButtonClick]
+  );
+  return /* @__PURE__ */ jsxs(
+    Box,
+    __spreadProps(__spreadValues(__spreadValues({
+      className: `ng-pristine ng-valid app-date input-group ng-touched ${className}`,
+      ref: datepickerRef,
+      style: __spreadValues(__spreadValues({}, getWidthStyle(width)), styles),
+      title: hint,
+      hidden: props.hidden
+    }, readonly && { readOnly: true }), disabled && { disabled: true }), {
+      children: [
+        /* @__PURE__ */ jsx(
+          TextField,
+          {
+            inputRef,
+            fullWidth: true,
+            placeholder: getPlaceholderText(),
+            disabled: disabled || readonly,
+            "aria-readonly": readonly,
+            error: Boolean(validationFailureMessage || invalidDateTimeFormat || dateNotInRange),
+            helperText: validationFailureMessage || (invalidDateTimeFormat ? "Invalid date format" : dateNotInRange ? "Date not in valid range" : ""),
+            slotProps: {
+              htmlInput: {
+                "aria-label": arialabel || `Date input ${getPlaceholderText()}`,
+                tabIndex: tabindex,
+                accessKey: shortcutkey,
+                "aria-invalid": validationFailureMessage || invalidDateTimeFormat || dateNotInRange,
+                readOnly: readonly || dataentrymode === "picker",
+                required,
+                autoFocus: autofocus,
+                name,
+                className: `form-control app-textbox app-dateinput display-input`,
+                style: __spreadValues({}, getWidthStyle(width)),
+                onMouseEnter: (event) => {
+                  var _a2;
+                  return onMouseEnter && name && onMouseEnter(event, (_a2 = listener == null ? void 0 : listener.Widgets) == null ? void 0 : _a2[name]);
+                },
+                onMouseLeave: (event) => {
+                  var _a2;
+                  return onMouseLeave && name && onMouseLeave(event, (_a2 = listener == null ? void 0 : listener.Widgets) == null ? void 0 : _a2[name]);
+                }
+              }
+            },
+            InputProps: {
+              endAdornment: /* @__PURE__ */ jsx(Box, { component: "span", className: "input-group-btn", children: /* @__PURE__ */ jsx(
+                WmButton,
+                {
+                  type: "button",
+                  className: `btn btn-default btn-time`,
+                  tabindex,
+                  disabled: disabled || readonly,
+                  "aria-label": inputValue ? `Change Date ${inputValue}` : "Choose date by pressing enter",
+                  "aria-haspopup": "true",
+                  "aria-expanded": showPicker,
+                  onClick: handleIconButtonClick,
+                  children: /* @__PURE__ */ jsx(Box, { component: "i", "aria-hidden": "true", className: "app-icon wm-sl-l sl-calendar" })
+                }
+              ) })
+            },
+            value: inputValue,
+            onChange: handleInputChange,
+            onKeyDown: handleInputKeyDown,
+            onClick: handleInputClick,
+            onFocus: (event) => {
+              var _a2;
+              return onFocus && name && onFocus(event, (_a2 = listener == null ? void 0 : listener.Widgets) == null ? void 0 : _a2[name]);
+            },
+            onBlur: (event) => {
+              var _a2;
+              return onBlur && name && onBlur(event, (_a2 = listener == null ? void 0 : listener.Widgets) == null ? void 0 : _a2[name]);
+            },
+            style: getWidthStyle(width)
+          }
+        ),
+        showPicker && /* @__PURE__ */ jsx(
+          DatePickerPopover,
+          {
+            open: showPicker,
+            anchorEl,
+            onClose: handleClose,
+            adaptiveposition,
+            showbuttonbar,
+            todaybutton,
+            clearbutton,
+            todaybuttonlabel,
+            clearbuttonlabel,
+            isNavigationDisabled,
+            restProps,
+            getDateObj: (date) => getDateObj(date != null ? date : null),
+            viewmode,
+            calendarViewMode,
+            calendarDate,
+            selectedDate,
+            selectfromothermonth,
+            showweeks,
+            isDateDisabled,
+            handleYearChange,
+            handleMonthChange,
+            handleCalendarChange,
+            setCalendarViewMode,
+            setCalendarDate,
+            handleTodayClick,
+            handleClearClick,
+            selectedLocale: currentLocale
+          }
+        )
+      ]
+    })
+  );
+});
+WmDate.displayName = "WmDate";
+const WithFormController = withFormController(WmDate);
+const WmDateStandalone = withStandalone(withBaseDateTime(WithFormController));
+var date_default = withBaseWrapper(withBaseDateTime(WithFormController));
+export {
+  WmDateStandalone as WmDate,
+  date_default as default
+};