dtable-utils 0.0.3 → 4.2.0

package/lib/filter/core.js

@@ -0,0 +1,336 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var filter = require('../validate/filter.js');
+var date = require('../date.js');
+var index = require('../constants/filter/index.js');
+var cellType = require('../constants/cell-type.js');
+var formula = require('../constants/formula.js');
+var filterModifier = require('../constants/filter/filter-modifier.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty__default["default"](target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+var EXACT_DATE_TERM_MODIFIER_TYPES = [filterModifier.FILTER_TERM_MODIFIER_TYPE.TODAY, filterModifier.FILTER_TERM_MODIFIER_TYPE.TOMORROW, filterModifier.FILTER_TERM_MODIFIER_TYPE.YESTERDAY, filterModifier.FILTER_TERM_MODIFIER_TYPE.ONE_WEEK_AGO, filterModifier.FILTER_TERM_MODIFIER_TYPE.ONE_WEEK_FROM_NOW, filterModifier.FILTER_TERM_MODIFIER_TYPE.ONE_MONTH_AGO, filterModifier.FILTER_TERM_MODIFIER_TYPE.ONE_MONTH_FROM_NOW, filterModifier.FILTER_TERM_MODIFIER_TYPE.NUMBER_OF_DAYS_AGO, filterModifier.FILTER_TERM_MODIFIER_TYPE.NUMBER_OF_DAYS_FROM_NOW, filterModifier.FILTER_TERM_MODIFIER_TYPE.EXACT_DATE];
+
+/**
+ * Get filters which excludes incomplete
+ * @param {array} filters e.g. [{ column_key, filter_predicate, ... }]
+ * @param {array} columns
+ * @returns valid filters, array
+ */
+var getValidFilters = function getValidFilters(filters, columns) {
+  if (!Array.isArray(filters) || !Array.isArray(columns)) {
+    return [];
+  }
+  return filters.filter(function (filter$1) {
+    var _ValidateFilter$valid = filter.ValidateFilter.validate(filter$1, columns),
+      error_message = _ValidateFilter$valid.error_message;
+    return !error_message || error_message !== index.FILTER_ERR_MSG.INCOMPLETE_FILTER;
+  });
+};
+
+/**
+ * Get filters without error messages
+ * @param {array} filters e.g. [{ column_key, filter_predicate, ... }]
+ * @param {array} columns
+ * @returns valid filters, array
+ */
+var getValidFiltersWithoutError = function getValidFiltersWithoutError(filters, columns) {
+  if (!Array.isArray(filters) || !Array.isArray(columns)) {
+    return [];
+  }
+  return filters.filter(function (filter$1) {
+    return !filter.ValidateFilter.validate(filter$1, columns).error_message;
+  });
+};
+
+/**
+ * Generate date for filter
+ * @param {string} filterTermModifier
+ * @param {any} filterTerm
+ * @returns date | date range, object
+ */
+var otherDate = function otherDate(filterTermModifier, filterTerm) {
+  var today = new Date();
+  var year = today.getFullYear();
+  var month = today.getMonth(); // use js month representation: 0 - 11
+  var day = today.getDate();
+
+  //          0   1   2   3    4   5   6   7   8   9  10  11 days in every month
+  var days = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+  days[1] = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0) ? 29 : 28; // is leap year
+  switch (filterTermModifier) {
+    case filterModifier.FILTER_TERM_MODIFIER_TYPE.TODAY:
+      {
+        // today, should start at 0:00 and end at 24:00
+        return new Date(year, month, day, 0, 0, 0);
+      }
+    case filterModifier.FILTER_TERM_MODIFIER_TYPE.TOMORROW:
+      {
+        return new Date(year, month, day + 1);
+      }
+    case filterModifier.FILTER_TERM_MODIFIER_TYPE.YESTERDAY:
+      {
+        return new Date(year, month, day - 1);
+      }
+    case filterModifier.FILTER_TERM_MODIFIER_TYPE.ONE_WEEK_AGO:
+      {
+        return new Date(year, month, day - 7);
+      }
+    case filterModifier.FILTER_TERM_MODIFIER_TYPE.ONE_WEEK_FROM_NOW:
+      {
+        return new Date(year, month, day + 7);
+      }
+    case filterModifier.FILTER_TERM_MODIFIER_TYPE.ONE_MONTH_AGO:
+      {
+        var pastMonth = month - 1;
+        var monthDaysIndex = month === 0 ? 11 : pastMonth;
+        var currentDay = day > days[monthDaysIndex] ? days[monthDaysIndex] : day;
+        return new Date(year, pastMonth, currentDay);
+      }
+    case filterModifier.FILTER_TERM_MODIFIER_TYPE.ONE_MONTH_FROM_NOW:
+      {
+        var nextMonth = month + 1;
+        var _monthDaysIndex = month === 11 ? 0 : nextMonth;
+        var _currentDay = day > days[_monthDaysIndex] ? days[_monthDaysIndex] : day;
+        return new Date(year, nextMonth, _currentDay);
+      }
+    case filterModifier.FILTER_TERM_MODIFIER_TYPE.NUMBER_OF_DAYS_AGO:
+      {
+        return new Date(year, month, day - Number(filterTerm));
+      }
+    case filterModifier.FILTER_TERM_MODIFIER_TYPE.NUMBER_OF_DAYS_FROM_NOW:
+      {
+        return new Date(year, month, day + Number(filterTerm));
+      }
+    case filterModifier.FILTER_TERM_MODIFIER_TYPE.EXACT_DATE:
+      {
+        return new Date(filterTerm);
+      }
+    case filterModifier.FILTER_TERM_MODIFIER_TYPE.THE_PAST_WEEK:
+      {
+        var weekDay = today.getDay() !== 0 ? today.getDay() : 7;
+        return {
+          startDate: new Date(year, month, day - weekDay - 6),
+          endDate: new Date(year, month, day - weekDay)
+        };
+      }
+    case filterModifier.FILTER_TERM_MODIFIER_TYPE.THIS_WEEK:
+      {
+        var _weekDay = today.getDay() !== 0 ? today.getDay() : 7;
+        return {
+          startDate: new Date(year, month, day - _weekDay + 1),
+          endDate: new Date(year, month, day - _weekDay + 7)
+        };
+      }
+    case filterModifier.FILTER_TERM_MODIFIER_TYPE.THE_NEXT_WEEK:
+      {
+        var _weekDay2 = today.getDay() !== 0 ? today.getDay() : 7;
+        return {
+          startDate: new Date(year, month, day - _weekDay2 + 8),
+          endDate: new Date(year, month, day - _weekDay2 + 14)
+        };
+      }
+    case filterModifier.FILTER_TERM_MODIFIER_TYPE.THE_PAST_MONTH:
+      {
+        var _pastMonth = month - 1;
+        return {
+          startDate: new Date(year, _pastMonth, 1),
+          endDate: new Date(year, _pastMonth, days[month === 0 ? 11 : _pastMonth])
+        };
+      }
+    case filterModifier.FILTER_TERM_MODIFIER_TYPE.THIS_MONTH:
+      {
+        return {
+          startDate: new Date(year, month, 1),
+          endDate: new Date(year, month, days[month])
+        };
+      }
+    case filterModifier.FILTER_TERM_MODIFIER_TYPE.THE_NEXT_MONTH:
+      {
+        var _nextMonth = month + 1;
+        return {
+          startDate: new Date(year, _nextMonth, 1),
+          endDate: new Date(year, _nextMonth, month === 11 ? days[0] : days[_nextMonth])
+        };
+      }
+    case filterModifier.FILTER_TERM_MODIFIER_TYPE.THE_PAST_YEAR:
+      {
+        var pastYear = year - 1;
+        return {
+          startDate: new Date(pastYear, 0, 1),
+          // The computer's month starts at 0.
+          endDate: new Date(pastYear, 11, 31)
+        };
+      }
+    case filterModifier.FILTER_TERM_MODIFIER_TYPE.THIS_YEAR:
+      {
+        return {
+          startDate: new Date(year, 0, 1),
+          endDate: new Date(year, 11, 31)
+        };
+      }
+    case filterModifier.FILTER_TERM_MODIFIER_TYPE.THE_NEXT_YEAR:
+      {
+        var nextYear = year + 1;
+        return {
+          startDate: new Date(nextYear, 0, 1),
+          endDate: new Date(nextYear, 11, 31)
+        };
+      }
+    case filterModifier.FILTER_TERM_MODIFIER_TYPE.THE_NEXT_NUMBERS_OF_DAYS:
+      {
+        return {
+          startDate: new Date(year, month, day + 1, 0, 0, 0),
+          endDate: new Date(year, month, day + Number(filterTerm))
+        };
+      }
+    case filterModifier.FILTER_TERM_MODIFIER_TYPE.THE_PAST_NUMBERS_OF_DAYS:
+      {
+        return {
+          startDate: new Date(year, month, day - Number(filterTerm)),
+          endDate: new Date(year, month, day, 0, 0, 0)
+        };
+      }
+    default:
+      {
+        return {};
+      }
+  }
+};
+
+/**
+ * Generate formatted date for filter
+ * @param {string} filterTermModifier
+ * @param {any} filterTerm
+ * @returns formatted date | date range, object
+ */
+var getFormattedFilterOtherDate = function getFormattedFilterOtherDate(filterTermModifier, filterTerm) {
+  var _otherDate = otherDate(filterTermModifier, filterTerm);
+  if (EXACT_DATE_TERM_MODIFIER_TYPES.includes(filterTermModifier)) {
+    return date.DateUtils.format(_otherDate);
+  }
+  var startDate = _otherDate.startDate,
+    endDate = _otherDate.endDate;
+  return {
+    startDate: startDate ? date.DateUtils.format(startDate) : '',
+    endDate: endDate ? date.DateUtils.format(endDate) : ''
+  };
+};
+
+/**
+ * Format filter with other_date, linked_column etc.
+ * @param {object} filter e.g. { filter_term, filter_term_modifier, ... }
+ * @param {object} column
+ * @returns formatted filter
+ */
+var getFormattedFilter = function getFormattedFilter(filter, column) {
+  var filter_term = filter.filter_term,
+    filter_term_modifier = filter.filter_term_modifier;
+  var columnType = column.type,
+    columnData = column.data;
+  var formattedFilter = filter;
+  switch (columnType) {
+    case cellType.CellType.FORMULA:
+    case cellType.CellType.LINK_FORMULA:
+      {
+        var result_type = columnData.result_type,
+          array_type = columnData.array_type,
+          array_data = columnData.array_data;
+        if (result_type === formula.FORMULA_RESULT_TYPE.DATE) {
+          formattedFilter.other_date = getFormattedFilterOtherDate(filter_term_modifier, filter_term);
+        }
+        if (result_type === formula.FORMULA_RESULT_TYPE.ARRAY) {
+          var linkedColumn = {
+            type: array_type,
+            data: array_data
+          };
+          formattedFilter.linked_column = linkedColumn;
+          formattedFilter = getFormattedFilter(formattedFilter, linkedColumn);
+        }
+        break;
+      }
+    case cellType.CellType.DATE:
+    case cellType.CellType.CTIME:
+    case cellType.CellType.MTIME:
+      {
+        formattedFilter.other_date = getFormattedFilterOtherDate(filter_term_modifier, filter_term);
+        break;
+      }
+    case cellType.CellType.LINK:
+      {
+        var _ref = columnData || {},
+          _array_type = _ref.array_type,
+          _array_data = _ref.array_data;
+        var _linkedColumn = {
+          type: _array_type,
+          data: _array_data
+        };
+        var filterColumnData = _objectSpread(_objectSpread({}, columnData), {}, {
+          result_type: formula.FORMULA_RESULT_TYPE.ARRAY
+        });
+        var filterColumn = _objectSpread(_objectSpread({}, column), {}, {
+          data: filterColumnData
+        });
+        formattedFilter.column = filterColumn;
+        formattedFilter.linked_column = _linkedColumn;
+        formattedFilter = getFormattedFilter(formattedFilter, _linkedColumn);
+        break;
+      }
+  }
+  return formattedFilter;
+};
+
+/**
+ * Get formatted filters with other_date, linked_column etc.
+ * @param {array} filters [{ filter_term, filter_term_modifier, column, ... }]
+ * @returns formatted filters, array
+ */
+var getFormattedFilters = function getFormattedFilters(filters) {
+  return filters.map(function (filter) {
+    return getFormattedFilter(filter, filter.column);
+  });
+};
+
+/**
+ * Get filters without error messages and formatted with filter column
+ * @param {array} filters e.g. [{ column_key, filter_predicate, ... }]
+ * @param {array} columns
+ * @returns filters, array
+ */
+var deleteInvalidFilter = function deleteInvalidFilter(filters, columns) {
+  var cleanFilters = [];
+  filters.forEach(function (filter$1) {
+    var column_key = filter$1.column_key;
+    var _ValidateFilter$valid2 = filter.ValidateFilter.validate(filter$1, columns),
+      error_message = _ValidateFilter$valid2.error_message;
+    if (error_message) {
+      if (error_message !== index.FILTER_ERR_MSG.INCOMPLETE_FILTER) {
+        throw new Error(error_message);
+      }
+    } else {
+      var filterColumn = columns.find(function (column) {
+        return column.key === column_key;
+      });
+      var newFilter = _objectSpread(_objectSpread({}, filter$1), {}, {
+        column: filterColumn
+      });
+      cleanFilters.push(newFilter);
+    }
+  });
+  return cleanFilters;
+};
+
+exports.deleteInvalidFilter = deleteInvalidFilter;
+exports.getFormattedFilter = getFormattedFilter;
+exports.getFormattedFilterOtherDate = getFormattedFilterOtherDate;
+exports.getFormattedFilters = getFormattedFilters;
+exports.getValidFilters = getValidFilters;
+exports.getValidFiltersWithoutError = getValidFiltersWithoutError;
+exports.otherDate = otherDate;

package/lib/filter/filter-column/array.js

@@ -0,0 +1,91 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var cellValue = require('../../cell-value-get/cell-value.js');
+var number = require('../../column/number.js');
+var checkbox = require('./checkbox.js');
+var collaborator = require('./collaborator.js');
+var date = require('./date.js');
+var text = require('./text.js');
+var multipleSelect = require('./multiple-select.js');
+var number$1 = require('./number.js');
+var cellType = require('../../constants/cell-type.js');
+var column = require('../../constants/column.js');
+var filterPredicate = require('../../constants/filter/filter-predicate.js');
+
+var TRUE_VALUE = [true, 'true'];
+
+/**
+ * Filter by array type
+ * @param {array} array e.g. [ cellValue, ... ]
+ * @param {object} filter e.g. { filter_predicate, column, ... }
+ * @param {string} username
+ * @param {string} userId
+ * @returns bool
+ */
+var filterByArrayType = function filterByArrayType(array, filter, _ref) {
+  var username = _ref.username,
+    userId = _ref.userId;
+  var column$1 = filter.column,
+    linked_column = filter.linked_column;
+  var filter_predicate = filter.filter_predicate;
+  if (Array.isArray(array)) {
+    if (filter_predicate === filterPredicate.FILTER_PREDICATE_TYPE.EMPTY) {
+      return array.length === 0;
+    }
+    if (filter_predicate === filterPredicate.FILTER_PREDICATE_TYPE.NOT_EMPTY) {
+      return array.length > 0;
+    }
+  }
+  if (!linked_column) {
+    return text.textFilter('', filter, userId);
+  }
+  var linkedColumnType = linked_column.type;
+  if (linkedColumnType === cellType.CellType.BOOL || linkedColumnType === cellType.CellType.CHECKBOX) {
+    var normalizedArray = array;
+    if (Array.isArray(array)) {
+      normalizedArray = array[0];
+    }
+    normalizedArray = TRUE_VALUE.includes(normalizedArray);
+    return checkbox.checkboxFilter(normalizedArray, filter);
+  }
+  if (linkedColumnType === cellType.CellType.SINGLE_SELECT) {
+    var _normalizedArray = array;
+    if (array && !Array.isArray(array)) {
+      _normalizedArray = [array];
+    }
+    return multipleSelect.multipleSelectFilter(_normalizedArray, filter);
+  }
+  if (linkedColumnType === cellType.CellType.MULTIPLE_SELECT) {
+    return multipleSelect.multipleSelectFilter(array, filter);
+  }
+  if (number.isNumericColumn({
+    type: linkedColumnType
+  })) {
+    var _normalizedArray2 = array;
+    if (Array.isArray(array)) {
+      var cellValueLength = array.length;
+      if (cellValueLength === 0) {
+        _normalizedArray2 = '';
+      } else if (cellValueLength === 1) {
+        _normalizedArray2 = array[0];
+      }
+    }
+    return number$1.numberFilter(_normalizedArray2, filter);
+  }
+  if (column.DATE_COLUMN_OPTIONS.includes(linkedColumnType)) {
+    var newCellValue = array;
+    if (Array.isArray(array)) {
+      newCellValue = String(array);
+    }
+    return date.dateFilter(newCellValue, filter);
+  }
+  if (column.COLLABORATOR_COLUMN_TYPES.includes(linkedColumnType)) {
+    return collaborator.collaboratorFilter(array, filter, username);
+  }
+  var displayString = cellValue.getFormulaDisplayString(array, column$1.data) || '';
+  return text.textFilter(displayString, filter, userId);
+};
+
+exports.filterByArrayType = filterByArrayType;

package/lib/filter/filter-column/checkbox.js

@@ -0,0 +1,18 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * Filter checkbox
+ * @param {bool} checked
+ * @param {bool} filter_term
+ * @returns boolean
+ */
+var checkboxFilter = function checkboxFilter(checked, _ref) {
+  var filter_term = _ref.filter_term;
+  var filterTerm = filter_term || false;
+  var normalizedChecked = checked || false;
+  return normalizedChecked === filterTerm;
+};
+
+exports.checkboxFilter = checkboxFilter;

package/lib/filter/filter-column/collaborator.js

@@ -0,0 +1,80 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _toConsumableArray = require('@babel/runtime/helpers/toConsumableArray');
+var filterPredicate = require('../../constants/filter/filter-predicate.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _toConsumableArray__default = /*#__PURE__*/_interopDefaultLegacy(_toConsumableArray);
+
+/**
+ * Filter collaborator
+ * @param {array} emails e.g. [ collaborator.email, ... ]
+ * @param {string} filter_predicate
+ * @param {array} filter_term e.g. [ collaborator.email, ... ]
+ * @param {string} username
+ * @returns bool
+ */
+var collaboratorFilter = function collaboratorFilter(emails, _ref, username) {
+  var filter_predicate = _ref.filter_predicate,
+    filter_term = _ref.filter_term;
+  switch (filter_predicate) {
+    case filterPredicate.FILTER_PREDICATE_TYPE.HAS_ANY_OF:
+      {
+        return !Array.isArray(filter_term) || filter_term.length === 0 || Array.isArray(emails) && filter_term.some(function (email) {
+          return emails.includes(email);
+        });
+      }
+    case filterPredicate.FILTER_PREDICATE_TYPE.HAS_ALL_OF:
+      {
+        return !Array.isArray(filter_term) || filter_term.length === 0 || Array.isArray(emails) && filter_term.every(function (email) {
+          return emails.includes(email);
+        });
+      }
+    case filterPredicate.FILTER_PREDICATE_TYPE.HAS_NONE_OF:
+      {
+        if (!Array.isArray(filter_term) || filter_term.length === 0 || !Array.isArray(emails) || emails.length === 0) {
+          return true;
+        }
+        return filter_term.every(function (email) {
+          return emails.indexOf(email) < 0;
+        });
+      }
+    case filterPredicate.FILTER_PREDICATE_TYPE.IS_EXACTLY:
+      {
+        if (!Array.isArray(filter_term) || filter_term.length === 0) {
+          return true;
+        }
+        if (!Array.isArray(emails) || emails.length === 0) {
+          return false;
+        }
+        var nonReptCellValue = _toConsumableArray__default["default"](new Set(emails));
+        if (nonReptCellValue.length !== filter_term.length) {
+          return false;
+        }
+        return filter_term.every(function (email) {
+          return nonReptCellValue.includes(email);
+        });
+      }
+    case filterPredicate.FILTER_PREDICATE_TYPE.EMPTY:
+      {
+        return !Array.isArray(emails) || emails.length === 0;
+      }
+    case filterPredicate.FILTER_PREDICATE_TYPE.NOT_EMPTY:
+      {
+        return Array.isArray(emails) && emails.length > 0;
+      }
+    case filterPredicate.FILTER_PREDICATE_TYPE.INCLUDE_ME:
+      {
+        return Array.isArray(emails) && emails.indexOf(username) > -1;
+      }
+    default:
+      {
+        return false;
+      }
+  }
+};
+
+exports.collaboratorFilter = collaboratorFilter;

package/lib/filter/filter-column/creator.js

@@ -0,0 +1,63 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var filterPredicate = require('../../constants/filter/filter-predicate.js');
+
+/**
+ * Filter creator
+ * @param {string} email
+ * @param {string} filter_predicate
+ * @param {array} filter_term e.g. [ collaborator.email, ... ]
+ * @param {string} username
+ * @returns bool
+ */
+var creatorFilter = function creatorFilter(email, _ref, username) {
+  var filter_predicate = _ref.filter_predicate,
+    filter_term = _ref.filter_term;
+  switch (filter_predicate) {
+    case filterPredicate.FILTER_PREDICATE_TYPE.CONTAINS:
+      {
+        if (!Array.isArray(filter_term)) {
+          return true;
+        }
+        if (!email) {
+          return false;
+        }
+        return filter_term.findIndex(function (filterEmail) {
+          return filterEmail === email;
+        }) > -1;
+      }
+    case filterPredicate.FILTER_PREDICATE_TYPE.NOT_CONTAIN:
+      {
+        if (!Array.isArray(filter_term) || !email) {
+          return true;
+        }
+        return filter_term.findIndex(function (filterEmail) {
+          return filterEmail === email;
+        }) < 0;
+      }
+    case filterPredicate.FILTER_PREDICATE_TYPE.INCLUDE_ME:
+      {
+        return email === username;
+      }
+    case filterPredicate.FILTER_PREDICATE_TYPE.IS:
+      {
+        if (!filter_term) return true;
+        if (!Array.isArray(filter_term)) return email === filter_term;
+        return email === filter_term[0];
+      }
+    case filterPredicate.FILTER_PREDICATE_TYPE.IS_NOT:
+      {
+        if (!filter_term) return true;
+        if (!Array.isArray(filter_term)) return email !== filter_term;
+        return email !== filter_term[0];
+      }
+    default:
+      {
+        return false;
+      }
+  }
+};
+
+exports.creatorFilter = creatorFilter;

package/lib/filter/filter-column/date.js

@@ -0,0 +1,106 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var date = require('../../date.js');
+var filterPredicate = require('../../constants/filter/filter-predicate.js');
+var filterModifier = require('../../constants/filter/filter-modifier.js');
+
+/**
+ * Filter date
+ * @param {string} date
+ * @param {string} filter_predicate
+ * @param {string} filter_term_modifier
+ * @param {any} filter_term date string or number etc.
+ * @param {string|object} other_date date string or { startDate, endDate }
+ * @returns bool
+ */
+var dateFilter = function dateFilter(date$1, _ref) {
+  var filter_predicate = _ref.filter_predicate,
+    filter_term_modifier = _ref.filter_term_modifier,
+    filter_term = _ref.filter_term,
+    other_date = _ref.other_date;
+  switch (filter_predicate) {
+    case filterPredicate.FILTER_PREDICATE_TYPE.IS:
+      {
+        return filter_term_modifier === filterModifier.FILTER_TERM_MODIFIER_TYPE.EXACT_DATE && !filter_term || date.DateUtils.format(date$1) === other_date;
+      }
+    case filterPredicate.FILTER_PREDICATE_TYPE.IS_WITHIN:
+      {
+        if (filter_term_modifier === filterModifier.FILTER_TERM_MODIFIER_TYPE.EXACT_DATE && !filter_term) {
+          return true;
+        }
+        if (!date$1) {
+          return false;
+        }
+        var startDate = other_date.startDate,
+          endDate = other_date.endDate;
+        var currentDate = date.DateUtils.format(date$1);
+        return currentDate >= startDate && currentDate <= endDate;
+      }
+    case filterPredicate.FILTER_PREDICATE_TYPE.IS_BEFORE:
+      {
+        if (filter_term_modifier === filterModifier.FILTER_TERM_MODIFIER_TYPE.EXACT_DATE && !filter_term) {
+          return true;
+        }
+        if (!date$1 || !date.DateUtils.getValidDate(date$1)) {
+          return false;
+        }
+        return date.DateUtils.format(date$1) < other_date;
+      }
+    case filterPredicate.FILTER_PREDICATE_TYPE.IS_AFTER:
+      {
+        if (filter_term_modifier === filterModifier.FILTER_TERM_MODIFIER_TYPE.EXACT_DATE && !filter_term) {
+          return true;
+        }
+        if (!date$1 || !date.DateUtils.getValidDate(date$1)) {
+          return false;
+        }
+        return date.DateUtils.format(date$1) > other_date;
+      }
+    case filterPredicate.FILTER_PREDICATE_TYPE.IS_ON_OR_BEFORE:
+      {
+        if (filter_term_modifier === filterModifier.FILTER_TERM_MODIFIER_TYPE.EXACT_DATE && !filter_term) {
+          return true;
+        }
+        if (!date$1 || !date.DateUtils.getValidDate(date$1)) {
+          return false;
+        }
+        return date.DateUtils.format(date$1) <= other_date;
+      }
+    case filterPredicate.FILTER_PREDICATE_TYPE.IS_ON_OR_AFTER:
+      {
+        if (filter_term_modifier === filterModifier.FILTER_TERM_MODIFIER_TYPE.EXACT_DATE && !filter_term) {
+          return true;
+        }
+        if (!date$1 || !date.DateUtils.getValidDate(date$1)) {
+          return false;
+        }
+        return date.DateUtils.format(date$1) >= other_date;
+      }
+    case filterPredicate.FILTER_PREDICATE_TYPE.IS_NOT:
+      {
+        if (filter_term_modifier === filterModifier.FILTER_TERM_MODIFIER_TYPE.EXACT_DATE && !filter_term) {
+          return true;
+        }
+        if (!date$1 || !date.DateUtils.getValidDate(date$1)) {
+          return false;
+        }
+        return date.DateUtils.format(date$1) !== other_date;
+      }
+    case filterPredicate.FILTER_PREDICATE_TYPE.EMPTY:
+      {
+        return !(date$1 && date.DateUtils.getValidDate(date$1));
+      }
+    case filterPredicate.FILTER_PREDICATE_TYPE.NOT_EMPTY:
+      {
+        return !!(date$1 && date.DateUtils.getValidDate(date$1));
+      }
+    default:
+      {
+        return false;
+      }
+  }
+};
+
+exports.dateFilter = dateFilter;