dtable-utils/lib/view/formula.js

dtable common utils

'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;