ggaction 0.0.12 → 0.0.15

package/src/actions/scales/channels.js

@@ -0,0 +1,212 @@
+import { action } from "../../core/action.js";
+import { validateUserId } from "../../core/identifiers.js";
+import { validateOptionObject } from "../../core/validation.js";
+import { normalizePositionScaleChannel } from "../../core/vocabulary.js";
+import { findLayer } from "../../selectors/layers.js";
+import { requireSemanticScale } from "../../selectors/scales.js";
+import { findScaleConsumers } from "./consumers/index.js";
+
+const DEFINITIONS = Object.freeze({
+  editXScale: Object.freeze({
+    channel: "x",
+    options: Object.freeze([
+      "type", "domain", "range", "nice", "zero", "clamp", "reverse",
+      "base", "exponent", "constant", "paddingInner", "paddingOuter",
+      "padding", "align", "unknown"
+    ])
+  }),
+  editYScale: Object.freeze({
+    channel: "y",
+    options: Object.freeze([
+      "type", "domain", "range", "nice", "zero", "clamp", "reverse",
+      "base", "exponent", "constant", "paddingInner", "paddingOuter",
+      "padding", "align", "unknown"
+    ])
+  }),
+  editThetaScale: Object.freeze({
+    channel: "theta",
+    options: Object.freeze([
+      "type", "domain", "range", "nice", "zero", "clamp", "reverse",
+      "paddingInner", "paddingOuter", "padding", "align"
+    ])
+  }),
+  editRScale: Object.freeze({
+    channel: "radius",
+    options: Object.freeze([
+      "type", "domain", "range", "nice", "zero", "clamp", "reverse",
+      "base", "exponent", "constant", "radialMapping"
+    ])
+  }),
+  editColorScale: Object.freeze({
+    channel: "color",
+    options: Object.freeze([
+      "type", "domain", "range", "clamp", "reverse", "palette",
+      "interpolate", "midpoint", "unknown"
+    ])
+  }),
+  editStrokeScale: Object.freeze({
+    channel: "stroke",
+    targetOnly: true,
+    options: Object.freeze([
+      "type", "domain", "range", "clamp", "reverse", "palette",
+      "interpolate", "midpoint", "unknown"
+    ])
+  }),
+  editSizeScale: Object.freeze({
+    channel: "size",
+    options: Object.freeze([
+      "type", "domain", "range", "unknown", "clamp", "reverse", "base",
+      "exponent"
+    ])
+  }),
+  editOpacityScale: Object.freeze({
+    channel: "opacity",
+    options: Object.freeze([
+      "type", "domain", "range", "nice", "zero", "clamp", "reverse", "unknown"
+    ])
+  }),
+  editShapeScale: Object.freeze({
+    channel: "shape",
+    options: Object.freeze(["type", "domain", "range", "unknown"])
+  }),
+  editStrokeWidthScale: Object.freeze({
+    channel: "strokeWidth",
+    options: Object.freeze([
+      "type", "domain", "range", "nice", "zero", "clamp", "reverse",
+      "base", "exponent", "constant"
+    ])
+  }),
+  editStrokeDashScale: Object.freeze({
+    channel: "strokeDash",
+    options: Object.freeze(["type", "domain", "range"])
+  })
+});
+
+function scaleIdsForLayer(program, layer, channel) {
+  if (layer === undefined) return [];
+  return [...new Set(allConsumers(program)
+    .filter(consumer =>
+      consumer.layer.id === layer.id &&
+      normalizePositionScaleChannel(consumer.channel) === channel
+    )
+    .map(consumer => consumer.encoding.scale))];
+}
+
+function allConsumers(program) {
+  return program.semanticSpec.scales.flatMap(scale =>
+    findScaleConsumers(program, scale.id)
+  );
+}
+
+function channelScaleIds(program, channel) {
+  return [...new Set(allConsumers(program)
+    .filter(consumer => normalizePositionScaleChannel(consumer.channel) === channel)
+    .map(consumer => consumer.encoding.scale))];
+}
+
+function requireSingleScale(ids, operation, scope) {
+  if (ids.length === 1) return ids[0];
+  if (ids.length === 0) {
+    throw new Error(`${operation} could not find a ${scope} scale.`);
+  }
+  throw new Error(`${operation} ${scope} scale is ambiguous; provide id or target.`);
+}
+
+function validateScaleChannel(program, id, channel, operation) {
+  requireSemanticScale(program, id);
+  const consumers = findScaleConsumers(program, id);
+  if (consumers.length === 0) {
+    throw new Error(`${operation} requires a scale bound to the ${channel} channel.`);
+  }
+  const compatible = ["color", "stroke"].includes(channel)
+    ? new Set(["color", "stroke"])
+    : new Set([channel]);
+  if (!consumers.some(consumer =>
+    normalizePositionScaleChannel(consumer.channel) === channel
+  ) || consumers.some(consumer =>
+    !compatible.has(normalizePositionScaleChannel(consumer.channel))
+  )) {
+    throw new Error(
+      `Scale "${id}" must include a ${channel} channel consumer and no incompatible channel consumers.`
+    );
+  }
+  return id;
+}
+
+function resolveScaleId(program, args, channel, operation) {
+  const explicitId = args.id === undefined
+    ? undefined
+    : validateUserId(args.id, "Scale id");
+  const target = args.target === undefined
+    ? undefined
+    : validateUserId(args.target, "Mark id");
+  const targetLayer = target === undefined ? undefined : findLayer(program, target);
+  if (target !== undefined && targetLayer === undefined) {
+    throw new Error(`Unknown mark target "${target}".`);
+  }
+  const targetId = targetLayer === undefined
+    ? undefined
+    : requireSingleScale(scaleIdsForLayer(program, targetLayer, channel), operation, `target ${channel}`);
+  if (explicitId !== undefined && targetId !== undefined && explicitId !== targetId) {
+    throw new Error(`${operation} id "${explicitId}" does not match target "${target}" scale "${targetId}".`);
+  }
+  if (explicitId !== undefined) {
+    return validateScaleChannel(program, explicitId, channel, operation);
+  }
+  if (targetId !== undefined) return validateScaleChannel(program, targetId, channel, operation);
+
+  const current = findLayer(program, program.context.currentMark);
+  const currentIds = scaleIdsForLayer(program, current, channel);
+  if (currentIds.length > 1) {
+    throw new Error(`${operation} current-mark ${channel} scale is ambiguous; provide id or target.`);
+  }
+  if (currentIds.length === 1) {
+    return validateScaleChannel(program, currentIds[0], channel, operation);
+  }
+  return validateScaleChannel(
+    program,
+    requireSingleScale(channelScaleIds(program, channel), operation, channel),
+    channel,
+    operation
+  );
+}
+
+function createChannelScaleEditor(operation, definition) {
+  return action(
+    {
+      op: operation,
+      description: `Edit the scale bound to the ${definition.channel} channel.`
+    },
+    function (args = {}) {
+      validateOptionObject(
+        args,
+        [...(definition.targetOnly === true ? [] : ["id"]), "target", ...definition.options],
+        operation
+      );
+      if (definition.targetOnly === true && args.target === undefined) {
+        throw new Error(`${operation} requires target.`);
+      }
+      if (!definition.options.some(property => Object.hasOwn(args, property))) {
+        throw new Error(`${operation} requires at least one editable property.`);
+      }
+      const id = resolveScaleId(this, args, definition.channel, operation);
+      const patch = Object.fromEntries(
+        Object.entries(args).filter(([property]) => property !== "target")
+      );
+      return this.editScale({ ...patch, id });
+    }
+  );
+}
+
+export const channelScaleEditors = Object.freeze(Object.fromEntries(
+  Object.entries(DEFINITIONS).map(([operation, definition]) => [
+    operation,
+    createChannelScaleEditor(operation, definition)
+  ])
+));
+
+export function registerChannelScaleActions(ProgramClass) {
+  for (const [operation, editor] of Object.entries(channelScaleEditors)) {
+    ProgramClass.prototype[operation] = editor;
+  }
+}

package/src/actions/scales/consumers/common.js

@@ -1,9 +1,7 @@
-import {
-  readNominalField,
-  readQuantitativeField,
-  readScaleField,
-  readTemporalField
-} from "../../../grammar/scales/index.js";
+import { isSourceOwnedText } from "../../../grammar/text.js";
+import { readSeriesIdentity } from "../../../grammar/pathSeries.js";
+import { readAreaEndpoint } from "../../../grammar/areaEndpoints.js";
+import { readScaleField } from "../../../grammar/scales/index.js";
 import { findDataset } from "../../../selectors/datasets.js";
 import { requireSemanticScale } from "../../../selectors/scales.js";
 import { SCALED_ENCODING_CHANNELS } from "../../../core/vocabulary.js";
@@ -15,6 +13,7 @@ export function findScale(program, id) {
 export function findScaleConsumers(program, id) {
   const consumers = [];
   for (const layer of program.semanticSpec.layers) {
+    if (isSourceOwnedText(layer)) continue;
     for (const channel of SCALED_ENCODING_CHANNELS) {
       const encoding = layer.encoding?.[channel];
       if (encoding?.scale === id) consumers.push({ layer, channel, encoding });
@@ -44,9 +43,9 @@ export function requireConsumerDataset(program, consumer) {
 }
 
 export function isDirectCategoricalConsumer(consumer) {
-  return ["color", "strokeDash", "xOffset", "yOffset", "shape"].includes(
+  return ["color", "stroke", "strokeDash", "xOffset", "yOffset", "shape"].includes(
     consumer.channel
-  ) && consumer.encoding.fieldType === "nominal";
+  ) && ["nominal", "ordinal"].includes(consumer.encoding.fieldType);
 }
 
 export function readConsumerFieldValues(
@@ -55,55 +54,23 @@ export function readConsumerFieldValues(
   dataset,
   scale = findScale(program, consumer.encoding.scale)
 ) {
-  const allowUnknown = Object.hasOwn(scale, "unknown");
-  if (consumer.role === "parallelDimension") {
-    return readScaleField(
-      dataset.values,
-      consumer.encoding.field,
-      consumer.encoding.fieldType,
-      { allowUnknown: true }
-    );
-  }
-  if (isDirectCategoricalConsumer(consumer)) {
-    return allowUnknown
-      ? readScaleField(
-          dataset.values,
-          consumer.encoding.field,
-          consumer.encoding.fieldType,
-          { allowUnknown: true }
-        )
-      : readNominalField(dataset.values, consumer.encoding.field);
-  }
-  if (consumer.encoding.fieldType === "temporal") {
-    return allowUnknown
-      ? readScaleField(dataset.values, consumer.encoding.field, "temporal", {
-          allowUnknown: true
-        })
-      : readTemporalField(dataset.values, consumer.encoding.field);
+  const { field, fieldType, temporalUnit } = consumer.encoding;
+  if (consumer.layer.mark.type === "bar" && consumer.layer.encoding?.group !== undefined && ["xOffset", "yOffset"].includes(consumer.channel)) {
+    return readSeriesIdentity(dataset.values, consumer.layer).values;
   }
-  if (["nominal", "ordinal"].includes(consumer.encoding.fieldType)) {
-    if (!["ordinal", "band", "point"].includes(scale.type)) {
-      throw new Error(
-        `Scale materialization requires a quantitative encoding on mark "${consumer.layer.id}".`
-      );
-    }
-    return allowUnknown
-      ? readScaleField(
-          dataset.values,
-          consumer.encoding.field,
-          consumer.encoding.fieldType,
-          { allowUnknown: true }
-        )
-      : readNominalField(dataset.values, consumer.encoding.field);
-  }
-  if (consumer.encoding.fieldType !== "quantitative") {
+  const parallel = consumer.role === "parallelDimension";
+  if (!parallel && !isDirectCategoricalConsumer(consumer) &&
+    fieldType !== "quantitative" && fieldType !== "temporal" &&
+    (!["nominal", "ordinal"].includes(fieldType) ||
+      !["ordinal", "band", "point"].includes(scale.type))) {
     throw new Error(
       `Scale materialization requires a quantitative encoding on mark "${consumer.layer.id}".`
     );
   }
-  return allowUnknown
-    ? readScaleField(dataset.values, consumer.encoding.field, "quantitative", {
-        allowUnknown: true
-      })
-    : readQuantitativeField(dataset.values, consumer.encoding.field);
+  if (consumer.layer.mark.type === "area" && ["x", "y", "x2", "y2"].includes(consumer.channel) && fieldType === "quantitative") {
+    return readAreaEndpoint(dataset.values, consumer.encoding, consumer.layer.mark.missing).filter(value => value != null);
+  }
+  return readScaleField(dataset.values, field, fieldType, {
+    allowUnknown: parallel || Object.hasOwn(scale, "unknown"), temporalUnit
+  });
 }

package/src/actions/scales/consumers/families.js

@@ -1,3 +1,5 @@
+import { isPendingMeasuredRadiusConsumer } from "../../../materialization/scales/policies/arc.js";
+import { deriveMeasuredArcValues } from "../../../grammar/arcs.js";
 import { deriveBarAggregates } from "../../../grammar/bars/aggregate.js";
 import {
   BAR_GRAINS,
@@ -5,9 +7,9 @@ import {
 } from "../../../grammar/bars/policy.js";
 import {
   deriveLineSeries,
-  deriveLineSeriesFieldValues,
   resolveLineBins
 } from "../../../grammar/lineSeries.js";
+import { derivePathSeriesFieldValues } from "../../../grammar/pathSeries.js";
 import { isAggregate } from "../../../grammar/aggregate.js";
 import {
   resolveRectConsumerValues
@@ -26,6 +28,11 @@ function lineDerivationOptions(program, consumer, dataset) {
 }
 
 export function resolveMarkFamilyConsumerValues(program, consumer, dataset) {
+  if (consumer.layer.mark?.type === "arc" && consumer.channel === "radius" &&
+    findScale(program, consumer.encoding.scale).radialMapping !== undefined) {
+    return { matched: true, values: isPendingMeasuredRadiusConsumer(consumer) ? [] : deriveMeasuredArcValues(dataset.values, consumer.layer).map(item => item.radius) };
+  }
+
   if (consumer.layer.mark?.type === "rect") {
     return {
       matched: true,
@@ -36,29 +43,36 @@ export function resolveMarkFamilyConsumerValues(program, consumer, dataset) {
       )
     };
   }
+  const { layer, channel } = consumer;
+  const encoding = layer.encoding ?? {};
+  const appearance = ["stroke", "strokeWidth", "opacity"].includes(channel);
   if (
-    consumer.layer.mark?.type === "line" &&
-    ((consumer.layer.encoding?.x !== undefined &&
-      isAggregate(consumer.layer.encoding?.y?.aggregate) &&
-      !(consumer.channel === "x" &&
-        consumer.layer.encoding?.x?.bin !== undefined)) ||
-      consumer.channel === "strokeWidth")
+    layer.mark?.type === "line" &&
+    ((["x", "y"].includes(channel) && encoding.x !== undefined &&
+      isAggregate(encoding.y?.aggregate) &&
+      !(channel === "x" &&
+        encoding.x?.bin !== undefined)) ||
+      appearance) &&
+    encoding.parallel === undefined &&
+    ((encoding.x !== undefined && encoding.y !== undefined) ||
+      (encoding.theta !== undefined && encoding.radius !== undefined))
   ) {
     const derived = deriveLineSeries(
       dataset.values,
-      consumer.layer,
+      layer,
       lineDerivationOptions(program, consumer, dataset)
     );
     return {
       matched: true,
-      values: consumer.channel === "strokeWidth"
-        ? deriveLineSeriesFieldValues(
+      values: appearance
+        ? derivePathSeriesFieldValues(
             dataset.values,
-            consumer.layer,
-            derived,
-            consumer.encoding.field
+            derived.series,
+            consumer.encoding.field,
+            channel,
+            consumer.encoding
           )
-        : consumer.channel === "x" ? derived.xValues : derived.yValues
+        : channel === "x" ? derived.xValues : derived.yValues
     };
   }
   if (resolveBarGrain(consumer.layer) === BAR_GRAINS.aggregate) {

package/src/actions/scales/consumers/index.js

@@ -1,4 +1,6 @@
+import { readAreaEndpoint } from "../../../grammar/areaEndpoints.js";
 import { normalizeRuleDatum } from "../../../grammar/rules.js";
+import { normalizePositionDatum } from "../../../grammar/positionDatum.js";
 import {
   findScale,
   isDirectCategoricalConsumer,
@@ -6,7 +8,9 @@ import {
   requireConsumerDataset
 } from "./common.js";
 import { resolveMarkFamilyConsumerValues } from "./families.js";
-import { resolveCategoryOrder } from "../../../grammar/categoryOrder.js";
+import { CATEGORY_ORDER_CHANNELS, resolveCategoryOrder } from "../../../grammar/categoryOrder.js";
+import { resolveHistogramInput } from
+  "../../../materialization/bars/histogram.js";
 
 export { findScale, findScaleConsumers } from "./common.js";
 export {
@@ -14,13 +18,27 @@ export {
   resolveSeriesLayoutScaleValues
 } from "./seriesLayout.js";
 
-export function resolveConsumerValues(program, consumer) {
-  const dataset = requireConsumerDataset(program, consumer);
+export function resolveConsumerValuesForDataset(program, consumer, dataset) {
+  if (consumer.layer.mark.type === "rect") return resolveMarkFamilyConsumerValues(program, consumer, dataset).values;
   if (Object.hasOwn(consumer.encoding, "datum")) {
+    if (consumer.layer.mark.type === "area") {
+      readAreaEndpoint(dataset.values, consumer.encoding, consumer.layer.mark.missing);
+      return [consumer.encoding.datum];
+    }
+    if (consumer.layer.mark.type === "text") {
+      return [normalizePositionDatum(
+        consumer.encoding.datum,
+        consumer.encoding.fieldType,
+        consumer.channel,
+        consumer.encoding.temporalUnit,
+        "Text"
+      )];
+    }
     return [normalizeRuleDatum(
       consumer.encoding.datum,
       consumer.encoding.fieldType,
-      consumer.channel
+      consumer.channel,
+      consumer.encoding.temporalUnit
     )];
   }
   if (
@@ -32,6 +50,14 @@ export function resolveConsumerValues(program, consumer) {
     );
   }
   const scale = findScale(program, consumer.encoding.scale);
+  if (
+    consumer.layer.mark.type === "bar" &&
+    consumer.channel === "x" &&
+    consumer.encoding.bin !== undefined &&
+    consumer.encoding.weight !== undefined
+  ) {
+    return resolveHistogramInput(dataset, consumer.encoding).values;
+  }
   if (isDirectCategoricalConsumer(consumer)) {
     return readConsumerFieldValues(program, consumer, dataset, scale);
   }
@@ -41,9 +67,21 @@ export function resolveConsumerValues(program, consumer) {
     : readConsumerFieldValues(program, consumer, dataset, scale);
 }
 
+export function resolveConsumerValues(program, consumer) {
+  return resolveConsumerValuesForDataset(
+    program,
+    consumer,
+    requireConsumerDataset(program, consumer)
+  );
+}
+
 export function resolveConsumerCategoryOrder(program, consumer) {
   const order = consumer.encoding.categoryOrder;
   if (order === undefined) return undefined;
+  if (!CATEGORY_ORDER_CHANNELS.includes(consumer.channel) ||
+    !["nominal", "ordinal"].includes(consumer.encoding.fieldType)) {
+    throw new Error("Remove category order before assigning a non-categorical position.");
+  }
   const dataset = requireConsumerDataset(program, consumer);
   return resolveCategoryOrder(dataset.values, consumer.encoding.field, order);
 }

package/src/actions/scales/consumers/seriesLayout.js

@@ -1,3 +1,5 @@
+import { readSeriesIdentity } from "../../../grammar/pathSeries.js";
+import { deriveAreaSeries } from "../../../grammar/areaSeries.js";
 import { deriveBarAggregates } from "../../../grammar/bars/aggregate.js";
 import { validateGeneratedItemLimit } from "../../../core/validation.js";
 import {
@@ -7,7 +9,6 @@ import {
   resolveBarGrain
 } from "../../../grammar/bars/policy.js";
 import {
-  countHistogramBins,
   findHistogramBinIndex,
   resolveHistogramBins
 } from "../../../grammar/histogram.js";
@@ -20,11 +21,12 @@ import {
 } from "../../../grammar/seriesLayout.js";
 import {
   readNominalField,
-  readQuantitativeField,
   resolveOrdinalDomain
 } from "../../../grammar/scales/index.js";
 import { findDataset } from "../../../selectors/datasets.js";
 import { findScale } from "./common.js";
+import { resolveHistogramInput } from
+  "../../../materialization/bars/histogram.js";
 
 export function resolveHistogramCountValues(program, consumer) {
   const xEncoding = consumer.layer.encoding?.x;
@@ -42,7 +44,8 @@ export function resolveHistogramCountValues(program, consumer) {
       `Histogram mark "${consumer.layer.id}" requires an existing dataset.`
     );
   }
-  const xValues = readQuantitativeField(dataset.values, xEncoding.field);
+  const input = resolveHistogramInput(dataset, xEncoding);
+  const xValues = input.values;
   const bins = resolveHistogramBins({
     values: xValues,
     bin: xEncoding.bin,
@@ -50,7 +53,12 @@ export function resolveHistogramCountValues(program, consumer) {
     nice: xScale.nice ?? true,
     zero: xScale.zero ?? false
   });
-  return countHistogramBins(xValues, bins.boundaries);
+  const cells = bins.boundaries.slice(0, -1).map(() => []);
+  xValues.forEach((value, index) => {
+    const bin = findHistogramBinIndex(value, bins.boundaries);
+    if (bin !== -1) cells[bin].push(input.entries[index]);
+  });
+  return cells.map(input.mass);
 }
 
 function resolveHistogramPartitions(program, consumer) {
@@ -58,7 +66,8 @@ function resolveHistogramPartitions(program, consumer) {
   const dataset = findDataset(program, layer.data);
   const xEncoding = layer.encoding.x;
   const xScale = findScale(program, xEncoding.scale);
-  const xValues = readQuantitativeField(dataset.values, xEncoding.field);
+  const input = resolveHistogramInput(dataset, xEncoding);
+  const xValues = input.values;
   const bins = resolveHistogramBins({
     values: xValues,
     bin: xEncoding.bin,
@@ -67,11 +76,25 @@ function resolveHistogramPartitions(program, consumer) {
     zero: xScale.zero ?? false
   });
   const colorEncoding = layer.encoding?.color;
+  if (layer.encoding?.group !== undefined) {
+    const identity = readSeriesIdentity(input.rows, layer);
+    validateGeneratedItemLimit((bins.boundaries.length - 1) * identity.domain.length, "Histogram layout cell count");
+    const cells = bins.boundaries.slice(0, -1).map(() => identity.domain.map(() => []));
+    const groups = new Map(identity.domain.map((value, index) => [value, index]));
+    xValues.forEach((value, index) => { const bin = findHistogramBinIndex(value, bins.boundaries);
+      if (bin !== -1) cells[bin][groups.get(identity.values[index])].push(input.entries[index]); });
+    return cells.map(partition => partition.map(input.mass));
+  }
   if (colorEncoding?.scale === undefined) {
-    return countHistogramBins(xValues, bins.boundaries).map(value => [value]);
+    const cells = bins.boundaries.slice(0, -1).map(() => []);
+    xValues.forEach((value, index) => {
+      const bin = findHistogramBinIndex(value, bins.boundaries);
+      if (bin !== -1) cells[bin].push(input.entries[index]);
+    });
+    return cells.map(entries => [input.mass(entries)]);
   }
   const colorScale = findScale(program, colorEncoding.scale);
-  const colorValues = readNominalField(dataset.values, colorEncoding.field);
+  const colorValues = readNominalField(input.rows, colorEncoding.field);
   const colorDomain = resolveOrdinalDomain(colorScale.domain, colorValues);
   validateGeneratedItemLimit(
     (bins.boundaries.length - 1) * colorDomain.length,
@@ -79,14 +102,16 @@ function resolveHistogramPartitions(program, consumer) {
   );
   const colorIndex = new Map(colorDomain.map((value, index) => [value, index]));
   const partitions = bins.boundaries.slice(0, -1).map(() =>
-    colorDomain.map(() => 0)
+    colorDomain.map(() => [])
   );
   for (let index = 0; index < xValues.length; index += 1) {
     const bin = findHistogramBinIndex(xValues[index], bins.boundaries);
     const color = colorIndex.get(colorValues[index]);
-    if (bin !== -1 && color !== undefined) partitions[bin][color] += 1;
+    if (bin !== -1 && color !== undefined) {
+      partitions[bin][color].push(input.entries[index]);
+    }
   }
-  return partitions;
+  return partitions.map(partition => partition.map(input.mass));
 }
 
 function resolveAggregatePartitions(program, consumer) {
@@ -101,6 +126,12 @@ function resolveAggregatePartitions(program, consumer) {
     : derived.yValues;
   const categoryDomain = resolveOrdinalDomain(categoryScale.domain, categoryValues);
   const colorEncoding = layer.encoding?.color;
+  if (layer.encoding?.group !== undefined) {
+    const series = readSeriesIdentity(dataset.values, layer).domain;
+    validateGeneratedItemLimit(categoryDomain.length * series.length, "Aggregate layout cell count");
+    const cells = new Map(derived.values.map(value => [JSON.stringify([value[channels.category], value.series]), value[channels.measure]]));
+    return categoryDomain.map(category => series.map(key => cells.get(JSON.stringify([category, key])) ?? 0));
+  }
   if (
     colorEncoding?.scale === undefined ||
     colorEncoding.fieldType === "quantitative"
@@ -181,11 +212,25 @@ export function resolveSeriesLayoutScaleValues(program, consumer) {
       values: resolveSeriesLayoutDomainValues(partitions, layout)
     };
   }
+  if (consumer.layer.mark?.type === "area" && consumer.layer.layout?.mode !== undefined) {
+    const layer = consumer.layer;
+    const dataset = findDataset(program, layer.data);
+    const density = dataset.transform?.some(transform => transform.type === "density");
+    if (!density && (layer.encoding?.x === undefined || layer.encoding?.y === undefined || (layer.encoding?.x2 === undefined && layer.encoding?.y2 === undefined))) return undefined;
+    if (!density && layer.encoding?.x !== undefined && layer.encoding?.y !== undefined && (layer.encoding?.x2 !== undefined || layer.encoding?.y2 !== undefined)) {
+      const derived = deriveAreaSeries(dataset.values, layer);
+      const measure = derived.orientation === "vertical" ? "y" : "x";
+      if (![measure, `${measure}2`].includes(consumer.channel)) return undefined;
+      const layout = layer.layout.mode;
+      if (layout === "overlay") return undefined;
+      return { layout, values: layout === "fill" ? [0, 1] : derived[`${measure}Values`] };
+    }
+  }
   if (consumer.channel !== "y") return undefined;
   if (consumer.layer.mark?.type === "area") {
-    const layout = consumer.layer.encoding?.y?.stack === "center"
+    const layout = consumer.layer.layout?.mode ?? (consumer.layer.encoding?.y?.stack === "center"
       ? "center"
-      : consumer.layer.encoding?.color?.layout;
+      : consumer.layer.encoding?.color?.layout);
     if (layout === undefined || layout === "overlay") return undefined;
     const partitions = resolveAreaPartitions(program, consumer);
     if (partitions === undefined) {