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,48 +193,55 @@ 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);
             }
         }
     }
 
-    // Look into the fullInput module attributes for array attributes
-    // to make sure that 'custom' array attributes are detected.
-    //
-    // At the moment, we need this block to make sure that
-    // ohlc and candlestick 'open', 'high', 'low', 'close' can be
-    // used with filter and groupby transforms.
-    if(trace._fullInput && trace._fullInput._module && trace._fullInput._module.attributes) {
-        exports.crawl(trace._fullInput._module.attributes, callback);
-        arrayAttributes = Lib.filterUnique(arrayAttributes);
-    }
-
     return arrayAttributes;
 };
 

src/plots/cartesian/type_defaults.js

@@ -107,7 +107,7 @@ function getFirstNonEmptyTrace(data, id, axLetter) {
         var trace = data[i];
 
         if(trace.type === 'splom' &&
-                trace._commonLength > 0 &&
+                trace._length > 0 &&
                 trace['_' + axLetter + 'axes'][id]
         ) {
             return trace;

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/traces/parcoords/calc.js

@@ -15,7 +15,7 @@ var wrap = require('../../lib/gup').wrap;
 
 module.exports = function calc(gd, trace) {
     var cs = !!trace.line.colorscale && Lib.isArrayOrTypedArray(trace.line.color);
-    var color = cs ? trace.line.color : constHalf(trace._commonLength);
+    var color = cs ? trace.line.color : constHalf(trace._length);
     var cscale = cs ? trace.line.colorscale : [[0, trace.line.color], [1, trace.line.color]];
 
     if(hasColorscale(trace, 'line')) {

src/traces/parcoords/defaults.js

@@ -26,7 +26,7 @@ function handleLineDefaults(traceIn, traceOut, defaultColor, layout, coerce) {
             // TODO: I think it would be better to keep showing lines beyond the last line color
             // but I'm not sure what color to give these lines - probably black or white
             // depending on the background color?
-            traceOut._commonLength = Math.min(traceOut._commonLength, lineColor.length);
+            traceOut._length = Math.min(traceOut._length, lineColor.length);
         }
         else {
             traceOut.line.color = defaultColor;
@@ -84,7 +84,7 @@ function dimensionsDefaults(traceIn, traceOut) {
         dimensionsOut.push(dimensionOut);
     }
 
-    traceOut._commonLength = commonLength;
+    traceOut._length = commonLength;
 
     return dimensionsOut;
 }
@@ -108,7 +108,7 @@ module.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout
     // but we can't do this in dimensionsDefaults (yet?) because line.color can also
     // truncate
     for(var i = 0; i < dimensions.length; i++) {
-        if(dimensions[i].visible) dimensions[i]._length = traceOut._commonLength;
+        if(dimensions[i].visible) dimensions[i]._length = traceOut._length;
     }
 
     // make default font size 10px (default is 12),

src/traces/parcoords/parcoords.js

@@ -142,7 +142,7 @@ function model(layout, d, i) {
         color: lineColor.map(d3.scale.linear().domain(dimensionExtent({
             values: lineColor,
             range: [line.cmin, line.cmax],
-            _length: trace._commonLength
+            _length: trace._length
         }))),
         blockLineCount: c.blockLineCount,
         canvasOverdrag: c.overdrag * c.canvasPixelRatio

src/traces/scattergl/convert.js

@@ -87,7 +87,7 @@ function convertStyle(gd, trace) {
 }
 
 function convertMarkerStyle(trace) {
-    var count = trace._length || trace._commonLength;
+    var count = trace._length;
     var optsIn = trace.marker;
     var optsOut = {};
     var i;

src/traces/splom/defaults.js

@@ -86,7 +86,7 @@ function handleDimensionsDefaults(traceIn, traceOut) {
         if(dimOut.visible) dimOut._length = commonLength;
     }
 
-    traceOut._commonLength = commonLength;
+    traceOut._length = commonLength;
 
     return dimensionsOut.length;
 }

src/traces/splom/index.js

@@ -29,7 +29,7 @@ var TOO_MANY_POINTS = require('../scattergl/constants').TOO_MANY_POINTS;
 
 function calc(gd, trace) {
     var dimensions = trace.dimensions;
-    var commonLength = trace._commonLength;
+    var commonLength = trace._length;
     var stash = {};
     var opts = {};
     // 'c' for calculated, 'l' for linear,
@@ -228,7 +228,7 @@ function plotOne(gd, cd0) {
     scene.unselectBatch = null;
 
     if(selectMode) {
-        var commonLength = trace._commonLength;
+        var commonLength = trace._length;
 
         if(!scene.selectBatch) {
             scene.selectBatch = [];

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/parcoords_test.js

@@ -182,7 +182,7 @@ describe('parcoords initialization tests', function() {
                 {values: [], visible: true},
                 {values: [1, 2], visible: false} // shouldn't be truncated to as visible: false
             ]});
-            expect(fullTrace._commonLength).toBe(3);
+            expect(fullTrace._length).toBe(3);
         });
 
         it('cleans up constraintrange', function() {