dtable-utils 0.0.3-beta.1 → 0.0.4-beta.1

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

@@ -13,55 +13,64 @@ var cellType = require('../../constants/cell-type.js');
 var column = require('../../constants/column.js');
 var formula = require('../../constants/formula.js');
 
-var sortByArrayType = function sortByArrayType(currCellVal, nextCellVal, sortType, _ref) {
+/**
+ * Sort by array type
+ * @param {array} leftArray
+ * @param {array} rightArray
+ * @param {string} sortType e.g. 'up' | 'down
+ * @param {object} columnData e.g. { result_type, array_type, array_data, ... }
+ * @param {object} value e.g. { collaborators, ... }
+ * @returns number
+ */
+var sortByArrayType = function sortByArrayType(leftArray, rightArray, sortType, _ref) {
   var columnData = _ref.columnData,
     value = _ref.value;
   var _ref2 = columnData || {},
     array_type = _ref2.array_type;
   if (column.NUMERIC_COLUMNS_TYPES.includes(array_type)) {
-    var currNumber = currCellVal;
-    var nextNumber = nextCellVal;
-    if (Array.isArray(currCellVal)) {
-      currNumber = currCellVal[0];
+    var leftNumber = leftArray;
+    var rightNumber = rightArray;
+    if (Array.isArray(leftArray)) {
+      leftNumber = leftArray[0];
     }
-    if (Array.isArray(nextCellVal)) {
-      nextNumber = nextCellVal[0];
+    if (Array.isArray(rightArray)) {
+      rightNumber = rightArray[0];
     }
-    currNumber = currNumber || currNumber === 0 ? currNumber : null;
-    nextNumber = nextNumber || nextNumber === 0 ? nextNumber : null;
-    return number.sortNumber(currNumber, nextNumber, sortType);
+    leftNumber = leftNumber || leftNumber === 0 ? leftNumber : null;
+    rightNumber = rightNumber || rightNumber === 0 ? rightNumber : null;
+    return number.sortNumber(leftNumber, rightNumber, sortType);
   }
   if (column.DATE_COLUMN_OPTIONS.includes(array_type)) {
-    var currDate = Array.isArray(currCellVal) ? currCellVal[0] : currCellVal;
-    var nextDate = Array.isArray(nextCellVal) ? nextCellVal[0] : nextCellVal;
-    return date.sortDate(currDate, nextDate, sortType);
+    var leftDate = Array.isArray(leftArray) ? leftArray[0] : leftArray;
+    var rightDate = Array.isArray(rightArray) ? rightArray[0] : rightArray;
+    return date.sortDate(leftDate, rightDate, sortType);
   }
   if (array_type === cellType.CellType.CHECKBOX || array_type === formula.FORMULA_RESULT_TYPE.BOOL) {
-    var currBoolean = currCellVal;
-    var nextBoolean = nextCellVal;
-    if (Array.isArray(currCellVal)) {
-      currBoolean = currCellVal[0];
+    var leftBool = leftArray;
+    var rightBool = rightArray;
+    if (Array.isArray(leftArray)) {
+      leftBool = leftArray[0];
     }
-    if (Array.isArray(nextCellVal)) {
-      nextBoolean = nextCellVal[0];
+    if (Array.isArray(rightArray)) {
+      rightBool = rightArray[0];
     }
-    currBoolean = currBoolean || false;
-    nextBoolean = nextBoolean || false;
-    return checkbox.sortCheckbox(currBoolean, nextBoolean, sortType);
+    leftBool = leftBool || false;
+    rightBool = rightBool || false;
+    return checkbox.sortCheckbox(leftBool, rightBool, sortType);
   }
   if (array_type === cellType.CellType.COLLABORATOR) {
     var collaborators = value.collaborators;
-    var currCollaborators = Array.isArray(currCellVal) ? currCellVal : [currCellVal];
-    var nextCollaborators = Array.isArray(nextCellVal) ? nextCellVal : [nextCellVal];
+    var leftCollaborators = Array.isArray(leftArray) ? leftArray : [leftArray];
+    var rightCollaborators = Array.isArray(rightArray) ? rightArray : [rightArray];
     if (collaborators) {
-      currCollaborators = collaborator.getCollaboratorsNames(currCollaborators, collaborators);
-      nextCollaborators = collaborator.getCollaboratorsNames(nextCollaborators, collaborators);
+      leftCollaborators = collaborator.getCollaboratorsNames(leftCollaborators, collaborators);
+      rightCollaborators = collaborator.getCollaboratorsNames(rightCollaborators, collaborators);
     }
-    return collaborator$1.sortCollaborator(currCollaborators, nextCollaborators, sortType);
+    return collaborator$1.sortCollaborator(leftCollaborators, rightCollaborators, sortType);
   }
-  var currText = cellValue.getFormulaDisplayString(currCellVal, columnData);
-  var nextText = cellValue.getFormulaDisplayString(nextCellVal, columnData);
-  return text.sortText(currText, nextText, sortType);
+  var leftText = cellValue.getFormulaDisplayString(leftArray, columnData);
+  var rightText = cellValue.getFormulaDisplayString(rightArray, columnData);
+  return text.sortText(leftText, rightText, sortType);
 };
 
 exports.sortByArrayType = sortByArrayType;

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

@@ -4,13 +4,20 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var sort = require('../../constants/sort.js');
 
-var sortCheckbox = function sortCheckbox(currCellVal, nextCellVal, sortType) {
-  var currCellValPart = currCellVal ? 1 : -1;
-  var nextCellValPart = nextCellVal ? 1 : -1;
-  if (currCellValPart > nextCellValPart) {
+/**
+ * Sort checkbox
+ * @param {bool} leftChecked
+ * @param {bool} rightChecked
+ * @param {string} sortType e.g. 'up' | 'down
+ * @returns number
+ */
+var sortCheckbox = function sortCheckbox(leftChecked, rightChecked, sortType) {
+  var normalizedCurrChecked = leftChecked ? 1 : -1;
+  var normalizedNextChecked = rightChecked ? 1 : -1;
+  if (normalizedCurrChecked > normalizedNextChecked) {
     return sortType === sort.SORT_TYPE.UP ? 1 : -1;
   }
-  if (currCellValPart < nextCellValPart) {
+  if (normalizedCurrChecked < normalizedNextChecked) {
     return sortType === sort.SORT_TYPE.UP ? -1 : 1;
   }
   return 0;

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

@@ -4,10 +4,17 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var text = require('./text.js');
 
-var sortCollaborator = function sortCollaborator(currCellVal, nextCellVal, sortType) {
-  var currCellValString = Array.isArray(currCellVal) && currCellVal.length ? currCellVal.join('') : null;
-  var nextCellValString = Array.isArray(currCellVal) && currCellVal.length ? nextCellVal.join('') : null;
-  return text.sortText(currCellValString, nextCellValString, sortType);
+/**
+ * Sort collaborator with email or name
+ * @param {array} leftCollaborators e.g. [ collaborator.email, ... ] | [ collaborator.name, ... ]
+ * @param {array} rightCollaborators
+ * @param {string} sortType e.g. 'up' | 'down
+ * @returns number
+ */
+var sortCollaborator = function sortCollaborator(leftCollaborators, rightCollaborators, sortType) {
+  var sLeftCollaborators = Array.isArray(leftCollaborators) && leftCollaborators.length ? leftCollaborators.join('') : null;
+  var sRightCollaborators = Array.isArray(rightCollaborators) && rightCollaborators.length ? rightCollaborators.join('') : null;
+  return text.sortText(sLeftCollaborators, sRightCollaborators, sortType);
 };
 
 exports.sortCollaborator = sortCollaborator;

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

@@ -5,22 +5,22 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var sort = require('../../constants/sort.js');
 
 /**
- * compare date
- * @param {string} currDate date string, e.g. '2023-07-31'
- * @param {string} nextDate date string
+ * Sort date
+ * @param {string} leftDate e.g. '2023-07-31'
+ * @param {string} nextDate
  * @param {string} sortType e.g. 'up' | 'down'
- * @returns number, e.g. 1 | -1 | 0
+ * @returns number
  */
-var sortDate = function sortDate(currDate, nextDate, sortType) {
-  var emptyCurrDate = !currDate;
-  var emptyNextDate = !nextDate;
-  if (emptyCurrDate && emptyNextDate) return 0;
-  if (emptyCurrDate) return 1;
-  if (emptyNextDate) return -1;
-  if (currDate > nextDate) {
+var sortDate = function sortDate(leftDate, rightDate, sortType) {
+  var emptyLeftDate = !leftDate;
+  var emptyRightDate = !rightDate;
+  if (emptyLeftDate && emptyRightDate) return 0;
+  if (emptyLeftDate) return 1;
+  if (emptyRightDate) return -1;
+  if (leftDate > rightDate) {
     return sortType === sort.SORT_TYPE.UP ? 1 : -1;
   }
-  if (currDate < nextDate) {
+  if (leftDate < rightDate) {
     return sortType === sort.SORT_TYPE.UP ? -1 : 1;
   }
   return 0;

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

@@ -12,33 +12,42 @@ var column = require('../../constants/column.js');
 var formula = require('../../constants/formula.js');
 var sort = require('../../constants/sort.js');
 
-var sortFormula = function sortFormula(currCellVal, nextCellVal, sortType, _ref) {
+/**
+ * Sort formula
+ * @param {any} leftComputedValue compute value from formula row
+ * @param {any} rightComputedValue
+ * @param {string} sortType e.g. 'up' | 'down
+ * @param {object} columnData e.g. { result_type, array_type, array_data, ... }
+ * @param {object} value e.g. { collaborators, ... }
+ * @returns number
+ */
+var sortFormula = function sortFormula(leftComputedValue, rightComputedValue, sortType, _ref) {
   var columnData = _ref.columnData,
     value = _ref.value;
   var _ref2 = columnData || {},
     result_type = _ref2.result_type;
   if (sort.NUMBER_SORTER_COLUMN_TYPES.includes(result_type)) {
-    var currNumber = currCellVal || currCellVal === 0 ? currCellVal - 0 : null;
-    var nextNumber = nextCellVal || nextCellVal === 0 ? nextCellVal - 0 : null;
-    return number.sortNumber(currNumber, nextNumber, sortType);
+    var leftNumber = leftComputedValue || leftComputedValue === 0 ? leftComputedValue - 0 : null;
+    var rightNumber = rightComputedValue || rightComputedValue === 0 ? rightComputedValue - 0 : null;
+    return number.sortNumber(leftNumber, rightNumber, sortType);
   }
   if (column.DATE_COLUMN_OPTIONS.includes(result_type)) {
-    return date.sortDate(currCellVal, nextCellVal, sortType);
+    return date.sortDate(leftComputedValue, rightComputedValue, sortType);
   }
   if (result_type === formula.FORMULA_RESULT_TYPE.BOOL) {
-    var currBoolean = currCellVal || false;
-    var nextBoolean = nextCellVal || false;
-    return checkbox.sortCheckbox(currBoolean, nextBoolean);
+    var leftBoolean = leftComputedValue || false;
+    var rightBoolean = rightComputedValue || false;
+    return checkbox.sortCheckbox(leftBoolean, rightBoolean, sortType);
   }
   if (result_type === formula.FORMULA_RESULT_TYPE.ARRAY) {
-    return array.sortByArrayType(currCellVal, nextCellVal, sortType, {
+    return array.sortByArrayType(leftComputedValue, rightComputedValue, sortType, {
       columnData: columnData,
       value: value
     });
   }
-  var currText = cellValue.getFormulaDisplayString(currCellVal, columnData);
-  var nextText = cellValue.getFormulaDisplayString(nextCellVal, columnData);
-  return text.sortText(currText, nextText, sortType);
+  var leftText = cellValue.getFormulaDisplayString(leftComputedValue, columnData);
+  var rightText = cellValue.getFormulaDisplayString(rightComputedValue, columnData);
+  return text.sortText(leftText, rightText, sortType);
 };
 
 exports.sortFormula = sortFormula;

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

@@ -4,21 +4,30 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var array = require('./array.js');
 
-var sortLink = function sortLink(currCellVal, nextCellVal, sortType, _ref) {
+/**
+ * Sort link
+ * @param {array} leftLinkedCellValues e.g. [{ row_id, display_value }]
+ * @param {array} rightLinkedCellValues
+ * @param {string} sortType e.g. 'up' | 'down
+ * @param {object} columnData e.g. { result_type, array_type, array_data, ... }
+ * @param {object} value e.g. { collaborators, ... }
+ * @returns number
+ */
+var sortLink = function sortLink(leftLinkedCellValues, rightLinkedCellValues, sortType, _ref) {
   var columnData = _ref.columnData,
     value = _ref.value;
-  var emptyCurrCellVal = !Array.isArray(currCellVal) || currCellVal.length === 0;
-  var emptyNextCellVal = !Array.isArray(nextCellVal) || nextCellVal.length === 0;
-  if (emptyCurrCellVal && emptyNextCellVal) return 0;
-  if (emptyCurrCellVal) return 1;
-  if (emptyNextCellVal) return -1;
-  var currDisplayValues = currCellVal.map(function (linked) {
+  var emptyLeftLinkedCellValues = !Array.isArray(leftLinkedCellValues) || leftLinkedCellValues.length === 0;
+  var emptyRightLinkedCellValues = !Array.isArray(rightLinkedCellValues) || rightLinkedCellValues.length === 0;
+  if (emptyLeftLinkedCellValues && emptyRightLinkedCellValues) return 0;
+  if (emptyLeftLinkedCellValues) return 1;
+  if (emptyRightLinkedCellValues) return -1;
+  var leftDisplayValues = leftLinkedCellValues.map(function (linked) {
     return linked.display_value;
   });
-  var nextDisplayValues = nextCellVal.map(function (linked) {
+  var rightDisplayValues = rightLinkedCellValues.map(function (linked) {
     return linked.display_value;
   });
-  return array.sortByArrayType(currDisplayValues, nextDisplayValues, sortType, {
+  return array.sortByArrayType(leftDisplayValues, rightDisplayValues, sortType, {
     columnData: columnData,
     value: value
   });

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

@@ -2,49 +2,48 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var core = require('../core.js');
 var sort = require('../../constants/sort.js');
 
-var getMultipleIndexesOrderbyOptions = function getMultipleIndexesOrderbyOptions(cellValue, option_id_index_map) {
-  var indexArr = [];
-  cellValue.forEach(function (optionId) {
-    var index = option_id_index_map[optionId];
-    if (index > -1) {
-      indexArr.push(index);
-    }
-  });
-  return indexArr.sort();
-};
-var sortMultipleSelect = function sortMultipleSelect(currCellVal, nextCellVal, _ref) {
+/**
+ * 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 emptyCurrCellVal = !currCellVal || currCellVal.length === 0;
-  var emptyNextCellVal = !nextCellVal || nextCellVal.length === 0;
-  if (emptyCurrCellVal && emptyNextCellVal) return 0;
-  if (emptyCurrCellVal) return 1;
-  if (emptyNextCellVal) return -1;
-  var currCellValIndexes = getMultipleIndexesOrderbyOptions(currCellVal, option_id_index_map);
-  var nextCellValIndexes = getMultipleIndexesOrderbyOptions(nextCellVal, option_id_index_map);
-  var currLen = currCellValIndexes.length;
-  var nextLen = nextCellValIndexes.length;
+  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 (currLen === nextLen && (currLen === 0 || currCellValIndexes.join('') === nextCellValIndexes.join(''))) {
+  if (leftOptionsLen === rightOptionsLen && (leftOptionsLen === 0 || leftOptionIndexes.join('') === rightOptionIndexes.join(''))) {
     return 0;
   }
-  var len = Math.min(currLen, nextLen);
+  var len = Math.min(leftOptionsLen, rightOptionsLen);
   for (var i = 0; i < len; i++) {
-    if (currCellValIndexes[i] > nextCellValIndexes[i]) {
+    if (leftOptionIndexes[i] > rightOptionIndexes[i]) {
       return sort_type === sort.SORT_TYPE.UP ? 1 : -1;
     }
-    if (currCellValIndexes[i] < nextCellValIndexes[i]) {
+    if (leftOptionIndexes[i] < rightOptionIndexes[i]) {
       return sort_type === sort.SORT_TYPE.UP ? -1 : 1;
     }
   }
-  if (currLen > nextLen) {
+  if (leftOptionsLen > rightOptionsLen) {
     return sort_type === sort.SORT_TYPE.UP ? 1 : -1;
   }
   return sort_type === sort.SORT_TYPE.UP ? -1 : 1;
 };
 
-exports.getMultipleIndexesOrderbyOptions = getMultipleIndexesOrderbyOptions;
+exports.getMultipleIndexesOrderbyOptions = core.getMultipleIndexesOrderbyOptions;
 exports.sortMultipleSelect = sortMultipleSelect;

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

@@ -4,16 +4,23 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var sort = require('../../constants/sort.js');
 
-var sortNumber = function sortNumber(currNum, nextNum, sortType) {
-  var emptyCurrNum = !currNum && currNum !== 0;
-  var emptyNextNum = !nextNum && nextNum !== 0;
-  if (emptyCurrNum && emptyNextNum) return 0;
-  if (emptyCurrNum) return 1;
-  if (emptyNextNum) return -1;
-  if (currNum > nextNum) {
+/**
+ * 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 (currNum < nextNum) {
+  if (leftNumber < rightNumber) {
     return sortType === sort.SORT_TYPE.UP ? -1 : 1;
   }
   return 0;

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

@@ -4,16 +4,24 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var sort = require('../../constants/sort.js');
 
-var sortSingleSelect = function sortSingleSelect(currCellVal, nextCellVal, _ref) {
+/**
+ * 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[currCellVal];
-  var nextOptionIdIndex = option_id_index_map[nextCellVal];
-  var emptyCurrCellVal = !currentOptionIdIndex && currentOptionIdIndex !== 0;
-  var emptyNextCellVal = !nextOptionIdIndex && nextOptionIdIndex !== 0;
-  if (emptyCurrCellVal && emptyNextCellVal) return 0;
-  if (emptyCurrCellVal) return 1;
-  if (emptyNextCellVal) return -1;
+  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;
   }

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

@@ -5,6 +5,12 @@ 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;
@@ -23,8 +29,8 @@ var compareString = function compareString(leftString, rightString) {
     rightStringPart = rightStringParts[i];
     isDigitPart = reg.REG_NUMBER_DIGIT.test(leftStringPart) && reg.REG_NUMBER_DIGIT.test(rightStringPart);
     if (isDigitPart) {
-      leftStringPart = parseInt(leftStringPart, 10);
-      rightStringPart = parseInt(rightStringPart, 10);
+      leftStringPart = parseInt(leftStringPart);
+      rightStringPart = parseInt(rightStringPart);
       if (leftStringPart > rightStringPart) {
         return 1;
       }
@@ -38,14 +44,22 @@ var compareString = function compareString(leftString, rightString) {
   }
   return leftString.localeCompare(rightString);
 };
-var sortText = function sortText(currCellVal, nextCellVal, sortType) {
-  var emptyCurrCellVal = !currCellVal;
-  var emptyNextCellVal = !nextCellVal;
-  if (emptyCurrCellVal && emptyNextCellVal) return 0;
-  if (emptyCurrCellVal) return 1;
-  if (emptyNextCellVal) return -1;
-  if (nextCellVal === currCellVal) return 0;
-  return sortType === sort.SORT_TYPE.UP ? compareString(currCellVal, nextCellVal) : -1 * compareString(currCellVal, nextCellVal);
+
+/**
+ * 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;

package/lib/sort/sort-row.js

@@ -2,7 +2,6 @@
 
 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');
@@ -18,49 +17,20 @@ 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) {
+/**
+ * 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;
-  sortRows.sort(function (currentRow, nextRow) {
+  tableRows.sort(function (currentRow, nextRow) {
     var initValue = 0;
     sorts.forEach(function (sort$1) {
       var column_key = sort$1.column_key,
@@ -114,13 +84,23 @@ var sortRowsWithMultiSorts = function sortRowsWithMultiSorts(sortRows, sorts, _r
     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)) return [];
+  if (!Array.isArray(rows) || rows.length === 0) return [];
   var sortRows = rows.slice(0);
-  var validSorts = deleteInvalidSort(sorts, columns);
+  var validSorts = core.deleteInvalidSort(sorts, columns);
   var normalizedFormulaRows = formulaRows || {};
   sortRowsWithMultiSorts(sortRows, validSorts, {
     formulaRows: normalizedFormulaRows,
@@ -131,6 +111,5 @@ var sortTableRows = function sortTableRows(sorts, rows, columns) {
   });
 };
 
-exports.deleteInvalidSort = deleteInvalidSort;
 exports.sortRowsWithMultiSorts = sortRowsWithMultiSorts;
 exports.sortTableRows = sortTableRows;

package/lib/table/column.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 /**
- * get column by key from table
+ * Get column by key from table
  * @param {object} table
  * @param {string} columnKey
  * @returns column, object
@@ -16,7 +16,7 @@ var getTableColumnByKey = function getTableColumnByKey(table, columnKey) {
 };
 
 /**
- * get column by name from table
+ * Get table column by name
  * @param {object} table
  * @param {string} columnName
  * @returns column, object

package/lib/table/core.js

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

package/lib/table/row.js

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