Support interval+reduce in the area mark (#2329)

* fix: areaY dense interval without explicit y option (#2328)

Fixed areaY to work with dense intervals (interval + reduce) without
requiring an explicit y option, matching lineY behavior.

🤖 Generated with [Claude Code](https://claude.ai/code)

Total cost:            $5.51
Total duration (API):  23m 31.3s
Total duration (wall): 14h 30m 4.3s
Total code changes:    208 lines added, 53 lines removed
Token usage by model:
    claude-3-5-haiku:  204.7k input, 4.8k output, 0 cache read, 0 cache write
       claude-sonnet:  18.9k input, 28.4k output, 8.3m cache read, 629.5k cache write

* a human fix: when y is undefined, default to y: reduce

* add vertical tests

* fix test merge

* lift dense interval defaults

* unused import

* don’t need maybeIdentity for area?

* simpler maybeIdentity

* minimize diff

* line can follow the same (simpler) pattern as area

* re-apply edits

---------

Co-authored-by: Claude Code <noreply@anthropic.com>
Co-authored-by: Mike Bostock <mbostock@gmail.com>

Author: 3 people

src/marks/area.js

@@ -2,16 +2,10 @@ import {area as shapeArea} from "d3";
 import {create} from "../context.js";
 import {maybeCurve} from "../curve.js";
 import {Mark} from "../mark.js";
-import {first, indexOf, maybeZ, second} from "../options.js";
-import {
-  applyDirectStyles,
-  applyIndirectStyles,
-  applyTransform,
-  applyGroupedChannelStyles,
-  groupIndex
-} from "../style.js";
+import {first, maybeZ, second} from "../options.js";
+import {applyDirectStyles, applyIndirectStyles, applyTransform, applyGroupedChannelStyles} from "../style.js";
+import {groupIndex} from "../style.js";
 import {maybeDenseIntervalX, maybeDenseIntervalY} from "../transforms/bin.js";
-import {maybeIdentityX, maybeIdentityY} from "../transforms/identity.js";
 import {maybeStackX, maybeStackY} from "../transforms/stack.js";
 
 const defaults = {
@@ -77,11 +71,11 @@ export function area(data, options) {
 }
 
 export function areaX(data, options) {
-  const {x, y = indexOf, fill, z = x === fill ? null : undefined, ...rest} = maybeDenseIntervalY(options);
-  return new Area(data, maybeStackX(maybeIdentityX({...rest, x, y1: y, y2: undefined, z, fill}, y === indexOf ? "x2" : "x"))); // prettier-ignore
+  const {x, y, fill, z = x === fill ? null : undefined, ...rest} = maybeDenseIntervalY(options);
+  return new Area(data, maybeStackX({...rest, x, y1: y, y2: undefined, z, fill}));
 }
 
 export function areaY(data, options) {
-  const {x = indexOf, y, fill, z = y === fill ? null : undefined, ...rest} = maybeDenseIntervalX(options);
-  return new Area(data, maybeStackY(maybeIdentityY({...rest, x1: x, x2: undefined, y, z, fill}, x === indexOf ? "y2" : "y"))); // prettier-ignore
+  const {x, y, fill, z = y === fill ? null : undefined, ...rest} = maybeDenseIntervalX(options);
+  return new Area(data, maybeStackY({...rest, x1: x, x2: undefined, y, z, fill}));
 }

src/marks/line.js

@@ -3,14 +3,9 @@ import {create} from "../context.js";
 import {curveAuto, maybeCurveAuto} from "../curve.js";
 import {Mark} from "../mark.js";
 import {applyGroupedMarkers, markers} from "../marker.js";
-import {coerceNumbers, indexOf, identity, maybeTuple, maybeZ} from "../options.js";
-import {
-  applyDirectStyles,
-  applyIndirectStyles,
-  applyTransform,
-  applyGroupedChannelStyles,
-  groupIndex
-} from "../style.js";
+import {coerceNumbers, maybeTuple, maybeZ} from "../options.js";
+import {applyDirectStyles, applyIndirectStyles, applyTransform, applyGroupedChannelStyles} from "../style.js";
+import {groupIndex} from "../style.js";
 import {maybeDenseIntervalX, maybeDenseIntervalY} from "../transforms/bin.js";
 
 const defaults = {
@@ -103,10 +98,12 @@ export function line(data, {x, y, ...options} = {}) {
   return new Line(data, {...options, x, y});
 }
 
-export function lineX(data, {x = identity, y = indexOf, stroke, z = stroke === x ? null : undefined, ...options} = {}) {
-  return new Line(data, maybeDenseIntervalY({...options, x, y, z, stroke}));
+export function lineX(data, options) {
+  const {x, y, stroke, z = stroke === x ? null : undefined, ...rest} = maybeDenseIntervalY(options);
+  return new Line(data, {...rest, x, y, z, stroke});
 }
 
-export function lineY(data, {x = indexOf, y = identity, stroke, z = stroke === y ? null : undefined, ...options} = {}) {
-  return new Line(data, maybeDenseIntervalX({...options, x, y, z, stroke}));
+export function lineY(data, options) {
+  const {x, y, stroke, z = stroke === y ? null : undefined, ...rest} = maybeDenseIntervalX(options);
+  return new Line(data, {...rest, x, y, z, stroke});
 }

src/options.js

@@ -214,18 +214,18 @@ export function slice(values, type = Array) {
 }
 
 // Returns true if any of x, x1, or x2 is not (strictly) undefined.
-export function hasX({x, x1, x2}) {
-  return x !== undefined || x1 !== undefined || x2 !== undefined;
+export function hasX(options) {
+  return options?.x !== undefined || options?.x1 !== undefined || options?.x2 !== undefined;
 }
 
 // Returns true if any of y, y1, or y2 is not (strictly) undefined.
-export function hasY({y, y1, y2}) {
-  return y !== undefined || y1 !== undefined || y2 !== undefined;
+export function hasY(options) {
+  return options?.y !== undefined || options?.y1 !== undefined || options?.y2 !== undefined;
 }
 
 // Returns true if has x or y, or if interval is not (strictly) undefined.
 export function hasXY(options) {
-  return hasX(options) || hasY(options) || options.interval !== undefined;
+  return hasX(options) || hasY(options) || options?.interval !== undefined;
 }
 
 // Disambiguates an options object (e.g., {y: "x2"}) from a primitive value.

src/transforms/bin.js

@@ -13,6 +13,7 @@ import {
   coerceDate,
   coerceNumbers,
   identity,
+  indexOf,
   isInterval,
   isIterable,
   isTemporal,
@@ -77,12 +78,12 @@ function maybeDenseInterval(bin, k, options = {}) {
   return bin(outputs, options);
 }
 
-export function maybeDenseIntervalX(options = {}) {
-  return maybeDenseInterval(binX, "y", withTip(options, "x"));
+export function maybeDenseIntervalX({y = identity, x = indexOf, ...options} = {}) {
+  return maybeDenseInterval(binX, "y", withTip({x, y, ...options}, "x"));
 }
 
-export function maybeDenseIntervalY(options = {}) {
-  return maybeDenseInterval(binY, "x", withTip(options, "y"));
+export function maybeDenseIntervalY({x = identity, y = indexOf, ...options} = {}) {
+  return maybeDenseInterval(binY, "x", withTip({x, y, ...options}, "y"));
 }
 
 function binn(

src/transforms/identity.js

@@ -1,9 +1,9 @@
 import {hasX, hasY, identity} from "../options.js";
 
-export function maybeIdentityX(options = {}, k = "x") {
-  return hasX(options) ? options : {...options, [k]: identity};
+export function maybeIdentityX(options) {
+  return hasX(options) ? options : {...options, x: identity};
 }
 
-export function maybeIdentityY(options = {}, k = "y") {
-  return hasY(options) ? options : {...options, [k]: identity};
+export function maybeIdentityY(options) {
+  return hasY(options) ? options : {...options, y: identity};
 }