dtable-utils 0.0.1 → 0.0.3-beta.1

package/es/view/core.js

@@ -0,0 +1,135 @@
+import { getValidFilters, getValidFiltersWithoutError } from '../filter/core.js';
+import { getValidGroupbys } from '../group/core.js';
+import { getValidSorts } from '../sort/core.js';
+import { CellType } from '../constants/cell-type.js';
+
+/**
+ * get view by id
+ * @param {array} views { _id: '', ... }
+ * @param {string} viewId
+ * @returns object
+ */
+var getViewById = function getViewById(views, viewId) {
+  if (!Array.isArray(views) || !viewId) return null;
+  return views.find(function (view) {
+    return view._id === viewId;
+  });
+};
+
+/**
+ * check whether the view contains filters
+ * @param {object} view { filters: [], ... }
+ * @param {array} columns
+ * @returns boolean
+ */
+var isFilterView = function isFilterView(view, columns) {
+  var validFilters = getValidFilters(view.filters, columns);
+  return validFilters.length > 0;
+};
+
+/**
+ * check whether the view contains groupbys
+ * @param {object} view { groupbys: [], ... }
+ * @param {array} columns
+ * @returns boolean
+ */
+var isGroupView = function isGroupView(view, columns) {
+  var validGroupbys = getValidGroupbys(view.groupbys, columns);
+  return validGroupbys.length > 0;
+};
+
+/**
+ * check whether the view contains sorts
+ * @param {object} view { sorts: [], ... }
+ * @param {array} columns
+ * @returns boolean
+ */
+var isSortView = function isSortView(view, columns) {
+  var sorts = view.sorts;
+  var validSorts = getValidSorts(sorts, columns);
+  return validSorts.length > 0;
+};
+
+/**
+ * check is default view which no contains filters, sorts, groupbys etc.
+ * @param {object} view { sorts: [], ... }
+ * @param {array} columns
+ * @returns boolean
+ */
+var isDefaultView = function isDefaultView(view, columns) {
+  return !isFilterView(view, columns) && !isSortView(view, columns) && !isGroupView(view, columns);
+};
+
+/**
+ * get link columns which used either in filters, groupbys, sorts etc.
+ * @param {object} view { filters, groupbys, sorts, ... }
+ * @param {object} table
+ * @returns array, link columns
+ */
+var getLinkColumnsUsedInFilters = function getLinkColumnsUsedInFilters(view, table) {
+  var filters = view.filters,
+    sorts = view.sorts,
+    groupbys = view.groupbys;
+  var columns = table.columns;
+  if (!Array.isArray(columns)) return [];
+  var validFilters = getValidFiltersWithoutError(filters, columns);
+  var validSorts = getValidSorts(sorts, columns);
+  var validGroupbys = getValidGroupbys(groupbys, columns);
+  var hasFilters = validFilters && validFilters.length > 0;
+  var hasSorts = validSorts && validSorts.length > 0;
+  var hasGroupbys = validGroupbys && validGroupbys.length > 0;
+  if (!hasFilters && !hasSorts && !hasGroupbys) return [];
+  var keyLinkColumnMap = {};
+  var keyExistLinkColumnMap = {};
+  var linkColumns = [];
+  columns.forEach(function (column) {
+    var key = column.key,
+      name = column.name,
+      type = column.type,
+      data = column.data,
+      width = column.width;
+    if (type === CellType.LINK) {
+      keyLinkColumnMap[column.key] = {
+        key: key,
+        name: name,
+        type: type,
+        data: data,
+        width: width
+      };
+    }
+  });
+  if (Object.keys(keyLinkColumnMap).length === 0) return [];
+  if (hasFilters) {
+    validFilters.forEach(function (filter) {
+      var filterColumnKey = filter.column_key;
+      var filterLinkColumn = keyLinkColumnMap[filterColumnKey];
+      if (filterLinkColumn && !keyExistLinkColumnMap[filterColumnKey]) {
+        linkColumns.push(filterLinkColumn);
+        keyExistLinkColumnMap[filterColumnKey] = true;
+      }
+    });
+  }
+  if (hasSorts) {
+    validSorts.forEach(function (sort) {
+      var sortColumnKey = sort.column_key;
+      var sortLinkColumn = keyLinkColumnMap[sortColumnKey];
+      if (sortLinkColumn && !keyExistLinkColumnMap[sortColumnKey]) {
+        linkColumns.push(sortLinkColumn);
+        keyExistLinkColumnMap[sortColumnKey] = true;
+      }
+    });
+  }
+  if (hasGroupbys) {
+    validGroupbys.forEach(function (groupby) {
+      var groupbyColumnKey = groupby.column_key;
+      var groupbyLinkColumn = keyLinkColumnMap[groupbyColumnKey];
+      if (groupbyLinkColumn && !keyExistLinkColumnMap[groupbyColumnKey]) {
+        linkColumns.push(groupbyLinkColumn);
+        keyExistLinkColumnMap[groupbyColumnKey] = true;
+      }
+    });
+  }
+  return linkColumns;
+};
+
+export { getLinkColumnsUsedInFilters, getViewById, isDefaultView, isFilterView, isGroupView, isSortView };

package/es/view/formula.js

@@ -0,0 +1,143 @@
+import { CellType } from '../constants/cell-type.js';
+import { FORMULA_COLUMN_TYPES_MAP } from '../constants/formula.js';
+
+/**
+ * transform the formats of link column to link-formula's
+ * @param {object} linkColumn { key, data: { display_column_key, ... }, ... }
+ * @returns object
+ */
+var transLink2LinkFormula = function transLink2LinkFormula(linkColumn) {
+  var key = linkColumn.key,
+    name = linkColumn.name,
+    data = linkColumn.data;
+  var display_column_key = data.display_column_key;
+  return {
+    key: key,
+    name: name,
+    type: CellType.LINK_FORMULA,
+    data: {
+      formula: 'lookup',
+      link_column_key: key,
+      level1_linked_table_column_key: display_column_key,
+      level2_linked_table_column_key: null,
+      operated_columns: []
+    }
+  };
+};
+
+/**
+ * get sorted formula columns
+ * @param {array} formulaColumns
+ * @param {object} table
+ * @returns array
+ */
+var getSortedFormulaColumns = function getSortedFormulaColumns(formulaColumns, table) {
+  if (!Array.isArray(formulaColumns) || !table || !Array.isArray(table.columns)) return [];
+  var keyColumnMap = {};
+  table.columns.forEach(function (column) {
+    var key = column.key,
+      type = column.type;
+    if (FORMULA_COLUMN_TYPES_MAP[type]) {
+      keyColumnMap[key] = column;
+    } else if (type === CellType.LINK && column.data) {
+      keyColumnMap[key] = transLink2LinkFormula(column);
+    }
+  });
+
+  // get none-repeating formulas
+  var key_sorting_formula_column = {};
+  var sorting_formula_column_keys = [];
+  formulaColumns.forEach(function (column) {
+    var columnKey = column.key;
+    if (!key_sorting_formula_column[columnKey]) {
+      key_sorting_formula_column[columnKey] = column;
+      sorting_formula_column_keys.push(columnKey);
+    }
+  });
+
+  /**
+   * e.g. formula1 = formula2 + formula3
+   * e.g. formula2 = 1 + 2
+   * e.g. formula3 = formula2 + 3
+   * edges: formula2 --> formula1, formula2 --> formula3; formula3 --> formula1
+   * keyInDegreeMap, the total number of formula columns that depend on: { formula1_key: 2, formula2_key: 0, formula3_key: 1 }
+   * keyEdgesMap: { formula2_key: [formula1_key, formula3_key],  formula3_kye: [formula1_key]}
+   */
+  var keyInDegreeMap = {};
+  var keyEdgesMap = {};
+  sorting_formula_column_keys.forEach(function (formulaColumnKey) {
+    var formulaColumn = key_sorting_formula_column[formulaColumnKey];
+    var data = formulaColumn.data;
+    var operated_columns = data.operated_columns;
+    keyInDegreeMap[formulaColumnKey] = 0;
+    Array.isArray(operated_columns) && operated_columns.forEach(function (dependColumnKey) {
+      var dependColumn = keyColumnMap[dependColumnKey];
+      if (!dependColumn) {
+        return;
+      }
+      keyInDegreeMap[formulaColumnKey]++;
+      if (keyEdgesMap[dependColumnKey]) {
+        keyEdgesMap[dependColumnKey].push(formulaColumnKey);
+      } else {
+        keyEdgesMap[dependColumnKey] = [formulaColumnKey];
+      }
+    });
+  });
+  var sortedList = [];
+  var waitingQueue = [];
+  sorting_formula_column_keys.forEach(function (formulaColumnKey) {
+    if (keyInDegreeMap[formulaColumnKey] === 0) {
+      waitingQueue.push(formulaColumnKey);
+    }
+  });
+  while (waitingQueue.length) {
+    var columnKey = waitingQueue.shift();
+    var edges = keyEdgesMap[columnKey];
+    sortedList.push(columnKey);
+    Array.isArray(edges) && edges.forEach(function (edge) {
+      keyInDegreeMap[edge]--;
+      if (keyInDegreeMap[edge] === 0) {
+        waitingQueue.push(edge);
+      }
+    });
+  }
+  return sortedList.map(function (columnKey) {
+    return keyColumnMap[columnKey];
+  });
+};
+
+/**
+ * get formula columns and link columns from table
+ * @param {object} table { columns: [], ... }
+ * @returns array
+ */
+var getFormulaColumnsContainLinks = function getFormulaColumnsContainLinks(table) {
+  var columns = table.columns;
+  var formulaColumns = columns.filter(function (column) {
+    var type = column.type,
+      data = column.data;
+    if (type === CellType.LINK) {
+      return !!data;
+    }
+    return FORMULA_COLUMN_TYPES_MAP[type] && data;
+  });
+  return formulaColumns.map(function (column) {
+    if (column.type === CellType.LINK) {
+      return transLink2LinkFormula(column);
+    }
+    return column;
+  });
+};
+
+/**
+ * get sorted formula columns and link columns from table
+ * @param {object} table { columns: [], ... }
+ * @returns array
+ */
+var getSortedFormulaColumnsContainLinks = function getSortedFormulaColumnsContainLinks(table) {
+  var formulaColumns = getFormulaColumnsContainLinks(table);
+  if (formulaColumns.length === 0) return [];
+  return getSortedFormulaColumns(formulaColumns, table);
+};
+
+export { getFormulaColumnsContainLinks, getSortedFormulaColumns, getSortedFormulaColumnsContainLinks, transLink2LinkFormula };

package/es/view/group.js

@@ -0,0 +1,32 @@
+/**
+ * get group by paths.
+ * @param {array} paths e.g. [0, 1, 2]
+ * @param {array} groups
+ * @returns object
+ */
+var getGroupByPath = function getGroupByPath(paths, groups) {
+  if (!Array.isArray(paths) || !Array.isArray(groups)) {
+    return null;
+  }
+  var level0GroupIndex = paths[0];
+  if (level0GroupIndex < 0 || level0GroupIndex >= groups.length) {
+    return null;
+  }
+  var level = 1;
+  var foundGroup = groups[level0GroupIndex];
+  while (level < paths.length) {
+    if (!foundGroup) {
+      break;
+    }
+    var subGroups = foundGroup.subgroups;
+    var currentLevelGroupIndex = paths[level];
+    if (!Array.isArray(subGroups) || currentLevelGroupIndex < 0 || currentLevelGroupIndex >= subGroups.length) {
+      break;
+    }
+    foundGroup = subGroups[currentLevelGroupIndex];
+    level += 1;
+  }
+  return foundGroup;
+};
+
+export { getGroupByPath };

package/es/view/summaries.js

@@ -0,0 +1,179 @@
+import { getRowsByIds } from '../table/row.js';
+import { isTableRows } from '../row/core.js';
+import '@babel/runtime/helpers/defineProperty';
+import '../constants/group.js';
+import '../validate/filter.js';
+import '../filter/core.js';
+import '@babel/runtime/helpers/toConsumableArray';
+import '../constants/filter/filter-column-options.js';
+import '../constants/filter/filter-modifier.js';
+import '../constants/filter/filter-predicate.js';
+import '../constants/filter/filter-is-within.js';
+import '../date.js';
+import { isNumber } from '../number.js';
+import '../cell-value-get/cell-value.js';
+import { isNumericColumn } from '../column/number.js';
+import '../constants/column.js';
+import { FORMULA_COLUMN_TYPES_MAP } from '../constants/formula.js';
+import '../constants/row-color.js';
+
+/**
+ * calculate summaries of numeric columns from table
+ * @param {object} table
+ * @param {array} rows table's rows or rows ids
+ * @param {object} formulaRows support numeric formula columns
+ * @returns object, { [column.key]: { sum, average, median, max, min, ... }, ... }
+ */
+var getSummaries = function getSummaries(table, rows, formulaRows) {
+  var numericColumns = table.columns.filter(function (column) {
+    return isNumericColumn(column);
+  });
+  if (numericColumns.length === 0) {
+    return {};
+  }
+  var summaryRows = isTableRows(rows) ? rows : getRowsByIds(table, rows);
+  var summaries = {};
+  numericColumns.forEach(function (column) {
+    var type = column.type,
+      key = column.key;
+    var validNumbersCount = 0;
+    var medianArr = [];
+    var sum = 0;
+    var min;
+    var max;
+    var median;
+    summaryRows.forEach(function (row) {
+      var cellValue = row[key];
+      if (FORMULA_COLUMN_TYPES_MAP[type]) {
+        var formulaRow = formulaRows && formulaRows[row._id];
+        cellValue = formulaRow && formulaRow[key];
+        if (Array.isArray(cellValue) && cellValue.length === 1) {
+          cellValue = cellValue[0];
+        }
+      }
+      if (isNumber(cellValue)) {
+        medianArr.push(cellValue);
+        validNumbersCount += 1;
+        sum += cellValue;
+        if (min === undefined) {
+          min = cellValue;
+        } else {
+          min = cellValue < min ? cellValue : min;
+        }
+        if (max === undefined) {
+          max = cellValue;
+        } else {
+          max = cellValue > max ? cellValue : max;
+        }
+      }
+    });
+    if (validNumbersCount > 0) {
+      medianArr.sort();
+      if (medianArr.length % 2 === 0) {
+        median = (medianArr[medianArr.length / 2 - 1] + medianArr[medianArr.length / 2]) / 2;
+      } else {
+        median = medianArr[parseInt(medianArr.length / 2)];
+      }
+    }
+    var average = validNumbersCount === 0 ? 0 : sum / validNumbersCount;
+    summaries[key] = {
+      sum: sum,
+      average: average,
+      median: median,
+      max: max,
+      min: min
+    };
+  });
+  return summaries;
+};
+
+/**
+ * calculate sub-group's summaries of numeric columns
+ * @param {array} subgroups { summaries, ... }
+ * @param {array} numericColumns
+ * @returns object, { [column.key]: { sum, average, median, max, min, ... } }
+ */
+var getSummariesWithSubgroups = function getSummariesWithSubgroups(subgroups, numericColumns) {
+  var subgroupsLen = subgroups.length;
+  var summaries = {};
+  numericColumns.forEach(function (column) {
+    var medianArr = [];
+    var sum = 0;
+    var average = 0;
+    var median;
+    var max;
+    var min;
+    subgroups.forEach(function (subgroup) {
+      var summaries = subgroup.summaries;
+      var summary = summaries[column.key];
+      var subgroupSum = summary.sum,
+        subgroupAverage = summary.average,
+        subgroupMedian = summary.median,
+        subgroupMax = summary.max,
+        subgroupMin = summary.min;
+      sum += subgroupSum || 0;
+      average += subgroupAverage || 0;
+      if (isNumber(subgroupMedian)) {
+        medianArr.push(subgroupMedian);
+      }
+      if (isNumber(subgroupMax)) {
+        if (max === undefined) {
+          max = subgroupMax;
+        } else {
+          max = subgroupMax > max ? subgroupMax : max;
+        }
+      }
+      if (isNumber(subgroupMin)) {
+        if (min === undefined) {
+          min = subgroupMin;
+        } else {
+          min = subgroupMin < min ? subgroupMin : min;
+        }
+      }
+    });
+    if (medianArr.length > 0) {
+      medianArr.sort();
+      if (medianArr.length % 2 === 0) {
+        median = (medianArr[medianArr.length / 2 - 1] + medianArr[medianArr.length / 2]) / 2;
+      } else {
+        median = medianArr[parseInt(medianArr.length / 2)];
+      }
+    }
+    average = average / subgroupsLen;
+    summaries[column.key] = {
+      sum: sum,
+      average: average,
+      median: median,
+      max: max,
+      min: min
+    };
+  });
+  return summaries;
+};
+
+/**
+ * calculate group's summaries of numeric columns from table
+ * @param {array} groups { subgroups, row_ids, ... }
+ * @param {object} table
+ * @param {object} formulaRows support numeric formula columns
+ */
+var updateGroupSummaries = function updateGroupSummaries(groups, table, formulaRows) {
+  var numericColumns = table.columns.filter(function (column) {
+    return isNumericColumn(column);
+  });
+  if (!Array.isArray(groups) || numericColumns.length === 0) {
+    return;
+  }
+  groups.forEach(function (group) {
+    var subgroups = group.subgroups,
+      row_ids = group.row_ids;
+    if (Array.isArray(subgroups) && subgroups.length > 0) {
+      updateGroupSummaries(subgroups, table, formulaRows);
+      group.summaries = getSummariesWithSubgroups(subgroups, numericColumns);
+    } else if (row_ids) {
+      group.summaries = getSummaries(table, row_ids, formulaRows);
+    }
+  });
+};
+
+export { getSummaries, getSummariesWithSubgroups, updateGroupSummaries };