@rc-component/picker 1.0.0

package/es/PickerPanel/TimePanel/TimePanelBody/index.js

@@ -0,0 +1,283 @@
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import * as React from 'react';
+import useTimeInfo from "../../../hooks/useTimeInfo";
+import { formatValue } from "../../../utils/dateUtil";
+import { PickerHackContext, usePanelContext } from "../../context";
+import TimeColumn from "./TimeColumn";
+function isAM(hour) {
+  return hour < 12;
+}
+export default function TimePanelBody(props) {
+  var showHour = props.showHour,
+    showMinute = props.showMinute,
+    showSecond = props.showSecond,
+    showMillisecond = props.showMillisecond,
+    showMeridiem = props.use12Hours,
+    changeOnScroll = props.changeOnScroll;
+  var _usePanelContext = usePanelContext(),
+    prefixCls = _usePanelContext.prefixCls,
+    values = _usePanelContext.values,
+    generateConfig = _usePanelContext.generateConfig,
+    locale = _usePanelContext.locale,
+    onSelect = _usePanelContext.onSelect,
+    _usePanelContext$onHo = _usePanelContext.onHover,
+    onHover = _usePanelContext$onHo === void 0 ? function () {} : _usePanelContext$onHo,
+    pickerValue = _usePanelContext.pickerValue;
+  var value = (values === null || values === void 0 ? void 0 : values[0]) || null;
+  var _React$useContext = React.useContext(PickerHackContext),
+    onCellDblClick = _React$useContext.onCellDblClick;
+
+  // ========================== Info ==========================
+  var _useTimeInfo = useTimeInfo(generateConfig, props, value),
+    _useTimeInfo2 = _slicedToArray(_useTimeInfo, 5),
+    getValidTime = _useTimeInfo2[0],
+    rowHourUnits = _useTimeInfo2[1],
+    getMinuteUnits = _useTimeInfo2[2],
+    getSecondUnits = _useTimeInfo2[3],
+    getMillisecondUnits = _useTimeInfo2[4];
+
+  // ========================= Value ==========================
+  // PickerValue will tell which one to align on the top
+  var getUnitValue = function getUnitValue(func) {
+    var valueUnitVal = value && generateConfig[func](value);
+    var pickerUnitValue = pickerValue && generateConfig[func](pickerValue);
+    return [valueUnitVal, pickerUnitValue];
+  };
+  var _getUnitValue = getUnitValue('getHour'),
+    _getUnitValue2 = _slicedToArray(_getUnitValue, 2),
+    hour = _getUnitValue2[0],
+    pickerHour = _getUnitValue2[1];
+  var _getUnitValue3 = getUnitValue('getMinute'),
+    _getUnitValue4 = _slicedToArray(_getUnitValue3, 2),
+    minute = _getUnitValue4[0],
+    pickerMinute = _getUnitValue4[1];
+  var _getUnitValue5 = getUnitValue('getSecond'),
+    _getUnitValue6 = _slicedToArray(_getUnitValue5, 2),
+    second = _getUnitValue6[0],
+    pickerSecond = _getUnitValue6[1];
+  var _getUnitValue7 = getUnitValue('getMillisecond'),
+    _getUnitValue8 = _slicedToArray(_getUnitValue7, 2),
+    millisecond = _getUnitValue8[0],
+    pickerMillisecond = _getUnitValue8[1];
+  var meridiem = hour === null ? null : isAM(hour) ? 'am' : 'pm';
+
+  // ========================= Column =========================
+  // Hours
+  var hourUnits = React.useMemo(function () {
+    if (!showMeridiem) {
+      return rowHourUnits;
+    }
+    return isAM(hour) ? rowHourUnits.filter(function (h) {
+      return isAM(h.value);
+    }) : rowHourUnits.filter(function (h) {
+      return !isAM(h.value);
+    });
+  }, [hour, rowHourUnits, showMeridiem]);
+
+  // >>> Pick Fallback
+  var getEnabled = function getEnabled(units, val) {
+    var _enabledUnits$;
+    var enabledUnits = units.filter(function (unit) {
+      return !unit.disabled;
+    });
+    return val !== null && val !== void 0 ? val : // Fallback to enabled value
+    enabledUnits === null || enabledUnits === void 0 || (_enabledUnits$ = enabledUnits[0]) === null || _enabledUnits$ === void 0 ? void 0 : _enabledUnits$.value;
+  };
+
+  // >>> Minutes
+  var validHour = getEnabled(rowHourUnits, hour);
+  var minuteUnits = React.useMemo(function () {
+    return getMinuteUnits(validHour);
+  }, [getMinuteUnits, validHour]);
+
+  // >>> Seconds
+  var validMinute = getEnabled(minuteUnits, minute);
+  var secondUnits = React.useMemo(function () {
+    return getSecondUnits(validHour, validMinute);
+  }, [getSecondUnits, validHour, validMinute]);
+
+  // >>> Milliseconds
+  var validSecond = getEnabled(secondUnits, second);
+  var millisecondUnits = React.useMemo(function () {
+    return getMillisecondUnits(validHour, validMinute, validSecond);
+  }, [getMillisecondUnits, validHour, validMinute, validSecond]);
+  var validMillisecond = getEnabled(millisecondUnits, millisecond);
+
+  // Meridiem
+  var meridiemUnits = React.useMemo(function () {
+    if (!showMeridiem) {
+      return [];
+    }
+    var base = generateConfig.getNow();
+    var amDate = generateConfig.setHour(base, 6);
+    var pmDate = generateConfig.setHour(base, 18);
+    var formatMeridiem = function formatMeridiem(date, defaultLabel) {
+      var cellMeridiemFormat = locale.cellMeridiemFormat;
+      return cellMeridiemFormat ? formatValue(date, {
+        generateConfig: generateConfig,
+        locale: locale,
+        format: cellMeridiemFormat
+      }) : defaultLabel;
+    };
+    return [{
+      label: formatMeridiem(amDate, 'AM'),
+      value: 'am',
+      disabled: rowHourUnits.every(function (h) {
+        return h.disabled || !isAM(h.value);
+      })
+    }, {
+      label: formatMeridiem(pmDate, 'PM'),
+      value: 'pm',
+      disabled: rowHourUnits.every(function (h) {
+        return h.disabled || isAM(h.value);
+      })
+    }];
+  }, [rowHourUnits, showMeridiem, generateConfig, locale]);
+
+  // ========================= Change =========================
+  /**
+   * Check if time is validate or will match to validate one
+   */
+  var triggerChange = function triggerChange(nextDate) {
+    var validateDate = getValidTime(nextDate);
+    onSelect(validateDate);
+  };
+
+  // ========================= Column =========================
+  // Create a template date for the trigger change event
+  var triggerDateTmpl = React.useMemo(function () {
+    var tmpl = value || pickerValue || generateConfig.getNow();
+    var isNotNull = function isNotNull(num) {
+      return num !== null && num !== undefined;
+    };
+    if (isNotNull(hour)) {
+      tmpl = generateConfig.setHour(tmpl, hour);
+      tmpl = generateConfig.setMinute(tmpl, minute);
+      tmpl = generateConfig.setSecond(tmpl, second);
+      tmpl = generateConfig.setMillisecond(tmpl, millisecond);
+    } else if (isNotNull(pickerHour)) {
+      tmpl = generateConfig.setHour(tmpl, pickerHour);
+      tmpl = generateConfig.setMinute(tmpl, pickerMinute);
+      tmpl = generateConfig.setSecond(tmpl, pickerSecond);
+      tmpl = generateConfig.setMillisecond(tmpl, pickerMillisecond);
+    } else if (isNotNull(validHour)) {
+      tmpl = generateConfig.setHour(tmpl, validHour);
+      tmpl = generateConfig.setMinute(tmpl, validMinute);
+      tmpl = generateConfig.setSecond(tmpl, validSecond);
+      tmpl = generateConfig.setMillisecond(tmpl, validMillisecond);
+    }
+    return tmpl;
+  }, [value, pickerValue, hour, minute, second, millisecond, validHour, validMinute, validSecond, validMillisecond, pickerHour, pickerMinute, pickerSecond, pickerMillisecond, generateConfig]);
+
+  // ===================== Columns Change =====================
+  var fillColumnValue = function fillColumnValue(val, func) {
+    if (val === null) {
+      return null;
+    }
+    return generateConfig[func](triggerDateTmpl, val);
+  };
+  var getNextHourTime = function getNextHourTime(val) {
+    return fillColumnValue(val, 'setHour');
+  };
+  var getNextMinuteTime = function getNextMinuteTime(val) {
+    return fillColumnValue(val, 'setMinute');
+  };
+  var getNextSecondTime = function getNextSecondTime(val) {
+    return fillColumnValue(val, 'setSecond');
+  };
+  var getNextMillisecondTime = function getNextMillisecondTime(val) {
+    return fillColumnValue(val, 'setMillisecond');
+  };
+  var getMeridiemTime = function getMeridiemTime(val) {
+    if (val === null) {
+      return null;
+    }
+    if (val === 'am' && !isAM(hour)) {
+      return generateConfig.setHour(triggerDateTmpl, hour - 12);
+    } else if (val === 'pm' && isAM(hour)) {
+      return generateConfig.setHour(triggerDateTmpl, hour + 12);
+    }
+    return triggerDateTmpl;
+  };
+  var onHourChange = function onHourChange(val) {
+    triggerChange(getNextHourTime(val));
+  };
+  var onMinuteChange = function onMinuteChange(val) {
+    triggerChange(getNextMinuteTime(val));
+  };
+  var onSecondChange = function onSecondChange(val) {
+    triggerChange(getNextSecondTime(val));
+  };
+  var onMillisecondChange = function onMillisecondChange(val) {
+    triggerChange(getNextMillisecondTime(val));
+  };
+  var onMeridiemChange = function onMeridiemChange(val) {
+    triggerChange(getMeridiemTime(val));
+  };
+
+  // ====================== Column Hover ======================
+  var onHourHover = function onHourHover(val) {
+    onHover(getNextHourTime(val));
+  };
+  var onMinuteHover = function onMinuteHover(val) {
+    onHover(getNextMinuteTime(val));
+  };
+  var onSecondHover = function onSecondHover(val) {
+    onHover(getNextSecondTime(val));
+  };
+  var onMillisecondHover = function onMillisecondHover(val) {
+    onHover(getNextMillisecondTime(val));
+  };
+  var onMeridiemHover = function onMeridiemHover(val) {
+    onHover(getMeridiemTime(val));
+  };
+
+  // ========================= Render =========================
+  var sharedColumnProps = {
+    onDblClick: onCellDblClick,
+    changeOnScroll: changeOnScroll
+  };
+  return /*#__PURE__*/React.createElement("div", {
+    className: "".concat(prefixCls, "-content")
+  }, showHour && /*#__PURE__*/React.createElement(TimeColumn, _extends({
+    units: hourUnits,
+    value: hour,
+    optionalValue: pickerHour,
+    type: "hour",
+    onChange: onHourChange,
+    onHover: onHourHover
+  }, sharedColumnProps)), showMinute && /*#__PURE__*/React.createElement(TimeColumn, _extends({
+    units: minuteUnits,
+    value: minute,
+    optionalValue: pickerMinute,
+    type: "minute",
+    onChange: onMinuteChange,
+    onHover: onMinuteHover
+  }, sharedColumnProps)), showSecond && /*#__PURE__*/React.createElement(TimeColumn, _extends({
+    units: secondUnits,
+    value: second,
+    optionalValue: pickerSecond,
+    type: "second",
+    onChange: onSecondChange,
+    onHover: onSecondHover
+  }, sharedColumnProps)), showMillisecond && /*#__PURE__*/React.createElement(TimeColumn, _extends({
+    units: millisecondUnits,
+    value: millisecond,
+    optionalValue: pickerMillisecond,
+    type: "millisecond",
+    onChange: onMillisecondChange,
+    onHover: onMillisecondHover
+  }, sharedColumnProps)), showMeridiem && /*#__PURE__*/React.createElement(TimeColumn, _extends({
+    units: meridiemUnits,
+    value: meridiem,
+    type: "meridiem",
+    onChange: onMeridiemChange,
+    onHover: onMeridiemHover
+  }, sharedColumnProps)));
+}

package/es/PickerPanel/TimePanel/TimePanelBody/useScrollTo.d.ts

@@ -0,0 +1,2 @@
+import * as React from 'react';
+export default function useScrollTo(ulRef: React.RefObject<HTMLUListElement>, value: number | string): [syncScroll: VoidFunction, clearScroll: VoidFunction, isScrolling: () => boolean];

package/es/PickerPanel/TimePanel/TimePanelBody/useScrollTo.js

@@ -0,0 +1,72 @@
+import { useEvent } from '@rc-component/util';
+import raf from "@rc-component/util/es/raf";
+import isVisible from "@rc-component/util/es/Dom/isVisible";
+import * as React from 'react';
+var SPEED_PTG = 1 / 3;
+export default function useScrollTo(ulRef, value) {
+  // ========================= Scroll =========================
+  var scrollingRef = React.useRef(false);
+  var scrollRafRef = React.useRef(null);
+  var scrollDistRef = React.useRef(null);
+  var isScrolling = function isScrolling() {
+    return scrollingRef.current;
+  };
+  var stopScroll = function stopScroll() {
+    raf.cancel(scrollRafRef.current);
+    scrollingRef.current = false;
+  };
+  var scrollRafTimesRef = React.useRef();
+  var startScroll = function startScroll() {
+    var ul = ulRef.current;
+    scrollDistRef.current = null;
+    scrollRafTimesRef.current = 0;
+    if (ul) {
+      var targetLi = ul.querySelector("[data-value=\"".concat(value, "\"]"));
+      var firstLi = ul.querySelector("li");
+      var doScroll = function doScroll() {
+        stopScroll();
+        scrollingRef.current = true;
+        scrollRafTimesRef.current += 1;
+        var currentTop = ul.scrollTop;
+        var firstLiTop = firstLi.offsetTop;
+        var targetLiTop = targetLi.offsetTop;
+        var targetTop = targetLiTop - firstLiTop;
+
+        // Wait for element exist. 5 frames is enough
+        if (targetLiTop === 0 && targetLi !== firstLi || !isVisible(ul)) {
+          if (scrollRafTimesRef.current <= 5) {
+            scrollRafRef.current = raf(doScroll);
+          }
+          return;
+        }
+        var nextTop = currentTop + (targetTop - currentTop) * SPEED_PTG;
+        var dist = Math.abs(targetTop - nextTop);
+
+        // Break if dist get larger, which means user is scrolling
+        if (scrollDistRef.current !== null && scrollDistRef.current < dist) {
+          stopScroll();
+          return;
+        }
+        scrollDistRef.current = dist;
+
+        // Stop when dist is less than 1
+        if (dist <= 1) {
+          ul.scrollTop = targetTop;
+          stopScroll();
+          return;
+        }
+
+        // IE not support `scrollTo`
+        ul.scrollTop = nextTop;
+        scrollRafRef.current = raf(doScroll);
+      };
+      if (targetLi && firstLi) {
+        doScroll();
+      }
+    }
+  };
+
+  // ======================== Trigger =========================
+  var syncScroll = useEvent(startScroll);
+  return [syncScroll, stopScroll, isScrolling];
+}

package/es/PickerPanel/TimePanel/TimePanelBody/util.d.ts

@@ -0,0 +1,3 @@
+import type { GenerateConfig } from '../../../generate';
+import type { Unit } from './TimeColumn';
+export declare function findValidateTime<DateType>(date: DateType, getHourUnits: () => Unit<number>[], getMinuteUnits: (hour: number) => Unit<number>[], getSecondUnits: (hour: number, minute: number) => Unit<number>[], getMillisecondUnits: (hour: number, minute: number, second: number) => Unit<number>[], generateConfig: GenerateConfig<DateType>): DateType;

package/es/PickerPanel/TimePanel/TimePanelBody/util.js

@@ -0,0 +1,43 @@
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+export function findValidateTime(date, getHourUnits, getMinuteUnits, getSecondUnits, getMillisecondUnits, generateConfig) {
+  var nextDate = date;
+  function alignValidate(getUnitValue, setUnitValue, units) {
+    var nextValue = generateConfig[getUnitValue](nextDate);
+    var nextUnit = units.find(function (unit) {
+      return unit.value === nextValue;
+    });
+    if (!nextUnit || nextUnit.disabled) {
+      // Find most closest unit
+      var validateUnits = units.filter(function (unit) {
+        return !unit.disabled;
+      });
+      var reverseEnabledUnits = _toConsumableArray(validateUnits).reverse();
+      var validateUnit = reverseEnabledUnits.find(function (unit) {
+        return unit.value <= nextValue;
+      }) || validateUnits[0];
+      if (validateUnit) {
+        nextValue = validateUnit.value;
+        nextDate = generateConfig[setUnitValue](nextDate, nextValue);
+      }
+    }
+    return nextValue;
+  }
+
+  // Find validate hour
+  var nextHour = alignValidate('getHour', 'setHour', getHourUnits());
+
+  // Find validate minute
+  var nextMinute = alignValidate('getMinute', 'setMinute', getMinuteUnits(nextHour));
+
+  // Find validate second
+  var nextSecond = alignValidate('getSecond', 'setSecond', getSecondUnits(nextHour, nextMinute));
+
+  // Find validate millisecond
+  alignValidate('getMillisecond', 'setMillisecond', getMillisecondUnits(nextHour, nextMinute, nextSecond));
+  return nextDate;
+}

package/es/PickerPanel/TimePanel/index.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+import type { SharedPanelProps } from '../../interface';
+export type TimePanelProps<DateType extends object> = SharedPanelProps<DateType>;
+export default function TimePanel<DateType extends object = any>(props: TimePanelProps<DateType>): React.JSX.Element;

package/es/PickerPanel/TimePanel/index.js

@@ -0,0 +1,38 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import classNames from 'classnames';
+import * as React from 'react';
+import { formatValue } from "../../utils/dateUtil";
+import { PanelContext, useInfo } from "../context";
+import PanelHeader from "../PanelHeader";
+import TimePanelBody from "./TimePanelBody";
+export default function TimePanel(props) {
+  var prefixCls = props.prefixCls,
+    value = props.value,
+    locale = props.locale,
+    generateConfig = props.generateConfig,
+    showTime = props.showTime;
+  var _ref = showTime || {},
+    format = _ref.format;
+  var panelPrefixCls = "".concat(prefixCls, "-time-panel");
+
+  // ========================== Base ==========================
+  var _useInfo = useInfo(props, 'time'),
+    _useInfo2 = _slicedToArray(_useInfo, 1),
+    info = _useInfo2[0];
+
+  // ========================= Render =========================
+  return /*#__PURE__*/React.createElement(PanelContext.Provider, {
+    value: info
+  }, /*#__PURE__*/React.createElement("div", {
+    className: classNames(panelPrefixCls)
+  }, /*#__PURE__*/React.createElement(PanelHeader, null, value ? formatValue(value, {
+    locale: locale,
+    format: format,
+    generateConfig: generateConfig
+  }) : "\xA0"), /*#__PURE__*/React.createElement(TimePanelBody, showTime)));
+}

package/es/PickerPanel/WeekPanel/index.d.ts

@@ -0,0 +1,3 @@
+import * as React from 'react';
+import type { SharedPanelProps } from '../../interface';
+export default function WeekPanel<DateType extends object = any>(props: SharedPanelProps<DateType>): React.JSX.Element;

package/es/PickerPanel/WeekPanel/index.js

@@ -0,0 +1,55 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import classNames from 'classnames';
+import * as React from 'react';
+import { isInRange, isSameWeek } from "../../utils/dateUtil";
+import DatePanel from "../DatePanel";
+export default function WeekPanel(props) {
+  var prefixCls = props.prefixCls,
+    generateConfig = props.generateConfig,
+    locale = props.locale,
+    value = props.value,
+    hoverValue = props.hoverValue,
+    hoverRangeValue = props.hoverRangeValue;
+
+  // =============================== Row ================================
+  var localeName = locale.locale;
+  var rowPrefixCls = "".concat(prefixCls, "-week-panel-row");
+  var rowClassName = function rowClassName(currentDate) {
+    var rangeCls = {};
+    if (hoverRangeValue) {
+      var _hoverRangeValue = _slicedToArray(hoverRangeValue, 2),
+        rangeStart = _hoverRangeValue[0],
+        rangeEnd = _hoverRangeValue[1];
+      var isRangeStart = isSameWeek(generateConfig, localeName, rangeStart, currentDate);
+      var isRangeEnd = isSameWeek(generateConfig, localeName, rangeEnd, currentDate);
+      rangeCls["".concat(rowPrefixCls, "-range-start")] = isRangeStart;
+      rangeCls["".concat(rowPrefixCls, "-range-end")] = isRangeEnd;
+      rangeCls["".concat(rowPrefixCls, "-range-hover")] = !isRangeStart && !isRangeEnd && isInRange(generateConfig, rangeStart, rangeEnd, currentDate);
+    }
+    if (hoverValue) {
+      rangeCls["".concat(rowPrefixCls, "-hover")] = hoverValue.some(function (date) {
+        return isSameWeek(generateConfig, localeName, currentDate, date);
+      });
+    }
+    return classNames(rowPrefixCls, _defineProperty({}, "".concat(rowPrefixCls, "-selected"), !hoverRangeValue && isSameWeek(generateConfig, localeName, value, currentDate)),
+    // Patch for hover range
+    rangeCls);
+  };
+
+  // ============================== Render ==============================
+  return /*#__PURE__*/React.createElement(DatePanel, _extends({}, props, {
+    mode: "week",
+    panelName: "week",
+    rowClassName: rowClassName
+  }));
+}

package/es/PickerPanel/YearPanel/index.d.ts

@@ -0,0 +1,3 @@
+import * as React from 'react';
+import type { SharedPanelProps } from '../../interface';
+export default function YearPanel<DateType extends object = any>(props: SharedPanelProps<DateType>): React.JSX.Element;

package/es/PickerPanel/YearPanel/index.js

@@ -0,0 +1,116 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import * as React from 'react';
+import { formatValue, isInRange, isSameYear } from "../../utils/dateUtil";
+import { PanelContext, useInfo } from "../context";
+import PanelBody from "../PanelBody";
+import PanelHeader from "../PanelHeader";
+export default function YearPanel(props) {
+  var prefixCls = props.prefixCls,
+    locale = props.locale,
+    generateConfig = props.generateConfig,
+    pickerValue = props.pickerValue,
+    disabledDate = props.disabledDate,
+    onPickerValueChange = props.onPickerValueChange,
+    onModeChange = props.onModeChange;
+  var panelPrefixCls = "".concat(prefixCls, "-year-panel");
+
+  // ========================== Base ==========================
+  var _useInfo = useInfo(props, 'year'),
+    _useInfo2 = _slicedToArray(_useInfo, 1),
+    info = _useInfo2[0];
+  var getStartYear = function getStartYear(date) {
+    var startYear = Math.floor(generateConfig.getYear(date) / 10) * 10;
+    return generateConfig.setYear(date, startYear);
+  };
+  var getEndYear = function getEndYear(date) {
+    var startYear = getStartYear(date);
+    return generateConfig.addYear(startYear, 9);
+  };
+  var startYearDate = getStartYear(pickerValue);
+  var endYearDate = getEndYear(pickerValue);
+  var baseDate = generateConfig.addYear(startYearDate, -1);
+
+  // ========================= Cells ==========================
+  var getCellDate = function getCellDate(date, offset) {
+    return generateConfig.addYear(date, offset);
+  };
+  var getCellText = function getCellText(date) {
+    return formatValue(date, {
+      locale: locale,
+      format: locale.cellYearFormat,
+      generateConfig: generateConfig
+    });
+  };
+  var getCellClassName = function getCellClassName(date) {
+    return _defineProperty({}, "".concat(prefixCls, "-cell-in-view"), isSameYear(generateConfig, date, startYearDate) || isSameYear(generateConfig, date, endYearDate) || isInRange(generateConfig, startYearDate, endYearDate, date));
+  };
+
+  // ======================== Disabled ========================
+  var mergedDisabledDate = disabledDate ? function (currentDate, disabledInfo) {
+    // Start
+    var startMonth = generateConfig.setMonth(currentDate, 0);
+    var startDate = generateConfig.setDate(startMonth, 1);
+
+    // End
+    var endMonth = generateConfig.addYear(startDate, 1);
+    var endDate = generateConfig.addDate(endMonth, -1);
+    return disabledDate(startDate, disabledInfo) && disabledDate(endDate, disabledInfo);
+  } : null;
+
+  // ========================= Header =========================
+  var yearNode = /*#__PURE__*/React.createElement("button", {
+    type: "button",
+    key: "decade",
+    "aria-label": locale.decadeSelect,
+    onClick: function onClick() {
+      onModeChange('decade');
+    },
+    tabIndex: -1,
+    className: "".concat(prefixCls, "-decade-btn")
+  }, formatValue(startYearDate, {
+    locale: locale,
+    format: locale.yearFormat,
+    generateConfig: generateConfig
+  }), "-", formatValue(endYearDate, {
+    locale: locale,
+    format: locale.yearFormat,
+    generateConfig: generateConfig
+  }));
+
+  // ========================= Render =========================
+  return /*#__PURE__*/React.createElement(PanelContext.Provider, {
+    value: info
+  }, /*#__PURE__*/React.createElement("div", {
+    className: panelPrefixCls
+  }, /*#__PURE__*/React.createElement(PanelHeader, {
+    superOffset: function superOffset(distance) {
+      return generateConfig.addYear(pickerValue, distance * 10);
+    },
+    onChange: onPickerValueChange
+    // Limitation
+    ,
+    getStart: getStartYear,
+    getEnd: getEndYear
+  }, yearNode), /*#__PURE__*/React.createElement(PanelBody, _extends({}, props, {
+    disabledDate: mergedDisabledDate,
+    titleFormat: locale.fieldYearFormat,
+    colNum: 3,
+    rowNum: 4,
+    baseDate: baseDate
+    // Body
+    ,
+    getCellDate: getCellDate,
+    getCellText: getCellText,
+    getCellClassName: getCellClassName
+  }))));
+}