optimize channel type coercion (#863)

Author: mbostock

src/channel.js

@@ -1,5 +1,5 @@
 import {ascending, descending, rollup, sort} from "d3";
-import {first, labelof, maybeValue, range, valueof} from "./options.js";
+import {first, labelof, map, maybeValue, range, valueof} from "./options.js";
 import {registry} from "./scales/index.js";
 import {maybeReduce} from "./transforms/group.js";
 
@@ -52,7 +52,7 @@ export function channelSort(channels, facetChannels, data, options) {
 function difference(channels, k1, k2) {
   const X1 = values(channels, k1);
   const X2 = values(channels, k2);
-  return Float64Array.from(X2, (x2, i) => Math.abs(x2 - X1[i]));
+  return map(X2, (x2, i) => Math.abs(x2 - X1[i]), Float64Array);
 }
 
 function values(channels, name, alias) {

src/options.js

@@ -80,6 +80,16 @@ export function arrayify(data, type) {
     : (data instanceof type ? data : type.from(data)));
 }
 
+// An optimization of type.from(values, f): if the given values are already an
+// instanceof the desired array type, the faster values.map method is used.
+export function map(values, f, type = Array) {
+  return values instanceof type ? values.map(f) : type.from(values, f);
+}
+
+export function isTypedArray(values) {
+  return values instanceof TypedArray;
+}
+
 // Disambiguates an options object (e.g., {y: "x2"}) from a primitive value.
 export function isObject(option) {
   return option?.toString === objectToString;

src/scales.js

@@ -1,5 +1,5 @@
 import {parse as isoParse} from "isoformat";
-import {isColor, isEvery, isOrdinal, isFirst, isSymbol, isTemporal, maybeSymbol, order, isTemporalString, isNumericString, isScaleOptions} from "./options.js";
+import {isColor, isEvery, isOrdinal, isFirst, isSymbol, isTemporal, isTemporalString, isNumericString, isScaleOptions, isTypedArray, map, maybeSymbol, order} from "./options.js";
 import {registry, color, position, radius, opacity, symbol, length} from "./scales/index.js";
 import {ScaleLinear, ScaleSqrt, ScalePow, ScaleLog, ScaleSymlog, ScaleQuantile, ScaleQuantize, ScaleThreshold, ScaleIdentity} from "./scales/quantitative.js";
 import {ScaleDiverging, ScaleDivergingSqrt, ScaleDivergingPow, ScaleDivergingLog, ScaleDivergingSymlog} from "./scales/diverging.js";
@@ -171,17 +171,17 @@ function Scale(key, channels = [], options = {}) {
     case "pow":
     case "log":
     case "symlog":
-      options = coerceType(channels, options, coerceNumber, Float64Array);
+      options = coerceType(channels, options, coerceNumbers);
       break;
     case "identity":
       switch (registry.get(key)) {
-        case position: options = coerceType(channels, options, coerceNumber, Float64Array); break;
-        case symbol: options = coerceType(channels, options, maybeSymbol); break;
+        case position: options = coerceType(channels, options, coerceNumbers); break;
+        case symbol: options = coerceType(channels, options, coerceSymbols); break;
       }
       break;
     case "utc":
     case "time":
-      options = coerceType(channels, options, coerceDate);
+      options = coerceType(channels, options, coerceDates);
       break;
   }
 
@@ -352,13 +352,29 @@ export function isCollapsed(scale) {
 }
 
 // Mutates channel.value!
-function coerceType(channels, options, coerce, type) {
-  for (const c of channels) c.value = coerceArray(c.value, coerce, type);
-  return {...options, domain: coerceArray(options.domain, coerce, type)};
+function coerceType(channels, {domain, ...options}, coerceValues) {
+  for (const c of channels) {
+    if (c.value !== undefined) {
+      c.value = coerceValues(c.value);
+    }
+  }
+  return {
+    domain: domain === undefined ? domain : coerceValues(domain),
+    ...options
+  };
+}
+
+function coerceSymbols(values) {
+  return map(values, maybeSymbol);
+}
+
+function coerceDates(values) {
+  return map(values, coerceDate);
 }
 
-function coerceArray(array, coerce, type = Array) {
-  if (array !== undefined) return type.from(array, coerce);
+// If the values are specified as a typed array, no coercion is required.
+function coerceNumbers(values) {
+  return isTypedArray(values) ? values : map(values, coerceNumber, Float64Array);
 }
 
 // Unlike Mark’s number, here we want to convert null and undefined to NaN,