@seafile/seafile-calendar 0.0.29-alpha15 → 0.0.29-alpha19

package/es/util/index.js

@@ -0,0 +1,564 @@
+import _extends from 'babel-runtime/helpers/extends';
+import dayjs from 'dayjs';
+import utc from 'dayjs/plugin/utc';
+
+dayjs.extend(utc);
+export var currentDate = dayjs().date();
+export var currentMonth = dayjs().month() + 1;
+export var currentYear = dayjs().year();
+export var stringCurrentDate = String(currentDate).padStart(2, '0');
+export var stringCurrentMonth = String(currentMonth).padStart(2, '0');
+export var currentTime = 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() {
+    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 function formatDateLocal(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 isValidMonth(monthStr) {
+  if (typeof monthStr === 'undefined' || monthStr === null) return currentMonth;
+  if (!/^\d+$/.test(Number(monthStr))) return currentMonth;
+  var month = Number(monthStr);
+  if (month >= 1 && month <= 12) {
+    return monthStr;
+  }
+  return currentMonth;
+}
+
+export function isValidDay(dayStr) {
+  if (!/^\d+$/.test(dayStr)) return false;
+  var day = Number(dayStr);
+  if ([1, 3, 5, 7, 8, 10, 12].includes(currentMonth)) {
+    return day >= 1 && day <= 31;
+  }
+  if ([4, 6, 9, 11].includes(currentMonth)) {
+    return day >= 1 && day <= 30;
+  }
+  if (currentMonth === 2) {
+    var isLeapYear = function isLeapYear(year) {
+      return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
+    };
+    var year = currentYear;
+    if (isLeapYear(year)) {
+      return day >= 1 && day <= 29;
+    }
+    return day >= 1 && day <= 28;
+  }
+}
+
+export function fullValidYear(yearStr) {
+  var year = yearStr;
+  if (!year || isNaN(year)) return currentYear;
+  if (year.length === 2) {
+    if (Number(year) >= 0 && Number(year) < 69) {
+      return year ? '20' + year : currentYear;
+    } else if (Number(year) >= 69 && Number(year) < 100) {
+      return year ? '19' + year : currentYear;
+    }
+  }
+  if (year.length === 4) {
+    return year;
+  }
+  return year ? year.padStart(4, '0') : currentYear;
+}
+
+export function delimate(formatPrefix) {
+  var delimiter = void 0;
+  if (formatPrefix === DATE_FORMATS.Germany_Russia_etc || formatPrefix === DATE_FORMATS.Germany_Russia_etcAndTime) {
+    delimiter = '.';
+  } else if (formatPrefix === DATE_FORMATS.ISO || formatPrefix === DATE_FORMATS.ISOAndTime) {
+    delimiter = '-';
+  } else {
+    delimiter = '/';
+  }
+  return delimiter;
+}
+
+export function getDateFormatByStr(str, format) {
+  var cananderStr = str || '';
+  var delimiter = delimate(format);
+  var parts = cananderStr.split(delimiter);
+  if (parts.length !== 3) return format;
+  if (format === DATE_FORMATS.ISO) {
+    return DATE_FORMATS.ISO;
+  }
+  if (format === DATE_FORMATS.ISOAndTime) {
+    return DATE_FORMATS.ISOAndTime;
+  }
+  if (format === DATE_FORMATS.US) {
+    return DATE_FORMATS.US;
+  }
+  if (format === DATE_FORMATS.USAndTime) {
+    return DATE_FORMATS.USAndTime;
+  }
+  if (format === DATE_FORMATS.European || format === DATE_FORMATS.Germany_Russia_etc) {
+    var day = parts[0],
+        month = parts[1];
+
+    var dayLen = day.length;
+    var monthLen = month.length;
+    if (dayLen === 2 && monthLen === 2) {
+      return 'DD' + delimiter + 'MM' + delimiter + 'YYYY';
+    } else if (dayLen === 2 && monthLen === 1) {
+      return 'DD' + delimiter + 'M' + delimiter + 'YYYY';
+    } else if (dayLen === 1 && monthLen === 2) {
+      return 'D' + delimiter + 'MM' + delimiter + 'YYYY';
+    } else if (dayLen === 1 && monthLen === 1) {
+      return 'D' + delimiter + 'M' + delimiter + 'YYYY';
+    }
+  }
+  if (format === DATE_FORMATS.EuropeanAndTime || format === DATE_FORMATS.Germany_Russia_etcAndTime) {
+    var _day = parts[0],
+        _month = parts[1];
+
+    var _dayLen = _day.length;
+    var _monthLen = _month.length;
+    if (_dayLen === 2 && _monthLen === 2) {
+      return 'DD' + delimiter + 'MM' + delimiter + 'YYYY HH:mm';
+    } else if (_dayLen === 2 && _monthLen === 1) {
+      return 'DD' + delimiter + 'M' + delimiter + 'YYYY HH:mm';
+    } else if (_dayLen === 1 && _monthLen === 2) {
+      return 'D' + delimiter + 'MM' + delimiter + 'YYYY HH:mm';
+    } else if (_dayLen === 1 && _monthLen === 1) {
+      return 'D' + delimiter + 'M' + delimiter + 'YYYY HH:mm';
+    }
+  }
+  return format;
+}
+
+export function isCurrentYear(year, month, day) {
+  return Number(month) >= 1 && Number(month) <= 12 && Number(day) >= 1 && Number(day) <= 31 ? year : currentYear; // eslint-disable-line max-len
+}
+
+export function validateTime(inputTime) {
+  if (!inputTime || typeof inputTime !== 'string') {
+    return currentTime;
+  }
+  var trimmed = inputTime.trim();
+  var timeRegex = /^(\d{2}):(\d{2})$/;
+  var match = trimmed.match(timeRegex);
+  if (!match) {
+    return currentTime;
+  }
+  var hour = Number(match[1]);
+  var minute = Number(match[2]);
+  if (hour > 23 || minute > 59) {
+    return currentTime;
+  }
+  return match[1] + ':' + match[2];
+}
+
+export function checkSpecialBetweenDigits(str) {
+  var regex = /^\d+[^0-9]\d+$/;
+  return regex.test(str);
+}
+
+function getDatePart(str) {
+  if (typeof str !== 'string') return '';
+  var parts = str.trim().split(/\s+/);
+  return parts[0];
+}
+
+export function normalizeDateInput(str, localeFormat, delimiter) {
+  var day = void 0;
+  var month = void 0;
+  var year = void 0;
+  var time = currentTime;
+  var parts = formatDateLocal(str, localeFormat, DATE_FORMATS);
+  if (localeFormat === DATE_FORMATS.ISO) {
+    var hasSpecial = hasSpecialChar(str);
+    var numStr = str.replace(/[^0-9]/g, '');
+    if (numStr.length === 7) {
+      year = numStr.slice(0, 4);
+      month = numStr.slice(4, 6).padStart(2, '0');
+      day = numStr.slice(6, 7).padStart(2, '0');
+      if (!isValidDay(day)) {
+        return year + '-' + stringCurrentMonth + '-' + stringCurrentDate;
+      }
+      return year + '-' + month + '-' + day;
+    }
+    if (hasSpecial) {
+      year = fullValidYear(parts[0]);
+      month = Number(parts[1]);
+      day = Number(parts[2]);
+      if (month >= 1 && month <= 12) {
+        if (isValidDay(day)) {
+          return year + '-' + String(month).padStart(2, '0') + '-' + String(day).padStart(2, '0');
+        }
+        return year + '-' + String(month).padStart(2, '0') + '-01';
+      }
+      if ((month >= 13 || month < 1) && isNaN(day)) {
+        return year + '-' + stringCurrentMonth + '-' + stringCurrentDate;
+      }
+      if ((month >= 13 || month < 1) && day) {
+        return String(currentYear) + '-' + stringCurrentMonth + '-' + stringCurrentDate;
+      }
+      if (!month && !day) {
+        return year + '-01-01';
+      }
+    }
+    if (str.length >= 1 && str.length <= 8) {
+      year = fullValidYear(str.slice(0, 4));
+      month = str.slice(4, 6);
+      day = Number(str.slice(6, 8));
+      if (str.length === 5 && Number(month) < 1) {
+        return year + '-' + stringCurrentMonth + '-' + stringCurrentDate + ' ';
+      }
+      if (str.length === 6 && Number(month) < 1) {
+        return year + '-' + stringCurrentMonth + '-' + stringCurrentDate;
+      }
+      if (str.length === 7) {
+        if (!isValidDay(day)) {
+          return year + '-' + String(isValidMonth(month)).padStart(2, '0') + '-' + stringCurrentDate;
+        }
+        return year + '-' + String(isValidMonth(month)).padStart(2, '0') + '-' + String(day).padStart(2, '0'); // eslint-disable-line max-len
+      }
+      if (str.length === 8) {
+        if (!isValidDay(day)) {
+          return isCurrentYear(year, month, day) + '-' + String(isValidMonth(month)).padStart(2, '0') + '-' + stringCurrentDate; // eslint-disable-line max-len
+        }
+        return isCurrentYear(year, month, day) + '-' + String(isValidMonth(month)).padStart(2, '0') + '-' + String(day).padStart(2, '0'); // eslint-disable-line max-len
+      }
+      if (Number(month) >= 1 && Number(month) <= 12 && isValidDay(day)) {
+        return year + '-' + month.padStart(2, '0') + '-' + String(day).padStart(2, '0');
+      }
+      return year + '-' + (month ? month.padStart(2, '0') : '01') + '-' + (day ? String(day).padStart(2, '0') : '01'); // eslint-disable-line max-len
+    }
+    return currentYear + '/' + stringCurrentMonth + '/' + stringCurrentDate;
+  }
+  if (localeFormat === DATE_FORMATS.ISOAndTime) {
+    var unNormalDate = getDatePart(str);
+    var unNormalDateParts = formatDateLocal(unNormalDate, localeFormat, DATE_FORMATS);
+    var _hasSpecial = hasSpecialChar(unNormalDate);
+    var _numStr = unNormalDate.replace(/[^0-9]/g, '');
+    if (_numStr.length === 7) {
+      year = _numStr.slice(0, 4);
+      month = _numStr.slice(4, 6).padStart(2, '0');
+      day = _numStr.slice(6, 7).padStart(2, '0');
+      if (parts.length === 3) {
+        time = validateTime(parts[1] + ':' + parts[2]);
+      }
+      if (parts.length === 4) {
+        time = validateTime(parts[2] + ':' + parts[3]);
+      }
+      if (parts.length === 5) {
+        time = validateTime(parts[3] + ':' + parts[4]);
+      }
+      if (!isValidDay(day)) {
+        return year + '-' + stringCurrentMonth + '-' + stringCurrentDate + ' ' + time;
+      }
+      return year + '-' + month + '-' + day + ' ' + time;
+    }
+    if (_hasSpecial) {
+      if (unNormalDateParts.length < 3) {
+        parts.splice(2, 0, '1');
+      }
+      year = fullValidYear(parts[0]);
+      month = Number(parts[1]);
+      day = Number(parts[2]);
+      time = validateTime(parts[3] + ':' + parts[4]);
+      if (month >= 1 && month <= 12) {
+        if (isValidDay(day)) {
+          return year + '-' + String(month).padStart(2, '0') + '-' + String(day).padStart(2, '0') + ' ' + time; // eslint-disable-line max-len
+        }
+        return year + '-' + String(month).padStart(2, '0') + '-01 ' + time;
+      }
+      if ((month >= 13 || month < 1) && isNaN(day)) {
+        return year + '-' + stringCurrentMonth + '-' + stringCurrentDate + ' ' + time; // eslint-disable-line max-len
+      }
+      if ((month >= 13 || month < 1) && day) {
+        return String(currentYear) + '-' + stringCurrentMonth + '-' + stringCurrentDate + ' ' + time; // eslint-disable-line max-len
+      }
+      if (!month && !day) {
+        return year + '-01-01 ' + time;
+      }
+    }
+    if (unNormalDate.length >= 1 && unNormalDate.length <= 8) {
+      year = fullValidYear(unNormalDate.slice(0, 4));
+      month = unNormalDate.slice(4, 6);
+      day = Number(unNormalDate.slice(6, 8));
+      var timeParts = formatDateLocal(str, localeFormat, DATE_FORMATS);
+      time = validateTime(timeParts[1] + ':' + timeParts[2]);
+      if (unNormalDate.length === 5 && Number(month) < 1) {
+        return year + '-' + stringCurrentMonth + '-' + stringCurrentDate + ' ' + time;
+      }
+      if (unNormalDate.length === 6 && Number(month) < 1) {
+        return year + '-' + stringCurrentMonth + '-' + stringCurrentDate + ' ' + time;
+      }
+      if (unNormalDate.length === 7) {
+        if (!isValidDay(day)) {
+          return year + '-' + String(isValidMonth(month)).padStart(2, '0') + '-' + stringCurrentDate + ' ' + time; // eslint-disable-line max-len
+        }
+        return year + '-' + String(isValidMonth(month)).padStart(2, '0') + '-' + String(day).padStart(2, '0') + ' ' + time; // eslint-disable-line max-len
+      }
+      if (unNormalDate.length === 8) {
+        if (!isValidDay(day)) {
+          return isCurrentYear(year, month, day) + '-' + String(isValidMonth(month)).padStart(2, '0') + '-' + stringCurrentDate + ' ' + time; // eslint-disable-line max-len
+        }
+        return isCurrentYear(year, month, day) + '-' + String(isValidMonth(month)).padStart(2, '0') + '-' + String(day).padStart(2, '0') + ' ' + time; // eslint-disable-line max-len
+      }
+      if (Number(month) >= 1 && Number(month) <= 12 && isValidDay(day)) {
+        return year + '-' + month.padStart(2, '0') + '-' + String(day).padStart(2, '0') + ' ' + time;
+      }
+      return year + '-' + (month ? month.padStart(2, '0') : '01') + '-' + (day ? String(day).padStart(2, '0') : '01') + ' ' + time; // eslint-disable-line max-len
+    }
+    return currentYear + '/' + stringCurrentMonth + '/' + stringCurrentDate + ' ' + time;
+  }
+  if (localeFormat === DATE_FORMATS.US) {
+    var _hasSpecial2 = hasSpecialChar(str);
+    if (_hasSpecial2) {
+      month = Number(parts[0]);
+      day = Number(parts[1]);
+      year = fullValidYear(parts[2]);
+      if (month >= 1 && month <= 12 && isValidDay(day)) {
+        return month + '/' + day + '/' + year;
+      }
+      return currentMonth + '/' + currentDate + '/' + currentYear;
+    }
+    if (str.length >= 1 && str.length <= 8) {
+      month = Number(str.slice(0, 2));
+      day = Number(str.slice(2, 4));
+      year = fullValidYear(str.slice(4, str.length));
+      if (month >= 1 && month <= 12) {
+        if (isValidDay(day)) {
+          return month + '/' + day + '/' + year;
+        }
+        if (!day) {
+          return month + '/1/' + year;
+        }
+        return currentMonth + '/' + currentDate + '/' + currentYear;
+      }
+    }
+    return currentMonth + '/' + currentDate + '/' + currentYear;
+  }
+  if (localeFormat === DATE_FORMATS.USAndTime) {
+    var _unNormalDate = getDatePart(str);
+    var _unNormalDateParts = formatDateLocal(_unNormalDate, localeFormat, DATE_FORMATS);
+    var _hasSpecial3 = hasSpecialChar(_unNormalDate);
+    if (_hasSpecial3) {
+      if (_unNormalDateParts.length < 3) {
+        parts.splice(2, 0, String(currentYear));
+      }
+      month = Number(parts[0]);
+      day = Number(parts[1]);
+      year = fullValidYear(parts[2]);
+      time = validateTime(parts[3] + ':' + parts[4]);
+      if (month >= 1 && month <= 12 && isValidDay(day)) {
+        return month + '/' + day + '/' + year + ' ' + time;
+      }
+      return currentMonth + '/' + currentDate + '/' + currentYear + ' ' + time;
+    }
+    if (_unNormalDate.length >= 1 && _unNormalDate.length <= 8) {
+      month = Number(_unNormalDate.slice(0, 2));
+      day = Number(_unNormalDate.slice(2, 4));
+      year = fullValidYear(_unNormalDate.slice(4, _unNormalDate.length));
+      var _timeParts = formatDateLocal(str, localeFormat, DATE_FORMATS);
+      time = validateTime(_timeParts[1] + ':' + _timeParts[2]);
+      if (month >= 1 && month <= 12) {
+        if (isValidDay(day)) {
+          return month + '/' + day + '/' + year + ' ' + time;
+        }
+        if (!day) {
+          return month + '/1/' + year + ' ' + time;
+        }
+        return currentMonth + '/' + currentDate + '/' + currentYear + ' ' + time;
+      }
+    }
+    return currentMonth + '/' + currentDate + '/' + currentYear + ' ' + time;
+  }
+  if (localeFormat === DATE_FORMATS.European || localeFormat === DATE_FORMATS.Germany_Russia_etc) {
+    var _hasSpecial4 = hasSpecialChar(str);
+    if (_hasSpecial4) {
+      day = parts[0];
+      month = parts[1];
+      year = fullValidYear(parts[2]);
+      if (isValidDay(day) && Number(month) >= 1 && Number(month) <= 12) {
+        return '' + Number(day) + delimiter + Number(month) + delimiter + year;
+      }
+      return '' + currentDate + delimiter + currentMonth + delimiter + currentYear;
+    }
+    if (str.length >= 1 && str.length <= 8) {
+      day = Number(str.slice(0, 2));
+      var monthStr = str.slice(2, 4);
+      month = isValidMonth(monthStr);
+      var yearStr = str.slice(4, str.length);
+      year = fullValidYear(yearStr);
+
+      if (isValidDay(day)) {
+        if (Number(monthStr) < 1 && Number(monthStr) > 12) {
+          return '' + currentDate + delimiter + currentMonth + delimiter + currentYear;
+        }
+        return '' + Number(day) + delimiter + Number(month) + delimiter + year;
+      }
+    }
+    return '' + currentDate + delimiter + currentMonth + delimiter + currentYear;
+  }
+  if (localeFormat === DATE_FORMATS.EuropeanAndTime || localeFormat === DATE_FORMATS.Germany_Russia_etcAndTime) {
+    var _unNormalDate2 = getDatePart(str);
+    var _unNormalDateParts2 = formatDateLocal(_unNormalDate2, localeFormat, DATE_FORMATS);
+    var _hasSpecial5 = hasSpecialChar(_unNormalDate2);
+    if (_hasSpecial5) {
+      if (_unNormalDateParts2.length < 3) {
+        parts.splice(2, 0, String(currentYear));
+      }
+      day = parts[0];
+      month = parts[1];
+      year = fullValidYear(parts[2]);
+      time = validateTime(parts[3] + ':' + parts[4]);
+      if (isValidDay(day) && Number(month) >= 1 && Number(month) <= 12) {
+        return '' + Number(day) + delimiter + Number(month) + delimiter + year + ' ' + time;
+      }
+      return '' + currentDate + delimiter + currentMonth + delimiter + currentYear + ' ' + time;
+    }
+    if (_unNormalDate2.length >= 1 && _unNormalDate2.length <= 8) {
+      day = Number(_unNormalDate2.slice(0, 2));
+      var _monthStr = _unNormalDate2.slice(2, 4);
+      month = isValidMonth(_monthStr);
+      var _yearStr = _unNormalDate2.slice(4, _unNormalDate2.length);
+      year = fullValidYear(_yearStr);
+      var _timeParts2 = formatDateLocal(str, localeFormat, DATE_FORMATS);
+      time = validateTime(_timeParts2[1] + ':' + _timeParts2[2]);
+      if (isValidDay(day)) {
+        if (Number(_monthStr) < 1 && Number(_monthStr) > 12) {
+          return '' + currentDate + delimiter + currentMonth + delimiter + currentYear + ' ' + time;
+        }
+        return '' + Number(day) + delimiter + Number(month) + delimiter + year + ' ' + time;
+      }
+    }
+    return '' + currentDate + delimiter + currentMonth + delimiter + currentYear + ' ' + time;
+  }
+}

package/es/util/toTime.js

@@ -0,0 +1,21 @@
+export function goStartMonth(time) {
+  return time.clone().startOf('month');
+}
+
+export function goEndMonth(time) {
+  return time.clone().endOf('month');
+}
+
+export function goTime(time, direction, unit) {
+  return time.clone().add(direction, unit);
+}
+
+export function includesTime() {
+  var timeList = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var time = arguments[1];
+  var unit = arguments[2];
+
+  return timeList.some(function (t) {
+    return t.isSame(time, unit);
+  });
+}