dtable-utils 0.0.2 → 0.0.3-beta.1

package/es/index.js

@@ -1,26 +1,78 @@
 export { CellType } from './constants/cell-type.js';
-export { COLLABORATOR_COLUMN_TYPES, COLUMNS_ICON_CONFIG, DATE_COLUMN_OPTIONS, DEFAULT_DATE_FORMAT, DEFAULT_NUMBER_FORMAT, DURATION_DECIMAL_DIGITS, DURATION_FORMATS, DURATION_FORMATS_MAP, DURATION_ZERO_DISPLAY, NUMERIC_COLUMNS_TYPES } from './constants/column.js';
-export { FILTER_ERR_MSG } from './constants/filter/index.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 { HIGHLIGHT_COLORS, SELECT_OPTION_COLORS } from './constants/select-option.js';
-export { generatorBase64Code } from './common.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';
+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 { 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';
+export { getGroupByPath } from './view/group.js';
+export { getLinkById, getLinkCellValue, getLinkTableID, getLinkedTableID, isValidLink } from './link/core.js';
 export { getDateDisplayString } from './cell-value-get/date.js';
 export { getDurationDisplayString } from './cell-value-get/duration.js';
-export { getNumberDisplayString, replaceNumberNotAllowInput } from './cell-value-get/number.js';
-export { getMultipleOptionName, getOptionName } from './cell-value-get/option.js';
-export { getCollaboratorsName, getCollaboratorsNames } from './cell-value-get/collaborator.js';
-export { getGeolocationDisplayString } from './cell-value-get/geolocation.js';
+export { getNumberDisplayString, getPrecisionNumber, replaceNumberNotAllowInput } from './cell-value-get/number.js';
+export { getColumnOptionNameById, getMultipleOptionName, getOption, getOptionName } from './cell-value-get/option.js';
+export { getCollaborator, getCollaboratorsName, getCollaboratorsNames } from './cell-value-get/collaborator.js';
+export { getGeolocationByGranularity, getGeolocationDisplayString } from './cell-value-get/geolocation.js';
 export { getDigitalSignImageUrl } from './cell-value-get/digital-sign.js';
 export { getLongtextDisplayString } from './cell-value-get/long-text.js';
-export { getCellValueDisplayString, getFormulaDisplayString } from './cell-value-get/cell-value.js';
-export { formatStringToNumber, getFloatNumber } from './cell-value-set/number.js';
-export { getColumnOptions } from './column/common.js';
+export { getCellValueDisplayString, getCellValueStringResult, getFormulaDisplayString } from './cell-value-get/cell-value.js';
+export { getRateDisplayString } from './cell-value-get/rate.js';
+export { formatDurationToNumber, formatStringToNumber, getFloatNumber } from './cell-value-set/number.js';
+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';
 export { isValidEmail } from './validate/email.js';
+export { isValidPosition } from './validate/geolocation.js';
+export { deleteInvalidFilter, getFormattedFilter, getFormattedFilterOtherDate, getFormattedFilters, getValidFilters, getValidFiltersWithoutError, otherDate } from './filter/core.js';
+export { checkboxFilter } from './filter/filter-column/checkbox.js';
+export { collaboratorFilter } from './filter/filter-column/collaborator.js';
+export { creatorFilter } from './filter/filter-column/creator.js';
+export { dateFilter } from './filter/filter-column/date.js';
+export { digitalSignFilter } from './filter/filter-column/digital-sign.js';
+export { fileFilter } from './filter/filter-column/file.js';
+export { formulaFilter } from './filter/filter-column/formula.js';
+export { geolocationFilter } from './filter/filter-column/geolocation.js';
+export { textFilter } from './filter/filter-column/text.js';
+export { longTextFilter } from './filter/filter-column/long-text.js';
+export { multipleSelectFilter } from './filter/filter-column/multiple-select.js';
+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 { 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 { 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 { 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 { 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

@@ -0,0 +1,78 @@
+import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
+
+/**
+ * get link by id
+ * @param {array} links [{ _id, ... }]
+ * @param {string} linkId
+ * @returns object
+ */
+var getLinkById = function getLinkById(links, linkId) {
+  if (!Array.isArray(links) || !linkId) return null;
+  return links.find(function (link) {
+    return link._id === linkId;
+  });
+};
+
+/**
+ * check is valid link by link column's data
+ * @param {object} columnData 
+ * @returns boolean
+ */
+var isValidLink = function isValidLink(linkColumnData) {
+  if (!linkColumnData) return false;
+  var link_id = linkColumnData.link_id,
+    table_id = linkColumnData.table_id,
+    other_table_id = linkColumnData.other_table_id,
+    display_column_key = linkColumnData.display_column_key;
+  return !!(link_id && table_id && other_table_id && display_column_key);
+};
+
+/**
+ * get current table's id
+ * @param {string} currentTableID
+ * @param {string} tableID
+ * @param {string} otherTableID
+ * @returns string
+ */
+var getLinkTableID = function getLinkTableID(currentTableID, tableID, otherTableID) {
+  return currentTableID === tableID ? tableID : otherTableID;
+};
+
+/**
+ * get linked table's id
+ * @param {string} currentTableID
+ * @param {string} tableID
+ * @param {string} otherTableID
+ * @returns 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
+ * @param {string} table1Id
+ * @param {string} table2Id
+ * @param {string} rowId
+ * @returns array, linked rows ids
+ */
+var getLinkCellValue = function getLinkCellValue(links, linkId, table1Id, table2Id, rowId) {
+  if (!Array.isArray(links) || links.length === 0 || !table1Id || !table2Id || !rowId) return [];
+  var linkBetween2Tables = getLinkById(links, linkId);
+  if (!linkBetween2Tables) return [];
+  var linkMap = {};
+  if (table1Id === table2Id) {
+    linkMap = linkBetween2Tables.table2_table1_map;
+  } else {
+    linkMap = linkBetween2Tables.table1_id === table1Id ? linkBetween2Tables.table1_table2_map : linkBetween2Tables.table2_table1_map;
+  }
+  var linkedRowIds = linkMap[rowId];
+  if (!linkedRowIds) {
+    return [];
+  }
+  return _toConsumableArray(linkedRowIds);
+};
+
+export { getLinkById, getLinkCellValue, getLinkTableID, getLinkedTableID, isValidLink };

package/es/number.js

@@ -0,0 +1,13 @@
+/**
+ * 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;
+};
+
+export { isNumber, isNumberEqual };

package/es/row/color.js

@@ -0,0 +1,278 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { getTableColumnByKey } from '../table/column.js';
+import { getRowsByIds } from '../table/row.js';
+import { isTableRows } from './core.js';
+import { getColumnOptions } from '../column/option.js';
+import { getGeolocationDisplayString } from '../cell-value-get/geolocation.js';
+import { ValidateFilter } from '../validate/filter.js';
+import { deleteInvalidFilter, getFormattedFilters } from '../filter/core.js';
+import { filterRow } from '../filter/filter-row.js';
+import { ROW_COLOR_TYPE, ROW_COLOR_FOR_DUPLICATE_VALUES, SUPPORT_CHECKING_DUPLICATE_COLUMNS_TYPES } from '../constants/row-color.js';
+import { CellType } from '../constants/cell-type.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; }
+var isValidRowColorRule = function isValidRowColorRule(rule, columns) {
+  var filters = rule.filters;
+  if (!filters || filters.length === 0) return false;
+  return filters.some(function (filter) {
+    return !ValidateFilter.validate(filter, columns).error_message;
+  });
+};
+var getValidRowColorRules = function getValidRowColorRules(colorRules, columns) {
+  return colorRules.filter(function (colorRule) {
+    return isValidRowColorRule(colorRule, columns);
+  });
+};
+var getOptionIdMap = function getOptionIdMap(options) {
+  if (!Array.isArray(options) || options.length === 0) return {};
+  var optionsMap = {};
+  options.forEach(function (option) {
+    optionsMap[option.id] = true;
+  });
+  return optionsMap;
+};
+var getFormattedDuplicateColumns = function getFormattedDuplicateColumns(columns, duplicateColumnKeys, _ref) {
+  var collaborators = _ref.collaborators;
+  var formattedColumns = [];
+  var _loop = function _loop() {
+    var key = duplicateColumnKeys[i];
+    var currColumn = columns.find(function (column) {
+      return column.key === key;
+    });
+    if (!currColumn) return "continue";
+    var type = currColumn.type,
+      data = currColumn.data;
+    var formattedColumnData = data;
+    if (!SUPPORT_CHECKING_DUPLICATE_COLUMNS_TYPES.includes(type)) return "continue";
+    if (type === CellType.SINGLE_SELECT || type === CellType.MULTIPLE_SELECT) {
+      var options = getColumnOptions(currColumn);
+      formattedColumnData = getOptionIdMap(options);
+    } else if (type === CellType.COLLABORATOR) {
+      var optionsMap = {};
+      if (Array.isArray(collaborators)) {
+        collaborators.forEach(function (collaborator) {
+          optionsMap[collaborator.email] = true;
+        });
+      }
+      formattedColumnData = optionsMap;
+    }
+    formattedColumns.push({
+      key: key,
+      type: type,
+      data: formattedColumnData
+    });
+  };
+  for (var i = 0; i < duplicateColumnKeys.length; i++) {
+    var _ret = _loop();
+    if (_ret === "continue") continue;
+  }
+  return formattedColumns;
+};
+var getDuplicateRowValue = function getDuplicateRowValue(row, columns, formulaRow) {
+  if (!row) return '';
+  var rowValue = columns.map(function (column) {
+    var type = column.type,
+      data = column.data,
+      key = column.key;
+    var cellValue = row[key];
+    switch (type) {
+      case CellType.SINGLE_SELECT:
+        {
+          return data[cellValue] ? cellValue : '';
+        }
+      case CellType.MULTIPLE_SELECT:
+      case CellType.COLLABORATOR:
+        {
+          if (!Array.isArray(cellValue) || cellValue.length === 0) return '';
+          return cellValue.filter(function (item) {
+            return data[item];
+          }).sort().join('');
+        }
+      case CellType.GEOLOCATION:
+        {
+          if (!cellValue) return '';
+          return getGeolocationDisplayString(cellValue, data) || '';
+        }
+      case CellType.NUMBER:
+        {
+          if (!cellValue && cellValue !== 0) return '';
+          return cellValue;
+        }
+      case CellType.FORMULA:
+        {
+          if (!formulaRow) return '';
+          cellValue = formulaRow[key];
+          return cellValue;
+        }
+      default:
+        {
+          return cellValue || '';
+        }
+    }
+  }).join('_seatable_join_key_');
+  if (!rowValue) return '';
+  if (typeof ''.replaceAll !== 'function') {
+    // eslint-disable-next-line
+    String.prototype.replaceAll = function (s1, s2) {
+      return this.replace(new RegExp(s1, 'gm'), s2);
+    };
+  }
+  if (!rowValue.replaceAll('_seatable_join_key_', '')) return '';
+  return rowValue;
+};
+var getRowsColorBySingleSelectColumn = function getRowsColorBySingleSelectColumn(rows, columnKey, table) {
+  var colors = {};
+  var column = getTableColumnByKey(table, columnKey);
+  var options = getColumnOptions(column);
+  if (!Array.isArray(options) || options.length === 0) return {};
+  var option_id_color_map = {};
+  options.forEach(function (option) {
+    option_id_color_map[option.id] = option.color;
+  });
+  rows.forEach(function (row) {
+    var optionId = row[columnKey];
+    var color = optionId ? option_id_color_map[optionId] : '';
+    if (color) {
+      colors[row._id] = color;
+    }
+  });
+  return colors;
+};
+var getRowsColorByRules = function getRowsColorByRules(rows, view, table) {
+  var _ref2 = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {},
+    username = _ref2.username,
+    userId = _ref2.userId;
+  var formula_rows = view.formula_rows,
+    colorbys = view.colorbys;
+  var _ref3 = colorbys || {},
+    type = _ref3.type,
+    color_by_rules = _ref3.color_by_rules;
+  if (type !== ROW_COLOR_TYPE.BY_RULES) return {};
+  var columns = table.columns;
+  var validColorRules = getValidRowColorRules(color_by_rules, columns);
+  var colorRulesLen = validColorRules.length;
+  var colors = {};
+  if (colorRulesLen === 0) return {};
+  validColorRules = validColorRules.map(function (colorRule) {
+    var filters = colorRule.filters;
+    var validFilters;
+    try {
+      validFilters = deleteInvalidFilter(filters, columns);
+    } catch (err) {
+      validFilters = [];
+    }
+    validFilters = getFormattedFilters(validFilters);
+    return _objectSpread(_objectSpread({}, colorRule), {}, {
+      filters: validFilters
+    });
+  });
+  rows.forEach(function (row) {
+    var rowId = row._id;
+    var formulaRow = formula_rows && formula_rows[rowId] || {};
+    for (var i = 0; i < colorRulesLen; i++) {
+      var colorRule = validColorRules[i];
+      var color = colorRule.color,
+        filter_conjunction = colorRule.filter_conjunction,
+        filters = colorRule.filters;
+      if (filterRow(row, filter_conjunction, filters, {
+        formulaRow: formulaRow,
+        username: username,
+        userId: userId
+      })) {
+        colors[rowId] = color;
+        break;
+      }
+    }
+  });
+  return colors;
+};
+var getRowsColorByDuplicateValues = function getRowsColorByDuplicateValues(rows, view, table, _ref4) {
+  var collaborators = _ref4.collaborators;
+  var colorbys = view.colorbys,
+    formula_rows = view.formula_rows;
+  var color_by_duplicate_column_keys = colorbys.color_by_duplicate_column_keys;
+  if (!Array.isArray(color_by_duplicate_column_keys) || color_by_duplicate_column_keys.length === 0) return {};
+  var columns = table.columns;
+  var formattedColumns = getFormattedDuplicateColumns(columns, color_by_duplicate_column_keys, {
+    collaborators: collaborators
+  });
+  if (formattedColumns.length === 0) return {};
+  var colors = {};
+  var duplicate_rows_ids_map = {}; // row value: [ row_id ]
+  for (var i = 0; i < rows.length; i++) {
+    var row = rows[i];
+    var rowId = row._id;
+    var formulaRow = formula_rows && formula_rows[rowId];
+    var rowValue = getDuplicateRowValue(row, formattedColumns, formulaRow);
+    if (!rowValue) continue;
+    var validRowIds = duplicate_rows_ids_map[rowValue];
+    if (validRowIds && validRowIds.length > 0) {
+      colors[rowId] = ROW_COLOR_FOR_DUPLICATE_VALUES;
+      validRowIds.push(rowId);
+      var firstDuplicateRowId = validRowIds[0];
+      if (!colors[firstDuplicateRowId]) {
+        colors[firstDuplicateRowId] = ROW_COLOR_FOR_DUPLICATE_VALUES;
+      }
+    } else {
+      duplicate_rows_ids_map[rowValue] = [rowId];
+    }
+  }
+  return {
+    colors: colors,
+    duplicate_rows_ids_map: duplicate_rows_ids_map
+  };
+};
+var getRowsColor = function getRowsColor(rows, view, table, value) {
+  var _ref5 = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {},
+    username = _ref5.username,
+    userId = _ref5.userId;
+  var colorbys = view.colorbys;
+  if (!colorbys) return {};
+  var tableRows = isTableRows(rows) ? rows : getRowsByIds(table, rows);
+  if (tableRows.length === 0) return {};
+  var type = colorbys.type,
+    color_by_column = colorbys.color_by_column;
+  switch (type) {
+    case ROW_COLOR_TYPE.BY_COLUMN:
+      {
+        return {
+          colors: getRowsColorBySingleSelectColumn(tableRows, color_by_column, table)
+        };
+      }
+    case ROW_COLOR_TYPE.BY_RULES:
+      {
+        return {
+          colors: getRowsColorByRules(tableRows, view, table, {
+            username: username,
+            userId: userId
+          })
+        };
+      }
+    case ROW_COLOR_TYPE.BY_DUPLICATE_VALUES:
+      {
+        var _ref6 = value || {},
+          _ref6$collaborators = _ref6.collaborators,
+          collaborators = _ref6$collaborators === void 0 ? [] : _ref6$collaborators;
+        return getRowsColorByDuplicateValues(tableRows, view, table, {
+          collaborators: collaborators
+        });
+      }
+    default:
+      {
+        return {};
+      }
+  }
+};
+var RowColorUtils = {
+  isValidRowColorRule: isValidRowColorRule,
+  getValidRowColorRules: getValidRowColorRules,
+  getRowsColor: getRowsColor,
+  getFormattedDuplicateColumns: getFormattedDuplicateColumns,
+  getDuplicateRowValue: getDuplicateRowValue,
+  getRowsColorBySingleSelectColumn: getRowsColorBySingleSelectColumn,
+  getRowsColorByRules: getRowsColorByRules,
+  getRowsColorByDuplicateValues: getRowsColorByDuplicateValues
+};
+
+export { RowColorUtils as default };

package/es/row/core.js

@@ -0,0 +1,161 @@
+import _typeof from '@babel/runtime/helpers/typeof';
+import { getFormulaDisplayString } from '../cell-value-get/cell-value.js';
+import 'dayjs';
+import '../constants/column.js';
+import { getColumnOptionNameById } from '../cell-value-get/option.js';
+import '../constants/group.js';
+import { getLinkCellValue } from '../link/core.js';
+import { isEmpty } from '../common.js';
+import { CellType } from '../constants/cell-type.js';
+import { CONVERT_ROW_COLUMNS_LIMIT } from '../constants/limit.js';
+
+var isTableRows = function isTableRows(rows) {
+  return Array.isArray(rows) && _typeof(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 > CONVERT_ROW_COLUMNS_LIMIT) {
+    columns = columns.slice(0, 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 = row[key];
+    switch (type) {
+      case CellType.SINGLE_SELECT:
+        {
+          if (!column.data) {
+            if (debug) {
+              debug('No options found');
+            }
+            break;
+          }
+          result[columnName] = getColumnOptionNameById(column, cellValue);
+          break;
+        }
+      case CellType.MULTIPLE_SELECT:
+        {
+          if (!column.data) {
+            if (debug) {
+              debug('No options found');
+            }
+            break;
+          }
+          if (!Array.isArray(cellValue)) {
+            result[columnName] = '';
+            break;
+          }
+          var optionNames = [];
+          for (var optionIndex = 0; optionIndex < cellValue.length; optionIndex++) {
+            var optionName = getColumnOptionNameById(column, cellValue[optionIndex]);
+            if (optionName) {
+              optionNames.push(optionName);
+            }
+          }
+          result[columnName] = optionNames;
+          break;
+        }
+      case CellType.LONG_TEXT:
+        {
+          result[columnName] = cellValue ? cellValue.text : '';
+          break;
+        }
+      case 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] = getLinkCellValue(links, link_id, tableID, otherTableID, row._id);
+          break;
+        }
+      case CellType.FORMULA:
+      case CellType.LINK_FORMULA:
+        {
+          if (!column.data || !formulaResults) {
+            if (debug) {
+              debug('No formula found');
+            }
+            break;
+          }
+          var _formulaRow = formulaResults[row._id] || {};
+          result[columnName] = 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;
+        }
+    }
+    if (isEmpty(result[columnName])) {
+      delete result[columnName];
+    }
+  }
+  return result;
+};
+
+export { convertRow, isTableRows };

package/es/sort/core.js

@@ -0,0 +1,32 @@
+import { SORT_COLUMN_OPTIONS } from '../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, columns) {
+  var sortByColumn = sort && columns.find(function (column) {
+    return column.key === sort.column_key;
+  });
+  if (!sortByColumn) return false;
+  return 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);
+  });
+};
+
+export { getValidSorts, isValidSort };