Redesign the group, bin, and stack transforms.

src/index.js

@@ -6,7 +6,7 @@ export {bin, binX, binY} from "./marks/bin.js";
 export {Cell, cell, cellX, cellY} from "./marks/cell.js";
 export {Dot, dot, dotX, dotY} from "./marks/dot.js";
 export {Frame, frame} from "./marks/frame.js";
-export {group, groupX, groupY} from "./marks/group.js";
+export {groupCell, groupDot, groupBarX, groupBarY} from "./marks/group.js";
 export {Line, line, lineX, lineY} from "./marks/line.js";
 export {Link, link} from "./marks/link.js";
 export {Rect, rect, rectX, rectY} from "./marks/rect.js";
@@ -15,6 +15,6 @@ export {stackAreaX, stackAreaY, stackBarX, stackBarY} from "./marks/stack.js";
 export {Text, text, textX, textY} from "./marks/text.js";
 export {TickX, TickY, tickX, tickY} from "./marks/tick.js";
 export {bin1, bin2} from "./transforms/bin.js";
-export {group1, group2} from "./transforms/group.js";
+export {groupX, groupY, group} from "./transforms/group.js";
 export {movingAverage} from "./transforms/movingAverage.js";
 export {stackX, stackY} from "./transforms/stack.js";

src/marks/group.js

@@ -1,93 +1,20 @@
-import {arrayify, identity, first, second, maybeLabel, maybeZero} from "../mark.js";
-import {group1, group2} from "../transforms/group.js";
+import {groupX, groupY, group} from "../transforms/group.js";
 import {barX, barY} from "./bar.js";
 import {cell} from "./cell.js";
+import {dot} from "./dot.js";
 
-export function group(data, {
-  x = first,
-  y = second,
-  transform,
-  ...options
-} = {}) {
-  if (transform !== undefined) data = transform(arrayify(data));
-  return cell(
-    data,
-    {
-      ...options,
-      transform: group2(x, y),
-      x: maybeLabel(first, x),
-      y: maybeLabel(second, y),
-      fill: length3
-    }
-  );
+export function groupCell(data, options) {
+  return cell(...group(data, {out: "fill", ...options}));
 }
 
-export function groupX(data, {
-  x = identity,
-  y,
-  y1,
-  y2,
-  transform,
-  ...options
-} = {}) {
-  data = arrayify(data);
-  if (transform !== undefined) data = arrayify(transform(data));
-  ([y1, y2] = maybeZero(y, y1, y2, maybeLength(data, options)));
-  return barY(
-    data,
-    {
-      ...options,
-      transform: group1(x),
-      x: maybeLabel(first, x),
-      y1,
-      y2
-    }
-  );
+export function groupDot(data, options) {
+  return dot(...group(data, {out: "r", ...options}));
 }
 
-export function groupY(data, {
-  y = identity,
-  x,
-  x1,
-  x2,
-  transform,
-  ...options
-} = {}) {
-  data = arrayify(data);
-  if (transform !== undefined) data = arrayify(transform(data));
-  ([x1, x2] = maybeZero(x, x1, x2, maybeLength(data, options)));
-  return barX(
-    data,
-    {
-      ...options,
-      transform: group1(y),
-      x1,
-      x2,
-      y: maybeLabel(first, y)
-    }
-  );
+export function groupBarX(data, options) {
+  return barX(...groupY(data, options));
 }
 
-function length2([, group]) {
-  return group.length;
-}
-
-function length3([,, group]) {
-  return group.length;
-}
-
-length2.label = length3.label = "Frequency";
-
-function maybeLength(data, {normalize}) {
-  return normalize ? normalizer(normalize, data.length) : length2;
-}
-
-// An alternative channel definition to length2 (above) that computes the
-// proportion of each bin in [0, k]. If k is true, it is treated as 100 for
-// percentages; otherwise, it is typically 1.
-function normalizer(k, n) {
-  k = k === true ? 100 : +k;
-  const value = ([, group]) => group.length * k / n;
-  value.label = `Frequency${k === 100 ? " (%)" : ""}`;
-  return value;
+export function groupBarY(data, options) {
+  return barY(...groupX(data, options));
 }

src/transforms/group.js

@@ -1,8 +1,48 @@
 import {groups} from "d3-array";
 import {defined} from "../defined.js";
-import {valueof, maybeValue, range, offsetRange} from "../mark.js";
+import {valueof, maybeValue, range, offsetRange, maybeLabel, first, arrayify, second, identity} from "../mark.js";
 
-export function group1(x) {
+export function groupX(data, {x = identity, transform, ...options} = {}) {
+  if (transform !== undefined) data = transform(arrayify(data));
+  return [
+    data,
+    {
+      ...options,
+      transform: group1(x),
+      x: maybeLabel(first, x),
+      y: maybeLength(data, options)
+    }
+  ];
+}
+
+export function groupY(data, {y = identity, transform, ...options} = {}) {
+  if (transform !== undefined) data = transform(arrayify(data));
+  return [
+    data,
+    {
+      ...options,
+      transform: group1(y),
+      y: maybeLabel(first, y),
+      x: maybeLength(data, options)
+    }
+  ];
+}
+
+export function group(data, {x = first, y = second, out, transform, ...options} = {}) {
+  if (transform !== undefined) data = transform(arrayify(data));
+  return [
+    data,
+    {
+      ...options,
+      transform: group2(x, y),
+      x: maybeLabel(first, x),
+      y: maybeLabel(second, y),
+      [out]: length3
+    }
+  ];
+}
+
+function group1(x) {
   const {value} = maybeValue({value: x});
   return (data, facets) => {
     const values = valueof(data, value);
@@ -11,7 +51,7 @@ export function group1(x) {
   };
 }
 
-export function group2(vx, vy) {
+function group2(vx, vy) {
   const {value: x} = maybeValue({value: vx});
   const {value: y} = maybeValue({value: vy});
   return (data, facets) => {
@@ -51,6 +91,30 @@ function defined1([key]) {
 }
 
 // When faceting, some groups may be empty; these are filtered out.
-export function nonempty1([, {length}]) {
+function nonempty1([, {length}]) {
   return length > 0;
 }
+
+function length2([, group]) {
+  return group.length;
+}
+
+function length3([,, group]) {
+  return group.length;
+}
+
+length2.label = length3.label = "Frequency";
+
+function maybeLength(data, {normalize}) {
+  return normalize ? normalizer(normalize, data.length) : length2;
+}
+
+// An alternative channel definition to length2 (above) that computes the
+// proportion of each bin in [0, k]. If k is true, it is treated as 100 for
+// percentages; otherwise, it is typically 1.
+function normalizer(k, n) {
+  k = k === true ? 100 : +k;
+  const value = ([, group]) => group.length * k / n;
+  value.label = `Frequency${k === 100 ? " (%)" : ""}`;
+  return value;
+}

test/plots/moby-dick-faceted.js

@@ -17,7 +17,7 @@ export default async function() {
       y: cases
     },
     marks: [
-      Plot.groupX(letters, {x: uppers}),
+      Plot.groupBarY(letters, {x: uppers}),
       Plot.ruleY([0])
     ]
   });

test/plots/moby-dick-letter-frequency.js

@@ -8,7 +8,7 @@ export default async function() {
       grid: true
     },
     marks: [
-      Plot.groupX([...mobydick]
+      Plot.groupBarY([...mobydick]
         .filter(c => /[a-z]/i.test(c))
         .map(c => c.toUpperCase())),
       Plot.ruleY([0])

test/plots/moby-dick-letter-position.js

@@ -30,7 +30,7 @@ export default async function() {
       scheme: "blues"
     },
     marks: [
-      Plot.group(positions, {insetTop: 1, insetLeft: 1})
+      Plot.groupCell(positions, {insetTop: 1, insetLeft: 1})
     ]
   });
 }

test/plots/word-length-moby-dick.js

@@ -20,7 +20,7 @@ export default async function() {
       grid: true
     },
     marks: [
-      Plot.groupX(words, {x: d => d.length, normalize: true})
+      Plot.groupBarY(words, {x: d => d.length, normalize: true})
     ]
   });
 }