dtable-utils 0.0.3 → 0.0.4-beta.1

package/lib/color/gradient-color.js

@@ -0,0 +1,110 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var _classCallCheck = require('@babel/runtime/helpers/classCallCheck');
+var _createClass = require('@babel/runtime/helpers/createClass');
+var color = require('../constants/color.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
+var _classCallCheck__default = /*#__PURE__*/_interopDefaultLegacy(_classCallCheck);
+var _createClass__default = /*#__PURE__*/_interopDefaultLegacy(_createClass);
+
+var GradientColorUtils = /*#__PURE__*/function () {
+  function GradientColorUtils(_ref) {
+    var colorType = _ref.colorType,
+      max = _ref.max,
+      min = _ref.min;
+    _classCallCheck__default["default"](this, GradientColorUtils);
+    var newColorType = colorType || 'color_gradation_1';
+    var colors = color.COLOR_GRADATION_OPTIONS[newColorType];
+    this.startColor = this.hexToRgb(colors[0]);
+    this.endColor = this.hexToRgb(colors[4]);
+    this.min = min;
+    this.max = max;
+    this.computeMap = {};
+  }
+  _createClass__default["default"](GradientColorUtils, [{
+    key: "hexToRgb",
+    value: function hexToRgb(hexCode) {
+      var reg = /^#([0-9a-fA-f]{3}|[0-9a-fA-f]{6})$/;
+      var nextHexCode = hexCode.toLowerCase();
+      if (nextHexCode && reg.test(nextHexCode)) {
+        if (nextHexCode.length === 4) {
+          var newHexCode = '#';
+          for (var i = 1; i < 4; i += 1) {
+            newHexCode += nextHexCode.slice(i, i + 1).concat(nextHexCode.slice(i, i + 1));
+          }
+          nextHexCode = newHexCode;
+        }
+        var hexCodeChange = [];
+        for (var _i = 1; _i < 7; _i += 2) {
+          hexCodeChange.push(parseInt("0x".concat(nextHexCode.slice(_i, _i + 2))));
+        }
+        return "RGB(".concat(hexCodeChange.join(','), ")");
+      }
+      return nextHexCode;
+    }
+  }, {
+    key: "getColorGradation",
+    value: function getColorGradation(color1, color2, value1, value2, value) {
+      var rgb1 = color1.split(',');
+      var r1 = parseInt(rgb1[0].split('(')[1]);
+      var g1 = parseInt(rgb1[1]);
+      var b1 = parseInt(rgb1[2].split(')')[0]);
+      var rgb2 = color2.split(',');
+      var r2 = parseInt(rgb2[0].split('(')[1]);
+      var g2 = parseInt(rgb2[1]);
+      var b2 = parseInt(rgb2[2].split(')')[0]);
+      var r = Math.round(r1 - (r1 - r2) / (value1 - value2) * (value1 - value));
+      var g = Math.round(g1 - (g1 - g2) / (value1 - value2) * (value1 - value));
+      var b = Math.round(b1 - (b1 - b2) / (value1 - value2) * (value1 - value));
+      return "rgb(".concat(r, ", ").concat(g, ", ").concat(b, ")");
+    }
+  }, {
+    key: "getCellColor",
+    value: function getCellColor(value) {
+      if (this.computeMap[value]) {
+        return this.computeMap[value];
+      }
+
+      // eslint-disable-next-line
+      if (value == this.min) {
+        if (this.computeMap[value]) {
+          this.computeMap[value] = this.startColor;
+        } else {
+          this.computeMap = _defineProperty__default["default"]({}, value, this.startColor);
+        }
+        return this.computeMap[value];
+      }
+
+      // eslint-disable-next-line
+      if (value == this.max) {
+        if (this.computeMap[value]) {
+          this.computeMap[value] = this.endColor;
+        } else {
+          this.computeMap = _defineProperty__default["default"]({}, value, this.endColor);
+        }
+        return this.computeMap[value];
+      }
+      if (value > this.min && value < this.max) {
+        var color1 = this.startColor,
+          color2 = this.endColor,
+          value1 = this.min,
+          value2 = this.max;
+        var color = this.getColorGradation(color1, color2, value1, value2, value);
+        this.computeMap[value] = color;
+        return this.computeMap[value];
+      }
+
+      // value < min || value > max
+      return null;
+    }
+  }]);
+  return GradientColorUtils;
+}();
+
+exports["default"] = GradientColorUtils;

package/lib/color/row-color.js

@@ -0,0 +1,297 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var column = require('../table/column.js');
+var row = require('../table/row.js');
+var core$1 = require('../row/core.js');
+var option = require('../column/option.js');
+var geolocation = require('../cell-value-get/geolocation.js');
+var filter = require('../validate/filter.js');
+var core = require('../filter/core.js');
+var filterRow = require('../filter/filter-row.js');
+var rowColor = require('../constants/row-color.js');
+var cellType = require('../constants/cell-type.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 isValidRowColorRule = function isValidRowColorRule(rule, columns) {
+  var filters = rule.filters;
+  if (!filters || filters.length === 0) return false;
+  return filters.some(function (filter$1) {
+    return !filter.ValidateFilter.validate(filter$1, columns).error_message;
+  });
+};
+var getValidRowColorRules = function getValidRowColorRules(colorRules, columns) {
+  return colorRules.filter(function (colorRule) {
+    return isValidRowColorRule(colorRule, columns);
+  });
+};
+var getOptionIdMap = function getOptionIdMap(options) {
+  if (!Array.isArray(options) || options.length === 0) return {};
+  var optionsMap = {};
+  options.forEach(function (option) {
+    optionsMap[option.id] = true;
+  });
+  return optionsMap;
+};
+var getFormattedDuplicateColumns = function getFormattedDuplicateColumns(columns, duplicateColumnKeys, _ref) {
+  var collaborators = _ref.collaborators;
+  var formattedColumns = [];
+  var _loop = function _loop() {
+    var key = duplicateColumnKeys[i];
+    var currColumn = columns.find(function (column) {
+      return column.key === key;
+    });
+    if (!currColumn) return "continue";
+    var type = currColumn.type,
+      data = currColumn.data;
+    var formattedColumnData = data;
+    if (!rowColor.SUPPORT_CHECKING_DUPLICATE_COLUMNS_TYPES.includes(type)) return "continue";
+    if (type === cellType.CellType.SINGLE_SELECT || type === cellType.CellType.MULTIPLE_SELECT) {
+      var options = option.getColumnOptions(currColumn);
+      formattedColumnData = getOptionIdMap(options);
+    } else if (type === cellType.CellType.COLLABORATOR) {
+      var optionsMap = {};
+      if (Array.isArray(collaborators)) {
+        collaborators.forEach(function (collaborator) {
+          optionsMap[collaborator.email] = true;
+        });
+      }
+      formattedColumnData = optionsMap;
+    }
+    formattedColumns.push({
+      key: key,
+      type: type,
+      data: formattedColumnData
+    });
+  };
+  for (var i = 0; i < duplicateColumnKeys.length; i++) {
+    var _ret = _loop();
+    if (_ret === "continue") continue;
+  }
+  return formattedColumns;
+};
+var getDuplicateRowValue = function getDuplicateRowValue(row, columns, formulaRow) {
+  if (!row) return '';
+  var rowValue = columns.map(function (column) {
+    var type = column.type,
+      data = column.data,
+      key = column.key;
+    var cellValue = row[key];
+    switch (type) {
+      case cellType.CellType.SINGLE_SELECT:
+        {
+          return data[cellValue] ? cellValue : '';
+        }
+      case cellType.CellType.MULTIPLE_SELECT:
+      case cellType.CellType.COLLABORATOR:
+        {
+          if (!Array.isArray(cellValue) || cellValue.length === 0) return '';
+          return cellValue.filter(function (item) {
+            return data[item];
+          }).sort().join('');
+        }
+      case cellType.CellType.GEOLOCATION:
+        {
+          if (!cellValue) return '';
+          return geolocation.getGeolocationDisplayString(cellValue, data) || '';
+        }
+      case cellType.CellType.NUMBER:
+        {
+          if (!cellValue && cellValue !== 0) return '';
+          return cellValue;
+        }
+      case cellType.CellType.FORMULA:
+        {
+          if (!formulaRow) return '';
+          cellValue = formulaRow[key];
+          return cellValue;
+        }
+      default:
+        {
+          return cellValue || '';
+        }
+    }
+  }).join('_seatable_join_key_');
+  if (!rowValue) return '';
+  if (typeof ''.replaceAll !== 'function') {
+    // eslint-disable-next-line
+    String.prototype.replaceAll = function (s1, s2) {
+      return this.replace(new RegExp(s1, 'gm'), s2);
+    };
+  }
+  if (!rowValue.replaceAll('_seatable_join_key_', '')) return '';
+  return rowValue;
+};
+var getRowsColorBySingleSelectColumn = function getRowsColorBySingleSelectColumn(rows, columnKey, table) {
+  var colors = {};
+  var column$1 = column.getTableColumnByKey(table, columnKey);
+  var options = option.getColumnOptions(column$1);
+  if (!Array.isArray(options) || options.length === 0) return {};
+  var option_id_color_map = {};
+  options.forEach(function (option) {
+    option_id_color_map[option.id] = option.color;
+  });
+  rows.forEach(function (row) {
+    var optionId = row[columnKey];
+    var color = optionId ? option_id_color_map[optionId] : '';
+    if (color) {
+      colors[row._id] = color;
+    }
+  });
+  return colors;
+};
+var getRowsColorByRules = function getRowsColorByRules(rows, view, table) {
+  var _ref2 = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {},
+    username = _ref2.username,
+    userId = _ref2.userId;
+  var formula_rows = view.formula_rows,
+    colorbys = view.colorbys;
+  var _ref3 = colorbys || {},
+    type = _ref3.type,
+    color_by_rules = _ref3.color_by_rules;
+  if (type !== rowColor.ROW_COLOR_TYPE.BY_RULES) return {};
+  var columns = table.columns;
+  var validColorRules = getValidRowColorRules(color_by_rules, columns);
+  var colorRulesLen = validColorRules.length;
+  var colors = {};
+  if (colorRulesLen === 0) return {};
+  validColorRules = validColorRules.map(function (colorRule) {
+    var filters = colorRule.filters;
+    var validFilters;
+    try {
+      validFilters = core.deleteInvalidFilter(filters, columns);
+    } catch (err) {
+      validFilters = [];
+    }
+    validFilters = core.getFormattedFilters(validFilters);
+    return _objectSpread(_objectSpread({}, colorRule), {}, {
+      filters: validFilters
+    });
+  });
+  rows.forEach(function (row) {
+    var rowId = row._id;
+    var formulaRow = formula_rows && formula_rows[rowId] || {};
+    for (var i = 0; i < colorRulesLen; i++) {
+      var colorRule = validColorRules[i];
+      var color = colorRule.color,
+        filter_conjunction = colorRule.filter_conjunction,
+        filters = colorRule.filters;
+      if (filterRow.filterRow(row, filter_conjunction, filters, {
+        formulaRow: formulaRow,
+        username: username,
+        userId: userId
+      })) {
+        colors[rowId] = color;
+        break;
+      }
+    }
+  });
+  return colors;
+};
+var getRowsColorByDuplicateValues = function getRowsColorByDuplicateValues(rows, view, table, _ref4) {
+  var collaborators = _ref4.collaborators;
+  var colorbys = view.colorbys,
+    formula_rows = view.formula_rows;
+  var color_by_duplicate_column_keys = colorbys.color_by_duplicate_column_keys;
+  if (!Array.isArray(color_by_duplicate_column_keys) || color_by_duplicate_column_keys.length === 0) return {};
+  var columns = table.columns;
+  var formattedColumns = getFormattedDuplicateColumns(columns, color_by_duplicate_column_keys, {
+    collaborators: collaborators
+  });
+  if (formattedColumns.length === 0) return {};
+  var colors = {};
+  var duplicate_rows_ids_map = {}; // row value: [ row_id ]
+  for (var i = 0; i < rows.length; i++) {
+    var row = rows[i];
+    var rowId = row._id;
+    var formulaRow = formula_rows && formula_rows[rowId];
+    var rowValue = getDuplicateRowValue(row, formattedColumns, formulaRow);
+    if (!rowValue) continue;
+    var validRowIds = duplicate_rows_ids_map[rowValue];
+    if (validRowIds && validRowIds.length > 0) {
+      colors[rowId] = rowColor.ROW_COLOR_FOR_DUPLICATE_VALUES;
+      validRowIds.push(rowId);
+      var firstDuplicateRowId = validRowIds[0];
+      if (!colors[firstDuplicateRowId]) {
+        colors[firstDuplicateRowId] = rowColor.ROW_COLOR_FOR_DUPLICATE_VALUES;
+      }
+    } else {
+      duplicate_rows_ids_map[rowValue] = [rowId];
+    }
+  }
+  return {
+    colors: colors,
+    duplicate_rows_ids_map: duplicate_rows_ids_map
+  };
+};
+
+/**
+ * Calculate rows color.
+ * @param {array} rows
+ * @param {object} view
+ * @param {object} table e.g. { id_row_map, ... }
+ * @param {object} value e.g. { tables, collaborators, ... }
+ * @param {string} username
+ * @param {userId} username
+ * @returns rows color, object
+ */
+var getRowsColor = function getRowsColor(rows, view, table, value) {
+  var _ref5 = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {},
+    username = _ref5.username,
+    userId = _ref5.userId;
+  var colorbys = view.colorbys;
+  if (!colorbys) return {};
+  var tableRows = core$1.isTableRows(rows) ? rows : row.getRowsByIds(table, rows);
+  if (tableRows.length === 0) return {};
+  var type = colorbys.type,
+    color_by_column = colorbys.color_by_column;
+  switch (type) {
+    case rowColor.ROW_COLOR_TYPE.BY_COLUMN:
+      {
+        return {
+          colors: getRowsColorBySingleSelectColumn(tableRows, color_by_column, table)
+        };
+      }
+    case rowColor.ROW_COLOR_TYPE.BY_RULES:
+      {
+        return {
+          colors: getRowsColorByRules(tableRows, view, table, {
+            username: username,
+            userId: userId
+          })
+        };
+      }
+    case rowColor.ROW_COLOR_TYPE.BY_DUPLICATE_VALUES:
+      {
+        var _ref6 = value || {},
+          _ref6$collaborators = _ref6.collaborators,
+          collaborators = _ref6$collaborators === void 0 ? [] : _ref6$collaborators;
+        return getRowsColorByDuplicateValues(tableRows, view, table, {
+          collaborators: collaborators
+        });
+      }
+    default:
+      {
+        return {};
+      }
+  }
+};
+var RowColorUtils = {
+  isValidRowColorRule: isValidRowColorRule,
+  getValidRowColorRules: getValidRowColorRules,
+  getRowsColor: getRowsColor,
+  getFormattedDuplicateColumns: getFormattedDuplicateColumns,
+  getDuplicateRowValue: getDuplicateRowValue,
+  getRowsColorBySingleSelectColumn: getRowsColorBySingleSelectColumn,
+  getRowsColorByRules: getRowsColorByRules,
+  getRowsColorByDuplicateValues: getRowsColorByDuplicateValues
+};
+
+exports["default"] = RowColorUtils;

package/lib/column/{common.js → core.js}

@@ -7,7 +7,7 @@ var formula = require('../constants/formula.js');
 
 /**
  * Get column type.
- * @param {object} column { type: 'xxx', ... }
+ * @param {object} column { type, ... }
  * @returns column type
  */
 var getColumnType = function getColumnType(column) {
@@ -30,17 +30,4 @@ var getColumnType = function getColumnType(column) {
   return type;
 };
 
-/**
- * Get options from single-select/multiple-select column.
- * @param {object} column e.g. { type, data: { options: [] } }
- * @returns options, array
- */
-var getColumnOptions = function getColumnOptions(column) {
-  if (!column || !column.data || !Array.isArray(column.data.options)) {
-    return [];
-  }
-  return column.data.options;
-};
-
-exports.getColumnOptions = getColumnOptions;
 exports.getColumnType = getColumnType;

package/lib/column/date.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var common = require('./common.js');
+var core = require('./core.js');
 var column = require('../constants/column.js');
 
 /**
@@ -14,7 +14,7 @@ var column = require('../constants/column.js');
  * @returns true/false, bool
  */
 var isDateColumn = function isDateColumn(column$1) {
-  return column.DATE_COLUMN_OPTIONS.includes(common.getColumnType(column$1));
+  return column.DATE_COLUMN_OPTIONS.includes(core.getColumnType(column$1));
 };
 
 exports.isDateColumn = isDateColumn;

package/lib/column/number.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var common = require('./common.js');
+var core = require('./core.js');
 var cellType = require('../constants/cell-type.js');
 var column = require('../constants/column.js');
 
@@ -15,7 +15,7 @@ var column = require('../constants/column.js');
  * @returns true/false, bool
  */
 var isNumericColumn = function isNumericColumn(column$1) {
-  return column.NUMERIC_COLUMNS_TYPES.includes(common.getColumnType(column$1));
+  return column.NUMERIC_COLUMNS_TYPES.includes(core.getColumnType(column$1));
 };
 
 /**
@@ -27,7 +27,7 @@ var isNumericColumn = function isNumericColumn(column$1) {
  * @returns true/false, bool
  */
 var isNumberColumn = function isNumberColumn(column) {
-  return common.getColumnType(column) === cellType.CellType.NUMBER;
+  return core.getColumnType(column) === cellType.CellType.NUMBER;
 };
 
 exports.isNumberColumn = isNumberColumn;

package/lib/column/option.js

@@ -0,0 +1,153 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var selectOption = require('../constants/select-option.js');
+
+/**
+ * Get options from single-select/multiple-select column.
+ * @param {object} column e.g. { type, data: { options: [] } }
+ * @returns options, array
+ */
+var getColumnOptions = function getColumnOptions(column) {
+  if (!column || !column.data || !Array.isArray(column.data.options)) {
+    return [];
+  }
+  return column.data.options;
+};
+
+/**
+ * generate unique option id
+ * @param {array} options e.g. [{ id, ... }, ...]
+ * @returns generated option id, string
+ */
+var generateOptionID = function generateOptionID(options) {
+  if (options.length === 1) return String(Math.floor(Math.random() * Math.pow(10, 6)));
+  var optionID;
+  var isIDUnique = false;
+  while (!isIDUnique) {
+    optionID = String(Math.floor(Math.random() * Math.pow(10, 6)));
+
+    // eslint-disable-next-line
+    isIDUnique = options.every(function (option) {
+      return option.id !== optionID;
+    });
+    if (isIDUnique) {
+      break;
+    }
+  }
+  return optionID;
+};
+var getRandomOptionColor = function getRandomOptionColor(options) {
+  var defaultOptions = selectOption.SELECT_OPTION_COLORS.slice(12, 24);
+  var colorIdx = Math.floor(Math.random() * defaultOptions.length);
+  if (!Array.isArray(options) || options.length === 0) {
+    return defaultOptions[colorIdx];
+  }
+
+  // Avoid using the same color for adjacent labels
+  var adjacentOptions = options.slice(-(defaultOptions.length - 1));
+  var adjacentOptionsColorIdxArr = [];
+  var selectOptionColorObj = {};
+  defaultOptions.forEach(function (colorItem, index) {
+    selectOptionColorObj[colorItem.COLOR] = index;
+  });
+  adjacentOptions.forEach(function (option) {
+    var optionColorIdx = selectOptionColorObj[option.color];
+    adjacentOptionsColorIdxArr.push(optionColorIdx);
+  });
+
+  // eslint-disable-next-line
+  while (adjacentOptionsColorIdxArr.indexOf(colorIdx) != -1) {
+    colorIdx = Math.floor(Math.random() * defaultOptions.length);
+  }
+  return defaultOptions[colorIdx] || defaultOptions[0];
+};
+
+/**
+ * generate option
+ * @param {array} options e.g. [{ id, ... }, ...]
+ * @param {string} optionName
+ * @param {string} optionColor used to find system support color options. The new color option will be generated if not found by "optionColor" or not supported
+ * @returns generated option, object
+ */
+var createOption = function createOption(options, optionName) {
+  var optionColor = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+  var id = generateOptionID(options);
+  var colors = optionColor && selectOption.SELECT_OPTION_COLORS.find(function (systemColor) {
+    return systemColor.COLOR === optionColor;
+  });
+  if (!colors) {
+    colors = getRandomOptionColor(options);
+  }
+  return {
+    id: id,
+    name: optionName,
+    color: colors.COLOR,
+    textColor: colors.TEXT_COLOR
+  };
+};
+
+/**
+ * Generate cell option by name.
+ * Return the option id if exist, otherwise generate a new option
+ * @param {array} options e.g. [{ id, ... }, ...]
+ * @param {string} optionName used as the option name
+ * @returns option id and option, object
+ */
+var generatorCellOption = function generatorCellOption(options, optionName) {
+  var existOption = options.find(function (option) {
+    return option.name === optionName;
+  });
+  if (existOption) {
+    return {
+      selectedOptionId: existOption.id
+    };
+  }
+  var newOption = createOption(options, optionName) || {};
+  return {
+    cellOption: newOption,
+    selectedOptionId: newOption.id
+  };
+};
+
+/**
+ * Generate cell options by names.
+ * Return the options ids if exist, otherwise generate new options
+ * @param {array} options e.g. [{ id, ... }, ...]
+ * @param {array} optionNames used as the options names
+ * @returns options ids and options, object
+ */
+var generatorCellOptions = function generatorCellOptions(options, optionNames) {
+  var cellOptions = [];
+  var selectedOptionIds = [];
+  optionNames.forEach(function (optionName) {
+    var existingOption = options.find(function (option) {
+      return option.name === optionName;
+    });
+    if (existingOption) {
+      selectedOptionIds.push(existingOption.id);
+    } else {
+      var cellOption = createOption(options, optionName);
+      if (cellOption) {
+        cellOptions.push(cellOption);
+        selectedOptionIds.push(cellOption.id);
+      }
+    }
+  });
+  if (cellOptions.length === 0) {
+    return {
+      selectedOptionIds: selectedOptionIds
+    };
+  }
+  return {
+    cellOptions: cellOptions,
+    selectedOptionIds: selectedOptionIds
+  };
+};
+
+exports.createOption = createOption;
+exports.generateOptionID = generateOptionID;
+exports.generatorCellOption = generatorCellOption;
+exports.generatorCellOptions = generatorCellOptions;
+exports.getColumnOptions = getColumnOptions;

package/lib/common.js

@@ -2,6 +2,12 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var _typeof = require('@babel/runtime/helpers/typeof');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _typeof__default = /*#__PURE__*/_interopDefaultLegacy(_typeof);
+
 /**
  * Generate a random string of specified length.
  * @param {number} keyLength
@@ -16,11 +22,29 @@ var generatorBase64Code = function generatorBase64Code() {
   }
   return key;
 };
-var isNumber = function isNumber(num) {
-  return (num || num === 0) && Object.prototype.toString.call(num) === '[object Number]';
+
+/**
+ * Check whether the given value is empty
+ * @param {any} val
+ * @returns bool
+ */
+var isEmpty = function isEmpty(val) {
+  if (val === null || val === undefined) return true;
+  if (val.length !== undefined) return val.length === 0;
+  if (val instanceof Date) return false;
+  if (_typeof__default["default"](val) === 'object') return Object.keys(val).length === 0;
+  return false;
 };
+
+/**
+ * Check whether the object is empty.
+ * The true will be returned if the "obj" is invalid.
+ * @param {object} obj
+ * @returns bool
+ */
 var isEmptyObject = function isEmptyObject(obj) {
   var name;
+  // eslint-disable-next-line
   for (name in obj) {
     return false;
   }
@@ -28,5 +52,5 @@ var isEmptyObject = function isEmptyObject(obj) {
 };
 
 exports.generatorBase64Code = generatorBase64Code;
+exports.isEmpty = isEmpty;
 exports.isEmptyObject = isEmptyObject;
-exports.isNumber = isNumber;