@cloudtower/eagle 0.0.0-testid-rc-0 → 0.0.0-theme-rc-1

package/dist/esm/coreX/DateRangePicker/common.js

@@ -0,0 +1,278 @@
+import { cx } from '@linaria/core';
+import { Typo } from '../../core/Typo/index.js';
+import dayjs from 'dayjs';
+
+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));
+const BASIC_RELATIVE_TIME_CONFIG = [
+  {
+    unit: "m",
+    value: 5
+  },
+  {
+    unit: "m",
+    value: 15
+  },
+  {
+    unit: "m",
+    value: 30
+  },
+  {
+    unit: "h",
+    value: 1
+  },
+  {
+    unit: "h",
+    value: 3
+  },
+  {
+    unit: "h",
+    value: 6
+  },
+  {
+    unit: "h",
+    value: 12
+  },
+  {
+    unit: "d",
+    value: 1
+  },
+  {
+    unit: "d",
+    value: 2
+  },
+  {
+    unit: "d",
+    value: 7
+  },
+  {
+    unit: "d",
+    value: 15
+  },
+  {
+    unit: "d",
+    value: 30
+  }
+];
+function getTime(year, month, date) {
+  return dayjs(`${year}-${month}-${date}`, "YYYY-M-D");
+}
+function trimTime(time) {
+  return dayjs(time.format("YYYY-MM-DD"), "YYYY-MM-DD");
+}
+function isSameDate(first, second) {
+  return trimTime(first).isSame(trimTime(second));
+}
+function getClassNameForDateBlock(range, date, mapOfHighlightDay, disabled) {
+  const className = ["date", Typo.Label.l1_regular];
+  const today = dayjs(dayjs().format("YYYY-MM-DD"), "YYY-MM-DD");
+  if (today.diff(date, "day") === 0) {
+    className.push("today");
+  }
+  if (range[0] && isSameDate(range[0], date) || range[1] && isSameDate(range[1], date)) {
+    className.push("checked");
+  }
+  if (disabled) {
+    className.push("disabled");
+  }
+  if (mapOfHighlightDay.has(date.format("YYYY-MM-DD"))) {
+    className.push("highlight");
+  }
+  return cx(...className);
+}
+function getDiffMonthAndDate(first, second) {
+  const diffDayList = [];
+  let max = first;
+  let min = second;
+  if (first.valueOf() > second.valueOf()) {
+    max = first;
+    min = second;
+  } else if (second.valueOf() > first.valueOf()) {
+    max = second;
+    min = first;
+  }
+  const diffDayCount = max.diff(min, "day");
+  if (!diffDayCount) {
+    return [];
+  }
+  let time = min;
+  diffDayList.push(time.format("YYYY-MM-DD"));
+  for (let day = 0; day < diffDayCount; day++) {
+    time = time.add(1, "day");
+    diffDayList.push(time.format("YYYY-MM-DD"));
+  }
+  return diffDayList;
+}
+function time2stringByUnit(time, type) {
+  const _time = parseInt(time);
+  if (Number.isInteger(_time)) {
+    switch (type) {
+      case "h": {
+        if (_time > 23) {
+          return "23";
+        } else if (/^0/.test(time)) {
+          return time;
+        } else {
+          return _time.toString();
+        }
+      }
+      case "s":
+      case "m": {
+        if (_time > 59) {
+          return "59";
+        } else if (/^0/.test(time)) {
+          return time;
+        } else {
+          return _time.toString();
+        }
+      }
+    }
+  }
+  return "";
+}
+function time2string(time) {
+  const _time = time.toString();
+  if (_time.length === 0) {
+    return "00";
+  } else if (_time.length === 1) {
+    return `0${_time}`;
+  } else {
+    return _time;
+  }
+}
+function normalizeRelativeTime(date, defaultType = "past") {
+  if (date.type) {
+    return date;
+  }
+  return __spreadProps(__spreadValues({}, date), {
+    type: defaultType
+  });
+}
+function getRelativeTimeRange(date, defaultType = "past", nowDate = dayjs()) {
+  const normalizedDate = normalizeRelativeTime(date, defaultType);
+  const rangeEnd = normalizedDate.type === "future" ? nowDate.add(normalizedDate.value, normalizedDate.unit) : nowDate.subtract(normalizedDate.value, normalizedDate.unit);
+  return [nowDate, rangeEnd];
+}
+function getEffectiveAbsoluteTimeBounds(type = "past", minDate, maxDate, nowDate = dayjs()) {
+  if (type !== "future") {
+    return {
+      minDate,
+      maxDate
+    };
+  }
+  let effectiveMinDate = nowDate.startOf("day");
+  let effectiveMaxDate = nowDate.add(1, "year");
+  if (minDate) {
+    const parsedMinDate = dayjs(minDate);
+    if (parsedMinDate.isValid() && parsedMinDate.isAfter(effectiveMinDate)) {
+      effectiveMinDate = parsedMinDate;
+    }
+  }
+  if (maxDate) {
+    const parsedMaxDate = dayjs(maxDate);
+    if (parsedMaxDate.isValid() && parsedMaxDate.isBefore(effectiveMaxDate)) {
+      effectiveMaxDate = parsedMaxDate;
+    }
+  }
+  return {
+    minDate: effectiveMinDate,
+    maxDate: effectiveMaxDate
+  };
+}
+function isAbsoluteTimeRangeWithinBounds(range, minDate, maxDate) {
+  const [start, end] = range;
+  const min = minDate ? dayjs(minDate) : void 0;
+  const max = maxDate ? dayjs(maxDate) : void 0;
+  if (!(start == null ? void 0 : start.isValid()) || !(end == null ? void 0 : end.isValid()) || start.isAfter(end) || min && !min.isValid() || max && !max.isValid() || min && max && min.isAfter(max)) {
+    return false;
+  }
+  return (!min || !start.isBefore(min)) && (!max || !end.isAfter(max));
+}
+function hasAbsoluteTimeRangeIntersection(range, minDate, maxDate) {
+  const [start, end] = range;
+  const min = minDate ? dayjs(minDate) : void 0;
+  const max = maxDate ? dayjs(maxDate) : void 0;
+  if (!(start == null ? void 0 : start.isValid()) || !(end == null ? void 0 : end.isValid()) || start.isAfter(end) || min && !min.isValid() || max && !max.isValid() || min && max && min.isAfter(max)) {
+    return false;
+  }
+  return (!min || !end.isBefore(min)) && (!max || !start.isAfter(max));
+}
+function clampAbsoluteTimeRangeToBounds(range, minDate, maxDate) {
+  if (!hasAbsoluteTimeRangeIntersection(range, minDate, maxDate)) {
+    return void 0;
+  }
+  const [start, end] = range;
+  const min = minDate ? dayjs(minDate) : void 0;
+  const max = maxDate ? dayjs(maxDate) : void 0;
+  const clampedRange = [
+    min && start.isBefore(min) ? min : start,
+    max && end.isAfter(max) ? max : end
+  ];
+  return isAbsoluteTimeRangeWithinBounds(clampedRange, minDate, maxDate) ? clampedRange : void 0;
+}
+function getDateText(date, t, defaultType = "past") {
+  const normalizedDate = normalizeRelativeTime(date, defaultType);
+  const count = normalizedDate.value;
+  const dateString = {
+    d: t("common.day_count", { count }),
+    h: t("common.hour_count", { count }),
+    m: t("common.minute_count", { count }),
+    M: t("common.month_measure_count", { count }),
+    y: t("common.year_count", { count })
+  }[normalizedDate.unit];
+  return `${t(
+    normalizedDate.type === "future" ? "components.future" : "components.past"
+  )} ${dateString}`;
+}
+function checkDateNotInRange(date, minDate, maxDate) {
+  if (!minDate && !maxDate) {
+    return true;
+  }
+  if (minDate) {
+    const _minDate = dayjs(minDate);
+    if (!_minDate.isValid()) {
+      return true;
+    }
+    if (isSameDate(_minDate, date)) {
+      return true;
+    }
+    if (_minDate.isAfter(date)) {
+      return false;
+    }
+  }
+  if (maxDate) {
+    const _maxDate = dayjs(maxDate);
+    if (!_maxDate.isValid()) {
+      return true;
+    }
+    if (isSameDate(_maxDate, date)) {
+      return true;
+    }
+    if (_maxDate.isBefore(date)) {
+      return false;
+    }
+  }
+  return true;
+}
+function copyDay(day) {
+  return day.clone().set("millisecond", 0);
+}
+
+export { BASIC_RELATIVE_TIME_CONFIG, checkDateNotInRange, clampAbsoluteTimeRangeToBounds, copyDay, getClassNameForDateBlock, getDateText, getDiffMonthAndDate, getEffectiveAbsoluteTimeBounds, getRelativeTimeRange, getTime, hasAbsoluteTimeRangeIntersection, isAbsoluteTimeRangeWithinBounds, isSameDate, normalizeRelativeTime, time2string, time2stringByUnit, trimTime };

package/dist/esm/coreX/DateRangePicker/index.js

@@ -0,0 +1,402 @@
+import { CalendarClockDateTime16SecondaryIcon, CalendarClockDateTime16GradientBlueIcon, CalendarTimeRecord16Icon } from '@cloudtower/icons-react';
+import { cx } from '@linaria/core';
+import Icon from '../../core/Icon/index.js';
+import Input from '../../core/Input/index.js';
+import Tooltip from '../../core/Tooltip/index.js';
+import { Typo } from '../../core/Typo/index.js';
+import AbsoluteDate from './AbsoluteDate.js';
+import { DateRangePickerStyle, ResetPopoverStyle } from './DateRangePicker.style.js';
+import RelativeTime from './RelativeTime.js';
+import TabMenu from '../TabMenu/index.js';
+import useParrotTranslation from '../../hooks/useParrotTranslation.js';
+import { Popover } from 'antd';
+import dayjs from 'dayjs';
+import React__default, { useState, useEffect, useRef } from 'react';
+import { normalizeRelativeTime, getEffectiveAbsoluteTimeBounds, getRelativeTimeRange, isAbsoluteTimeRangeWithinBounds, getDateText, clampAbsoluteTimeRangeToBounds, hasAbsoluteTimeRangeIntersection } from './common.js';
+
+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));
+const TimeRange = (props) => {
+  const {
+    visible,
+    panelType,
+    direction,
+    relativeTime,
+    range,
+    mode = ["relative", "absolute"],
+    minDate,
+    maxDate,
+    maxRange,
+    onTypeChange,
+    onRelativeTimeChange,
+    onAbsoluteTimeOk,
+    onAbsoluteTimeChange,
+    relativeTimeSelectOptions
+  } = props;
+  const { t } = useParrotTranslation();
+  const absoluteDateRef = useRef(null);
+  useEffect(() => {
+    var _a, _b;
+    if (!visible) {
+      (_b = (_a = absoluteDateRef.current) == null ? void 0 : _a.reset) == null ? void 0 : _b.call(_a);
+    }
+  }, [visible]);
+  if (mode === "relative") {
+    return /* @__PURE__ */ React__default.createElement("div", { className: "relative-time-container" }, /* @__PURE__ */ React__default.createElement(
+      RelativeTime,
+      {
+        value: relativeTime,
+        type: direction,
+        onChange: (time) => onRelativeTimeChange == null ? void 0 : onRelativeTimeChange(time),
+        config: relativeTimeSelectOptions
+      }
+    ));
+  } else if (mode === "absolute") {
+    return /* @__PURE__ */ React__default.createElement("div", { className: "absolute-time-container" }, /* @__PURE__ */ React__default.createElement(
+      AbsoluteDate,
+      {
+        ref: absoluteDateRef,
+        range: range || [null, null],
+        minDate,
+        maxDate,
+        maxRange,
+        onChange: (range2) => onAbsoluteTimeChange == null ? void 0 : onAbsoluteTimeChange(range2),
+        onOk: (range2) => onAbsoluteTimeOk == null ? void 0 : onAbsoluteTimeOk(range2)
+      }
+    ));
+  } else {
+    const tabs = [
+      {
+        key: "relative",
+        title: t("components.relative_time"),
+        children: /* @__PURE__ */ React__default.createElement("div", { className: "relative-time-container" }, /* @__PURE__ */ React__default.createElement(
+          RelativeTime,
+          {
+            value: relativeTime,
+            type: direction,
+            onChange: (time) => onRelativeTimeChange == null ? void 0 : onRelativeTimeChange(time),
+            config: relativeTimeSelectOptions
+          }
+        ))
+      },
+      {
+        key: "absolute",
+        title: t("components.absolute_time"),
+        children: /* @__PURE__ */ React__default.createElement("div", { className: "absolute-time-container" }, /* @__PURE__ */ React__default.createElement(
+          AbsoluteDate,
+          {
+            ref: absoluteDateRef,
+            range: range || [null, null],
+            minDate,
+            maxDate,
+            maxRange,
+            onChange: (range2) => onAbsoluteTimeChange == null ? void 0 : onAbsoluteTimeChange(range2),
+            onOk: (range2) => onAbsoluteTimeOk == null ? void 0 : onAbsoluteTimeOk(range2)
+          }
+        ))
+      }
+    ].filter((item) => mode.includes(item.key));
+    return /* @__PURE__ */ React__default.createElement(
+      TabMenu,
+      {
+        selectedKey: panelType,
+        tabs,
+        onChange: onTypeChange,
+        size: "small"
+      }
+    );
+  }
+};
+const TimePickerHistory = (props) => {
+  const { history, type, minDate, maxDate, onSelect } = props;
+  const { t } = useParrotTranslation();
+  function contentRender() {
+    const filteredHistory = history.filter((item) => {
+      if (Array.isArray(item.value)) {
+        if (type !== "future") {
+          return true;
+        }
+        if (item.value.length !== 2 || !item.value[0] || !item.value[1]) {
+          return false;
+        }
+        return hasAbsoluteTimeRangeIntersection(
+          [dayjs(item.value[0]), dayjs(item.value[1])],
+          minDate,
+          maxDate
+        );
+      }
+      return normalizeRelativeTime(item.value, "past").type === type;
+    }).sort((a, b) => b.timestamp - a.timestamp);
+    if (!filteredHistory.length) {
+      return /* @__PURE__ */ React__default.createElement(React__default.Fragment, null, t("components.empty_search_history"));
+    }
+    return filteredHistory.map((item, index) => {
+      const normalizedRelativeTime = Array.isArray(item.value) ? void 0 : normalizeRelativeTime(item.value, "past");
+      const text = Array.isArray(item.value) ? `${dayjs(item.value[0]).format("YYYY-MM-DD hh:mm:ss")} - ${dayjs(
+        item.value[1]
+      ).format("YYYY-MM-DD hh:mm:ss")}` : getDateText(normalizedRelativeTime, t);
+      return /* @__PURE__ */ React__default.createElement(
+        "li",
+        {
+          key: index,
+          className: Typo.Label.l2_regular,
+          onClick: () => {
+            if (Array.isArray(item.value)) {
+              onSelect([
+                dayjs(item.value[0]),
+                dayjs(item.value[1])
+              ]);
+              return;
+            }
+            onSelect(normalizedRelativeTime);
+          }
+        },
+        text
+      );
+    });
+  }
+  return /* @__PURE__ */ React__default.createElement(DateRangePickerStyle.History, null, /* @__PURE__ */ React__default.createElement("header", { className: Typo.Heading.h2_regular_title }, t("components.date_range_picker_history_title")), /* @__PURE__ */ React__default.createElement("ul", null, contentRender()));
+};
+const DateRangePicker = (props) => {
+  var _a;
+  const {
+    size = "medium",
+    value,
+    type: relativeTimeType = "past",
+    history,
+    mode = ["relative", "absolute"],
+    minDate,
+    maxDate,
+    maxRange,
+    onChange,
+    relativeTimeSelectOptions
+  } = props;
+  const { t } = useParrotTranslation();
+  const [datePickerVisible, setDatePickerVisible] = useState(false);
+  const [panelType, setPanelType] = useState("relative");
+  const [range, setRange] = useState(
+    Array.isArray(value) ? value : void 0
+  );
+  const relativeTime = value && !Array.isArray(value) ? normalizeRelativeTime(value, relativeTimeType) : void 0;
+  const { minDate: effectiveMinDate, maxDate: effectiveMaxDate } = getEffectiveAbsoluteTimeBounds(relativeTimeType, minDate, maxDate);
+  const isAbsoluteValue = value && Array.isArray(value);
+  function handleChange(type, time) {
+    var _a2, _b;
+    const rangeHistory = [
+      ...(_a2 = history == null ? void 0 : history.dateRangeHistories[history.scope]) != null ? _a2 : []
+    ];
+    if (type === "absolute" && Array.isArray(time)) {
+      if (relativeTimeType === "future" && !isAbsoluteTimeRangeWithinBounds(
+        time,
+        effectiveMinDate,
+        effectiveMaxDate
+      )) {
+        return;
+      }
+      const value2 = time.map((item) => (item == null ? void 0 : item.format()) || "");
+      rangeHistory.push({
+        type,
+        value: value2,
+        timestamp: Date.now()
+      });
+      onChange == null ? void 0 : onChange(type, time, time);
+    } else if (type === "relative" && !Array.isArray(time)) {
+      const normalizedRelativeTime = normalizeRelativeTime(
+        time,
+        relativeTimeType
+      );
+      rangeHistory.push({
+        type,
+        value: normalizedRelativeTime,
+        timestamp: Date.now()
+      });
+      onChange == null ? void 0 : onChange(
+        type,
+        normalizedRelativeTime,
+        getRelativeTimeRange(normalizedRelativeTime)
+      );
+    }
+    history == null ? void 0 : history.setDateRangeHistory(__spreadProps(__spreadValues({}, (_b = history == null ? void 0 : history.dateRangeHistories) != null ? _b : {}), {
+      [history.scope]: rangeHistory
+    }));
+    setDatePickerVisible(false);
+  }
+  useEffect(() => {
+    if (relativeTime) {
+      setPanelType("relative");
+      onChange == null ? void 0 : onChange("relative", relativeTime, getRelativeTimeRange(relativeTime));
+    } else if (Array.isArray(value)) {
+      setRange(value);
+      setPanelType("absolute");
+      onChange == null ? void 0 : onChange("absolute", value, value);
+    }
+  }, [relativeTimeType, value]);
+  function displayRangeRender() {
+    var _a2, _b;
+    if (relativeTime) {
+      return /* @__PURE__ */ React__default.createElement(React__default.Fragment, null, getDateText(relativeTime, t));
+    } else if (isAbsoluteValue) {
+      return /* @__PURE__ */ React__default.createElement(React__default.Fragment, null, /* @__PURE__ */ React__default.createElement(
+        Input,
+        {
+          readOnly: true,
+          value: (_a2 = value[0]) == null ? void 0 : _a2.format("YYYY-MM-DD HH:mm:ss"),
+          placeholder: "YYYY-MM-DD HH:mm:ss"
+        }
+      ), /* @__PURE__ */ React__default.createElement("span", { className: "concat-symbol-block" }, "-"), /* @__PURE__ */ React__default.createElement(
+        Input,
+        {
+          readOnly: true,
+          value: (_b = value[1]) == null ? void 0 : _b.format("YYYY-MM-DD HH:mm:ss"),
+          placeholder: "YYYY-MM-DD HH:mm:ss"
+        }
+      ));
+    }
+  }
+  function handleSelectHistory(value2) {
+    if (Array.isArray(value2)) {
+      let selectedRange = [...value2];
+      if (relativeTimeType === "future") {
+        selectedRange = clampAbsoluteTimeRangeToBounds(
+          value2,
+          effectiveMinDate,
+          effectiveMaxDate
+        );
+      } else {
+        const [start, end] = selectedRange;
+        if (minDate && start) {
+          const parsedMinDate = dayjs(minDate);
+          selectedRange[0] = start.isBefore(parsedMinDate) ? parsedMinDate : start;
+        }
+        if (maxDate && end) {
+          const parsedMaxDate = dayjs(maxDate);
+          selectedRange[1] = end.isAfter(parsedMaxDate) ? parsedMaxDate : end;
+        }
+      }
+      if (!selectedRange) {
+        return;
+      }
+      const [selectedStart, selectedEnd] = selectedRange;
+      if (!(selectedStart == null ? void 0 : selectedStart.isValid()) || !(selectedEnd == null ? void 0 : selectedEnd.isValid()) || selectedStart.isAfter(selectedEnd)) {
+        return;
+      }
+      handleChange("absolute", selectedRange);
+      return;
+    }
+    handleChange("relative", normalizeRelativeTime(value2, "past"));
+  }
+  return /* @__PURE__ */ React__default.createElement(
+    DateRangePickerStyle.Wrapper,
+    {
+      className: cx(
+        "date-range-picker",
+        datePickerVisible && "active",
+        size === "large" && "large",
+        size === "medium" && "medium"
+      )
+    },
+    /* @__PURE__ */ React__default.createElement(
+      Icon,
+      {
+        className: "default-calendar-icon",
+        iconWidth: 16,
+        iconHeight: 16,
+        src: CalendarClockDateTime16SecondaryIcon
+      }
+    ),
+    /* @__PURE__ */ React__default.createElement(
+      Icon,
+      {
+        className: "hover-calendar-icon",
+        iconWidth: 16,
+        iconHeight: 16,
+        src: CalendarClockDateTime16GradientBlueIcon
+      }
+    ),
+    /* @__PURE__ */ React__default.createElement(
+      Popover,
+      {
+        overlayClassName: cx(DateRangePickerStyle.Popover, ResetPopoverStyle),
+        visible: datePickerVisible,
+        content: /* @__PURE__ */ React__default.createElement(
+          TimeRange,
+          {
+            visible: datePickerVisible,
+            panelType,
+            direction: relativeTimeType,
+            range,
+            relativeTime,
+            mode,
+            minDate: effectiveMinDate,
+            maxDate: effectiveMaxDate,
+            maxRange,
+            onTypeChange: setPanelType,
+            onRelativeTimeChange: (time) => {
+              handleChange("relative", time);
+            },
+            onAbsoluteTimeChange: setRange,
+            onAbsoluteTimeOk: (range2) => {
+              handleChange("absolute", range2);
+            },
+            relativeTimeSelectOptions
+          }
+        ),
+        placement: "bottomLeft",
+        trigger: ["click"],
+        onVisibleChange: (visible) => {
+          if (!visible && (Array.isArray(value) || !value)) {
+            setRange(value);
+          }
+          setDatePickerVisible(visible);
+        }
+      },
+      /* @__PURE__ */ React__default.createElement("div", { className: "date-input-content" }, displayRangeRender())
+    ),
+    history ? /* @__PURE__ */ React__default.createElement(
+      Popover,
+      {
+        placement: "bottomRight",
+        trigger: ["click"],
+        content: /* @__PURE__ */ React__default.createElement(
+          TimePickerHistory,
+          {
+            history: (_a = history.dateRangeHistories[history.scope]) != null ? _a : [],
+            type: relativeTimeType,
+            minDate: effectiveMinDate,
+            maxDate: effectiveMaxDate,
+            onSelect: handleSelectHistory
+          }
+        ),
+        overlayClassName: ResetPopoverStyle
+      },
+      /* @__PURE__ */ React__default.createElement(
+        Tooltip,
+        {
+          trigger: "hover",
+          overlay: t("components.date_range_picker_history_title")
+        },
+        /* @__PURE__ */ React__default.createElement(Icon, { className: "past-time-icon", src: CalendarTimeRecord16Icon })
+      )
+    ) : null
+  );
+};
+var DateRangePicker$1 = DateRangePicker;
+
+export { AbsoluteDate, RelativeTime, DateRangePicker$1 as default };

package/dist/esm/coreX/DateRangePicker/utils.js

@@ -0,0 +1,3 @@
+const getFirstDateOfMonth = (date, weekStartOnMonday = true) => (date.set("date", 1).day() - Number(weekStartOnMonday) + 7) % 7;
+
+export { getFirstDateOfMonth };