acud 0.0.60

package/es/date-picker/src/panels/TimePanel/TimeBody.js

@@ -0,0 +1,211 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import * as React from 'react';
+import useMemo from "rc-util/es/hooks/useMemo";
+import TimeUnitColumn from './TimeUnitColumn';
+import { leftPad } from '../../utils/miscUtil';
+import { setTime as utilSetTime } from '../../utils/timeUtil';
+
+function shouldUnitsUpdate(prevUnits, nextUnits) {
+  if (prevUnits.length !== nextUnits.length) return true; // if any unit's disabled status is different, the units should be re-evaluted
+
+  for (var i = 0; i < prevUnits.length; i += 1) {
+    if (prevUnits[i].disabled !== nextUnits[i].disabled) return true;
+  }
+
+  return false;
+}
+
+function generateUnits(start, end, step, disabledUnits) {
+  var units = [];
+
+  for (var i = start; i <= end; i += step) {
+    units.push({
+      label: leftPad(i, 2),
+      value: i,
+      disabled: (disabledUnits || []).includes(i)
+    });
+  }
+
+  return units;
+}
+
+function TimeBody(props) {
+  var generateConfig = props.generateConfig,
+      prefixCls = props.prefixCls,
+      operationRef = props.operationRef,
+      activeColumnIndex = props.activeColumnIndex,
+      value = props.value,
+      showHour = props.showHour,
+      showMinute = props.showMinute,
+      showSecond = props.showSecond,
+      use12Hours = props.use12Hours,
+      _props$hourStep = props.hourStep,
+      hourStep = _props$hourStep === void 0 ? 1 : _props$hourStep,
+      _props$minuteStep = props.minuteStep,
+      minuteStep = _props$minuteStep === void 0 ? 1 : _props$minuteStep,
+      _props$secondStep = props.secondStep,
+      secondStep = _props$secondStep === void 0 ? 1 : _props$secondStep,
+      disabledHours = props.disabledHours,
+      disabledMinutes = props.disabledMinutes,
+      disabledSeconds = props.disabledSeconds,
+      hideDisabledOptions = props.hideDisabledOptions,
+      onSelect = props.onSelect;
+  var columns = [];
+  var contentPrefixCls = "".concat(prefixCls, "-content");
+  var columnPrefixCls = "".concat(prefixCls, "-time-panel");
+  var isPM;
+  var originHour = value ? generateConfig.getHour(value) : -1;
+  var hour = originHour;
+  var minute = value ? generateConfig.getMinute(value) : -1;
+  var second = value ? generateConfig.getSecond(value) : -1;
+
+  var setTime = function setTime(isNewPM, newHour, newMinute, newSecond) {
+    var newDate = value || generateConfig.getNow();
+    var mergedHour = Math.max(0, newHour);
+    var mergedMinute = Math.max(0, newMinute);
+    var mergedSecond = Math.max(0, newSecond);
+    newDate = utilSetTime(generateConfig, newDate, !use12Hours || !isNewPM ? mergedHour : mergedHour + 12, mergedMinute, mergedSecond);
+    return newDate;
+  }; // ========================= Unit =========================
+
+
+  var rawHours = generateUnits(0, 23, hourStep, disabledHours && disabledHours());
+  var memorizedRawHours = useMemo(function () {
+    return rawHours;
+  }, rawHours, shouldUnitsUpdate); // Should additional logic to handle 12 hours
+
+  if (use12Hours) {
+    isPM = hour >= 12; // -1 means should display AM
+
+    hour %= 12;
+  }
+
+  var _React$useMemo = React.useMemo(function () {
+    if (!use12Hours) {
+      return [false, false];
+    }
+
+    var AMPMDisabled = [true, true];
+    memorizedRawHours.forEach(function (_ref) {
+      var disabled = _ref.disabled,
+          hourValue = _ref.value;
+      if (disabled) return;
+
+      if (hourValue >= 12) {
+        AMPMDisabled[1] = false;
+      } else {
+        AMPMDisabled[0] = false;
+      }
+    });
+    return AMPMDisabled;
+  }, [use12Hours, memorizedRawHours]),
+      _React$useMemo2 = _slicedToArray(_React$useMemo, 2),
+      AMDisabled = _React$useMemo2[0],
+      PMDisabled = _React$useMemo2[1];
+
+  var hours = React.useMemo(function () {
+    if (!use12Hours) return memorizedRawHours;
+    return memorizedRawHours.filter(isPM ? function (hourMeta) {
+      return hourMeta.value >= 12;
+    } : function (hourMeta) {
+      return hourMeta.value < 12;
+    }).map(function (hourMeta) {
+      var hourValue = hourMeta.value % 12;
+      var hourLabel = hourValue === 0 ? '12' : leftPad(hourValue, 2);
+      return _extends(_extends({}, hourMeta), {
+        label: hourLabel,
+        value: hourValue
+      });
+    });
+  }, [use12Hours, isPM, memorizedRawHours]);
+  var minutes = generateUnits(0, 59, minuteStep, disabledMinutes && disabledMinutes(originHour));
+  var seconds = generateUnits(0, 59, secondStep, disabledSeconds && disabledSeconds(originHour, minute)); // ====================== Operations ======================
+
+  operationRef.current = {
+    onUpDown: function onUpDown(diff) {
+      var column = columns[activeColumnIndex];
+
+      if (column) {
+        var valueIndex = column.units.findIndex(function (unit) {
+          return unit.value === column.value;
+        });
+        var unitLen = column.units.length;
+
+        for (var i = 1; i < unitLen; i += 1) {
+          var nextUnit = column.units[(valueIndex + diff * i + unitLen) % unitLen];
+
+          if (nextUnit.disabled !== true) {
+            column.onSelect(nextUnit.value);
+            break;
+          }
+        }
+      }
+    }
+  }; // ======================== Render ========================
+
+  function addColumnNode(condition, node, columnValue, units, onColumnSelect) {
+    if (condition !== false) {
+      columns.push({
+        node: /*#__PURE__*/React.cloneElement(node, {
+          prefixCls: columnPrefixCls,
+          value: columnValue,
+          active: activeColumnIndex === columns.length,
+          onSelect: onColumnSelect,
+          units: units,
+          hideDisabledOptions: hideDisabledOptions
+        }),
+        onSelect: onColumnSelect,
+        value: columnValue,
+        units: units
+      });
+    }
+  } // Hour
+
+
+  addColumnNode(showHour, /*#__PURE__*/React.createElement(TimeUnitColumn, {
+    key: "hour"
+  }), hour, hours, function (num) {
+    onSelect(setTime(isPM, num, minute, second), 'mouse');
+  }); // Minute
+
+  addColumnNode(showMinute, /*#__PURE__*/React.createElement(TimeUnitColumn, {
+    key: "minute"
+  }), minute, minutes, function (num) {
+    onSelect(setTime(isPM, hour, num, second), 'mouse');
+  }); // Second
+
+  addColumnNode(showSecond, /*#__PURE__*/React.createElement(TimeUnitColumn, {
+    key: "second"
+  }), second, seconds, function (num) {
+    onSelect(setTime(isPM, hour, minute, num), 'mouse');
+  }); // 12 Hours
+
+  var PMIndex = -1;
+
+  if (typeof isPM === 'boolean') {
+    PMIndex = isPM ? 1 : 0;
+  }
+
+  addColumnNode(use12Hours === true, /*#__PURE__*/React.createElement(TimeUnitColumn, {
+    key: "12hours"
+  }), PMIndex, [{
+    label: 'AM',
+    value: 0,
+    disabled: AMDisabled
+  }, {
+    label: 'PM',
+    value: 1,
+    disabled: PMDisabled
+  }], function (num) {
+    onSelect(setTime(!!num, hour, minute, second), 'mouse');
+  });
+  return /*#__PURE__*/React.createElement("div", {
+    className: contentPrefixCls
+  }, columns.map(function (_ref2) {
+    var node = _ref2.node;
+    return node;
+  }));
+}
+
+export default TimeBody;

package/es/date-picker/src/panels/TimePanel/TimeHeader.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import type { Locale } from '../../interface';
+import type { GenerateConfig } from '../../generate';
+export declare type TimeHeaderProps<DateType> = {
+    prefixCls: string;
+    value?: DateType | null;
+    locale: Locale;
+    generateConfig: GenerateConfig<DateType>;
+    format: string;
+};
+declare function TimeHeader<DateType>(props: TimeHeaderProps<DateType>): JSX.Element;
+export default TimeHeader;

package/es/date-picker/src/panels/TimePanel/TimeHeader.js

@@ -0,0 +1,29 @@
+import * as React from 'react';
+import Header from '../Header';
+import PanelContext from '../../PanelContext';
+import { formatValue } from '../../utils/dateUtil';
+
+function TimeHeader(props) {
+  var _React$useContext = React.useContext(PanelContext),
+      hideHeader = _React$useContext.hideHeader;
+
+  if (hideHeader) {
+    return null;
+  }
+
+  var prefixCls = props.prefixCls,
+      generateConfig = props.generateConfig,
+      locale = props.locale,
+      value = props.value,
+      format = props.format;
+  var headerPrefixCls = "".concat(prefixCls, "-header");
+  return /*#__PURE__*/React.createElement(Header, {
+    prefixCls: headerPrefixCls
+  }, value ? formatValue(value, {
+    locale: locale,
+    format: format,
+    generateConfig: generateConfig
+  }) : '时间选择器');
+}
+
+export default TimeHeader;

package/es/date-picker/src/panels/TimePanel/TimeUnitColumn.d.ts

@@ -0,0 +1,16 @@
+import * as React from 'react';
+export declare type Unit = {
+    label: React.ReactText;
+    value: number;
+    disabled: boolean;
+};
+export declare type TimeUnitColumnProps = {
+    prefixCls?: string;
+    units?: Unit[];
+    value?: number;
+    active?: boolean;
+    hideDisabledOptions?: boolean;
+    onSelect?: (value: number) => void;
+};
+declare function TimeUnitColumn(props: TimeUnitColumnProps): JSX.Element;
+export default TimeUnitColumn;

package/es/date-picker/src/panels/TimePanel/TimeUnitColumn.js

@@ -0,0 +1,80 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import * as React from 'react';
+import { useRef, useLayoutEffect } from 'react';
+import classNames from 'classnames';
+import { scrollTo, waitElementReady } from '../../utils/uiUtil';
+import PanelContext from '../../PanelContext';
+
+function TimeUnitColumn(props) {
+  var prefixCls = props.prefixCls,
+      units = props.units,
+      onSelect = props.onSelect,
+      value = props.value,
+      active = props.active,
+      hideDisabledOptions = props.hideDisabledOptions;
+  var cellPrefixCls = "".concat(prefixCls, "-cell");
+
+  var _React$useContext = React.useContext(PanelContext),
+      open = _React$useContext.open;
+
+  var ulRef = useRef(null);
+  var liRefs = useRef(new Map());
+  var scrollRef = useRef(); // `useLayoutEffect` here to avoid blink by duration is 0
+
+  useLayoutEffect(function () {
+    var li = liRefs.current.get(value);
+
+    if (li && open !== false) {
+      scrollTo(ulRef.current, li.offsetTop, 120);
+    }
+  }, [value]);
+  useLayoutEffect(function () {
+    if (open) {
+      var li = liRefs.current.get(value);
+
+      if (li) {
+        scrollRef.current = waitElementReady(li, function () {
+          scrollTo(ulRef.current, li.offsetTop, 0);
+        });
+      }
+    }
+
+    return function () {
+      var _a;
+
+      (_a = scrollRef.current) === null || _a === void 0 ? void 0 : _a.call(scrollRef);
+    };
+  }, [open]);
+  return /*#__PURE__*/React.createElement("ul", {
+    className: classNames("".concat(prefixCls, "-column"), _defineProperty({}, "".concat(prefixCls, "-column-active"), active)),
+    ref: ulRef,
+    style: {
+      position: 'relative'
+    }
+  }, units.map(function (unit) {
+    var _classNames2;
+
+    if (hideDisabledOptions && unit.disabled) {
+      return null;
+    }
+
+    return /*#__PURE__*/React.createElement("li", {
+      key: unit.value,
+      ref: function ref(element) {
+        liRefs.current.set(unit.value, element);
+      },
+      className: classNames(cellPrefixCls, (_classNames2 = {}, _defineProperty(_classNames2, "".concat(cellPrefixCls, "-disabled"), unit.disabled), _defineProperty(_classNames2, "".concat(cellPrefixCls, "-selected"), value === unit.value), _classNames2)),
+      onClick: function onClick() {
+        if (unit.disabled) {
+          return;
+        }
+
+        onSelect(unit.value);
+      }
+    }, /*#__PURE__*/React.createElement("div", {
+      className: "".concat(cellPrefixCls, "-inner")
+    }, unit.label));
+  }));
+}
+
+export default TimeUnitColumn;

package/es/date-picker/src/panels/TimePanel/index.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="react" />
+import type { PanelSharedProps, DisabledTimes } from '../../interface';
+export declare type SharedTimeProps<DateType> = {
+    format?: string;
+    showNow?: boolean;
+    showHour?: boolean;
+    showMinute?: boolean;
+    showSecond?: boolean;
+    use12Hours?: boolean;
+    hourStep?: number;
+    minuteStep?: number;
+    secondStep?: number;
+    hideDisabledOptions?: boolean;
+    defaultValue?: DateType;
+} & DisabledTimes;
+export declare type TimePanelProps<DateType> = {
+    format?: string;
+    active?: boolean;
+} & PanelSharedProps<DateType> & SharedTimeProps<DateType>;
+declare function TimePanel<DateType>(props: TimePanelProps<DateType>): JSX.Element;
+export default TimePanel;

package/es/date-picker/src/panels/TimePanel/index.js

@@ -0,0 +1,74 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import * as React from 'react';
+import classNames from 'classnames';
+import TimeHeader from './TimeHeader';
+import TimeBody from './TimeBody';
+import { createKeyDownHandler } from '../../utils/uiUtil';
+
+var countBoolean = function countBoolean(boolList) {
+  return boolList.filter(function (bool) {
+    return bool !== false;
+  }).length;
+};
+
+function TimePanel(props) {
+  var generateConfig = props.generateConfig,
+      _props$format = props.format,
+      format = _props$format === void 0 ? 'HH:mm:ss' : _props$format,
+      prefixCls = props.prefixCls,
+      active = props.active,
+      operationRef = props.operationRef,
+      showHour = props.showHour,
+      showMinute = props.showMinute,
+      showSecond = props.showSecond,
+      _props$use12Hours = props.use12Hours,
+      use12Hours = _props$use12Hours === void 0 ? false : _props$use12Hours,
+      onSelect = props.onSelect,
+      value = props.value;
+  var panelPrefixCls = "".concat(prefixCls, "-time-panel");
+  var bodyOperationRef = React.useRef(); // ======================= Keyboard =======================
+
+  var _React$useState = React.useState(-1),
+      _React$useState2 = _slicedToArray(_React$useState, 2),
+      activeColumnIndex = _React$useState2[0],
+      setActiveColumnIndex = _React$useState2[1];
+
+  var columnsCount = countBoolean([showHour, showMinute, showSecond, use12Hours]);
+  operationRef.current = {
+    onKeyDown: function onKeyDown(event) {
+      return createKeyDownHandler(event, {
+        onLeftRight: function onLeftRight(diff) {
+          setActiveColumnIndex((activeColumnIndex + diff + columnsCount) % columnsCount);
+        },
+        onUpDown: function onUpDown(diff) {
+          if (activeColumnIndex === -1) {
+            setActiveColumnIndex(0);
+          } else if (bodyOperationRef.current) {
+            bodyOperationRef.current.onUpDown(diff);
+          }
+        },
+        onEnter: function onEnter() {
+          onSelect(value || generateConfig.getNow(), 'key');
+          setActiveColumnIndex(-1);
+        }
+      });
+    },
+    onBlur: function onBlur() {
+      setActiveColumnIndex(-1);
+    }
+  };
+  return /*#__PURE__*/React.createElement("div", {
+    className: classNames(panelPrefixCls, _defineProperty({}, "".concat(panelPrefixCls, "-active"), active))
+  }, /*#__PURE__*/React.createElement(TimeHeader, _extends({}, props, {
+    format: format,
+    prefixCls: prefixCls
+  })), /*#__PURE__*/React.createElement(TimeBody, _extends({}, props, {
+    prefixCls: prefixCls,
+    activeColumnIndex: activeColumnIndex,
+    operationRef: bodyOperationRef
+  })));
+}
+
+export default TimePanel;

package/es/date-picker/src/panels/WeekPanel/index.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import type { PanelSharedProps } from '../../interface';
+export declare type WeekPanelProps<DateType> = PanelSharedProps<DateType>;
+declare function WeekPanel<DateType>(props: WeekPanelProps<DateType>): JSX.Element;
+export default WeekPanel;

package/es/date-picker/src/panels/WeekPanel/index.js

@@ -0,0 +1,40 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import * as React from 'react';
+import classNames from 'classnames';
+import DatePanel from '../DatePanel';
+import { isSameWeek } from '../../utils/dateUtil';
+
+function WeekPanel(props) {
+  var prefixCls = props.prefixCls,
+      generateConfig = props.generateConfig,
+      locale = props.locale,
+      value = props.value; // Render additional column
+
+  var cellPrefixCls = "".concat(prefixCls, "-cell");
+
+  var prefixColumn = function prefixColumn(date) {
+    return /*#__PURE__*/React.createElement("td", {
+      key: "week",
+      className: classNames(cellPrefixCls, "".concat(cellPrefixCls, "-week"))
+    }, generateConfig.locale.getWeek(locale.locale, date));
+  }; // Add row className
+
+
+  var rowPrefixCls = "".concat(prefixCls, "-week-panel-row");
+
+  var rowClassName = function rowClassName(date) {
+    return classNames(rowPrefixCls, _defineProperty({}, "".concat(rowPrefixCls, "-selected"), isSameWeek(generateConfig, locale.locale, value, date)));
+  };
+
+  return /*#__PURE__*/React.createElement(DatePanel, _extends({}, props, {
+    panelName: "week",
+    prefixColumn: prefixColumn,
+    rowClassName: rowClassName,
+    keyboardConfig: {
+      onLeftRight: null
+    }
+  }));
+}
+
+export default WeekPanel;

package/es/date-picker/src/panels/YearPanel/YearBody.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="react" />
+import type { GenerateConfig } from '../../generate';
+import type { Locale, NullableDateType } from '../../interface';
+export declare const YEAR_COL_COUNT = 3;
+export declare type YearBodyProps<DateType> = {
+    prefixCls: string;
+    locale: Locale;
+    generateConfig: GenerateConfig<DateType>;
+    value?: NullableDateType<DateType>;
+    viewDate: DateType;
+    disabledDate?: (date: DateType) => boolean;
+    onSelect: (value: DateType) => void;
+};
+declare function YearBody<DateType>(props: YearBodyProps<DateType>): JSX.Element;
+export default YearBody;

package/es/date-picker/src/panels/YearPanel/YearBody.js

@@ -0,0 +1,65 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import { YEAR_DECADE_COUNT } from '.';
+import useCellClassName from '../../hooks/useCellClassName';
+import { formatValue, isSameYear } from '../../utils/dateUtil';
+import RangeContext from '../../RangeContext';
+import PanelBody from '../PanelBody';
+export var YEAR_COL_COUNT = 3;
+var YEAR_ROW_COUNT = 4;
+
+function YearBody(props) {
+  var prefixCls = props.prefixCls,
+      value = props.value,
+      viewDate = props.viewDate,
+      locale = props.locale,
+      generateConfig = props.generateConfig;
+
+  var _React$useContext = React.useContext(RangeContext),
+      rangedValue = _React$useContext.rangedValue,
+      hoverRangedValue = _React$useContext.hoverRangedValue;
+
+  var yearPrefixCls = "".concat(prefixCls, "-cell"); // =============================== Year ===============================
+
+  var yearNumber = generateConfig.getYear(viewDate);
+  var startYear = Math.floor(yearNumber / YEAR_DECADE_COUNT) * YEAR_DECADE_COUNT;
+  var endYear = startYear + YEAR_DECADE_COUNT - 1;
+  var baseYear = generateConfig.setYear(viewDate, startYear - Math.ceil((YEAR_COL_COUNT * YEAR_ROW_COUNT - YEAR_DECADE_COUNT) / 2));
+
+  var isInView = function isInView(date) {
+    var currentYearNumber = generateConfig.getYear(date);
+    return startYear <= currentYearNumber && currentYearNumber <= endYear;
+  };
+
+  var getCellClassName = useCellClassName({
+    cellPrefixCls: yearPrefixCls,
+    value: value,
+    generateConfig: generateConfig,
+    rangedValue: rangedValue,
+    hoverRangedValue: hoverRangedValue,
+    isSameCell: function isSameCell(current, target) {
+      return isSameYear(generateConfig, current, target);
+    },
+    isInView: isInView,
+    offsetCell: function offsetCell(date, offset) {
+      return generateConfig.addYear(date, offset);
+    }
+  });
+  return /*#__PURE__*/React.createElement(PanelBody, _extends({}, props, {
+    rowNum: YEAR_ROW_COUNT,
+    colNum: YEAR_COL_COUNT,
+    baseDate: baseYear,
+    getCellText: generateConfig.getYear,
+    getCellClassName: getCellClassName,
+    getCellDate: generateConfig.addYear,
+    titleCell: function titleCell(date) {
+      return formatValue(date, {
+        locale: locale,
+        format: 'YYYY',
+        generateConfig: generateConfig
+      });
+    }
+  }));
+}
+
+export default YearBody;

package/es/date-picker/src/panels/YearPanel/YearHeader.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+import type { GenerateConfig } from '../../generate';
+export declare type YearHeaderProps<DateType> = {
+    prefixCls: string;
+    viewDate: DateType;
+    value?: DateType | null;
+    generateConfig: GenerateConfig<DateType>;
+    onPrevDecade: () => void;
+    onNextDecade: () => void;
+    onDecadeClick: () => void;
+};
+declare function YearHeader<DateType>(props: YearHeaderProps<DateType>): JSX.Element;
+export default YearHeader;

package/es/date-picker/src/panels/YearPanel/YearHeader.js

@@ -0,0 +1,37 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import * as React from 'react';
+import Header from '../Header';
+import { YEAR_DECADE_COUNT } from '.';
+import PanelContext from '../../PanelContext';
+
+function YearHeader(props) {
+  var prefixCls = props.prefixCls,
+      generateConfig = props.generateConfig,
+      viewDate = props.viewDate,
+      onPrevDecade = props.onPrevDecade,
+      onNextDecade = props.onNextDecade,
+      onDecadeClick = props.onDecadeClick;
+
+  var _React$useContext = React.useContext(PanelContext),
+      hideHeader = _React$useContext.hideHeader;
+
+  if (hideHeader) {
+    return null;
+  }
+
+  var headerPrefixCls = "".concat(prefixCls, "-header");
+  var yearNumber = generateConfig.getYear(viewDate);
+  var startYear = Math.floor(yearNumber / YEAR_DECADE_COUNT) * YEAR_DECADE_COUNT;
+  var endYear = startYear + YEAR_DECADE_COUNT - 1;
+  return /*#__PURE__*/React.createElement(Header, _extends({}, props, {
+    prefixCls: headerPrefixCls,
+    onSuperPrev: onPrevDecade,
+    onSuperNext: onNextDecade
+  }), /*#__PURE__*/React.createElement("button", {
+    type: "button",
+    onClick: onDecadeClick,
+    className: "".concat(prefixCls, "-decade-btn")
+  }, startYear, "-", endYear));
+}
+
+export default YearHeader;

package/es/date-picker/src/panels/YearPanel/index.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import type { PanelSharedProps, PanelMode } from '../../interface';
+export declare type YearPanelProps<DateType> = {
+    sourceMode: PanelMode;
+} & PanelSharedProps<DateType>;
+export declare const YEAR_DECADE_COUNT = 10;
+declare function YearPanel<DateType>(props: YearPanelProps<DateType>): JSX.Element;
+export default YearPanel;