fix and 🔒 bug with impliedEdits and groupby transform

Author: alexcjohnson

src/plot_api/plot_api.js

@@ -1420,6 +1420,16 @@ function _restyle(gd, aobj, traces) {
 
     function rangeAttr(axName) { return 'LAYOUT' + axName + '.range'; }
 
+    function getFullTrace(traceIndex) {
+        // usually fullData maps 1:1 onto data, but with groupby transforms
+        // the fullData index can be greater. Take the *first* matching trace.
+        for(var j = traceIndex; j < fullData.length; j++) {
+            if(fullData[j]._input === data[traceIndex]) return fullData[j];
+        }
+        // should never get here - and if we *do* it should cause an error
+        // later on undefined fullTrace is passed to nestedProperty.
+    }
+
     // for attrs that interact (like scales & autoscales), save the
     // old vals before making the change
     // val=undefined will not set a value, just record what the value was.
@@ -1507,7 +1517,7 @@ function _restyle(gd, aobj, traces) {
         undoit[ai] = a0();
         for(i = 0; i < traces.length; i++) {
             cont = data[traces[i]];
-            contFull = fullData[traces[i]];
+            contFull = getFullTrace(traces[i]);
             param = Lib.nestedProperty(cont, ai);
             oldVal = param.get();
             newVal = Array.isArray(vi) ? vi[i % vi.length] : vi;

test/jasmine/tests/plot_api_test.js

@@ -1266,28 +1266,52 @@ describe('Test plot api', function() {
             .then(done);
         });
 
-        it('sets x/ytype scaled when editing heatmap x0/dx/y0/dy', function(done) {
-            var x0 = 3;
-            var dy = 5;
-
-            function check(scaled, msg) {
-                expect(gd.data[0].x0).negateIf(!scaled).toBe(x0, msg);
-                expect(gd.data[0].xtype).toBe(scaled ? 'scaled' : undefined, msg);
-                expect(gd.data[0].dy).negateIf(!scaled).toBe(dy, msg);
-                expect(gd.data[0].ytype).toBe(scaled ? 'scaled' : undefined, msg);
-            }
+        function checkScaling(xyType, xyTypeIn, iIn, iOut) {
+            expect(gd._fullData[iOut].xtype).toBe(xyType);
+            expect(gd._fullData[iOut].ytype).toBe(xyType);
+            expect(gd.data[iIn].xtype).toBe(xyTypeIn);
+            expect(gd.data[iIn].ytype).toBe(xyTypeIn);
+        }
 
-            Plotly.plot(gd, [{x: [1, 2, 4], y: [2, 3, 5], z: [[1, 2], [3, 4]], type: 'heatmap'}])
+        it('sets heatmap xtype/ytype when you edit x/y data or scaling params', function(done) {
+            Plotly.plot(gd, [{type: 'heatmap', z: [[0, 1], [2, 3]]}])
             .then(function() {
-                check(false, 'initial');
-                return Plotly.restyle(gd, {x0: x0, dy: dy});
+                // TODO would probably be better to actively default to 'array' here...
+                checkScaling(undefined, undefined, 0, 0);
+                return Plotly.restyle(gd, {x: [[2, 4]], y: [[3, 5]]}, [0]);
             })
             .then(function() {
-                check(true, 'set x0 & dy');
-                return Queue.undo(gd);
+                checkScaling('array', 'array', 0, 0);
+                return Plotly.restyle(gd, {x0: 1, dy: 3}, [0]);
             })
             .then(function() {
-                check(false, 'undo');
+                checkScaling('scaled', 'scaled', 0, 0);
+            })
+            .catch(failTest)
+            .then(done);
+        });
+
+        it('sets heatmap xtype/ytype even when data/fullData indices mismatch', function(done) {
+            Plotly.plot(gd, [
+                {
+                    // importantly, this is NOT a heatmap trace, so _fullData[1]
+                    // will not have the same attributes as data[1]
+                    x: [1, -1, -2, 0],
+                    y: [1, 2, 3, 1],
+                    transforms: [{type: 'groupby', groups: ['a', 'b', 'a', 'b']}]
+                },
+                {type: 'heatmap', z: [[0, 1], [2, 3]]}
+            ])
+            .then(function() {
+                checkScaling(undefined, undefined, 1, 2);
+                return Plotly.restyle(gd, {x: [[2, 4]], y: [[3, 5]]}, [1]);
+            })
+            .then(function() {
+                checkScaling('array', 'array', 1, 2);
+                return Plotly.restyle(gd, {x0: 1, dy: 3}, [1]);
+            })
+            .then(function() {
+                checkScaling('scaled', 'scaled', 1, 2);
             })
             .catch(failTest)
             .then(done);