Transform react

src/plot_api/plot_api.js

@@ -2267,7 +2267,10 @@ exports.react = function(gd, data, layout, config) {
         gd.layout = layout || {};
         helpers.cleanLayout(gd.layout);
 
-        Plots.supplyDefaults(gd);
+        // "true" skips updating calcdata and remapping arrays from calcTransforms,
+        // which supplyDefaults usually does at the end, but we may need to NOT do
+        // if the diff (which we haven't determined yet) says we'll recalc
+        Plots.supplyDefaults(gd, true);
 
         var newFullData = gd._fullData;
         var newFullLayout = gd._fullLayout;
@@ -2289,6 +2292,9 @@ exports.react = function(gd, data, layout, config) {
 
         // clear calcdata if required
         if(restyleFlags.calc || relayoutFlags.calc) gd.calcdata = undefined;
+        // otherwise do the calcdata updates and calcTransform array remaps that we skipped earlier
+        else Plots.supplyDefaultsUpdateCalc(gd.calcdata, newFullData);
+
         if(relayoutFlags.margins) helpers.clearAxisAutomargins(gd);
 
         // Note: what restyle/relayout use impliedEdits and clearAxisTypes for

src/plot_api/plot_schema.js

@@ -171,9 +171,12 @@ exports.isValObject = function(obj) {
 exports.findArrayAttributes = function(trace) {
     var arrayAttributes = [];
     var stack = [];
+    var isArrayStack = [];
+    var baseContainer, baseAttrName;
 
     function callback(attr, attrName, attrs, level) {
         stack = stack.slice(0, level).concat([attrName]);
+        isArrayStack = isArrayStack.slice(0, level).concat([attr && attr._isLinkedToArray]);
 
         var splittableAttr = (
             attr &&
@@ -190,33 +193,51 @@ exports.findArrayAttributes = function(trace) {
 
         if(!splittableAttr) return;
 
-        var astr = toAttrString(stack);
-        var val = Lib.nestedProperty(trace, astr).get();
-        if(!Lib.isArrayOrTypedArray(val)) return;
-
-        arrayAttributes.push(astr);
+        crawlIntoTrace(baseContainer, 0, '');
     }
 
-    function toAttrString(stack) {
-        return stack.join('.');
+    function crawlIntoTrace(container, i, astrPartial) {
+        var item = container[stack[i]];
+        var newAstrPartial = astrPartial + stack[i];
+        if(i === stack.length - 1) {
+            if(Lib.isArrayOrTypedArray(item)) {
+                arrayAttributes.push(baseAttrName + newAstrPartial);
+            }
+        }
+        else {
+            if(isArrayStack[i]) {
+                if(Array.isArray(item)) {
+                    for(var j = 0; j < item.length; j++) {
+                        if(Lib.isPlainObject(item[j])) {
+                            crawlIntoTrace(item[j], i + 1, newAstrPartial + '[' + j + '].');
+                        }
+                    }
+                }
+            }
+            else if(Lib.isPlainObject(item)) {
+                crawlIntoTrace(item, i + 1, newAstrPartial + '.');
+            }
+        }
     }
 
+    baseContainer = trace;
+    baseAttrName = '';
     exports.crawl(baseAttributes, callback);
     if(trace._module && trace._module.attributes) {
         exports.crawl(trace._module.attributes, callback);
     }
 
-    if(trace.transforms) {
-        var transforms = trace.transforms;
-
+    var transforms = trace.transforms;
+    if(transforms) {
         for(var i = 0; i < transforms.length; i++) {
             var transform = transforms[i];
             var module = transform._module;
 
             if(module) {
-                stack = ['transforms[' + i + ']'];
+                baseAttrName = 'transforms[' + i + '].';
+                baseContainer = transform;
 
-                exports.crawl(module.attributes, callback, 1);
+                exports.crawl(module.attributes, callback);
             }
         }
     }

src/plots/plots.js

@@ -274,7 +274,7 @@ var extraFormatKeys = [
 // gd._fullLayout._transformModules
 //   is a list of all the transform modules invoked.
 //
-plots.supplyDefaults = function(gd) {
+plots.supplyDefaults = function(gd, skipCalcUpdate) {
     var oldFullLayout = gd._fullLayout || {};
 
     if(oldFullLayout._skipDefaults) {
@@ -458,24 +458,28 @@ plots.supplyDefaults = function(gd) {
     }
 
     // update object references in calcdata
-    if(oldCalcdata.length === newFullData.length) {
-        for(i = 0; i < newFullData.length; i++) {
-            var newTrace = newFullData[i];
-            var cd0 = oldCalcdata[i][0];
-            if(cd0 && cd0.trace) {
-                if(cd0.trace._hasCalcTransform) {
-                    remapTransformedArrays(cd0, newTrace);
-                } else {
-                    cd0.trace = newTrace;
-                }
-            }
-        }
+    if(!skipCalcUpdate && oldCalcdata.length === newFullData.length) {
+        plots.supplyDefaultsUpdateCalc(oldCalcdata, newFullData);
     }
 
     // sort base plot modules for consistent ordering
     newFullLayout._basePlotModules.sort(sortBasePlotModules);
 };
 
+plots.supplyDefaultsUpdateCalc = function(oldCalcdata, newFullData) {
+    for(var i = 0; i < newFullData.length; i++) {
+        var newTrace = newFullData[i];
+        var cd0 = oldCalcdata[i][0];
+        if(cd0 && cd0.trace) {
+            if(cd0.trace._hasCalcTransform) {
+                remapTransformedArrays(cd0, newTrace);
+            } else {
+                cd0.trace = newTrace;
+            }
+        }
+    }
+};
+
 /**
  * Make a container for collecting subplots we need to display.
  *

src/transforms/aggregate.js

@@ -254,6 +254,8 @@ exports.calcTransform = function(gd, trace, opts) {
             enabled: true
         });
     }
+
+    trace._length = groupings.length;
 };
 
 function aggregateOneArray(gd, trace, groupings, aggregation) {

test/jasmine/tests/plot_api_test.js

@@ -2955,6 +2955,190 @@ describe('Test plot api', function() {
             .then(done);
         });
 
+        function aggregatedPie(i) {
+            var labels = i <= 1 ?
+                ['A', 'B', 'A', 'C', 'A', 'B', 'C', 'A', 'B', 'C', 'A'] :
+                ['X', 'Y', 'Z', 'Z', 'Y', 'Z', 'X', 'Z', 'Y', 'Z', 'X'];
+            var trace = {
+                type: 'pie',
+                values: [4, 1, 4, 4, 1, 4, 4, 2, 1, 1, 15],
+                labels: labels,
+                transforms: [{
+                    type: 'aggregate',
+                    groups: labels,
+                    aggregations: [{target: 'values', func: 'sum'}]
+                }]
+            };
+            return {
+                data: [trace],
+                layout: {
+                    datarevision: i,
+                    colorway: ['red', 'orange', 'yellow', 'green', 'blue', 'violet']
+                }
+            };
+        }
+
+        var aggPie1CD = [[
+            {v: 26, label: 'A', color: 'red', i: 0},
+            {v: 9, label: 'C', color: 'orange', i: 2},
+            {v: 6, label: 'B', color: 'yellow', i: 1}
+        ]];
+
+        var aggPie2CD = [[
+            {v: 23, label: 'X', color: 'red', i: 0},
+            {v: 15, label: 'Z', color: 'orange', i: 2},
+            {v: 3, label: 'Y', color: 'yellow', i: 1}
+        ]];
+
+        function aggregatedScatter(i) {
+            return {
+                data: [{
+                    x: [1, 2, 3, 4, 6, 5],
+                    y: [2, 1, 3, 5, 6, 4],
+                    transforms: [{
+                        type: 'aggregate',
+                        groups: [1, -1, 1, -1, 1, -1],
+                        aggregations: i > 1 ? [{func: 'last', target: 'x'}] : []
+                    }]
+                }],
+                layout: {daterevision: i + 10}
+            };
+        }
+
+        var aggScatter1CD = [[
+            {x: 1, y: 2, i: 0},
+            {x: 2, y: 1, i: 1}
+        ]];
+
+        var aggScatter2CD = [[
+            {x: 6, y: 2, i: 0},
+            {x: 5, y: 1, i: 1}
+        ]];
+
+        function aggregatedParcoords(i) {
+            return {
+                data: [{
+                    type: 'parcoords',
+                    dimensions: [
+                        {label: 'A', values: [1, 2, 3, 4]},
+                        {label: 'B', values: [4, 3, 2, 1]}
+                    ],
+                    transforms: i ? [{
+                        type: 'aggregate',
+                        groups: [1, 2, 1, 2],
+                        aggregations: [
+                            {target: 'dimensions[0].values', func: i > 1 ? 'avg' : 'first'},
+                            {target: 'dimensions[1].values', func: i > 1 ? 'first' : 'avg'}
+                        ]
+                    }] :
+                    []
+                }]
+            };
+        }
+
+        var aggParcoords0Vals = [[1, 2, 3, 4], [4, 3, 2, 1]];
+        var aggParcoords1Vals = [[1, 2], [3, 2]];
+        var aggParcoords2Vals = [[2, 3], [4, 3]];
+
+        function checkCalcData(expectedCD) {
+            return function() {
+                expect(gd.calcdata.length).toBe(expectedCD.length);
+                expectedCD.forEach(function(expectedCDi, i) {
+                    var cdi = gd.calcdata[i];
+                    expect(cdi.length).toBe(expectedCDi.length, i);
+                    expectedCDi.forEach(function(expectedij, j) {
+                        expect(cdi[j]).toEqual(jasmine.objectContaining(expectedij));
+                    });
+                });
+            };
+        }
+
+        function checkValues(expectedVals) {
+            return function() {
+                expect(gd._fullData.length).toBe(1);
+                var dims = gd._fullData[0].dimensions;
+                expect(dims.length).toBe(expectedVals.length);
+                expectedVals.forEach(function(expected, i) {
+                    expect(dims[i].values).toEqual(expected);
+                });
+            };
+        }
+
+        function reactWith(fig) {
+            return function() { return Plotly.react(gd, fig); };
+        }
+
+        it('can change pie aggregations', function(done) {
+            Plotly.newPlot(gd, aggregatedPie(1))
+            .then(checkCalcData(aggPie1CD))
+
+            .then(reactWith(aggregatedPie(2)))
+            .then(checkCalcData(aggPie2CD))
+
+            .then(reactWith(aggregatedPie(1)))
+            .then(checkCalcData(aggPie1CD))
+            .catch(failTest)
+            .then(done);
+        });
+
+        it('can change scatter aggregations', function(done) {
+            Plotly.newPlot(gd, aggregatedScatter(1))
+            .then(checkCalcData(aggScatter1CD))
+
+            .then(reactWith(aggregatedScatter(2)))
+            .then(checkCalcData(aggScatter2CD))
+
+            .then(reactWith(aggregatedScatter(1)))
+            .then(checkCalcData(aggScatter1CD))
+            .catch(failTest)
+            .then(done);
+        });
+
+        it('can change parcoords aggregations', function(done) {
+            Plotly.newPlot(gd, aggregatedParcoords(0))
+            .then(checkValues(aggParcoords0Vals))
+
+            .then(reactWith(aggregatedParcoords(1)))
+            .then(checkValues(aggParcoords1Vals))
+
+            .then(reactWith(aggregatedParcoords(2)))
+            .then(checkValues(aggParcoords2Vals))
+
+            .then(reactWith(aggregatedParcoords(0)))
+            .then(checkValues(aggParcoords0Vals))
+
+            .catch(failTest)
+            .then(done);
+        });
+
+        it('can change type with aggregations', function(done) {
+            Plotly.newPlot(gd, aggregatedScatter(1))
+            .then(checkCalcData(aggScatter1CD))
+
+            .then(reactWith(aggregatedPie(1)))
+            .then(checkCalcData(aggPie1CD))
+
+            .then(reactWith(aggregatedParcoords(1)))
+            .then(checkValues(aggParcoords1Vals))
+
+            .then(reactWith(aggregatedScatter(1)))
+            .then(checkCalcData(aggScatter1CD))
+
+            .then(reactWith(aggregatedParcoords(2)))
+            .then(checkValues(aggParcoords2Vals))
+
+            .then(reactWith(aggregatedPie(2)))
+            .then(checkCalcData(aggPie2CD))
+
+            .then(reactWith(aggregatedScatter(2)))
+            .then(checkCalcData(aggScatter2CD))
+
+            .then(reactWith(aggregatedParcoords(0)))
+            .then(checkValues(aggParcoords0Vals))
+            .catch(failTest)
+            .then(done);
+        });
+
         it('can change frames without redrawing', function(done) {
             var data = [{y: [1, 2, 3]}];
             var layout = {};