Transform react

src/traces/histogram/defaults.js

@@ -24,8 +24,6 @@ module.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout
 
     var x = coerce('x');
     var y = coerce('y');
-    var hasX = x && x.length;
-    var hasY = y && y.length;
 
     var cumulative = coerce('cumulative.enabled');
     if(cumulative) {
@@ -35,12 +33,11 @@ module.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout
 
     coerce('text');
 
-    var orientation = coerce('orientation', (hasY && !hasX) ? 'h' : 'v');
+    var orientation = coerce('orientation', (y && !x) ? 'h' : 'v');
     var sampleLetter = orientation === 'v' ? 'x' : 'y';
     var aggLetter = orientation === 'v' ? 'y' : 'x';
-    var sample = traceOut[sampleLetter];
 
-    var len = (hasX && hasY) ? Math.min(x.length && y.length) : (sample || []).length;
+    var len = (x && y) ? Math.min(x.length && y.length) : (traceOut[sampleLetter] || []).length;
 
     if(!len) {
         traceOut.visible = false;

src/traces/pie/defaults.js

@@ -21,9 +21,9 @@ module.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout
     var len;
 
     var vals = coerce('values');
-    var hasVals = Lib.isArrayOrTypedArray(vals) && vals.length;
+    var hasVals = Lib.isArrayOrTypedArray(vals);
     var labels = coerce('labels');
-    if(Array.isArray(labels) && labels.length) {
+    if(Array.isArray(labels)) {
         len = labels.length;
         if(hasVals) len = Math.min(len, vals.length);
     }
@@ -39,6 +39,11 @@ module.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout
         coerce('label0');
         coerce('dlabel');
     }
+
+    if(!len) {
+        traceOut.visible = false;
+        return;
+    }
     traceOut._length = len;
 
     var lineWidth = coerce('marker.line.width');

test/jasmine/tests/bar_test.js

@@ -74,6 +74,23 @@ describe('Bar.supplyDefaults', function() {
         expect(traceOut.visible).toBe(false);
     });
 
+    [{letter: 'y', counter: 'x'}, {letter: 'x', counter: 'y'}].forEach(function(spec) {
+        var l = spec.letter;
+        var c = spec.counter;
+        var c0 = c + '0';
+        var dc = 'd' + c;
+        it('should be visible using ' + c0 + '/' + dc + ' if ' + c + ' is missing completely but ' + l + ' is present', function() {
+            traceIn = {};
+            traceIn[l] = [1, 2];
+            supplyDefaults(traceIn, traceOut, defaultColor, {});
+            expect(traceOut.visible).toBe(undefined, l); // visible: true gets set above the module level
+            expect(traceOut._length).toBe(2, l);
+            expect(traceOut[c0]).toBe(0, c0);
+            expect(traceOut[dc]).toBe(1, dc);
+            expect(traceOut.orientation).toBe(l === 'x' ? 'h' : 'v', l);
+        });
+    });
+
     it('should not set base, offset or width', function() {
         traceIn = {
             y: [1, 2, 3]

test/jasmine/tests/finance_test.js

@@ -141,7 +141,7 @@ describe('finance charts defaults:', function() {
         expect(out._fullData[1]._fullInput.x).toBeDefined();
     });
 
-    it('should set visible to *false* when minimum supplied length is 0', function() {
+    it('should set visible to *false* when a component (other than x) is missing', function() {
         var trace0 = Lib.extendDeep({}, mock0, { type: 'ohlc' });
         trace0.close = undefined;
 
@@ -160,6 +160,17 @@ describe('finance charts defaults:', function() {
         expect(visibilities).toEqual([false, false]);
     });
 
+    it('should return visible: false if any data component is empty', function() {
+        ['ohlc', 'candlestick'].forEach(function(type) {
+            ['open', 'high', 'low', 'close', 'x'].forEach(function(attr) {
+                var trace = Lib.extendDeep({}, mock1, {type: type});
+                trace[attr] = [];
+                var out = _supply([trace]);
+                expect(out._fullData[0].visible).toBe(false, type + ' - ' + attr);
+            });
+        });
+    });
+
     it('direction *showlegend* should be inherited from trace-wide *showlegend*', function() {
         var trace0 = Lib.extendDeep({}, mock0, {
             type: 'ohlc',

test/jasmine/tests/histogram_test.js

@@ -34,13 +34,30 @@ describe('Test histogram', function() {
             traceIn = {
                 y: []
             };
+            traceOut = {};
+            supplyDefaults(traceIn, traceOut, '', {});
+            expect(traceOut.visible).toBe(false);
+        });
+
+        it('should set visible to false when x or y is empty AND the other is present', function() {
+            traceIn = {
+                x: [],
+                y: [1, 2, 2]
+            };
+            supplyDefaults(traceIn, traceOut, '', {});
+            expect(traceOut.visible).toBe(false);
+
+            traceIn = {
+                x: [1, 2, 2],
+                y: []
+            };
+            traceOut = {};
             supplyDefaults(traceIn, traceOut, '', {});
             expect(traceOut.visible).toBe(false);
         });
 
         it('should set visible to false when type is histogram2d(contour) and x or y are empty', function() {
             traceIn = {
-                type: 'histogram2d',
                 x: [],
                 y: [1, 2, 2]
             };
@@ -51,20 +68,23 @@ describe('Test histogram', function() {
                 x: [1, 2, 2],
                 y: []
             };
+            traceOut = {};
             supplyDefaults2D(traceIn, traceOut, '', {});
             expect(traceOut.visible).toBe(false);
 
             traceIn = {
                 x: [],
                 y: []
             };
+            traceOut = {};
             supplyDefaults2D(traceIn, traceOut, '', {});
             expect(traceOut.visible).toBe(false);
 
             traceIn = {
                 x: [],
                 y: [1, 2, 2]
             };
+            traceOut = {};
             supplyDefaults2DC(traceIn, traceOut, '', {});
             expect(traceOut.visible).toBe(false);
         });
@@ -80,6 +100,7 @@ describe('Test histogram', function() {
                 x: [1, 2, 2],
                 y: [1, 2, 2]
             };
+            traceOut = {};
             supplyDefaults(traceIn, traceOut, '', {});
             expect(traceOut.orientation).toBe('v');
         });
@@ -111,6 +132,7 @@ describe('Test histogram', function() {
             traceIn = {
                 x: [1, 2, 2]
             };
+            traceOut = {};
             supplyDefaults(traceIn, traceOut, '', {});
             expect(traceOut.autobinx).toBeUndefined();
         });
@@ -130,6 +152,7 @@ describe('Test histogram', function() {
             traceIn = {
                 y: [1, 2, 2]
             };
+            traceOut = {};
             supplyDefaults(traceIn, traceOut, '', {});
             expect(traceOut.autobiny).toBeUndefined();
         });

test/jasmine/tests/pie_test.js

@@ -8,11 +8,57 @@ var failTest = require('../assets/fail_test');
 var click = require('../assets/click');
 var getClientPosition = require('../assets/get_client_position');
 var mouseEvent = require('../assets/mouse_event');
+var supplyAllDefaults = require('../assets/supply_defaults');
 
 var customAssertions = require('../assets/custom_assertions');
 var assertHoverLabelStyle = customAssertions.assertHoverLabelStyle;
 var assertHoverLabelContent = customAssertions.assertHoverLabelContent;
 
+
+describe('Pie defaults', function() {
+    function _supply(trace) {
+        var gd = {
+            data: [trace],
+            layout: {}
+        };
+
+        supplyAllDefaults(gd);
+
+        return gd._fullData[0];
+    }
+
+    it('finds the minimum length of labels & values', function() {
+        var out = _supply({type: 'pie', labels: ['A', 'B'], values: [1, 2, 3]});
+        expect(out._length).toBe(2);
+
+        out = _supply({type: 'pie', labels: ['A', 'B', 'C'], values: [1, 2]});
+        expect(out._length).toBe(2);
+    });
+
+    it('allows labels or values to be missing but not both', function() {
+        var out = _supply({type: 'pie', values: [1, 2]});
+        expect(out.visible).toBe(true);
+        expect(out._length).toBe(2);
+        expect(out.label0).toBe(0);
+        expect(out.dlabel).toBe(1);
+
+        out = _supply({type: 'pie', labels: ['A', 'B']});
+        expect(out.visible).toBe(true);
+        expect(out._length).toBe(2);
+
+        out = _supply({type: 'pie'});
+        expect(out.visible).toBe(false);
+    });
+
+    it('is marked invisible if either labels or values is empty', function() {
+        var out = _supply({type: 'pie', labels: [], values: [1, 2]});
+        expect(out.visible).toBe(false);
+
+        out = _supply({type: 'pie', labels: ['A', 'B'], values: []});
+        expect(out.visible).toBe(false);
+    });
+});
+
 describe('Pie traces:', function() {
     'use strict';
 

test/jasmine/tests/scatter_test.js

@@ -79,6 +79,22 @@ describe('Test scatter', function() {
             expect(traceOut.visible).toBe(false);
         });
 
+        [{letter: 'y', counter: 'x'}, {letter: 'x', counter: 'y'}].forEach(function(spec) {
+            var l = spec.letter;
+            var c = spec.counter;
+            var c0 = c + '0';
+            var dc = 'd' + c;
+            it('should be visible using ' + c0 + '/' + dc + ' if ' + c + ' is missing completely but ' + l + ' is present', function() {
+                traceIn = {};
+                traceIn[spec.letter] = [1, 2];
+                supplyDefaults(traceIn, traceOut, defaultColor, layout);
+                expect(traceOut.visible).toBe(undefined, l); // visible: true gets set above the module level
+                expect(traceOut._length).toBe(2, l);
+                expect(traceOut[c0]).toBe(0, c0);
+                expect(traceOut[dc]).toBe(1, dc);
+            });
+        });
+
         it('should correctly assign \'hoveron\' default', function() {
             traceIn = {
                 x: [1, 2, 3],

test/jasmine/tests/scatterternary_test.js

@@ -146,6 +146,21 @@ describe('scatterternary defaults', function() {
         expect(traceOut._length).toBe(1);
     });
 
+    it('is set visible: false if a, b, or c is empty', function() {
+        var trace0 = {
+            a: [1, 2],
+            b: [2, 1],
+            c: [2, 2]
+        };
+
+        ['a', 'b', 'c'].forEach(function(letter) {
+            traceIn = Lib.extendDeep({}, trace0);
+            traceIn[letter] = [];
+            supplyDefaults(traceIn, traceOut, defaultColor, layout);
+            expect(traceOut.visible).toBe(false, letter);
+        });
+    });
+
     it('should include \'name\' in \'hoverinfo\' default if multi trace graph', function() {
         traceIn = {
             type: 'scatterternary',