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

package/es/index.js

@@ -1,7 +1,7 @@
 export { CellType } from './constants/cell-type.js';
 export { COLLABORATOR_COLUMN_TYPES, COLUMNS_ICON_CONFIG, COLUMN_OPTIONS, DATE_COLUMN_OPTIONS, DATE_DEFAULT_TYPES, DATE_FORMAT_MAP, DATE_UNIT, DEFAULT_DATE_FORMAT, DEFAULT_NUMBER_FORMAT, DURATION_DECIMAL_DIGITS, DURATION_FORMATS, DURATION_FORMATS_MAP, DURATION_ZERO_DISPLAY, FILL_DEFAULT_VALUE_COLUMNS_TYPE, MULTIPLE_CELL_VALUE_COLUMN_TYPE_MAP, NOT_SUPPORT_EDIT_COLUMN_TYPE_MAP, NUMERIC_COLUMNS_TYPES, SINGLE_CELL_VALUE_COLUMN_TYPE_MAP, UTC_FORMAT_DEFAULT } from './constants/column.js';
 export { FILTER_CONJUNCTION_TYPE, FILTER_ERR_MSG } from './constants/filter/index.js';
-export { FORMULA_COLUMN_TYPES_MAP, FORMULA_RESULT_TYPE } from './constants/formula.js';
+export { DISPLAY_INTERNAL_ERRORS, FORMULA_COLUMN_TYPES_MAP, FORMULA_RESULT_TYPE } from './constants/formula.js';
 export { HIGHLIGHT_COLORS, SELECT_OPTION_COLORS } from './constants/select-option.js';
 export { NUMBER_SORTER_COLUMN_TYPES, SORT_COLUMN_OPTIONS, SORT_TYPE, TEXT_SORTER_COLUMN_TYPES } from './constants/sort.js';
 export { DISPLAY_GROUP_DATE_GRANULARITY, DISPLAY_GROUP_GEOLOCATION_GRANULARITY, GROUP_DATE_GRANULARITY, GROUP_GEOLOCATION_GRANULARITY, MAX_GROUP_LEVEL, SUPPORT_GROUP_COLUMN_TYPES } from './constants/group.js';
@@ -9,10 +9,11 @@ export { COLUMN_PERMISSION_TYPE } from './constants/column-permission.js';
 export { REG_NUMBER_DIGIT, REG_STRING_NUMBER_PARTS } from './constants/reg.js';
 export { COLOR_GRADATION_OPTIONS } from './constants/color.js';
 export { HEADER_HEIGHT_TYPE } from './constants/grid-header.js';
-export { generatorBase64Code, isEmpty } from './common.js';
-export { getTableById } from './table/index.js';
+export { generatorBase64Code, isEmpty, isEmptyObject } from './common.js';
+export { getTableById } from './table/core.js';
+export { getTableColumnByKey, getTableColumnByName } from './table/column.js';
+export { getRowById, getRowsByIds } from './table/row.js';
 export { convertRow, isTableRows } from './row/core.js';
-export { default as RowColorUtils } from './row/color.js';
 export { getLinkColumnsUsedInFilters, getViewById, isDefaultView, isFilterView, isGroupView, isSortView } from './view/core.js';
 export { getSummaries, getSummariesWithSubgroups, updateGroupSummaries } from './view/summaries.js';
 export { getFormulaColumnsContainLinks, getSortedFormulaColumns, getSortedFormulaColumnsContainLinks, transLink2LinkFormula } from './view/formula.js';
@@ -33,7 +34,6 @@ export { formatTextToDate } from './cell-value-set/date.js';
 export { createOption, generateOptionID, generatorCellOption, generatorCellOptions, getColumnOptions } from './column/option.js';
 export { isDateColumn } from './column/date.js';
 export { isNumberColumn, isNumericColumn } from './column/number.js';
-export { default as ColumnColorUtils } from './column/color.js';
 export { DateUtils } from './date.js';
 export { isNumber, isNumberEqual } from './number.js';
 export { ValidateFilter } from './validate/filter.js';
@@ -55,24 +55,24 @@ export { numberFilter } from './filter/filter-column/number.js';
 export { singleSelectFilter } from './filter/filter-column/single-select.js';
 export { linkFilter } from './filter/filter-column/link.js';
 export { filterRow, filterRows, getFilteredRowsWithoutFormulaCalculation } from './filter/filter-row.js';
-export { getValidSorts, isValidSort } from './sort/core.js';
+export { deleteInvalidSort, getMultipleIndexesOrderbyOptions, getValidSorts, isValidSort } from './sort/core.js';
 export { sortCheckbox } from './sort/sort-column/checkbox.js';
 export { sortCollaborator } from './sort/sort-column/collaborator.js';
 export { sortDate } from './sort/sort-column/date.js';
 export { sortByArrayType } from './sort/sort-column/array.js';
 export { sortFormula } from './sort/sort-column/formula.js';
 export { sortLink } from './sort/sort-column/link.js';
-export { getMultipleIndexesOrderbyOptions, sortMultipleSelect } from './sort/sort-column/multiple-select.js';
+export { sortMultipleSelect } from './sort/sort-column/multiple-select.js';
 export { sortNumber } from './sort/sort-column/number.js';
 export { sortSingleSelect } from './sort/sort-column/single-select.js';
 export { compareString, sortText } from './sort/sort-column/text.js';
-export { deleteInvalidSort, sortRowsWithMultiSorts, sortTableRows } from './sort/sort-row.js';
+export { sortRowsWithMultiSorts, sortTableRows } from './sort/sort-row.js';
 export { deleteInvalidGroupby, getValidGroupbys, isValidGroupby } from './group/core.js';
 export { getGroupedRowsWithoutFormulaCalculation, groupTableRows, groupViewRows } from './group/group-row.js';
 export { default as GradientColorUtils } from './color/gradient-color.js';
+export { default as ColumnColorUtils } from './color/column-color.js';
+export { default as RowColorUtils } from './color/row-color.js';
 export { FILTER_COLUMN_OPTIONS } from './constants/filter/filter-column-options.js';
 export { FILTER_TERM_MODIFIER_SHOW, FILTER_TERM_MODIFIER_TYPE } from './constants/filter/filter-modifier.js';
 export { FILTER_PREDICATE_SHOW, FILTER_PREDICATE_TYPE } from './constants/filter/filter-predicate.js';
 export { filterTermModifierIsWithin, filterTermModifierNotWithin } from './constants/filter/filter-is-within.js';
-export { getTableColumnByKey, getTableColumnByName } from './table/column.js';
-export { getRowById, getRowsByIds } from './table/row.js';

package/es/link/core.js

@@ -1,10 +1,10 @@
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 
 /**
- * get link by id
- * @param {array} links [{ _id, ... }]
+ * Get link by id
+ * @param {array} links e.g. [{ _id, ... }, ...]
  * @param {string} linkId
- * @returns object
+ * @returns link, object
  */
 var getLinkById = function getLinkById(links, linkId) {
   if (!Array.isArray(links) || !linkId) return null;
@@ -14,9 +14,9 @@ var getLinkById = function getLinkById(links, linkId) {
 };
 
 /**
- * check is valid link by link column's data
- * @param {object} columnData 
- * @returns boolean
+ * Check is valid link
+ * @param {object} columnData
+ * @returns bool
  */
 var isValidLink = function isValidLink(linkColumnData) {
   if (!linkColumnData) return false;
@@ -28,35 +28,35 @@ var isValidLink = function isValidLink(linkColumnData) {
 };
 
 /**
- * get current table's id
+ * Get current table id by link relationship
  * @param {string} currentTableID
  * @param {string} tableID
  * @param {string} otherTableID
- * @returns string
+ * @returns current table id, string
  */
 var getLinkTableID = function getLinkTableID(currentTableID, tableID, otherTableID) {
   return currentTableID === tableID ? tableID : otherTableID;
 };
 
 /**
- * get linked table's id
+ * Get linked table id by link relationship
  * @param {string} currentTableID
  * @param {string} tableID
  * @param {string} otherTableID
- * @returns string
+ * @returns linked table id, string
  */
 var getLinkedTableID = function getLinkedTableID(currentTableID, tableID, otherTableID) {
   return currentTableID === tableID ? otherTableID : tableID;
 };
 
 /**
- * get linked rows ids of the row id
- * @param {array} links [ { _id: '', table1_id, table2_id: '', table1_table2_map: {}, table2_table1_map: {} }, ... ]
- * @param {string} link_id
+ * Get linked rows ids by the given row id
+ * @param {array} links e.g. [ { _id, table1_id, table2_id, table1_table2_map, table2_table1_map, ... }, ... ]
+ * @param {string} linkId
  * @param {string} table1Id
  * @param {string} table2Id
  * @param {string} rowId
- * @returns array, linked rows ids
+ * @returns linked rows ids, array
  */
 var getLinkCellValue = function getLinkCellValue(links, linkId, table1Id, table2Id, rowId) {
   if (!Array.isArray(links) || links.length === 0 || !table1Id || !table2Id || !rowId) return [];

package/es/number.js

@@ -1,13 +1,21 @@
 /**
- * check whether is number
+ * Check whether is number
  * @param {number} number
  * @returns boolean
  */
 var isNumber = function isNumber(number) {
   return (number || number === 0) && Object.prototype.toString.call(number) === '[object Number]';
 };
-var isNumberEqual = function isNumberEqual(number1, number2) {
-  return number1 === number2 || Math.abs(number1 - number2) < 0.00001;
+
+/**
+ * Check whether the numbers is equal
+ * Two numbers are considered equal if the absolute value of their difference is less than 0.00001
+ * @param {number} leftNumber
+ * @param {number} rightNumber
+ * @returns bool
+ */
+var isNumberEqual = function isNumberEqual(leftNumber, rightNumber) {
+  return leftNumber === rightNumber || Math.abs(leftNumber - rightNumber) < 0.00001;
 };
 
 export { isNumber, isNumberEqual };

package/es/row/core.js

@@ -2,6 +2,7 @@ import _typeof from '@babel/runtime/helpers/typeof';
 import { getFormulaDisplayString } from '../cell-value-get/cell-value.js';
 import 'dayjs';
 import '../constants/column.js';
+import '../constants/formula.js';
 import { getColumnOptionNameById } from '../cell-value-get/option.js';
 import '../constants/group.js';
 import { getLinkCellValue } from '../link/core.js';
@@ -9,9 +10,27 @@ import { isEmpty } from '../common.js';
 import { CellType } from '../constants/cell-type.js';
 import { CONVERT_ROW_COLUMNS_LIMIT } from '../constants/limit.js';
 
+/**
+ * Check is table rows
+ * @param {array} rows e.g. table rows: [{ _id, xxx }, ...] | view rows: [ row._id, ... ]
+ * @returns bool
+ */
 var isTableRows = function isTableRows(rows) {
   return Array.isArray(rows) && _typeof(rows[0]) === 'object';
 };
+
+/**
+ * Convert row
+ * e.g. { '0000': 'a' } to { 'Name': 'a' }
+ * @param {object} row
+ * @param {object} value e.g. { links, ... }
+ * @param {object} table e.g. { _id, columns, ... }
+ * @param {object} view e.g. { hidden_columns, ... }
+ * @param {object} formulaResults computed value of formula, link-formula, link etc.
+ * @param {bool} convertLinkID use to convert link: get linked from formulaResults if true, otherwise get linked from links
+ * @param {func} debug use to debug if supplied
+ * @returns converted row, object
+ */
 var convertRow = function convertRow(row, value, table, view, formulaResults, convertLinkID) {
   var _ref = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : {},
     debug = _ref.debug;
@@ -94,7 +113,7 @@ var convertRow = function convertRow(row, value, table, view, formulaResults, co
             // get values form formulaResults
             var formulaRow = formulaResults && formulaResults[row._id];
             var cellResult = formulaRow && formulaRow[key];
-            if (!cellResult || !Array.isArray(cellResult) || cellResult.length === 0) {
+            if (!Array.isArray(cellResult) || cellResult.length === 0) {
               result[columnName] = null;
               break;
             }

package/es/sort/core.js

@@ -1,10 +1,16 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { getColumnOptions } from '../column/option.js';
+import { CellType } from '../constants/cell-type.js';
 import { SORT_COLUMN_OPTIONS } from '../constants/sort.js';
 
+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(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; }
+
 /**
- * check is valid sort
- * @param {object} sort e.g. { column_key: '', sort_type: '' }
+ * Check is valid sort
+ * @param {object} sort e.g. { column_key, sort_type, ... }
  * @param {array} columns
- * @returns boolean
+ * @returns bool
  */
 var isValidSort = function isValidSort(sort, columns) {
   var sortByColumn = sort && columns.find(function (column) {
@@ -15,12 +21,12 @@ var isValidSort = function isValidSort(sort, columns) {
 };
 
 /**
- * get valid sorts
+ * Get valid sorts
  *   1. sort column is exist or not
  *   2. valid sort type
- * @param {array} sorts
+ * @param {array} sorts e.g. [{ column_key, sort_type, ... }, ...]
  * @param {array} columns
- * @returns array
+ * @returns valid sorts, array
  */
 var getValidSorts = function getValidSorts(sorts, columns) {
   if (!Array.isArray(sorts) || !Array.isArray(columns)) return [];
@@ -29,4 +35,57 @@ var getValidSorts = function getValidSorts(sorts, columns) {
   });
 };
 
-export { getValidSorts, isValidSort };
+/**
+ * Get sorted option index of the "optionIds"
+ * @param {array} optionIds
+ * @param {object} option_id_index_map e.g. {[option.id]: 0, ...}
+ * @returns sorted options index, array
+ */
+var getMultipleIndexesOrderbyOptions = function getMultipleIndexesOrderbyOptions(optionIds, option_id_index_map) {
+  var indexArr = [];
+  optionIds.forEach(function (optionId) {
+    var index = option_id_index_map[optionId];
+    if (index > -1) {
+      indexArr.push(index);
+    }
+  });
+  return indexArr.sort();
+};
+
+/**
+ * Get valid and formatted sorts
+ * @param {array} sorts e.g. [{ column_key, sort_type, ... }, ...]
+ * @param {array} columns
+ * @returns valid and formatted sorts, array
+ */
+var deleteInvalidSort = function deleteInvalidSort(sorts, columns) {
+  var validSorts = 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.SINGLE_SELECT:
+      case CellType.MULTIPLE_SELECT:
+        {
+          var options = 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;
+};
+
+export { deleteInvalidSort, getMultipleIndexesOrderbyOptions, getValidSorts, isValidSort };

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

@@ -9,55 +9,64 @@ import { CellType } from '../../constants/cell-type.js';
 import { NUMERIC_COLUMNS_TYPES, DATE_COLUMN_OPTIONS } from '../../constants/column.js';
 import { FORMULA_RESULT_TYPE } from '../../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 (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 sortNumber(currNumber, nextNumber, sortType);
+    leftNumber = leftNumber || leftNumber === 0 ? leftNumber : null;
+    rightNumber = rightNumber || rightNumber === 0 ? rightNumber : null;
+    return sortNumber(leftNumber, rightNumber, sortType);
   }
   if (DATE_COLUMN_OPTIONS.includes(array_type)) {
-    var currDate = Array.isArray(currCellVal) ? currCellVal[0] : currCellVal;
-    var nextDate = Array.isArray(nextCellVal) ? nextCellVal[0] : nextCellVal;
-    return sortDate(currDate, nextDate, sortType);
+    var leftDate = Array.isArray(leftArray) ? leftArray[0] : leftArray;
+    var rightDate = Array.isArray(rightArray) ? rightArray[0] : rightArray;
+    return sortDate(leftDate, rightDate, sortType);
   }
   if (array_type === CellType.CHECKBOX || array_type === 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 sortCheckbox(currBoolean, nextBoolean, sortType);
+    leftBool = leftBool || false;
+    rightBool = rightBool || false;
+    return sortCheckbox(leftBool, rightBool, sortType);
   }
   if (array_type === 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 = getCollaboratorsNames(currCollaborators, collaborators);
-      nextCollaborators = getCollaboratorsNames(nextCollaborators, collaborators);
+      leftCollaborators = getCollaboratorsNames(leftCollaborators, collaborators);
+      rightCollaborators = getCollaboratorsNames(rightCollaborators, collaborators);
     }
-    return sortCollaborator(currCollaborators, nextCollaborators, sortType);
+    return sortCollaborator(leftCollaborators, rightCollaborators, sortType);
   }
-  var currText = getFormulaDisplayString(currCellVal, columnData);
-  var nextText = getFormulaDisplayString(nextCellVal, columnData);
-  return sortText(currText, nextText, sortType);
+  var leftText = getFormulaDisplayString(leftArray, columnData);
+  var rightText = getFormulaDisplayString(rightArray, columnData);
+  return sortText(leftText, rightText, sortType);
 };
 
 export { sortByArrayType };

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

@@ -1,12 +1,19 @@
 import { SORT_TYPE } from '../../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_TYPE.UP ? 1 : -1;
   }
-  if (currCellValPart < nextCellValPart) {
+  if (normalizedCurrChecked < normalizedNextChecked) {
     return sortType === SORT_TYPE.UP ? -1 : 1;
   }
   return 0;

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

@@ -1,9 +1,16 @@
 import { sortText } from './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 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 sortText(sLeftCollaborators, sRightCollaborators, sortType);
 };
 
 export { sortCollaborator };

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

@@ -1,22 +1,22 @@
 import { SORT_TYPE } from '../../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_TYPE.UP ? 1 : -1;
   }
-  if (currDate < nextDate) {
+  if (leftDate < rightDate) {
     return sortType === SORT_TYPE.UP ? -1 : 1;
   }
   return 0;

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

@@ -8,33 +8,42 @@ import { DATE_COLUMN_OPTIONS } from '../../constants/column.js';
 import { FORMULA_RESULT_TYPE } from '../../constants/formula.js';
 import { NUMBER_SORTER_COLUMN_TYPES } from '../../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 (NUMBER_SORTER_COLUMN_TYPES.includes(result_type)) {
-    var currNumber = currCellVal || currCellVal === 0 ? currCellVal - 0 : null;
-    var nextNumber = nextCellVal || nextCellVal === 0 ? nextCellVal - 0 : null;
-    return sortNumber(currNumber, nextNumber, sortType);
+    var leftNumber = leftComputedValue || leftComputedValue === 0 ? leftComputedValue - 0 : null;
+    var rightNumber = rightComputedValue || rightComputedValue === 0 ? rightComputedValue - 0 : null;
+    return sortNumber(leftNumber, rightNumber, sortType);
   }
   if (DATE_COLUMN_OPTIONS.includes(result_type)) {
-    return sortDate(currCellVal, nextCellVal, sortType);
+    return sortDate(leftComputedValue, rightComputedValue, sortType);
   }
   if (result_type === FORMULA_RESULT_TYPE.BOOL) {
-    var currBoolean = currCellVal || false;
-    var nextBoolean = nextCellVal || false;
-    return sortCheckbox(currBoolean, nextBoolean);
+    var leftBoolean = leftComputedValue || false;
+    var rightBoolean = rightComputedValue || false;
+    return sortCheckbox(leftBoolean, rightBoolean, sortType);
   }
   if (result_type === FORMULA_RESULT_TYPE.ARRAY) {
-    return sortByArrayType(currCellVal, nextCellVal, sortType, {
+    return sortByArrayType(leftComputedValue, rightComputedValue, sortType, {
       columnData: columnData,
       value: value
     });
   }
-  var currText = getFormulaDisplayString(currCellVal, columnData);
-  var nextText = getFormulaDisplayString(nextCellVal, columnData);
-  return sortText(currText, nextText, sortType);
+  var leftText = getFormulaDisplayString(leftComputedValue, columnData);
+  var rightText = getFormulaDisplayString(rightComputedValue, columnData);
+  return sortText(leftText, rightText, sortType);
 };
 
 export { sortFormula };

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

@@ -1,20 +1,29 @@
 import { sortByArrayType } from './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 sortByArrayType(currDisplayValues, nextDisplayValues, sortType, {
+  return sortByArrayType(leftDisplayValues, rightDisplayValues, sortType, {
     columnData: columnData,
     value: value
   });

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

@@ -1,45 +1,45 @@
+import { getMultipleIndexesOrderbyOptions } from '../core.js';
+export { getMultipleIndexesOrderbyOptions } from '../core.js';
 import { SORT_TYPE } from '../../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 = getMultipleIndexesOrderbyOptions(leftOptionIds, option_id_index_map);
+  var rightOptionIndexes = 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_TYPE.UP ? 1 : -1;
     }
-    if (currCellValIndexes[i] < nextCellValIndexes[i]) {
+    if (leftOptionIndexes[i] < rightOptionIndexes[i]) {
       return sort_type === SORT_TYPE.UP ? -1 : 1;
     }
   }
-  if (currLen > nextLen) {
+  if (leftOptionsLen > rightOptionsLen) {
     return sort_type === SORT_TYPE.UP ? 1 : -1;
   }
   return sort_type === SORT_TYPE.UP ? -1 : 1;
 };
 
-export { getMultipleIndexesOrderbyOptions, sortMultipleSelect };
+export { sortMultipleSelect };