@native-html/heuristic-table-plugin/lib/commonjs/helpers/createRenderTree.js

🔠 A 100% native component using heuristics to render tables in react-native-render-html

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = createRenderTree;

var _pipe = _interopRequireDefault(require("ramda/src/pipe"));

var _prop = _interopRequireDefault(require("ramda/src/prop"));

var _slice = _interopRequireDefault(require("ramda/src/slice"));

var _sum = _interopRequireDefault(require("ramda/src/sum"));

var _map = _interopRequireDefault(require("ramda/src/map"));

var _max = _interopRequireDefault(require("ramda/src/max"));

var _reduce = _interopRequireDefault(require("ramda/src/reduce"));

var _partial = _interopRequireDefault(require("ramda/src/partial"));

var _flatten = _interopRequireDefault(require("ramda/src/flatten"));

var _sort = _interopRequireDefault(require("ramda/src/sort"));

var _filter = _interopRequireDefault(require("ramda/src/filter"));

var _makeRows = _interopRequireDefault(require("./makeRows"));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

const getRowGroupHeight = (0, _pipe.default)((0, _map.default)((0, _prop.default)('lenY')), (0, _reduce.default)(_max.default, 0));

function groupCellsByVGroup(cellsByRow) {
  const cellsByVGroup = [];
  let rowHeight = 1;

  for (let i = 0; i < cellsByRow.length; i += Math.max(rowHeight, 1)) {
    const row = cellsByRow[i];
    rowHeight = getRowGroupHeight(row);
    cellsByVGroup.push((0, _slice.default)(i, i + rowHeight)(cellsByRow));
  }

  return cellsByVGroup;
}

function makeRowContainer(cells) {
  return {
    type: 'row-container',
    children: cells
  };
}

function makeColContainer(cells) {
  return {
    type: 'col-container',
    children: (0, _makeRows.default)(cells).map(makeRowContainer)
  };
}

const splitToColumnContainers = (0, _pipe.default)(_flatten.default, function (cells) {
  let breakpointsX = (0, _pipe.default)((0, _filter.default)(cell => cell.lenY > 1), (0, _map.default)((0, _prop.default)('x')))(cells);
  let breakpointIndex = 0;
  const cellsByRow = (0, _sort.default)((a, b) => a.x - b.x)(cells);
  let containers = [];
  let colGroup = [];

  for (const cell of cellsByRow) {
    var _breakpointsX$breakpo;

    if (cell.x < ((_breakpointsX$breakpo = breakpointsX[breakpointIndex]) !== null && _breakpointsX$breakpo !== void 0 ? _breakpointsX$breakpo : Infinity)) {
      colGroup.push(cell);
    } else {
      colGroup.length && containers.push(colGroup);
      containers.push([cell]);
      colGroup = [];
      breakpointIndex += 1;
    }
  }

  colGroup.length && containers.push(colGroup);
  return containers.map(makeColContainer);
});

function translateVGroups(virtualRowGroups) {
  const flattenRows = [];

  for (const rowGroup of virtualRowGroups) {
    if (rowGroup.length === 1) {
      flattenRows.push({
        type: 'row-container',
        children: rowGroup[0]
      });
    } else {
      const container = {
        type: 'row-container',
        children: splitToColumnContainers(rowGroup)
      };
      flattenRows.push(container);
    }
  }

  return flattenRows;
}

function makeCell(columnWidths, cell) {
  return { ...cell,
    type: 'cell',
    width: (0, _pipe.default)((0, _slice.default)(cell.x, cell.x + cell.lenX), _sum.default)(columnWidths)
  };
}

function createRenderTree(display, columnWidths) {
  const children = (0, _pipe.default)((0, _map.default)((0, _partial.default)(makeCell, [columnWidths])), _makeRows.default, groupCellsByVGroup, translateVGroups)(display.cells);
  return {
    type: 'root',
    children: children
  };
}
//# sourceMappingURL=createRenderTree.js.map