@hrforte/react-pivottable 1.0.1 → 2.0.0

package/dist/Utilities.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.PivotData = exports.createSorterByType = exports.detectDataType = exports.builtInSorters = exports.sortAs = exports.getSort = exports.numberFormat = exports.naturalSort = exports.locales = exports.derivers = exports.aggregators = exports.aggregatorTemplates = undefined;
+exports.PivotData = exports.sortersHaveFunctions = exports.createSorterByType = exports.detectDataType = exports.builtInSorters = exports.sortAs = exports.getSort = exports.numberFormat = exports.naturalSort = exports.locales = exports.derivers = exports.aggregators = exports.aggregatorTemplates = undefined;
 
 var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
 
@@ -391,6 +391,25 @@ var usFmtPct = numberFormat({
   suffix: '%'
 });
 
+// Emit a progress callback every N processed records without adding
+// measurable overhead to the per-record loop.
+var RECORD_PROGRESS_BATCH_SIZE = 25000;
+
+// Returns true when the sorters prop itself, or any of its entries, is a
+// function. Function-based sorters cannot be transferred to a Web Worker, so
+// PivotData re-applies them on the main thread after worker hydration.
+var sortersHaveFunctions = function sortersHaveFunctions(sorters) {
+  if (typeof sorters === 'function') {
+    return true;
+  }
+  if (!sorters || (typeof sorters === 'undefined' ? 'undefined' : _typeof(sorters)) !== 'object') {
+    return false;
+  }
+  return Object.keys(sorters).some(function (attr) {
+    return typeof sorters[attr] === 'function';
+  });
+};
+
 var aggregatorTemplates = {
   count: function count() {
     var formatter = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : usFmtInt;
@@ -855,15 +874,103 @@ var PivotData = function () {
     this.allTotal = this.createAggregatorCell([], []);
     this.sorted = false;
 
-    // iterate through input, accumulating data for cells
-    PivotData.forEachRecord(this.props.data, this.props.derivedAttributes, function (record) {
+    if (this.props.precomputedData) {
+      // Results computed by the Web Worker (or any previous pass) are
+      // hydrated instead of re-scanning every record on the main thread.
+      this.hydrateFromPrecomputed(this.props.precomputedData);
+      return;
+    }
+
+    var progressHook = this.props.onRecordProcessed;
+    var recordHandler = function recordHandler(record) {
       if (_this2.filter(record)) {
         _this2.processRecord(record);
       }
-    });
+    };
+    if (typeof progressHook === 'function') {
+      var recordsProcessed = 0;
+      PivotData.forEachRecord(this.props.data, this.props.derivedAttributes, function (record) {
+        recordHandler(record);
+        recordsProcessed++;
+        if (recordsProcessed % RECORD_PROGRESS_BATCH_SIZE === 0) {
+          progressHook(recordsProcessed);
+        }
+      });
+    } else {
+      PivotData.forEachRecord(this.props.data, this.props.derivedAttributes, recordHandler);
+    }
   }
 
+  /*
+   * Rebuilds tree/totals from a serialized PivotData payload (as produced by
+   * `serializePivotData` inside the worker). Aggregated values are final, so
+   * only lightweight stub aggregators with the correct `value()` and
+   * `format()` behavior are created per cell.
+   */
+
+
   _createClass(PivotData, [{
+    key: 'hydrateFromPrecomputed',
+    value: function hydrateFromPrecomputed(precomputed) {
+      var _this3 = 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, [], []);
+      });
+
+      var makeCell = function makeCell(serializedCell) {
+        var values = serializedCell && serializedCell.values || {};
+        var instances = {};
+        _this3.aggregations.forEach(function (agg) {
+          var source = formatSources[agg.key];
+          var _value = values[agg.key];
+          instances[agg.key] = {
+            push: function push() {},
+            value: function value() {
+              return _value;
+            },
+            format: function format(x) {
+              return source.format(x);
+            },
+
+            numInputs: source.numInputs,
+            outlet: source.outlet
+          };
+        });
+        return new AggregatorCell(instances, _this3.primaryAggregation.key);
+      };
+
+      var hydrateTotals = function hydrateTotals(source, target) {
+        Object.keys(source || {}).forEach(function (flatKey) {
+          target[flatKey] = makeCell(source[flatKey]);
+        });
+      };
+
+      this.rowKeys = (precomputed.rowKeys || []).map(function (key) {
+        return key.slice();
+      });
+      this.colKeys = (precomputed.colKeys || []).map(function (key) {
+        return key.slice();
+      });
+      this.rowTotals = {};
+      hydrateTotals(precomputed.rowTotals, this.rowTotals);
+      this.colTotals = {};
+      hydrateTotals(precomputed.colTotals, this.colTotals);
+      this.tree = {};
+      Object.keys(precomputed.tree || {}).forEach(function (flatRowKey) {
+        _this3.tree[flatRowKey] = {};
+        hydrateTotals(precomputed.tree[flatRowKey], _this3.tree[flatRowKey]);
+      });
+      this.allTotal = makeCell(precomputed.allTotal);
+
+      // Keys were already sorted inside the worker; only re-sort on the main
+      // thread when a sorter could not cross the worker boundary (functions).
+      this.sorted = !sortersHaveFunctions(this.props.sorters);
+    }
+  }, {
     key: 'filter',
     value: function filter(record) {
       for (var k in this.props.valueFilter) {
@@ -876,10 +983,10 @@ var PivotData = function () {
   }, {
     key: 'forEachMatchingRecord',
     value: function forEachMatchingRecord(criteria, callback) {
-      var _this3 = this;
+      var _this4 = this;
 
       return PivotData.forEachRecord(this.props.data, this.props.derivedAttributes, function (record) {
-        if (!_this3.filter(record)) {
+        if (!_this4.filter(record)) {
           return;
         }
         for (var k in criteria) {
@@ -894,7 +1001,7 @@ var PivotData = function () {
   }, {
     key: 'arrSort',
     value: function arrSort(attrs) {
-      var _this4 = this;
+      var _this5 = this;
 
       var a = void 0;
       var sortersArr = function () {
@@ -907,7 +1014,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(_this4.props.sorters, a));
+            result.push(getSort(_this5.props.sorters, a));
           }
         } catch (err) {
           _didIteratorError2 = true;
@@ -962,12 +1069,12 @@ var PivotData = function () {
   }, {
     key: 'sortKeys',
     value: function sortKeys() {
-      var _this5 = this;
+      var _this6 = this;
 
       if (!this.sorted) {
         this.sorted = true;
         var v = function v(r, c) {
-          return _this5.getAggregator(r, c).value();
+          return _this6.getAggregator(r, c).value();
         };
 
         // Handle per-row sorting
@@ -975,11 +1082,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 < _this5.props.rows.length; i++) {
-              var attr = _this5.props.rows[i];
+            for (var i = 0; i < _this6.props.rows.length; i++) {
+              var attr = _this6.props.rows[i];
               if (attr && rowSorts[attr]) {
                 var sortDir = rowSorts[attr] === 'ASC' ? 1 : -1;
-                var sorter = getSort(_this5.props.sorters, attr);
+                var sorter = getSort(_this6.props.sorters, attr);
                 var comparison = sorter(a[i] || '', b[i] || '');
                 if (comparison !== 0) {
                   return sortDir * comparison;
@@ -987,7 +1094,7 @@ var PivotData = function () {
               }
             }
             // If sorted attributes are equal, use default sorting for remaining attributes
-            return _this5.arrSort(_this5.props.rows)(a, b);
+            return _this6.arrSort(_this6.props.rows)(a, b);
           });
         } else {
           // Use global row order
@@ -1012,11 +1119,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 < _this5.props.cols.length; i++) {
-              var attr = _this5.props.cols[i];
+            for (var i = 0; i < _this6.props.cols.length; i++) {
+              var attr = _this6.props.cols[i];
               if (attr && colSorts[attr]) {
                 var sortDir = colSorts[attr] === 'ASC' ? 1 : -1;
-                var sorter = getSort(_this5.props.sorters, attr);
+                var sorter = getSort(_this6.props.sorters, attr);
                 var comparison = sorter(a[i] || '', b[i] || '');
                 if (comparison !== 0) {
                   return sortDir * comparison;
@@ -1024,7 +1131,7 @@ var PivotData = function () {
               }
             }
             // If sorted attributes are equal, use default sorting for remaining attributes
-            return _this5.arrSort(_this5.props.cols)(a, b);
+            return _this6.arrSort(_this6.props.cols)(a, b);
           });
         } else {
           // Use global col order
@@ -1268,25 +1375,25 @@ var PivotData = function () {
   }, {
     key: 'buildAggregatorFactories',
     value: function buildAggregatorFactories() {
-      var _this6 = this;
+      var _this7 = this;
 
       var factories = {};
       this.aggregations.forEach(function (agg) {
-        if (!(agg.aggregatorName in _this6.props.aggregators)) {
+        if (!(agg.aggregatorName in _this7.props.aggregators)) {
           throw new Error('unknown aggregator ' + agg.aggregatorName);
         }
-        factories[agg.key] = _this6.props.aggregators[agg.aggregatorName](agg.vals);
+        factories[agg.key] = _this7.props.aggregators[agg.aggregatorName](agg.vals);
       });
       return factories;
     }
   }, {
     key: 'createAggregatorCell',
     value: function createAggregatorCell(rowKey, colKey) {
-      var _this7 = this;
+      var _this8 = this;
 
       var instances = {};
       this.aggregations.forEach(function (agg) {
-        instances[agg.key] = _this7.aggregatorFactories[agg.key](_this7, rowKey, colKey);
+        instances[agg.key] = _this8.aggregatorFactories[agg.key](_this8, rowKey, colKey);
       });
       return new AggregatorCell(instances, this.primaryAggregation.key);
     }
@@ -1453,8 +1560,10 @@ PivotData.propTypes = {
   rows: _propTypes2.default.arrayOf(_propTypes2.default.string),
   vals: _propTypes2.default.arrayOf(_propTypes2.default.string),
   valueFilter: _propTypes2.default.objectOf(_propTypes2.default.objectOf(_propTypes2.default.bool)),
-  sorters: _propTypes2.default.oneOfType([_propTypes2.default.func, _propTypes2.default.objectOf(_propTypes2.default.func)]),
+  sorters: _propTypes2.default.oneOfType([_propTypes2.default.func, _propTypes2.default.objectOf(_propTypes2.default.oneOfType([_propTypes2.default.func, _propTypes2.default.string, _propTypes2.default.array]))]),
   derivedAttributes: _propTypes2.default.objectOf(_propTypes2.default.func),
+  precomputedData: _propTypes2.default.object,
+  onRecordProcessed: _propTypes2.default.func,
   rowOrder: _propTypes2.default.oneOf(['key_a_to_z', 'value_a_to_z', 'value_z_to_a']),
   colOrder: _propTypes2.default.oneOf(['key_a_to_z', 'value_a_to_z', 'value_z_to_a']),
   rowSorts: _propTypes2.default.objectOf(_propTypes2.default.oneOf(['ASC', 'DESC'])),
@@ -1472,5 +1581,6 @@ exports.sortAs = sortAs;
 exports.builtInSorters = builtInSorters;
 exports.detectDataType = detectDataType;
 exports.createSorterByType = createSorterByType;
+exports.sortersHaveFunctions = sortersHaveFunctions;
 exports.PivotData = PivotData;
 //# sourceMappingURL=Utilities.js.map