@seafile/seafile-calendar/es/util/index.js

React Calendar

import _extends from 'babel-runtime/helpers/extends';
import dayjs from 'dayjs';
import utc from 'dayjs/plugin/utc';
import localeData from 'dayjs/plugin/localeData';

dayjs.extend(utc);
dayjs.extend(localeData);
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'
};

export var CALENDAR_STATUS = {
  SPECIFIC_TIME: 'specific_time',
  CURRENT_TIME: 'current_time'
};

export var syncCurrentTime = function syncCurrentTime(date, status) {
  if (status === CALENDAR_STATUS.CURRENT_TIME) {
    return date.hour(dayjs().hour()).minute(dayjs().minute()).second(dayjs().second());
  }
  return date;
};

var defaultDisabledTime = {
  disabledHours: function disabledHours() {
    return [];
  },
  disabledMinutes: function disabledMinutes() {
    return [];
  },
  disabledSeconds: function disabledSeconds() {
    return [];
  }
};

export function getTodayTime(value) {
  var today = dayjs();
  today = today.locale(value.locale()).utcOffset(value.utcOffset());
  return today;
}

export function getTitleString(value) {
  return value.format('LL');
}

export function getTodayTimeStr(value) {
  var today = getTodayTime(value);
  return getTitleString(today);
}

export function getMonthName(month) {
  var locale = month.locale();
  var localeData = month.localeData();
  return localeData[locale === 'zh-cn' ? 'months' : 'monthsShort'](month);
}

export function syncTime(from, to) {
  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) {
  var disabledTimeConfig = disabledTime ? disabledTime(value) : {};
  disabledTimeConfig = _extends({}, defaultDisabledTime, disabledTimeConfig);
  return disabledTimeConfig;
}

export function isTimeValidByConfig(value, disabledTimeConfig) {
  var invalidTime = false;
  if (value) {
    var hour = value.hour();
    var minutes = value.minute();
    var seconds = value.second();
    var disabledHours = disabledTimeConfig.disabledHours();
    if (disabledHours.indexOf(hour) === -1) {
      var disabledMinutes = disabledTimeConfig.disabledMinutes(hour);
      if (disabledMinutes.indexOf(minutes) === -1) {
        var disabledSeconds = disabledTimeConfig.disabledSeconds(hour, minutes);
        invalidTime = disabledSeconds.indexOf(seconds) !== -1;
      } else {
        invalidTime = true;
      }
    } else {
      invalidTime = true;
    }
  }
  return !invalidTime;
}

export function isTimeValid(value, disabledTime) {
  var disabledTimeConfig = getTimeConfig(value, disabledTime);
  return isTimeValidByConfig(value, disabledTimeConfig);
}

export function isAllowedDate(value, disabledDate, disabledTime) {
  if (disabledDate) {
    if (disabledDate(value)) {
      return false;
    }
  }
  if (disabledTime) {
    if (!isTimeValid(value, disabledTime)) {
      return false;
    }
  }
  return true;
}

export function formatDate(value, format) {
  if (!value) {
    return '';
  }

  if (Array.isArray(format)) {
    format = format[0];
  }

  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
    }
  }
}