moving functionality from calc.js to a helper file

plotly · monfera · Oct 5, 2017 · Oct 3, 2017 · Oct 3, 2017 · Oct 3, 2017
commit 309c8bb14aafe72ad7f12095ef31adf42ec45524
diff --git a/src/traces/table/calc.js b/src/traces/table/calc.js
@@ -8,124 +8,8 @@
 
 'use strict';
 
-var c = require('./constants');
 var wrap = require('../../lib/gup').wrap;
-var extendFlat = require('../../lib/extend').extendFlat;
 
 module.exports = function calc(gd, trace) {
-    var domain = trace.domain;
-    var groupWidth = Math.floor(gd._fullLayout._size.w * (domain.x[1] - domain.x[0]));
-    var groupHeight = Math.floor(gd._fullLayout._size.h * (domain.y[1] - domain.y[0]));
-    var headerRowHeights = trace.header.values[0].map(function() {return trace.header.height;});
-    var rowHeights = trace.cells.values[0].map(function() {return trace.cells.height;});
-    var headerHeight = headerRowHeights.reduce(function(a, b) {return a + b;}, 0);
-    var scrollHeight = groupHeight - headerHeight;
-    var minimumFillHeight = scrollHeight + c.uplift;
-    var anchorToRowBlock = makeAnchorToRowBlock(rowHeights, minimumFillHeight);
-    var anchorToHeaderRowBlock = makeAnchorToRowBlock(headerRowHeights, headerHeight);
-    var headerRowBlocks = makeRowBlock(anchorToHeaderRowBlock, []);
-    var rowBlocks = makeRowBlock(anchorToRowBlock, headerRowBlocks);
-    var uniqueKeys = {};
-    var columnOrder = trace._fullInput.columnorder;
-    var columnWidths = trace.header.values.map(function(d, i) {
-        return Array.isArray(trace.columnwidth) ?
-            trace.columnwidth[Math.min(i, trace.columnwidth.length - 1)] :
-            isFinite(trace.columnwidth) && trace.columnwidth !== null ? trace.columnwidth : 1;
-    });
    var totalColumnWidths = columnWidths.reduce(function(p, n) {return p + n;}, 0);
-
-    // fit columns in the available vertical space as there's no vertical scrolling now
-    columnWidths = columnWidths.map(function(d) {return d / totalColumnWidths * groupWidth;});
-
-    var calcdata = {
-        key: trace.index,
-        translateX: domain.x[0] * gd._fullLayout._size.w,
-        translateY: gd._fullLayout._size.h * (1 - domain.y[1]),
-        size: gd._fullLayout._size,
-        width: groupWidth,
-        height: groupHeight,
-        columnOrder: columnOrder, // will be mutated on column move, todo use in callback
-        groupHeight: groupHeight,
-        rowBlocks: rowBlocks,
-        headerRowBlocks: headerRowBlocks,
-        scrollY: 0, // will be mutated on scroll
-        cells: trace.cells,
-        headerCells: trace.header,
-        gdColumns: trace.header.values.map(function(d) {return d[0];}),
-        gdColumnsOriginalOrder: trace.header.values.map(function(d) {return d[0];}),
-        prevPages: [0, 0],
-        scrollbarState: {scrollbarScrollInProgress: false},
-        columns: trace.header.values.map(function(label, i) {
-            var foundKey = uniqueKeys[label];
-            uniqueKeys[label] = (foundKey || 0) + 1;
-            var key = label + '__' + uniqueKeys[label];
-            return {
-                key: key,
-                label: label,
-                specIndex: i,
-                xIndex: columnOrder[i],
-                xScale: xScale,
-                x: undefined, // initialized below
-                calcdata: undefined, // initialized below
-                columnWidth: columnWidths[i]
-            };
-        })
-    };
-
-    calcdata.columns.forEach(function(col) {
-        col.calcdata = calcdata;
-        col.x = xScale(col);
-    });
-
-    return wrap(calcdata);
+    return wrap(trace);
 };
-
-function xScale(d) {
-    return d.calcdata.columns.reduce(function(prev, next) {
-        return next.xIndex < d.xIndex ? prev + next.columnWidth : prev;
-    }, 0);
-}
-
-function makeRowBlock(anchorToRowBlock, auxiliary) {
-    var blockAnchorKeys = Object.keys(anchorToRowBlock);
-    return blockAnchorKeys.map(function(k) {return extendFlat({}, anchorToRowBlock[k], {auxiliaryBlocks: auxiliary});});
-    }
-
-function makeAnchorToRowBlock(rowHeights, minimumFillHeight) {
-
-    var anchorToRowBlock = {};
-    var currentRowHeight;
-    var currentAnchor = 0;
-    var currentBlockHeight = 0;
-    var currentBlock = makeIdentity();
-    var currentFirstRowIndex = 0;
-    var blockCounter = 0;
-    for(var i = 0; i < rowHeights.length; i++) {
-        currentRowHeight = rowHeights[i];
-        currentBlock.rows.push({
-            rowIndex: i,
-            rowHeight: currentRowHeight
-        });
-        currentBlockHeight += currentRowHeight;
-        if(currentBlockHeight >= minimumFillHeight || i === rowHeights.length - 1) {
-            anchorToRowBlock[currentAnchor] = currentBlock;
-            currentBlock.key = blockCounter++;
-            currentBlock.firstRowIndex = currentFirstRowIndex;
-            currentBlock.lastRowIndex = i;
-            currentBlock = makeIdentity();
-            currentAnchor += currentBlockHeight;
-            currentFirstRowIndex = i + 1;
-            currentBlockHeight = 0;
-        }
-    }
-
-    return anchorToRowBlock;
-}
-
-function makeIdentity() {
-    return {
-        firstRowIndex: null,
-        lastRowIndex: null,
-        rows: []
-    };
-}
diff --git a/src/traces/table/data_preparation_helper.js b/src/traces/table/data_preparation_helper.js
@@ -0,0 +1,131 @@
+/**
+* Copyright 2012-2017, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+'use strict';
+
+var c = require('./constants');
+var extendFlat = require('../../lib/extend').extendFlat;
+
+// pure functions, don't alter but passes on `gd` and parts of `trace` without deep copying
+module.exports = function calc(gd, trace) {
+    var domain = trace.domain;
+    var groupWidth = Math.floor(gd._fullLayout._size.w * (domain.x[1] - domain.x[0]));
+    var groupHeight = Math.floor(gd._fullLayout._size.h * (domain.y[1] - domain.y[0]));
+    var headerRowHeights = trace.header.values[0].map(function() {return trace.header.height;});
+    var rowHeights = trace.cells.values[0].map(function() {return trace.cells.height;});
+    var headerHeight = headerRowHeights.reduce(function(a, b) {return a + b;}, 0);
+    var scrollHeight = groupHeight - headerHeight;
+    var minimumFillHeight = scrollHeight + c.uplift;
+    var anchorToRowBlock = makeAnchorToRowBlock(rowHeights, minimumFillHeight);
+    var anchorToHeaderRowBlock = makeAnchorToRowBlock(headerRowHeights, headerHeight);
+    var headerRowBlocks = makeRowBlock(anchorToHeaderRowBlock, []);
+    var rowBlocks = makeRowBlock(anchorToRowBlock, headerRowBlocks);
+    var uniqueKeys = {};
+    var columnOrder = trace._fullInput.columnorder;
+    var columnWidths = trace.header.values.map(function(d, i) {
+        return Array.isArray(trace.columnwidth) ?
+            trace.columnwidth[Math.min(i, trace.columnwidth.length - 1)] :
+            isFinite(trace.columnwidth) && trace.columnwidth !== null ? trace.columnwidth : 1;
+    });
+    var totalColumnWidths = columnWidths.reduce(function(p, n) {return p + n;}, 0);
+
+    // fit columns in the available vertical space as there's no vertical scrolling now
+    columnWidths = columnWidths.map(function(d) {return d / totalColumnWidths * groupWidth;});
+
+    var calcdata = {
+        key: trace.index,
+        translateX: domain.x[0] * gd._fullLayout._size.w,
+        translateY: gd._fullLayout._size.h * (1 - domain.y[1]),
+        size: gd._fullLayout._size,
+        width: groupWidth,
+        height: groupHeight,
+        columnOrder: columnOrder, // will be mutated on column move, todo use in callback
+        groupHeight: groupHeight,
+        rowBlocks: rowBlocks,
+        headerRowBlocks: headerRowBlocks,
+        scrollY: 0, // will be mutated on scroll
+        cells: trace.cells,
+        headerCells: trace.header,
+        gdColumns: trace.header.values.map(function(d) {return d[0];}),
+        gdColumnsOriginalOrder: trace.header.values.map(function(d) {return d[0];}),
+        prevPages: [0, 0],
+        scrollbarState: {scrollbarScrollInProgress: false},
+        columns: trace.header.values.map(function(label, i) {
+            var foundKey = uniqueKeys[label];
+            uniqueKeys[label] = (foundKey || 0) + 1;
+            var key = label + '__' + uniqueKeys[label];
+            return {
+                key: key,
+                label: label,
+                specIndex: i,
+                xIndex: columnOrder[i],
+                xScale: xScale,
+                x: undefined, // initialized below
+                calcdata: undefined, // initialized below
+                columnWidth: columnWidths[i]
+            };
+        })
+    };
+
+    calcdata.columns.forEach(function(col) {
+        col.calcdata = calcdata;
+        col.x = xScale(col);
+    });
+
+    return calcdata;
+};
+
+function xScale(d) {
+    return d.calcdata.columns.reduce(function(prev, next) {
+        return next.xIndex < d.xIndex ? prev + next.columnWidth : prev;
+    }, 0);
+}
+
+function makeRowBlock(anchorToRowBlock, auxiliary) {
+    var blockAnchorKeys = Object.keys(anchorToRowBlock);
+    return blockAnchorKeys.map(function(k) {return extendFlat({}, anchorToRowBlock[k], {auxiliaryBlocks: auxiliary});});
+}
+
+function makeAnchorToRowBlock(rowHeights, minimumFillHeight) {
+
+    var anchorToRowBlock = {};
+    var currentRowHeight;
+    var currentAnchor = 0;
+    var currentBlockHeight = 0;
+    var currentBlock = makeIdentity();
+    var currentFirstRowIndex = 0;
+    var blockCounter = 0;
+    for(var i = 0; i < rowHeights.length; i++) {
+        currentRowHeight = rowHeights[i];
+        currentBlock.rows.push({
+            rowIndex: i,
+            rowHeight: currentRowHeight
+        });
+        currentBlockHeight += currentRowHeight;
+        if(currentBlockHeight >= minimumFillHeight || i === rowHeights.length - 1) {
+            anchorToRowBlock[currentAnchor] = currentBlock;
+            currentBlock.key = blockCounter++;
+            currentBlock.firstRowIndex = currentFirstRowIndex;
+            currentBlock.lastRowIndex = i;
+            currentBlock = makeIdentity();
+            currentAnchor += currentBlockHeight;
+            currentFirstRowIndex = i + 1;
+            currentBlockHeight = 0;
+        }
+    }
+
+    return anchorToRowBlock;
+}
+
+function makeIdentity() {
+    return {
+        firstRowIndex: null,
+        lastRowIndex: null,
+        rows: []
+    };
+}
diff --git a/src/traces/table/plot.js b/src/traces/table/plot.js
@@ -16,15 +16,20 @@ var extendFlat = require('../../lib/extend').extendFlat;
 var svgUtil = require('../../lib/svg_text_utils');
 var raiseToTop = require('../../lib').raiseToTop;
 var cancelEeaseColumn = require('../../lib').cancelTransition;
+var prepareData = require('./data_preparation_helper');
 
-module.exports = function plot(gd, calcdata) {
+module.exports = function plot(gd, wrappedTraceHolders) {
 
     if(c.clipView) {
         gd._fullLayout._paper.attr('height', 2000);
     }
 
     var table = gd._fullLayout._paper.selectAll('.table')
-        .data(calcdata.map(gup.unwrap), gup.keyFun);
+        .data(wrappedTraceHolders.map(function(wrappedTraceHolder) {
+            var traceHolder = gup.unwrap(wrappedTraceHolder);
+            var trace = traceHolder.trace;
+            return prepareData(gd, trace);
+        }), gup.keyFun);
 
     table.exit().remove();
 
@@ -130,7 +135,7 @@ module.exports = function plot(gd, calcdata) {
                 d.x = d.xScale(d);
                 d.calcdata.columnDragInProgress = false;
                 easeColumn(movedColumn, d, 0);
-                columnMoved(gd, calcdata, p.key, p.columns.map(function(dd) {return dd.xIndex;}));
+                columnMoved(gd, p, p.columns.map(function(dd) {return dd.xIndex;}));
             })
         );
 
@@ -557,13 +562,13 @@ function isLatex(content) {
 
 function hasWrapCharacter(text) {return text.indexOf(c.wrapSplitCharacter) !== -1;}
 
-function columnMoved(gd, calcdata, i, indices) {
-    var o = calcdata[i][0].gdColumnsOriginalOrder;
-    calcdata[i][0].gdColumns.sort(function(a, b) {
+function columnMoved(gd, calcdata, indices) {
+    var o = calcdata.gdColumnsOriginalOrder;
+    calcdata.gdColumns.sort(function(a, b) {
         return indices[o.indexOf(a)] - indices[o.indexOf(b)];
     });
 
-    calcdata[i][0].columnorder = indices;
+    calcdata.columnorder = indices;
 
     gd.emit('plotly_restyle');
 }