dtable-utils 0.0.1 → 0.0.3-beta.1

package/lib/filter/core.js

@@ -0,0 +1,301 @@
+'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 [{ column_key: '', filter_predicate: '' }]
+ * @param {array} columns
+ * @returns 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 [{ column_key: '', filter_predicate: '' }]
+ * @param {array} columns
+ * @returns 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;
+  });
+};
+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();
+  var days = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+  //          0   1   2   3    4   5   6   7   8   9  10  11
+  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 {};
+      }
+  }
+};
+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 _ref = _otherDate || {},
+    startDate = _ref.startDate,
+    endDate = _ref.endDate;
+  return {
+    startDate: date.DateUtils.format(startDate),
+    endDate: date.DateUtils.format(endDate)
+  };
+};
+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);
+        } else 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 _ref2 = columnData || {},
+          _array_type = _ref2.array_type,
+          _array_data = _ref2.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;
+};
+var getFormattedFilters = function getFormattedFilters(filters) {
+  return filters.map(function (filter) {
+    return getFormattedFilter(filter, filter.column);
+  });
+};
+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) {
+        return;
+      }
+      throw new Error(error_message);
+    }
+    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,86 @@
+'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');
+require('../../constants/filter/filter-column-options.js');
+require('../../constants/filter/filter-modifier.js');
+var filterPredicate = require('../../constants/filter/filter-predicate.js');
+require('../../constants/filter/filter-is-within.js');
+
+var TRUE_VALUE = [true, 'true'];
+var filterByArrayType = function filterByArrayType(cellValue$1, 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(cellValue$1)) {
+    if (filter_predicate === filterPredicate.FILTER_PREDICATE_TYPE.EMPTY) {
+      return cellValue$1.length === 0;
+    }
+    if (filter_predicate === filterPredicate.FILTER_PREDICATE_TYPE.NOT_EMPTY) {
+      return cellValue$1.length > 0;
+    }
+  }
+  if (!linked_column) {
+    return text.textFilter('', filter, userId);
+  }
+  var data = column$1.data;
+  var linkedColumnType = linked_column.type;
+  if (linkedColumnType === cellType.CellType.BOOL || linkedColumnType === cellType.CellType.CHECKBOX) {
+    var normalizedCellValue = cellValue$1;
+    if (Array.isArray(cellValue$1)) {
+      normalizedCellValue = cellValue$1[0];
+    }
+    normalizedCellValue = TRUE_VALUE.includes(normalizedCellValue);
+    return checkbox.checkboxFilter(normalizedCellValue, filter);
+  }
+  if (linkedColumnType === cellType.CellType.SINGLE_SELECT) {
+    var _normalizedCellValue = cellValue$1;
+    if (cellValue$1 && !Array.isArray(cellValue$1)) {
+      _normalizedCellValue = [cellValue$1];
+    }
+    return multipleSelect.multipleSelectFilter(_normalizedCellValue, filter);
+  }
+  if (linkedColumnType === cellType.CellType.MULTIPLE_SELECT) {
+    return multipleSelect.multipleSelectFilter(cellValue$1, filter);
+  }
+  if (number.isNumericColumn({
+    type: linkedColumnType
+  })) {
+    var _normalizedCellValue2 = cellValue$1;
+    if (Array.isArray(cellValue$1)) {
+      var cellValueLength = cellValue$1.length;
+      if (cellValueLength === 0) {
+        _normalizedCellValue2 = '';
+      } else if (cellValueLength === 1) {
+        _normalizedCellValue2 = cellValue$1[0];
+      }
+    }
+    return number$1.numberFilter(_normalizedCellValue2, filter);
+  }
+  if (column.DATE_COLUMN_OPTIONS.includes(linkedColumnType)) {
+    var newCellValue = cellValue$1;
+    if (Array.isArray(cellValue$1)) {
+      newCellValue = String(cellValue$1);
+    }
+    return date.dateFilter(newCellValue, filter);
+  }
+  if (column.COLLABORATOR_COLUMN_TYPES.includes(linkedColumnType)) {
+    return collaborator.collaboratorFilter(cellValue$1, filter, username);
+  }
+  var sCellValue = cellValue.getFormulaDisplayString(cellValue$1, data) || '';
+  return text.textFilter(sCellValue, filter, userId);
+};
+
+exports.filterByArrayType = filterByArrayType;

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

@@ -0,0 +1,12 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var checkboxFilter = function checkboxFilter(cellValue, _ref) {
+  var filter_term = _ref.filter_term;
+  var filterTerm = filter_term || false;
+  var normalizedCellValue = cellValue || false;
+  return normalizedCellValue === filterTerm;
+};
+
+exports.checkboxFilter = checkboxFilter;

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

@@ -0,0 +1,75 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _toConsumableArray = require('@babel/runtime/helpers/toConsumableArray');
+require('../../constants/filter/filter-column-options.js');
+require('../../constants/filter/filter-modifier.js');
+var filterPredicate = require('../../constants/filter/filter-predicate.js');
+require('../../constants/filter/filter-is-within.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _toConsumableArray__default = /*#__PURE__*/_interopDefaultLegacy(_toConsumableArray);
+
+var collaboratorFilter = function collaboratorFilter(cellValue, _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(cellValue) && filter_term.some(function (email) {
+          return cellValue.includes(email);
+        });
+      }
+    case filterPredicate.FILTER_PREDICATE_TYPE.HAS_ALL_OF:
+      {
+        return !Array.isArray(filter_term) || filter_term.length === 0 || Array.isArray(cellValue) && filter_term.every(function (email) {
+          return cellValue.includes(email);
+        });
+      }
+    case filterPredicate.FILTER_PREDICATE_TYPE.HAS_NONE_OF:
+      {
+        if (!Array.isArray(filter_term) || filter_term.length === 0 || !Array.isArray(cellValue) || cellValue.length === 0) {
+          return true;
+        }
+        return filter_term.every(function (email) {
+          return cellValue.indexOf(email) < 0;
+        });
+      }
+    case filterPredicate.FILTER_PREDICATE_TYPE.IS_EXACTLY:
+      {
+        if (!Array.isArray(filter_term) || filter_term.length === 0) {
+          return true;
+        }
+        if (!Array.isArray(cellValue) || cellValue.length === 0) {
+          return false;
+        }
+        var nonReptCellValue = _toConsumableArray__default["default"](new Set(cellValue));
+        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(cellValue) || cellValue.length === 0;
+      }
+    case filterPredicate.FILTER_PREDICATE_TYPE.NOT_EMPTY:
+      {
+        return Array.isArray(cellValue) && cellValue.length > 0;
+      }
+    case filterPredicate.FILTER_PREDICATE_TYPE.INCLUDE_ME:
+      {
+        return Array.isArray(cellValue) && cellValue.indexOf(username) > -1;
+      }
+    default:
+      {
+        return false;
+      }
+  }
+};
+
+exports.collaboratorFilter = collaboratorFilter;

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

@@ -0,0 +1,54 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('../../constants/filter/filter-column-options.js');
+require('../../constants/filter/filter-modifier.js');
+var filterPredicate = require('../../constants/filter/filter-predicate.js');
+require('../../constants/filter/filter-is-within.js');
+
+var creatorFilter = function creatorFilter(cellValue, _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 (!cellValue) {
+          return false;
+        }
+        return filter_term.findIndex(function (item) {
+          return item === cellValue;
+        }) > -1;
+      }
+    case filterPredicate.FILTER_PREDICATE_TYPE.NOT_CONTAIN:
+      {
+        if (!Array.isArray(filter_term) || !cellValue) {
+          return true;
+        }
+        return filter_term.findIndex(function (item) {
+          return item === cellValue;
+        }) < 0;
+      }
+    case filterPredicate.FILTER_PREDICATE_TYPE.INCLUDE_ME:
+      {
+        return cellValue === username;
+      }
+    case filterPredicate.FILTER_PREDICATE_TYPE.IS:
+      {
+        return !Array.isArray(filter_term) || cellValue === filter_term[0];
+      }
+    case filterPredicate.FILTER_PREDICATE_TYPE.IS_NOT:
+      {
+        return !Array.isArray(filter_term) || cellValue !== filter_term[0];
+      }
+    default:
+      {
+        return false;
+      }
+  }
+};
+
+exports.creatorFilter = creatorFilter;

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

@@ -0,0 +1,63 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var date = require('../../date.js');
+require('../../constants/filter/filter-column-options.js');
+var filterModifier = require('../../constants/filter/filter-modifier.js');
+var filterPredicate = require('../../constants/filter/filter-predicate.js');
+require('../../constants/filter/filter-is-within.js');
+
+var dateFilter = function dateFilter(cellValue, _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(cellValue) === other_date;
+      }
+    case filterPredicate.FILTER_PREDICATE_TYPE.IS_WITHIN:
+      {
+        var startDate = other_date.startDate,
+          endDate = other_date.endDate;
+        var currentDate = date.DateUtils.format(cellValue);
+        return filter_term_modifier === filterModifier.FILTER_TERM_MODIFIER_TYPE.EXACT_DATE && !filter_term || !!cellValue && currentDate >= startDate && currentDate <= endDate;
+      }
+    case filterPredicate.FILTER_PREDICATE_TYPE.IS_BEFORE:
+      {
+        return filter_term_modifier === filterModifier.FILTER_TERM_MODIFIER_TYPE.EXACT_DATE && !filter_term || !!cellValue && date.DateUtils.getValidDate(cellValue) && date.DateUtils.format(cellValue) < other_date;
+      }
+    case filterPredicate.FILTER_PREDICATE_TYPE.IS_AFTER:
+      {
+        return filter_term_modifier === filterModifier.FILTER_TERM_MODIFIER_TYPE.EXACT_DATE && !filter_term || !!cellValue && date.DateUtils.getValidDate(cellValue) && date.DateUtils.format(cellValue) > other_date;
+      }
+    case filterPredicate.FILTER_PREDICATE_TYPE.IS_ON_OR_BEFORE:
+      {
+        return filter_term_modifier === filterModifier.FILTER_TERM_MODIFIER_TYPE.EXACT_DATE && !filter_term || !!cellValue && date.DateUtils.getValidDate(cellValue) && date.DateUtils.format(cellValue) <= other_date;
+      }
+    case filterPredicate.FILTER_PREDICATE_TYPE.IS_ON_OR_AFTER:
+      {
+        return filter_term_modifier === filterModifier.FILTER_TERM_MODIFIER_TYPE.EXACT_DATE && !filter_term || !!cellValue && date.DateUtils.getValidDate(cellValue) && date.DateUtils.format(cellValue) >= other_date;
+      }
+    case filterPredicate.FILTER_PREDICATE_TYPE.IS_NOT:
+      {
+        return filter_term_modifier === filterModifier.FILTER_TERM_MODIFIER_TYPE.EXACT_DATE && !filter_term || !cellValue || date.DateUtils.format(cellValue) !== other_date;
+      }
+    case filterPredicate.FILTER_PREDICATE_TYPE.EMPTY:
+      {
+        return cellValue && date.DateUtils.getValidDate(cellValue) ? false : true;
+      }
+    case filterPredicate.FILTER_PREDICATE_TYPE.NOT_EMPTY:
+      {
+        return cellValue && date.DateUtils.getValidDate(cellValue) ? true : false;
+      }
+    default:
+      {
+        return false;
+      }
+  }
+};
+
+exports.dateFilter = dateFilter;

package/lib/filter/filter-column/digital-sign.js

@@ -0,0 +1,30 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('../../constants/filter/filter-column-options.js');
+require('../../constants/filter/filter-modifier.js');
+var filterPredicate = require('../../constants/filter/filter-predicate.js');
+require('../../constants/filter/filter-is-within.js');
+
+var digitalSignFilter = function digitalSignFilter(cellValue, _ref) {
+  var filter_predicate = _ref.filter_predicate;
+  switch (filter_predicate) {
+    case filterPredicate.FILTER_PREDICATE_TYPE.EMPTY:
+      {
+        if (!cellValue) return true;
+        return !cellValue.username || !cellValue.sign_time || !cellValue.sign_image_url;
+      }
+    case filterPredicate.FILTER_PREDICATE_TYPE.NOT_EMPTY:
+      {
+        if (!cellValue) return false;
+        return cellValue.username && cellValue.sign_time && cellValue.sign_image_url ? true : false;
+      }
+    default:
+      {
+        return false;
+      }
+  }
+};
+
+exports.digitalSignFilter = digitalSignFilter;

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

@@ -0,0 +1,28 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('../../constants/filter/filter-column-options.js');
+require('../../constants/filter/filter-modifier.js');
+var filterPredicate = require('../../constants/filter/filter-predicate.js');
+require('../../constants/filter/filter-is-within.js');
+
+var fileFilter = function fileFilter(cellValue, _ref) {
+  var filter_predicate = _ref.filter_predicate;
+  switch (filter_predicate) {
+    case filterPredicate.FILTER_PREDICATE_TYPE.EMPTY:
+      {
+        return cellValue && cellValue.length > 0 ? false : true;
+      }
+    case filterPredicate.FILTER_PREDICATE_TYPE.NOT_EMPTY:
+      {
+        return cellValue && cellValue.length > 0 ? true : false;
+      }
+    default:
+      {
+        return false;
+      }
+  }
+};
+
+exports.fileFilter = fileFilter;