@seafile/seafile-calendar 0.0.2 → 0.0.3-Apoi0.1

package/es/decade/DecadePanel.js

@@ -9,7 +9,7 @@ import classnames from 'classnames';
 
 function goYear(direction) {
   var next = this.state.value.clone();
-  next.add(direction, 'years');
+  next = next.add(direction, 'years');
   this.setState({
     value: next
   });
@@ -17,8 +17,8 @@ function goYear(direction) {
 
 function chooseDecade(year, event) {
   var next = this.state.value.clone();
-  next.year(year);
-  next.month(this.state.value.month());
+  next = next.year(year);
+  next = next.month(this.state.value.month());
   this.props.onSelect(next);
   event.preventDefault();
 }

package/es/full-calendar/CalendarHeader.js

@@ -18,13 +18,13 @@ var CalendarHeader = function (_Component) {
 
   CalendarHeader.prototype.onYearChange = function onYearChange(year) {
     var newValue = this.props.value.clone();
-    newValue.year(parseInt(year, 10));
+    newValue = newValue.year(parseInt(year, 10));
     this.props.onValueChange(newValue);
   };
 
   CalendarHeader.prototype.onMonthChange = function onMonthChange(month) {
     var newValue = this.props.value.clone();
-    newValue.month(parseInt(month, 10));
+    newValue = newValue.month(parseInt(month, 10));
     this.props.onValueChange(newValue);
   };
 
@@ -70,7 +70,7 @@ var CalendarHeader = function (_Component) {
     var Select = props.Select;
 
     for (var index = 0; index < 12; index++) {
-      t.month(index);
+      t = t.month(index);
       options.push(React.createElement(
         Select.Option,
         { key: '' + index },

package/es/mixin/CalendarMixin.js

@@ -4,7 +4,7 @@ import _inherits from 'babel-runtime/helpers/inherits';
 import React from 'react';
 import PropTypes from 'prop-types';
 import classnames from 'classnames';
-import moment from 'moment';
+import dayjs from 'dayjs';
 import { isAllowedDate, getTodayTime } from '../util/index';
 
 function noop() {}
@@ -14,7 +14,7 @@ export function getNowByCurrentStateValue(value) {
   if (value) {
     ret = getTodayTime(value);
   } else {
-    ret = moment();
+    ret = dayjs();
   }
   return ret;
 }

package/es/month/MonthTable.js

@@ -11,7 +11,7 @@ var COL = 3;
 
 function chooseMonth(month) {
   var next = this.state.value.clone();
-  next.month(month);
+  next = next.month(month);
   this.setAndSelectValue(next);
 }
 
@@ -54,7 +54,7 @@ var MonthTable = function (_Component) {
     for (var rowIndex = 0; rowIndex < ROW; rowIndex++) {
       months[rowIndex] = [];
       for (var colIndex = 0; colIndex < COL; colIndex++) {
-        current.month(index);
+        current = current.month(index);
         var content = getMonthName(current);
         months[rowIndex][colIndex] = {
           value: index,
@@ -87,20 +87,20 @@ var MonthTable = function (_Component) {
         var disabled = false;
         if (props.disabledDate) {
           var testValue = value.clone();
-          testValue.month(monthData.value);
+          testValue = testValue.month(monthData.value);
           disabled = props.disabledDate(testValue);
         }
         var classNameMap = (_classNameMap = {}, _classNameMap[prefixCls + '-cell'] = 1, _classNameMap[prefixCls + '-cell-disabled'] = disabled, _classNameMap[prefixCls + '-selected-cell'] = monthData.value === currentMonth, _classNameMap[prefixCls + '-current-cell'] = today.year() === value.year() && monthData.value === today.month(), _classNameMap);
         var cellEl = void 0;
         if (cellRender) {
           var currentValue = value.clone();
-          currentValue.month(monthData.value);
+          currentValue = currentValue.month(monthData.value);
           cellEl = cellRender(currentValue, locale);
         } else {
           var content = void 0;
           if (contentRender) {
             var _currentValue = value.clone();
-            _currentValue.month(monthData.value);
+            _currentValue = _currentValue.month(monthData.value);
             content = contentRender(_currentValue, locale);
           } else {
             content = monthData.content;

package/es/util/dayjs.js

@@ -0,0 +1,17 @@
+import dayjs from 'dayjs';
+import localeData from 'dayjs/plugin/localeData';
+import weekOfYear from 'dayjs/plugin/weekOfYear';
+import utc from 'dayjs/plugin/utc';
+import advancedFormat from 'dayjs/plugin/advancedFormat';
+import customParseFormat from 'dayjs/plugin/customParseFormat';
+import badMutable from 'dayjs/plugin/badMutable';
+import 'dayjs/locale/zh-cn';
+import 'dayjs/locale/en-gb';
+
+dayjs.extend(localeData);
+dayjs.extend(weekOfYear);
+dayjs.extend(utc);
+dayjs.extend(advancedFormat);
+dayjs.extend(customParseFormat);
+dayjs.extend(badMutable);
+export default dayjs;

package/es/util/index.js

@@ -1,5 +1,31 @@
 import _extends from 'babel-runtime/helpers/extends';
-import moment from 'moment';
+import dayjs from 'dayjs';
+import utc from 'dayjs/plugin/utc';
+
+dayjs.extend(utc);
+export var getCurrentDate = function getCurrentDate() {
+  return dayjs().date();
+};
+export var getCurrentMonth = function getCurrentMonth() {
+  return dayjs().month() + 1;
+};
+export var getCurrentYear = function getCurrentYear() {
+  return dayjs().year();
+};
+export var getCurrentTime = function getCurrentTime() {
+  return dayjs().format('HH:mm');
+};
+
+export var DATE_FORMATS = {
+  ISO: 'YYYY-MM-DD',
+  ISOAndTime: 'YYYY-MM-DD HH:mm',
+  US: 'M/D/YYYY',
+  USAndTime: 'M/D/YYYY HH:mm',
+  European: 'DD/MM/YYYY',
+  EuropeanAndTime: 'DD/MM/YYYY HH:mm',
+  Germany_Russia_etc: 'DD.MM.YYYY',
+  Germany_Russia_etcAndTime: 'DD.MM.YYYY HH:mm'
+};
 
 var defaultDisabledTime = {
   disabledHours: function disabledHours() {
@@ -14,8 +40,8 @@ var defaultDisabledTime = {
 };
 
 export function getTodayTime(value) {
-  var today = moment();
-  today.locale(value.locale()).utcOffset(value.utcOffset());
+  var today = dayjs();
+  today = today.locale(value.locale()).utcOffset(value.utcOffset());
   return today;
 }
 
@@ -35,11 +61,11 @@ export function getMonthName(month) {
 }
 
 export function syncTime(from, to) {
-  if (!moment.isMoment(from) || !moment.isMoment(to)) return;
-  to.hour(from.hour());
-  to.minute(from.minute());
-  to.second(from.second());
-  to.millisecond(from.millisecond());
+  if (!dayjs.isDayjs(from) || !dayjs.isDayjs(to)) return;
+  to = to.hour(from.hour());
+  to = to.minute(from.minute());
+  to = to.second(from.second());
+  to = to.millisecond(from.millisecond());
 }
 
 export function getTimeConfig(value, disabledTime) {
@@ -99,4 +125,421 @@ export function formatDate(value, format) {
   }
 
   return value.format(format);
+}
+
+export var isLeapYear = function isLeapYear(year) {
+  return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
+};
+
+export function validateCalendarDay(dayStr) {
+  if (!/^\d+$/.test(dayStr)) return false;
+  var day = Number(dayStr);
+  var MONTHS_WITH_31_DAYS = [1, 3, 5, 7, 8, 10, 12];
+  var MONTHS_WITH_30_DAYS = [4, 6, 9, 11];
+  if (MONTHS_WITH_31_DAYS.includes(getCurrentMonth())) {
+    return day >= 1 && day <= 31;
+  }
+  if (MONTHS_WITH_30_DAYS.includes(getCurrentMonth())) {
+    return day >= 1 && day <= 30;
+  }
+  if (getCurrentMonth() === 2) {
+    var year = getCurrentYear();
+    if (isLeapYear(year)) {
+      return day >= 1 && day <= 29;
+    }
+    return day >= 1 && day <= 28;
+  }
+}
+
+export function tokenizeFormattedDate(formatStr, format) {
+  var str = formatStr || '';
+  var cleanStr = void 0;
+  switch (format) {
+    case DATE_FORMATS.ISO:
+    case DATE_FORMATS.ISOAndTime:
+      cleanStr = str.replace(/[^0-9]+/g, '-');
+      return cleanStr.split('-').filter(Boolean).map(String);
+    case DATE_FORMATS.US:
+    case DATE_FORMATS.USAndTime:
+    case DATE_FORMATS.European:
+    case DATE_FORMATS.EuropeanAndTime:
+      cleanStr = str.replace(/[^0-9]+/g, '/');
+      return cleanStr.split('/').filter(Boolean).map(String);
+    case DATE_FORMATS.Germany_Russia_etc:
+    case DATE_FORMATS.Germany_Russia_etcAndTime:
+      cleanStr = str.replace(/[^0-9]+/g, '.');
+      return cleanStr.split('.').filter(Boolean).map(String);
+    default:
+      return [];
+  }
+}
+
+export function hasSpecialChar(str) {
+  var matches = str.match(/[^0-9]/g);
+  return matches ? matches.length : 0;
+}
+
+export function validateTime(inputTime) {
+  if (!inputTime || typeof inputTime !== 'string') {
+    return getCurrentTime();
+  }
+  var trimmed = inputTime.trim();
+  var timeRegex = /^(\d{2}):(\d{2})$/;
+  var match = trimmed.match(timeRegex);
+  if (!match) {
+    return getCurrentTime();
+  }
+  var hour = Number(match[1]);
+  var minute = Number(match[2]);
+  if (hour > 23 || minute > 59) {
+    return getCurrentTime();
+  }
+  return match[1] + ':' + match[2];
+}
+
+export function delimate(format) {
+  var delimiter = void 0;
+  if (format === DATE_FORMATS.Germany_Russia_etc || format === DATE_FORMATS.Germany_Russia_etcAndTime) {
+    delimiter = '.';
+  } else if (format === DATE_FORMATS.ISO || format === DATE_FORMATS.ISOAndTime) {
+    delimiter = '-';
+  } else {
+    delimiter = '/';
+  }
+  return delimiter;
+}
+
+export function validateCalendarYear(yearStr) {
+  var year = yearStr;
+  if (!year || isNaN(year)) return getCurrentYear();
+  if (year.length === 2) {
+    if (Number(year) >= 0 && Number(year) < 69) {
+      return year ? '20' + year : getCurrentYear();
+    } else if (Number(year) >= 69 && Number(year) < 100) {
+      return year ? '19' + year : getCurrentYear();
+    }
+  }
+  if (year.length === 4) {
+    return year;
+  }
+  return year ? year.padStart(4, '0') : getCurrentYear();
+}
+
+export function validateAndNormalizeDate(dayStr, monthStr, yearStr) {
+  var day = Number(dayStr);
+  var month = Number(monthStr);
+  var year = yearStr;
+  var isInThirtyOneDaysMonths = [1, 3, 5, 7, 8, 10, 12].includes(month);
+  var isInThirtyDaysMonths = [4, 6, 9, 11].includes(month);
+  var isValidDayThirtyOne = day < 1 || day > 31;
+  var isValidDayThirty = day < 1 || day > 30;
+  var isValidDayTwentyNight = day < 1 || day > 29;
+  var isValidDayTwentyEight = day < 1 || day > 28;
+
+  if (month > 12 || month < 0 || !month) {
+    day = getCurrentDate();
+    month = getCurrentMonth();
+    year = getCurrentYear();
+  }
+
+  if (isInThirtyOneDaysMonths && isValidDayThirtyOne || isInThirtyDaysMonths && isValidDayThirty) {
+    day = getCurrentDate();
+    month = getCurrentMonth();
+    year = getCurrentYear();
+  }
+
+  if (month === 2) {
+    if (isLeapYear(year) && isValidDayTwentyNight) {
+      day = getCurrentDate();
+      month = getCurrentMonth();
+      year = getCurrentYear();
+    } else if (isValidDayTwentyEight) {
+      day = getCurrentDate();
+      month = getCurrentMonth();
+      year = getCurrentYear();
+    }
+  }
+  return { day: day, month: month, year: year };
+}
+
+export function getDatePart(str) {
+  if (typeof str !== 'string') return '';
+  var parts = str.trim().split(/\s+/);
+  return parts[0];
+}
+
+export function initializeStr(str, format) {
+  var inputStr = str;
+  var inputStrLength = inputStr.length;
+  var time = getCurrentTime();
+  var hasSpecial = hasSpecialChar(inputStr);
+  var formattedArray = tokenizeFormattedDate(inputStr, format);
+  var dateDelimater = delimate(format);
+  if (format === DATE_FORMATS.ISO) {
+    var numStr = inputStr.replace(/[^0-9]/g, '');
+    if (numStr.length === 7 || numStr.length === 8) {
+      var yearStr = numStr.slice(0, 4);
+      var monthStr = numStr.slice(4, 6) || '01';
+      var dateStr = numStr.slice(6, numStr.length) || '01';
+      var validateYear = validateCalendarYear(yearStr);
+
+      var _validateAndNormalize = validateAndNormalizeDate(dateStr, monthStr, validateYear),
+          day = _validateAndNormalize.day,
+          month = _validateAndNormalize.month;
+
+      var _validateAndNormalize2 = validateAndNormalizeDate(dateStr, monthStr, validateYear),
+          year = _validateAndNormalize2.year;
+
+      day = String(day).padStart(2, 0);
+      month = String(month).padStart(2, 0);
+      return '' + year + dateDelimater + month + dateDelimater + day;
+    }
+    if (hasSpecial) {
+      var _validateYear = validateCalendarYear(formattedArray[0]);
+
+      var _validateAndNormalize3 = validateAndNormalizeDate(formattedArray[2] || '01', formattedArray[1] || '01', _validateYear),
+          _day = _validateAndNormalize3.day,
+          _month = _validateAndNormalize3.month; // eslint-disable-line max-len
+
+
+      var _validateAndNormalize4 = validateAndNormalizeDate(formattedArray[2] || '01', formattedArray[1] || '01', _validateYear),
+          _year = _validateAndNormalize4.year; // eslint-disable-line max-len
+
+
+      _day = String(_day).padStart(2, 0);
+      _month = String(_month).padStart(2, 0);
+      return '' + _year + dateDelimater + _month + dateDelimater + _day;
+    } else if (inputStrLength >= 1 && inputStrLength <= 8) {
+      var _yearStr = inputStr.slice(0, 4);
+      var _monthStr = inputStr.slice(4, 6) || '01';
+      var _dateStr = inputStr.slice(6, 8) || '01';
+      var _validateYear2 = validateCalendarYear(_yearStr);
+
+      var _validateAndNormalize5 = validateAndNormalizeDate(_dateStr, _monthStr, _validateYear2),
+          _day2 = _validateAndNormalize5.day,
+          _month2 = _validateAndNormalize5.month;
+
+      var _validateAndNormalize6 = validateAndNormalizeDate(_dateStr, _monthStr, _validateYear2),
+          _year2 = _validateAndNormalize6.year;
+
+      _day2 = String(_day2).padStart(2, 0);
+      _month2 = String(_month2).padStart(2, 0);
+      return '' + _year2 + dateDelimater + _month2 + dateDelimater + _day2;
+    } else if (inputStrLength > 8) {
+      return '' + getCurrentYear() + dateDelimater + String(getCurrentMonth()).padStart(2, 0) + dateDelimater + String(getCurrentDate()).padStart(2, 0); // eslint-disable-line max-len
+    }
+  } else if (format === DATE_FORMATS.ISOAndTime) {
+    var datePart = getDatePart(inputStr);
+    var formattedDateArray = tokenizeFormattedDate(datePart, format);
+    var isDateSpecial = hasSpecialChar(datePart);
+    var _numStr = datePart.replace(/[^0-9]/g, '');
+    if (_numStr.length === 7 || _numStr.length === 8) {
+      var _yearStr2 = _numStr.slice(0, 4);
+      var _monthStr2 = _numStr.slice(4, 6) || '01';
+      var _dateStr2 = _numStr.slice(6, _numStr.length) || '01';
+      if (formattedArray.length === 3) {
+        time = validateTime(formattedArray[1] + ':' + formattedArray[2]);
+      }
+      if (formattedArray.length === 4) {
+        time = validateTime(formattedArray[2] + ':' + formattedArray[3]);
+      }
+      if (formattedArray.length === 5) {
+        time = validateTime(formattedArray[3] + ':' + formattedArray[4]);
+      }
+      var _validateYear3 = validateCalendarYear(_yearStr2);
+
+      var _validateAndNormalize7 = validateAndNormalizeDate(_dateStr2, _monthStr2, _validateYear3),
+          _day3 = _validateAndNormalize7.day,
+          _month3 = _validateAndNormalize7.month;
+
+      var _validateAndNormalize8 = validateAndNormalizeDate(_dateStr2, _monthStr2, _validateYear3),
+          _year3 = _validateAndNormalize8.year;
+
+      _day3 = String(_day3).padStart(2, 0);
+      _month3 = String(_month3).padStart(2, 0);
+      return '' + _year3 + dateDelimater + _month3 + dateDelimater + _day3 + ' ' + time;
+    }
+    if (isDateSpecial) {
+      if (formattedDateArray.length < 3) {
+        formattedArray.splice(2, 0, '01');
+      }
+      var _validateYear4 = validateCalendarYear(formattedArray[0]);
+
+      var _validateAndNormalize9 = validateAndNormalizeDate(formattedArray[2] || '01', formattedArray[1] || '01', _validateYear4),
+          _day4 = _validateAndNormalize9.day,
+          _month4 = _validateAndNormalize9.month; // eslint-disable-line max-len
+
+
+      var _validateAndNormalize10 = validateAndNormalizeDate(formattedArray[2] || '01', formattedArray[1] || '01', _validateYear4),
+          _year4 = _validateAndNormalize10.year; // eslint-disable-line max-len
+
+
+      time = validateTime(formattedArray[3] + ':' + formattedArray[4]);
+      _day4 = String(_day4).padStart(2, 0);
+      _month4 = String(_month4).padStart(2, 0);
+      return '' + _year4 + dateDelimater + _month4 + dateDelimater + _day4 + ' ' + time;
+    } else if (datePart.length >= 1 && datePart.length <= 8) {
+      var _yearStr3 = datePart.slice(0, 4);
+      var _monthStr3 = datePart.slice(4, 6) || '01';
+      var _dateStr3 = datePart.slice(6, 8) || '01';
+      var timeParts = tokenizeFormattedDate(inputStr, format);
+      time = validateTime(timeParts[1] + ':' + timeParts[2]);
+      var _validateYear5 = validateCalendarYear(_yearStr3);
+
+      var _validateAndNormalize11 = validateAndNormalizeDate(_dateStr3, _monthStr3, _validateYear5),
+          _day5 = _validateAndNormalize11.day,
+          _month5 = _validateAndNormalize11.month;
+
+      var _validateAndNormalize12 = validateAndNormalizeDate(_dateStr3, _monthStr3, _validateYear5),
+          _year5 = _validateAndNormalize12.year;
+
+      _day5 = String(_day5).padStart(2, 0);
+      _month5 = String(_month5).padStart(2, 0);
+      return '' + _year5 + dateDelimater + _month5 + dateDelimater + _day5 + ' ' + time;
+    } else if (datePart.length > 8) {
+      return '' + getCurrentYear() + dateDelimater + String(getCurrentMonth()).padStart(2, 0) + dateDelimater + String(getCurrentDate()).padStart(2, 0) + '  ' + getCurrentTime(); // eslint-disable-line max-len
+    }
+  } else if (format === DATE_FORMATS.US) {
+    if (hasSpecial) {
+      var _validateYear6 = validateCalendarYear(formattedArray[2]);
+
+      var _validateAndNormalize13 = validateAndNormalizeDate(formattedArray[1] || '1', formattedArray[0], _validateYear6),
+          _day6 = _validateAndNormalize13.day,
+          _month6 = _validateAndNormalize13.month,
+          _year6 = _validateAndNormalize13.year; // eslint-disable-line max-len
+
+
+      return '' + _month6 + dateDelimater + _day6 + dateDelimater + _year6;
+    } else if (inputStrLength >= 1 && inputStrLength <= 8) {
+      var _monthStr4 = inputStr.slice(0, 2);
+      var _dateStr4 = inputStr.slice(2, 4) || '1';
+      var _yearStr4 = inputStr.slice(4, inputStr.length);
+      var _validateYear7 = validateCalendarYear(_yearStr4);
+
+      var _validateAndNormalize14 = validateAndNormalizeDate(_dateStr4, _monthStr4, _validateYear7),
+          _day7 = _validateAndNormalize14.day,
+          _month7 = _validateAndNormalize14.month,
+          _year7 = _validateAndNormalize14.year;
+
+      return '' + _month7 + dateDelimater + _day7 + dateDelimater + _year7; // eslint-disable-line max-len
+    } else if (inputStrLength > 8) {
+      return '' + String(getCurrentMonth()).padStart(2, 0) + dateDelimater + String(getCurrentDate()).padStart(2, 0) + dateDelimater + getCurrentYear(); // eslint-disable-line max-len
+    }
+  } else if (format === DATE_FORMATS.USAndTime) {
+    var _datePart = getDatePart(inputStr);
+    var _formattedDateArray = tokenizeFormattedDate(_datePart, format);
+    var _isDateSpecial = hasSpecialChar(_datePart);
+    if (_isDateSpecial) {
+      if (_formattedDateArray.length < 3) {
+        formattedArray.splice(2, 0, String(getCurrentYear()));
+      }
+      var _validateYear8 = validateCalendarYear(formattedArray[2]);
+
+      var _validateAndNormalize15 = validateAndNormalizeDate(formattedArray[1] || '1', formattedArray[0], _validateYear8),
+          _day8 = _validateAndNormalize15.day,
+          _month8 = _validateAndNormalize15.month,
+          _year8 = _validateAndNormalize15.year; // eslint-disable-line max-len
+
+
+      time = validateTime(formattedArray[3] + ':' + formattedArray[4]);
+      return '' + _month8 + dateDelimater + _day8 + dateDelimater + _year8 + ' ' + time;
+    } else if (_datePart.length >= 1 && _datePart.length <= 8) {
+      var _monthStr5 = _datePart.slice(0, 2);
+      var _dateStr5 = _datePart.slice(2, 4) || '1';
+      var _yearStr5 = _datePart.slice(4, _datePart.length);
+      var _validateYear9 = validateCalendarYear(_yearStr5); // eslint-disable-line max-len
+
+      var _validateAndNormalize16 = validateAndNormalizeDate(_dateStr5, _monthStr5, _validateYear9),
+          _day9 = _validateAndNormalize16.day,
+          _month9 = _validateAndNormalize16.month,
+          _year9 = _validateAndNormalize16.year;
+
+      var _timeParts = tokenizeFormattedDate(inputStr, format);
+      time = validateTime(_timeParts[1] + ':' + _timeParts[2]) || getCurrentTime();
+      return '' + _month9 + dateDelimater + _day9 + dateDelimater + _year9 + ' ' + time;
+    } else if (_datePart.length > 8) {
+      return '' + String(getCurrentMonth()).padStart(2, 0) + dateDelimater + String(getCurrentDate()).padStart(2, 0) + dateDelimater + getCurrentYear() + ' ' + getCurrentTime(); // eslint-disable-line max-len
+    }
+  } else if (format === DATE_FORMATS.European || format === DATE_FORMATS.Germany_Russia_etc) {
+    if (hasSpecial) {
+      var _validateYear10 = validateCalendarYear(formattedArray[2]);
+
+      var _validateAndNormalize17 = validateAndNormalizeDate(formattedArray[0], formattedArray[1], _validateYear10),
+          _day10 = _validateAndNormalize17.day,
+          _month10 = _validateAndNormalize17.month; // eslint-disable-line max-len
+
+
+      var _validateAndNormalize18 = validateAndNormalizeDate(formattedArray[0], formattedArray[1], _validateYear10),
+          _year10 = _validateAndNormalize18.year; // eslint-disable-line max-len
+
+
+      _day10 = String(_day10).padStart(2, 0);
+      _month10 = String(_month10).padStart(2, 0);
+      return '' + _day10 + dateDelimater + _month10 + dateDelimater + _year10;
+    } else if (inputStrLength >= 1 && inputStrLength <= 8) {
+      var _dateStr6 = inputStr.slice(0, 2);
+      var _monthStr6 = inputStr.slice(2, 4) || getCurrentMonth();
+      var _yearStr6 = inputStr.slice(4, inputStr.length);
+      var _validateYear11 = validateCalendarYear(_yearStr6);
+
+      var _validateAndNormalize19 = validateAndNormalizeDate(_dateStr6, _monthStr6, _validateYear11),
+          _year11 = _validateAndNormalize19.year; // eslint-disable-line max-len
+
+
+      var _validateAndNormalize20 = validateAndNormalizeDate(_dateStr6, _monthStr6, _validateYear11),
+          _day11 = _validateAndNormalize20.day,
+          _month11 = _validateAndNormalize20.month; // eslint-disable-line max-len
+
+
+      _day11 = String(_day11).padStart(2, 0);
+      _month11 = String(_month11).padStart(2, 0);
+      return '' + _day11 + dateDelimater + _month11 + dateDelimater + _year11;
+    } else if (inputStrLength > 8) {
+      return '' + String(getCurrentDate()).padStart(2, 0) + dateDelimater + String(getCurrentMonth()).padStart(2, 0) + dateDelimater + getCurrentYear(); // eslint-disable-line max-len
+    }
+  } else if (format === DATE_FORMATS.EuropeanAndTime || format === DATE_FORMATS.Germany_Russia_etcAndTime) {
+    var _datePart2 = getDatePart(inputStr);
+    var _formattedDateArray2 = tokenizeFormattedDate(_datePart2, format);
+    var _isDateSpecial2 = hasSpecialChar(_datePart2);
+    if (_isDateSpecial2) {
+      if (_formattedDateArray2.length < 3) {
+        formattedArray.splice(2, 0, String(getCurrentYear()));
+      }
+      var _validateYear12 = validateCalendarYear(formattedArray[2]);
+
+      var _validateAndNormalize21 = validateAndNormalizeDate(formattedArray[0], formattedArray[1], _validateYear12),
+          _day12 = _validateAndNormalize21.day,
+          _month12 = _validateAndNormalize21.month; // eslint-disable-line max-len
+
+
+      var _validateAndNormalize22 = validateAndNormalizeDate(formattedArray[0], formattedArray[1], _validateYear12),
+          _year12 = _validateAndNormalize22.year; // eslint-disable-line max-len
+
+
+      time = validateTime(formattedArray[3] + ':' + formattedArray[4]);
+      _day12 = String(_day12).padStart(2, 0);
+      _month12 = String(_month12).padStart(2, 0);
+      return '' + _day12 + dateDelimater + _month12 + dateDelimater + _year12 + ' ' + time;
+    } else if (_datePart2.length >= 1 && _datePart2.length <= 8) {
+      var _dateStr7 = _datePart2.slice(0, 2);
+      var _monthStr7 = _datePart2.slice(2, 4) || getCurrentMonth();
+      var _yearStr7 = _datePart2.slice(4, _datePart2.length);
+      var _timeParts2 = tokenizeFormattedDate(inputStr, format);
+      time = validateTime(_timeParts2[1] + ':' + _timeParts2[2]);
+      var _validateYear13 = validateCalendarYear(_yearStr7);
+
+      var _validateAndNormalize23 = validateAndNormalizeDate(_dateStr7, _monthStr7, _validateYear13),
+          _day13 = _validateAndNormalize23.day,
+          _month13 = _validateAndNormalize23.month;
+
+      var _validateAndNormalize24 = validateAndNormalizeDate(_dateStr7, _monthStr7, _validateYear13),
+          _year13 = _validateAndNormalize24.year;
+
+      _day13 = String(_day13).padStart(2, 0);
+      _month13 = String(_month13).padStart(2, 0);
+      return '' + _day13 + dateDelimater + _month13 + dateDelimater + _year13 + ' ' + time;
+    } else if (_datePart2.length > 8) {
+      return '' + String(getCurrentDate()).padStart(2, 0) + dateDelimater + String(getCurrentMonth()).padStart(2, 0) + dateDelimater + getCurrentYear() + ' ' + getCurrentTime(); // eslint-disable-line max-len
+    }
+  }
 }

package/es/year/YearPanel.js

@@ -9,7 +9,7 @@ var COL = 3;
 
 function goYear(direction) {
   var value = this.state.value.clone();
-  value.add(direction, 'year');
+  value = value.add(direction, 'year');
   this.setState({
     value: value
   });
@@ -17,8 +17,8 @@ function goYear(direction) {
 
 function chooseYear(year) {
   var value = this.state.value.clone();
-  value.year(year);
-  value.month(this.state.value.month());
+  value = value.year(year);
+  value = value.month(this.state.value.month());
   this.setState({
     value: value
   });
@@ -83,22 +83,14 @@ var YearPanel = function (_React$Component) {
       var tds = row.map(function (yearData) {
         var _classNameMap;
 
-        var classNameMap = (_classNameMap = {}, _classNameMap[prefixCls + '-cell'] = 1, _classNameMap[prefixCls + '-selected-cell'] = yearData.year === currentYear, _classNameMap[prefixCls + '-last-decade-cell'] = yearData.year < startYear, _classNameMap[prefixCls + '-next-decade-cell'] = yearData.year > endYear, _classNameMap);
-        var clickHandler = void 0;
-        if (yearData.year < startYear) {
-          clickHandler = _this2.previousDecade;
-        } else if (yearData.year > endYear) {
-          clickHandler = _this2.nextDecade;
-        } else {
-          clickHandler = chooseYear.bind(_this2, yearData.year);
-        }
+        var classNameMap = (_classNameMap = {}, _classNameMap[prefixCls + '-cell'] = 1, _classNameMap[prefixCls + '-selected-cell'] = yearData.year === currentYear, _classNameMap);
         return React.createElement(
           'td',
           {
             role: 'gridcell',
             title: yearData.title,
             key: yearData.content,
-            onClick: clickHandler,
+            onClick: chooseYear.bind(_this2, yearData.year),
             className: classnames(classNameMap)
           },
           React.createElement(