dtable-utils 0.0.3 → 0.0.4-beta.1

package/lib/sort/sort-column/multiple-select.js

@@ -0,0 +1,49 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var core = require('../core.js');
+var sort = require('../../constants/sort.js');
+
+/**
+ * Sort multiple-select
+ * @param {array} leftOptionIds the ids of options
+ * @param {array} rightOptionIds
+ * @param {string} sort_type e.g. 'up' | 'down'
+ * @param {object} option_id_index_map e.g. { [option.id]: 0, ... }
+ * @returns number
+ */
+var sortMultipleSelect = function sortMultipleSelect(leftOptionIds, rightOptionIds, _ref) {
+  var sort_type = _ref.sort_type,
+    option_id_index_map = _ref.option_id_index_map;
+  var emptyLeftOptionIds = !leftOptionIds || leftOptionIds.length === 0;
+  var emptyRightOptionIds = !rightOptionIds || rightOptionIds.length === 0;
+  if (emptyLeftOptionIds && emptyRightOptionIds) return 0;
+  if (emptyLeftOptionIds) return 1;
+  if (emptyRightOptionIds) return -1;
+  var leftOptionIndexes = core.getMultipleIndexesOrderbyOptions(leftOptionIds, option_id_index_map);
+  var rightOptionIndexes = core.getMultipleIndexesOrderbyOptions(rightOptionIds, option_id_index_map);
+  var leftOptionsLen = leftOptionIndexes.length;
+  var rightOptionsLen = rightOptionIndexes.length;
+
+  // current multiple select equal to next multiple select.
+  if (leftOptionsLen === rightOptionsLen && (leftOptionsLen === 0 || leftOptionIndexes.join('') === rightOptionIndexes.join(''))) {
+    return 0;
+  }
+  var len = Math.min(leftOptionsLen, rightOptionsLen);
+  for (var i = 0; i < len; i++) {
+    if (leftOptionIndexes[i] > rightOptionIndexes[i]) {
+      return sort_type === sort.SORT_TYPE.UP ? 1 : -1;
+    }
+    if (leftOptionIndexes[i] < rightOptionIndexes[i]) {
+      return sort_type === sort.SORT_TYPE.UP ? -1 : 1;
+    }
+  }
+  if (leftOptionsLen > rightOptionsLen) {
+    return sort_type === sort.SORT_TYPE.UP ? 1 : -1;
+  }
+  return sort_type === sort.SORT_TYPE.UP ? -1 : 1;
+};
+
+exports.getMultipleIndexesOrderbyOptions = core.getMultipleIndexesOrderbyOptions;
+exports.sortMultipleSelect = sortMultipleSelect;

package/lib/sort/sort-column/number.js

@@ -0,0 +1,29 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var sort = require('../../constants/sort.js');
+
+/**
+ * Sort number
+ * @param {number} leftNumber
+ * @param {number} rightNumber
+ * @param {string} sortType e.g. 'up' | 'down'
+ * @returns number
+ */
+var sortNumber = function sortNumber(leftNumber, rightNumber, sortType) {
+  var emptyLeftNumber = !leftNumber && leftNumber !== 0;
+  var emptyRightNumber = !rightNumber && rightNumber !== 0;
+  if (emptyLeftNumber && emptyRightNumber) return 0;
+  if (emptyLeftNumber) return 1;
+  if (emptyRightNumber) return -1;
+  if (leftNumber > rightNumber) {
+    return sortType === sort.SORT_TYPE.UP ? 1 : -1;
+  }
+  if (leftNumber < rightNumber) {
+    return sortType === sort.SORT_TYPE.UP ? -1 : 1;
+  }
+  return 0;
+};
+
+exports.sortNumber = sortNumber;

package/lib/sort/sort-column/single-select.js

@@ -0,0 +1,34 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var sort = require('../../constants/sort.js');
+
+/**
+ * Sort single-select
+ * @param {string} leftOptionId the id of option
+ * @param {string} rightOptionId
+ * @param {string} sort_type e.g. 'up' | 'down'
+ * @param {object} option_id_index_map e.g. { [option.id]: 0, ... }
+ * @returns number
+ */
+var sortSingleSelect = function sortSingleSelect(leftOptionId, rightOptionId, _ref) {
+  var sort_type = _ref.sort_type,
+    option_id_index_map = _ref.option_id_index_map;
+  var currentOptionIdIndex = option_id_index_map[leftOptionId];
+  var nextOptionIdIndex = option_id_index_map[rightOptionId];
+  var emptyLeftOptionId = !currentOptionIdIndex && currentOptionIdIndex !== 0;
+  var emptyRightOptionId = !nextOptionIdIndex && nextOptionIdIndex !== 0;
+  if (emptyLeftOptionId && emptyRightOptionId) return 0;
+  if (emptyLeftOptionId) return 1;
+  if (emptyRightOptionId) return -1;
+  if (currentOptionIdIndex > nextOptionIdIndex) {
+    return sort_type === sort.SORT_TYPE.UP ? 1 : -1;
+  }
+  if (currentOptionIdIndex < nextOptionIdIndex) {
+    return sort_type === sort.SORT_TYPE.UP ? -1 : 1;
+  }
+  return 0;
+};
+
+exports.sortSingleSelect = sortSingleSelect;

package/lib/sort/sort-column/text.js

@@ -0,0 +1,66 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var reg = require('../../constants/reg.js');
+var sort = require('../../constants/sort.js');
+
+/**
+ * Compare strings
+ * @param {string} leftString
+ * @param {string} rightString
+ * @returns number
+ */
+var compareString = function compareString(leftString, rightString) {
+  if (!leftString && !rightString) return 0;
+  if (!leftString) return -1;
+  if (!rightString) return 1;
+  if (typeof leftString !== 'string' || typeof rightString !== 'string') return 0;
+  var leftStringParts = leftString.match(reg.REG_STRING_NUMBER_PARTS);
+  var rightStringParts = rightString.match(reg.REG_STRING_NUMBER_PARTS);
+  var len = Math.min(leftStringParts.length, rightStringParts.length);
+  var isDigitPart;
+  var leftStringPart;
+  var rightStringPart;
+
+  // Loop through each substring part to canCompare the overall strings.
+  for (var i = 0; i < len; i++) {
+    leftStringPart = leftStringParts[i];
+    rightStringPart = rightStringParts[i];
+    isDigitPart = reg.REG_NUMBER_DIGIT.test(leftStringPart) && reg.REG_NUMBER_DIGIT.test(rightStringPart);
+    if (isDigitPart) {
+      leftStringPart = parseInt(leftStringPart);
+      rightStringPart = parseInt(rightStringPart);
+      if (leftStringPart > rightStringPart) {
+        return 1;
+      }
+      if (leftStringPart < rightStringPart) {
+        return -1;
+      }
+    }
+    if (leftStringPart !== rightStringPart) {
+      return leftString.localeCompare(rightString);
+    }
+  }
+  return leftString.localeCompare(rightString);
+};
+
+/**
+ * Sort text
+ * @param {string} leftText
+ * @param {string} rightText
+ * @param {string} sortType e.g. 'up' | 'down
+ * @returns number
+ */
+var sortText = function sortText(leftText, rightText, sortType) {
+  var emptyLeftText = !leftText;
+  var emptyRightText = !rightText;
+  if (emptyLeftText && emptyRightText) return 0;
+  if (emptyLeftText) return 1;
+  if (emptyRightText) return -1;
+  if (rightText === leftText) return 0;
+  return sortType === sort.SORT_TYPE.UP ? compareString(leftText, rightText) : -1 * compareString(leftText, rightText);
+};
+
+exports.compareString = compareString;
+exports.sortText = sortText;

package/lib/sort/sort-row.js

@@ -0,0 +1,115 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var core = require('./core.js');
+var checkbox = require('./sort-column/checkbox.js');
+var collaborator$1 = require('./sort-column/collaborator.js');
+var date = require('./sort-column/date.js');
+var collaborator = require('../cell-value-get/collaborator.js');
+require('../cell-value-get/cell-value.js');
+var number = require('./sort-column/number.js');
+var text = require('./sort-column/text.js');
+var cellType = require('../constants/cell-type.js');
+var column = require('../constants/column.js');
+var formula = require('../constants/formula.js');
+var formula$1 = require('./sort-column/formula.js');
+var link = require('./sort-column/link.js');
+var multipleSelect = require('./sort-column/multiple-select.js');
+var singleSelect = require('./sort-column/single-select.js');
+var sort = require('../constants/sort.js');
+
+/**
+ * Sort rows with multiple sorts
+ * @param {array} tableRows e.g. [{ _id, [column.key]: '', ...}, ...]
+ * @param {array} sorts e.g. [{ column_key, sort_type, column, ... }, ...]
+ * @param {object} formulaRows computed value of formula, link-formula, link etc.
+ * @param {object} value e.g. { collaborators, ... }
+ */
+var sortRowsWithMultiSorts = function sortRowsWithMultiSorts(tableRows, sorts, _ref) {
+  var _ref$formulaRows = _ref.formulaRows,
+    formulaRows = _ref$formulaRows === void 0 ? {} : _ref$formulaRows,
+    value = _ref.value;
+  tableRows.sort(function (currentRow, nextRow) {
+    var initValue = 0;
+    sorts.forEach(function (sort$1) {
+      var column_key = sort$1.column_key,
+        sort_type = sort$1.sort_type,
+        column$1 = sort$1.column;
+      var columnType = column$1.type,
+        columnData = column$1.data;
+      var currCellVal = currentRow[column_key];
+      var nextCellVal = nextRow[column_key];
+      if (column.DATE_COLUMN_OPTIONS.includes(columnType)) {
+        initValue = initValue || date.sortDate(currCellVal, nextCellVal, sort_type);
+      } else if (columnType === cellType.CellType.SINGLE_SELECT) {
+        initValue = initValue || singleSelect.sortSingleSelect(currCellVal, nextCellVal, sort$1);
+      } else if (sort.NUMBER_SORTER_COLUMN_TYPES.includes(columnType)) {
+        initValue = initValue || number.sortNumber(currCellVal, nextCellVal, sort_type);
+      } else if (formula.FORMULA_COLUMN_TYPES_MAP[columnType]) {
+        var currentFormulaRow = formulaRows[currentRow._id] || {};
+        var nextFormulaRow = formulaRows[nextRow._id] || {};
+        currCellVal = currentFormulaRow[column_key];
+        nextCellVal = nextFormulaRow[column_key];
+        initValue = initValue || formula$1.sortFormula(currCellVal, nextCellVal, sort_type, {
+          columnData: columnData,
+          value: value
+        });
+      } else if (columnType === cellType.CellType.COLLABORATOR) {
+        var collaborators = value.collaborators;
+        var currValidCollaborators = currCellVal;
+        var nextValidCollaborators = nextCellVal;
+        if (collaborators) {
+          currValidCollaborators = collaborator.getCollaboratorsNames(currCellVal, collaborators);
+          nextValidCollaborators = collaborator.getCollaboratorsNames(nextCellVal, collaborators);
+        }
+        initValue = initValue || collaborator$1.sortCollaborator(currValidCollaborators, nextValidCollaborators, sort_type);
+      } else if (columnType === cellType.CellType.CHECKBOX) {
+        initValue = initValue || checkbox.sortCheckbox(currCellVal, nextCellVal, sort_type);
+      } else if (columnType === cellType.CellType.MULTIPLE_SELECT) {
+        initValue = initValue || multipleSelect.sortMultipleSelect(currCellVal, nextCellVal, sort$1);
+      } else if (columnType === cellType.CellType.LINK) {
+        var _currentFormulaRow = formulaRows[currentRow._id] || {};
+        var _nextFormulaRow = formulaRows[nextRow._id] || {};
+        currCellVal = _currentFormulaRow[column_key];
+        nextCellVal = _nextFormulaRow[column_key];
+        initValue = initValue || link.sortLink(currCellVal, nextCellVal, sort_type, {
+          columnData: columnData,
+          value: value
+        });
+      } else {
+        initValue = initValue || text.sortText(currCellVal, nextCellVal, sort_type);
+      }
+    });
+    return initValue;
+  });
+};
+
+/**
+ * Get sorted rows ids from table rows with multiple sorts
+ * @param {array} sorts e.g. [{ column_key, sort_type, column, ... }, ...]
+ * @param {array} rows e.g. [{ _id, [column.key]: '', ...}, ...]
+ * @param {array} columns e.g. [{ key, type, ... }, ...]
+ * @param {object} formulaRows computed value of formula, link-formula, link etc.
+ * @param {object} value e.g. { collaborators, ... }
+ * @returns sorted rows ids, array
+ */
+var sortTableRows = function sortTableRows(sorts, rows, columns) {
+  var _ref2 = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {},
+    formulaRows = _ref2.formulaRows,
+    value = _ref2.value;
+  if (!Array.isArray(rows) || rows.length === 0) return [];
+  var sortRows = rows.slice(0);
+  var validSorts = core.deleteInvalidSort(sorts, columns);
+  var normalizedFormulaRows = formulaRows || {};
+  sortRowsWithMultiSorts(sortRows, validSorts, {
+    formulaRows: normalizedFormulaRows,
+    value: value
+  });
+  return sortRows.map(function (row) {
+    return row._id;
+  });
+};
+
+exports.sortRowsWithMultiSorts = sortRowsWithMultiSorts;
+exports.sortTableRows = sortTableRows;

package/lib/table/column.js

@@ -0,0 +1,32 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * Get column by key from table
+ * @param {object} table
+ * @param {string} columnKey
+ * @returns column, object
+ */
+var getTableColumnByKey = function getTableColumnByKey(table, columnKey) {
+  if (!table || !Array.isArray(table.columns) || !columnKey) return null;
+  return table.columns.find(function (column) {
+    return column.key === columnKey;
+  });
+};
+
+/**
+ * Get table column by name
+ * @param {object} table
+ * @param {string} columnName
+ * @returns column, object
+ */
+var getTableColumnByName = function getTableColumnByName(table, columnName) {
+  if (!table || !Array.isArray(table.columns) || !columnName) return null;
+  return table.columns.find(function (column) {
+    return column.name === columnName;
+  });
+};
+
+exports.getTableColumnByKey = getTableColumnByKey;
+exports.getTableColumnByName = getTableColumnByName;

package/lib/table/core.js

@@ -0,0 +1,18 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * Get table by id
+ * @param {array} tables
+ * @param {string} tableId
+ * @returns table, object
+ */
+var getTableById = function getTableById(tables, tableId) {
+  if (!Array.isArray(tables) || !tableId) return null;
+  return tables.find(function (table) {
+    return table._id === tableId;
+  });
+};
+
+exports.getTableById = getTableById;

package/lib/table/row.js

@@ -0,0 +1,30 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * Get table row by id
+ * @param {object} table
+ * @param {string} rowId the id of row
+ * @returns row, object
+ */
+var getRowById = function getRowById(table, rowId) {
+  if (!table || !table.id_row_map || !rowId) return null;
+  return table.id_row_map[rowId];
+};
+
+/**
+ * Get table rows by ids
+ * @param {object} table { id_row_map, ... }
+ * @param {array} rowsIds [ row._id, ... ]
+ * @returns rows, array
+ */
+var getRowsByIds = function getRowsByIds(table, rowsIds) {
+  if (!table || !table.id_row_map || !Array.isArray(rowsIds)) return [];
+  return rowsIds.map(function (rowId) {
+    return table.id_row_map[rowId];
+  }).filter(Boolean);
+};
+
+exports.getRowById = getRowById;
+exports.getRowsByIds = getRowsByIds;

package/lib/validate/filter.js

@@ -9,7 +9,7 @@ var cellType = require('../constants/cell-type.js');
 var column = require('../constants/column.js');
 var formula = require('../constants/formula.js');
 var index = require('../constants/filter/index.js');
-var common = require('../column/common.js');
+var option = require('../column/option.js');
 var date = require('../column/date.js');
 var filterPredicate = require('../constants/filter/filter-predicate.js');
 var filterModifier = require('../constants/filter/filter-modifier.js');
@@ -307,7 +307,7 @@ var ValidateFilter = /*#__PURE__*/function () {
           }
         case cellType.CellType.SINGLE_SELECT:
           {
-            var options = common.getColumnOptions(filterColumn);
+            var options = option.getColumnOptions(filterColumn);
             if (PREDICATES_REQUIRE_ARRAY_TERM.includes(predicate)) {
               if (!this.isValidTermType(term, TERM_TYPE_MAP.ARRAY)) {
                 return false;
@@ -349,7 +349,7 @@ var ValidateFilter = /*#__PURE__*/function () {
             }
 
             // contains deleted option(s)
-            var _options = common.getColumnOptions(filterColumn);
+            var _options = option.getColumnOptions(filterColumn);
             return this.isValidSelectedOptions(term, _options);
           }
         case cellType.CellType.DATE:

package/lib/validate/geolocation.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var isValidPosition = function isValidPosition(lng, lat) {
+  return (lng || lng === 0) && (lat || lat === 0);
+};
+
+exports.isValidPosition = isValidPosition;

package/lib/view/core.js

@@ -0,0 +1,143 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var core = require('../filter/core.js');
+var core$1 = require('../group/core.js');
+var core$2 = require('../sort/core.js');
+var cellType = require('../constants/cell-type.js');
+
+/**
+ * Get view by id
+ * @param {array} views e.g. [{ _id, ... }, ...]
+ * @param {string} viewId
+ * @returns view, object
+ */
+var getViewById = function getViewById(views, viewId) {
+  if (!Array.isArray(views) || !viewId) return null;
+  return views.find(function (view) {
+    return view._id === viewId;
+  });
+};
+
+/**
+ * Check whether the view contains filters
+ * @param {object} view e.g. { filters, ... }
+ * @param {array} columns
+ * @returns bool
+ */
+var isFilterView = function isFilterView(view, columns) {
+  var validFilters = core.getValidFilters(view.filters, columns);
+  return validFilters.length > 0;
+};
+
+/**
+ * Check whether the view contains groupbys
+ * @param {object} view e.g. { groupbys, ... }
+ * @param {array} columns
+ * @returns bool
+ */
+var isGroupView = function isGroupView(view, columns) {
+  var validGroupbys = core$1.getValidGroupbys(view.groupbys, columns);
+  return validGroupbys.length > 0;
+};
+
+/**
+ * Check whether the view contains sorts
+ * @param {object} view e.g. { sorts, ... }
+ * @param {array} columns
+ * @returns bool
+ */
+var isSortView = function isSortView(view, columns) {
+  var validSorts = core$2.getValidSorts(view.sorts, columns);
+  return validSorts.length > 0;
+};
+
+/**
+ * Check is default view which no contains filters, sorts, groupbys etc.
+ * @param {object} view e.g. { filters, groupbys, sorts, ... }
+ * @param {array} columns
+ * @returns bool
+ */
+var isDefaultView = function isDefaultView(view, columns) {
+  return !isFilterView(view, columns) && !isSortView(view, columns) && !isGroupView(view, columns);
+};
+
+/**
+ * Get link columns which used either in filters, groupbys, sorts etc.
+ * @param {object} view e.g. { filters, groupbys, sorts, ... }
+ * @param {object} table e.g. { columns, ... }
+ * @returns link columns, array
+ */
+var getLinkColumnsUsedInFilters = function getLinkColumnsUsedInFilters(view, table) {
+  var filters = view.filters,
+    sorts = view.sorts,
+    groupbys = view.groupbys;
+  var columns = table.columns;
+  if (!Array.isArray(columns)) return [];
+  var validFilters = core.getValidFiltersWithoutError(filters, columns);
+  var validSorts = core$2.getValidSorts(sorts, columns);
+  var validGroupbys = core$1.getValidGroupbys(groupbys, columns);
+  var hasFilters = validFilters && validFilters.length > 0;
+  var hasSorts = validSorts && validSorts.length > 0;
+  var hasGroupbys = validGroupbys && validGroupbys.length > 0;
+  if (!hasFilters && !hasSorts && !hasGroupbys) return [];
+  var keyLinkColumnMap = {};
+  var keyExistLinkColumnMap = {};
+  var linkColumns = [];
+  columns.forEach(function (column) {
+    var key = column.key,
+      name = column.name,
+      type = column.type,
+      data = column.data,
+      width = column.width;
+    if (type === cellType.CellType.LINK) {
+      keyLinkColumnMap[column.key] = {
+        key: key,
+        name: name,
+        type: type,
+        data: data,
+        width: width
+      };
+    }
+  });
+  if (Object.keys(keyLinkColumnMap).length === 0) return [];
+  if (hasFilters) {
+    validFilters.forEach(function (filter) {
+      var filterColumnKey = filter.column_key;
+      var filterLinkColumn = keyLinkColumnMap[filterColumnKey];
+      if (filterLinkColumn && !keyExistLinkColumnMap[filterColumnKey]) {
+        linkColumns.push(filterLinkColumn);
+        keyExistLinkColumnMap[filterColumnKey] = true;
+      }
+    });
+  }
+  if (hasSorts) {
+    validSorts.forEach(function (sort) {
+      var sortColumnKey = sort.column_key;
+      var sortLinkColumn = keyLinkColumnMap[sortColumnKey];
+      if (sortLinkColumn && !keyExistLinkColumnMap[sortColumnKey]) {
+        linkColumns.push(sortLinkColumn);
+        keyExistLinkColumnMap[sortColumnKey] = true;
+      }
+    });
+  }
+  if (hasGroupbys) {
+    validGroupbys.forEach(function (groupby) {
+      var groupbyColumnKey = groupby.column_key;
+      var groupbyLinkColumn = keyLinkColumnMap[groupbyColumnKey];
+      if (groupbyLinkColumn && !keyExistLinkColumnMap[groupbyColumnKey]) {
+        linkColumns.push(groupbyLinkColumn);
+        keyExistLinkColumnMap[groupbyColumnKey] = true;
+      }
+    });
+  }
+  return linkColumns;
+};
+
+exports.getLinkColumnsUsedInFilters = getLinkColumnsUsedInFilters;
+exports.getViewById = getViewById;
+exports.isDefaultView = isDefaultView;
+exports.isFilterView = isFilterView;
+exports.isGroupView = isGroupView;
+exports.isSortView = isSortView;