mark.channels is an object

Author: mbostock

src/channel.js

@@ -15,10 +15,10 @@ export function Channel(data, {scale, type, value, filter, hint}) {
   };
 }
 
-export function channelObject(channelDescriptors, data) {
+export function Channels(channelDescriptors, data) {
   const channels = {};
-  for (const channel of channelDescriptors) {
-    channels[channel.name] = Channel(data, channel);
+  for (const name in channelDescriptors) {
+    channels[name] = Channel(data, channelDescriptors[name]);
   }
   return channels;
 }

src/marks/dot.js

@@ -42,10 +42,9 @@ export class Dot extends Mark {
     // appropriate default symbols based on whether the dots are filled or
     // stroked, and for the symbol legend to match the appearance of the dots.
     const {channels} = this;
-    const symbolChannel = channels.find(({scale}) => scale === "symbol");
+    const {symbol: symbolChannel} = channels;
     if (symbolChannel) {
-      const fillChannel = channels.find(({name}) => name === "fill");
-      const strokeChannel = channels.find(({name}) => name === "stroke");
+      const {fill: fillChannel, stroke: strokeChannel} = channels;
       symbolChannel.hint = {
         fill: fillChannel ? (fillChannel.value === symbolChannel.value ? "color" : "currentColor") : this.fill,
         stroke: strokeChannel ? (strokeChannel.value === symbolChannel.value ? "color" : "currentColor") : this.stroke

src/plot.js

@@ -1,6 +1,6 @@
 import {cross, difference, groups, InternMap, select} from "d3";
 import {Axes, autoAxisTicks, autoScaleLabels} from "./axes.js";
-import {Channel, channelObject, channelDomain, valueObject} from "./channel.js";
+import {Channel, Channels, channelDomain, valueObject} from "./channel.js";
 import {Context, create} from "./context.js";
 import {defined} from "./defined.js";
 import {Dimensions} from "./dimensions.js";
@@ -266,7 +266,7 @@ export class Mark {
     this.facet = facet == null || facet === false ? null : keyword(facet === true ? "include" : facet, "facet", ["auto", "include", "exclude"]);
     if (extraChannels !== undefined) channels = [...channels, ...extraChannels.filter(e => !channels.some(c => c.name === e.name))];
     if (defaults !== undefined) channels = [...channels, ...styles(this, options, defaults)];
-    this.channels = channels.filter(channel => {
+    this.channels = Object.fromEntries(channels.filter(channel => {
       const {name, value, optional} = channel;
       if (value == null) {
         if (optional) return false;
@@ -278,7 +278,7 @@ export class Mark {
       if (names.has(key)) throw new Error(`duplicate channel: ${key}`);
       names.add(key);
       return true;
-    });
+    }).map(channel => [channel.name, channel]));
     this.dx = +dx || 0;
     this.dy = +dy || 0;
     this.clip = maybeClip(clip);
@@ -287,7 +287,7 @@ export class Mark {
     let data = arrayify(this.data);
     if (facets === undefined && data != null) facets = [range(data)];
     if (this.transform != null) ({facets, data} = this.transform(data, facets)), data = arrayify(data);
-    const channels = channelObject(this.channels, data);
+    const channels = Channels(this.channels, data);
     if (this.sort != null) channelDomain(channels, facetChannels, data, this.sort);
     return {data, facets, channels};
   }

test/marks/area-test.js

@@ -6,9 +6,9 @@ it("area(data, options) has the expected defaults", () => {
   const area = Plot.area(undefined, {x1: "0", y1: "1"});
   assert.strictEqual(area.data, undefined);
   // assert.strictEqual(area.transform, undefined);
-  assert.deepStrictEqual(area.channels.map(c => c.name), ["x1", "y1"]);
-  assert.deepStrictEqual(area.channels.map(c => c.value), ["0", "1"]);
-  assert.deepStrictEqual(area.channels.map(c => c.scale), ["x", "y"]);
+  assert.deepStrictEqual(Object.keys(area.channels), ["x1", "y1"]);
+  assert.deepStrictEqual(Object.values(area.channels).map(c => c.value), ["0", "1"]);
+  assert.deepStrictEqual(Object.values(area.channels).map(c => c.scale), ["x", "y"]);
   assert.strictEqual(area.curve, curveLinear);
   assert.strictEqual(area.fill, undefined);
   assert.strictEqual(area.fillOpacity, undefined);
@@ -26,28 +26,28 @@ it("area(data, options) has the expected defaults", () => {
 
 it("area(data, {x1, y1, y2}) specifies an optional y2 channel", () => {
   const area = Plot.area(undefined, {x1: "0", y1: "1", y2: "2"});
-  const y2 = area.channels.find(c => c.name === "y2");
+  const {y2} = area.channels;
   assert.strictEqual(y2.value, "2");
   assert.strictEqual(y2.scale, "y");
 });
 
 it("area(data, {x1, x2, y1}) specifies an optional x2 channel", () => {
   const area = Plot.area(undefined, {x1: "0", x2: "1", y1: "2"});
-  const x2 = area.channels.find(c => c.name === "x2");
+  const {x2} = area.channels;
   assert.strictEqual(x2.value, "1");
   assert.strictEqual(x2.scale, "x");
 });
 
 it("area(data, {z}) specifies an optional z channel", () => {
   const area = Plot.area(undefined, {x1: "0", y1: "1", z: "2"});
-  const z = area.channels.find(c => c.name === "z");
+  const {z} = area.channels;
   assert.strictEqual(z.value, "2");
   assert.strictEqual(z.scale, undefined);
 });
 
 it("area(data, {title}) specifies an optional title channel", () => {
   const area = Plot.area(undefined, {x1: "0", y1: "1", title: "2"});
-  const title = area.channels.find(c => c.name === "title");
+  const {title} = area.channels;
   assert.strictEqual(title.value, "2");
   assert.strictEqual(title.scale, undefined);
 });
@@ -65,14 +65,14 @@ it("area(data, {fill}) allows fill to be null", () => {
 it("area(data, {fill}) allows fill to be a variable color", () => {
   const area = Plot.area(undefined, {x1: "0", y1: "1", fill: "x"});
   assert.strictEqual(area.fill, undefined);
-  const fill = area.channels.find(c => c.name === "fill");
+  const {fill} = area.channels;
   assert.strictEqual(fill.value, "x");
   assert.strictEqual(fill.scale, "color");
 });
 
 it("area(data, {fill}) implies a default z channel if fill is variable", () => {
   const area = Plot.area(undefined, {x1: "0", y1: "1", fill: "2", stroke: "3"}); // fill takes priority
-  const z = area.channels.find(c => c.name === "z");
+  const {z} = area.channels;
   assert.strictEqual(z.value, "2");
   assert.strictEqual(z.scale, undefined);
 });
@@ -90,14 +90,14 @@ it("area(data, {stroke}) allows stroke to be null", () => {
 it("area(data, {stroke}) allows stroke to be a variable color", () => {
   const area = Plot.area(undefined, {x1: "0", y1: "1", stroke: "x"});
   assert.strictEqual(area.stroke, undefined);
-  const stroke = area.channels.find(c => c.name === "stroke");
+  const {stroke} = area.channels;
   assert.strictEqual(stroke.value, "x");
   assert.strictEqual(stroke.scale, "color");
 });
 
 it("area(data, {stroke}) implies a default z channel if stroke is variable", () => {
   const area = Plot.area(undefined, {x1: "0", y1: "1", stroke: "2"});
-  const z = area.channels.find(c => c.name === "z");
+  const {z} = area.channels;
   assert.strictEqual(z.value, "2");
   assert.strictEqual(z.scale, undefined);
 });
@@ -109,26 +109,26 @@ it("area(data, {curve}) specifies a named curve or function", () => {
 
 it("areaX(data, {x, y}) defaults x1 to zero, x2 to x, and y1 to y", () => {
   const area = Plot.areaX(undefined, {x: "0", y: "1"});
-  const x1 = area.channels.find(c => c.name === "x1");
+  const {x1} = area.channels;
   // assert.strictEqual(x1.value, 0);
   assert.strictEqual(x1.scale, "x");
-  const x2 = area.channels.find(c => c.name === "x2");
+  const {x2} = area.channels;
   assert.strictEqual(x2.value.label, "0");
   assert.strictEqual(x2.scale, "x");
-  const y1 = area.channels.find(c => c.name === "y1");
+  const {y1} = area.channels;
   assert.strictEqual(y1.value, "1");
   assert.strictEqual(y1.scale, "y");
 });
 
 it("areaY(data, {x, y}) defaults x1 to x, y1 to zero, and y2 to y", () => {
   const area = Plot.areaY(undefined, {x: "0", y: "1"});
-  const x1 = area.channels.find(c => c.name === "x1");
+  const {x1} = area.channels;
   assert.strictEqual(x1.value, "0");
   assert.strictEqual(x1.scale, "x");
-  const y1 = area.channels.find(c => c.name === "y1");
+  const {y1} = area.channels;
   // assert.strictEqual(y1.value, 0);
   assert.strictEqual(y1.scale, "y");
-  const y2 = area.channels.find(c => c.name === "y2");
+  const {y2} = area.channels;
   assert.strictEqual(y2.value.label, "1");
   assert.strictEqual(y2.scale, "y");
 });

test/marks/bar-test.js

@@ -5,9 +5,9 @@ it("barX() has the expected defaults", () => {
   const bar = Plot.barX();
   assert.strictEqual(bar.data, undefined);
   // assert.strictEqual(bar.transform, undefined);
-  assert.deepStrictEqual(bar.channels.map(c => c.name), ["x1", "x2", "y"]);
-  // assert.deepStrictEqual(bar.channels.map(c => Plot.valueof([1, 2, 3], c.value)), [[0, 0, 0], [1, 2, 3]]);
-  assert.deepStrictEqual(bar.channels.map(c => c.scale), ["x", "x", "y"]);
+  assert.deepStrictEqual(Object.keys(bar.channels), ["x1", "x2", "y"]);
+  // assert.deepStrictEqual(Object.values(bar.channels).map(c => Plot.valueof([1, 2, 3], c.value)), [[0, 0, 0], [1, 2, 3]]);
+  assert.deepStrictEqual(Object.values(bar.channels).map(c => c.scale), ["x", "x", "y"]);
   assert.strictEqual(bar.fill, undefined);
   assert.strictEqual(bar.fillOpacity, undefined);
   assert.strictEqual(bar.stroke, undefined);
@@ -28,15 +28,15 @@ it("barX() has the expected defaults", () => {
 
 it("barX(data, {y}) uses a band scale", () => {
   const bar = Plot.barX(undefined, {y: "x"});
-  assert.deepStrictEqual(bar.channels.map(c => c.name), ["x1", "x2", "y"]);
-  assert.deepStrictEqual(bar.channels.map(c => c.scale), ["x", "x", "y"]);
-  assert.strictEqual(bar.channels.find(c => c.name === "y").type, "band");
-  assert.strictEqual(bar.channels.find(c => c.name === "y").value.label, "x");
+  assert.deepStrictEqual(Object.keys(bar.channels), ["x1", "x2", "y"]);
+  assert.deepStrictEqual(Object.values(bar.channels).map(c => c.scale), ["x", "x", "y"]);
+  assert.strictEqual(bar.channels.y.type, "band");
+  assert.strictEqual(bar.channels.y.value.label, "x");
 });
 
 it("barX(data, {title}) specifies an optional title channel", () => {
   const bar = Plot.barX(undefined, {title: "x"});
-  const title = bar.channels.find(c => c.name === "title");
+  const {title} = bar.channels;
   assert.strictEqual(title.value, "x");
   assert.strictEqual(title.scale, undefined);
 });
@@ -54,7 +54,7 @@ it("barX(data, {fill}) allows fill to be null", () => {
 it("barX(data, {fill}) allows fill to be a variable color", () => {
   const bar = Plot.barX(undefined, {fill: "x"});
   assert.strictEqual(bar.fill, undefined);
-  const fill = bar.channels.find(c => c.name === "fill");
+  const {fill} = bar.channels;
   assert.strictEqual(fill.value, "x");
   assert.strictEqual(fill.scale, "color");
 });
@@ -72,20 +72,20 @@ it("barX(data, {stroke}) allows stroke to be null", () => {
 it("barX(data, {stroke}) allows stroke to be a variable color", () => {
   const bar = Plot.barX(undefined, {stroke: "x"});
   assert.strictEqual(bar.stroke, undefined);
-  const stroke = bar.channels.find(c => c.name === "stroke");
+  const {stroke} = bar.channels;
   assert.strictEqual(stroke.value, "x");
   assert.strictEqual(stroke.scale, "color");
 });
 
 it("barX(data, {x, y}) defaults x1 to zero and x2 to x", () => {
   const bar = Plot.barX(undefined, {x: "0", y: "1"});
-  const x1 = bar.channels.find(c => c.name === "x1");
+  const {x1} = bar.channels;
   // assert.strictEqual(x1.value, 0);
   assert.strictEqual(x1.scale, "x");
-  const x2 = bar.channels.find(c => c.name === "x2");
+  const {x2} = bar.channels;
   assert.strictEqual(x2.value.label, "0");
   assert.strictEqual(x2.scale, "x");
-  const y = bar.channels.find(c => c.name === "y");
+  const {y} = bar.channels;
   assert.strictEqual(y.value.label, "1");
   assert.strictEqual(y.scale, "y");
 });
@@ -99,9 +99,9 @@ it("barY() has the expected defaults", () => {
   const bar = Plot.barY();
   assert.strictEqual(bar.data, undefined);
   // assert.strictEqual(bar.transform, undefined);
-  assert.deepStrictEqual(bar.channels.map(c => c.name), ["y1", "y2", "x"]);
-  // assert.deepStrictEqual(bar.channels.map(c => Plot.valueof([1, 2, 3], c.value)), [[0, 0, 0], [1, 2, 3]]);
-  assert.deepStrictEqual(bar.channels.map(c => c.scale), ["y", "y", "x"]);
+  assert.deepStrictEqual(Object.keys(bar.channels), ["y1", "y2", "x"]);
+  // assert.deepStrictEqual(Object.values(bar.channels).map(c => Plot.valueof([1, 2, 3], c.value)), [[0, 0, 0], [1, 2, 3]]);
+  assert.deepStrictEqual(Object.values(bar.channels).map(c => c.scale), ["y", "y", "x"]);
   assert.strictEqual(bar.fill, undefined);
   assert.strictEqual(bar.fillOpacity, undefined);
   assert.strictEqual(bar.stroke, undefined);
@@ -122,15 +122,15 @@ it("barY() has the expected defaults", () => {
 
 it("barY(data, {x}) uses a band scale", () => {
   const bar = Plot.barY(undefined, {x: "y"});
-  assert.deepStrictEqual(bar.channels.map(c => c.name), ["y1", "y2", "x"]);
-  assert.deepStrictEqual(bar.channels.map(c => c.scale), ["y", "y", "x"]);
-  assert.strictEqual(bar.channels.find(c => c.name === "x").type, "band");
-  assert.strictEqual(bar.channels.find(c => c.name === "x").value.label, "y");
+  assert.deepStrictEqual(Object.keys(bar.channels), ["y1", "y2", "x"]);
+  assert.deepStrictEqual(Object.values(bar.channels).map(c => c.scale), ["y", "y", "x"]);
+  assert.strictEqual(bar.channels.x.type, "band");
+  assert.strictEqual(bar.channels.x.value.label, "y");
 });
 
 it("barY(data, {title}) specifies an optional title channel", () => {
   const bar = Plot.barY(undefined, {title: "x"});
-  const title = bar.channels.find(c => c.name === "title");
+  const {title} = bar.channels;
   assert.strictEqual(title.value, "x");
   assert.strictEqual(title.scale, undefined);
 });
@@ -148,7 +148,7 @@ it("barY(data, {fill}) allows fill to be null", () => {
 it("barY(data, {fill}) allows fill to be a variable color", () => {
   const bar = Plot.barY(undefined, {fill: "x"});
   assert.strictEqual(bar.fill, undefined);
-  const fill = bar.channels.find(c => c.name === "fill");
+  const {fill} = bar.channels;
   assert.strictEqual(fill.value, "x");
   assert.strictEqual(fill.scale, "color");
 });
@@ -166,20 +166,20 @@ it("barY(data, {stroke}) allows stroke to be null", () => {
 it("barY(data, {stroke}) allows stroke to be a variable color", () => {
   const bar = Plot.barY(undefined, {stroke: "x"});
   assert.strictEqual(bar.stroke, undefined);
-  const stroke = bar.channels.find(c => c.name === "stroke");
+  const {stroke} = bar.channels;
   assert.strictEqual(stroke.value, "x");
   assert.strictEqual(stroke.scale, "color");
 });
 
 it("barY(data, {x, y}) defaults y1 to zero and y2 to y", () => {
   const bar = Plot.barY(undefined, {x: "0", y: "1"});
-  const x = bar.channels.find(c => c.name === "x");
+  const {x} = bar.channels;
   assert.strictEqual(x.value.label, "0");
   assert.strictEqual(x.scale, "x");
-  const y1 = bar.channels.find(c => c.name === "y1");
+  const {y1} = bar.channels;
   // assert.strictEqual(y1.value, 0);
   assert.strictEqual(y1.scale, "y");
-  const y2 = bar.channels.find(c => c.name === "y2");
+  const {y2} = bar.channels;
   assert.strictEqual(y2.value.label, "1");
   assert.strictEqual(y2.scale, "y");
 });

test/marks/cell-test.js

@@ -5,11 +5,11 @@ it("cell() has the expected defaults", () => {
   const cell = Plot.cell();
   assert.strictEqual(cell.data, undefined);
   assert.strictEqual(cell.transform, undefined);
-  assert.deepStrictEqual(cell.channels.map(c => c.name), ["x", "y"]);
-  assert.deepStrictEqual(cell.channels.map(c => Plot.valueof([[1, 2], [3, 4]], c.value)), [[1, 3], [2, 4]]);
-  assert.deepStrictEqual(cell.channels.map(c => c.scale), ["x", "y"]);
-  assert.strictEqual(cell.channels.find(c => c.name === "x").type, "band");
-  assert.strictEqual(cell.channels.find(c => c.name === "y").type, "band");
+  assert.deepStrictEqual(Object.keys(cell.channels), ["x", "y"]);
+  assert.deepStrictEqual(Object.values(cell.channels).map(c => Plot.valueof([[1, 2], [3, 4]], c.value)), [[1, 3], [2, 4]]);
+  assert.deepStrictEqual(Object.values(cell.channels).map(c => c.scale), ["x", "y"]);
+  assert.strictEqual(cell.channels.x.type, "band");
+  assert.strictEqual(cell.channels.y.type, "band");
   assert.strictEqual(cell.fill, undefined);
   assert.strictEqual(cell.fillOpacity, undefined);
   assert.strictEqual(cell.stroke, undefined);
@@ -30,7 +30,7 @@ it("cell() has the expected defaults", () => {
 
 it("cell(data, {title}) specifies an optional title channel", () => {
   const cell = Plot.cell(undefined, {title: "x"});
-  const title = cell.channels.find(c => c.name === "title");
+  const {title} = cell.channels;
   assert.strictEqual(title.value, "x");
   assert.strictEqual(title.scale, undefined);
 });
@@ -48,7 +48,7 @@ it("cell(data, {fill}) allows fill to be null", () => {
 it("cell(data, {fill}) allows fill to be a variable color", () => {
   const cell = Plot.cell(undefined, {fill: "x"});
   assert.strictEqual(cell.fill, undefined);
-  const fill = cell.channels.find(c => c.name === "fill");
+  const {fill} = cell.channels;
   assert.strictEqual(fill.value, "x");
   assert.strictEqual(fill.scale, "color");
 });
@@ -66,7 +66,7 @@ it("cell(data, {stroke}) allows stroke to be null", () => {
 it("cell(data, {stroke}) allows stroke to be a variable color", () => {
   const cell = Plot.cell(undefined, {stroke: "x"});
   assert.strictEqual(cell.stroke, undefined);
-  const stroke = cell.channels.find(c => c.name === "stroke");
+  const {stroke} = cell.channels;
   assert.strictEqual(stroke.value, "x");
   assert.strictEqual(stroke.scale, "color");
 });
@@ -75,18 +75,18 @@ it("cellX() defaults x to identity and y to null", () => {
   const cell = Plot.cellX();
   assert.strictEqual(cell.data, undefined);
   assert.strictEqual(cell.transform, undefined);
-  assert.deepStrictEqual(cell.channels.map(c => c.name), ["x", "fill"]);
-  assert.deepStrictEqual(cell.channels.map(c => Plot.valueof([1, 2, 3], c.value)), [[ 0, 1, 2 ], [ 1, 2, 3 ]]);
-  assert.deepStrictEqual(cell.channels.map(c => c.scale), ["x", "color"]);
-  assert.strictEqual(cell.channels.find(c => c.name === "x").type, "band");
+  assert.deepStrictEqual(Object.keys(cell.channels), ["x", "fill"]);
+  assert.deepStrictEqual(Object.values(cell.channels).map(c => Plot.valueof([1, 2, 3], c.value)), [[ 0, 1, 2 ], [ 1, 2, 3 ]]);
+  assert.deepStrictEqual(Object.values(cell.channels).map(c => c.scale), ["x", "color"]);
+  assert.strictEqual(cell.channels.x.type, "band");
 });
 
 it("cellY() defaults y to identity and x to null", () => {
   const cell = Plot.cellY();
   assert.strictEqual(cell.data, undefined);
   assert.strictEqual(cell.transform, undefined);
-  assert.deepStrictEqual(cell.channels.map(c => c.name), ["y", "fill"]);
-  assert.deepStrictEqual(cell.channels.map(c => Plot.valueof([1, 2, 3], c.value)), [[ 0, 1, 2 ], [ 1, 2, 3 ]]);
-  assert.deepStrictEqual(cell.channels.map(c => c.scale), ["y", "color"]);
-  assert.strictEqual(cell.channels.find(c => c.name === "y").type, "band");
+  assert.deepStrictEqual(Object.keys(cell.channels), ["y", "fill"]);
+  assert.deepStrictEqual(Object.values(cell.channels).map(c => Plot.valueof([1, 2, 3], c.value)), [[ 0, 1, 2 ], [ 1, 2, 3 ]]);
+  assert.deepStrictEqual(Object.values(cell.channels).map(c => c.scale), ["y", "color"]);
+  assert.strictEqual(cell.channels.y.type, "band");
 });