import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
import _createClass from "@babel/runtime/helpers/esm/createClass";
import _assertThisInitialized from "@babel/runtime/helpers/esm/assertThisInitialized";
import _inherits from "@babel/runtime/helpers/esm/inherits";
import _createSuper from "@babel/runtime/helpers/esm/createSuper";
import _extends from "@babel/runtime/helpers/esm/extends";
import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
import _typeof from "@babel/runtime/helpers/esm/typeof";
import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
import classNames from 'classnames';
import useMergedState from "rc-util/es/hooks/useMergedState";
import raf from "rc-util/es/raf";
import warning from "rc-util/es/warning";
import pickAttrs from "rc-util/es/pickAttrs";
import * as React from 'react';
import { useEffect, useRef, useState } from 'react';
import { useCellRender } from "./hooks/useCellRender";
import useHoverValue from "./hooks/useHoverValue";
import usePickerInput from "./hooks/usePickerInput";
import usePresets from "./hooks/usePresets";
import useRangeDisabled from "./hooks/useRangeDisabled";
import useRangeOpen from "./hooks/useRangeOpen";
import useRangeViewDates from "./hooks/useRangeViewDates";
import useTextValueMapping from "./hooks/useTextValueMapping";
import useValueTexts from "./hooks/useValueTexts";
import PanelContext from "./PanelContext";
import PickerPanel from "./PickerPanel";
import PickerTrigger from "./PickerTrigger";
import PresetPanel from "./PresetPanel";
import RangeContext from "./RangeContext";
import { formatValue, getClosingViewDate, isEqual, isSameDate, isSameQuarter, isSameWeek, parseValue } from "./utils/dateUtil";
import getExtraFooter from "./utils/getExtraFooter";
import getRanges from "./utils/getRanges";
import { getValue, toArray, updateValues } from "./utils/miscUtil";
import { elementsContains, getDefaultFormat, getInputSize } from "./utils/uiUtil";
import { legacyPropsWarning } from "./utils/warnUtil";
import { getClearIcon } from "./utils/getClearIcon";
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;
}

// TMP type to fit for ts 3.9.2

function InnerRangePicker(props) {
  var _classNames2, _classNames3, _classNames4;
  var _ref = props,
    _ref$prefixCls = _ref.prefixCls,
    prefixCls = _ref$prefixCls === void 0 ? 'rc-picker' : _ref$prefixCls,
    id = _ref.id,
    style = _ref.style,
    className = _ref.className,
    popupStyle = _ref.popupStyle,
    dropdownClassName = _ref.dropdownClassName,
    transitionName = _ref.transitionName,
    dropdownAlign = _ref.dropdownAlign,
    getPopupContainer = _ref.getPopupContainer,
    generateConfig = _ref.generateConfig,
    locale = _ref.locale,
    placeholder = _ref.placeholder,
    autoFocus = _ref.autoFocus,
    disabled = _ref.disabled,
    format = _ref.format,
    _ref$picker = _ref.picker,
    picker = _ref$picker === void 0 ? 'date' : _ref$picker,
    showTime = _ref.showTime,
    use12Hours = _ref.use12Hours,
    _ref$separator = _ref.separator,
    separator = _ref$separator === void 0 ? '~' : _ref$separator,
    value = _ref.value,
    defaultValue = _ref.defaultValue,
    defaultPickerValue = _ref.defaultPickerValue,
    open = _ref.open,
    defaultOpen = _ref.defaultOpen,
    disabledDate = _ref.disabledDate,
    _disabledTime = _ref.disabledTime,
    dateRender = _ref.dateRender,
    monthCellRender = _ref.monthCellRender,
    cellRender = _ref.cellRender,
    panelRender = _ref.panelRender,
    presets = _ref.presets,
    ranges = _ref.ranges,
    allowEmpty = _ref.allowEmpty,
    allowClear = _ref.allowClear,
    suffixIcon = _ref.suffixIcon,
    clearIcon = _ref.clearIcon,
    pickerRef = _ref.pickerRef,
    inputReadOnly = _ref.inputReadOnly,
    mode = _ref.mode,
    renderExtraFooter = _ref.renderExtraFooter,
    onChange = _ref.onChange,
    onOpenChange = _ref.onOpenChange,
    onPanelChange = _ref.onPanelChange,
    onCalendarChange = _ref.onCalendarChange,
    _onFocus = _ref.onFocus,
    onBlur = _ref.onBlur,
    onMouseDown = _ref.onMouseDown,
    onMouseUp = _ref.onMouseUp,
    onMouseEnter = _ref.onMouseEnter,
    onMouseLeave = _ref.onMouseLeave,
    onClick = _ref.onClick,
    _onOk = _ref.onOk,
    _onKeyDown = _ref.onKeyDown,
    components = _ref.components,
    order = _ref.order,
    direction = _ref.direction,
    activePickerIndex = _ref.activePickerIndex,
    _ref$autoComplete = _ref.autoComplete,
    autoComplete = _ref$autoComplete === void 0 ? 'off' : _ref$autoComplete,
    changeOnBlur = _ref.changeOnBlur;
  var needConfirmButton = picker === 'date' && !!showTime || picker === 'time';
  var containerRef = useRef(null);
  var panelDivRef = useRef(null);
  var startInputDivRef = useRef(null);
  var endInputDivRef = useRef(null);
  var separatorRef = useRef(null);
  var startInputRef = useRef(null);
  var endInputRef = useRef(null);
  var arrowRef = useRef(null);

  // ============================ Warning ============================
  if (process.env.NODE_ENV !== 'production') {
    legacyPropsWarning(props);
  }

  // ============================= Misc ==============================
  var formatList = toArray(getDefaultFormat(format, picker, showTime, use12Hours));
  var formatDateValue = function formatDateValue(values, index) {
    return values && values[index] ? formatValue(values[index], {
      generateConfig: generateConfig,
      locale: locale,
      format: formatList[0]
    }) : '';
  };

  // Operation ref
  var operationRef = useRef(null);
  var mergedDisabled = React.useMemo(function () {
    if (Array.isArray(disabled)) {
      return disabled;
    }
    return [disabled || false, disabled || false];
  }, [disabled]);

  // ============================= Value =============================
  var _useMergedState = useMergedState(null, {
      value: value,
      defaultValue: defaultValue,
      postState: function postState(values) {
        return picker === 'time' && !order ? values : reorderValues(values, generateConfig);
      }
    }),
    _useMergedState2 = _slicedToArray(_useMergedState, 2),
    mergedValue = _useMergedState2[0],
    setInnerValue = _useMergedState2[1];

  // =========================== View Date ===========================
  // Config view panel
  var _useRangeViewDates = useRangeViewDates({
      values: mergedValue,
      picker: picker,
      defaultDates: defaultPickerValue,
      generateConfig: generateConfig
    }),
    _useRangeViewDates2 = _slicedToArray(_useRangeViewDates, 2),
    getViewDate = _useRangeViewDates2[0],
    setViewDate = _useRangeViewDates2[1];

  // ========================= Select Values =========================
  var _useMergedState3 = useMergedState(mergedValue, {
      postState: function postState(values) {
        var postValues = values;
        if (mergedDisabled[0] && mergedDisabled[1]) {
          return postValues;
        }

        // Fill disabled unit
        for (var i = 0; i < 2; i += 1) {
          if (mergedDisabled[i] && !postValues && !getValue(postValues, i) && !getValue(allowEmpty, i)) {
            postValues = updateValues(postValues, generateConfig.getNow(), i);
          }
        }
        return postValues;
      }
    }),
    _useMergedState4 = _slicedToArray(_useMergedState3, 2),
    selectedValue = _useMergedState4[0],
    setSelectedValue = _useMergedState4[1];

  // ============================= Modes =============================
  var _useMergedState5 = useMergedState([picker, picker], {
      value: mode
    }),
    _useMergedState6 = _slicedToArray(_useMergedState5, 2),
    mergedModes = _useMergedState6[0],
    setInnerModes = _useMergedState6[1];
  useEffect(function () {
    setInnerModes([picker, picker]);
  }, [picker]);
  var triggerModesChange = function triggerModesChange(modes, values) {
    setInnerModes(modes);
    if (onPanelChange) {
      onPanelChange(values, modes);
    }
  };

  // ============================= Open ==============================
  var _useRangeOpen = useRangeOpen(defaultOpen, open, activePickerIndex, changeOnBlur, needConfirmButton, startInputRef, endInputRef, getValue(selectedValue, 0), getValue(selectedValue, 1), mergedDisabled, onOpenChange),
    _useRangeOpen2 = _slicedToArray(_useRangeOpen, 4),
    mergedOpen = _useRangeOpen2[0],
    mergedActivePickerIndex = _useRangeOpen2[1],
    firstTimeOpen = _useRangeOpen2[2],
    _triggerOpen = _useRangeOpen2[3];
  var startOpen = mergedOpen && mergedActivePickerIndex === 0;
  var endOpen = mergedOpen && mergedActivePickerIndex === 1;

  // ========================= Disable Date ==========================
  var _useRangeDisabled = useRangeDisabled({
      picker: picker,
      selectedValue: selectedValue,
      locale: locale,
      disabled: mergedDisabled,
      disabledDate: disabledDate,
      generateConfig: generateConfig
    }, !mergedOpen || firstTimeOpen),
    _useRangeDisabled2 = _slicedToArray(_useRangeDisabled, 2),
    disabledStartDate = _useRangeDisabled2[0],
    disabledEndDate = _useRangeDisabled2[1];

  // ============================= Popup =============================
  // Popup min width
  var _useState = useState(0),
    _useState2 = _slicedToArray(_useState, 2),
    popupMinWidth = _useState2[0],
    setPopupMinWidth = _useState2[1];
  useEffect(function () {
    if (!mergedOpen && containerRef.current) {
      setPopupMinWidth(containerRef.current.offsetWidth);
    }
  }, [mergedOpen]);

  // ============================ Trigger ============================
  function triggerOpenAndFocus(index) {
    _triggerOpen(true, index, 'open');
    // Use setTimeout to make sure panel DOM exists
    raf(function () {
      var _inputRef$current;
      var inputRef = [startInputRef, endInputRef][index];
      (_inputRef$current = inputRef.current) === null || _inputRef$current === void 0 ? void 0 : _inputRef$current.focus();
    }, 0);
  }
  function triggerChange(newValue, sourceIndex, triggerCalendarChangeOnly) {
    var values = newValue;
    var startValue = getValue(values, 0);
    var endValue = getValue(values, 1);

    // >>>>> Format start & end values
    if (startValue && endValue && generateConfig.isAfter(startValue, endValue)) {
      if (
      // WeekPicker only compare week
      picker === 'week' && !isSameWeek(generateConfig, locale.locale, startValue, endValue) ||
      // QuotaPicker only compare week
      picker === 'quarter' && !isSameQuarter(generateConfig, startValue, endValue) ||
      // Other non-TimePicker compare date
      picker !== 'week' && picker !== 'quarter' && picker !== 'time' && !isSameDate(generateConfig, startValue, endValue)) {
        // Clean up end date when start date is after end date
        if (sourceIndex === 0) {
          values = [startValue, null];
          endValue = null;
        } else {
          startValue = null;
          values = [null, endValue];
        }
      } else if (picker !== 'time' || order !== false) {
        // Reorder when in same date
        values = reorderValues(values, generateConfig);
      }
    }
    setSelectedValue(values);
    var startStr = formatDateValue(values, 0);
    var endStr = formatDateValue(values, 1);
    if (onCalendarChange) {
      var _info = {
        range: sourceIndex === 0 ? 'start' : 'end'
      };
      onCalendarChange(values, [startStr, endStr], _info);
    }
    if (!triggerCalendarChangeOnly) {
      // >>>>> Trigger `onChange` event
      var canStartValueTrigger = canValueTrigger(startValue, 0, mergedDisabled, allowEmpty);
      var canEndValueTrigger = canValueTrigger(endValue, 1, mergedDisabled, allowEmpty);
      var canTrigger = values === null || canStartValueTrigger && canEndValueTrigger;
      if (canTrigger) {
        // Trigger onChange only when value is validate
        setInnerValue(values);
        if (onChange && (!isEqual(generateConfig, getValue(mergedValue, 0), startValue) || !isEqual(generateConfig, getValue(mergedValue, 1), endValue))) {
          onChange(values, [startStr, endStr]);
        }
      }
    }
  }
  var forwardKeyDown = function forwardKeyDown(e) {
    if (mergedOpen && operationRef.current && operationRef.current.onKeyDown) {
      // Let popup panel handle keyboard
      return operationRef.current.onKeyDown(e);
    }

    /* istanbul ignore next */
    /* eslint-disable no-lone-blocks */
    {
      warning(false, 'Picker not correct forward KeyDown operation. Please help to fire issue about this.');
      return false;
    }
  };

  // ============================= Text ==============================
  var sharedTextHooksProps = {
    formatList: formatList,
    generateConfig: generateConfig,
    locale: locale
  };
  var _useValueTexts = useValueTexts(getValue(selectedValue, 0), sharedTextHooksProps),
    _useValueTexts2 = _slicedToArray(_useValueTexts, 2),
    startValueTexts = _useValueTexts2[0],
    firstStartValueText = _useValueTexts2[1];
  var _useValueTexts3 = useValueTexts(getValue(selectedValue, 1), sharedTextHooksProps),
    _useValueTexts4 = _slicedToArray(_useValueTexts3, 2),
    endValueTexts = _useValueTexts4[0],
    firstEndValueText = _useValueTexts4[1];
  var _onTextChange = function onTextChange(newText, index) {
    var inputDate = parseValue(newText, {
      locale: locale,
      formatList: formatList,
      generateConfig: generateConfig
    });
    var disabledFunc = index === 0 ? disabledStartDate : disabledEndDate;
    if (inputDate && !disabledFunc(inputDate)) {
      setSelectedValue(updateValues(selectedValue, inputDate, index));
      setViewDate(inputDate, index);
    }
  };
  var _useTextValueMapping = useTextValueMapping({
      valueTexts: startValueTexts,
      onTextChange: function onTextChange(newText) {
        return _onTextChange(newText, 0);
      }
    }),
    _useTextValueMapping2 = _slicedToArray(_useTextValueMapping, 3),
    startText = _useTextValueMapping2[0],
    triggerStartTextChange = _useTextValueMapping2[1],
    resetStartText = _useTextValueMapping2[2];
  var _useTextValueMapping3 = useTextValueMapping({
      valueTexts: endValueTexts,
      onTextChange: function onTextChange(newText) {
        return _onTextChange(newText, 1);
      }
    }),
    _useTextValueMapping4 = _slicedToArray(_useTextValueMapping3, 3),
    endText = _useTextValueMapping4[0],
    triggerEndTextChange = _useTextValueMapping4[1],
    resetEndText = _useTextValueMapping4[2];
  var _useState3 = useState(null),
    _useState4 = _slicedToArray(_useState3, 2),
    rangeHoverValue = _useState4[0],
    setRangeHoverValue = _useState4[1];

  // ========================== Hover Range ==========================
  var _useState5 = useState(null),
    _useState6 = _slicedToArray(_useState5, 2),
    hoverRangedValue = _useState6[0],
    setHoverRangedValue = _useState6[1];
  var _useHoverValue = useHoverValue(startText, {
      formatList: formatList,
      generateConfig: generateConfig,
      locale: locale
    }),
    _useHoverValue2 = _slicedToArray(_useHoverValue, 3),
    startHoverValue = _useHoverValue2[0],
    onStartEnter = _useHoverValue2[1],
    onStartLeave = _useHoverValue2[2];
  var _useHoverValue3 = useHoverValue(endText, {
      formatList: formatList,
      generateConfig: generateConfig,
      locale: locale
    }),
    _useHoverValue4 = _slicedToArray(_useHoverValue3, 3),
    endHoverValue = _useHoverValue4[0],
    onEndEnter = _useHoverValue4[1],
    onEndLeave = _useHoverValue4[2];
  var onDateMouseEnter = function onDateMouseEnter(date) {
    setHoverRangedValue(updateValues(selectedValue, date, mergedActivePickerIndex));
    if (mergedActivePickerIndex === 0) {
      onStartEnter(date);
    } else {
      onEndEnter(date);
    }
  };
  var onDateMouseLeave = function onDateMouseLeave() {
    setHoverRangedValue(updateValues(selectedValue, null, mergedActivePickerIndex));
    if (mergedActivePickerIndex === 0) {
      onStartLeave();
    } else {
      onEndLeave();
    }
  };

  // ============================= Input =============================
  // We call effect to update `delayOpen` here since
  // when popup closed and input focused, should not trigger change when click another input
  var _React$useState = React.useState(mergedOpen),
    _React$useState2 = _slicedToArray(_React$useState, 2),
    delayOpen = _React$useState2[0],
    setDelayOpen = _React$useState2[1];
  React.useEffect(function () {
    setDelayOpen(mergedOpen);
  }, [mergedOpen]);
  var onInternalBlur = function onInternalBlur(e) {
    if (delayOpen) {
      if (needConfirmButton) {
        // when in dateTime mode, switching between two date input fields will trigger onCalendarChange.
        // when onBlur is triggered, the input field has already switched, 
        // so it's necessary to obtain the value of the previous input field here.
        var needTriggerIndex = mergedActivePickerIndex ? 0 : 1;
        var selectedIndexValue = getValue(selectedValue, needTriggerIndex);
        if (selectedIndexValue) {
          triggerChange(selectedValue, needTriggerIndex, true);
        }
      } else if (changeOnBlur) {
        var _selectedIndexValue = getValue(selectedValue, mergedActivePickerIndex);
        if (_selectedIndexValue) {
          triggerChange(selectedValue, mergedActivePickerIndex);
        }
      }
    }
    return onBlur === null || onBlur === void 0 ? void 0 : onBlur(e);
  };
  var getSharedInputHookProps = function getSharedInputHookProps(index, resetText) {
    return {
      blurToCancel: !changeOnBlur && needConfirmButton,
      changeOnBlur: changeOnBlur,
      forwardKeyDown: forwardKeyDown,
      onBlur: onInternalBlur,
      isClickOutside: function isClickOutside(target) {
        var elementsRefs = [startInputDivRef.current, endInputDivRef.current, containerRef.current];
        return !elementsContains([].concat(_toConsumableArray(needConfirmButton ? [elementsRefs[mergedActivePickerIndex]] : elementsRefs), [panelDivRef.current]), target);
      },
      onFocus: function onFocus(e) {
        if (_onFocus) {
          _onFocus(e);
        }
      },
      triggerOpen: function triggerOpen(newOpen) {
        if (newOpen) {
          _triggerOpen(newOpen, index, 'open');
        } else {
          _triggerOpen(newOpen,
          // Close directly if no selected value provided
          getValue(selectedValue, index) ? index : false, 'blur');
        }
      },
      onSubmit: function onSubmit() {
        if (
        // When user typing disabledDate with keyboard and enter, this value will be empty
        !selectedValue ||
        // Normal disabled check
        disabledDate && disabledDate(selectedValue[index])) {
          return false;
        }
        triggerChange(selectedValue, index);
        resetText();

        // Switch
        _triggerOpen(false, mergedActivePickerIndex, 'confirm');
      },
      onCancel: function onCancel() {
        _triggerOpen(false, index, 'cancel');
        setSelectedValue(mergedValue);
        resetText();
      }
    };
  };
  var sharedPickerInput = {
    onKeyDown: function onKeyDown(e, preventDefault) {
      _onKeyDown === null || _onKeyDown === void 0 ? void 0 : _onKeyDown(e, preventDefault);
    }
  };
  var _usePickerInput = usePickerInput(_objectSpread(_objectSpread({}, getSharedInputHookProps(0, resetStartText)), {}, {
      open: startOpen,
      value: startText
    }, sharedPickerInput)),
    _usePickerInput2 = _slicedToArray(_usePickerInput, 2),
    startInputProps = _usePickerInput2[0],
    _usePickerInput2$ = _usePickerInput2[1],
    startFocused = _usePickerInput2$.focused,
    startTyping = _usePickerInput2$.typing;
  var _usePickerInput3 = usePickerInput(_objectSpread(_objectSpread({}, getSharedInputHookProps(1, resetEndText)), {}, {
      open: endOpen,
      value: endText
    }, sharedPickerInput)),
    _usePickerInput4 = _slicedToArray(_usePickerInput3, 2),
    endInputProps = _usePickerInput4[0],
    _usePickerInput4$ = _usePickerInput4[1],
    endFocused = _usePickerInput4$.focused,
    endTyping = _usePickerInput4$.typing;

  // ========================== Click Picker ==========================
  var onPickerClick = function onPickerClick(e) {
    // When click inside the picker & outside the picker's input elements
    // the panel should still be opened
    if (onClick) {
      onClick(e);
    }
    if (!mergedOpen && !startInputRef.current.contains(e.target) && !endInputRef.current.contains(e.target)) {
      if (!mergedDisabled[0]) {
        triggerOpenAndFocus(0);
      } else if (!mergedDisabled[1]) {
        triggerOpenAndFocus(1);
      }
    }
  };
  var onPickerMouseDown = function onPickerMouseDown(e) {
    // shouldn't affect input elements if picker is active
    if (onMouseDown) {
      onMouseDown(e);
    }
    if (mergedOpen && (startFocused || endFocused) && !startInputRef.current.contains(e.target) && !endInputRef.current.contains(e.target)) {
      e.preventDefault();
    }
  };

  // ============================= Sync ==============================
  // Close should sync back with text value
  var startStr = mergedValue && mergedValue[0] ? formatValue(mergedValue[0], {
    locale: locale,
    format: 'YYYYMMDDHHmmss',
    generateConfig: generateConfig
  }) : '';
  var endStr = mergedValue && mergedValue[1] ? formatValue(mergedValue[1], {
    locale: locale,
    format: 'YYYYMMDDHHmmss',
    generateConfig: generateConfig
  }) : '';
  useEffect(function () {
    if (!mergedOpen) {
      setSelectedValue(mergedValue);
      if (!startValueTexts.length || startValueTexts[0] === '') {
        triggerStartTextChange('');
      } else if (firstStartValueText !== startText) {
        resetStartText();
      }
      if (!endValueTexts.length || endValueTexts[0] === '') {
        triggerEndTextChange('');
      } else if (firstEndValueText !== endText) {
        resetEndText();
      }
    }
  }, [mergedOpen, startValueTexts, endValueTexts]);

  // Sync innerValue with control mode
  useEffect(function () {
    setSelectedValue(mergedValue);
  }, [startStr, endStr]);
  var mergedCellRender = useCellRender({
    cellRender: cellRender,
    monthCellRender: monthCellRender,
    dateRender: dateRender
  });
  var panelDateRender = React.useMemo(function () {
    if (!mergedCellRender) return undefined;
    return function (date, info) {
      return mergedCellRender(date, _objectSpread(_objectSpread({}, info), {}, {
        range: mergedActivePickerIndex ? 'end' : 'start'
      }));
    };
  }, [mergedActivePickerIndex, mergedCellRender]);

  // ============================ Warning ============================
  if (process.env.NODE_ENV !== 'production') {
    if (value && Array.isArray(disabled) && (getValue(disabled, 0) && !getValue(value, 0) || getValue(disabled, 1) && !getValue(value, 1))) {
      warning(false, '`disabled` should not set with empty `value`. You should set `allowEmpty` or `value` instead.');
    }
    warning(!dateRender, "'dateRender' is deprecated. Please use 'cellRender' instead.");
    warning(!monthCellRender, "'monthCellRender' is deprecated. Please use 'cellRender' instead.");
    warning(!clearIcon, '`clearIcon` will be removed in future. Please use `allowClear` instead.');
  }

  // ============================ Private ============================
  if (pickerRef) {
    pickerRef.current = {
      focus: function focus() {
        if (startInputRef.current) {
          startInputRef.current.focus();
        }
      },
      blur: function blur() {
        if (startInputRef.current) {
          startInputRef.current.blur();
        }
        if (endInputRef.current) {
          endInputRef.current.blur();
        }
      }
    };
  }

  // ============================ Ranges =============================
  var presetList = usePresets(presets, ranges);

  // ============================= Panel =============================
  function renderPanel() {
    var panelPosition = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
    var panelProps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
    var panelHoverRangedValue = null;
    if (mergedOpen && hoverRangedValue && hoverRangedValue[0] && hoverRangedValue[1] && generateConfig.isAfter(hoverRangedValue[1], hoverRangedValue[0])) {
      panelHoverRangedValue = hoverRangedValue;
    }
    var panelShowTime = showTime;
    if (showTime && _typeof(showTime) === 'object' && showTime.defaultValue) {
      var timeDefaultValues = showTime.defaultValue;
      panelShowTime = _objectSpread(_objectSpread({}, showTime), {}, {
        defaultValue: getValue(timeDefaultValues, mergedActivePickerIndex) || undefined
      });
    }
    return /*#__PURE__*/React.createElement(RangeContext.Provider, {
      value: {
        inRange: true,
        panelPosition: panelPosition,
        rangedValue: rangeHoverValue || selectedValue,
        hoverRangedValue: panelHoverRangedValue
      }
    }, /*#__PURE__*/React.createElement(PickerPanel, _extends({}, props, panelProps, {
      cellRender: panelDateRender,
      showTime: panelShowTime,
      mode: mergedModes[mergedActivePickerIndex],
      generateConfig: generateConfig,
      style: undefined,
      direction: direction,
      disabledDate: mergedActivePickerIndex === 0 ? disabledStartDate : disabledEndDate,
      disabledTime: function disabledTime(date) {
        if (_disabledTime) {
          return _disabledTime(date, mergedActivePickerIndex === 0 ? 'start' : 'end');
        }
        return false;
      },
      className: classNames(_defineProperty({}, "".concat(prefixCls, "-panel-focused"), mergedActivePickerIndex === 0 ? !startTyping : !endTyping)),
      value: getValue(selectedValue, mergedActivePickerIndex),
      locale: locale,
      tabIndex: -1,
      onPanelChange: function onPanelChange(date, newMode) {
        // clear hover value when panel change
        if (mergedActivePickerIndex === 0) {
          onStartLeave(true);
        }
        if (mergedActivePickerIndex === 1) {
          onEndLeave(true);
        }
        triggerModesChange(updateValues(mergedModes, newMode, mergedActivePickerIndex), updateValues(selectedValue, date, mergedActivePickerIndex));
        var viewDate = date;
        if (panelPosition === 'right' && mergedModes[mergedActivePickerIndex] === newMode) {
          viewDate = getClosingViewDate(viewDate, newMode, generateConfig, -1);
        }
        setViewDate(viewDate, mergedActivePickerIndex);
      },
      onOk: null,
      onSelect: undefined,
      onChange: undefined,
      defaultValue: mergedActivePickerIndex === 0 ? getValue(selectedValue, 1) : getValue(selectedValue, 0)
      // defaultPickerValue={undefined}
    })));
  }

  var arrowLeft = 0;
  var panelLeft = 0;
  if (mergedActivePickerIndex && startInputDivRef.current && separatorRef.current && panelDivRef.current && arrowRef.current) {
    // Arrow offset
    arrowLeft = startInputDivRef.current.offsetWidth + separatorRef.current.offsetWidth;

    // If panelWidth - arrowWidth - arrowMarginLeft < arrowLeft, panel should move to right side.
    // If arrowOffsetLeft > arrowLeft, arrowMarginLeft = arrowOffsetLeft - arrowLeft
    var arrowMarginLeft = arrowRef.current.offsetLeft > arrowLeft ? arrowRef.current.offsetLeft - arrowLeft : arrowRef.current.offsetLeft;
    var panelWidth = panelDivRef.current.offsetWidth;
    var arrowWidth = arrowRef.current.offsetWidth;
    if (panelWidth && arrowWidth && arrowLeft > panelWidth - arrowWidth - (direction === 'rtl' ? 0 : arrowMarginLeft)) {
      panelLeft = arrowLeft;
    }
  }
  var arrowPositionStyle = direction === 'rtl' ? {
    right: arrowLeft
  } : {
    left: arrowLeft
  };
  function renderPanels() {
    var panels;
    var extraNode = getExtraFooter(prefixCls, mergedModes[mergedActivePickerIndex], renderExtraFooter);
    var rangesNode = getRanges({
      prefixCls: prefixCls,
      components: components,
      needConfirmButton: needConfirmButton,
      okDisabled: !getValue(selectedValue, mergedActivePickerIndex) || disabledDate && disabledDate(selectedValue[mergedActivePickerIndex]),
      locale: locale,
      // rangeList,
      onOk: function onOk() {
        var selectedIndexValue = getValue(selectedValue, mergedActivePickerIndex);
        if (selectedIndexValue) {
          triggerChange(selectedValue, mergedActivePickerIndex);
          _onOk === null || _onOk === void 0 ? void 0 : _onOk(selectedValue);

          // Switch
          _triggerOpen(false, mergedActivePickerIndex, 'confirm');
        }
      }
    });
    if (picker !== 'time' && !showTime) {
      var viewDate = getViewDate(mergedActivePickerIndex);
      var nextViewDate = getClosingViewDate(viewDate, picker, generateConfig);
      var currentMode = mergedModes[mergedActivePickerIndex];
      var showDoublePanel = currentMode === picker;
      var leftPanel = renderPanel(showDoublePanel ? 'left' : false, {
        pickerValue: viewDate,
        onPickerValueChange: function onPickerValueChange(newViewDate) {
          setViewDate(newViewDate, mergedActivePickerIndex);
        }
      });
      var rightPanel = renderPanel('right', {
        pickerValue: nextViewDate,
        onPickerValueChange: function onPickerValueChange(newViewDate) {
          setViewDate(getClosingViewDate(newViewDate, picker, generateConfig, -1), mergedActivePickerIndex);
        }
      });
      if (direction === 'rtl') {
        panels = /*#__PURE__*/React.createElement(React.Fragment, null, rightPanel, showDoublePanel && leftPanel);
      } else {
        panels = /*#__PURE__*/React.createElement(React.Fragment, null, leftPanel, showDoublePanel && rightPanel);
      }
    } else {
      panels = renderPanel();
    }
    var mergedNodes = /*#__PURE__*/React.createElement("div", {
      className: "".concat(prefixCls, "-panel-layout")
    }, /*#__PURE__*/React.createElement(PresetPanel, {
      prefixCls: prefixCls,
      presets: presetList,
      onClick: function onClick(nextValue) {
        triggerChange(nextValue, null);
        _triggerOpen(false, mergedActivePickerIndex, 'preset');
      },
      onHover: function onHover(hoverValue) {
        setRangeHoverValue(hoverValue);
      }
    }), /*#__PURE__*/React.createElement("div", null, /*#__PURE__*/React.createElement("div", {
      className: "".concat(prefixCls, "-panels")
    }, panels), (extraNode || rangesNode) && /*#__PURE__*/React.createElement("div", {
      className: "".concat(prefixCls, "-footer")
    }, extraNode, rangesNode)));
    if (panelRender) {
      mergedNodes = panelRender(mergedNodes);
    }
    return /*#__PURE__*/React.createElement("div", {
      className: "".concat(prefixCls, "-panel-container"),
      style: {
        marginLeft: panelLeft
      },
      ref: panelDivRef,
      onMouseDown: function onMouseDown(e) {
        e.preventDefault();
      }
    }, mergedNodes);
  }
  var rangePanel = /*#__PURE__*/React.createElement("div", {
    className: classNames("".concat(prefixCls, "-range-wrapper"), "".concat(prefixCls, "-").concat(picker, "-range-wrapper")),
    style: {
      minWidth: popupMinWidth
    }
  }, /*#__PURE__*/React.createElement("div", {
    ref: arrowRef,
    className: "".concat(prefixCls, "-range-arrow"),
    style: arrowPositionStyle
  }), renderPanels());

  // ============================= Icons =============================
  var suffixNode;
  if (suffixIcon) {
    suffixNode = /*#__PURE__*/React.createElement("span", {
      className: "".concat(prefixCls, "-suffix"),
      onMouseDown: function onMouseDown(e) {
        // Not lost focus
        e.preventDefault();
      }
    }, suffixIcon);
  }
  var mergedClearIcon = getClearIcon(prefixCls, allowClear, clearIcon);
  var clearNode = /*#__PURE__*/React.createElement("span", {
    onMouseDown: function onMouseDown(e) {
      e.preventDefault();
      e.stopPropagation();
    },
    onMouseUp: function onMouseUp(e) {
      e.preventDefault();
      e.stopPropagation();
      var values = mergedValue;
      if (!mergedDisabled[0]) {
        values = updateValues(values, null, 0);
      }
      if (!mergedDisabled[1]) {
        values = updateValues(values, null, 1);
      }
      triggerChange(values, null);
      _triggerOpen(false, mergedActivePickerIndex, 'clear');
    },
    className: "".concat(prefixCls, "-clear"),
    role: "button"
  }, mergedClearIcon);
  var mergedAllowClear = allowClear && (getValue(mergedValue, 0) && !mergedDisabled[0] || getValue(mergedValue, 1) && !mergedDisabled[1]);
  var inputSharedProps = {
    size: getInputSize(picker, formatList[0], generateConfig)
  };
  var activeBarLeft = 0;
  var activeBarWidth = 0;
  if (startInputDivRef.current && endInputDivRef.current && separatorRef.current) {
    if (mergedActivePickerIndex === 0) {
      activeBarWidth = startInputDivRef.current.offsetWidth;
    } else {
      activeBarLeft = arrowLeft;
      activeBarWidth = endInputDivRef.current.offsetWidth;
    }
  }
  var activeBarPositionStyle = direction === 'rtl' ? {
    right: activeBarLeft
  } : {
    left: activeBarLeft
  };
  // ============================ Return =============================
  var onContextSelect = function onContextSelect(date, type) {
    var values = updateValues(selectedValue, date, mergedActivePickerIndex);
    if (type === 'submit' || type !== 'key' && !needConfirmButton) {
      // triggerChange will also update selected values
      triggerChange(values, mergedActivePickerIndex);
      // clear hover value style
      if (mergedActivePickerIndex === 0) {
        onStartLeave();
      } else {
        onEndLeave();
      }

      // Switch
      var nextActivePickerIndex = mergedActivePickerIndex === 0 ? 1 : 0;
      if (mergedDisabled[nextActivePickerIndex]) {
        _triggerOpen(false, false, 'confirm');
      } else {
        _triggerOpen(false, mergedActivePickerIndex, 'confirm');
      }
    } else {
      setSelectedValue(values);
    }
  };
  return /*#__PURE__*/React.createElement(PanelContext.Provider, {
    value: {
      operationRef: operationRef,
      hideHeader: picker === 'time',
      onDateMouseEnter: onDateMouseEnter,
      onDateMouseLeave: onDateMouseLeave,
      hideRanges: true,
      onSelect: onContextSelect,
      open: mergedOpen
    }
  }, /*#__PURE__*/React.createElement(PickerTrigger, {
    visible: mergedOpen,
    popupElement: rangePanel,
    popupStyle: popupStyle,
    prefixCls: prefixCls,
    dropdownClassName: dropdownClassName,
    dropdownAlign: dropdownAlign,
    getPopupContainer: getPopupContainer,
    transitionName: transitionName,
    range: true,
    direction: direction
  }, /*#__PURE__*/React.createElement("div", _extends({
    ref: containerRef,
    className: classNames(prefixCls, "".concat(prefixCls, "-range"), className, (_classNames2 = {}, _defineProperty(_classNames2, "".concat(prefixCls, "-disabled"), mergedDisabled[0] && mergedDisabled[1]), _defineProperty(_classNames2, "".concat(prefixCls, "-focused"), mergedActivePickerIndex === 0 ? startFocused : endFocused), _defineProperty(_classNames2, "".concat(prefixCls, "-rtl"), direction === 'rtl'), _classNames2)),
    style: style,
    onClick: onPickerClick,
    onMouseEnter: onMouseEnter,
    onMouseLeave: onMouseLeave,
    onMouseDown: onPickerMouseDown,
    onMouseUp: onMouseUp
  }, pickAttrs(props, {
    aria: true,
    data: true
  })), /*#__PURE__*/React.createElement("div", {
    className: classNames("".concat(prefixCls, "-input"), (_classNames3 = {}, _defineProperty(_classNames3, "".concat(prefixCls, "-input-active"), mergedActivePickerIndex === 0), _defineProperty(_classNames3, "".concat(prefixCls, "-input-placeholder"), !!startHoverValue), _classNames3)),
    ref: startInputDivRef
  }, /*#__PURE__*/React.createElement("input", _extends({
    id: id,
    disabled: mergedDisabled[0],
    readOnly: inputReadOnly || typeof formatList[0] === 'function' || !startTyping,
    value: startHoverValue || startText,
    onChange: function onChange(e) {
      triggerStartTextChange(e.target.value);
    },
    autoFocus: autoFocus,
    placeholder: getValue(placeholder, 0) || '',
    ref: startInputRef
  }, startInputProps, inputSharedProps, {
    autoComplete: autoComplete
  }))), /*#__PURE__*/React.createElement("div", {
    className: "".concat(prefixCls, "-range-separator"),
    ref: separatorRef
  }, separator), /*#__PURE__*/React.createElement("div", {
    className: classNames("".concat(prefixCls, "-input"), (_classNames4 = {}, _defineProperty(_classNames4, "".concat(prefixCls, "-input-active"), mergedActivePickerIndex === 1), _defineProperty(_classNames4, "".concat(prefixCls, "-input-placeholder"), !!endHoverValue), _classNames4)),
    ref: endInputDivRef
  }, /*#__PURE__*/React.createElement("input", _extends({
    disabled: mergedDisabled[1],
    readOnly: inputReadOnly || typeof formatList[0] === 'function' || !endTyping,
    value: endHoverValue || endText,
    onChange: function onChange(e) {
      triggerEndTextChange(e.target.value);
    },
    placeholder: getValue(placeholder, 1) || '',
    ref: endInputRef
  }, endInputProps, inputSharedProps, {
    autoComplete: autoComplete
  }))), /*#__PURE__*/React.createElement("div", {
    className: "".concat(prefixCls, "-active-bar"),
    style: _objectSpread(_objectSpread({}, activeBarPositionStyle), {}, {
      width: activeBarWidth,
      position: 'absolute'
    })
  }), suffixNode, mergedAllowClear && clearNode)));
}

// Wrap with class component to enable pass generic with instance method
var RangePicker = /*#__PURE__*/function (_React$Component) {
  _inherits(RangePicker, _React$Component);
  var _super = _createSuper(RangePicker);
  function RangePicker() {
    var _this;
    _classCallCheck(this, RangePicker);
    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }
    _this = _super.call.apply(_super, [this].concat(args));
    _defineProperty(_assertThisInitialized(_this), "pickerRef", /*#__PURE__*/React.createRef());
    _defineProperty(_assertThisInitialized(_this), "focus", function () {
      if (_this.pickerRef.current) {
        _this.pickerRef.current.focus();
      }
    });
    _defineProperty(_assertThisInitialized(_this), "blur", function () {
      if (_this.pickerRef.current) {
        _this.pickerRef.current.blur();
      }
    });
    return _this;
  }
  _createClass(RangePicker, [{
    key: "render",
    value: function render() {
      return /*#__PURE__*/React.createElement(InnerRangePicker, _extends({}, this.props, {
        pickerRef: this.pickerRef
      }));
    }
  }]);
  return RangePicker;
}(React.Component);
export default RangePicker;