dtable-utils 0.0.1 → 0.0.3-beta.1

package/lib/row/core.js

@@ -0,0 +1,170 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _typeof = require('@babel/runtime/helpers/typeof');
+var cellValue = require('../cell-value-get/cell-value.js');
+require('dayjs');
+require('../constants/column.js');
+var option = require('../cell-value-get/option.js');
+require('../constants/group.js');
+var core = require('../link/core.js');
+var common = require('../common.js');
+var cellType = require('../constants/cell-type.js');
+var limit = require('../constants/limit.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _typeof__default = /*#__PURE__*/_interopDefaultLegacy(_typeof);
+
+var isTableRows = function isTableRows(rows) {
+  return Array.isArray(rows) && _typeof__default["default"](rows[0]) === 'object';
+};
+var convertRow = function convertRow(row, value, table, view, formulaResults, convertLinkID) {
+  var _ref = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : {},
+    debug = _ref.debug;
+  var result = {};
+  // eslint-disable-next-line
+  if (row.hasOwnProperty('_id')) {
+    result._id = row._id;
+  }
+  // eslint-disable-next-line
+  if (row.hasOwnProperty('_mtime')) {
+    result._mtime = row._mtime;
+  }
+  // eslint-disable-next-line
+  if (row.hasOwnProperty('_ctime')) {
+    result._ctime = row._ctime;
+  }
+  var columns = table.columns;
+  if (columns.length > limit.CONVERT_ROW_COLUMNS_LIMIT) {
+    columns = columns.slice(0, limit.CONVERT_ROW_COLUMNS_LIMIT);
+  }
+  var hiddenColumns = view ? view.hidden_columns : null;
+  for (var i = 0; i < columns.length; i++) {
+    var column = columns[i];
+    var key = column.key,
+      type = column.type,
+      columnName = column.name;
+    if (hiddenColumns && hiddenColumns.includes(key)) {
+      continue;
+    }
+    var cellValue$1 = row[key];
+    switch (type) {
+      case cellType.CellType.SINGLE_SELECT:
+        {
+          if (!column.data) {
+            if (debug) {
+              debug('No options found');
+            }
+            break;
+          }
+          result[columnName] = option.getColumnOptionNameById(column, cellValue$1);
+          break;
+        }
+      case cellType.CellType.MULTIPLE_SELECT:
+        {
+          if (!column.data) {
+            if (debug) {
+              debug('No options found');
+            }
+            break;
+          }
+          if (!Array.isArray(cellValue$1)) {
+            result[columnName] = '';
+            break;
+          }
+          var optionNames = [];
+          for (var optionIndex = 0; optionIndex < cellValue$1.length; optionIndex++) {
+            var optionName = option.getColumnOptionNameById(column, cellValue$1[optionIndex]);
+            if (optionName) {
+              optionNames.push(optionName);
+            }
+          }
+          result[columnName] = optionNames;
+          break;
+        }
+      case cellType.CellType.LONG_TEXT:
+        {
+          result[columnName] = cellValue$1 ? cellValue$1.text : '';
+          break;
+        }
+      case cellType.CellType.LINK:
+        {
+          if (!column.data) {
+            if (debug) {
+              debug('No links found');
+            }
+            break;
+          }
+          // convertLinkID to display value
+          if (convertLinkID) {
+            // get values form formulaResults
+            var formulaRow = formulaResults && formulaResults[row._id];
+            var cellResult = formulaRow && formulaRow[key];
+            if (!cellResult || !Array.isArray(cellResult) || cellResult.length === 0) {
+              result[columnName] = null;
+              break;
+            }
+            // linked with common column:
+            // cellResult
+            // [
+            //   {row_id: '', displayValue: ''},
+            //   {row_id: '', displayValue: ''},
+            // ]
+
+            // linked with formula column and formula result is array
+            // cellResult
+            // [
+            //   {row_id: '', display_value: []},
+            //   {row_id: '', display_value: []},
+            // ]
+            result[columnName] = cellResult;
+            break;
+          }
+          var tableID = table._id;
+          var _column$data = column.data,
+            link_id = _column$data.link_id,
+            table_id = _column$data.table_id,
+            other_table_id = _column$data.other_table_id;
+          var otherTableID = tableID === table_id ? other_table_id : table_id;
+          var links = value.links;
+          result[columnName] = core.getLinkCellValue(links, link_id, tableID, otherTableID, row._id);
+          break;
+        }
+      case cellType.CellType.FORMULA:
+      case cellType.CellType.LINK_FORMULA:
+        {
+          if (!column.data || !formulaResults) {
+            if (debug) {
+              debug('No formula found');
+            }
+            break;
+          }
+          var _formulaRow = formulaResults[row._id] || {};
+          result[columnName] = cellValue.getFormulaDisplayString(_formulaRow[key], column.data);
+          break;
+        }
+      default:
+        {
+          // text/email/url/auto-number/
+          // check/
+          // rate/duration/
+          // file/image/button/
+          // translate in dtable-events
+          // number/
+          // date/ctime/mtime/
+          // geolocation/
+          // collaborator/creator/last-modifier/
+          result[columnName] = cellValue$1;
+        }
+    }
+    if (common.isEmpty(result[columnName])) {
+      delete result[columnName];
+    }
+  }
+  return result;
+};
+
+exports.convertRow = convertRow;
+exports.isTableRows = isTableRows;

package/lib/sort/core.js

@@ -0,0 +1,37 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var sort = require('../constants/sort.js');
+
+/**
+ * check is valid sort
+ * @param {object} sort e.g. { column_key: '', sort_type: '' }
+ * @param {array} columns
+ * @returns boolean
+ */
+var isValidSort = function isValidSort(sort$1, columns) {
+  var sortByColumn = sort$1 && columns.find(function (column) {
+    return column.key === sort$1.column_key;
+  });
+  if (!sortByColumn) return false;
+  return sort.SORT_COLUMN_OPTIONS.includes(sortByColumn.type);
+};
+
+/**
+ * get valid sorts
+ *   1. sort column is exist or not
+ *   2. valid sort type
+ * @param {array} sorts
+ * @param {array} columns
+ * @returns array
+ */
+var getValidSorts = function getValidSorts(sorts, columns) {
+  if (!Array.isArray(sorts) || !Array.isArray(columns)) return [];
+  return sorts.filter(function (sort) {
+    return isValidSort(sort, columns);
+  });
+};
+
+exports.getValidSorts = getValidSorts;
+exports.isValidSort = isValidSort;

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

@@ -0,0 +1,67 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var collaborator = require('../../cell-value-get/collaborator.js');
+var cellValue = require('../../cell-value-get/cell-value.js');
+var checkbox = require('./checkbox.js');
+var collaborator$1 = require('./collaborator.js');
+var date = require('./date.js');
+var number = require('./number.js');
+var text = require('./text.js');
+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) {
+  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];
+    }
+    if (Array.isArray(nextCellVal)) {
+      nextNumber = nextCellVal[0];
+    }
+    currNumber = currNumber || currNumber === 0 ? currNumber : null;
+    nextNumber = nextNumber || nextNumber === 0 ? nextNumber : null;
+    return number.sortNumber(currNumber, nextNumber, 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);
+  }
+  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];
+    }
+    if (Array.isArray(nextCellVal)) {
+      nextBoolean = nextCellVal[0];
+    }
+    currBoolean = currBoolean || false;
+    nextBoolean = nextBoolean || false;
+    return checkbox.sortCheckbox(currBoolean, nextBoolean, 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];
+    if (collaborators) {
+      currCollaborators = collaborator.getCollaboratorsNames(currCollaborators, collaborators);
+      nextCollaborators = collaborator.getCollaboratorsNames(nextCollaborators, collaborators);
+    }
+    return collaborator$1.sortCollaborator(currCollaborators, nextCollaborators, sortType);
+  }
+  var currText = cellValue.getFormulaDisplayString(currCellVal, columnData);
+  var nextText = cellValue.getFormulaDisplayString(nextCellVal, columnData);
+  return text.sortText(currText, nextText, sortType);
+};
+
+exports.sortByArrayType = sortByArrayType;

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

@@ -0,0 +1,19 @@
+'use strict';
+
+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) {
+    return sortType === sort.SORT_TYPE.UP ? 1 : -1;
+  }
+  if (currCellValPart < nextCellValPart) {
+    return sortType === sort.SORT_TYPE.UP ? -1 : 1;
+  }
+  return 0;
+};
+
+exports.sortCheckbox = sortCheckbox;

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

@@ -0,0 +1,13 @@
+'use strict';
+
+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);
+};
+
+exports.sortCollaborator = sortCollaborator;

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

@@ -0,0 +1,29 @@
+'use strict';
+
+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
+ * @param {string} sortType e.g. 'up' | 'down'
+ * @returns number, e.g. 1 | -1 | 0
+ */
+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) {
+    return sortType === sort.SORT_TYPE.UP ? 1 : -1;
+  }
+  if (currDate < nextDate) {
+    return sortType === sort.SORT_TYPE.UP ? -1 : 1;
+  }
+  return 0;
+};
+
+exports.sortDate = sortDate;

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

@@ -0,0 +1,44 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var cellValue = require('../../cell-value-get/cell-value.js');
+var array = require('./array.js');
+var checkbox = require('./checkbox.js');
+var date = require('./date.js');
+var number = require('./number.js');
+var text = require('./text.js');
+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) {
+  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);
+  }
+  if (column.DATE_COLUMN_OPTIONS.includes(result_type)) {
+    return date.sortDate(currCellVal, nextCellVal, sortType);
+  }
+  if (result_type === formula.FORMULA_RESULT_TYPE.BOOL) {
+    var currBoolean = currCellVal || false;
+    var nextBoolean = nextCellVal || false;
+    return checkbox.sortCheckbox(currBoolean, nextBoolean);
+  }
+  if (result_type === formula.FORMULA_RESULT_TYPE.ARRAY) {
+    return array.sortByArrayType(currCellVal, nextCellVal, sortType, {
+      columnData: columnData,
+      value: value
+    });
+  }
+  var currText = cellValue.getFormulaDisplayString(currCellVal, columnData);
+  var nextText = cellValue.getFormulaDisplayString(nextCellVal, columnData);
+  return text.sortText(currText, nextText, sortType);
+};
+
+exports.sortFormula = sortFormula;

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

@@ -0,0 +1,27 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var array = require('./array.js');
+
+var sortLink = function sortLink(currCellVal, nextCellVal, 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) {
+    return linked.display_value;
+  });
+  var nextDisplayValues = nextCellVal.map(function (linked) {
+    return linked.display_value;
+  });
+  return array.sortByArrayType(currDisplayValues, nextDisplayValues, sortType, {
+    columnData: columnData,
+    value: value
+  });
+};
+
+exports.sortLink = sortLink;

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

@@ -0,0 +1,50 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+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) {
+  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;
+
+  // current multiple select equal to next multiple select.
+  if (currLen === nextLen && (currLen === 0 || currCellValIndexes.join('') === nextCellValIndexes.join(''))) {
+    return 0;
+  }
+  var len = Math.min(currLen, nextLen);
+  for (var i = 0; i < len; i++) {
+    if (currCellValIndexes[i] > nextCellValIndexes[i]) {
+      return sort_type === sort.SORT_TYPE.UP ? 1 : -1;
+    }
+    if (currCellValIndexes[i] < nextCellValIndexes[i]) {
+      return sort_type === sort.SORT_TYPE.UP ? -1 : 1;
+    }
+  }
+  if (currLen > nextLen) {
+    return sort_type === sort.SORT_TYPE.UP ? 1 : -1;
+  }
+  return sort_type === sort.SORT_TYPE.UP ? -1 : 1;
+};
+
+exports.getMultipleIndexesOrderbyOptions = getMultipleIndexesOrderbyOptions;
+exports.sortMultipleSelect = sortMultipleSelect;

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

@@ -0,0 +1,22 @@
+'use strict';
+
+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) {
+    return sortType === sort.SORT_TYPE.UP ? 1 : -1;
+  }
+  if (currNum < nextNum) {
+    return sortType === sort.SORT_TYPE.UP ? -1 : 1;
+  }
+  return 0;
+};
+
+exports.sortNumber = sortNumber;

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

@@ -0,0 +1,26 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var sort = require('../../constants/sort.js');
+
+var sortSingleSelect = function sortSingleSelect(currCellVal, nextCellVal, _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;
+  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,52 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var reg = require('../../constants/reg.js');
+var sort = require('../../constants/sort.js');
+
+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, 10);
+      rightStringPart = parseInt(rightStringPart, 10);
+      if (leftStringPart > rightStringPart) {
+        return 1;
+      }
+      if (leftStringPart < rightStringPart) {
+        return -1;
+      }
+    }
+    if (leftStringPart !== rightStringPart) {
+      return leftString.localeCompare(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);
+};
+
+exports.compareString = compareString;
+exports.sortText = sortText;