@hisptz/dhis2-analytics 1.0.10 → 1.0.11

package/build/es/components/PivotTable/services/engine.js

@@ -0,0 +1,894 @@
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+// @ts-nocheck
+import times from 'lodash/times';
+import { DIMENSION_TYPE_DATA, DIMENSION_TYPE_DATA_ELEMENT_GROUP_SET, DIMENSION_TYPE_ORGANISATION_UNIT, DIMENSION_TYPE_PERIOD } from '../constants/dataTypes';
+import { DIMENSION_ID_ORGUNIT } from '../constants/predefinedDimensions.js';
+import { parseValue, renderValue } from '../utils';
+import { VALUE_TYPE_NUMBER, VALUE_TYPE_TEXT } from '../constants/valueTypes.js';
+import { AdaptiveClippingController } from './adaptiveClippingController';
+import { AGGREGATE_TYPE_AVERAGE, AGGREGATE_TYPE_NA, AGGREGATE_TYPE_SUM, CELL_TYPE_SUBTOTAL, CELL_TYPE_TOTAL, CELL_TYPE_VALUE, DISPLAY_DENSITY_OPTION_COMFORTABLE, DISPLAY_DENSITY_OPTION_COMPACT, DISPLAY_DENSITY_OPTION_NORMAL, DISPLAY_DENSITY_PADDING_COMFORTABLE, DISPLAY_DENSITY_PADDING_COMPACT, DISPLAY_DENSITY_PADDING_NORMAL, FONT_SIZE_LARGE, FONT_SIZE_NORMAL, FONT_SIZE_OPTION_LARGE, FONT_SIZE_OPTION_NORMAL, FONT_SIZE_OPTION_SMALL, FONT_SIZE_SMALL, NUMBER_TYPE_COLUMN_PERCENTAGE, NUMBER_TYPE_ROW_PERCENTAGE, NUMBER_TYPE_VALUE, SORT_ORDER_ASCENDING, SORT_ORDER_DESCENDING } from '../constants/pivotTable';
+import { compact } from "lodash";
+const dataFields = ['value', 'numerator', 'denominator', 'factor', 'multiplier', 'divisor'];
+const defaultOptions = {
+  hideEmptyColumns: false,
+  hideEmptyRows: false,
+  showRowTotals: false,
+  showColumnTotals: false,
+  showRowSubtotals: false,
+  showColumnSubtotals: false,
+  fixColumnHeaders: false,
+  fixRowHeaders: false
+};
+const defaultVisualizationProps = {
+  fontSize: FONT_SIZE_OPTION_NORMAL,
+  displayDensity: DISPLAY_DENSITY_OPTION_NORMAL
+};
+const isDxDimension = dimensionItem => [DIMENSION_TYPE_DATA, DIMENSION_TYPE_DATA_ELEMENT_GROUP_SET].includes(dimensionItem.dimensionType);
+const countFromDisaggregates = list => {
+  let count = 1;
+  list.forEach(x => {
+    count *= x.items.length;
+  });
+  return count;
+};
+const addSize = list => {
+  const reversedList = list.slice().reverse();
+  reversedList.forEach((level, idx) => {
+    var _lastLevel$count, _lastLevel$size;
+    // Start at the "leaf" disaggregate
+    const lastLevel = reversedList[idx - 1];
+    level.size = lastLevel ? ((_lastLevel$count = lastLevel === null || lastLevel === void 0 ? void 0 : lastLevel.count) !== null && _lastLevel$count !== void 0 ? _lastLevel$count : 1) * ((_lastLevel$size = lastLevel === null || lastLevel === void 0 ? void 0 : lastLevel.size) !== null && _lastLevel$size !== void 0 ? _lastLevel$size : 1) : 1;
+  });
+};
+const listByDimension = list => list.reduce((all, item) => {
+  all[item.dimension] = item;
+  return all;
+}, {});
+const sortByHierarchy = items => {
+  items.sort((a, b) => {
+    if (!a.hierarchy || !b.hierarchy) {
+      return 0;
+    }
+    return a.hierarchy.join('/').localeCompare(b.hierarchy.join('/'));
+  });
+};
+const buildDimensionLookup = (visualization, metadata, headers) => {
+  var _visualization$rows$m;
+  if (!metadata) {
+    return;
+  }
+  const rows = (_visualization$rows$m = visualization.rows.map(row => {
+    var _metadata$dimensions, _metadata$dimensions2, _metadata$dimensions$, _metadata$dimensions3;
+    return {
+      dimension: row.dimension,
+      meta: metadata.items[row.dimension],
+      count: (_metadata$dimensions = metadata.dimensions[row.dimension]) === null || _metadata$dimensions === void 0 ? void 0 : _metadata$dimensions.length,
+      itemIds: (_metadata$dimensions2 = metadata.dimensions[row.dimension]) !== null && _metadata$dimensions2 !== void 0 ? _metadata$dimensions2 : [],
+      items: (_metadata$dimensions$ = (_metadata$dimensions3 = metadata.dimensions[row.dimension]) === null || _metadata$dimensions3 === void 0 ? void 0 : _metadata$dimensions3.map(item => metadata.items[item])) !== null && _metadata$dimensions$ !== void 0 ? _metadata$dimensions$ : [],
+      isDxDimension: isDxDimension(metadata.items[row.dimension]),
+      position: 'row'
+    };
+  })) !== null && _visualization$rows$m !== void 0 ? _visualization$rows$m : [];
+  const columns = visualization.columns.map(column => {
+    var _metadata$dimensions4, _metadata$dimensions5, _metadata$dimensions$2, _metadata$dimensions6;
+    return {
+      dimension: column.dimension,
+      meta: metadata.items[column.dimension],
+      count: (_metadata$dimensions4 = metadata.dimensions[column.dimension]) === null || _metadata$dimensions4 === void 0 ? void 0 : _metadata$dimensions4.length,
+      itemIds: (_metadata$dimensions5 = metadata.dimensions[column.dimension]) !== null && _metadata$dimensions5 !== void 0 ? _metadata$dimensions5 : [],
+      items: (_metadata$dimensions$2 = (_metadata$dimensions6 = metadata.dimensions[column.dimension]) === null || _metadata$dimensions6 === void 0 ? void 0 : _metadata$dimensions6.map(item => metadata.items[item])) !== null && _metadata$dimensions$2 !== void 0 ? _metadata$dimensions$2 : [],
+      isDxDimension: isDxDimension(metadata.items[column.dimension]),
+      position: 'column'
+    };
+  });
+  addSize(rows);
+  addSize(columns);
+  const allByDimension = {
+    ...listByDimension(rows),
+    ...listByDimension(columns)
+  };
+  const headerDimensions = compact(headers === null || headers === void 0 ? void 0 : headers.map(header => allByDimension[header.name]));
+  const rowHeaders = headerDimensions.map((_, idx) => idx).filter(idx => headerDimensions[idx] && headerDimensions[idx].position === 'row');
+  const columnHeaders = headerDimensions.map((_, idx) => idx).filter(idx => headerDimensions[idx] && headerDimensions[idx].position === 'column');
+  const dataHeaders = dataFields.reduce((out, field) => {
+    out[field] = headers === null || headers === void 0 ? void 0 : headers.findIndex(header => header.name === field);
+    return out;
+  }, {});
+  const ouDimension = allByDimension[DIMENSION_ID_ORGUNIT];
+  if (visualization.showHierarchy && metadata.ouNameHierarchy && ouDimension) {
+    ouDimension.items.forEach(ou => {
+      const hierarchy = metadata.ouNameHierarchy[ou.uid];
+      if (hierarchy) {
+        ou.hierarchy = hierarchy.split('/').filter(x => x.length);
+      }
+    });
+    sortByHierarchy(ouDimension.items);
+    ouDimension.itemIds = ouDimension.items.map(item => item.uid);
+  }
+  return {
+    rows,
+    columns,
+    allByDimension,
+    headerDimensions,
+    rowHeaders,
+    columnHeaders,
+    dataHeaders
+  };
+};
+const lookup = (dataRow, dimensionLookup, _ref) => {
+  let {
+    doColumnSubtotals,
+    doRowSubtotals
+  } = _ref;
+  let row = 0;
+  for (const headerIndex of dimensionLookup.rowHeaders) {
+    const idx = dimensionLookup.headerDimensions[headerIndex].itemIds.indexOf(dataRow[headerIndex]);
+    if (idx === -1) {
+      return undefined;
+    }
+    const size = dimensionLookup.headerDimensions[headerIndex].size;
+    row += idx * size;
+  }
+  if (doColumnSubtotals) {
+    row += Math.floor(row / dimensionLookup.rows[0].size);
+  }
+  let column = 0;
+  for (const headerIndex of dimensionLookup.columnHeaders) {
+    const idx = dimensionLookup.headerDimensions[headerIndex].itemIds.indexOf(dataRow[headerIndex]);
+    if (idx === -1) {
+      return undefined;
+    }
+    const size = dimensionLookup.headerDimensions[headerIndex].size;
+    column += idx * size;
+  }
+  if (doRowSubtotals) {
+    column += Math.floor(column / dimensionLookup.columns[0].size);
+  }
+  return {
+    column,
+    row
+  };
+};
+const applyTotalAggregationType = (_ref2, overrideTotalAggregationType) => {
+  let {
+    totalAggregationType,
+    value,
+    numerator,
+    denominator,
+    multiplier,
+    divisor
+  } = _ref2;
+  switch (overrideTotalAggregationType || totalAggregationType) {
+    case AGGREGATE_TYPE_NA:
+      return 'N/A';
+    case AGGREGATE_TYPE_AVERAGE:
+      return (numerator || value) * multiplier / (denominator * divisor || 1);
+    case AGGREGATE_TYPE_SUM:
+    default:
+      return value;
+  }
+};
+export class PivotTableEngine {
+  constructor(visualization, data) {
+    var _this$dimensionLookup, _this$dimensionLookup2, _this$dimensionLookup3, _this$dimensionLookup4, _this$dimensionLookup5, _this$dimensionLookup6, _this$dimensionLookup7, _this$dimensionLookup8, _this$dimensionLookup9;
+    let legendSets = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+    _defineProperty(this, "visualization", void 0);
+    _defineProperty(this, "rawData", void 0);
+    _defineProperty(this, "options", void 0);
+    _defineProperty(this, "legendSets", void 0);
+    _defineProperty(this, "dimensionLookup", void 0);
+    _defineProperty(this, "adaptiveClippingController", void 0);
+    _defineProperty(this, "columnDepth", 0);
+    _defineProperty(this, "rowDepth", 0);
+    _defineProperty(this, "height", 0);
+    _defineProperty(this, "width", 0);
+    _defineProperty(this, "data", []);
+    _defineProperty(this, "rowMap", []);
+    _defineProperty(this, "columnMap", []);
+    _defineProperty(this, "doRowTotals", false);
+    _defineProperty(this, "doColumnTotals", false);
+    _defineProperty(this, "doRowSubtotals", false);
+    _defineProperty(this, "doColumnSubtotals", false);
+    _defineProperty(this, "dataWidth", 0);
+    _defineProperty(this, "dataHeight", 0);
+    _defineProperty(this, "rawDataHeight", 0);
+    this.visualization = Object.assign({}, defaultVisualizationProps, visualization);
+    this.legendSets = (legendSets || []).reduce((sets, set) => {
+      return {
+        ...sets,
+        [set.id]: set
+      };
+    }, {});
+    this.rawData = data;
+    this.dimensionLookup = buildDimensionLookup(this.visualization, this.rawData.metaData, this.rawData.headers);
+    this.options = {
+      ...defaultOptions,
+      showColumnTotals: visualization.colTotals,
+      showRowTotals: visualization.rowTotals,
+      showColumnSubtotals: visualization.colSubTotals,
+      showRowSubtotals: visualization.rowSubTotals,
+      hideEmptyColumns: visualization.hideEmptyColumns,
+      hideEmptyRows: visualization.hideEmptyRows,
+      title: visualization.hideTitle ? undefined : visualization.title,
+      subtitle: visualization.hideSubtitle ? undefined : visualization.subtitle,
+      // turn on fixed headers only when there are dimensions
+      fixColumnHeaders: (_this$dimensionLookup = this.dimensionLookup) !== null && _this$dimensionLookup !== void 0 && _this$dimensionLookup.columns.length ? visualization.fixColumnHeaders : false,
+      fixRowHeaders: (_this$dimensionLookup2 = this.dimensionLookup) !== null && _this$dimensionLookup2 !== void 0 && _this$dimensionLookup2.rows.length ? visualization.fixRowHeaders : false
+    };
+    this.adaptiveClippingController = new AdaptiveClippingController(this);
+    const doColumnSubtotals = this.options.showColumnSubtotals && ((_this$dimensionLookup3 = (_this$dimensionLookup4 = this.dimensionLookup) === null || _this$dimensionLookup4 === void 0 ? void 0 : (_this$dimensionLookup5 = _this$dimensionLookup4.rows) === null || _this$dimensionLookup5 === void 0 ? void 0 : _this$dimensionLookup5.length) !== null && _this$dimensionLookup3 !== void 0 ? _this$dimensionLookup3 : 1) > 1;
+    const singularRow = ((_this$dimensionLookup6 = this.dimensionLookup) === null || _this$dimensionLookup6 === void 0 ? void 0 : _this$dimensionLookup6.rows.length) === 1 && ((_this$dimensionLookup7 = this.dimensionLookup) === null || _this$dimensionLookup7 === void 0 ? void 0 : _this$dimensionLookup7.rows[0].count) === 1;
+    const firstColumnIsSortable = !doColumnSubtotals && !singularRow;
+    this.columnDepth = ((_this$dimensionLookup8 = this.dimensionLookup) === null || _this$dimensionLookup8 === void 0 ? void 0 : _this$dimensionLookup8.columns.length) || (this.visualization.showDimensionLabels || firstColumnIsSortable ? 1 : 0);
+    this.rowDepth = ((_this$dimensionLookup9 = this.dimensionLookup) === null || _this$dimensionLookup9 === void 0 ? void 0 : _this$dimensionLookup9.rows.length) || (this.visualization.showDimensionLabels ? 1 : 0);
+    this.buildMatrix();
+  }
+  get cellPadding() {
+    switch (this.visualization.displayDensity) {
+      case DISPLAY_DENSITY_OPTION_COMPACT:
+        return DISPLAY_DENSITY_PADDING_COMPACT;
+      case DISPLAY_DENSITY_OPTION_COMFORTABLE:
+        return DISPLAY_DENSITY_PADDING_COMFORTABLE;
+      case DISPLAY_DENSITY_OPTION_NORMAL:
+      default:
+        return DISPLAY_DENSITY_PADDING_NORMAL;
+    }
+  }
+  get fontSize() {
+    switch (this.visualization.fontSize) {
+      case FONT_SIZE_OPTION_SMALL:
+        return FONT_SIZE_SMALL;
+      case FONT_SIZE_OPTION_LARGE:
+        return FONT_SIZE_LARGE;
+      case FONT_SIZE_OPTION_NORMAL:
+      default:
+        return FONT_SIZE_NORMAL;
+    }
+  }
+  get scrollIconBuffer() {
+    switch (this.visualization.fontSize) {
+      case FONT_SIZE_OPTION_SMALL:
+        return 11;
+      case FONT_SIZE_OPTION_LARGE:
+        return 15;
+      case FONT_SIZE_OPTION_NORMAL:
+      default:
+        return 13;
+    }
+  }
+  getRaw(_ref3) {
+    var _headers$find, _headers$find2, _this$dimensionLookup10;
+    let {
+      row,
+      column
+    } = _ref3;
+    const cellType = this.getRawCellType({
+      row,
+      column
+    });
+    const dxDimension = this.getRawCellDxDimension({
+      row,
+      column
+    });
+    const headers = [...this.getRawRowHeader(row), ...this.getRawColumnHeader(column)];
+    const peId = (_headers$find = headers.find(header => (header === null || header === void 0 ? void 0 : header.dimensionItemType) === DIMENSION_TYPE_PERIOD)) === null || _headers$find === void 0 ? void 0 : _headers$find.uid;
+    const ouId = (_headers$find2 = headers.find(header => (header === null || header === void 0 ? void 0 : header.dimensionItemType) === DIMENSION_TYPE_ORGANISATION_UNIT)) === null || _headers$find2 === void 0 ? void 0 : _headers$find2.uid;
+    if (!this.data[row] || !this.data[row][column]) {
+      return {
+        cellType,
+        empty: true,
+        ouId,
+        peId
+      };
+    }
+    const dataRow = this.data[row][column];
+    let rawValue = cellType === CELL_TYPE_VALUE ? dataRow[(_this$dimensionLookup10 = this.dimensionLookup) === null || _this$dimensionLookup10 === void 0 ? void 0 : _this$dimensionLookup10.dataHeaders.value] : dataRow.value;
+    let renderedValue = rawValue;
+    const valueType = (dxDimension === null || dxDimension === void 0 ? void 0 : dxDimension.valueType) || VALUE_TYPE_TEXT;
+    if (valueType === VALUE_TYPE_NUMBER) {
+      rawValue = parseValue(rawValue);
+      switch (this.visualization.numberType) {
+        case NUMBER_TYPE_ROW_PERCENTAGE:
+          renderedValue = rawValue / this.percentageTotals[row].value;
+          break;
+        case NUMBER_TYPE_COLUMN_PERCENTAGE:
+          renderedValue = rawValue / this.percentageTotals[column].value;
+          break;
+        default:
+          break;
+      }
+    }
+    renderedValue = renderValue(renderedValue, valueType, this.visualization);
+    return {
+      cellType,
+      empty: false,
+      valueType,
+      rawValue,
+      renderedValue,
+      dxDimension,
+      ouId,
+      peId
+    };
+  }
+  get(_ref4) {
+    let {
+      row,
+      column
+    } = _ref4;
+    const mappedRow = this.rowMap[row],
+      mappedColumn = this.columnMap[column];
+    if (!mappedRow && mappedRow !== 0 || !mappedColumn && mappedColumn !== 0) {
+      return undefined;
+    }
+    return this.getRaw({
+      row: mappedRow,
+      column: mappedColumn
+    });
+  }
+  getRawCellType(_ref5) {
+    let {
+      row,
+      column
+    } = _ref5;
+    const isRowTotal = this.doRowTotals && column === this.dataWidth - 1;
+    const isColumnTotal = this.doColumnTotals && row === this.dataHeight - 1;
+    if (isRowTotal || isColumnTotal) {
+      return CELL_TYPE_TOTAL;
+    }
+    const isRowSubtotal = this.doRowSubtotals && (column + 1) % (this.dimensionLookup.columns[0].size + 1) === 0;
+    const isColumnSubtotal = this.doColumnSubtotals && (row + 1) % (this.dimensionLookup.rows[0].size + 1) === 0;
+    if (isRowSubtotal || isColumnSubtotal) {
+      return CELL_TYPE_SUBTOTAL;
+    }
+    return CELL_TYPE_VALUE;
+  }
+  getCellType(_ref6) {
+    let {
+      row,
+      column
+    } = _ref6;
+    row = this.rowMap[row];
+    column = this.columnMap[column];
+    return this.getRawCellType({
+      row,
+      column
+    });
+  }
+  getDimensionLabel(rowLevel, columnLevel) {
+    const lastRowLevel = this.rowDepth - 1;
+    const lastColumnLevel = this.columnDepth - 1;
+    if (rowLevel !== lastRowLevel && columnLevel !== lastColumnLevel) {
+      return null;
+    }
+    if (rowLevel === lastRowLevel && this.dimensionLookup.rows[lastRowLevel] && columnLevel === lastColumnLevel && this.dimensionLookup.columns[lastColumnLevel]) {
+      return `${this.dimensionLookup.rows[lastRowLevel].meta.name} / ${this.dimensionLookup.columns[lastColumnLevel].meta.name}`;
+    }
+    if (lastRowLevel === -1) {
+      return this.dimensionLookup.columns[columnLevel].meta.name;
+    }
+    if (lastColumnLevel === -1) {
+      return this.dimensionLookup.rows[rowLevel].meta.name;
+    }
+    if (rowLevel === lastRowLevel && this.dimensionLookup.columns[columnLevel]) {
+      return this.dimensionLookup.columns[columnLevel].meta.name;
+    }
+    if (columnLevel === lastColumnLevel && this.dimensionLookup.rows[rowLevel]) {
+      return this.dimensionLookup.rows[rowLevel].meta.name;
+    }
+  }
+  getCellDxDimension(_ref7) {
+    let {
+      row,
+      column
+    } = _ref7;
+    return this.getRawCellDxDimension({
+      row: this.rowMap[row],
+      column: this.columnMap[column]
+    });
+  }
+  getRawCellDxDimension(_ref8) {
+    let {
+      row,
+      column
+    } = _ref8;
+    if (!this.data[row]) {
+      return undefined;
+    }
+    const cellValue = this.data[row][column];
+    if (!cellValue) {
+      return undefined;
+    }
+    if (!Array.isArray(cellValue)) {
+      // This is a total cell
+      return {
+        valueType: cellValue.valueType,
+        totalAggregationType: cellValue.totalAggregationType,
+        legendSet: undefined
+      };
+    }
+    const rowHeaders = this.getRawRowHeader(row);
+    const columnHeaders = this.getRawColumnHeader(column);
+    const dxRowIndex = this.dimensionLookup.rows.findIndex(dim => dim.isDxDimension);
+    if (rowHeaders.length && dxRowIndex !== -1) {
+      return {
+        valueType: rowHeaders[dxRowIndex].valueType,
+        totalAggregationType: rowHeaders[dxRowIndex].totalAggregationType,
+        legendSet: rowHeaders[dxRowIndex].legendSet
+      };
+    }
+    const dxColumnIndex = this.dimensionLookup.columns.findIndex(dim => dim.isDxDimension);
+    if (columnHeaders.length && dxColumnIndex !== -1) {
+      return {
+        valueType: columnHeaders[dxColumnIndex].valueType,
+        totalAggregationType: columnHeaders[dxColumnIndex].totalAggregationType,
+        legendSet: columnHeaders[dxColumnIndex].legendSet
+      };
+    }
+
+    // Data is in Filter
+    // TODO : This assumes the server ignores text types, we should confirm this is the case
+    return {
+      valueType: VALUE_TYPE_NUMBER,
+      totalAggregationType: AGGREGATE_TYPE_SUM
+    };
+  }
+  rowIsEmpty(row) {
+    return !this.data[row] || this.data[row].length === 0;
+  }
+  columnIsEmpty(column) {
+    return !this.adaptiveClippingController.columns.sizes[column];
+  }
+  getRawColumnHeader(column) {
+    var _this$dimensionLookup17;
+    if (this.doRowTotals && column === this.dataWidth - 1) {
+      return times(this.columnDepth - 1, () => undefined).concat([{
+        name: 'Total'
+      }]);
+    }
+    if (this.doRowSubtotals) {
+      var _this$dimensionLookup11, _this$dimensionLookup12, _this$dimensionLookup13, _this$dimensionLookup14, _this$dimensionLookup15, _this$dimensionLookup16;
+      if ((column + 1) % (((_this$dimensionLookup11 = (_this$dimensionLookup12 = this.dimensionLookup) === null || _this$dimensionLookup12 === void 0 ? void 0 : (_this$dimensionLookup13 = _this$dimensionLookup12.columns[0]) === null || _this$dimensionLookup13 === void 0 ? void 0 : _this$dimensionLookup13.size) !== null && _this$dimensionLookup11 !== void 0 ? _this$dimensionLookup11 : 0) + 1) === 0) {
+        return times(this.columnDepth - 1, () => undefined).concat([{
+          name: 'Subtotal'
+        }]);
+      }
+      column -= Math.floor(column / (((_this$dimensionLookup14 = (_this$dimensionLookup15 = this.dimensionLookup) === null || _this$dimensionLookup15 === void 0 ? void 0 : (_this$dimensionLookup16 = _this$dimensionLookup15.columns[0]) === null || _this$dimensionLookup16 === void 0 ? void 0 : _this$dimensionLookup16.size) !== null && _this$dimensionLookup14 !== void 0 ? _this$dimensionLookup14 : 0) + 1));
+    }
+    return (_this$dimensionLookup17 = this.dimensionLookup) === null || _this$dimensionLookup17 === void 0 ? void 0 : _this$dimensionLookup17.columns.map(dimension => {
+      var _dimension$size, _dimension$count;
+      const itemIndex = Math.floor(column / ((_dimension$size = dimension.size) !== null && _dimension$size !== void 0 ? _dimension$size : 1)) % ((_dimension$count = dimension.count) !== null && _dimension$count !== void 0 ? _dimension$count : 1);
+      return dimension.items[itemIndex];
+    });
+  }
+  getColumnHeader(column) {
+    return this.getRawColumnHeader(this.columnMap[column]);
+  }
+  getRawRowHeader(row) {
+    var _this$dimensionLookup26, _this$dimensionLookup27;
+    if (this.doColumnTotals && row === this.dataHeight - 1) {
+      return times(this.rowDepth - 1, () => undefined).concat([{
+        name: 'Total'
+      }]);
+    }
+    if (this.doColumnSubtotals) {
+      var _this$dimensionLookup18, _this$dimensionLookup19, _this$dimensionLookup20, _this$dimensionLookup21, _this$dimensionLookup22, _this$dimensionLookup23, _this$dimensionLookup24, _this$dimensionLookup25;
+      if ((row + 1) % (((_this$dimensionLookup18 = (_this$dimensionLookup19 = this.dimensionLookup) === null || _this$dimensionLookup19 === void 0 ? void 0 : (_this$dimensionLookup20 = _this$dimensionLookup19.rows) === null || _this$dimensionLookup20 === void 0 ? void 0 : (_this$dimensionLookup21 = _this$dimensionLookup20[0]) === null || _this$dimensionLookup21 === void 0 ? void 0 : _this$dimensionLookup21.size) !== null && _this$dimensionLookup18 !== void 0 ? _this$dimensionLookup18 : 0) + 1) === 0) {
+        return times(this.rowDepth - 1, () => undefined).concat([{
+          name: 'Subtotal'
+        }]);
+      }
+      row -= Math.floor(row / (((_this$dimensionLookup22 = (_this$dimensionLookup23 = this.dimensionLookup) === null || _this$dimensionLookup23 === void 0 ? void 0 : (_this$dimensionLookup24 = _this$dimensionLookup23.rows) === null || _this$dimensionLookup24 === void 0 ? void 0 : (_this$dimensionLookup25 = _this$dimensionLookup24[0]) === null || _this$dimensionLookup25 === void 0 ? void 0 : _this$dimensionLookup25.size) !== null && _this$dimensionLookup22 !== void 0 ? _this$dimensionLookup22 : 0) + 1));
+    }
+    return (_this$dimensionLookup26 = (_this$dimensionLookup27 = this.dimensionLookup) === null || _this$dimensionLookup27 === void 0 ? void 0 : _this$dimensionLookup27.rows.map(dimension => {
+      var _dimension$size2, _dimension$count2;
+      const itemIndex = Math.floor(row / ((_dimension$size2 = dimension === null || dimension === void 0 ? void 0 : dimension.size) !== null && _dimension$size2 !== void 0 ? _dimension$size2 : 1)) % ((_dimension$count2 = dimension.count) !== null && _dimension$count2 !== void 0 ? _dimension$count2 : 1);
+      return dimension.items[itemIndex];
+    })) !== null && _this$dimensionLookup26 !== void 0 ? _this$dimensionLookup26 : [];
+  }
+  getRowHeader(row) {
+    return this.getRawRowHeader(this.rowMap[row]);
+  }
+  getDependantTotalCells(_ref9) {
+    var _this$dimensionLookup28, _this$dimensionLookup29, _this$dimensionLookup30, _this$dimensionLookup31, _this$dimensionLookup32, _this$dimensionLookup33;
+    let {
+      row,
+      column
+    } = _ref9;
+    const rowSubtotalSize = ((_this$dimensionLookup28 = (_this$dimensionLookup29 = this.dimensionLookup) === null || _this$dimensionLookup29 === void 0 ? void 0 : (_this$dimensionLookup30 = _this$dimensionLookup29.columns[0]) === null || _this$dimensionLookup30 === void 0 ? void 0 : _this$dimensionLookup30.size) !== null && _this$dimensionLookup28 !== void 0 ? _this$dimensionLookup28 : 0) + 1;
+    const rowSubtotal = rowSubtotalSize && this.doRowSubtotals && {
+      row,
+      column: Math.ceil((column + 1) / rowSubtotalSize) * rowSubtotalSize - 1,
+      size: rowSubtotalSize - 1
+    };
+    const rowSubtotalColumnTotal = this.doRowSubtotals && this.doColumnTotals && {
+      row: this.dataHeight - 1,
+      column: rowSubtotal === null || rowSubtotal === void 0 ? void 0 : rowSubtotal.column,
+      size: this.rawDataHeight
+    };
+    const columnSubtotalSize = ((_this$dimensionLookup31 = (_this$dimensionLookup32 = this.dimensionLookup) === null || _this$dimensionLookup32 === void 0 ? void 0 : (_this$dimensionLookup33 = _this$dimensionLookup32.rows[0]) === null || _this$dimensionLookup33 === void 0 ? void 0 : _this$dimensionLookup33.size) !== null && _this$dimensionLookup31 !== void 0 ? _this$dimensionLookup31 : 0) + 1;
+    const columnSubtotal = columnSubtotalSize && this.doColumnSubtotals && {
+      row: Math.ceil((row + 1) / columnSubtotalSize) * columnSubtotalSize - 1,
+      column,
+      size: columnSubtotalSize - 1
+    };
+    const columnSubtotalRowTotal = this.doColumnSubtotals && this.doRowTotals && {
+      row: columnSubtotal.row,
+      column: this.dataWidth - 1,
+      size: this.rawDataWidth
+    };
+    const combinedSubtotal = rowSubtotalSize && columnSubtotalSize && this.doColumnSubtotals && this.doRowSubtotals && {
+      row: columnSubtotal.row,
+      column: rowSubtotal.column,
+      size: columnSubtotalSize * rowSubtotalSize
+    };
+    const rowTotal = this.doRowTotals && {
+      row,
+      column: this.dataWidth - 1,
+      size: this.rawDataWidth
+    };
+    const columnTotal = this.doColumnTotals && {
+      row: this.dataHeight - 1,
+      column,
+      size: this.rawDataHeight
+    };
+    const combinedTotal = this.doColumnTotals && this.doRowTotals && {
+      row: this.dataHeight - 1,
+      column: this.dataWidth - 1,
+      size: this.rawDataHeight * this.rawDataWidth
+    };
+    return {
+      rowSubtotal,
+      rowSubtotalColumnTotal,
+      columnSubtotal,
+      columnSubtotalRowTotal,
+      rowTotal,
+      columnTotal,
+      combinedSubtotal,
+      combinedTotal
+    };
+  }
+  addCellValueToTotals(pos, dataRow) {
+    const totals = this.getDependantTotalCells(pos);
+    const dxDimension = this.getRawCellDxDimension(pos);
+    Object.values(totals).forEach(totalItem => {
+      if (!totalItem) {
+        return;
+      }
+      this.data[totalItem.row] = this.data[totalItem.row] || [];
+      this.data[totalItem.row][totalItem.column] = this.data[totalItem.row][totalItem.column] || {
+        count: 0,
+        totalCount: totalItem.size
+      };
+      const totalCell = this.data[totalItem.row][totalItem.column];
+      const currentAggType = dxDimension === null || dxDimension === void 0 ? void 0 : dxDimension.totalAggregationType;
+      const previousAggType = totalCell.totalAggregationType || currentAggType;
+      if (previousAggType && currentAggType !== previousAggType) {
+        totalCell.totalAggregationType = AGGREGATE_TYPE_NA;
+      } else {
+        totalCell.totalAggregationType = currentAggType;
+      }
+      const currentValueType = dxDimension === null || dxDimension === void 0 ? void 0 : dxDimension.valueType;
+      const previousValueType = totalCell.valueType;
+      if (previousValueType && currentValueType !== previousValueType) {
+        totalCell.valueType = AGGREGATE_TYPE_NA;
+      } else {
+        totalCell.valueType = currentValueType;
+      }
+      if ((dxDimension === null || dxDimension === void 0 ? void 0 : dxDimension.valueType) === VALUE_TYPE_NUMBER) {
+        dataFields.forEach(field => {
+          const headerIndex = this.dimensionLookup.dataHeaders[field];
+          const value = parseValue(dataRow[headerIndex]);
+          if (value && !isNaN(value)) {
+            totalCell[field] = (totalCell[field] || 0) + value;
+          }
+        });
+      }
+      totalCell.count += 1;
+    });
+    if (this.visualization.numberType === NUMBER_TYPE_ROW_PERCENTAGE) {
+      if (!this.percentageTotals[pos.row]) {
+        this.percentageTotals[pos.row] = {
+          count: 0,
+          totalCount: this.rawDataWidth
+        };
+      }
+      const percentageTotal = this.percentageTotals[pos.row];
+      dataFields.forEach(field => {
+        const headerIndex = this.dimensionLookup.dataHeaders[field];
+        const value = parseValue(dataRow[headerIndex]);
+        if (value && !isNaN(value)) {
+          percentageTotal[field] = (percentageTotal[field] || 0) + value;
+        }
+      });
+      if (totals.columnSubtotal) {
+        if (!this.percentageTotals[totals.columnSubtotal.row]) {
+          this.percentageTotals[totals.columnSubtotal.row] = {
+            count: 0,
+            totalCount: this.rawDataWidth
+          };
+        }
+        const percentageTotal = this.percentageTotals[totals.columnSubtotal.row];
+        dataFields.forEach(field => {
+          const headerIndex = this.dimensionLookup.dataHeaders[field];
+          const value = parseValue(dataRow[headerIndex]);
+          if (value && !isNaN(value)) {
+            percentageTotal[field] = (percentageTotal[field] || 0) + value;
+          }
+        });
+      }
+      if (totals.columnTotal) {
+        if (!this.percentageTotals[totals.columnTotal.row]) {
+          this.percentageTotals[totals.columnTotal.row] = {
+            count: 0,
+            totalCount: this.rawDataWidth
+          };
+        }
+        const percentageTotal = this.percentageTotals[totals.columnTotal.row];
+        dataFields.forEach(field => {
+          const headerIndex = this.dimensionLookup.dataHeaders[field];
+          const value = parseValue(dataRow[headerIndex]);
+          if (value && !isNaN(value)) {
+            percentageTotal[field] = (percentageTotal[field] || 0) + value;
+          }
+        });
+      }
+    }
+    if (this.visualization.numberType === NUMBER_TYPE_COLUMN_PERCENTAGE) {
+      if (!this.percentageTotals[pos.column]) {
+        this.percentageTotals[pos.column] = {
+          count: 0,
+          totalCount: this.rawDataHeight
+        };
+      }
+      const percentageTotal = this.percentageTotals[pos.column];
+      dataFields.forEach(field => {
+        const headerIndex = this.dimensionLookup.dataHeaders[field];
+        const value = parseValue(dataRow[headerIndex]);
+        if (value && !isNaN(value)) {
+          percentageTotal[field] = (percentageTotal[field] || 0) + value;
+        }
+      });
+      if (totals.rowSubtotal) {
+        if (!this.percentageTotals[totals.rowSubtotal.column]) {
+          this.percentageTotals[totals.rowSubtotal.column] = {
+            count: 0,
+            totalCount: this.rawDataHeight
+          };
+        }
+        const percentageTotal = this.percentageTotals[totals.rowSubtotal.column];
+        dataFields.forEach(field => {
+          const headerIndex = this.dimensionLookup.dataHeaders[field];
+          const value = parseValue(dataRow[headerIndex]);
+          if (value && !isNaN(value)) {
+            percentageTotal[field] = (percentageTotal[field] || 0) + value;
+          }
+        });
+      }
+      if (totals.rowTotal) {
+        if (!this.percentageTotals[totals.rowTotal.column]) {
+          this.percentageTotals[totals.rowTotal.column] = {
+            count: 0,
+            totalCount: this.rawDataHeight
+          };
+        }
+        const percentageTotal = this.percentageTotals[totals.rowTotal.column];
+        dataFields.forEach(field => {
+          const headerIndex = this.dimensionLookup.dataHeaders[field];
+          const value = parseValue(dataRow[headerIndex]);
+          if (value && !isNaN(value)) {
+            percentageTotal[field] = (percentageTotal[field] || 0) + value;
+          }
+        });
+      }
+    }
+  }
+  finalizeTotal(_ref10) {
+    let {
+      row,
+      column
+    } = _ref10;
+    if (!this.data[row]) {
+      return;
+    }
+    const totalCell = this.data[row][column];
+    if (totalCell && totalCell.count) {
+      totalCell.value = applyTotalAggregationType(totalCell, this.visualization.numberType !== NUMBER_TYPE_VALUE && AGGREGATE_TYPE_SUM);
+      this.adaptiveClippingController.add({
+        row,
+        column
+      }, renderValue(totalCell.value, totalCell.valueType, this.visualization));
+    }
+  }
+  finalizeTotals() {
+    var _this$dimensionLookup34, _this$dimensionLookup35, _this$dimensionLookup36, _this$dimensionLookup37, _this$dimensionLookup38, _this$dimensionLookup39;
+    const columnSubtotalSize = ((_this$dimensionLookup34 = (_this$dimensionLookup35 = this.dimensionLookup) === null || _this$dimensionLookup35 === void 0 ? void 0 : (_this$dimensionLookup36 = _this$dimensionLookup35.rows[0]) === null || _this$dimensionLookup36 === void 0 ? void 0 : _this$dimensionLookup36.size) !== null && _this$dimensionLookup34 !== void 0 ? _this$dimensionLookup34 : 0) + 1;
+    const rowSubtotalSize = ((_this$dimensionLookup37 = (_this$dimensionLookup38 = this.dimensionLookup) === null || _this$dimensionLookup38 === void 0 ? void 0 : (_this$dimensionLookup39 = _this$dimensionLookup38.columns[0]) === null || _this$dimensionLookup39 === void 0 ? void 0 : _this$dimensionLookup39.size) !== null && _this$dimensionLookup37 !== void 0 ? _this$dimensionLookup37 : 0) + 1;
+    if (this.doRowSubtotals && rowSubtotalSize) {
+      times(this.dimensionLookup.columns[0].count, n => (n + 1) * rowSubtotalSize - 1).forEach(column => {
+        times(this.dataHeight - (this.doColumnTotals ? 1 : 0), n => n).forEach(row => {
+          // skip combined subtotal cells
+          if (!this.doColumnSubtotals || (row + 1) % columnSubtotalSize !== 0) {
+            this.finalizeTotal({
+              row,
+              column
+            });
+          }
+        });
+      });
+    }
+    if (this.doColumnSubtotals && columnSubtotalSize) {
+      times(this.dimensionLookup.rows[0].count, n => (n + 1) * columnSubtotalSize - 1).forEach(row => {
+        times(this.dataWidth - (this.doRowTotals ? 1 : 0), n => n).forEach(column => {
+          // skip combined subtotal cells
+          if (!this.doRowSubtotals || (column + 1) % rowSubtotalSize !== 0) {
+            this.finalizeTotal({
+              row,
+              column
+            });
+          }
+        });
+      });
+    }
+
+    // Combined subtotal cells
+    if (this.doRowSubtotals && this.doColumnSubtotals && rowSubtotalSize && columnSubtotalSize) {
+      times(this.dimensionLookup.rows[0].count, n => (n + 1) * columnSubtotalSize - 1).forEach(row => {
+        times(this.dimensionLookup.columns[0].count, n => (n + 1) * rowSubtotalSize - 1).forEach(column => {
+          this.finalizeTotal({
+            row,
+            column
+          });
+        });
+      });
+    }
+    if (this.doRowTotals) {
+      const column = this.dataWidth - 1;
+      const rowCount = this.doColumnTotals ? this.dataHeight - 1 : this.dataHeight;
+      times(rowCount, n => n).forEach(row => {
+        this.finalizeTotal({
+          row,
+          column
+        });
+      });
+    }
+    if (this.doColumnTotals) {
+      const row = this.dataHeight - 1;
+      const colCount = this.doRowTotals ? this.dataWidth - 1 : this.dataWidth;
+      times(colCount, n => n).forEach(column => {
+        this.finalizeTotal({
+          row,
+          column
+        });
+      });
+    }
+    if (this.doRowTotals && this.doColumnTotals) {
+      this.finalizeTotal({
+        row: this.dataHeight - 1,
+        column: this.dataWidth - 1
+      });
+    }
+    if (this.percentageTotals) {
+      this.percentageTotals.forEach(item => {
+        item.value = applyTotalAggregationType(item);
+      });
+    }
+  }
+  resetRowMap() {
+    this.rowMap = this.options.hideEmptyRows ? times(this.dataHeight, n => n).filter(idx => !!this.data[idx]) : times(this.dataHeight, n => n);
+  }
+  resetColumnMap() {
+    this.columnMap = this.options.hideEmptyColumns ? times(this.dataWidth, n => n).filter(idx => !this.columnIsEmpty(idx)) : times(this.dataWidth, n => n);
+  }
+  buildMatrix() {
+    this.data = [];
+    this.adaptiveClippingController.reset();
+    this.dataHeight = this.rawDataHeight = countFromDisaggregates(this.dimensionLookup.rows);
+    this.dataWidth = this.rawDataWidth = countFromDisaggregates(this.dimensionLookup.columns);
+
+    // TODO: Check last row/col dimension for size===1, skip redundant sub-totals
+    this.doRowSubtotals = this.options.showRowSubtotals && this.columnDepth > 1;
+    this.doColumnSubtotals = this.options.showColumnSubtotals && this.rowDepth > 1;
+    this.doRowTotals = this.options.showRowTotals && this.dataWidth > 1;
+    this.doColumnTotals = this.options.showColumnTotals && this.dataHeight > 1;
+    if (this.doRowSubtotals) {
+      this.dataWidth += this.dimensionLookup.columns[0].count;
+    }
+    if (this.doColumnSubtotals) {
+      this.dataHeight += this.dimensionLookup.rows[0].count;
+    }
+    if (this.doRowTotals) {
+      this.dataWidth += 1;
+    }
+    if (this.doColumnTotals) {
+      this.dataHeight += 1;
+    }
+
+    // TODO: Use total cell calculation, don't duplicate here
+    if (this.visualization.numberType === NUMBER_TYPE_ROW_PERCENTAGE || this.visualization.numberType === NUMBER_TYPE_COLUMN_PERCENTAGE) {
+      this.percentageTotals = [];
+    }
+    this.rawData.rows.forEach(dataRow => {
+      const pos = lookup(dataRow, this.dimensionLookup, this);
+      if (pos) {
+        this.data[pos.row] = this.data[pos.row] || [];
+        this.data[pos.row][pos.column] = dataRow;
+        this.addCellValueToTotals(pos, dataRow);
+      }
+    });
+    this.finalizeTotals();
+    this.rawData.rows.forEach(dataRow => {
+      const pos = lookup(dataRow, this.dimensionLookup, this);
+      if (pos) {
+        this.adaptiveClippingController.add(pos, this.getRaw(pos).renderedValue);
+      }
+    });
+    this.resetRowMap();
+    this.resetColumnMap();
+    this.height = this.rowMap.length;
+    this.width = this.columnMap.length;
+    this.adaptiveClippingController.finalize();
+  }
+  getColumnType(column) {
+    column = this.columnMap[column];
+    if (!column && column !== 0) {
+      return undefined;
+    }
+    if (this.doRowSubtotals && (column + 1) % (this.dimensionLookup.columns[0].size + 1) === 0) {
+      return CELL_TYPE_SUBTOTAL;
+    }
+    if (this.doRowTotals && column === this.dataWidth - 1) {
+      return CELL_TYPE_TOTAL;
+    }
+    return CELL_TYPE_VALUE;
+  }
+  isSortable(column) {
+    return this.dataHeight > 1 && !this.doColumnSubtotals && this.getColumnType(column) !== undefined;
+  }
+  sort(column, order) {
+    if (order !== SORT_ORDER_ASCENDING && order !== SORT_ORDER_DESCENDING) {
+      console.warn(`Invalid sort order ${order}`);
+      return;
+    }
+    if (!this.isSortable(column)) {
+      console.warn(`Invalid sort column ${column}`);
+      return;
+    }
+    const mappedColumn = this.columnMap[column];
+    this.rowMap.sort((rowA, rowB) => {
+      if (this.doColumnTotals && rowA === this.dataHeight - 1) {
+        return 1;
+      }
+      if (this.doColumnTotals && rowB === this.dataHeight - 1) {
+        return -1;
+      }
+      const valueA = this.getRaw({
+        row: rowA,
+        column: mappedColumn
+      });
+      const valueB = this.getRaw({
+        row: rowB,
+        column: mappedColumn
+      });
+      if ((!valueA || valueA.empty) && (!valueB || valueB.empty)) {
+        return 0;
+      }
+      if (!valueA || valueA.empty) {
+        return -1 * order;
+      }
+      if (!valueB || valueB.empty) {
+        return 1 * order;
+      }
+      if (valueA.valueType === VALUE_TYPE_NUMBER && valueB.valueType === VALUE_TYPE_NUMBER) {
+        return (valueA.rawValue - valueB.rawValue) * order;
+      }
+      return valueA.renderedValue.localeCompare(valueB.renderedValue) * order;
+    });
+    this.adaptiveClippingController.resetRowPartitions();
+  }
+  clearSort() {
+    this.resetRowMap();
+    this.adaptiveClippingController.resetRowPartitions();
+  }
+}