'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var vue = require('vue');
require('../../../hooks/index.cjs');
require('../../../utils/index.cjs');
var PickerTrigger = require('./PickerTrigger.cjs');
var PickerPanel = require('./PickerPanel.cjs');
var usePickerInput = require('./hooks/usePickerInput.cjs');
var PresetPanel = require('./PresetPanel.cjs');
var miscUtil = require('./utils/miscUtil.cjs');
var uiUtil = require('./utils/uiUtil.cjs');
var PanelContext = require('./PanelContext.cjs');
var dateUtil = require('./utils/dateUtil.cjs');
var useValueTexts = require('./hooks/useValueTexts.cjs');
var useTextValueMapping = require('./hooks/useTextValueMapping.cjs');
var usePresets = require('./hooks/usePresets.cjs');
var RangeContext = require('./RangeContext.cjs');
var useRangeDisabled = require('./hooks/useRangeDisabled.cjs');
var getExtraFooter = require('./utils/getExtraFooter.cjs');
var getRanges = require('./utils/getRanges.cjs');
var useRangeViewDates = require('./hooks/useRangeViewDates.cjs');
var useHoverValue = require('./hooks/useHoverValue.cjs');
var warnUtil = require('./utils/warnUtil.cjs');
var index = require('../../../hooks/use-merged-state/index.cjs');
var index$1 = require('../../../hooks/use-element-size/index.cjs');
var log = require('../../../utils/log.cjs');
var index$2 = require('../../../hooks/use-state/index.cjs');
var _class = require('../../../utils/dom/class.cjs');

function reorderValues(values, generateConfig) {
  if (values && values[0] && values[1] && generateConfig.isAfter(values[0], values[1]))
    return [values[1], values[0]];
  return values;
}
function canValueTrigger(value, index, disabled, allowEmpty) {
  if (value)
    return true;
  if (allowEmpty && allowEmpty[index])
    return true;
  if (disabled[(index + 1) % 2])
    return true;
  return false;
}
function RangerPicker() {
  return /* @__PURE__ */ vue.defineComponent({
    name: "RangerPicker",
    inheritAttrs: false,
    props: ["prefixCls", "id", "popupStyle", "dropdownClassName", "transitionName", "dropdownAlign", "getPopupContainer", "generateConfig", "locale", "placeholder", "autofocus", "disabled", "format", "picker", "showTime", "showNow", "showHour", "showMinute", "showSecond", "use12Hours", "separator", "value", "defaultValue", "defaultPickerValue", "open", "defaultOpen", "disabledDate", "disabledTime", "dateRender", "panelRender", "ranges", "allowEmpty", "allowClear", "suffixIcon", "clearIcon", "pickerRef", "inputReadOnly", "mode", "renderExtraFooter", "onChange", "onOpenChange", "onPanelChange", "onCalendarChange", "onFocus", "onBlur", "onMousedown", "onMouseup", "onMouseenter", "onMouseleave", "onClick", "onOk", "onKeydown", "components", "order", "direction", "activePickerIndex", "autocomplete", "minuteStep", "hourStep", "secondStep", "hideDisabledOptions", "disabledMinutes", "presets", "prevIcon", "nextIcon", "superPrevIcon", "superNextIcon"],
    setup(props, {
      attrs,
      expose
    }) {
      const needConfirmButton = vue.computed(() => props.picker === "date" && !!props.showTime || props.picker === "time");
      const presets = vue.computed(() => props.presets);
      const ranges = vue.computed(() => props.ranges);
      const presetList = usePresets.default(presets, ranges);
      const openRecordsRef = vue.ref({});
      const containerRef = vue.ref(null);
      const panelDivRef = vue.ref(null);
      const startInputDivRef = vue.ref(null);
      const endInputDivRef = vue.ref(null);
      const separatorRef = vue.ref(null);
      const startInputRef = vue.ref(null);
      const endInputRef = vue.ref(null);
      const arrowRef = vue.ref(null);
      if (process.env.NODE_ENV !== "production")
        warnUtil.legacyPropsWarning(props);
      const formatList = vue.computed(() => miscUtil.toArray(uiUtil.getDefaultFormat(props.format, props.picker, props.showTime, props.use12Hours)));
      const [mergedActivePickerIndex, setMergedActivePickerIndex] = index.useMergedState(0, {
        value: vue.toRef(props, "activePickerIndex")
      });
      const operationRef = vue.ref(null);
      const mergedDisabled = vue.computed(() => {
        const {
          disabled
        } = props;
        if (Array.isArray(disabled))
          return disabled;
        return [disabled || false, disabled || false];
      });
      const [mergedValue, setInnerValue] = index.useMergedState(null, {
        value: vue.toRef(props, "value"),
        defaultValue: props.defaultValue,
        postState: (values) => props.picker === "time" && !props.order ? values : reorderValues(values, props.generateConfig)
      });
      const [startViewDate, endViewDate, setViewDate] = useRangeViewDates.default({
        values: mergedValue,
        picker: vue.toRef(props, "picker"),
        defaultDates: props.defaultPickerValue,
        generateConfig: vue.toRef(props, "generateConfig")
      });
      const [selectedValue, setSelectedValue] = index.useMergedState(mergedValue.value, {
        postState: (values) => {
          let postValues = values;
          if (mergedDisabled.value[0] && mergedDisabled.value[1])
            return postValues;
          for (let i = 0; i < 2; i += 1) {
            if (mergedDisabled.value[i] && !miscUtil.getValue(postValues, i) && !miscUtil.getValue(props.allowEmpty, i))
              postValues = miscUtil.updateValues(postValues, props.generateConfig.getNow(), i);
          }
          return postValues;
        }
      });
      const [mergedModes, setInnerModes] = index.useMergedState([props.picker, props.picker], {
        value: vue.toRef(props, "mode")
      });
      vue.watch(() => props.picker, () => {
        setInnerModes([props.picker, props.picker]);
      });
      const triggerModesChange = (modes, values) => {
        var _a;
        setInnerModes(modes);
        (_a = props.onPanelChange) == null ? void 0 : _a.call(props, values, modes);
      };
      const [disabledStartDate, disabledEndDate] = useRangeDisabled.default({
        picker: vue.toRef(props, "picker"),
        selectedValue,
        locale: vue.toRef(props, "locale"),
        disabled: mergedDisabled,
        disabledDate: vue.toRef(props, "disabledDate"),
        generateConfig: vue.toRef(props, "generateConfig")
      }, openRecordsRef);
      const [mergedOpen, triggerInnerOpen] = index.useMergedState(false, {
        value: vue.toRef(props, "open"),
        defaultValue: props.defaultOpen,
        postState: (postOpen) => mergedDisabled.value[mergedActivePickerIndex.value] ? false : postOpen,
        onChange: (newOpen) => {
          var _a;
          (_a = props.onOpenChange) == null ? void 0 : _a.call(props, newOpen);
          if (!newOpen && operationRef.value && operationRef.value.onClose)
            operationRef.value.onClose();
        }
      });
      const startOpen = vue.computed(() => mergedOpen.value && mergedActivePickerIndex.value === 0);
      const endOpen = vue.computed(() => mergedOpen.value && mergedActivePickerIndex.value === 1);
      const panelLeft = vue.ref(0);
      const arrowLeft = vue.ref(0);
      const popupMinWidth = vue.ref(0);
      const {
        width: containerWidth
      } = index$1.useElementSize(containerRef);
      vue.watch([mergedOpen, containerWidth], () => {
        if (!mergedOpen.value && containerRef.value)
          popupMinWidth.value = containerWidth.value;
      });
      const {
        width: panelDivWidth
      } = index$1.useElementSize(panelDivRef);
      const {
        width: arrowWidth
      } = index$1.useElementSize(arrowRef);
      const {
        width: startInputDivWidth
      } = index$1.useElementSize(startInputDivRef);
      const {
        width: separatorWidth
      } = index$1.useElementSize(separatorRef);
      vue.watch([mergedActivePickerIndex, mergedOpen, panelDivWidth, arrowWidth, startInputDivWidth, separatorWidth, () => props.direction], () => {
        arrowLeft.value = 0;
        if (mergedActivePickerIndex.value) {
          if (startInputDivRef.value && separatorRef.value) {
            arrowLeft.value = startInputDivWidth.value + separatorWidth.value;
            if (panelDivWidth.value && arrowWidth.value && arrowLeft.value > panelDivWidth.value - arrowWidth.value - (props.direction === "rtl" || arrowRef.value.offsetLeft > arrowLeft.value ? 0 : arrowRef.value.offsetLeft))
              panelLeft.value = arrowLeft.value;
          }
        } else if (mergedActivePickerIndex.value === 0) {
          panelLeft.value = 0;
        }
      }, {
        immediate: true
      });
      const triggerRef = vue.ref();
      function triggerOpen(newOpen, index) {
        if (newOpen) {
          clearTimeout(triggerRef.value);
          openRecordsRef.value[index] = true;
          setMergedActivePickerIndex(index);
          triggerInnerOpen(newOpen);
          if (!mergedOpen.value)
            setViewDate(null, index);
        } else if (mergedActivePickerIndex.value === index) {
          triggerInnerOpen(newOpen);
          const openRecords = openRecordsRef.value;
          triggerRef.value = setTimeout(() => {
            if (openRecords === openRecordsRef.value)
              openRecordsRef.value = {};
          });
        }
      }
      function triggerOpenAndFocus(index) {
        triggerOpen(true, index);
        setTimeout(() => {
          const inputRef = [startInputRef, endInputRef][index];
          if (inputRef.value)
            inputRef.value.focus();
        }, 0);
      }
      function triggerChange(newValue, sourceIndex) {
        let values = newValue;
        let startValue = miscUtil.getValue(values, 0);
        let endValue = miscUtil.getValue(values, 1);
        const {
          generateConfig,
          locale,
          picker,
          order,
          onCalendarChange,
          allowEmpty,
          onChange,
          showTime
        } = props;
        if (startValue && endValue && generateConfig.isAfter(startValue, endValue)) {
          if (
            // WeekPicker only compare week
            picker === "week" && !dateUtil.isSameWeek(generateConfig, locale.locale, startValue, endValue) || picker === "quarter" && !dateUtil.isSameQuarter(generateConfig, startValue, endValue) || picker !== "week" && picker !== "quarter" && picker !== "time" && !(showTime ? dateUtil.isEqual(generateConfig, startValue, endValue) : dateUtil.isSameDate(generateConfig, startValue, endValue))
          ) {
            if (sourceIndex === 0) {
              values = [startValue, null];
              endValue = null;
            } else {
              startValue = null;
              values = [null, endValue];
            }
            openRecordsRef.value = {
              [sourceIndex]: true
            };
          } else if (picker !== "time" || order !== false) {
            values = reorderValues(values, generateConfig);
          }
        }
        setSelectedValue(values);
        const startStr2 = values && values[0] ? dateUtil.formatValue(values[0], {
          generateConfig,
          locale,
          format: formatList.value[0]
        }) : "";
        const endStr2 = values && values[1] ? dateUtil.formatValue(values[1], {
          generateConfig,
          locale,
          format: formatList.value[0]
        }) : "";
        if (onCalendarChange) {
          const info = {
            range: sourceIndex === 0 ? "start" : "end"
          };
          onCalendarChange(values, [startStr2, endStr2], info);
        }
        const canStartValueTrigger = canValueTrigger(startValue, 0, mergedDisabled.value, allowEmpty);
        const canEndValueTrigger = canValueTrigger(endValue, 1, mergedDisabled.value, allowEmpty);
        const canTrigger = values === null || canStartValueTrigger && canEndValueTrigger;
        if (canTrigger) {
          setInnerValue(values);
          if (onChange && (!dateUtil.isEqual(generateConfig, miscUtil.getValue(mergedValue.value, 0), startValue) || !dateUtil.isEqual(generateConfig, miscUtil.getValue(mergedValue.value, 1), endValue)))
            onChange(values, [startStr2, endStr2]);
        }
        let nextOpenIndex = null;
        if (sourceIndex === 0 && !mergedDisabled.value[1])
          nextOpenIndex = 1;
        else if (sourceIndex === 1 && !mergedDisabled.value[0])
          nextOpenIndex = 0;
        if (nextOpenIndex !== null && nextOpenIndex !== mergedActivePickerIndex.value && (!openRecordsRef.value[nextOpenIndex] || !miscUtil.getValue(values, nextOpenIndex)) && miscUtil.getValue(values, sourceIndex)) {
          triggerOpenAndFocus(nextOpenIndex);
        } else {
          triggerOpen(false, sourceIndex);
        }
      }
      const forwardKeydown = (e) => {
        if (mergedOpen && operationRef.value && operationRef.value.onKeydown) {
          return operationRef.value.onKeydown(e);
        }
        {
          log.warning(false, "Picker not correct forward Keydown operation. Please help to fire issue about this.");
          return false;
        }
      };
      const sharedTextHooksProps = {
        formatList,
        generateConfig: vue.toRef(props, "generateConfig"),
        locale: vue.toRef(props, "locale")
      };
      const [startValueTexts, firstStartValueText] = useValueTexts.default(vue.computed(() => miscUtil.getValue(selectedValue.value, 0)), sharedTextHooksProps);
      const [endValueTexts, firstEndValueText] = useValueTexts.default(vue.computed(() => miscUtil.getValue(selectedValue.value, 1)), sharedTextHooksProps);
      const onTextChange = (newText, index) => {
        const inputDate = dateUtil.parseValue(newText, {
          locale: props.locale,
          formatList: formatList.value,
          generateConfig: props.generateConfig
        });
        const disabledFunc = index === 0 ? disabledStartDate : disabledEndDate;
        if (inputDate && !disabledFunc(inputDate)) {
          setSelectedValue(miscUtil.updateValues(selectedValue.value, inputDate, index));
          setViewDate(inputDate, index);
        }
      };
      const [startText, triggerStartTextChange, resetStartText] = useTextValueMapping.default({
        valueTexts: startValueTexts,
        onTextChange: (newText) => onTextChange(newText, 0)
      });
      const [endText, triggerEndTextChange, resetEndText] = useTextValueMapping.default({
        valueTexts: endValueTexts,
        onTextChange: (newText) => onTextChange(newText, 1)
      });
      const [rangeHoverValue, setRangeHoverValue] = index$2.useState(null);
      const [hoverRangedValue, setHoverRangedValue] = index$2.useState(null);
      const [startHoverValue, onStartEnter, onStartLeave] = useHoverValue.default(startText, sharedTextHooksProps);
      const [endHoverValue, onEndEnter, onEndLeave] = useHoverValue.default(endText, sharedTextHooksProps);
      const onDateMouseenter = (date) => {
        setHoverRangedValue(miscUtil.updateValues(selectedValue.value, date, mergedActivePickerIndex.value));
        if (mergedActivePickerIndex.value === 0)
          onStartEnter(date);
        else
          onEndEnter(date);
      };
      const onDateMouseleave = () => {
        setHoverRangedValue(miscUtil.updateValues(selectedValue.value, null, mergedActivePickerIndex.value));
        if (mergedActivePickerIndex.value === 0)
          onStartLeave();
        else
          onEndLeave();
      };
      const getSharedInputHookProps = (index, resetText) => ({
        forwardKeydown,
        onBlur: (e) => {
          var _a;
          (_a = props.onBlur) == null ? void 0 : _a.call(props, e);
        },
        isClickOutside: (target) => !uiUtil.elementsContains([panelDivRef.value, startInputDivRef.value, endInputDivRef.value, containerRef.value], target),
        onFocus: (e) => {
          var _a;
          setMergedActivePickerIndex(index);
          (_a = props.onFocus) == null ? void 0 : _a.call(props, e);
        },
        triggerOpen: (newOpen) => {
          triggerOpen(newOpen, index);
        },
        onSubmit: () => {
          if (
            // When user typing disabledDate with keyboard and enter, this value will be empty
            !selectedValue.value || props.disabledDate && props.disabledDate(selectedValue.value[index])
          )
            return false;
          triggerChange(selectedValue.value, index);
          resetText();
        },
        onCancel: () => {
          triggerOpen(false, index);
          setSelectedValue(mergedValue.value);
          resetText();
        }
      });
      const [startInputProps, {
        focused: startFocused,
        typing: startTyping
      }] = usePickerInput.default({
        ...getSharedInputHookProps(0, resetStartText),
        blurToCancel: needConfirmButton,
        open: startOpen,
        value: startText,
        onKeydown: (e, preventDefault) => {
          var _a;
          (_a = props.onKeydown) == null ? void 0 : _a.call(props, e, preventDefault);
        }
      });
      const [endInputProps, {
        focused: endFocused,
        typing: endTyping
      }] = usePickerInput.default({
        ...getSharedInputHookProps(1, resetEndText),
        blurToCancel: needConfirmButton,
        open: endOpen,
        value: endText,
        onKeydown: (e, preventDefault) => {
          var _a;
          (_a = props.onKeydown) == null ? void 0 : _a.call(props, e, preventDefault);
        }
      });
      const onPickerClick = (e) => {
        var _a;
        (_a = props.onClick) == null ? void 0 : _a.call(props, e);
        if (!mergedOpen.value && !startInputRef.value.contains(e.target) && !endInputRef.value.contains(e.target)) {
          if (!mergedDisabled.value[0])
            triggerOpenAndFocus(0);
          else if (!mergedDisabled.value[1])
            triggerOpenAndFocus(1);
        }
      };
      const onPickerMousedown = (e) => {
        var _a;
        (_a = props.onMousedown) == null ? void 0 : _a.call(props, e);
        if (mergedOpen.value && (startFocused.value || endFocused.value) && !startInputRef.value.contains(e.target) && !endInputRef.value.contains(e.target))
          e.preventDefault();
      };
      const startStr = vue.computed(() => {
        var _a;
        return ((_a = mergedValue.value) == null ? void 0 : _a[0]) ? dateUtil.formatValue(mergedValue.value[0], {
          locale: props.locale,
          format: "YYYYMMDDHHmmss",
          generateConfig: props.generateConfig
        }) : "";
      });
      const endStr = vue.computed(() => {
        var _a;
        return ((_a = mergedValue.value) == null ? void 0 : _a[1]) ? dateUtil.formatValue(mergedValue.value[1], {
          locale: props.locale,
          format: "YYYYMMDDHHmmss",
          generateConfig: props.generateConfig
        }) : "";
      });
      vue.watch([mergedOpen, startValueTexts, endValueTexts], () => {
        if (!mergedOpen.value) {
          setSelectedValue(mergedValue.value);
          if (!startValueTexts.value.length || startValueTexts.value[0] === "")
            triggerStartTextChange("");
          else if (firstStartValueText.value !== startText.value)
            resetStartText();
          if (!endValueTexts.value.length || endValueTexts.value[0] === "")
            triggerEndTextChange("");
          else if (firstEndValueText.value !== endText.value)
            resetEndText();
        }
      });
      vue.watch([startStr, endStr], () => {
        setSelectedValue(mergedValue.value);
      });
      if (process.env.NODE_ENV !== "production") {
        vue.watchEffect(() => {
          const {
            value,
            disabled
          } = props;
          if (value && Array.isArray(disabled) && (miscUtil.getValue(disabled, 0) && !miscUtil.getValue(value, 0) || miscUtil.getValue(disabled, 1) && !miscUtil.getValue(value, 1))) {
            log.warning(false, "`disabled` should not set with empty `value`. You should set `allowEmpty` or `value` instead.");
          }
        });
      }
      expose({
        focus: () => {
          if (startInputRef.value)
            startInputRef.value.focus();
        },
        blur: () => {
          if (startInputRef.value)
            startInputRef.value.blur();
          if (endInputRef.value)
            endInputRef.value.blur();
        }
      });
      const panelHoverRangedValue = vue.computed(() => {
        if (mergedOpen.value && hoverRangedValue.value && hoverRangedValue.value[0] && hoverRangedValue.value[1] && props.generateConfig.isAfter(hoverRangedValue.value[1], hoverRangedValue.value[0]))
          return hoverRangedValue.value;
        else
          return null;
      });
      function renderPanel(panelPosition = false, panelProps = {}) {
        const {
          generateConfig,
          showTime,
          dateRender,
          direction,
          disabledTime,
          prefixCls,
          locale
        } = props;
        let panelShowTime = showTime;
        if (showTime && typeof showTime === "object" && showTime.defaultValue) {
          const timeDefaultValues = showTime.defaultValue;
          panelShowTime = {
            ...showTime,
            defaultValue: miscUtil.getValue(timeDefaultValues, mergedActivePickerIndex.value) || void 0
          };
        }
        let panelDateRender = null;
        if (dateRender) {
          panelDateRender = ({
            current: date,
            today
          }) => dateRender({
            current: date,
            today,
            info: {
              range: mergedActivePickerIndex.value ? "end" : "start"
            }
          });
        }
        return vue.createVNode(RangeContext.RangeContextProvider, {
          "value": {
            inRange: true,
            panelPosition,
            rangedValue: rangeHoverValue.value || selectedValue.value,
            hoverRangedValue: panelHoverRangedValue.value
          }
        }, {
          default: () => [vue.createVNode(PickerPanel.default, {
            ...props,
            ...panelProps,
            "dateRender": panelDateRender,
            "showTime": panelShowTime,
            "mode": mergedModes.value[mergedActivePickerIndex.value],
            "generateConfig": generateConfig,
            "style": void 0,
            "direction": direction,
            "disabledDate": mergedActivePickerIndex.value === 0 ? disabledStartDate : disabledEndDate,
            "disabledTime": (date) => {
              if (disabledTime)
                return disabledTime(date, mergedActivePickerIndex.value === 0 ? "start" : "end");
              return false;
            },
            "class": _class.classNames({
              [`${prefixCls}-panel-focused`]: mergedActivePickerIndex.value === 0 ? !startTyping.value : !endTyping.value
            }),
            "value": miscUtil.getValue(selectedValue.value, mergedActivePickerIndex.value),
            "locale": locale,
            "tabIndex": -1,
            "onPanelChange": (date, newMode) => {
              if (mergedActivePickerIndex.value === 0)
                onStartLeave(true);
              if (mergedActivePickerIndex.value === 1)
                onEndLeave(true);
              triggerModesChange(miscUtil.updateValues(mergedModes.value, newMode, mergedActivePickerIndex.value), miscUtil.updateValues(selectedValue.value, date, mergedActivePickerIndex.value));
              let viewDate = date;
              if (panelPosition === "right" && mergedModes.value[mergedActivePickerIndex.value] === newMode)
                viewDate = dateUtil.getClosingViewDate(viewDate, newMode, generateConfig, -1);
              setViewDate(viewDate, mergedActivePickerIndex.value);
            },
            "onOk": null,
            "onSelect": void 0,
            "onChange": void 0,
            "defaultValue": mergedActivePickerIndex.value === 0 ? miscUtil.getValue(selectedValue.value, 1) : miscUtil.getValue(selectedValue.value, 0)
          }, null)]
        });
      }
      const onContextSelect = (date, type) => {
        const values = miscUtil.updateValues(selectedValue.value, date, mergedActivePickerIndex.value);
        if (type === "submit" || type !== "key" && !needConfirmButton.value) {
          triggerChange(values, mergedActivePickerIndex.value);
          if (mergedActivePickerIndex.value === 0)
            onStartLeave();
          else
            onEndLeave();
        } else {
          setSelectedValue(values);
        }
      };
      PanelContext.useProvidePanel({
        operationRef,
        hideHeader: vue.computed(() => props.picker === "time"),
        onDateMouseenter,
        onDateMouseleave,
        hideRanges: vue.computed(() => true),
        onSelect: onContextSelect,
        open: mergedOpen
      });
      return () => {
        const {
          prefixCls = "rc-picker",
          id,
          popupStyle,
          dropdownClassName,
          transitionName,
          dropdownAlign,
          getPopupContainer,
          generateConfig,
          locale,
          placeholder,
          autofocus,
          picker = "date",
          showTime,
          separator = "~",
          disabledDate,
          panelRender,
          allowClear,
          suffixIcon,
          clearIcon,
          inputReadOnly,
          renderExtraFooter,
          onMouseenter,
          onMouseleave,
          onMouseup,
          onOk,
          components,
          direction,
          autocomplete = "off"
        } = props;
        const arrowPositionStyle = direction === "rtl" ? {
          right: `${arrowLeft.value}px`
        } : {
          left: `${arrowLeft.value}px`
        };
        function renderPanels() {
          let panels;
          const extraNode = getExtraFooter.default(prefixCls, mergedModes.value[mergedActivePickerIndex.value], renderExtraFooter);
          const rangesNode = getRanges.default({
            prefixCls,
            components,
            needConfirmButton: needConfirmButton.value,
            okDisabled: !miscUtil.getValue(selectedValue.value, mergedActivePickerIndex.value) || disabledDate && disabledDate(selectedValue.value[mergedActivePickerIndex.value]),
            locale,
            onOk: () => {
              if (miscUtil.getValue(selectedValue.value, mergedActivePickerIndex.value)) {
                triggerChange(selectedValue.value, mergedActivePickerIndex.value);
                if (onOk)
                  onOk(selectedValue.value);
              }
            }
          });
          if (picker !== "time" && !showTime) {
            const viewDate = mergedActivePickerIndex.value === 0 ? startViewDate.value : endViewDate.value;
            const nextViewDate = dateUtil.getClosingViewDate(viewDate, picker, generateConfig);
            const currentMode = mergedModes.value[mergedActivePickerIndex.value];
            const showDoublePanel = currentMode === picker;
            const leftPanel = renderPanel(showDoublePanel ? "left" : false, {
              pickerValue: viewDate,
              onPickerValueChange: (newViewDate) => {
                setViewDate(newViewDate, mergedActivePickerIndex.value);
              }
            });
            const rightPanel = renderPanel("right", {
              pickerValue: nextViewDate,
              onPickerValueChange: (newViewDate) => {
                setViewDate(dateUtil.getClosingViewDate(newViewDate, picker, generateConfig, -1), mergedActivePickerIndex.value);
              }
            });
            if (direction === "rtl") {
              panels = vue.createVNode(vue.Fragment, null, [rightPanel, showDoublePanel && leftPanel]);
            } else {
              panels = vue.createVNode(vue.Fragment, null, [leftPanel, showDoublePanel && rightPanel]);
            }
          } else {
            panels = renderPanel();
          }
          let mergedNodes = vue.createVNode("div", {
            "class": `${prefixCls}-panel-layout`
          }, [vue.createVNode(PresetPanel.default, {
            "prefixCls": prefixCls,
            "presets": presetList.value,
            "onClick": (nextValue) => {
              triggerChange(nextValue, null);
              triggerOpen(false, mergedActivePickerIndex.value);
            },
            "onHover": (hoverValue) => {
              setRangeHoverValue(hoverValue);
            }
          }, null), vue.createVNode("div", null, [vue.createVNode("div", {
            "class": `${prefixCls}-panels`
          }, [panels]), (extraNode || rangesNode) && vue.createVNode("div", {
            "class": `${prefixCls}-footer`
          }, [extraNode, rangesNode])])]);
          if (panelRender)
            mergedNodes = panelRender(mergedNodes);
          return vue.createVNode("div", {
            "class": `${prefixCls}-panel-container`,
            "style": {
              marginLeft: `${panelLeft.value}px`
            },
            "ref": panelDivRef,
            "onMousedown": (e) => {
              e.preventDefault();
            }
          }, [mergedNodes]);
        }
        const rangePanel = vue.createVNode("div", {
          "class": _class.classNames(`${prefixCls}-range-wrapper`, `${prefixCls}-${picker}-range-wrapper`),
          "style": {
            minWidth: `${popupMinWidth.value}px`
          }
        }, [vue.createVNode("div", {
          "ref": arrowRef,
          "class": `${prefixCls}-range-arrow`,
          "style": arrowPositionStyle
        }, null), renderPanels()]);
        let suffixNode;
        if (suffixIcon)
          suffixNode = vue.createVNode("span", {
            "class": `${prefixCls}-suffix`
          }, [suffixIcon]);
        let clearNode;
        if (allowClear && (miscUtil.getValue(mergedValue.value, 0) && !mergedDisabled.value[0] || miscUtil.getValue(mergedValue.value, 1) && !mergedDisabled.value[1])) {
          clearNode = vue.createVNode("span", {
            "onMousedown": (e) => {
              e.preventDefault();
              e.stopPropagation();
            },
            "onMouseup": (e) => {
              e.preventDefault();
              e.stopPropagation();
              let values = mergedValue.value;
              if (!mergedDisabled.value[0])
                values = miscUtil.updateValues(values, null, 0);
              if (!mergedDisabled.value[1])
                values = miscUtil.updateValues(values, null, 1);
              triggerChange(values, null);
              triggerOpen(false, mergedActivePickerIndex.value);
            },
            "class": `${prefixCls}-clear`
          }, [clearIcon || vue.createVNode("span", {
            "class": `${prefixCls}-clear-btn`
          }, null)]);
        }
        const inputSharedProps = {
          size: uiUtil.getInputSize(picker, formatList.value[0], generateConfig)
        };
        let activeBarLeft = 0;
        let activeBarWidth = 0;
        if (startInputDivRef.value && endInputDivRef.value && separatorRef.value) {
          if (mergedActivePickerIndex.value === 0) {
            activeBarWidth = startInputDivRef.value.offsetWidth;
          } else {
            activeBarLeft = arrowLeft.value;
            activeBarWidth = endInputDivRef.value.offsetWidth;
          }
        }
        const activeBarPositionStyle = direction === "rtl" ? {
          right: `${activeBarLeft}px`
        } : {
          left: `${activeBarLeft}px`
        };
        return vue.createVNode("div", {
          "ref": containerRef,
          "class": _class.classNames(prefixCls, `${prefixCls}-range`, attrs.class, {
            [`${prefixCls}-disabled`]: mergedDisabled.value[0] && mergedDisabled.value[1],
            [`${prefixCls}-focused`]: mergedActivePickerIndex.value === 0 ? startFocused.value : endFocused.value,
            [`${prefixCls}-rtl`]: direction === "rtl"
          }),
          "style": attrs.style,
          "onClick": onPickerClick,
          "onMouseenter": onMouseenter,
          "onMouseleave": onMouseleave,
          "onMousedown": onPickerMousedown,
          "onMouseup": onMouseup,
          ...miscUtil.default(props)
        }, [vue.createVNode("div", {
          "class": _class.classNames(`${prefixCls}-input`, {
            [`${prefixCls}-input-active`]: mergedActivePickerIndex.value === 0,
            [`${prefixCls}-input-placeholder`]: !!startHoverValue.value
          }),
          "ref": startInputDivRef
        }, [vue.createVNode("input", {
          "id": id,
          "disabled": mergedDisabled.value[0],
          "readonly": inputReadOnly || typeof formatList.value[0] === "function" || !startTyping.value,
          "value": startHoverValue.value || startText.value,
          "onInput": (e) => {
            triggerStartTextChange(e.target.value);
          },
          "autofocus": autofocus,
          "placeholder": miscUtil.getValue(placeholder, 0) || "",
          "ref": startInputRef,
          ...startInputProps.value,
          ...inputSharedProps,
          "autocomplete": autocomplete
        }, null)]), vue.createVNode("div", {
          "class": `${prefixCls}-range-separator`,
          "ref": separatorRef
        }, [separator]), vue.createVNode("div", {
          "class": _class.classNames(`${prefixCls}-input`, {
            [`${prefixCls}-input-active`]: mergedActivePickerIndex.value === 1,
            [`${prefixCls}-input-placeholder`]: !!endHoverValue.value
          }),
          "ref": endInputDivRef
        }, [vue.createVNode("input", {
          "disabled": mergedDisabled.value[1],
          "readonly": inputReadOnly || typeof formatList.value[0] === "function" || !endTyping.value,
          "value": endHoverValue.value || endText.value,
          "onInput": (e) => {
            triggerEndTextChange(e.target.value);
          },
          "placeholder": miscUtil.getValue(placeholder, 1) || "",
          "ref": endInputRef,
          ...endInputProps.value,
          ...inputSharedProps,
          "autocomplete": autocomplete
        }, null)]), vue.createVNode("div", {
          "class": `${prefixCls}-active-bar`,
          "style": {
            ...activeBarPositionStyle,
            width: `${activeBarWidth}px`,
            position: "absolute"
          }
        }, null), suffixNode, clearNode, vue.createVNode(PickerTrigger.default, {
          "visible": mergedOpen.value,
          "popupStyle": popupStyle,
          "prefixCls": prefixCls,
          "dropdownClassName": dropdownClassName,
          "dropdownAlign": dropdownAlign,
          "getPopupContainer": getPopupContainer,
          "transitionName": transitionName,
          "range": true,
          "direction": direction
        }, {
          default: () => [vue.createVNode("div", {
            "style": {
              pointerEvents: "none",
              position: "absolute",
              top: 0,
              bottom: 0,
              left: 0,
              right: 0
            }
          }, null)],
          popupElement: () => rangePanel
        })]);
      };
    }
  });
}
const InterRangerPicker = RangerPicker();

exports.default = InterRangerPicker;
//# sourceMappingURL=RangePicker.cjs.map
