dtable-utils 0.0.3 → 0.0.4-beta.1

package/lib/view/formula.js

@@ -0,0 +1,154 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var cellType = require('../constants/cell-type.js');
+var formula = require('../constants/formula.js');
+
+/**
+ * Transform the formats of link column to link-formula's
+ * @param {object} linkColumn e.g. { key, data: { display_column_key, ... }, ... }
+ * @returns converted link column, 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.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 the formula columns waiting to sort
+ * @param {object} table e.g. { columns, ... }
+ * @returns sorted formula columns, 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.FORMULA_COLUMN_TYPES_MAP[type]) {
+      keyColumnMap[key] = column;
+    } else if (type === cellType.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;
+    if (Array.isArray(operated_columns)) {
+      operated_columns.forEach(function (dependColumnKey) {
+        var dependColumn = keyColumnMap[dependColumnKey];
+        if (!dependColumn) {
+          return;
+        }
+        keyInDegreeMap[formulaColumnKey] += 1;
+        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);
+    if (Array.isArray(edges)) {
+      edges.forEach(function (edge) {
+        keyInDegreeMap[edge] -= 1;
+        if (keyInDegreeMap[edge] === 0) {
+          waitingQueue.push(edge);
+        }
+      });
+    }
+  }
+  return sortedList.map(function (columnKey) {
+    return keyColumnMap[columnKey];
+  });
+};
+
+/**
+ * Get table formula columns and link columns
+ * @param {object} table e.g. { columns, ... }
+ * @returns formula and link columns, 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.CellType.LINK) {
+      return !!data;
+    }
+    return formula.FORMULA_COLUMN_TYPES_MAP[type] && data;
+  });
+  return formulaColumns.map(function (column) {
+    if (column.type === cellType.CellType.LINK) {
+      return transLink2LinkFormula(column);
+    }
+    return column;
+  });
+};
+
+/**
+ * Get sorted formula and link columns from table
+ * @param {object} table e.g. { columns, ... }
+ * @returns sorted formula and link columns, array
+ */
+var getSortedFormulaColumnsContainLinks = function getSortedFormulaColumnsContainLinks(table) {
+  var formulaColumns = getFormulaColumnsContainLinks(table);
+  if (formulaColumns.length === 0) return [];
+  return getSortedFormulaColumns(formulaColumns, table);
+};
+
+exports.getFormulaColumnsContainLinks = getFormulaColumnsContainLinks;
+exports.getSortedFormulaColumns = getSortedFormulaColumns;
+exports.getSortedFormulaColumnsContainLinks = getSortedFormulaColumnsContainLinks;
+exports.transLink2LinkFormula = transLink2LinkFormula;

package/lib/view/group.js

@@ -0,0 +1,36 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * Get group by paths
+ * @param {array} paths e.g. [ 0, 1, 2 ]
+ * @param {array} groups grouped rows
+ * @returns group, 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;
+};
+
+exports.getGroupByPath = getGroupByPath;

package/lib/view/summaries.js

@@ -0,0 +1,173 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var row = require('../table/row.js');
+var core = require('../row/core.js');
+var number = require('../column/number.js');
+var number$1 = require('../number.js');
+var formula = require('../constants/formula.js');
+
+/**
+ * Calculate summaries of table numeric columns
+ * @param {object} table e.g. { columns, ... }
+ * @param {array} rows e.g. table rows: [{ _id, ...}, ...] | view rows: [ row._id, ... ]
+ * @param {object} formulaRows for numeric formula columns
+ * @returns summaries: { [column.key]: { sum, average, median, max, min, ... }, ... }, object
+ */
+var getSummaries = function getSummaries(table, rows, formulaRows) {
+  var numericColumns = table.columns.filter(function (column) {
+    return number.isNumericColumn(column);
+  });
+  if (numericColumns.length === 0) {
+    return {};
+  }
+  var summaryRows = core.isTableRows(rows) ? rows : row.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.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 (number$1.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 group summaries by subgroup
+ * @param {array} subgroups e.g. [{ summaries, ... }, ...]
+ * @param {array} numericColumns
+ * @returns summaries: { [column.key]: { sum, average, median, max, min, ... }, ... }, object
+ */
+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 subSummaries = subgroup.summaries;
+      var summary = subSummaries[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 (number$1.isNumber(subgroupMedian)) {
+        medianArr.push(subgroupMedian);
+      }
+      if (number$1.isNumber(subgroupMax)) {
+        if (max === undefined) {
+          max = subgroupMax;
+        } else {
+          max = subgroupMax > max ? subgroupMax : max;
+        }
+      }
+      if (number$1.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 /= subgroupsLen;
+    summaries[column.key] = {
+      sum: sum,
+      average: average,
+      median: median,
+      max: max,
+      min: min
+    };
+  });
+  return summaries;
+};
+
+/**
+ * Calculate group summaries
+ * @param {array} groups e.g. [{ subgroups, row_ids, ... }, ...]
+ * @param {object} table e.g. { columns, ... }
+ * @param {object} formulaRows for numeric formula columns
+ * @returns void
+ */
+var updateGroupSummaries = function updateGroupSummaries(groups, table, formulaRows) {
+  var numericColumns = table.columns.filter(function (column) {
+    return number.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);
+    }
+  });
+};
+
+exports.getSummaries = getSummaries;
+exports.getSummariesWithSubgroups = getSummariesWithSubgroups;
+exports.updateGroupSummaries = updateGroupSummaries;

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "dtable-utils",
-  "version": "0.0.3",
+  "version": "0.0.4-beta.1",
   "description": "dtable common utils",
   "main": "./lib/index.js",
   "module": "./es/index.js",
   "private": false,
   "scripts": {
-    "test": "jest --coverage --watchAll",
+    "test": "jest -c --watchAll",
+    "test-cov": "jest --coverage --watchAll",
     "eslint": "eslint ./src/**",
     "build": "rm -rf dist lib es && rollup -c",
     "prepublishOnly": "npm run build"
@@ -23,7 +24,8 @@
     "package.json"
   ],
   "dependencies": {
-    "dayjs": "1.10.7"
+    "dayjs": "1.10.7",
+    "deep-copy": "^1.4.2"
   },
   "devDependencies": {
     "@babel/core": "^7.22.5",