ggaction 0.0.11 → 0.0.13

package/src/grammar/arcs.js

@@ -17,12 +17,30 @@ function requireArcLayer(layer) {
     throw new Error("Arc derivation requires a semantic arc mark.");
   }
   const theta = layer.encoding?.theta;
-  if (theta === undefined || !["nominal", "ordinal"].includes(theta.fieldType)) {
-    throw new Error(`Arc mark "${layer.id}" requires categorical theta.`);
+  if (
+    theta === undefined ||
+    !["quantitative", "nominal", "ordinal"].includes(theta.fieldType)
+  ) {
+    throw new Error(
+      `Arc mark "${layer.id}" requires quantitative or categorical theta.`
+    );
   }
   return theta;
 }
 
+function requireContinuousThetaScale(scale, label) {
+  if (
+    scale?.type !== "linear" ||
+    !Array.isArray(scale.range) ||
+    scale.range.length !== 2 ||
+    !scale.range.every(Number.isFinite) ||
+    scale.range[0] === scale.range[1]
+  ) {
+    throw new Error(`${label} requires a resolved linear scale.`);
+  }
+  return scale;
+}
+
 function requireBandScale(scale, label) {
   if (
     scale?.type !== "band" ||
@@ -45,24 +63,90 @@ function colorValues(rows, encoding) {
     : readNominalField(rows, encoding.field);
 }
 
-export function readArcThetaWeights(rows, field, layerId = "arc") {
-  if (!Array.isArray(rows)) throw new TypeError("Arc theta weights require rows.");
+function readNonNegativeArcThetaValues(rows, field, layerId, role) {
+  if (!Array.isArray(rows)) throw new TypeError(`Arc theta ${role}s require rows.`);
   if (typeof field !== "string" || field.length === 0) {
-    throw new TypeError("Arc theta weight must be a non-empty string.");
+    throw new TypeError(`Arc theta ${role} must be a non-empty string.`);
   }
-  const weights = rows.map((row, index) => {
+  const values = rows.map((row, index) => {
     const value = row?.[field];
     if (!Number.isFinite(value) || value < 0) {
       throw new TypeError(
-        `Arc theta weight field "${field}" must contain non-negative finite numbers at row ${index}.`
+        `Arc theta ${role} field "${field}" must contain non-negative finite numbers at row ${index}.`
       );
     }
     return value;
   });
-  if (weights.every(value => value === 0)) {
-    throw new Error(`Arc mark "${layerId}" theta weights must have a positive total.`);
+  if (values.every(value => value === 0)) {
+    throw new Error(`Arc mark "${layerId}" theta ${role}s must have a positive total.`);
   }
-  return cloneAndFreeze(weights);
+  return cloneAndFreeze(values);
+}
+
+export function readArcThetaWeights(rows, field, layerId = "arc") {
+  return readNonNegativeArcThetaValues(rows, field, layerId, "weight");
+}
+
+export function readArcThetaValues(rows, field, layerId = "arc") {
+  return readNonNegativeArcThetaValues(rows, field, layerId, "value");
+}
+
+function resolveProportionalRanges(values, range, labelAt) {
+  const total = values.reduce((sum, value) => sum + value, 0);
+  const normalizedTotal = Number.isFinite(total)
+    ? undefined
+    : normalizedFiniteSum(values, "Arc theta values");
+  if (total === 0 || normalizedTotal?.total <= 0) {
+    throw new Error("Arc theta values must have a positive total.");
+  }
+  const span = range[1] - range[0];
+  let cursor = range[0];
+  let cumulative = 0;
+  let cumulativeCorrection = 0;
+  return values.map((value, index) => {
+    const normalizedValue = normalizedTotal === undefined
+      ? value
+      : value / normalizedTotal.scale;
+    const next = cumulative + normalizedValue;
+    if (normalizedTotal !== undefined) {
+      cumulativeCorrection += Math.abs(cumulative) >= Math.abs(normalizedValue)
+        ? cumulative - next + normalizedValue
+        : normalizedValue - next + cumulative;
+    }
+    cumulative = next;
+    const directEnd = cursor + value / total * span;
+    const endTheta = index === values.length - 1
+      ? range[1]
+      : normalizedTotal === undefined && Number.isFinite(directEnd)
+        ? directEnd
+        : interpolateNumber(
+            range[0],
+            range[1],
+            (cumulative + cumulativeCorrection) /
+              (normalizedTotal?.total ?? total)
+          );
+    if (!Number.isFinite(endTheta) || endTheta === cursor) {
+      throw new RangeError(
+        `Arc theta ${labelAt(index)} cannot resolve a distinct finite sector.`
+      );
+    }
+    const result = { startTheta: cursor, endTheta };
+    cursor = endTheta;
+    return result;
+  });
+}
+
+function resolveProportionalRadii(layer, frame, innerRadiusRatio) {
+  if (!Number.isFinite(frame?.availableRadius) || frame.availableRadius < 0) {
+    throw new RangeError(`Arc mark "${layer.id}" requires a finite available radius.`);
+  }
+  return {
+    innerRadius: requireFiniteResult(
+      frame.availableRadius * innerRadiusRatio,
+      `Arc mark "${layer.id}" inner radius`
+    ),
+    outerRadius: frame.availableRadius
+  };
 }
 
 function proportionalSectors(rows, layer, thetaScale, frame, innerRadiusRatio) {
@@ -87,14 +171,7 @@ function proportionalSectors(rows, layer, thetaScale, frame, innerRadiusRatio) {
       weight: weights[index]
     });
   }
-  if (!Number.isFinite(frame?.availableRadius) || frame.availableRadius < 0) {
-    throw new RangeError(`Arc mark "${layer.id}" requires a finite available radius.`);
-  }
-  const innerRadius = requireFiniteResult(
-    frame.availableRadius * innerRadiusRatio,
-    `Arc mark "${layer.id}" inner radius`
-  );
-  let cursor = thetaScale.range[0];
+  const radii = resolveProportionalRadii(layer, frame, innerRadiusRatio);
   const sectors = [];
   const positiveValues = thetaScale.domain.filter(value =>
     groups.get(value).some(item => item.weight > 0)
@@ -103,48 +180,15 @@ function proportionalSectors(rows, layer, thetaScale, frame, innerRadiusRatio) {
     groups.get(value).map(item => item.weight),
     `Arc theta group "${String(value)}" aggregate`
   ));
-  const total = aggregateValues.reduce((sum, value) => sum + value, 0);
-  const normalizedTotal = Number.isFinite(total)
-    ? undefined
-    : normalizedFiniteSum(
-        aggregateValues,
-        `Arc mark "${layer.id}" theta aggregates`
-      );
-  if (total === 0 || normalizedTotal?.total <= 0) {
-    throw new Error(`Arc mark "${layer.id}" has no positive theta weight.`);
-  }
-  const span = thetaScale.range[1] - thetaScale.range[0];
-  let cumulative = 0;
-  let cumulativeCorrection = 0;
+  const ranges = resolveProportionalRanges(
+    aggregateValues,
+    thetaScale.range,
+    index => `group "${String(positiveValues[index])}"`
+  );
   for (const [positiveIndex, value] of positiveValues.entries()) {
     const group = groups.get(value);
     const aggregateValue = aggregateValues[positiveIndex];
-    const normalizedValue = normalizedTotal === undefined
-      ? aggregateValue
-      : aggregateValue / normalizedTotal.scale;
-    const next = cumulative + normalizedValue;
-    if (normalizedTotal !== undefined) {
-      cumulativeCorrection += Math.abs(cumulative) >= Math.abs(normalizedValue)
-        ? cumulative - next + normalizedValue
-        : normalizedValue - next + cumulative;
-    }
-    cumulative = next;
-    const directEnd = cursor + aggregateValue / total * span;
-    const endTheta = positiveIndex === positiveValues.length - 1
-      ? thetaScale.range[1]
-      : normalizedTotal === undefined && Number.isFinite(directEnd)
-        ? directEnd
-        : interpolateNumber(
-            thetaScale.range[0],
-            thetaScale.range[1],
-            (cumulative + cumulativeCorrection) /
-              (normalizedTotal?.total ?? total)
-          );
-    if (!Number.isFinite(endTheta) || endTheta === cursor) {
-      throw new RangeError(
-        `Arc theta group "${String(value)}" cannot resolve a distinct finite sector.`
-      );
-    }
+    const { startTheta, endTheta } = ranges[positiveIndex];
     const distinctColors = [...new Set(group.map(item => item.color))];
     if (distinctColors.length > 1) {
       throw new Error(
@@ -157,17 +201,101 @@ function proportionalSectors(rows, layer, thetaScale, frame, innerRadiusRatio) {
       count: group.length,
       aggregateValue,
       color: distinctColors[0],
-      startTheta: cursor,
+      startTheta,
       endTheta,
-      innerRadius,
-      outerRadius: frame.availableRadius,
+      ...radii,
       sourceIndices: group.map(item => item.sourceIndex)
     });
-    cursor = endTheta;
   }
   return sectors;
 }
 
+function quantitativeSectors(rows, layer, thetaScale, frame, innerRadiusRatio) {
+  const theta = layer.encoding.theta;
+  if (layer.encoding?.radius !== undefined) {
+    throw new Error(
+      `Arc mark "${layer.id}" cannot combine quantitative theta with radius.`
+    );
+  }
+  const values = readArcThetaValues(rows, theta.field, layer.id);
+  const colors = colorValues(rows, layer.encoding?.color);
+  const positiveIndices = values
+    .map((value, index) => value > 0 ? index : undefined)
+    .filter(index => index !== undefined);
+  const positiveValues = positiveIndices.map(index => values[index]);
+  const ranges = resolveProportionalRanges(
+    positiveValues,
+    thetaScale.range,
+    index => `row ${positiveIndices[index]}`
+  );
+  const radii = resolveProportionalRadii(layer, frame, innerRadiusRatio);
+  return positiveIndices.map((sourceIndex, index) => ({
+    key: `${String(values[sourceIndex])}:${sourceIndex}`,
+    theta: values[sourceIndex],
+    count: 1,
+    aggregateValue: values[sourceIndex],
+    color: colors[sourceIndex],
+    ...ranges[index],
+    ...radii,
+    sourceIndices: [sourceIndex]
+  }));
+}
+
+export function deriveMeasuredArcValues(rows, layer) {
+  const theta = requireArcLayer(layer);
+  const radius = layer.encoding?.radius;
+  if (!["nominal", "ordinal"].includes(theta.fieldType) || theta.aggregate !== undefined ||
+    !["count", "sum"].includes(radius?.aggregate) || radius.fieldType !== "quantitative") {
+    throw new Error("Measured Arc requires equal-angle categorical theta and count or sum radius.");
+  }
+  if (radius.aggregate === "count" && Object.hasOwn(radius, "field")) {
+    throw new Error("Measured count radius does not accept a field.");
+  }
+  const categories = readNominalField(rows, theta.field);
+  const measures = radius.aggregate === "count" ? rows.map(() => 1)
+    : readQuantitativeField(rows, radius.field);
+  if (measures.some(value => value < 0)) {
+    throw new RangeError("Measured Arc radius inputs must be non-negative.");
+  }
+  const colors = colorValues(rows, layer.encoding?.color);
+  const groups = new Map();
+  for (const [index, category] of categories.entries()) {
+    const group = groups.get(category) ?? { key: category, sourceIndices: [], values: [], colors: [] };
+    group.sourceIndices.push(index);
+    group.values.push(measures[index]);
+    group.colors.push(colors[index]);
+    groups.set(category, group);
+  }
+  const result = [...groups.values()].map(group => {
+    const distinctColors = [...new Set(group.colors)];
+    if (distinctColors.length > 1) {
+      throw new Error(`Measured Arc category "${group.key}" must resolve to one color value.`);
+    }
+    return { key: group.key, theta: group.key, count: group.sourceIndices.length,
+      radius: stableFiniteSum(group.values, "Measured Arc radius aggregate"),
+      color: distinctColors[0], sourceIndices: group.sourceIndices };
+  });
+  if (!result.some(group => group.radius > 0)) {
+    throw new Error("Measured Arc radius requires at least one positive category aggregate.");
+  }
+  return cloneAndFreeze(result);
+}
+
+function measuredRadialSectors(rows, layer, thetaScale, radiusScale) {
+  const items = deriveMeasuredArcValues(rows, layer);
+  const centers = mapOrdinalPositionValues(items.map(item => item.theta), thetaScale);
+  const radii = mapContinuousScaleValues(items.map(item => item.radius), radiusScale);
+  const halfBand = (Math.sign(thetaScale.step) || 1) * thetaScale.bandwidth / 2;
+  const byCategory = new Map(items.map((item, index) => [item.theta, {
+    ...item, startTheta: centers[index] - halfBand, endTheta: centers[index] + halfBand,
+    innerRadius: radiusScale.range[0], outerRadius: radii[index]
+  }]));
+  return thetaScale.domain.flatMap(category => {
+    const item = byCategory.get(category);
+    return item === undefined || item.radius === 0 ? [] : [item];
+  });
+}
+
 function radialSectors(rows, layer, thetaScale, radiusScale) {
   const theta = layer.encoding.theta;
   const radius = layer.encoding?.radius;
@@ -223,7 +351,6 @@ export function deriveArcSectors(rows, layer, {
 } = {}) {
   if (!Array.isArray(rows)) throw new TypeError("Arc derivation requires rows.");
   const theta = requireArcLayer(layer);
-  requireBandScale(thetaScale, `Arc mark "${layer.id}" theta`);
   if (
     !Number.isFinite(innerRadiusRatio) ||
     innerRadiusRatio < 0 ||
@@ -231,8 +358,29 @@ export function deriveArcSectors(rows, layer, {
   ) {
     throw new RangeError("Arc innerRadius must be from 0 (inclusive) to 1 (exclusive).");
   }
-  const sectors = ["count", "sum"].includes(theta.aggregate)
-    ? proportionalSectors(rows, layer, thetaScale, frame, innerRadiusRatio)
-    : radialSectors(rows, layer, thetaScale, radiusScale);
+  const sectors = radiusScale?.radialMapping !== undefined
+    ? measuredRadialSectors(rows, layer, requireBandScale(thetaScale, `Arc mark "${layer.id}" theta`), radiusScale)
+    : theta.fieldType === "quantitative"
+    ? quantitativeSectors(
+        rows,
+        layer,
+        requireContinuousThetaScale(thetaScale, `Arc mark "${layer.id}" theta`),
+        frame,
+        innerRadiusRatio
+      )
+    : ["count", "sum"].includes(theta.aggregate)
+      ? proportionalSectors(
+          rows,
+          layer,
+          requireBandScale(thetaScale, `Arc mark "${layer.id}" theta`),
+          frame,
+          innerRadiusRatio
+        )
+      : radialSectors(
+          rows,
+          layer,
+          requireBandScale(thetaScale, `Arc mark "${layer.id}" theta`),
+          radiusScale
+        );
   return cloneAndFreeze({ sectors });
 }

package/src/grammar/areaEndpoints.js

@@ -0,0 +1,46 @@
+import { validateKeys, validateNonEmptyString } from "../core/validation.js";
+import { isPlainObject } from "../core/immutable.js";
+import { readQuantitativeField } from "./scales/fields.js";
+
+export function validateAreaMissing(value = "error") {
+  if (!["error", "break"].includes(value)) {
+    throw new Error('Area missing must be "error" or "break".');
+  }
+  return value;
+}
+
+export function normalizeAreaBound(bound) {
+  if (typeof bound === "string") return { field: validateNonEmptyString(bound, "Area endpoint field") };
+  if (!isPlainObject(bound)) throw new TypeError("Area bound must be a field or datum object.");
+  validateKeys(bound, ["datum"], "Area bound");
+  if (!Number.isFinite(bound.datum)) throw new TypeError("Area datum must be finite.");
+  return { datum: bound.datum };
+}
+
+export function readAreaEndpoint(rows, encoding, missing = "error") {
+  if (Object.hasOwn(encoding, "datum")) {
+    if (Object.hasOwn(encoding, "field") || !Number.isFinite(encoding.datum) || encoding.fieldType !== "quantitative") {
+      throw new TypeError("Area endpoint requires exactly one finite quantitative datum or field.");
+    }
+    return rows.map(() => encoding.datum);
+  }
+  if (missing !== "break") return readQuantitativeField(rows, encoding.field);
+  validateNonEmptyString(encoding.field, "Area endpoint field");
+  if (rows.length > 0 && !rows.some(row => Object.hasOwn(row, encoding.field))) {
+    throw new Error(`Area endpoint field "${encoding.field}" does not exist.`);
+  }
+  return rows.map((row, index) => {
+    const value = row[encoding.field];
+    if (value == null) return null;
+    if (!Number.isFinite(value)) {
+      throw new TypeError(`Field "${encoding.field}" must contain a finite number at row ${index}.`);
+    }
+    return value;
+  });
+}
+
+export function validateAreaEndpointPair(primary, secondary) {
+  if (primary?.datum !== undefined && secondary?.datum !== undefined) {
+    throw new Error("Area range requires at least one field endpoint.");
+  }
+}

package/src/grammar/areaSeries.js

@@ -1,15 +1,11 @@
 import { cloneAndFreeze } from "../core/immutable.js";
-import {
-  readNominalField,
-  readQuantitativeField,
-  readTemporalField
-} from "./scales/index.js";
-import {
-  layoutSeriesPartition,
-  validateColorLayout
-} from "./seriesLayout.js";
+import { readNominalField, readQuantitativeField, readTemporalField } from "./scales/index.js";
+import { layoutSeriesPartition, validateColorLayout } from "./seriesLayout.js";
 import { stableOrderPathValues } from "./pathOrder.js";
 import { deriveCategoricalDensitySeries } from "./categoricalDensity.js";
+import { validatePathSeriesAppearance } from "./pathSeries.js";
+import { readAreaEndpoint, validateAreaEndpointPair } from "./areaEndpoints.js";
+import { validateGeneratedItemLimit } from "../core/validation.js";
 
 function indexSegments(segments) {
   const indexed = [];
@@ -21,7 +17,7 @@ export function deriveAreaSeries(rows, layer) {
   if (layer?.mark?.type !== "area") {
     throw new Error("Area series derivation requires a semantic area mark.");
   }
-  const { x, y, x2, y2, group, color } = layer.encoding ?? {};
+  const { x, y, x2, y2 } = layer.encoding ?? {};
   const vertical =
     ["quantitative", "temporal"].includes(x?.fieldType) &&
     y?.fieldType === "quantitative" &&
@@ -37,26 +33,19 @@ export function deriveAreaSeries(rows, layer) {
       `Area mark "${layer.id}" requires exactly one quantitative x/x2 or y/y2 range and one quantitative or temporal independent position.`
     );
   }
-  if (group !== undefined && group.fieldType !== "nominal") {
-    throw new Error(`Area group encoding on mark "${layer.id}" must be nominal.`);
-  }
+  const grouping = validatePathSeriesAppearance(rows, layer);
   const orientation = vertical ? "vertical" : "horizontal";
   const independent = vertical ? x : y;
   const independentValues = independent.fieldType === "temporal"
-    ? readTemporalField(rows, independent.field)
+    ? readTemporalField(rows, independent.field, independent.temporalUnit)
     : readQuantitativeField(rows, independent.field);
-  const lower = vertical
-    ? readQuantitativeField(rows, y.field)
-    : readQuantitativeField(rows, x.field);
-  const upper = vertical
-    ? readQuantitativeField(rows, y2.field)
-    : readQuantitativeField(rows, x2.field);
-  const groupValues = group === undefined
-    ? rows.map(() => undefined)
-    : readNominalField(rows, group.field);
-  const colorValues = color === undefined
-    ? rows.map(() => undefined)
-    : readNominalField(rows, color.field);
+  if (Object.hasOwn(independent, "datum")) throw new Error("Area independent position requires a field.");
+  const primary = vertical ? y : x;
+  const secondary = vertical ? y2 : x2;
+  validateAreaEndpointPair(primary, secondary);
+  const missing = layer.mark.missing ?? "error";
+  const lower = readAreaEndpoint(rows, primary, missing);
+  const upper = readAreaEndpoint(rows, secondary, missing);
   const pathOrder = layer.encoding?.pathOrder;
   const orderValues = pathOrder === undefined
     ? undefined
@@ -64,32 +53,24 @@ export function deriveAreaSeries(rows, layer) {
   const groups = new Map();
 
   for (let index = 0; index < rows.length; index += 1) {
-    const key = groupValues[index];
+    const tuple = grouping.map(field => rows[index][field]);
+    const key = JSON.stringify(tuple);
     const series = groups.get(key) ?? {
-      key: {
-        ...(group === undefined ? {} : { [group.field]: key }),
-        ...(color === undefined ? {} : { [color.field]: colorValues[index] })
-      },
+      key: Object.fromEntries(grouping.map((field, i) => [field, tuple[i]])),
       values: []
     };
-    if (
-      color !== undefined &&
-      !Object.is(series.key[color.field], colorValues[index])
-    ) {
-      throw new Error(
-        `Area series "${String(key)}" must have one color value.`
-      );
-    }
     series.values.push(vertical
       ? {
           x: independentValues[index],
           y: lower[index],
           y2: upper[index],
+          ...(missing === "break" ? { sourceIndex: index } : {}),
           ...(orderValues === undefined ? {} : { pathOrder: orderValues[index] })
         }
       : {
           x: lower[index],
           x2: upper[index],
+          ...(missing === "break" ? { sourceIndex: index } : {}),
           y: independentValues[index],
           ...(orderValues === undefined ? {} : { pathOrder: orderValues[index] })
         });
@@ -98,7 +79,8 @@ export function deriveAreaSeries(rows, layer) {
   if (groups.size === 0) {
     throw new Error(`Area mark "${layer.id}" has no values.`);
   }
-  const series = [...groups.values()].map(item => {
+  layoutRawAreaGroups(groups, { layer, vertical, primary, secondary });
+  const series = [...groups.values()].flatMap(item => {
     const key = vertical ? "x" : "y";
     const values = pathOrder === undefined
       ? item.values.sort((left, right) => left[key] - right[key])
@@ -107,6 +89,22 @@ export function deriveAreaSeries(rows, layer) {
           item.values.map(value => value.pathOrder),
           pathOrder.order
         );
+    if (missing === "break") {
+      const segments = [];
+      let segment = [];
+      const emit = () => {
+        if (segment.length >= 2) segments.push({ key: item.key,
+          sourceIndices: segment.map(value => value.sourceIndex),
+          values: segment.map(({ sourceIndex, ...value }) => value) });
+        segment = [];
+      };
+      for (const value of values) {
+        if ((vertical ? value.y == null || value.y2 == null : value.x == null || value.x2 == null)) emit();
+        else segment.push(value);
+      }
+      emit();
+      return segments;
+    }
     if (values.length < 2) {
       throw new Error(
         `Area series on mark "${layer.id}" requires at least two points.`
@@ -114,6 +112,7 @@ export function deriveAreaSeries(rows, layer) {
     }
     return { key: item.key, values };
   });
+  if (series.length === 0) throw new Error(`Area mark "${layer.id}" has no valid segment with at least two points.`);
   return cloneAndFreeze({
     orientation,
     xValues: series.flatMap(item => item.values.flatMap(value =>
@@ -151,7 +150,7 @@ export function deriveCenteredAreaSeries(rows, layer) {
     );
   }
   const xValues = x.fieldType === "temporal"
-    ? readTemporalField(rows, x.field)
+    ? readTemporalField(rows, x.field, x.temporalUnit)
     : readQuantitativeField(rows, x.field);
   const yValues = readQuantitativeField(rows, y.field);
   const groups = readNominalField(rows, group.field);
@@ -359,3 +358,50 @@ export function layoutDensityAreaSeries(derived, layout = "overlay") {
     }))
   });
 }
+
+export function layoutRawAreaGroups(groups, { layer, vertical, primary, secondary }) {
+  const mode = layer.layout?.mode ?? "overlay";
+  validateColorLayout(mode);
+  if (mode === "overlay") return;
+  if (mode === "group" || (mode === "center" && !vertical)) {
+    throw new Error(`Area layout "${mode}" is incompatible with this orientation.`);
+  }
+  const primaryDatum = Object.hasOwn(primary, "datum");
+  const secondaryDatum = Object.hasOwn(secondary, "datum");
+  if (primaryDatum === secondaryDatum || (primaryDatum ? primary.datum : secondary.datum) !== 0) {
+    throw new Error("Stacked area requires one value field and one zero datum endpoint.");
+  }
+  const position = vertical ? "x" : "y";
+  const lower = vertical ? "y" : "x", upper = `${lower}2`;
+  const measure = primaryDatum ? upper : lower;
+  const series = [...groups.values()];
+  const indices = series.map(item => {
+    const index = new Map();
+    for (const value of item.values) {
+      if (index.has(value[position])) throw new Error("Area layout requires unique group/position rows.");
+      index.set(value[position], value);
+    }
+    return index;
+  });
+  const positions = [...new Set(series.flatMap(item => item.values.map(value => value[position])))].sort((a, b) => a - b);
+  validateGeneratedItemLimit(positions.length * series.length, "Area layout cell count");
+  if (indices.some(index => index.size !== positions.length || positions.some(value => !index.has(value)))) {
+    throw new Error("Area layout requires an aligned row for every group and position.");
+  }
+  for (const position of positions) {
+    const points = indices.map(index => index.get(position));
+    if (points.some(point => point[measure] == null)) {
+      for (const point of points) { point[lower] = null; point[upper] = null; }
+      continue;
+    }
+    const segments = layoutSeriesPartition(points.map(point => point[measure]), mode);
+    const byIndex = new Map(segments.map(segment => [segment.index, segment]));
+    let endpoint = mode === "center" ? segments[0]?.start ?? 0 : 0;
+    points.forEach((point, index) => {
+      const segment = byIndex.get(index);
+      point[lower] = segment?.start ?? (mode === "diverging" ? 0 : endpoint);
+      point[upper] = segment?.end ?? (mode === "diverging" ? 0 : endpoint);
+      if (segment !== undefined && mode !== "diverging") endpoint = segment.end;
+    });
+  }
+}

package/src/grammar/bars/aggregate.js

@@ -1,15 +1,9 @@
+import { readSeriesIdentity } from "../pathSeries.js";
 import { cloneAndFreeze } from "../../core/immutable.js";
 import { readNominalField, readTemporalField } from "../scales/index.js";
-import {
-  aggregateRows,
-  validateAggregateFieldType,
-  validateAggregateFieldValues,
-} from "../aggregate.js";
-import {
-  BAR_GRAINS,
-  resolveBarChannels,
-  resolveBarGrain
-} from "./policy.js";
+import { aggregateRows, validateAggregateFieldType, validateAggregateFieldValues } from "../aggregate.js";
+import { BAR_GRAINS, resolveBarChannels, resolveBarGrain, resolveBarColorLayout } from "./policy.js";
+import { layoutSeriesPartition } from "../seriesLayout.js";
 
 function requireAggregateBarEncoding(layer) {
   if (layer?.mark?.type !== "bar") {
@@ -33,7 +27,7 @@ export function deriveBarAggregates(rows, layer) {
   const { channels, category, measure } = requireAggregateBarEncoding(layer);
   validateAggregateFieldValues(rows, measure.field, measure.fieldType);
   const categoryValues = category.fieldType === "temporal"
-    ? readTemporalField(rows, category.field)
+    ? readTemporalField(rows, category.field, category.temporalUnit)
     : readNominalField(rows, category.field);
   const color = layer.encoding?.color;
   let colorValues;
@@ -52,17 +46,23 @@ export function deriveBarAggregates(rows, layer) {
       );
     }
   }
+  const identity = layer.encoding?.group === undefined ? undefined : readSeriesIdentity(rows, layer);
   const groups = new Map();
 
   for (let index = 0; index < rows.length; index += 1) {
     const categoryValue = categoryValues[index];
     const colorValue = colorValues?.[index];
-    const key = JSON.stringify([categoryValue, colorValue]);
+    const seriesValue = identity?.values[index];
+    const key = JSON.stringify([categoryValue, identity === undefined ? colorValue : seriesValue]);
     const group = groups.get(key) ?? {
       category: categoryValue,
+      ...(identity === undefined ? {} : { series: seriesValue }),
       ...(colorValues === undefined ? {} : { color: colorValue }),
       rows: []
     };
+    if (identity !== undefined && colorValues !== undefined && group.color !== colorValue) {
+      throw new Error("Bar color requires one categorical value within each aggregate cell.");
+    }
     group.rows.push(rows[index]);
     groups.set(key, group);
   }
@@ -82,6 +82,7 @@ export function deriveBarAggregates(rows, layer) {
       x: channels.category === "x" ? group.category : value,
       y: channels.category === "y" ? group.category : value,
       ...(color === undefined ? {} : { color: aggregateColor }),
+      ...(identity === undefined ? {} : { series: group.series }),
       count: group.rows.length
     }];
   });
@@ -96,3 +97,23 @@ export function deriveBarAggregates(rows, layer) {
     values
   });
 }
+
+export function deriveSeriesBarCells(rows, layer, categoryDomain, seriesDomain) {
+  const channels = resolveBarChannels(layer);
+  const values = deriveBarAggregates(rows, layer).values;
+  const identity = readSeriesIdentity(rows, layer);
+  const categories = categoryDomain ?? [...new Set(values.map(cell => cell[channels.category]))].sort((a, b) => a - b);
+  const seriesKey = cell => layer.encoding.group !== undefined ? cell.series : layer.encoding.color?.fieldType === "quantitative" ? undefined : cell.color;
+  const series = seriesDomain ?? (layer.encoding.group !== undefined ? identity.domain : [...new Set(values.map(seriesKey))]);
+  const cells = new Map(values.map(cell => [JSON.stringify([cell[channels.category], seriesKey(cell)]), cell]));
+  const layout = resolveBarColorLayout(layer);
+  return categories.flatMap(category => {
+    const partition = series.map(key => cells.get(JSON.stringify([category, key])));
+    const segments = layout === "group"
+      ? partition.flatMap((cell, index) => cell === undefined ? [] : [{ index, start: 0, end: cell[channels.measure] }])
+      : layoutSeriesPartition(partition.map(cell => cell?.[channels.measure] ?? 0), layout);
+    return segments.flatMap(segment => partition[segment.index] === undefined ? [] : [{
+      cell: partition[segment.index], start: segment.start, end: segment.end, seriesIndex: segment.index
+    }]);
+  });
+}