@hrforte/react-pivottable 2.2.1 → 3.0.0

package/dist/pivot-worker.js

@@ -303,13 +303,26 @@ Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
 /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__pivotCompute__ = __webpack_require__(5);
 
 
-var MAX_CACHED_DATASETS = 4;
+var MAX_CACHED_DATASETS = 2;
+var MAX_CACHED_PIVOTS = 2;
 
 var datasetCache = new Map();
+var pendingDatasets = new Map();
+var pivotCache = new Map();
+var pivotDataKeys = new Map();
+var pivotOwners = new Map();
 
 var debugEnabled = false;
 
-var cacheDataset = function cacheDataset(dataKey, dataset) {
+var cacheDataset = function cacheDataset(dataKey, dataset, ownerKey) {
+  if (ownerKey) {
+    datasetCache.forEach(function (cached, cachedKey) {
+      if (cached.ownerKey === ownerKey && cachedKey !== dataKey) {
+        datasetCache.delete(cachedKey);
+      }
+    });
+  }
+  dataset.ownerKey = ownerKey || null;
   datasetCache.delete(dataKey);
   datasetCache.set(dataKey, dataset);
   while (datasetCache.size > MAX_CACHED_DATASETS) {
@@ -346,7 +359,7 @@ self.addEventListener('message', function (event) {
     var startedAt = Date.now();
     log('#' + message.id + ' setData received: ' + (message.data || []).length + ' records (dataKey=' + message.dataKey + ')');
     try {
-      var dataset = cacheDataset(message.dataKey, Object(__WEBPACK_IMPORTED_MODULE_0__pivotCompute__["b" /* materializeData */])(message.data, {}));
+      var dataset = cacheDataset(message.dataKey, Object(__WEBPACK_IMPORTED_MODULE_0__pivotCompute__["i" /* materializeData */])(message.data, {}), message.ownerKey);
       log('#' + message.id + ' materialized ' + dataset.totalRecords + ' records in ' + (Date.now() - startedAt + 'ms (attributes: ' + Object.keys(dataset.attrValues).join(', ') + ')'));
     } catch (error) {
       log('#' + message.id + ' setData failed: ' + toErrorMessage(error));
@@ -359,20 +372,78 @@ self.addEventListener('message', function (event) {
     return;
   }
 
-  if (message.type === 'pivot:compute') {
+  if (message.type === 'pivot:setDataStart') {
+    pendingDatasets.set(message.dataKey, {
+      records: [],
+      ownerKey: message.ownerKey
+    });
+    return;
+  }
+
+  if (message.type === 'pivot:setDataChunk') {
+    var pending = pendingDatasets.get(message.dataKey);
+    if (pending) {
+      (message.data || []).forEach(function (record) {
+        return pending.records.push(record);
+      });
+    }
+    return;
+  }
+
+  if (message.type === 'pivot:setDataEnd') {
     var _startedAt = Date.now();
+    try {
+      var _pending = pendingDatasets.get(message.dataKey);
+      if (!_pending) {
+        throw new Error('no dataset staging buffer for key ' + message.dataKey);
+      }
+      pendingDatasets.delete(message.dataKey);
+      var _dataset = cacheDataset(message.dataKey, Object(__WEBPACK_IMPORTED_MODULE_0__pivotCompute__["i" /* materializeData */])(_pending.records, {}), _pending.ownerKey);
+      log('#' + message.id + ' materialized ' + _dataset.totalRecords + ' chunked records ' + ('in ' + (Date.now() - _startedAt) + 'ms'));
+    } catch (error) {
+      pendingDatasets.delete(message.dataKey);
+      postToMain({
+        type: 'pivot:error',
+        id: message.id,
+        message: toErrorMessage(error)
+      });
+    }
+    return;
+  }
+
+  if (message.type === 'pivot:compute') {
+    var _startedAt2 = Date.now();
     var config = message.config || {};
     try {
-      var _dataset = datasetCache.get(message.dataKey);
-      if (!_dataset) {
+      var _dataset2 = datasetCache.get(message.dataKey);
+      if (!_dataset2) {
         throw new Error('no dataset staged for key ' + message.dataKey);
       }
       log('#' + message.id + ' compute received (rows=[' + (config.rows || []).join(', ') + '] cols=[' + (config.cols || []).join(', ') + '])');
-      var result = Object(__WEBPACK_IMPORTED_MODULE_0__pivotCompute__["a" /* computePivotState */])(_dataset, message.config);
-      log('#' + message.id + ' computed in ' + (Date.now() - _startedAt) + 'ms (rowKeys: ' + result.rowKeys.length + ', colKeys: ' + result.colKeys.length + ', aggregations: ' + result.aggregations.map(function (agg) {
+      var result = Object(__WEBPACK_IMPORTED_MODULE_0__pivotCompute__["d" /* computePivotState */])(_dataset2, message.config);
+      var columnMode = config.aggregationDisplayMode === 'column';
+      var totalRows = Object(__WEBPACK_IMPORTED_MODULE_0__pivotCompute__["h" /* getPivotViewportRowCount */])(result, columnMode);
+      var totalColumns = Object(__WEBPACK_IMPORTED_MODULE_0__pivotCompute__["g" /* getPivotViewportColumnCount */])(result, columnMode);
+      var useVirtualSummary = config.virtualizeRows && (config.rendererName || 'Table') === 'Table' && !config.sortersRequireMainThread && (totalRows > __WEBPACK_IMPORTED_MODULE_0__pivotCompute__["b" /* VIRTUAL_ROW_THRESHOLD */] || totalColumns > __WEBPACK_IMPORTED_MODULE_0__pivotCompute__["a" /* VIRTUAL_COLUMN_THRESHOLD */]);
+      var sparseColumnsAligned = useVirtualSummary && Object(__WEBPACK_IMPORTED_MODULE_0__pivotCompute__["c" /* alignSparseColumnsToRows */])(result);
+      var resultForMain = useVirtualSummary ? Object(__WEBPACK_IMPORTED_MODULE_0__pivotCompute__["f" /* createVirtualPivotSummary */])(result, columnMode) : result;
+      resultForMain.viewportKey = message.id;
+      pivotCache.set(message.id, useVirtualSummary ? result : {
+        rowKeys: result.rowKeys,
+        aggregations: result.aggregations
+      });
+      pivotDataKeys.set(message.id, message.dataKey);
+      pivotOwners.set(message.id, message.ownerKey || null);
+      while (pivotCache.size > MAX_CACHED_PIVOTS) {
+        var oldestKey = pivotCache.keys().next().value;
+        pivotCache.delete(oldestKey);
+        pivotDataKeys.delete(oldestKey);
+        pivotOwners.delete(oldestKey);
+      }
+      log('#' + message.id + ' computed in ' + (Date.now() - _startedAt2) + 'ms (rowKeys: ' + result.rowKeys.length + ', colKeys: ' + result.colKeys.length + ', sparse columns aligned: ' + sparseColumnsAligned + ', aggregations: ' + result.aggregations.map(function (agg) {
         return agg.key;
       }).join(', ') + ')');
-      postToMain({ type: 'pivot:result', id: message.id, result: result });
+      postToMain({ type: 'pivot:result', id: message.id, result: resultForMain });
     } catch (error) {
       log('#' + message.id + ' compute failed: ' + toErrorMessage(error));
       postToMain({
@@ -381,6 +452,91 @@ self.addEventListener('message', function (event) {
         message: toErrorMessage(error)
       });
     }
+    return;
+  }
+
+  if (message.type === 'pivot:viewport') {
+    try {
+      var pivot = pivotCache.get(message.viewportKey);
+      if (!pivot) {
+        throw new Error('Pivot viewport cache is unavailable');
+      }
+      var _result = Object(__WEBPACK_IMPORTED_MODULE_0__pivotCompute__["e" /* computePivotViewport */])(pivot, message.start, message.end, message.columnMode, message.columnStart, message.columnEnd);
+      postToMain({ type: 'pivot:viewportResult', id: message.id, result: _result });
+      log('#' + message.id + ' viewport released after postMessage', {
+        rows: _result.rows.length,
+        datasets: datasetCache.size,
+        pivots: pivotCache.size
+      });
+    } catch (error) {
+      postToMain({
+        type: 'pivot:error',
+        id: message.id,
+        message: toErrorMessage(error)
+      });
+    }
+    return;
+  }
+
+  if (message.type === 'pivot:release') {
+    pivotCache.delete(message.viewportKey);
+    pivotDataKeys.delete(message.viewportKey);
+    pivotOwners.delete(message.viewportKey);
+    log('released pivot ' + message.viewportKey, {
+      datasets: datasetCache.size,
+      pivots: pivotCache.size
+    });
+    return;
+  }
+
+  if (message.type === 'pivot:releaseData') {
+    var _dataset3 = datasetCache.get(message.dataKey);
+    if (_dataset3) {
+      if (Array.isArray(_dataset3.materializedInput)) {
+        _dataset3.materializedInput.length = 0;
+      }
+      _dataset3.attrValues = null;
+    }
+    datasetCache.delete(message.dataKey);
+    pendingDatasets.delete(message.dataKey);
+    pivotCache.forEach(function (pivot, viewportKey) {
+      if (pivotDataKeys.get(viewportKey) === message.dataKey) {
+        pivot.attrValues = null;
+      }
+    });
+    log('released dataset ' + message.dataKey, {
+      datasets: datasetCache.size,
+      pivots: pivotCache.size
+    });
+    return;
+  }
+
+  if (message.type === 'pivot:releaseOwner') {
+    pendingDatasets.forEach(function (pending, dataKey) {
+      if (pending.ownerKey === message.ownerKey) {
+        pending.records.length = 0;
+        pendingDatasets.delete(dataKey);
+      }
+    });
+    datasetCache.forEach(function (dataset, dataKey) {
+      if (dataset.ownerKey === message.ownerKey) {
+        if (Array.isArray(dataset.materializedInput)) {
+          dataset.materializedInput.length = 0;
+        }
+        datasetCache.delete(dataKey);
+      }
+    });
+    pivotCache.forEach(function (pivot, viewportKey) {
+      if (pivotOwners.get(viewportKey) === message.ownerKey) {
+        pivotCache.delete(viewportKey);
+        pivotDataKeys.delete(viewportKey);
+        pivotOwners.delete(viewportKey);
+      }
+    });
+    log('released owner ' + message.ownerKey, {
+      datasets: datasetCache.size,
+      pivots: pivotCache.size
+    });
   }
 });
 
@@ -390,10 +546,17 @@ self.addEventListener('message', function (event) {
 
 "use strict";
 /* unused harmony export DEFAULT_WORKER_THRESHOLD */
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return VIRTUAL_ROW_THRESHOLD; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return VIRTUAL_COLUMN_THRESHOLD; });
 /* unused harmony export WORKER_DEBOUNCE_MS */
-/* harmony export (immutable) */ __webpack_exports__["b"] = materializeData;
-/* harmony export (immutable) */ __webpack_exports__["a"] = computePivotState;
+/* harmony export (immutable) */ __webpack_exports__["i"] = materializeData;
+/* harmony export (immutable) */ __webpack_exports__["d"] = computePivotState;
 /* unused harmony export serializePivotData */
+/* harmony export (immutable) */ __webpack_exports__["h"] = getPivotViewportRowCount;
+/* harmony export (immutable) */ __webpack_exports__["g"] = getPivotViewportColumnCount;
+/* harmony export (immutable) */ __webpack_exports__["c"] = alignSparseColumnsToRows;
+/* harmony export (immutable) */ __webpack_exports__["f"] = createVirtualPivotSummary;
+/* harmony export (immutable) */ __webpack_exports__["e"] = computePivotViewport;
 /* unused harmony export sortersHaveFunctions */
 /* unused harmony export sanitizeSorters */
 /* unused harmony export createWorkerConfig */
@@ -420,21 +583,34 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 // larger ones are handed off to the Web Worker.
 var DEFAULT_WORKER_THRESHOLD = 200;
 
+// Keep this in the computation module so the worker and renderer make the
+// same decision about when a compact, viewport-backed result can be used.
+var VIRTUAL_ROW_THRESHOLD = 300;
+var VIRTUAL_COLUMN_THRESHOLD = 100;
+
+var FLAT_KEY_SEPARATOR = String.fromCharCode(0);
+var SPARSE_CELL_FACTOR = 4;
+
 // Trailing debounce before a worker computation is dispatched, so rapid
 // interactions do not queue one full computation per single change.
 var WORKER_DEBOUNCE_MS = 100;
 
 /*
  * Walks the raw input once and computes the attribute-value inventory plus a
- * "materialized" copy of the records (with derived attributes applied).
+ * materialized view of the records (with derived attributes applied). Object
+ * arrays without derived attributes are reused to avoid a second pointer
+ * array for large datasets.
  * This is an exact extraction of the historical PivotTableUI behavior.
  */
 function materializeData(data, derivedAttributes) {
   var attrValues = {};
-  var materializedInput = [];
+  var canReuseInput = Array.isArray(data) && !Array.isArray(data[0]) && Object.keys(derivedAttributes || {}).length === 0;
+  var materializedInput = canReuseInput ? data : [];
   var recordsProcessed = 0;
   __WEBPACK_IMPORTED_MODULE_0__Utilities__["a" /* PivotData */].forEachRecord(data, derivedAttributes || {}, function (record) {
-    materializedInput.push(record);
+    if (!canReuseInput) {
+      materializedInput.push(record);
+    }
     var _iteratorNormalCompletion = true;
     var _didIteratorError = false;
     var _iteratorError = undefined;
@@ -500,14 +676,10 @@ function computePivotState(materialized, config) {
  */
 function serializePivotData(pivotData, materialized) {
   var serializeCell = function serializeCell(cell) {
-    var values = {};
-    pivotData.aggregations.forEach(function (agg) {
+    return pivotData.aggregations.map(function (agg) {
       var instance = cell.getInstance(agg.key);
-      if (instance) {
-        values[agg.key] = instance.value();
-      }
+      return instance ? instance.value() : null;
     });
-    return { values: values };
   };
 
   var tree = {};
@@ -543,11 +715,203 @@ function serializePivotData(pivotData, materialized) {
       return Object.assign({}, agg);
     }),
     attrValues: materialized.attrValues,
-    materializedInput: materialized.materializedInput,
     totalRecords: materialized.totalRecords
   };
 }
 
+function getPivotViewportRowCount(precomputed, columnMode) {
+  var aggregations = precomputed.aggregations || [];
+  var expandAggregations = aggregations.length > 1 && !columnMode;
+  var rowKeyCount = precomputed.rowKeys.length || (expandAggregations ? 1 : 0);
+  return rowKeyCount * (expandAggregations ? aggregations.length : 1);
+}
+
+function getPivotViewportColumnCount(precomputed, columnMode) {
+  var colKeys = precomputed.colKeys || [];
+  if (!columnMode) {
+    return colKeys.length;
+  }
+  var aggregations = precomputed.aggregations || [];
+  var baseColumnCount = colKeys.length || 1;
+  return baseColumnCount * aggregations.length;
+}
+
+// A high-cardinality field on both axes creates a sparse matrix. Natural row
+// and column sorting can put every populated cell outside the first viewport,
+// making a correctly computed table look empty. For extremely sparse virtual
+// tables, keep every column but order it by the first sorted row that contains
+// a value. Dense pivots keep their normal column order.
+function alignSparseColumnsToRows(precomputed) {
+  var rowKeys = precomputed.rowKeys || [];
+  var colKeys = precomputed.colKeys || [];
+  if (rowKeys.length <= VIRTUAL_ROW_THRESHOLD || colKeys.length <= VIRTUAL_COLUMN_THRESHOLD) {
+    return false;
+  }
+
+  var maxSparseCells = Math.max(rowKeys.length, colKeys.length) * SPARSE_CELL_FACTOR;
+  var nonEmptyCells = 0;
+  var columnIndexByFlatKey = {};
+  colKeys.forEach(function (colKey, index) {
+    columnIndexByFlatKey[colKey.join(FLAT_KEY_SEPARATOR)] = index;
+  });
+  var seenColumnIndexes = {};
+  var orderedColumnIndexes = [];
+
+  var _loop = function _loop(rowIndex) {
+    var flatRowKey = rowKeys[rowIndex].join(FLAT_KEY_SEPARATOR);
+    var rowBranch = (precomputed.tree || {})[flatRowKey] || {};
+    var rowColumnIndexes = [];
+    var flatColumnKeys = Object.keys(rowBranch);
+    nonEmptyCells += flatColumnKeys.length;
+    if (nonEmptyCells > maxSparseCells) {
+      return {
+        v: false
+      };
+    }
+    flatColumnKeys.forEach(function (flatColumnKey) {
+      var columnIndex = columnIndexByFlatKey[flatColumnKey];
+      if (typeof columnIndex === 'number' && !seenColumnIndexes[columnIndex]) {
+        seenColumnIndexes[columnIndex] = true;
+        rowColumnIndexes.push(columnIndex);
+      }
+    });
+    rowColumnIndexes.sort(function (a, b) {
+      return a - b;
+    });
+    rowColumnIndexes.forEach(function (columnIndex) {
+      return orderedColumnIndexes.push(columnIndex);
+    });
+  };
+
+  for (var rowIndex = 0; rowIndex < rowKeys.length; rowIndex++) {
+    var _ret = _loop(rowIndex);
+
+    if ((typeof _ret === 'undefined' ? 'undefined' : _typeof(_ret)) === "object") return _ret.v;
+  }
+
+  if (nonEmptyCells === 0) {
+    return false;
+  }
+  colKeys.forEach(function (colKey, index) {
+    if (!seenColumnIndexes[index]) {
+      orderedColumnIndexes.push(index);
+    }
+  });
+  precomputed.colKeys = orderedColumnIndexes.map(function (index) {
+    return colKeys[index];
+  });
+  return true;
+}
+
+/*
+ * Creates the small result kept on the main thread for a virtualized table.
+ * Cell and row-total values stay in the worker and are transferred only for
+ * the visible viewport. Column totals remain here because the totals footer
+ * is always visible.
+ */
+function createVirtualPivotSummary(precomputed, columnMode) {
+  return {
+    rowKeys: [],
+    colKeys: precomputed.colKeys,
+    tree: {},
+    rowTotals: {},
+    colTotals: {},
+    allTotal: precomputed.allTotal,
+    aggregations: precomputed.aggregations,
+    attrValues: precomputed.attrValues,
+    totalRecords: precomputed.totalRecords,
+    totalRows: getPivotViewportRowCount(precomputed, columnMode),
+    totalColumns: getPivotViewportColumnCount(precomputed, columnMode),
+    virtualized: true
+  };
+}
+
+// Build only the rows requested by a virtualized table. The result contains
+// plain data and can cross the worker boundary without cloning the full pivot.
+function computePivotViewport(precomputed, start, end, columnMode) {
+  var columnStart = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 0;
+  var columnEnd = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : Number.MAX_SAFE_INTEGER;
+
+  var aggregations = precomputed.aggregations || [];
+  var expandAggregations = aggregations.length > 1 && !columnMode;
+  var rowKeys = expandAggregations && precomputed.rowKeys.length === 0 ? [[]] : precomputed.rowKeys;
+  var totalRows = getPivotViewportRowCount(precomputed, columnMode);
+  var first = Math.max(0, Math.min(totalRows, Math.floor(start)));
+  var last = Math.max(first, Math.min(totalRows, Math.floor(end)));
+  var colKeys = precomputed.colKeys || [];
+  var baseColKeys = columnMode && colKeys.length === 0 ? [[]] : colKeys;
+  var totalColumns = getPivotViewportColumnCount(precomputed, columnMode);
+  var firstColumn = Math.max(0, Math.min(totalColumns, Math.floor(columnStart)));
+  var lastColumn = Math.max(firstColumn, Math.min(totalColumns, Math.floor(columnEnd)));
+  var visibleFlatColumnKeys = {};
+  for (var column = firstColumn; column < lastColumn; column++) {
+    var baseColumnIndex = columnMode ? Math.floor(column / aggregations.length) : column;
+    var colKey = baseColKeys[baseColumnIndex];
+    if (colKey) {
+      visibleFlatColumnKeys[colKey.join(FLAT_KEY_SEPARATOR)] = true;
+    }
+  }
+  var selectVisibleCells = function selectVisibleCells(source) {
+    if (!source) {
+      return null;
+    }
+    var selected = {};
+    Object.keys(visibleFlatColumnKeys).forEach(function (flatColKey) {
+      if (flatColKey in source) {
+        selected[flatColKey] = source[flatColKey];
+      }
+    });
+    return selected;
+  };
+  var rows = [];
+
+  for (var index = first; index < last; index++) {
+    var rowIndex = expandAggregations ? Math.floor(index / aggregations.length) : index;
+    var rowKey = rowKeys[rowIndex];
+    var aggregation = expandAggregations ? aggregations[index % aggregations.length] : aggregations[0];
+    var flatRowKey = rowKey.join(FLAT_KEY_SEPARATOR);
+    rows.push({
+      displayKey: expandAggregations ? rowKey.concat([aggregation.label || aggregation.aggregatorName]) : rowKey,
+      actualKey: rowKey,
+      aggregationKey: aggregation.key,
+      spans: [],
+      cells: precomputed.tree ? selectVisibleCells(precomputed.tree[flatRowKey] || {}) : null,
+      rowTotal: precomputed.rowTotals ? precomputed.rowTotals[flatRowKey] || null : null
+    });
+  }
+
+  // Merge repeated row labels inside this window. Doing it here keeps the
+  // prefix comparisons off the main thread for worker-backed tables.
+  var columns = rows.length > 0 ? rows[0].displayKey.length : 0;
+  for (var _column = 0; _column < columns; _column++) {
+    var runStart = 0;
+    for (var _index = 1; _index <= rows.length; _index++) {
+      var samePrefix = _index < rows.length;
+      for (var part = 0; samePrefix && part <= _column; part++) {
+        samePrefix = rows[_index - 1].displayKey[part] === rows[_index].displayKey[part];
+      }
+      if (!samePrefix) {
+        rows[runStart].spans[_column] = _index - runStart;
+        for (var merged = runStart + 1; merged < _index; merged++) {
+          rows[merged].spans[_column] = -1;
+        }
+        runStart = _index;
+      }
+    }
+  }
+
+  return {
+    start: first,
+    end: last,
+    totalRows: totalRows,
+    columnStart: firstColumn,
+    columnEnd: lastColumn,
+    totalColumns: totalColumns,
+    colTotals: selectVisibleCells(precomputed.colTotals || {}),
+    rows: rows
+  };
+}
+
 /*
  * Sorters containing functions cannot be structured-cloned into a worker.
  * Returns true when the sorters prop itself, or any of its entries, is a
@@ -601,7 +965,11 @@ function createWorkerConfig(props) {
     rowOrder: props.rowOrder,
     colOrder: props.colOrder,
     rowSorts: props.rowSorts,
-    colSorts: props.colSorts
+    colSorts: props.colSorts,
+    virtualizeRows: Boolean(props.virtualizeRows),
+    rendererName: props.rendererName,
+    aggregationDisplayMode: props.tableOptions && props.tableOptions.aggregationDisplayMode,
+    sortersRequireMainThread: sortersHaveFunctions(props.sorters)
   };
 }
 
@@ -634,6 +1002,22 @@ function canComputeInWorker(props) {
   if (!Array.isArray(data) || data.length < threshold) {
     return false;
   }
+
+  if (Object.keys(props.derivedAttributes || {}).length > 0) {
+    return false;
+  }
+
+  var requestedAggregatorNames = Array.isArray(props.aggregations) ? props.aggregations.map(function (aggregation) {
+    return aggregation.aggregatorName;
+  }) : [props.aggregatorName || 'Count'];
+  var aggregatorMap = props.aggregators || __WEBPACK_IMPORTED_MODULE_0__Utilities__["a" /* PivotData */].defaultProps.aggregators;
+  var usesCustomAggregator = requestedAggregatorNames.some(function (name) {
+    return typeof aggregatorMap[name] !== 'undefined' && aggregatorMap[name] !== __WEBPACK_IMPORTED_MODULE_0__Utilities__["a" /* PivotData */].defaultProps.aggregators[name];
+  });
+  if (usesCustomAggregator) {
+    return false;
+  }
+
   return true;
 }
 
@@ -1360,11 +1744,9 @@ var AggregatorCell = function () {
   _createClass(AggregatorCell, [{
     key: 'push',
     value: function push(record) {
-      var _this = this;
-
-      Object.keys(this.instances).forEach(function (key) {
-        _this.instances[key].push(record);
-      });
+      for (var key in this.instances) {
+        this.instances[key].push(record);
+      }
     }
   }, {
     key: 'getInstance',
@@ -1373,8 +1755,13 @@ var AggregatorCell = function () {
       if (targetKey && this.instances[targetKey]) {
         return this.instances[targetKey];
       }
-      var first = this.instances[this.primaryKey] || this.instances[Object.keys(this.instances)[0]];
-      return first || null;
+      if (this.instances[this.primaryKey]) {
+        return this.instances[this.primaryKey];
+      }
+      for (var _key2 in this.instances) {
+        return this.instances[_key2];
+      }
+      return null;
     }
   }]);
 
@@ -1435,6 +1822,7 @@ var dayNamesEn = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
 var zeroPad = function zeroPad(number) {
   return ('0' + number).substr(-2, 2);
 }; // eslint-disable-line no-magic-numbers
+var FLAT_KEY_SEPARATOR = String.fromCharCode(0);
 
 var derivers = {
   bin: function bin(col, binWidth) {
@@ -1487,7 +1875,7 @@ Data Model class
 
 var PivotData = function () {
   function PivotData() {
-    var _this2 = this;
+    var _this = this;
 
     var inputProps = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
 
@@ -1498,9 +1886,11 @@ var PivotData = function () {
 
     this.aggregations = this.normalizeAggregations();
     this.aggregationKeyLookup = {};
-    this.aggregations.forEach(function (agg) {
-      if (!(agg.aggregatorName in _this2.aggregationKeyLookup)) {
-        _this2.aggregationKeyLookup[agg.aggregatorName] = agg.key;
+    this.aggregationIndexLookup = {};
+    this.aggregations.forEach(function (agg, index) {
+      _this.aggregationIndexLookup[agg.key] = index;
+      if (!(agg.aggregatorName in _this.aggregationKeyLookup)) {
+        _this.aggregationKeyLookup[agg.aggregatorName] = agg.key;
       }
     });
     if (this.aggregations.length === 0) {
@@ -1526,8 +1916,8 @@ var PivotData = function () {
     }
 
     PivotData.forEachRecord(this.props.data, this.props.derivedAttributes, function (record) {
-      if (_this2.filter(record)) {
-        _this2.processRecord(record);
+      if (_this.filter(record)) {
+        _this.processRecord(record);
       }
     });
   }
@@ -1543,21 +1933,22 @@ var PivotData = function () {
   _createClass(PivotData, [{
     key: 'hydrateFromPrecomputed',
     value: function hydrateFromPrecomputed(precomputed) {
-      var _this3 = this;
+      var _this2 = this;
 
       // One real aggregator instance per aggregation provides `format()` and
       // `numInputs` for every hydrated stub cell.
       var formatSources = {};
       this.aggregations.forEach(function (agg) {
-        formatSources[agg.key] = _this3.aggregatorFactories[agg.key](_this3, [], []);
+        formatSources[agg.key] = _this2.aggregatorFactories[agg.key](_this2, [], []);
       });
+      this.precomputedFormatSources = formatSources;
 
       var makeCell = function makeCell(serializedCell) {
-        var values = serializedCell && serializedCell.values || {};
+        var values = Array.isArray(serializedCell) ? serializedCell : serializedCell && serializedCell.values || {};
         var instances = {};
-        _this3.aggregations.forEach(function (agg) {
+        _this2.aggregations.forEach(function (agg, index) {
           var source = formatSources[agg.key];
-          var _value = values[agg.key];
+          var _value = Array.isArray(values) ? values[index] : values[agg.key];
           instances[agg.key] = {
             push: function push() {},
             value: function value() {
@@ -1571,7 +1962,7 @@ var PivotData = function () {
             outlet: source.outlet
           };
         });
-        return new AggregatorCell(instances, _this3.primaryAggregation.key);
+        return new AggregatorCell(instances, _this2.primaryAggregation.key);
       };
 
       var hydrateTotals = function hydrateTotals(source, target) {
@@ -1592,8 +1983,8 @@ var PivotData = function () {
       hydrateTotals(precomputed.colTotals, this.colTotals);
       this.tree = {};
       Object.keys(precomputed.tree || {}).forEach(function (flatRowKey) {
-        _this3.tree[flatRowKey] = {};
-        hydrateTotals(precomputed.tree[flatRowKey], _this3.tree[flatRowKey]);
+        _this2.tree[flatRowKey] = {};
+        hydrateTotals(precomputed.tree[flatRowKey], _this2.tree[flatRowKey]);
       });
       this.allTotal = makeCell(precomputed.allTotal);
 
@@ -1601,6 +1992,40 @@ var PivotData = function () {
       // thread when a sorter could not cross the worker boundary (functions).
       this.sorted = !sortersHaveFunctions(this.props.sorters);
     }
+
+    // Virtualized worker results keep cell values in the worker. Convert one
+    // serialized viewport cell into an aggregator only when that cell is about
+    // to render, instead of hydrating every pivot cell on the main thread.
+
+  }, {
+    key: 'getPrecomputedAggregator',
+    value: function getPrecomputedAggregator(serializedCell, aggregationKey) {
+      if (!serializedCell) {
+        return PivotData.emptyAggregator;
+      }
+      var resolvedKey = aggregationKey;
+      if (resolvedKey && !(resolvedKey in this.aggregatorFactories) && this.aggregationKeyLookup[resolvedKey]) {
+        resolvedKey = this.aggregationKeyLookup[resolvedKey];
+      }
+      var source = this.precomputedFormatSources && this.precomputedFormatSources[resolvedKey];
+      if (!source) {
+        return PivotData.emptyAggregator;
+      }
+      var values = Array.isArray(serializedCell) ? serializedCell : serializedCell.values || {};
+      var _value2 = Array.isArray(values) ? values[this.aggregationIndexLookup[resolvedKey]] : values[resolvedKey];
+      return {
+        push: function push() {},
+        value: function value() {
+          return _value2;
+        },
+        format: function format(x) {
+          return source.format(x);
+        },
+
+        numInputs: source.numInputs,
+        outlet: source.outlet
+      };
+    }
   }, {
     key: 'filter',
     value: function filter(record) {
@@ -1614,10 +2039,10 @@ var PivotData = function () {
   }, {
     key: 'forEachMatchingRecord',
     value: function forEachMatchingRecord(criteria, callback) {
-      var _this4 = this;
+      var _this3 = this;
 
       return PivotData.forEachRecord(this.props.data, this.props.derivedAttributes, function (record) {
-        if (!_this4.filter(record)) {
+        if (!_this3.filter(record)) {
           return;
         }
         for (var k in criteria) {
@@ -1632,7 +2057,7 @@ var PivotData = function () {
   }, {
     key: 'arrSort',
     value: function arrSort(attrs) {
-      var _this5 = this;
+      var _this4 = this;
 
       var a = void 0;
       var sortersArr = function () {
@@ -1645,7 +2070,7 @@ var PivotData = function () {
           for (var _iterator2 = Array.from(attrs)[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
             a = _step2.value;
 
-            result.push(getSort(_this5.props.sorters, a));
+            result.push(getSort(_this4.props.sorters, a));
           }
         } catch (err) {
           _didIteratorError2 = true;
@@ -1700,12 +2125,12 @@ var PivotData = function () {
   }, {
     key: 'sortKeys',
     value: function sortKeys() {
-      var _this6 = this;
+      var _this5 = this;
 
       if (!this.sorted) {
         this.sorted = true;
         var v = function v(r, c) {
-          return _this6.getAggregator(r, c).value();
+          return _this5.getAggregator(r, c).value();
         };
 
         // Handle per-row sorting
@@ -1713,11 +2138,11 @@ var PivotData = function () {
           var rowSorts = this.props.rowSorts;
           this.rowKeys.sort(function (a, b) {
             // First, check if any sorted attribute has a difference
-            for (var i = 0; i < _this6.props.rows.length; i++) {
-              var attr = _this6.props.rows[i];
+            for (var i = 0; i < _this5.props.rows.length; i++) {
+              var attr = _this5.props.rows[i];
               if (attr && rowSorts[attr]) {
                 var sortDir = rowSorts[attr] === 'ASC' ? 1 : -1;
-                var sorter = getSort(_this6.props.sorters, attr);
+                var sorter = getSort(_this5.props.sorters, attr);
                 var comparison = sorter(a[i] || '', b[i] || '');
                 if (comparison !== 0) {
                   return sortDir * comparison;
@@ -1725,7 +2150,7 @@ var PivotData = function () {
               }
             }
             // If sorted attributes are equal, use default sorting for remaining attributes
-            return _this6.arrSort(_this6.props.rows)(a, b);
+            return _this5.arrSort(_this5.props.rows)(a, b);
           });
         } else {
           // Use global row order
@@ -1750,11 +2175,11 @@ var PivotData = function () {
           var colSorts = this.props.colSorts;
           this.colKeys.sort(function (a, b) {
             // First, check if any sorted attribute has a difference
-            for (var i = 0; i < _this6.props.cols.length; i++) {
-              var attr = _this6.props.cols[i];
+            for (var i = 0; i < _this5.props.cols.length; i++) {
+              var attr = _this5.props.cols[i];
               if (attr && colSorts[attr]) {
                 var sortDir = colSorts[attr] === 'ASC' ? 1 : -1;
-                var sorter = getSort(_this6.props.sorters, attr);
+                var sorter = getSort(_this5.props.sorters, attr);
                 var comparison = sorter(a[i] || '', b[i] || '');
                 if (comparison !== 0) {
                   return sortDir * comparison;
@@ -1762,7 +2187,7 @@ var PivotData = function () {
               }
             }
             // If sorted attributes are equal, use default sorting for remaining attributes
-            return _this6.arrSort(_this6.props.cols)(a, b);
+            return _this5.arrSort(_this5.props.cols)(a, b);
           });
         } else {
           // Use global col order
@@ -1801,58 +2226,16 @@ var PivotData = function () {
       // this code is called in a tight loop
       var colKey = [];
       var rowKey = [];
-      var _iteratorNormalCompletion4 = true;
-      var _didIteratorError4 = false;
-      var _iteratorError4 = undefined;
-
-      try {
-        for (var _iterator4 = Array.from(this.props.cols)[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
-          var x = _step4.value;
-
-          colKey.push(x in record ? record[x] : 'null');
-        }
-      } catch (err) {
-        _didIteratorError4 = true;
-        _iteratorError4 = err;
-      } finally {
-        try {
-          if (!_iteratorNormalCompletion4 && _iterator4.return) {
-            _iterator4.return();
-          }
-        } finally {
-          if (_didIteratorError4) {
-            throw _iteratorError4;
-          }
-        }
+      for (var index = 0; index < this.props.cols.length; index += 1) {
+        var x = this.props.cols[index];
+        colKey.push(x in record ? record[x] : 'null');
       }
-
-      var _iteratorNormalCompletion5 = true;
-      var _didIteratorError5 = false;
-      var _iteratorError5 = undefined;
-
-      try {
-        for (var _iterator5 = Array.from(this.props.rows)[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
-          var _x17 = _step5.value;
-
-          rowKey.push(_x17 in record ? record[_x17] : 'null');
-        }
-      } catch (err) {
-        _didIteratorError5 = true;
-        _iteratorError5 = err;
-      } finally {
-        try {
-          if (!_iteratorNormalCompletion5 && _iterator5.return) {
-            _iterator5.return();
-          }
-        } finally {
-          if (_didIteratorError5) {
-            throw _iteratorError5;
-          }
-        }
+      for (var _index = 0; _index < this.props.rows.length; _index += 1) {
+        var _x17 = this.props.rows[_index];
+        rowKey.push(_x17 in record ? record[_x17] : 'null');
       }
-
-      var flatRowKey = rowKey.join(String.fromCharCode(0));
-      var flatColKey = colKey.join(String.fromCharCode(0));
+      var flatRowKey = rowKey.join(FLAT_KEY_SEPARATOR);
+      var flatColKey = colKey.join(FLAT_KEY_SEPARATOR);
 
       this.allTotal.push(record);
 
@@ -1901,8 +2284,8 @@ var PivotData = function () {
     key: 'getAggregatorCell',
     value: function getAggregatorCell(rowKey, colKey) {
       var cell = void 0;
-      var flatRowKey = rowKey.join(String.fromCharCode(0));
-      var flatColKey = colKey.join(String.fromCharCode(0));
+      var flatRowKey = rowKey.join(FLAT_KEY_SEPARATOR);
+      var flatColKey = colKey.join(FLAT_KEY_SEPARATOR);
       if (rowKey.length === 0 && colKey.length === 0) {
         cell = this.allTotal;
       } else if (rowKey.length === 0) {
@@ -2006,25 +2389,25 @@ var PivotData = function () {
   }, {
     key: 'buildAggregatorFactories',
     value: function buildAggregatorFactories() {
-      var _this7 = this;
+      var _this6 = this;
 
       var factories = {};
       this.aggregations.forEach(function (agg) {
-        if (!(agg.aggregatorName in _this7.props.aggregators)) {
+        if (!(agg.aggregatorName in _this6.props.aggregators)) {
           throw new Error('unknown aggregator ' + agg.aggregatorName);
         }
-        factories[agg.key] = _this7.props.aggregators[agg.aggregatorName](agg.vals);
+        factories[agg.key] = _this6.props.aggregators[agg.aggregatorName](agg.vals);
       });
       return factories;
     }
   }, {
     key: 'createAggregatorCell',
     value: function createAggregatorCell(rowKey, colKey) {
-      var _this8 = this;
+      var _this7 = this;
 
       var instances = {};
       this.aggregations.forEach(function (agg) {
-        instances[agg.key] = _this8.aggregatorFactories[agg.key](_this8, rowKey, colKey);
+        instances[agg.key] = _this7.aggregatorFactories[agg.key](_this7, rowKey, colKey);
       });
       return new AggregatorCell(instances, this.primaryAggregation.key);
     }
@@ -2067,97 +2450,23 @@ PivotData.forEachRecord = function (input, derivedAttributes, f) {
   } else if (Array.isArray(input)) {
     if (Array.isArray(input[0])) {
       // array of arrays
-      return function () {
-        var result = [];
-        var _iteratorNormalCompletion6 = true;
-        var _didIteratorError6 = false;
-        var _iteratorError6 = undefined;
-
-        try {
-          for (var _iterator6 = Object.keys(input || {})[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {
-            var i = _step6.value;
-
-            var compactRecord = input[i];
-            if (i > 0) {
-              record = {};
-              var _iteratorNormalCompletion7 = true;
-              var _didIteratorError7 = false;
-              var _iteratorError7 = undefined;
-
-              try {
-                for (var _iterator7 = Object.keys(input[0] || {})[Symbol.iterator](), _step7; !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true) {
-                  var j = _step7.value;
-
-                  var k = input[0][j];
-                  record[k] = compactRecord[j];
-                }
-              } catch (err) {
-                _didIteratorError7 = true;
-                _iteratorError7 = err;
-              } finally {
-                try {
-                  if (!_iteratorNormalCompletion7 && _iterator7.return) {
-                    _iterator7.return();
-                  }
-                } finally {
-                  if (_didIteratorError7) {
-                    throw _iteratorError7;
-                  }
-                }
-              }
-
-              result.push(addRecord(record));
-            }
-          }
-        } catch (err) {
-          _didIteratorError6 = true;
-          _iteratorError6 = err;
-        } finally {
-          try {
-            if (!_iteratorNormalCompletion6 && _iterator6.return) {
-              _iterator6.return();
-            }
-          } finally {
-            if (_didIteratorError6) {
-              throw _iteratorError6;
-            }
-          }
+      var headers = input[0] || [];
+      for (var i = 1; i < input.length; i += 1) {
+        var compactRecord = input[i];
+        record = {};
+        for (var j = 0; j < headers.length; j += 1) {
+          record[headers[j]] = compactRecord[j];
         }
-
-        return result;
-      }();
+        addRecord(record);
+      }
+      return null;
     }
 
     // array of objects
-    return function () {
-      var result1 = [];
-      var _iteratorNormalCompletion8 = true;
-      var _didIteratorError8 = false;
-      var _iteratorError8 = undefined;
-
-      try {
-        for (var _iterator8 = Array.from(input)[Symbol.iterator](), _step8; !(_iteratorNormalCompletion8 = (_step8 = _iterator8.next()).done); _iteratorNormalCompletion8 = true) {
-          record = _step8.value;
-
-          result1.push(addRecord(record));
-        }
-      } catch (err) {
-        _didIteratorError8 = true;
-        _iteratorError8 = err;
-      } finally {
-        try {
-          if (!_iteratorNormalCompletion8 && _iterator8.return) {
-            _iterator8.return();
-          }
-        } finally {
-          if (_didIteratorError8) {
-            throw _iteratorError8;
-          }
-        }
-      }
-
-      return result1;
-    }();
+    for (var _i = 0; _i < input.length; _i += 1) {
+      addRecord(input[_i]);
+    }
+    return null;
   }
   throw new Error('unknown input format');
 };