Transform react

src/components/colorscale/calc.js

@@ -16,24 +16,47 @@ var flipScale = require('./flip_scale');
 
 
 module.exports = function calc(trace, vals, containerStr, cLetter) {
-    var container, inputContainer;
+    var container = trace;
+    var inputContainer = trace._input;
+    var fullInputContainer = trace._fullInput;
+
+    // set by traces with groupby transforms
+    var updateStyle = trace.updateStyle;
+
+    function doUpdate(attr, inputVal, fullVal) {
+        if(fullVal === undefined) fullVal = inputVal;
+
+        if(updateStyle) {
+            updateStyle(trace._input, containerStr ? (containerStr + '.' + attr) : attr, inputVal);
+        }
+        else {
+            inputContainer[attr] = inputVal;
+        }
+
+        container[attr] = fullVal;
+        if(fullInputContainer && (trace !== trace._fullInput)) {
+            if(updateStyle) {
+                updateStyle(trace._fullInput, containerStr ? (containerStr + '.' + attr) : attr, fullVal);
+            }
+            else {
+                fullInputContainer[attr] = fullVal;
+            }
+        }
+    }
 
     if(containerStr) {
-        container = Lib.nestedProperty(trace, containerStr).get();
-        inputContainer = Lib.nestedProperty(trace._input, containerStr).get();
-    }
-    else {
-        container = trace;
-        inputContainer = trace._input;
+        container = Lib.nestedProperty(container, containerStr).get();
+        inputContainer = Lib.nestedProperty(inputContainer, containerStr).get();
+        fullInputContainer = Lib.nestedProperty(fullInputContainer, containerStr).get() || {};
     }
 
-    var autoAttr = cLetter + 'auto',
-        minAttr = cLetter + 'min',
-        maxAttr = cLetter + 'max',
-        auto = container[autoAttr],
-        min = container[minAttr],
-        max = container[maxAttr],
-        scl = container.colorscale;
+    var autoAttr = cLetter + 'auto';
+    var minAttr = cLetter + 'min';
+    var maxAttr = cLetter + 'max';
+    var auto = container[autoAttr];
+    var min = container[minAttr];
+    var max = container[maxAttr];
+    var scl = container.colorscale;
 
     if(auto !== false || min === undefined) {
         min = Lib.aggNums(Math.min, null, vals);
@@ -48,11 +71,8 @@ module.exports = function calc(trace, vals, containerStr, cLetter) {
         max += 0.5;
     }
 
-    container[minAttr] = min;
-    container[maxAttr] = max;
-
-    inputContainer[minAttr] = min;
-    inputContainer[maxAttr] = max;
+    doUpdate(minAttr, min);
+    doUpdate(maxAttr, max);
 
     /*
      * If auto was explicitly false but min or max was missing,
@@ -61,17 +81,22 @@ module.exports = function calc(trace, vals, containerStr, cLetter) {
      * Otherwise make sure the trace still looks auto as far as later
      * changes are concerned.
      */
-    inputContainer[autoAttr] = (auto !== false ||
-        (min === undefined && max === undefined));
+    doUpdate(autoAttr, (auto !== false || (min === undefined && max === undefined)));
 
     if(container.autocolorscale) {
         if(min * max < 0) scl = scales.RdBu;
         else if(min >= 0) scl = scales.Reds;
         else scl = scales.Blues;
 
         // reversescale is handled at the containerOut level
-        inputContainer.colorscale = scl;
-        if(container.reversescale) scl = flipScale(scl);
-        container.colorscale = scl;
+        doUpdate('colorscale', scl, container.reversescale ? flipScale(scl) : scl);
+
+        // We pushed a colorscale back to input, which will change the default autocolorscale next time
+        // to avoid spurious redraws from Plotly.react, update resulting autocolorscale now
+        // This is a conscious decision so that changing the data later does not unexpectedly
+        // give you a new colorscale
+        if(!inputContainer.autocolorscale) {
+            doUpdate('autocolorscale', false);
+        }
     }
 };

src/traces/contour/set_contours.js

@@ -10,24 +10,30 @@
 'use strict';
 
 var Axes = require('../../plots/cartesian/axes');
-var extendFlat = require('../../lib').extendFlat;
+var Lib = require('../../lib');
 
 
 module.exports = function setContours(trace) {
     var contours = trace.contours;
 
     // check if we need to auto-choose contour levels
     if(trace.autocontour) {
-        var dummyAx = autoContours(trace.zmin, trace.zmax, trace.ncontours);
+        var zmin = trace.zmin;
+        var zmax = trace.zmax;
+        if(zmin === undefined || zmax === undefined) {
+            zmin = Lib.aggNums(Math.min, null, trace._z);
+            zmax = Lib.aggNums(Math.max, null, trace._z);
+        }
+        var dummyAx = autoContours(zmin, zmax, trace.ncontours);
 
         contours.size = dummyAx.dtick;
 
         contours.start = Axes.tickFirst(dummyAx);
         dummyAx.range.reverse();
         contours.end = Axes.tickFirst(dummyAx);
 
-        if(contours.start === trace.zmin) contours.start += contours.size;
-        if(contours.end === trace.zmax) contours.end -= contours.size;
+        if(contours.start === zmin) contours.start += contours.size;
+        if(contours.end === zmax) contours.end -= contours.size;
 
         // if you set a small ncontours, *and* the ends are exactly on zmin/zmax
         // there's an edge case where start > end now. Make sure there's at least
@@ -40,7 +46,7 @@ module.exports = function setContours(trace) {
         // previously we copied the whole contours object back, but that had
         // other info (coloring, showlines) that should be left to supplyDefaults
         if(!trace._input.contours) trace._input.contours = {};
-        extendFlat(trace._input.contours, {
+        Lib.extendFlat(trace._input.contours, {
             start: contours.start,
             end: contours.end,
             size: contours.size

src/traces/contourcarpet/calc.js

@@ -99,7 +99,7 @@ function heatmappishCalc(gd, trace) {
         z: z,
     };
 
-    if(trace.contours.type === 'levels') {
+    if(trace.contours.type === 'levels' && trace.contours.coloring !== 'none') {
         // auto-z and autocolorscale if applicable
         colorscaleCalc(trace, z, '', 'z');
     }

src/transforms/groupby.js

@@ -161,7 +161,8 @@ function transformOne(trace, state) {
     var groupNameObj;
 
     var opts = state.transform;
-    var groups = trace.transforms[state.transformIndex].groups;
+    var transformIndex = state.transformIndex;
+    var groups = trace.transforms[transformIndex].groups;
     var originalPointsAccessor = pointsAccessorFunction(trace.transforms, opts);
 
     if(!(Array.isArray(groups)) || groups.length === 0) {
@@ -196,7 +197,10 @@ function transformOne(trace, state) {
         // Start with a deep extend that just copies array references.
         newTrace = newData[i] = Lib.extendDeepNoArrays({}, trace);
         newTrace._group = groupName;
-        newTrace.transforms[state.transformIndex]._indexToPoints = {};
+        // helper function for when we need to push updates back to the input,
+        // outside of the normal restyle/relayout pathway, like filling in auto values
+        newTrace.updateStyle = styleUpdater(groupName, transformIndex);
+        newTrace.transforms[transformIndex]._indexToPoints = {};
 
         var suppliedName = null;
         if(groupNameObj) {
@@ -254,7 +258,7 @@ function transformOne(trace, state) {
     for(j = 0; j < len; j++) {
         newTrace = newData[indexLookup[groups[j]]];
 
-        var indexToPoints = newTrace.transforms[state.transformIndex]._indexToPoints;
+        var indexToPoints = newTrace.transforms[transformIndex]._indexToPoints;
         indexToPoints[indexCnts[groups[j]]] = originalPointsAccessor(j);
         indexCnts[groups[j]]++;
     }
@@ -272,3 +276,14 @@ function transformOne(trace, state) {
 
     return newData;
 }
+
+function styleUpdater(groupName, transformIndex) {
+    return function(trace, attr, value) {
+        Lib.keyedContainer(
+            trace,
+            'transforms[' + transformIndex + '].styles',
+            'target',
+            'value.' + attr
+        ).set(String(groupName), value);
+    };
+}

test/jasmine/tests/colorscale_test.js

@@ -364,20 +364,33 @@ describe('Test colorscale:', function() {
                 type: 'heatmap',
                 z: [[0, -1.5], [-2, -10]],
                 autocolorscale: true,
-                _input: {}
+                _input: {autocolorscale: true}
             };
             z = [[0, -1.5], [-2, -10]];
             calcColorscale(trace, z, '', 'z');
             expect(trace.autocolorscale).toBe(true);
             expect(trace.colorscale[5]).toEqual([1, 'rgb(220,220,220)']);
         });
 
+        it('should set autocolorscale to false if it wasn\'t explicitly set true in input', function() {
+            trace = {
+                type: 'heatmap',
+                z: [[0, -1.5], [-2, -10]],
+                autocolorscale: true,
+                _input: {}
+            };
+            z = [[0, -1.5], [-2, -10]];
+            calcColorscale(trace, z, '', 'z');
+            expect(trace.autocolorscale).toBe(false);
+            expect(trace.colorscale[5]).toEqual([1, 'rgb(220,220,220)']);
+        });
+
         it('should be Blues when the only numerical z <= -0.5', function() {
             trace = {
                 type: 'heatmap',
                 z: [['a', 'b'], [-0.5, 'd']],
                 autocolorscale: true,
-                _input: {}
+                _input: {autocolorscale: true}
             };
             z = [[undefined, undefined], [-0.5, undefined]];
             calcColorscale(trace, z, '', 'z');
@@ -390,7 +403,7 @@ describe('Test colorscale:', function() {
                 type: 'heatmap',
                 z: [['a', 'b'], [0.5, 'd']],
                 autocolorscale: true,
-                _input: {}
+                _input: {autocolorscale: true}
             };
             z = [[undefined, undefined], [0.5, undefined]];
             calcColorscale(trace, z, '', 'z');
@@ -404,7 +417,7 @@ describe('Test colorscale:', function() {
                 z: [['a', 'b'], [0.5, 'd']],
                 autocolorscale: true,
                 reversescale: true,
-                _input: {}
+                _input: {autocolorscale: true}
             };
             z = [[undefined, undefined], [0.5, undefined]];
             calcColorscale(trace, z, '', 'z');