dtable-utils 0.0.2 → 0.0.3-beta.1

package/lib/sort/sort-row.js

@@ -0,0 +1,136 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+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 option = require('../column/option.js');
+var sort = require('../constants/sort.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 deleteInvalidSort = function deleteInvalidSort(sorts, columns) {
+  var validSorts = core.getValidSorts(sorts, columns);
+  var cleanSorts = [];
+  validSorts.forEach(function (sort) {
+    var column_key = sort.column_key;
+    var sortColumn = columns.find(function (column) {
+      return column.key === column_key;
+    });
+    var columnType = sortColumn.type;
+    var newSort = _objectSpread(_objectSpread({}, sort), {}, {
+      column: sortColumn
+    });
+    switch (columnType) {
+      case cellType.CellType.SINGLE_SELECT:
+      case cellType.CellType.MULTIPLE_SELECT:
+        {
+          var options = option.getColumnOptions(sortColumn);
+          var option_id_index_map = {};
+          options.forEach(function (option, index) {
+            option_id_index_map[option.id] = index;
+          });
+          newSort.option_id_index_map = option_id_index_map;
+          break;
+        }
+    }
+    cleanSorts.push(newSort);
+  });
+  return cleanSorts;
+};
+var sortRowsWithMultiSorts = function sortRowsWithMultiSorts(sortRows, sorts, _ref) {
+  var _ref$formulaRows = _ref.formulaRows,
+    formulaRows = _ref$formulaRows === void 0 ? {} : _ref$formulaRows,
+    value = _ref.value;
+  sortRows.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;
+  });
+};
+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)) return [];
+  var sortRows = rows.slice(0);
+  var validSorts = deleteInvalidSort(sorts, columns);
+  var normalizedFormulaRows = formulaRows || {};
+  sortRowsWithMultiSorts(sortRows, validSorts, {
+    formulaRows: normalizedFormulaRows,
+    value: value
+  });
+  return sortRows.map(function (row) {
+    return row._id;
+  });
+};
+
+exports.deleteInvalidSort = deleteInvalidSort;
+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 column by name from table
+ * @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 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/index.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 row by id from table
+ * @param {object} table
+ * @param {string} rowId the id of row
+ * @returns object
+ */
+var getRowById = function getRowById(table, rowId) {
+  if (!table || !table.id_row_map || !rowId) return null;
+  return table.id_row_map[rowId];
+};
+
+/**
+ * get rows by ids from table
+ * @param {object} table { id_row_map, ... }
+ * @param {array} rowsIds [ row._id, ... ]
+ * @returns array, rows: [ row, ... ]
+ */
+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,144 @@
+'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 { _id: '', ... }
+ * @param {string} viewId
+ * @returns 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 { filters: [], ... }
+ * @param {array} columns
+ * @returns boolean
+ */
+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 { groupbys: [], ... }
+ * @param {array} columns
+ * @returns boolean
+ */
+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 { sorts: [], ... }
+ * @param {array} columns
+ * @returns boolean
+ */
+var isSortView = function isSortView(view, columns) {
+  var sorts = view.sorts;
+  var validSorts = core$2.getValidSorts(sorts, columns);
+  return validSorts.length > 0;
+};
+
+/**
+ * check is default view which no contains filters, sorts, groupbys etc.
+ * @param {object} view { sorts: [], ... }
+ * @param {array} columns
+ * @returns boolean
+ */
+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 { filters, groupbys, sorts, ... }
+ * @param {object} table
+ * @returns array, link columns
+ */
+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;

package/lib/view/formula.js

@@ -0,0 +1,150 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var cellType = require('../constants/cell-type.js');
+var formula = require('../constants/formula.js');
+
+/**
+ * transform the formats of link column to link-formula's
+ * @param {object} linkColumn { key, data: { display_column_key, ... }, ... }
+ * @returns object
+ */
+var transLink2LinkFormula = function transLink2LinkFormula(linkColumn) {
+  var key = linkColumn.key,
+    name = linkColumn.name,
+    data = linkColumn.data;
+  var display_column_key = data.display_column_key;
+  return {
+    key: key,
+    name: name,
+    type: cellType.CellType.LINK_FORMULA,
+    data: {
+      formula: 'lookup',
+      link_column_key: key,
+      level1_linked_table_column_key: display_column_key,
+      level2_linked_table_column_key: null,
+      operated_columns: []
+    }
+  };
+};
+
+/**
+ * get sorted formula columns
+ * @param {array} formulaColumns
+ * @param {object} table
+ * @returns array
+ */
+var getSortedFormulaColumns = function getSortedFormulaColumns(formulaColumns, table) {
+  if (!Array.isArray(formulaColumns) || !table || !Array.isArray(table.columns)) return [];
+  var keyColumnMap = {};
+  table.columns.forEach(function (column) {
+    var key = column.key,
+      type = column.type;
+    if (formula.FORMULA_COLUMN_TYPES_MAP[type]) {
+      keyColumnMap[key] = column;
+    } else if (type === cellType.CellType.LINK && column.data) {
+      keyColumnMap[key] = transLink2LinkFormula(column);
+    }
+  });
+
+  // get none-repeating formulas
+  var key_sorting_formula_column = {};
+  var sorting_formula_column_keys = [];
+  formulaColumns.forEach(function (column) {
+    var columnKey = column.key;
+    if (!key_sorting_formula_column[columnKey]) {
+      key_sorting_formula_column[columnKey] = column;
+      sorting_formula_column_keys.push(columnKey);
+    }
+  });
+
+  /**
+   * e.g. formula1 = formula2 + formula3
+   * e.g. formula2 = 1 + 2
+   * e.g. formula3 = formula2 + 3
+   * edges: formula2 --> formula1, formula2 --> formula3; formula3 --> formula1
+   * keyInDegreeMap, the total number of formula columns that depend on: { formula1_key: 2, formula2_key: 0, formula3_key: 1 }
+   * keyEdgesMap: { formula2_key: [formula1_key, formula3_key],  formula3_kye: [formula1_key]}
+   */
+  var keyInDegreeMap = {};
+  var keyEdgesMap = {};
+  sorting_formula_column_keys.forEach(function (formulaColumnKey) {
+    var formulaColumn = key_sorting_formula_column[formulaColumnKey];
+    var data = formulaColumn.data;
+    var operated_columns = data.operated_columns;
+    keyInDegreeMap[formulaColumnKey] = 0;
+    Array.isArray(operated_columns) && operated_columns.forEach(function (dependColumnKey) {
+      var dependColumn = keyColumnMap[dependColumnKey];
+      if (!dependColumn) {
+        return;
+      }
+      keyInDegreeMap[formulaColumnKey]++;
+      if (keyEdgesMap[dependColumnKey]) {
+        keyEdgesMap[dependColumnKey].push(formulaColumnKey);
+      } else {
+        keyEdgesMap[dependColumnKey] = [formulaColumnKey];
+      }
+    });
+  });
+  var sortedList = [];
+  var waitingQueue = [];
+  sorting_formula_column_keys.forEach(function (formulaColumnKey) {
+    if (keyInDegreeMap[formulaColumnKey] === 0) {
+      waitingQueue.push(formulaColumnKey);
+    }
+  });
+  while (waitingQueue.length) {
+    var columnKey = waitingQueue.shift();
+    var edges = keyEdgesMap[columnKey];
+    sortedList.push(columnKey);
+    Array.isArray(edges) && edges.forEach(function (edge) {
+      keyInDegreeMap[edge]--;
+      if (keyInDegreeMap[edge] === 0) {
+        waitingQueue.push(edge);
+      }
+    });
+  }
+  return sortedList.map(function (columnKey) {
+    return keyColumnMap[columnKey];
+  });
+};
+
+/**
+ * get formula columns and link columns from table
+ * @param {object} table { columns: [], ... }
+ * @returns array
+ */
+var getFormulaColumnsContainLinks = function getFormulaColumnsContainLinks(table) {
+  var columns = table.columns;
+  var formulaColumns = columns.filter(function (column) {
+    var type = column.type,
+      data = column.data;
+    if (type === cellType.CellType.LINK) {
+      return !!data;
+    }
+    return formula.FORMULA_COLUMN_TYPES_MAP[type] && data;
+  });
+  return formulaColumns.map(function (column) {
+    if (column.type === cellType.CellType.LINK) {
+      return transLink2LinkFormula(column);
+    }
+    return column;
+  });
+};
+
+/**
+ * get sorted formula columns and link columns from table
+ * @param {object} table { columns: [], ... }
+ * @returns array
+ */
+var getSortedFormulaColumnsContainLinks = function getSortedFormulaColumnsContainLinks(table) {
+  var formulaColumns = getFormulaColumnsContainLinks(table);
+  if (formulaColumns.length === 0) return [];
+  return getSortedFormulaColumns(formulaColumns, table);
+};
+
+exports.getFormulaColumnsContainLinks = getFormulaColumnsContainLinks;
+exports.getSortedFormulaColumns = getSortedFormulaColumns;
+exports.getSortedFormulaColumnsContainLinks = getSortedFormulaColumnsContainLinks;
+exports.transLink2LinkFormula = transLink2LinkFormula;

package/lib/view/group.js

@@ -0,0 +1,36 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * get group by paths.
+ * @param {array} paths e.g. [0, 1, 2]
+ * @param {array} groups
+ * @returns object
+ */
+var getGroupByPath = function getGroupByPath(paths, groups) {
+  if (!Array.isArray(paths) || !Array.isArray(groups)) {
+    return null;
+  }
+  var level0GroupIndex = paths[0];
+  if (level0GroupIndex < 0 || level0GroupIndex >= groups.length) {
+    return null;
+  }
+  var level = 1;
+  var foundGroup = groups[level0GroupIndex];
+  while (level < paths.length) {
+    if (!foundGroup) {
+      break;
+    }
+    var subGroups = foundGroup.subgroups;
+    var currentLevelGroupIndex = paths[level];
+    if (!Array.isArray(subGroups) || currentLevelGroupIndex < 0 || currentLevelGroupIndex >= subGroups.length) {
+      break;
+    }
+    foundGroup = subGroups[currentLevelGroupIndex];
+    level += 1;
+  }
+  return foundGroup;
+};
+
+exports.getGroupByPath = getGroupByPath;