Accept objects for encoded typedarrays in data_array valType

.eslintrc

@@ -14,8 +14,14 @@
     "Float32Array": true,
     "Float64Array": true,
     "Uint8Array": true,
+    "Int8Array": true,
+    "Uint8ClampedArray": true,
     "Int16Array": true,
+    "Uint16Array": true,
     "Int32Array": true,
+    "Uint32Array": true,
+    "BigInt64Array": true,
+    "BigUint64Array": true,
     "ArrayBuffer": true,
     "DataView": true,
     "SVGElement": false

package.json

@@ -63,6 +63,7 @@
     "@turf/bbox": "^6.0.1",
     "@turf/centroid": "^6.0.2",
     "alpha-shape": "^1.0.0",
+    "base64-arraybuffer": "^0.2.0",
     "canvas-fit": "^1.5.0",
     "color-alpha": "1.0.4",
     "color-normalize": "1.5.0",

src/lib/coerce.js

@@ -18,22 +18,49 @@ var DESELECTDIM = require('../constants/interactions').DESELECTDIM;
 var nestedProperty = require('./nested_property');
 var counterRegex = require('./regex').counter;
 var modHalf = require('./mod').modHalf;
+var isPlainObject = require('./is_plain_object');
 var isArrayOrTypedArray = require('./array').isArrayOrTypedArray;
 
+var typedArrays = {
+    int8: typeof Int8Array !== 'undefined' ? 1 : 0,
+    uint8: typeof Uint8Array !== 'undefined' ? 1 : 0,
+    uint8clamped: typeof Uint8ClampedArray !== 'undefined' ? 1 : 0,
+    int16: typeof Int16Array !== 'undefined' ? 1 : 0,
+    uint16: typeof Uint16Array !== 'undefined' ? 1 : 0,
+    int32: typeof Int32Array !== 'undefined' ? 1 : 0,
+    uint32: typeof Uint32Array !== 'undefined' ? 1 : 0,
+    float32: typeof Float32Array !== 'undefined' ? 1 : 0,
+    float64: typeof Float64Array !== 'undefined' ? 1 : 0,
+    bigint64: typeof BigInt64Array !== 'undefined' ? 1 : 0,
+    biguint64: typeof BigUint64Array !== 'undefined' ? 1 : 0
+};
+
 exports.valObjectMeta = {
     data_array: {
         // You can use *dflt=[] to force said array to exist though.
         description: [
             'An {array} of data.',
-            'The value MUST be an {array}, or we ignore it.',
-            'Note that typed arrays (e.g. Float32Array) are supported.'
+            'The value could be an {array}',
+            'noting that typed arrays (e.g. Float32Array) are also supported.',
+            'It could also be an object in the form of',
+            'v: {, dtype: \'float32\', bvals: [/* ... */]}, shape: [dim0 (, dim1, (dim3))]',
+            'otherwise, it would be ignored.'
         ].join(' '),
         requiredOpts: [],
         otherOpts: ['dflt'],
         coerceFunction: function(v, propOut, dflt) {
-            // TODO maybe `v: {type: 'float32', vals: [/* ... */]}` also
-            if(isArrayOrTypedArray(v)) propOut.set(v);
-            else if(dflt !== undefined) propOut.set(dflt);
+            var wasSet;
+            if(isArrayOrTypedArray(v)) {
+                propOut.set(v);
+                wasSet = true;
+            } else if(isPlainObject(v)) {
+                var T = typedArrays[v.dtype];
+                if(T) {
+                    propOut.set(v);
+                    wasSet = true;
+                }
+            }
+            if(!wasSet && dflt !== undefined) propOut.set(dflt);
         }
     },
     enumerated: {

src/plots/plots.js

@@ -11,6 +11,7 @@
 var d3 = require('d3');
 var timeFormatLocale = require('d3-time-format').timeFormatLocale;
 var isNumeric = require('fast-isnumeric');
+var b64 = require('base64-arraybuffer');
 
 var Registry = require('../registry');
 var PlotSchema = require('../plot_api/plot_schema');
@@ -2848,7 +2849,50 @@ function _transition(gd, transitionOpts, opts) {
     return transitionStarting.then(function() { return gd; });
 }
 
+var typedArrays = {
+    int8: typeof Int8Array !== 'undefined' ? Int8Array : null,
+    uint8: typeof Uint8Array !== 'undefined' ? Uint8Array : null,
+    uint8clamped: typeof Uint8ClampedArray !== 'undefined' ? Uint8ClampedArray : null,
+    int16: typeof Int16Array !== 'undefined' ? Int16Array : null,
+    uint16: typeof Uint16Array !== 'undefined' ? Uint16Array : null,
+    int32: typeof Int32Array !== 'undefined' ? Int32Array : null,
+    uint32: typeof Uint32Array !== 'undefined' ? Uint32Array : null,
+    float32: typeof Float32Array !== 'undefined' ? Float32Array : null,
+    float64: typeof Float64Array !== 'undefined' ? Float64Array : null,
+    bigint64: typeof BigInt64Array !== 'undefined' ? BigInt64Array : null,
+    biguint64: typeof BigUint64Array !== 'undefined' ? BigUint64Array : null
+};
+
+function _decode(cont) {
+    if(cont.dtype && cont.bvals) {
+        var T = typedArrays[cont.dtype];
+        if(T) {
+            return new T(b64.decode(cont.bvals));
+        }
+    }
+
+    for(var prop in cont) {
+        if(prop[0] !== '_' && cont.hasOwnProperty(prop)) {
+            var item = cont[prop];
+            if(Lib.isPlainObject(item)) {
+                var r = _decode(item);
+                if(r !== undefined) cont[prop] = r;
+            }
+        }
+    }
+}
+
+function decodeB64Arrays(gd) {
+    for(var i = 0; i < gd._fullData.length; i++) {
+        _decode(gd._fullData[i]);
+    }
+
+    _decode(gd._fullLayout);
+}
+
 plots.doCalcdata = function(gd, traces) {
+    decodeB64Arrays(gd);
+
     var axList = axisIDs.list(gd);
     var fullData = gd._fullData;
     var fullLayout = gd._fullLayout;

src/traces/heatmap/xyz_defaults.js

@@ -19,19 +19,25 @@ module.exports = function handleXYZDefaults(traceIn, traceOut, coerce, layout, x
     yName = yName || 'y';
     var x, y;
 
-    if(z === undefined || !z.length) return 0;
+    var shapeX = x ? (x.shape ? x.shape[0] : x.length) || 0 : 0;
+    var shapeY = y ? (y.shape ? y.shape[0] : y.length) || 0 : 0;
+    var shapeZ = z ? (z.shape ? z.shape[0] : z.length) || 0 : 0;
 
-    if(Lib.isArray1D(traceIn.z)) {
+    var zlen = shapeZ || (z && z.length) || 0;
+
+    if(z === undefined || !zlen) return 0;
+
+    if(Lib.isArray1D(traceIn.z) || (z && z.shape && z.shape.length === 1)) {
         x = coerce(xName);
         y = coerce(yName);
 
-        var xlen = Lib.minRowLength(x);
-        var ylen = Lib.minRowLength(y);
+        var xlen = shapeX || Lib.minRowLength(x);
+        var ylen = shapeY || Lib.minRowLength(y);
 
         // column z must be accompanied by xName and yName arrays
         if(xlen === 0 || ylen === 0) return 0;
 
-        traceOut._length = Math.min(xlen, ylen, z.length);
+        traceOut._length = Math.min(xlen, ylen, zlen);
     } else {
         x = coordDefaults(xName, coerce);
         y = coordDefaults(yName, coerce);

src/traces/isosurface/defaults.js

@@ -38,12 +38,18 @@ function supplyIsoDefaults(traceIn, traceOut, defaultColor, layout, coerce) {
     var z = coerce('z');
     var value = coerce('value');
 
-    if(
-        !x || !x.length ||
-        !y || !y.length ||
-        !z || !z.length ||
-        !value || !value.length
-    ) {
+    var len = 0;
+
+    if(x && y && z && value) {
+        len = Math.min(
+            (x.shape ? x.shape[0] : x.length) || 0,
+            (y.shape ? y.shape[0] : y.length) || 0,
+            (z.shape ? z.shape[0] : z.length) || 0,
+            (value.shape ? value.shape[0] : value.length) || 0
+        );
+    }
+
+    if(!len) {
         traceOut.visible = false;
         return;
     }

src/traces/scatter/xy_defaults.js

@@ -19,19 +19,22 @@ module.exports = function handleXYDefaults(traceIn, traceOut, layout, coerce) {
     var handleCalendarDefaults = Registry.getComponentMethod('calendars', 'handleTraceDefaults');
     handleCalendarDefaults(traceIn, traceOut, ['x', 'y'], layout);
 
+    var shapeX = x && x.shape ? x.shape[0] : 0;
+    var shapeY = y && y.shape ? y.shape[0] : 0;
+
     if(x) {
-        var xlen = Lib.minRowLength(x);
+        var xlen = shapeX || Lib.minRowLength(x);
         if(y) {
-            len = Math.min(xlen, Lib.minRowLength(y));
+            len = shapeY || Math.min(xlen, Lib.minRowLength(y));
         } else {
-            len = xlen;
+            len = shapeX || xlen;
             coerce('y0');
             coerce('dy');
         }
     } else {
         if(!y) return 0;
 
-        len = Lib.minRowLength(y);
+        len = shapeY || Lib.minRowLength(y);
         coerce('x0');
         coerce('dx');
     }

src/traces/scatter3d/defaults.js

@@ -78,8 +78,12 @@ function handleXYZDefaults(traceIn, traceOut, coerce, layout) {
     handleCalendarDefaults(traceIn, traceOut, ['x', 'y', 'z'], layout);
 
     if(x && y && z) {
+        var shapeX = (x.shape ? x.shape[0] : x.length) || 0;
+        var shapeY = (y.shape ? y.shape[0] : y.length) || 0;
+        var shapeZ = (z.shape ? z.shape[0] : z.length) || 0;
+
         // TODO: what happens if one is missing?
-        len = Math.min(x.length, y.length, z.length);
+        len = Math.min(shapeX, shapeY, shapeZ);
         traceOut._length = traceOut._xlength = traceOut._ylength = traceOut._zlength = len;
     }