dtable-utils 0.0.3 → 4.2.0

package/es/group/group-row.js

@@ -0,0 +1,402 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
+import { isTableRows } from '../row/core.js';
+import { getRowsByIds } from '../table/row.js';
+import { deleteInvalidGroupby } from './core.js';
+import { DateUtils } from '../date.js';
+import { isDateColumn } from '../column/date.js';
+import { getCollaboratorsNames } from '../cell-value-get/collaborator.js';
+import { getGeolocationByGranularity } from '../cell-value-get/geolocation.js';
+import { getFormulaDisplayString } from '../cell-value-get/cell-value.js';
+import { sortCheckbox } from '../sort/sort-column/checkbox.js';
+import { sortCollaborator } from '../sort/sort-column/collaborator.js';
+import { sortDate } from '../sort/sort-column/date.js';
+import { sortNumber } from '../sort/sort-column/number.js';
+import { sortText } from '../sort/sort-column/text.js';
+import { CellType } from '../constants/cell-type.js';
+import { SINGLE_CELL_VALUE_COLUMN_TYPE_MAP, MULTIPLE_CELL_VALUE_COLUMN_TYPE_MAP, DATE_COLUMN_OPTIONS } from '../constants/column.js';
+import { FORMULA_COLUMN_TYPES_MAP, FORMULA_RESULT_TYPE } from '../constants/formula.js';
+import { sortFormula } from '../sort/sort-column/formula.js';
+import { sortLink } from '../sort/sort-column/link.js';
+import { sortMultipleSelect } from '../sort/sort-column/multiple-select.js';
+import { sortSingleSelect } from '../sort/sort-column/single-select.js';
+import { MAX_GROUP_LEVEL } from '../constants/group.js';
+import { SORT_TYPE, SORT_COLUMN_OPTIONS, TEXT_SORTER_COLUMN_TYPES, NUMBER_SORTER_COLUMN_TYPES } 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; }
+var _getCellValue = function _getCellValue(row, formulaRows, groupby) {
+  var column_key = groupby.column_key,
+    column = groupby.column;
+  var cellValue = row[column_key];
+  var type = column.type;
+  if (FORMULA_COLUMN_TYPES_MAP[type]) {
+    var formulaRow = formulaRows[row._id] || {};
+    return formulaRow[column_key];
+  }
+  // link column value is calculate as a special formula column
+  if (type === CellType.LINK) {
+    var _formulaRow = formulaRows[row._id] || {};
+    return _formulaRow[column_key] || [];
+  }
+  return cellValue;
+};
+var _getFormattedCellValue = function _getFormattedCellValue(cellValue, groupby) {
+  var column = groupby.column,
+    countType = groupby.count_type;
+  var columnType = column.type,
+    columnData = column.data;
+  switch (columnType) {
+    case CellType.TEXT:
+    case CellType.URL:
+    case CellType.EMAIL:
+    case CellType.LAST_MODIFIER:
+    case CellType.CREATOR:
+      {
+        return cellValue || null;
+      }
+    case CellType.DATE:
+    case CellType.CTIME:
+    case CellType.MTIME:
+      {
+        return DateUtils.getDateByGranularity(cellValue, countType) || null;
+      }
+    case CellType.NUMBER:
+    case CellType.DURATION:
+    case CellType.RATE:
+      {
+        return cellValue || cellValue === 0 ? cellValue : null;
+      }
+    case CellType.CHECKBOX:
+      {
+        return !!cellValue;
+      }
+    case CellType.SINGLE_SELECT:
+      {
+        return cellValue || null;
+      }
+    case CellType.MULTIPLE_SELECT:
+      {
+        return Array.isArray(cellValue) ? cellValue : [];
+      }
+    case CellType.COLLABORATOR:
+      {
+        if (!Array.isArray(cellValue)) {
+          return [];
+        }
+        var collaborator_email_map = groupby.collaborator_email_map;
+        return cellValue.filter(function (email) {
+          return collaborator_email_map[email];
+        });
+      }
+    case CellType.GEOLOCATION:
+      {
+        return getGeolocationByGranularity(cellValue, countType);
+      }
+    case CellType.FORMULA:
+    case CellType.LINK_FORMULA:
+      {
+        var _ref = columnData || {},
+          result_type = _ref.result_type;
+        if (result_type === FORMULA_RESULT_TYPE.NUMBER) {
+          return cellValue || cellValue === 0 ? cellValue : null;
+        }
+        if (result_type === FORMULA_RESULT_TYPE.DATE) {
+          return DateUtils.getDateByGranularity(cellValue, countType) || null;
+        }
+        if (result_type === FORMULA_RESULT_TYPE.BOOL) {
+          return !!cellValue;
+        }
+        if (result_type === FORMULA_RESULT_TYPE.ARRAY) {
+          var newCellValue = cellValue;
+          if (isDateColumn(column) && Array.isArray(cellValue) && cellValue.length > 0) {
+            return DateUtils.getDateByGranularity(cellValue[0], countType) || null;
+          }
+
+          // convert to string
+          return getFormulaDisplayString(newCellValue, columnData) || null;
+        }
+        return cellValue || null;
+      }
+    case CellType.LINK:
+      {
+        if (!Array.isArray(cellValue) || cellValue.length === 0) {
+          return [];
+        }
+        return cellValue.map(function (linked) {
+          return linked.display_value;
+        });
+      }
+    default:
+      {
+        return null;
+      }
+  }
+};
+var _getStrCellValue = function _getStrCellValue(cellValue, columnType) {
+  var sCellValue = null;
+  if (SINGLE_CELL_VALUE_COLUMN_TYPE_MAP[columnType]) {
+    sCellValue = typeof cellValue === 'string' ? cellValue : String(cellValue);
+  } else if (MULTIPLE_CELL_VALUE_COLUMN_TYPE_MAP[columnType]) {
+    sCellValue = _toConsumableArray(cellValue).sort().toString();
+  }
+  return sCellValue;
+};
+var _findGroupIndexWithMultipleGroupbys = function _findGroupIndexWithMultipleGroupbys(sCellValue, cellValue2GroupIndexMap, groupsLength) {
+  var target = cellValue2GroupIndexMap[sCellValue];
+  if (target && target.index > -1) {
+    return target.index;
+  }
+
+  // eslint-disable-next-line
+  cellValue2GroupIndexMap[sCellValue] = {};
+
+  // eslint-disable-next-line
+  cellValue2GroupIndexMap[sCellValue].subgroups = {};
+
+  // eslint-disable-next-line
+  cellValue2GroupIndexMap[sCellValue].index = groupsLength;
+  return -1;
+};
+var _findGroupIndex = function _findGroupIndex(sCellValue, cellValue2GroupIndexMap, groupsLength) {
+  var index = cellValue2GroupIndexMap[sCellValue];
+  if (index > -1) {
+    return index;
+  }
+
+  // eslint-disable-next-line
+  cellValue2GroupIndexMap[sCellValue] = groupsLength;
+  return -1;
+};
+var getSortedGroups = function getSortedGroups(groups, groupbys, value, level) {
+  var _groupbys$level = groupbys[level],
+    column = _groupbys$level.column,
+    sort_type = _groupbys$level.sort_type;
+  var collaborators = value.collaborators;
+  var columnType = column.type,
+    columnData = column.data;
+  var normalizedSortType = sort_type || SORT_TYPE.UP;
+  var option_id_index_map = {};
+  if (columnType === CellType.SINGLE_SELECT || columnType === CellType.MULTIPLE_SELECT) {
+    var _ref2 = columnData || {},
+      options = _ref2.options;
+    if (Array.isArray(options)) {
+      options.forEach(function (option, index) {
+        option_id_index_map[option.id] = index;
+      });
+    }
+  }
+  groups.sort(function (currGroupRow, nextGroupRow) {
+    var currCellVal = currGroupRow.cell_value;
+    var nextCellVal = nextGroupRow.cell_value;
+    if (SORT_COLUMN_OPTIONS.includes(columnType)) {
+      var sortResult;
+      if (TEXT_SORTER_COLUMN_TYPES.includes(columnType)) {
+        sortResult = sortText(currCellVal, nextCellVal, normalizedSortType);
+      } else if (NUMBER_SORTER_COLUMN_TYPES.includes(columnType)) {
+        sortResult = sortNumber(currCellVal, nextCellVal, normalizedSortType);
+      } else if (DATE_COLUMN_OPTIONS.includes(columnType)) {
+        sortResult = sortDate(currCellVal, nextCellVal, normalizedSortType);
+      } else if (columnType === CellType.CHECKBOX) {
+        sortResult = sortCheckbox(currCellVal, nextCellVal, normalizedSortType);
+      } else if (columnType === CellType.COLLABORATOR) {
+        var currCollaborators = currCellVal;
+        var nextCollaborators = nextCellVal;
+        if (collaborators) {
+          currCollaborators = getCollaboratorsNames(currCollaborators, collaborators);
+          nextCollaborators = getCollaboratorsNames(nextCollaborators, collaborators);
+        }
+        sortResult = sortCollaborator(currCollaborators, nextCollaborators, normalizedSortType);
+      } else if (columnType === CellType.SINGLE_SELECT) {
+        sortResult = sortSingleSelect(currCellVal, nextCellVal, {
+          sort_type: normalizedSortType,
+          option_id_index_map: option_id_index_map
+        });
+      } else if (columnType === CellType.MULTIPLE_SELECT) {
+        sortResult = sortMultipleSelect(currCellVal, nextCellVal, {
+          sort_type: normalizedSortType,
+          option_id_index_map: option_id_index_map
+        });
+      } else if (FORMULA_COLUMN_TYPES_MAP[columnType]) {
+        var currOriginalCellVal = currGroupRow.original_cell_value;
+        var nextOriginalCellVal = nextGroupRow.original_cell_value;
+        sortResult = sortFormula(currOriginalCellVal, nextOriginalCellVal, normalizedSortType, {
+          columnData: columnData,
+          value: value
+        });
+      } else if (columnType === CellType.LINK) {
+        var _currOriginalCellVal = currGroupRow.original_cell_value;
+        var _nextOriginalCellVal = nextGroupRow.original_cell_value;
+        sortResult = sortLink(_currOriginalCellVal, _nextOriginalCellVal, normalizedSortType, {
+          columnData: columnData,
+          value: value
+        });
+      }
+      return sortResult;
+    }
+    if (currCellVal === '') return 1;
+    if (nextCellVal === '') return -1;
+    return 0;
+  });
+
+  // for nested group.
+  var isNestedGroup = Array.isArray(groups[0].subgroups) && groups[0].subgroups.length > 0;
+  if (isNestedGroup) {
+    var nextLevel = level + 1;
+
+    // eslint-disable-next-line
+    groups = groups.map(function (group) {
+      var sortedSubgroups = getSortedGroups(group.subgroups, groupbys, value, nextLevel);
+      return _objectSpread(_objectSpread({}, group), {}, {
+        subgroups: sortedSubgroups
+      });
+    });
+  }
+  return groups;
+};
+var groupRowsWithMultipleGroupbys = function groupRowsWithMultipleGroupbys(groupbys, rows, formulaRows, value) {
+  var validGroupbys = groupbys.length > MAX_GROUP_LEVEL ? groupbys.slice(0, MAX_GROUP_LEVEL) : _toConsumableArray(groupbys);
+  var groups = [];
+  var cellValue2GroupIndexMap = {};
+  rows.forEach(function (row) {
+    var rowId = row._id;
+    var updatedGroup;
+    var updateCellValue2GroupIndexMap;
+    for (var level = 0; level < validGroupbys.length; level++) {
+      var currentGroupby = validGroupbys[level];
+      var column = currentGroupby.column,
+        column_key = currentGroupby.column_key;
+      var columnType = column.type;
+      var cellValue = _getCellValue(row, formulaRows, currentGroupby);
+      var formattedValue = _getFormattedCellValue(cellValue, currentGroupby);
+      var sCellValue = _getStrCellValue(formattedValue, columnType);
+      var group = {
+        cell_value: formattedValue,
+        original_cell_value: cellValue,
+        row_ids: null,
+        column_key: column_key,
+        subgroups: [],
+        summaries: {}
+      };
+      if (level === 0) {
+        var groupedRowIndex = _findGroupIndexWithMultipleGroupbys(sCellValue, cellValue2GroupIndexMap, groups.length);
+        updateCellValue2GroupIndexMap = cellValue2GroupIndexMap[sCellValue].subgroups;
+        if (groupedRowIndex < 0) {
+          groups.push(group);
+          updatedGroup = groups[groups.length - 1];
+        } else {
+          updatedGroup = groups[groupedRowIndex];
+        }
+      } else {
+        var _groupedRowIndex = _findGroupIndexWithMultipleGroupbys(sCellValue, updateCellValue2GroupIndexMap, updatedGroup.subgroups.length);
+        updateCellValue2GroupIndexMap = updateCellValue2GroupIndexMap[sCellValue].subgroups;
+        if (_groupedRowIndex < 0) {
+          updatedGroup.subgroups.push(group);
+          updatedGroup = updatedGroup.subgroups[updatedGroup.subgroups.length - 1];
+        } else {
+          updatedGroup = updatedGroup.subgroups[_groupedRowIndex];
+        }
+
+        // update row_ids in the deepest group.
+        if (level === validGroupbys.length - 1) {
+          if (!updatedGroup.row_ids) {
+            updatedGroup.row_ids = [rowId];
+          } else {
+            updatedGroup.row_ids.push(rowId);
+          }
+        }
+      }
+    }
+  });
+  groups = getSortedGroups(groups, validGroupbys, value, 0);
+  return groups;
+};
+
+/**
+ * Group table rows
+ * @param {array} groupbys e.g. [{ column_key, count_type, column, ... }, ...]
+ * @param {array} rows e.g. [{ _id, ... }, ...]
+ * @param {object} formulaRows computed value of formula, link-formula, link etc.
+ * @param {object} value e.g. { collaborators, ... }
+ * @returns groups: [{
+ *    cell_value, original_cell_value, column_key,
+      row_ids, subgroups, summaries, ...}, ...], array
+ */
+var groupTableRows = function groupTableRows(groupbys, rows, formulaRows, value) {
+  if (groupbys.length === 0) {
+    return [];
+  }
+  if (groupbys.length > 1) {
+    return groupRowsWithMultipleGroupbys(groupbys, rows, formulaRows, value);
+  }
+  var groupby = groupbys[0];
+  var column_key = groupby.column_key,
+    column = groupby.column;
+  var columnType = column.type;
+  var groups = [];
+  var cellValue2GroupIndexMap = {};
+  rows.forEach(function (r) {
+    var cellValue = _getCellValue(r, formulaRows, groupby);
+    var formattedValue = _getFormattedCellValue(cellValue, groupby);
+    var sCellValue = _getStrCellValue(formattedValue, columnType);
+    var groupedRowIndex = _findGroupIndex(sCellValue, cellValue2GroupIndexMap, groups.length);
+    if (groupedRowIndex > -1) {
+      groups[groupedRowIndex].row_ids.push(r._id);
+    } else {
+      groups.push({
+        cell_value: formattedValue,
+        original_cell_value: cellValue,
+        column_key: column_key,
+        row_ids: [r._id],
+        subgroups: null,
+        summaries: {}
+      });
+    }
+  });
+
+  // sort groups
+  groups = getSortedGroups(groups, groupbys, value, 0);
+  return groups;
+};
+
+/**
+ * Group view rows
+ * @param {array} groupbys e.g. [{ column_key, count_type, column, ... }, ...]
+ * @param {object} table e.g. { id_row_map, ... }
+ * @param {array} rowsIds e.g. [ row._id, ...]
+ * @param {object} formulaRows computed value of formula, link-formula, link etc.
+ * @param {object} value e.g. { collaborators, ... }
+ * @returns groups: [{
+ *    cell_value, original_cell_value, column_key,
+      row_ids, subgroups, summaries, ...}, ...], array
+ */
+var groupViewRows = function groupViewRows(groupbys, table, rowsIds, formulaRows, value) {
+  if (rowsIds.length === 0) {
+    return [];
+  }
+  var rowsData = getRowsByIds(table, rowsIds);
+  return groupTableRows(groupbys, rowsData, formulaRows, value);
+};
+
+/**
+ * Group rows
+ * The "formulaRows" must be supplied if you want group rows by formula/link-formula/link columns
+ * @param {array} groupbys e.g. [{ column_key, count_type, ... }, ...]
+ * @param {array} rows e.g. table rows: [{ _id, ... }, ...] | view rows: [ row._id, ...]
+ * @param {object} table e.g. { id_row_map, columns, ... }
+ * @param {object} value e.g. { collaborators, ... }
+ * @param {object} formulaRows computed value of formula, link-formula, link etc.
+ * @returns groups: [{
+ *    cell_value, original_cell_value, column_key,
+      row_ids, subgroups, summaries, ...}, ...], array
+ */
+var getGroupedRowsWithoutFormulaCalculation = function getGroupedRowsWithoutFormulaCalculation(groupbys, rows, table, value) {
+  var _ref3 = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {},
+    _ref3$formulaRows = _ref3.formulaRows,
+    formulaRows = _ref3$formulaRows === void 0 ? null : _ref3$formulaRows;
+  var columns = table.columns;
+  var validGroupbys = deleteInvalidGroupby(groupbys, columns, table, value);
+  return isTableRows(rows) ? groupTableRows(validGroupbys, rows, formulaRows, value) : groupViewRows(validGroupbys, table, rows, formulaRows, value);
+};
+
+export { getGroupedRowsWithoutFormulaCalculation, groupTableRows, groupViewRows };

package/es/index.js

@@ -1,25 +1,77 @@
 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 { FORMULA_COLUMN_TYPES_MAP, FORMULA_RESULT_TYPE } from './constants/formula.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 { 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 { generatorBase64Code, isEmptyObject, isNumber } 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, 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 { 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 { 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 { 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 { 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 { 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';

package/es/link/core.js

@@ -0,0 +1,78 @@
+import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
+
+/**
+ * Get link by id
+ * @param {array} links e.g. [{ _id, ... }, ...]
+ * @param {string} linkId
+ * @returns link, 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
+ * @param {object} columnData
+ * @returns bool
+ */
+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 id by link relationship
+ * @param {string} currentTableID
+ * @param {string} tableID
+ * @param {string} otherTableID
+ * @returns current table id, string
+ */
+var getLinkTableID = function getLinkTableID(currentTableID, tableID, otherTableID) {
+  return currentTableID === tableID ? tableID : otherTableID;
+};
+
+/**
+ * Get linked table id by link relationship
+ * @param {string} currentTableID
+ * @param {string} tableID
+ * @param {string} otherTableID
+ * @returns linked table id, string
+ */
+var getLinkedTableID = function getLinkedTableID(currentTableID, tableID, otherTableID) {
+  return currentTableID === tableID ? otherTableID : tableID;
+};
+
+/**
+ * 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 linked rows ids, array
+ */
+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,21 @@
+/**
+ * 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]';
+};
+
+/**
+ * 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 };