npm - @dhis2/analytics - Versions diffs - 26.0.8 → 26.0.9 - Mend

@dhis2/analytics 26.0.8 → 26.0.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (735) hide show

package/build/es/modules/pivotTable/PivotTableEngine.js CHANGED Viewed

@@ -1,5 +1,6 @@
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+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); }
 import times from 'lodash/times';
 import { DIMENSION_TYPE_DATA, DIMENSION_TYPE_DATA_ELEMENT_GROUP_SET, DIMENSION_TYPE_ORGANISATION_UNIT, DIMENSION_TYPE_PERIOD } from '../dataTypes.js';
 import { DIMENSION_ID_ORGUNIT } from '../predefinedDimensions.js';
@@ -23,9 +24,7 @@ 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 => {
@@ -33,7 +32,6 @@ const countFromDisaggregates = list => {
   });
   return count;
 };
 const addSize = list => {
   const reversedList = list.slice().reverse();
   reversedList.forEach((level, idx) => {
@@ -42,22 +40,18 @@ const addSize = list => {
     level.size = lastLevel ? lastLevel.count * lastLevel.size : 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) => {
   const rows = visualization.rows.map(row => ({
     dimension: row.dimension,
@@ -79,7 +73,8 @@ const buildDimensionLookup = (visualization, metadata, headers) => {
   }));
   addSize(rows);
   addSize(columns);
-  const allByDimension = { ...listByDimension(rows),
+  const allByDimension = {
+    ...listByDimension(rows),
     ...listByDimension(columns)
   };
   const headerDimensions = headers.map(header => allByDimension[header.name]);
@@ -90,11 +85,9 @@ const buildDimensionLookup = (visualization, metadata, headers) => {
     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);
       }
@@ -102,7 +95,6 @@ const buildDimensionLookup = (visualization, metadata, headers) => {
     sortByHierarchy(ouDimension.items);
     ouDimension.itemIds = ouDimension.items.map(item => item.uid);
   }
   return {
     rows,
     columns,
@@ -113,52 +105,40 @@ const buildDimensionLookup = (visualization, metadata, headers) => {
     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,
@@ -168,48 +148,31 @@ const applyTotalAggregationType = (_ref2, overrideTotalAggregationType) => {
     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, legendSets) {
     _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", []);
     this.visualization = Object.assign({}, defaultVisualizationProps, visualization);
     this.legendSets = (legendSets || []).reduce((sets, set) => {
       sets[set.id] = set;
@@ -217,7 +180,8 @@ export class PivotTableEngine {
     }, {});
     this.rawData = data;
     this.dimensionLookup = buildDimensionLookup(this.visualization, this.rawData.metaData, this.rawData.headers);
-    this.options = { ...defaultOptions,
+    this.options = {
+      ...defaultOptions,
       showColumnTotals: visualization.colTotals,
       showRowTotals: visualization.rowTotals,
       showColumnSubtotals: visualization.colSubTotals,
@@ -238,10 +202,8 @@ export class PivotTableEngine {
     this.rowDepth = this.dimensionLookup.rows.length || (this.visualization.showDimensionLabels ? 1 : 0);
     this.buildMatrix();
   }
   getRaw(_ref3) {
     var _headers$find, _headers$find2;
     let {
       row,
       column
@@ -257,7 +219,6 @@ export class PivotTableEngine {
     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,
@@ -266,29 +227,23 @@ export class PivotTableEngine {
         peId
       };
     }
     const dataRow = this.data[row][column];
     let rawValue = cellType === CELL_TYPE_VALUE ? dataRow[this.dimensionLookup.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,
@@ -301,25 +256,21 @@ export class PivotTableEngine {
       peId
     };
   }
   get(_ref4) {
     let {
       row,
       column
     } = _ref4;
     const mappedRow = this.rowMap[row],
-          mappedColumn = this.columnMap[column];
+      mappedColumn = this.columnMap[column];
     if (!mappedRow && mappedRow !== 0 || !mappedColumn && mappedColumn !== 0) {
       return undefined;
     }
     return this.getRaw({
       row: mappedRow,
       column: mappedColumn
     });
   }
   getRawCellType(_ref5) {
     let {
       row,
@@ -327,21 +278,16 @@ export class PivotTableEngine {
     } = _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,
@@ -354,36 +300,28 @@ export class PivotTableEngine {
       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 "".concat(this.dimensionLookup.rows[lastRowLevel].meta.name, " / ").concat(this.dimensionLookup.columns[lastColumnLevel].meta.name);
+      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,
@@ -394,23 +332,18 @@ export class PivotTableEngine {
       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 {
@@ -419,11 +352,9 @@ export class PivotTableEngine {
         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,
@@ -431,90 +362,74 @@ export class PivotTableEngine {
         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
+    }
+    // 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) {
     if (this.doRowTotals && column === this.dataWidth - 1) {
       return times(this.columnDepth - 1, () => undefined).concat([{
         name: 'Total'
       }]);
     }
     if (this.doRowSubtotals) {
       if ((column + 1) % (this.dimensionLookup.columns[0].size + 1) === 0) {
         return times(this.columnDepth - 1, () => undefined).concat([{
           name: 'Subtotal'
         }]);
       }
       column -= Math.floor(column / (this.dimensionLookup.columns[0].size + 1));
     }
     return this.dimensionLookup.columns.map(dimension => {
       const itemIndex = Math.floor(column / dimension.size) % dimension.count;
       return dimension.items[itemIndex];
     });
   }
   getColumnHeader(column) {
     return this.getRawColumnHeader(this.columnMap[column]);
   }
   getRawRowHeader(row) {
     if (this.doColumnTotals && row === this.dataHeight - 1) {
       return times(this.rowDepth - 1, () => undefined).concat([{
         name: 'Total'
       }]);
     }
     if (this.doColumnSubtotals) {
       if ((row + 1) % (this.dimensionLookup.rows[0].size + 1) === 0) {
         return times(this.rowDepth - 1, () => undefined).concat([{
           name: 'Subtotal'
         }]);
       }
       row -= Math.floor(row / (this.dimensionLookup.rows[0].size + 1));
     }
     return this.dimensionLookup.rows.map(dimension => {
       const itemIndex = Math.floor(row / dimension.size) % dimension.count;
       return dimension.items[itemIndex];
     });
   }
   getRowHeader(row) {
     return this.getRawRowHeader(this.rowMap[row]);
   }
   getDependantTotalCells(_ref9) {
     var _this$dimensionLookup, _this$dimensionLookup2;
     let {
       row,
       column
@@ -572,7 +487,6 @@ export class PivotTableEngine {
       combinedTotal
     };
   }
   addCellValueToTotals(pos, dataRow) {
     const totals = this.getDependantTotalCells(pos);
     const dxDimension = this.getRawCellDxDimension(pos);
@@ -580,7 +494,6 @@ export class PivotTableEngine {
       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,
@@ -589,36 +502,29 @@ export class PivotTableEngine {
       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] = {
@@ -626,17 +532,14 @@ export class PivotTableEngine {
           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] = {
@@ -644,18 +547,15 @@ export class PivotTableEngine {
             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] = {
@@ -663,19 +563,16 @@ export class PivotTableEngine {
             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] = {
@@ -683,17 +580,14 @@ export class PivotTableEngine {
           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] = {
@@ -701,18 +595,15 @@ export class PivotTableEngine {
             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] = {
@@ -720,12 +611,10 @@ export class PivotTableEngine {
             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;
           }
@@ -733,19 +622,15 @@ export class PivotTableEngine {
       }
     }
   }
   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({
@@ -754,13 +639,10 @@ export class PivotTableEngine {
       }, renderValue(totalCell.value, totalCell.valueType, this.visualization));
     }
   }
   finalizeTotals() {
     var _this$dimensionLookup3, _this$dimensionLookup4;
     const columnSubtotalSize = ((_this$dimensionLookup3 = this.dimensionLookup.rows[0]) === null || _this$dimensionLookup3 === void 0 ? void 0 : _this$dimensionLookup3.size) + 1;
     const rowSubtotalSize = ((_this$dimensionLookup4 = this.dimensionLookup.columns[0]) === null || _this$dimensionLookup4 === void 0 ? void 0 : _this$dimensionLookup4.size) + 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 => {
@@ -774,7 +656,6 @@ export class PivotTableEngine {
         });
       });
     }
     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 => {
@@ -787,9 +668,9 @@ export class PivotTableEngine {
           }
         });
       });
-    } // Combined subtotal cells
+    }
+    // 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 => {
@@ -800,7 +681,6 @@ export class PivotTableEngine {
         });
       });
     }
     if (this.doRowTotals) {
       const column = this.dataWidth - 1;
       const rowCount = this.doColumnTotals ? this.dataHeight - 1 : this.dataHeight;
@@ -811,7 +691,6 @@ export class PivotTableEngine {
         });
       });
     }
     if (this.doColumnTotals) {
       const row = this.dataHeight - 1;
       const colCount = this.doRowTotals ? this.dataWidth - 1 : this.dataWidth;
@@ -822,106 +701,87 @@ export class PivotTableEngine {
         });
       });
     }
     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);
   }
   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;
     }
   }
   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.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
+    }
+    // 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;
@@ -931,7 +791,6 @@ export class PivotTableEngine {
     this.finalizeTotals();
     this.rawData.rows.forEach(dataRow => {
       const pos = lookup(dataRow, this.dimensionLookup, this);
       if (pos) {
         this.adaptiveClippingController.add(pos, this.getRaw(pos).renderedValue);
       }
@@ -942,50 +801,39 @@ export class PivotTableEngine {
     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 ".concat(order));
+      console.warn(`Invalid sort order ${order}`);
       return;
     }
     if (!this.isSortable(column)) {
-      console.warn("Invalid sort column ".concat(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
@@ -994,31 +842,24 @@ export class PivotTableEngine {
         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();
   }
 }