@kdcloudjs/kdesign 1.0.2

package/es/date-picker/date-picker.js

@@ -0,0 +1,444 @@
+import _extends from "@babel/runtime-corejs3/helpers/extends";
+import _slicedToArray from "@babel/runtime-corejs3/helpers/slicedToArray";
+import _findInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/find";
+import React, { useContext, useEffect } from 'react';
+import classnames from 'classnames';
+import parse from 'date-fns/parse';
+import ConfigContext from '../config-provider/ConfigContext';
+import { useMergedState, useOnClickOutside } from '../_utils/hooks';
+import { getCompProps } from '../_utils';
+import Context from './context';
+import Panel from './date-panel';
+import InputDate from './single/input-date';
+import { getDefaultFormat, getDataOrAriaProps, getInternalNextMode, generateUnits } from './utils';
+import useValueTexts from './hooks/use-value-texts';
+import useHoverValue from './hooks/use-hover-value';
+import { formatDate, getHours, getLowerBoundTime, getMinutes, getSeconds, isEqual, isValid, newDate, parseDate, setTime } from './utils/date-fns';
+import useTextValueMapping from './hooks/use-text-value-mapping';
+import { getCompLangMsg } from '../locale';
+import getExtraFooter from './utils/get-extra-footer';
+import getRanges from './utils/get-ranges';
+import usePopper from '../_utils/usePopper';
+
+function DatePicker(props) {
+  var customPrefixcls = props.prefixCls;
+
+  var _useContext = useContext(ConfigContext),
+      getPrefixCls = _useContext.getPrefixCls,
+      prefixCls = _useContext.prefixCls,
+      userDefaultProps = _useContext.compDefaultProps,
+      globalLocale = _useContext.locale;
+
+  var datePickerProps = getCompProps('DatePicker', userDefaultProps, props);
+  var datePickerPrefixCls = getPrefixCls(prefixCls, 'date-picker', customPrefixcls);
+  var id = datePickerProps.id,
+      style = datePickerProps.style,
+      className = datePickerProps.className,
+      dropdownClassName = datePickerProps.dropdownClassName,
+      popupStyle = datePickerProps.popupStyle,
+      locale = datePickerProps.locale,
+      inputReadOnly = datePickerProps.inputReadOnly,
+      allowClear = datePickerProps.allowClear,
+      autoFocus = datePickerProps.autoFocus,
+      _datePickerProps$pick = datePickerProps.picker,
+      picker = _datePickerProps$pick === void 0 ? 'date' : _datePickerProps$pick,
+      mode = datePickerProps.mode,
+      format = datePickerProps.format,
+      value = datePickerProps.value,
+      defaultValue = datePickerProps.defaultValue,
+      defaultPickerValue = datePickerProps.defaultPickerValue,
+      open = datePickerProps.open,
+      defaultOpen = datePickerProps.defaultOpen,
+      suffixIcon = datePickerProps.suffixIcon,
+      clearIcon = datePickerProps.clearIcon,
+      disabled = datePickerProps.disabled,
+      placeholder = datePickerProps.placeholder,
+      borderType = datePickerProps.borderType,
+      size = datePickerProps.size,
+      showToday = datePickerProps.showToday,
+      showTime = datePickerProps.showTime,
+      showNow = datePickerProps.showNow,
+      use12Hours = datePickerProps.use12Hours,
+      components = datePickerProps.components,
+      _datePickerProps$hour = datePickerProps.hourStep,
+      hourStep = _datePickerProps$hour === void 0 ? 1 : _datePickerProps$hour,
+      _datePickerProps$minu = datePickerProps.minuteStep,
+      minuteStep = _datePickerProps$minu === void 0 ? 1 : _datePickerProps$minu,
+      _datePickerProps$seco = datePickerProps.secondStep,
+      secondStep = _datePickerProps$seco === void 0 ? 1 : _datePickerProps$seco,
+      disabledDate = datePickerProps.disabledDate,
+      disabledHours = datePickerProps.disabledHours,
+      disabledMinutes = datePickerProps.disabledMinutes,
+      disabledSeconds = datePickerProps.disabledSeconds,
+      panelRender = datePickerProps.panelRender,
+      renderExtraFooter = datePickerProps.renderExtraFooter,
+      onChange = datePickerProps.onChange,
+      onSelect = datePickerProps.onSelect,
+      onOpenChange = datePickerProps.onOpenChange,
+      onFocus = datePickerProps.onFocus,
+      onBlur = datePickerProps.onBlur,
+      onMouseDown = datePickerProps.onMouseDown,
+      onMouseUp = datePickerProps.onMouseUp,
+      onMouseEnter = datePickerProps.onMouseEnter,
+      onMouseLeave = datePickerProps.onMouseLeave,
+      onContextMenu = datePickerProps.onContextMenu,
+      onClick = datePickerProps.onClick,
+      _onOk = datePickerProps.onOk; // ref
+
+  var panelDivRef = React.useRef(null);
+  var inputDivRef = React.useRef(null);
+  var popperRef = React.useRef(null);
+  var inputRef = React.useRef(null);
+  var isHourStepValid = 24 % hourStep === 0;
+  var isMinuteStepValid = 60 % minuteStep === 0;
+  var isSecondStepValid = 60 % secondStep === 0; // const hours = generateUnits(0, 23, hourStep, disabledHours && disabledHours())
+  // const minutes = generateUnits(0, 59, minuteStep, disabledMinutes && disabledMinutes(originHour))
+  // const seconds = generateUnits(0, 59, secondStep, disabledSeconds && disabledSeconds(originHour, minute))
+
+  var needConfirmButton = picker === 'date' && !!showTime || picker === 'time';
+  var datePickerLang = locale ? getCompLangMsg({
+    componentName: 'DatePicker'
+  }, function (_componentName, label) {
+    return locale[label];
+  }) : globalLocale.getCompLangMsg({
+    componentName: 'DatePicker'
+  }); // console.log(_format)
+  // 原始数据
+
+  var _useMergedState = useMergedState(null, {
+    value: value,
+    defaultValue: defaultValue
+  }),
+      _useMergedState2 = _slicedToArray(_useMergedState, 2),
+      dateValue = _useMergedState2[0],
+      setDateValue = _useMergedState2[1]; // 选中的数据
+
+
+  var _React$useState = React.useState(dateValue),
+      _React$useState2 = _slicedToArray(_React$useState, 2),
+      selectedValue = _React$useState2[0],
+      setSelectedValue = _React$useState2[1];
+
+  var hours;
+  var minutes;
+  var seconds;
+  var originHour;
+  var minute;
+  var second;
+  var disabledTimePanel = false;
+
+  if (picker === 'time' || picker === 'date' && showTime) {
+    originHour = selectedValue ? getHours(selectedValue) : -1;
+    minute = selectedValue ? getMinutes(selectedValue) : -1;
+    second = selectedValue ? getSeconds(selectedValue) : -1;
+    hours = generateUnits(0, 23, hourStep, disabledHours && disabledHours());
+    minutes = generateUnits(0, 59, minuteStep, disabledMinutes && disabledMinutes(originHour));
+    seconds = generateUnits(0, 59, secondStep, disabledSeconds && disabledSeconds(originHour, minute));
+
+    if (hours && !_findInstanceProperty(hours).call(hours, function (n) {
+      return !n.disabled;
+    }) || minutes && !_findInstanceProperty(minutes).call(minutes, function (n) {
+      return !n.disabled;
+    }) || seconds && !_findInstanceProperty(seconds).call(seconds, function (n) {
+      return !n.disabled;
+    })) {
+      disabledTimePanel = true;
+    }
+  }
+
+  var _format = getDefaultFormat(format, picker, showTime && !disabledTimePanel, use12Hours); // 面板展示日期
+
+
+  var _useMergedState3 = useMergedState(null, {
+    // value: pickerValue,
+    defaultValue: defaultPickerValue || dateValue,
+    postState: function postState(date) {
+      return date || newDate();
+    }
+  }),
+      _useMergedState4 = _slicedToArray(_useMergedState3, 2),
+      viewDate = _useMergedState4[0],
+      setViewDate = _useMergedState4[1]; // text
+
+
+  var valueText = useValueTexts(selectedValue, {
+    format: _format
+  }); // input 展示
+
+  var _useTextValueMapping = useTextValueMapping({
+    valueText: valueText,
+    onTextChange: function onTextChange(newText) {
+      // if (typeof _format !== 'function') {
+      var inputDate;
+
+      if (picker !== 'year') {
+        inputDate = parseDate(newText, _format);
+      } else {
+        var year = parse(newText, _format, newDate());
+        inputDate = isValid(year) ? year : null;
+      }
+
+      if (inputDate && (!disabledDate || !disabledDate(inputDate))) {
+        setSelectedValue(inputDate);
+        setViewDate(inputDate);
+      }
+    }
+  }),
+      _useTextValueMapping2 = _slicedToArray(_useTextValueMapping, 3),
+      text = _useTextValueMapping2[0],
+      triggerTextChange = _useTextValueMapping2[1],
+      resetText = _useTextValueMapping2[2];
+
+  var _useHoverValue = useHoverValue(text, {
+    format: _format
+  }),
+      _useHoverValue2 = _slicedToArray(_useHoverValue, 3),
+      hoverValue = _useHoverValue2[0],
+      onEnter = _useHoverValue2[1],
+      onLeave = _useHoverValue2[2];
+
+  var _useMergedState5 = useMergedState(false, {
+    value: open,
+    defaultValue: defaultOpen,
+    postState: function postState(postOpen) {
+      return disabled ? false : postOpen;
+    },
+    onChange: function onChange(newOpen) {
+      if (onOpenChange) {
+        onOpenChange(newOpen);
+      } // if (!newOpen && operationRef.current && operationRef.current.onClose) {
+      //   operationRef.current.onClose()
+      // }
+
+    }
+  }),
+      _useMergedState6 = _slicedToArray(_useMergedState5, 2),
+      openValue = _useMergedState6[0],
+      triggerInnerOpen = _useMergedState6[1]; // Save panel is changed from which panel
+
+
+  var _useMergedState7 = useMergedState(function () {
+    if (picker === 'time') {
+      return 'time';
+    }
+
+    return getInternalNextMode('date', picker);
+  }, {
+    value: mode
+  }),
+      _useMergedState8 = _slicedToArray(_useMergedState7, 2),
+      mergedMode = _useMergedState8[0],
+      setInnerMode = _useMergedState8[1];
+
+  useEffect(function () {
+    setInnerMode(picker);
+  }, [picker]);
+  useEffect(function () {
+    if (!openValue) {
+      setSelectedValue(dateValue);
+
+      if (valueText === '') {
+        triggerTextChange('');
+      } else if (valueText !== text) {
+        resetText();
+      }
+    } // eslint-disable-next-line react-hooks/exhaustive-deps
+
+  }, [openValue, valueText]);
+  useEffect(function () {
+    if (!openValue) {
+      resetText();
+    } // eslint-disable-next-line react-hooks/exhaustive-deps
+
+  }, [picker]);
+  useEffect(function () {
+    setSelectedValue(dateValue);
+  }, [dateValue]);
+  useOnClickOutside([popperRef, inputDivRef], function () {
+    setViewDate(selectedValue || newDate());
+    triggerOpen(false);
+  });
+
+  var triggerChange = function triggerChange(newValue) {
+    setSelectedValue(newValue);
+    setDateValue(newValue);
+
+    if (onSelect) {
+      onSelect(newValue);
+    }
+
+    if (onChange && !isEqual(dateValue, newValue)) {
+      onChange(newValue, newValue ? formatDate(newValue, _format) : '');
+    }
+  };
+
+  var triggerOpen = function triggerOpen(newOpen) {
+    if (disabled && newOpen) {
+      return;
+    }
+
+    triggerInnerOpen(newOpen);
+  };
+
+  var onContextSelect = function onContextSelect(date, type) {
+    if (type === 'submit' || type !== 'key' && !needConfirmButton) {
+      setViewDate(date);
+      triggerChange(date);
+      triggerOpen(false);
+    } else {
+      setViewDate(date);
+      triggerChange(date);
+    }
+  };
+
+  var onNow = function onNow() {
+    var now = newDate();
+    var lowerBoundTime = getLowerBoundTime(getHours(now), getMinutes(now), getSeconds(now), isHourStepValid ? hourStep : 1, isMinuteStepValid ? minuteStep : 1, isSecondStepValid ? secondStep : 1);
+    var adjustedNow = setTime(now, {
+      hour: lowerBoundTime[0],
+      minute: lowerBoundTime[1],
+      second: lowerBoundTime[2]
+    });
+
+    if (disabledDate && disabledDate(adjustedNow) || disabledTimePanel) {
+      return;
+    }
+
+    onContextSelect(adjustedNow, 'submit');
+  };
+
+  var extraFooter = getExtraFooter(datePickerPrefixCls, mergedMode, renderExtraFooter);
+  var rangesNode = getRanges({
+    prefixCls: datePickerPrefixCls,
+    components: components,
+    needConfirmButton: needConfirmButton,
+    okDisabled: !selectedValue || disabledDate && disabledDate(selectedValue),
+    locale: datePickerLang,
+    showNow: showNow,
+    onNow: needConfirmButton && onNow,
+    onOk: function onOk() {
+      if (selectedValue) {
+        onContextSelect(selectedValue, 'submit');
+
+        if (_onOk) {
+          _onOk(selectedValue);
+        }
+      }
+    }
+  });
+  var todayNode;
+
+  if (showToday && mergedMode === 'date' && picker === 'date' && !showTime) {
+    var now = newDate();
+    var todayCls = "".concat(datePickerPrefixCls, "-today-btn");
+
+    var _disabled = disabledDate && disabledDate(now);
+
+    todayNode = /*#__PURE__*/React.createElement("div", {
+      className: classnames(todayCls, _disabled && "".concat(datePickerPrefixCls, "-btn-disabled")),
+      "aria-disabled": _disabled,
+      onClick: function onClick() {
+        if (!_disabled) {
+          onContextSelect(now, 'mouse');
+        }
+      }
+    }, datePickerLang.today);
+  }
+
+  var panelProps = _extends(_extends({}, datePickerProps), {
+    format: _format,
+    onChange: setSelectedValue
+  }); // 渲染日期选择表盘
+
+
+  function renderPanel() {
+    var panelNode = /*#__PURE__*/React.createElement(Panel, _extends({}, panelProps));
+
+    if (panelRender) {
+      panelNode = panelRender(panelNode);
+    }
+
+    return /*#__PURE__*/React.createElement(Context.Provider, {
+      value: {
+        hours: hours,
+        minutes: minutes,
+        seconds: seconds,
+        originHour: originHour,
+        minute: minute,
+        second: second,
+        disabledTimePanel: disabledTimePanel,
+        prefixCls: datePickerPrefixCls,
+        dateValue: selectedValue,
+        viewDate: viewDate,
+        open: openValue,
+        locale: datePickerLang,
+        onSelect: onContextSelect,
+        setViewDate: setViewDate,
+        onDateMouseEnter: onEnter,
+        onDateMouseLeave: onLeave
+      }
+    }, panelNode, extraFooter || rangesNode || todayNode ? /*#__PURE__*/React.createElement("div", {
+      className: "".concat(datePickerPrefixCls, "-footer")
+    }, extraFooter, rangesNode, todayNode) : null);
+  }
+
+  var inputProps = {
+    inputRef: inputRef,
+    panelDivRef: panelDivRef,
+    id: id,
+    autoFocus: autoFocus,
+    allowClear: allowClear,
+    className: className,
+    borderType: borderType,
+    disabled: disabled,
+    hoverValue: hoverValue,
+    picker: picker,
+    placeholder: placeholder,
+    style: style,
+    size: size,
+    text: text,
+    needConfirmButton: needConfirmButton,
+    suffixIcon: suffixIcon,
+    clearIcon: clearIcon,
+    dateValue: dateValue,
+    selectedValue: selectedValue,
+    format: _format,
+    open: openValue,
+    readOnly: inputReadOnly,
+    prefixCls: datePickerPrefixCls,
+    locale: datePickerLang,
+    dataOrAriaProps: getDataOrAriaProps(datePickerProps),
+    disabledDate: disabledDate,
+    onFocus: onFocus,
+    onBlur: onBlur,
+    onMouseDown: onMouseDown,
+    onMouseUp: onMouseUp,
+    onMouseEnter: onMouseEnter,
+    onMouseLeave: onMouseLeave,
+    onContextMenu: onContextMenu,
+    onClick: onClick,
+    setSelectedValue: setSelectedValue,
+    triggerTextChange: triggerTextChange,
+    triggerOpen: triggerOpen,
+    triggerChange: triggerChange,
+    resetText: resetText
+  };
+  return usePopper( /*#__PURE__*/React.createElement(InputDate, _extends({
+    ref: inputDivRef
+  }, inputProps)), /*#__PURE__*/React.createElement("div", {
+    ref: popperRef,
+    onMouseDown: function onMouseDown(e) {
+      e.preventDefault();
+    }
+  }, renderPanel()), {
+    trigger: 'click',
+    prefixCls: "".concat(datePickerPrefixCls, "-panel"),
+    arrow: false,
+    popperClassName: dropdownClassName,
+    popperStyle: popupStyle,
+    visible: openValue,
+    placement: 'bottomLeft'
+  });
+}
+
+export default DatePicker;

package/es/date-picker/hooks/use-hover-value.d.ts

@@ -0,0 +1,3 @@
+import { DateType } from '../interface';
+import { ValueTextConfig } from './use-value-texts';
+export default function useHoverValue(valueText: string, { format }: ValueTextConfig): [string, (date: DateType) => void, (immediately?: boolean) => void];

package/es/date-picker/hooks/use-hover-value.js

@@ -0,0 +1,53 @@
+import _slicedToArray from "@babel/runtime-corejs3/helpers/slicedToArray";
+import isNumber from 'lodash/isNumber';
+import { useState, useEffect, useRef } from 'react';
+import useValueTexts from './use-value-texts';
+export default function useHoverValue(valueText, _ref) {
+  var format = _ref.format;
+
+  var _useState = useState(null),
+      _useState2 = _slicedToArray(_useState, 2),
+      value = _useState2[0],
+      internalSetValue = _useState2[1];
+
+  var ref = useRef();
+
+  function setValue(val) {
+    var immediately = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    isNumber(ref.current) && cancelAnimationFrame(ref.current);
+
+    if (immediately) {
+      internalSetValue(val);
+      return;
+    }
+
+    ref.current = requestAnimationFrame(function () {
+      internalSetValue(val);
+    });
+  }
+
+  var valueTexts = useValueTexts(value, {
+    format: format
+  });
+
+  function onEnter(date) {
+    setValue(date);
+  }
+
+  function onLeave() {
+    var immediately = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    setValue(null, immediately);
+  }
+
+  useEffect(function () {
+    onLeave(true); // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [valueText]);
+  useEffect(function () {
+    return function () {
+      if (isNumber(ref.current)) {
+        return cancelAnimationFrame(ref.current);
+      }
+    };
+  }, []);
+  return [valueTexts, onEnter, onLeave];
+}

package/es/date-picker/hooks/use-picker-input.d.ts

@@ -0,0 +1,16 @@
+import * as React from 'react';
+export default function usePickerInput({ preventBlurRef, open, value, isClickOutside, triggerOpen, blurToCancel, onSubmit, onCancel, onFocus, onBlur, }: {
+    preventBlurRef: React.RefObject<boolean>;
+    open: boolean;
+    value: string;
+    isClickOutside: (clickElement: EventTarget | null) => boolean;
+    triggerOpen: (open: boolean) => void;
+    blurToCancel?: boolean;
+    onSubmit: () => void | boolean;
+    onCancel: () => void;
+    onFocus?: React.FocusEventHandler<HTMLInputElement>;
+    onBlur?: React.FocusEventHandler<HTMLInputElement>;
+}): [React.DOMAttributes<HTMLInputElement>, {
+    focused: boolean;
+    typing: boolean;
+}];

package/es/date-picker/hooks/use-picker-input.js

@@ -0,0 +1,114 @@
+import _slicedToArray from "@babel/runtime-corejs3/helpers/slicedToArray";
+import { useState, useEffect, useRef } from 'react'; // import KeyCode from '../../_utils/KeyCode'
+
+export default function usePickerInput(_ref) {
+  var preventBlurRef = _ref.preventBlurRef,
+      open = _ref.open,
+      value = _ref.value,
+      isClickOutside = _ref.isClickOutside,
+      triggerOpen = _ref.triggerOpen,
+      blurToCancel = _ref.blurToCancel,
+      onSubmit = _ref.onSubmit,
+      onCancel = _ref.onCancel,
+      _onFocus = _ref.onFocus,
+      _onBlur = _ref.onBlur;
+
+  var _useState = useState(false),
+      _useState2 = _slicedToArray(_useState, 2),
+      typing = _useState2[0],
+      setTyping = _useState2[1];
+
+  var _useState3 = useState(false),
+      _useState4 = _slicedToArray(_useState3, 2),
+      focused = _useState4[0],
+      setFocused = _useState4[1];
+
+  var valueChangedRef = useRef(false);
+  var inputProps = {
+    onMouseDown: function onMouseDown() {
+      setTyping(true);
+      triggerOpen(true);
+    },
+    // onKeyDown: (e) => {
+    //   switch (e.which) {
+    //     case KeyCode.ENTER: {
+    //       if (!open) {
+    //         triggerOpen(true)
+    //       } else if (onSubmit() !== false) {
+    //         setTyping(true)
+    //       }
+    //       e.preventDefault()
+    //       return
+    //     }
+    //     case KeyCode.TAB: {
+    //       if (typing && open && !e.shiftKey) {
+    //         setTyping(false)
+    //         e.preventDefault()
+    //       } else if (!typing && open) {
+    //         if (!forwardKeyDown(e) && e.shiftKey) {
+    //           setTyping(true)
+    //           e.preventDefault()
+    //         }
+    //       }
+    //       return
+    //     }
+    //     case KeyCode.ESC: {
+    //       setTyping(true)
+    //       onCancel()
+    //       return
+    //     }
+    //   }
+    //   if (!open && ![KeyCode.SHIFT].includes(e.which)) {
+    //     triggerOpen(true)
+    //   } else if (!typing) {
+    //     // Let popup panel handle keyboard
+    //     forwardKeyDown(e)
+    //   }
+    // },
+    onFocus: function onFocus(e) {
+      setTyping(true);
+      setFocused(true);
+
+      if (_onFocus) {
+        _onFocus(e);
+      }
+    },
+    onBlur: function onBlur(e) {
+      if (preventBlurRef.current || !isClickOutside(document.activeElement)) {
+        // preventBlurRef.current = false
+        return;
+      }
+
+      if (blurToCancel) {
+        setTimeout(function () {
+          if (isClickOutside(document.activeElement)) {
+            onCancel();
+          }
+        }, 0);
+      } else if (open) {
+        triggerOpen(false);
+
+        if (valueChangedRef.current) {
+          onSubmit();
+        }
+      }
+
+      setFocused(false);
+
+      if (_onBlur) {
+        _onBlur(e);
+      }
+    }
+  }; // check if value changed
+
+  useEffect(function () {
+    valueChangedRef.current = false;
+  }, [open]);
+  useEffect(function () {
+    valueChangedRef.current = true;
+  }, [value]);
+  return [inputProps, {
+    focused: focused,
+    typing: typing
+  }];
+}

package/es/date-picker/hooks/use-range-cls.d.ts

@@ -0,0 +1,14 @@
+import { DateType, EventValue, RangeValue } from '../interface';
+declare type InterRangeValue = [EventValue, EventValue];
+export default function useRangeCls({ prefixCls, isRange, rangeValue, hoverRangedValue, isCurrentMonth, isAfterStart, isBeforeEnd, isStart, isEnd, }: {
+    prefixCls: string;
+    isRange: boolean;
+    rangeValue?: RangeValue;
+    hoverRangedValue?: RangeValue;
+    isCurrentMonth?: (date: DateType) => boolean;
+    isAfterStart: (date: DateType, rangeValue: InterRangeValue) => boolean;
+    isBeforeEnd: (date: DateType, rangeValue: InterRangeValue) => boolean;
+    isStart: (date: DateType, rangeValue: InterRangeValue) => boolean;
+    isEnd: (date: DateType, rangeValue: InterRangeValue) => boolean;
+}): (date: DateType) => {};
+export {};

package/es/date-picker/hooks/use-range-cls.js

@@ -0,0 +1,42 @@
+import _defineProperty from "@babel/runtime-corejs3/helpers/defineProperty";
+import _findInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/find";
+import _filterInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/filter";
+import classnames from 'classnames';
+import { isAfter, isSameDay } from '../utils/date-fns';
+export default function useRangeCls(_ref) {
+  var prefixCls = _ref.prefixCls,
+      isRange = _ref.isRange,
+      rangeValue = _ref.rangeValue,
+      hoverRangedValue = _ref.hoverRangedValue,
+      isCurrentMonth = _ref.isCurrentMonth,
+      isAfterStart = _ref.isAfterStart,
+      isBeforeEnd = _ref.isBeforeEnd,
+      isStart = _ref.isStart,
+      isEnd = _ref.isEnd;
+
+  function getClassName(date) {
+    if (isRange) {
+      var _classnames;
+
+      var _rangeValue = rangeValue || [null, null];
+
+      if (hoverRangedValue === null || hoverRangedValue === void 0 ? void 0 : _findInstanceProperty(hoverRangedValue).call(hoverRangedValue, function (n) {
+        return n;
+      })) {
+        _rangeValue = hoverRangedValue;
+      }
+
+      if (_filterInstanceProperty(_rangeValue).call(_rangeValue, function (n) {
+        return n;
+      }).length !== _rangeValue.length) return {};
+      if (isSameDay(_rangeValue[0], _rangeValue[1])) return {};
+      if (isCurrentMonth && !isCurrentMonth(date)) return {};
+      if (_rangeValue[0] && _rangeValue[1] && isAfter(_rangeValue[0], _rangeValue[1])) return {};
+      return classnames((_classnames = {}, _defineProperty(_classnames, "".concat(prefixCls, "-range-view"), isAfterStart(date, _rangeValue) && isBeforeEnd(date, _rangeValue)), _defineProperty(_classnames, "".concat(prefixCls, "-range-start"), isStart(date, _rangeValue)), _defineProperty(_classnames, "".concat(prefixCls, "-range-end"), isEnd(date, _rangeValue)), _classnames));
+    }
+
+    return {};
+  }
+
+  return getClassName;
+}

package/es/date-picker/hooks/use-range-disabled.d.ts

@@ -0,0 +1,7 @@
+import { RangeValue, PickerMode, DateType } from '../interface';
+export default function useRangeDisabled({ picker, selectedValue, disabledDate, disabled, }: {
+    picker: PickerMode;
+    selectedValue: RangeValue;
+    disabledDate?: (date: DateType) => boolean;
+    disabled: [boolean, boolean];
+}, disabledStart: boolean, disabledEnd: boolean): ((date: DateType) => boolean)[];