ggaction 0.0.11 → 0.0.13

package/src/materialization/facetGuides/preparation.js

@@ -149,6 +149,27 @@ function compatibleLegendChildren(program, source, inferred) {
   });
 }
 
+function promotedLegendPlacement(source, kinds) {
+  const positioned = kinds.map(kind => source.guideConfigs.legend[kind])
+    .filter(config => config.position !== undefined);
+  const positions = new Set(positioned.map(config => config.position));
+  if (positions.size > 1) {
+    throw new Error(
+      "Shared facet legends must use one common edge position."
+    );
+  }
+  const aligns = new Set(positioned.map(config => config.align ?? "center"));
+  if (aligns.size > 1) {
+    throw new Error(
+      "Shared facet legends must use one common alignment."
+    );
+  }
+  return {
+    position: positioned[0]?.position ?? "right",
+    align: positioned[0]?.align ?? "center"
+  };
+}
+
 export function prepareSharedFacetLegend(program) {
   if (program.compositionSpec.facet.guides.legend !== "shared") {
     return undefined;
@@ -176,6 +197,8 @@ export function prepareSharedFacetLegend(program) {
     throw new Error("Shared facet legend has no measurable concrete bounds.");
   }
   const gradient = kinds.includes("gradient");
+  const placement = promotedLegendPlacement(source, kinds);
+  const width = Math.ceil(bounds.right - bounds.left);
   return {
     mode: "promoted",
     source,
@@ -185,8 +208,10 @@ export function prepareSharedFacetLegend(program) {
     bounds,
     compatibility,
     reservation: {
+      ...placement,
       gap: gradient ? 24 : 18,
-      width: gradient ? 112 : Math.max(132, Math.ceil(bounds.right - bounds.left))
+      width: Math.max(gradient ? 112 : 132, width),
+      height: Math.ceil(bounds.bottom - bounds.top)
     }
   };
 }

package/src/materialization/facets.js

@@ -162,10 +162,17 @@ export function resolveFacetProgramLayout(program, preparedLegend) {
   }
   const title = titleLayout(program);
   const spec = program.compositionSpec;
+  const gridCells = new Map(
+    (spec.facet.grid?.cells ?? []).map(cell => [cell.id, cell])
+  );
   const layout = resolveFacetLayout({
     children: spec.children.map((id, index) => ({
       ...compositionChildDescriptor(id, program.children[id]),
-      value: spec.facet.values[index]
+      value: spec.facet.values[index],
+      ...(gridCells.has(id) ? {
+        row: gridCells.get(id).row,
+        column: gridCells.get(id).column
+      } : {})
     })),
     columns: spec.columns,
     gap: spec.gap,
@@ -175,7 +182,9 @@ export function resolveFacetProgramLayout(program, preparedLegend) {
     sharedLegend: spec.facet.guides.legend === "shared",
     ...(preparedLegend === undefined ? {} : {
       sharedLegendGap: preparedLegend.reservation.gap,
-      sharedLegendWidth: preparedLegend.reservation.width
+      sharedLegendWidth: preparedLegend.reservation.width,
+      sharedLegendHeight: preparedLegend.reservation.height,
+      sharedLegendPosition: preparedLegend.reservation.position
     })
   });
   const plots = spec.children.map(id => ({

package/src/materialization/guides/layout.js

@@ -0,0 +1,57 @@
+import { assertGuideCollisionBlocks } from "../../layout/guideCollisions.js";
+import { unionConcreteGraphicBounds } from "../../grammar/schemas/graphicBounds.js";
+import { axisGraphicIds, legendResourcePolicies } from "./resources.js";
+
+// Only domain-owned guides participate. Extension primitives may deliberately
+// overlap, and a combined categorical/size legend is one occupied group.
+export function resolveGuideCollisionBlocks(graphicSpec, guideConfigs, titleConfig) {
+  const blocks = [];
+  const append = (id, kind, position, ids) => {
+    if (position === undefined) return;
+    const existing = ids.filter(id => graphicSpec.objects[id] !== undefined);
+    const bounds = unionConcreteGraphicBounds(graphicSpec, existing);
+    if (bounds !== undefined) blocks.push({ id, kind, position, bounds });
+  };
+  append("chart title", "title", titleConfig?.position, ["chartTitle", "chartSubtitle"]);
+  for (const channel of ["x", "y"]) {
+    for (const id of axisGraphicIds(channel)) {
+      const component = id.slice(`${channel}Axis`.length).toLowerCase();
+      append(`${channel}-axis ${component}`, "axis", guideConfigs.axis?.[channel]?.[component]?.position, [id]);
+    }
+  }
+  const policies = legendResourcePolicies();
+  const configs = guideConfigs.legend ?? {};
+  const categorical = policies.find(policy => policy.family === "categorical" && configs[policy.kind] !== undefined);
+  const combined = categorical !== undefined && configs.size !== undefined &&
+    configs[categorical.kind].target === configs.size.target;
+  for (const policy of policies) {
+    const config = configs[policy.kind];
+    if (config === undefined || combined && policy.kind === "size") continue;
+    const ids = combined && policy === categorical
+      ? [...policy.graphicIds, ...policies.find(item => item.kind === "size").graphicIds]
+      : policy.graphicIds;
+    append(`${policy.kind}${combined && policy === categorical ? "+size" : ""} legend`, "legend", config.position, ids);
+  }
+  return blocks;
+}
+
+
+// Defer cross-guide checks while sibling materializers still carry old
+// coordinates. The scope is transient and never survives a returned program.
+export function withGuideLayoutTransaction(program, apply) {
+  if (program.context.deferGuideLayoutValidation === true) return apply(program);
+  const result = apply(program._withContext({ deferGuideLayoutValidation: true }));
+  const { deferGuideLayoutValidation: _deferred, ...context } = result.context;
+  if (Object.hasOwn(program.context, "deferGuideLayoutValidation")) {
+    context.deferGuideLayoutValidation = program.context.deferGuideLayoutValidation;
+  }
+  const next = result._clone({ context });
+  assertGuideCollisionBlocks(resolveGuideCollisionBlocks(next.graphicSpec, next.guideConfigs, next.titleConfig));
+  return next;
+}
+
+export function withGuideLayoutValidation(implementation) {
+  return function (args) {
+    return withGuideLayoutTransaction(this, program => implementation.call(program, args));
+  };
+}

package/src/materialization/guides/resources.js

@@ -27,7 +27,7 @@ const LEGEND_RESOURCE_POLICIES = Object.freeze({
     family: "size",
     rematerializeOp: "rematerializeSizeLegend",
     graphicIds: Object.freeze([
-      "sizeLegendSymbols", "sizeLegendLabels", "sizeLegendTitle"
+      "sizeLegendBackground", "sizeLegendSymbols", "sizeLegendLabels", "sizeLegendTitle"
     ])
   }),
   gradient: Object.freeze({
@@ -62,7 +62,7 @@ const LEGEND_RESOURCE_POLICIES = Object.freeze({
     family: "strokeWidth",
     rematerializeOp: "rematerializeStrokeWidthLegend",
     graphicIds: Object.freeze([
-      "strokeWidthLegendSymbols", "strokeWidthLegendLabels",
+      "strokeWidthLegendBackground", "strokeWidthLegendSymbols", "strokeWidthLegendLabels",
       "strokeWidthLegendTitle"
     ])
   })

package/src/materialization/legends.js

@@ -1,5 +1,11 @@
+import { findLayer } from "../selectors/layers.js";
 import { LEGEND_CONFIG_KINDS } from "../core/vocabulary.js";
 
+export function isOpacityLegendLayer(layer) {
+  return ["point", "line"].includes(layer.mark?.type) &&
+    layer.encoding?.opacity?.scale !== undefined;
+}
+
 export function hasMaterializedLegend(program) {
   return LEGEND_CONFIG_KINDS.some(kind => {
     const config = program.guideConfigs?.legend?.[kind];
@@ -15,6 +21,9 @@ export function materializedLegendUsesScale(program, id) {
   return LEGEND_CONFIG_KINDS.some(kind => {
     const config = program.guideConfigs?.legend?.[kind];
     if (config === undefined) return false;
-    return config.scale === id || config.scales?.includes(id);
+    const order = program.semanticSpec.guides.legend?.[kind]?.order;
+    const linkedScale = order?.channel === undefined ? undefined
+      : findLayer(program, config.target)?.encoding?.[order.channel]?.scale;
+    return config.scale === id || config.scales?.includes(id) || linkedScale === id;
   });
 }

package/src/materialization/marks/capabilities.js

@@ -108,11 +108,19 @@ export function isIntentionallyEmptyArea(program, layer) {
 export function canMaterializeArc(_program, layer) {
   if (
     layer.mark?.type !== "arc" ||
-    layer.encoding?.theta?.scale === undefined ||
-    !["nominal", "ordinal"].includes(layer.encoding.theta.fieldType)
+    layer.encoding?.theta?.scale === undefined
   ) {
     return false;
   }
+  if (layer.encoding.theta.fieldType === "quantitative") {
+    return (
+      layer.encoding.theta.aggregate === undefined &&
+      layer.encoding?.radius === undefined
+    );
+  }
+  if (!["nominal", "ordinal"].includes(layer.encoding.theta.fieldType)) {
+    return false;
+  }
   if (["count", "sum"].includes(layer.encoding.theta.aggregate)) {
     return layer.encoding?.radius === undefined;
   }
@@ -137,9 +145,9 @@ export function canMaterializeBar(program, layer) {
   ) {
     const offsetChannel = resolveBarOffsetChannel(layer);
     return (
-      layer.encoding?.color?.field !== undefined &&
-      layer.encoding?.[offsetChannel]?.field === layer.encoding.color.field &&
-      layer.encoding[offsetChannel].scale !== undefined
+      (layer.encoding?.group !== undefined || (layer.encoding?.color?.field !== undefined &&
+      layer.encoding?.[offsetChannel]?.field === layer.encoding.color.field)) &&
+      layer.encoding[offsetChannel]?.scale !== undefined
     );
   }
   return true;
@@ -155,14 +163,29 @@ export function canMaterializeRule(program, layer) {
   );
 }
 
+const TEXT_SOURCE_CAPABILITIES = Object.freeze({
+  point: canMaterializePoint,
+  line: canMaterializeLine,
+  bar: canMaterializeBar,
+  rule: canMaterializeRule,
+  rect: (program, layer) => canMaterializeRect(program, layer) ||
+    program.markConfigs[layer.id]?.gradientPlot?.materialized === true,
+  arc: canMaterializeArc
+});
+
+export function isTextSource(layer) {
+  return layer?.data !== undefined &&
+    Object.hasOwn(TEXT_SOURCE_CAPABILITIES, layer.mark?.type);
+}
+
 export function canMaterializeText(program, layer) {
   if (layer.mark?.type !== "text" || layer.encoding?.text === undefined) {
     return false;
   }
   if (layer.source !== undefined) {
     const source = findLayer(program, layer.source);
-    return source !== undefined &&
-      ["point", "bar", "rule", "rect", "arc"].includes(source.mark?.type) &&
+    return isTextSource(source) &&
+      TEXT_SOURCE_CAPABILITIES[source.mark.type](program, source) &&
       Array.isArray(program.graphicSpec.objects[source.id]?.items);
   }
   return hasCartesianPositionScales(layer);

package/src/materialization/marks/grouping.js

@@ -0,0 +1,52 @@
+import { findUpstreamTransform } from "../dataProvenance.js";
+import { readPathSeriesFields, validatePathSeriesAppearance } from "../../grammar/pathSeries.js";
+
+export function validatePathGroupAppearance(program, layer, dataset) {
+  if (layer.mark.type === "area" && findUpstreamTransform(program, dataset, "density")) {
+    // Density placement owns a category/split grain beyond the visible group field.
+    readPathSeriesFields(dataset.values, layer);
+    return;
+  }
+  validatePathSeriesAppearance(dataset.values, layer);
+}
+
+export function assertPathGroupCompatible(program, layer, dataset, group) {
+  if (layer.encoding?.parallel !== undefined) {
+    throw new Error("Parallel paths have row identity and do not support encodeGroup.");
+  }
+  const field = group?.field;
+  for (const [type, editor] of [
+    ["density", "editDensity"],
+    ["horizon", "editHorizon"],
+    ["regression", "editRegression"],
+    ["interval", "editErrorBand"]
+  ]) {
+    const transform = findUpstreamTransform(program, dataset, type);
+    if (transform === undefined) continue;
+    const fields = type === "horizon" ? [transform.as.group]
+      : type === "interval"
+        ? transform.groupBy.filter(value =>
+            value !== layer.encoding?.x?.field && value !== layer.encoding?.y?.field
+          )
+        : [transform.groupBy];
+    if (group?.fields !== undefined || group === undefined ||
+        field === undefined || !fields.includes(field)) {
+      throw new Error(
+        `${type === "density" ? "Density area" : type + " path"} mark "${layer.id}" must group by ${fields.length === 1 && fields[0] !== undefined ? JSON.stringify(fields[0]) : "its owned field"}; use ${editor}.`
+      );
+    }
+  }
+  if (layer.layout?.mode !== undefined) {
+    if (group === undefined && !["overlay"].includes(layer.layout.mode)) throw new Error("Remove active series layout before removing its group.");
+    return;
+  }
+  if (layer.mark?.type === "area" && (
+    layer.encoding?.y?.stack === "center" ||
+    ![undefined, "overlay"].includes(layer.encoding?.color?.layout)
+  )) {
+    if (group?.fields !== undefined ||
+        (layer.encoding?.color !== undefined && field !== layer.encoding.color.field)) {
+      throw new Error("Area layout requires one group field matching its color field.");
+    }
+  }
+}

package/src/materialization/marks/index.js

@@ -1,5 +1,11 @@
-import { POSITION_CHANNELS } from "../../core/vocabulary.js";
+import { isSourceOwnedText } from "../../grammar/text.js";
+import { findLayer } from "../../selectors/layers.js";
+import {
+  POSITION_CHANNELS,
+  POSITION_ENCODING_CHANNELS
+} from "../../core/vocabulary.js";
 import { getMarkMaterializationPolicy } from "./policies.js";
+import { buildMaterializationPlan } from "../planner.js";
 
 export {
   canMaterializeArc,
@@ -10,10 +16,29 @@ export {
   canMaterializeRect,
   canMaterializeRule,
   canMaterializeText,
-  canMaterializeTick
+  canMaterializeTick,
+  isTextSource
 } from "./capabilities.js";
 
-export function getMarkRematerializationStep(layer) {
+export function getLayerScaleIds(layer) {
+  if (isSourceOwnedText(layer)) return [];
+  return [
+    ...Object.values(layer.encoding ?? {}).map(encoding => encoding?.scale),
+    ...(layer.encoding?.parallel?.dimensions ?? []).map(dimension => dimension.scale)
+  ].filter(scale => scale !== undefined);
+}
+
+export function getScaleConsumerMarkSteps(program, scaleIds) {
+  return program.semanticSpec.layers
+    .filter(layer => getLayerScaleIds(layer).some(id => scaleIds.includes(id)))
+    .map(layer => getMarkMaterializationStep(program, layer))
+    .filter(step => step !== undefined);
+}
+
+export function getMarkRematerializationStep(program, layer) {
+  if (program.markConfigs?.[layer.id]?.markFilter?.empty === true) {
+    return { op: "materializeEmptyMark", args: { id: layer.id } };
+  }
   const policy = getMarkMaterializationPolicy(layer);
   return policy === undefined
     ? undefined
@@ -25,14 +50,15 @@ export function getMarkMaterializationStep(program, layer) {
   if (policy === undefined || !policy.canMaterialize(program, layer)) {
     return undefined;
   }
-  return getMarkRematerializationStep(layer);
+  return getMarkRematerializationStep(program, layer);
 }
 
 export function getSourceDependentMarkSteps(program, sourceId) {
-  return program.semanticSpec.layers.flatMap(layer =>
+  return (program.semanticSpec.layers ?? []).flatMap(layer =>
     layer.source === sourceId &&
     getMarkMaterializationPolicy(layer)?.sourceDependent === true
-      ? [getMarkMaterializationStep(program, layer)].filter(
+      ? [getMarkMaterializationStep(program, layer) ??
+          getExistingMarkRematerializationStep(program, layer)].filter(
           step => step !== undefined
         )
       : []
@@ -43,39 +69,39 @@ export function getPositionEncodingMaterializationSteps(program, layer, scaleId)
   const policy = getMarkMaterializationPolicy(layer);
   if (policy === undefined) return [];
   const complete = policy.canMaterialize(program, layer);
-  const mark = getMarkRematerializationStep(layer);
+  const mark = getMarkRematerializationStep(program, layer);
   const sharedConsumerMarks = (program.semanticSpec.layers ?? [])
     .filter(candidate =>
       candidate.id !== layer.id &&
+      !isSourceOwnedText(candidate) &&
       POSITION_CHANNELS.some(channel =>
         candidate.encoding?.[channel]?.scale === scaleId
       )
     )
     .map(candidate => getMarkMaterializationStep(program, candidate))
     .filter(step => step !== undefined);
+  const dependentMarks = [mark, ...sharedConsumerMarks]
+    .flatMap(step => getSourceDependentMarkSteps(program, step.args.id));
   const scale = {
     op: "rematerializeScale",
     args: sharedConsumerMarks.length === 0
       ? { id: scaleId }
       : { id: scaleId, marks: false }
   };
-  if (!complete) {
-    if (policy.positionEncoding.incomplete === "scale") {
-      return [scale, ...sharedConsumerMarks];
-    }
-    return policy.positionEncoding.scaleFirst
+  const direct = !complete && policy.positionEncoding.incomplete === "scale"
+    ? [scale, ...sharedConsumerMarks]
+    : policy.positionEncoding.scaleFirst
       ? [scale, mark, ...sharedConsumerMarks]
       : [mark, ...sharedConsumerMarks];
-  }
-  return policy.positionEncoding.scaleFirst
-    ? [scale, mark, ...sharedConsumerMarks]
-    : [mark, ...sharedConsumerMarks];
+  return buildMaterializationPlan({ marks: [...direct, ...dependentMarks] });
 }
 
 export function getScaleConsumerMaterializationMode(layer, channel) {
   const policy = getMarkMaterializationPolicy(layer);
   if (policy === undefined) return "direct";
-  if (POSITION_CHANNELS.includes(channel)) {
+  if (POSITION_ENCODING_CHANNELS.includes(channel)) {
+    // Attached labels require their source's completed geometry, after scales.
+    if (layer.source !== undefined && policy.sourceDependent === true) return "defer";
     return policy.scaleApplication.position ?? policy.scaleApplication.default;
   }
   if (policy.scaleApplication.deferredChannels?.includes(channel)) {
@@ -96,7 +122,7 @@ export function getExistingMarkRematerializationStep(program, layer) {
   ) {
     return undefined;
   }
-  return getMarkRematerializationStep(layer);
+  return getMarkRematerializationStep(program, layer);
 }
 
 export function getEncodingMaterializationStages(program, layer, channel, scale) {
@@ -108,22 +134,34 @@ export function getEncodingMaterializationStages(program, layer, channel, scale)
         args: { id: scale, guides: false, marks: false }
       }]
     : [];
-  const shared = policy.encoding?.sharedChannels?.includes(channel) === true &&
-    scale !== undefined;
+  const shared = scale !== undefined && (
+    scales.length > 0 || policy.encoding?.sharedChannels?.includes(channel) === true
+  );
   const candidates = shared
     ? program.semanticSpec.layers.filter(candidate =>
-        candidate.mark?.type === layer.mark?.type &&
-        candidate.encoding?.[channel]?.scale === scale
+        candidate.id === layer.id || candidate.encoding?.[channel]?.scale === scale
       )
     : [layer];
   const marks = candidates.flatMap(candidate => {
-    if (policy.encoding?.skipRematerialization?.(program, candidate) === true) {
+    const candidatePolicy = getMarkMaterializationPolicy(candidate);
+    if (candidatePolicy?.encoding?.skipRematerialization?.(program, candidate) === true) {
       return [];
     }
-    const step = policy.encoding?.completeOnly === true
+    const step = candidate.id !== layer.id || candidatePolicy?.encoding?.completeOnly === true
       ? getMarkMaterializationStep(program, candidate)
-      : getMarkRematerializationStep(candidate);
+      : getMarkRematerializationStep(program, candidate);
     return step === undefined ? [] : [step];
   });
   return { scales, marks };
 }
+
+// Reuse a plan's scale stage only when it covers every scale consumed by the mark.
+export function reusePlannedMarkScales(program, steps, scaleIds) {
+  const resolved = new Set(scaleIds);
+  return steps.map(step => {
+    const layer = findLayer(program, step.args?.id);
+    if (layer === undefined || getMarkMaterializationPolicy(layer)?.acceptsResolvedScales !== true ||
+        !getLayerScaleIds(layer).every(id => resolved.has(id))) return step;
+    return { ...step, args: { ...step.args, scales: false } };
+  });
+}

package/src/materialization/marks/policies.js

@@ -40,7 +40,9 @@ const MARK_MATERIALIZATION_POLICIES = Object.freeze({
   line: Object.freeze({
     canMaterialize: canMaterializeLine,
     op: "rematerializeLineMark",
+    acceptsResolvedScales: true,
     positionEncoding: Object.freeze({ incomplete: "scale", scaleFirst: false }),
+    encoding: Object.freeze({ scaleFirst: true, completeOnly: true }),
     scaleApplication: Object.freeze({ default: "defer" })
   }),
   area: Object.freeze({

package/src/materialization/rect.js

@@ -2,28 +2,36 @@ import {
   mapOrdinalPositionValues,
   readScaleField
 } from "../grammar/scales/index.js";
-import { RECT_MODES, resolveRectMode } from "../grammar/rects.js";
+import { normalizePositionDatum } from "../grammar/positionDatum.js";
+import { resolveGraphicBounds } from "../layout/canvas.js";
+import { RECT_MODES, resolveRectMode, rectUsesFields } from "../grammar/rects.js";
 import { DEFAULT_RECT_MARK } from "./rectConfig.js";
 import { mapScaleConsumerValues } from "./scales/map.js";
 
-function optionalValues(rows, encoding) {
+function optionalValues(rows, encoding, length, channel) {
+  if (Object.hasOwn(encoding, "datum")) {
+    const value = normalizePositionDatum(encoding.datum, encoding.fieldType, channel, encoding.temporalUnit, "Rect");
+    return Array.from({ length }, () => value);
+  }
   return readScaleField(rows, encoding.field, encoding.fieldType, {
-    allowUnknown: true
+    allowUnknown: true, temporalUnit: encoding.temporalUnit
   });
 }
 
 function requiredChannels(layer, mode) {
-  return mode === RECT_MODES.ranged
-    ? ["x", "x2", "y", "y2", ...(layer.encoding?.color ? ["color"] : [])]
-    : ["x", "y", ...(layer.encoding?.color ? ["color"] : [])];
+  const position = mode === RECT_MODES.xSpan ? ["x", "x2"]
+    : mode === RECT_MODES.ySpan ? ["y", "y2"]
+    : mode === RECT_MODES.ranged ? ["x", "x2", "y", "y2"] : ["x", "y"];
+  return [...position, ...(layer.encoding?.color ? ["color"] : [])];
 }
 
 export function resolveRectConsumerValues(layer, dataset, channel) {
-  const requested = optionalValues(dataset.values, layer.encoding[channel]);
+  const length = rectUsesFields(layer) ? dataset.values.length : 1;
+  const requested = optionalValues(dataset.values, layer.encoding[channel], length, channel);
   const mode = resolveRectMode(layer);
   if (mode === undefined) return requested;
   const complete = requiredChannels(layer, mode).map(candidate =>
-    optionalValues(dataset.values, layer.encoding[candidate])
+    optionalValues(dataset.values, layer.encoding[candidate], length, candidate)
   );
   return requested.map((value, index) =>
     complete.every(values => values[index] !== undefined) ? value : undefined
@@ -68,24 +76,22 @@ function appearance(config, fill) {
 export function resolveRectRows(program, layer, dataset) {
   const mode = resolveRectMode(layer);
   if (mode === undefined) return [];
-  const x = mappedEncoding(program, layer, dataset, "x");
-  const y = mappedEncoding(program, layer, dataset, "y");
-  const x2 = mode === RECT_MODES.ranged
-    ? mappedEncoding(program, layer, dataset, "x2")
-    : undefined;
-  const y2 = mode === RECT_MODES.ranged
-    ? mappedEncoding(program, layer, dataset, "y2")
-    : undefined;
+  const bounds = resolveGraphicBounds(program);
+  const x = layer.encoding.x === undefined ? undefined : mappedEncoding(program, layer, dataset, "x");
+  const y = layer.encoding.y === undefined ? undefined : mappedEncoding(program, layer, dataset, "y");
+  const x2 = layer.encoding.x2 === undefined ? undefined : mappedEncoding(program, layer, dataset, "x2");
+  const y2 = layer.encoding.y2 === undefined ? undefined : mappedEncoding(program, layer, dataset, "y2");
   const color = layer.encoding?.color === undefined
     ? undefined
     : mappedEncoding(program, layer, dataset, "color").values;
   const config = program.markConfigs[layer.id] ?? DEFAULT_RECT_MARK;
 
-  return dataset.values.flatMap((row, index) => {
+  const rows = rectUsesFields(layer) ? dataset.values : [{}];
+  return rows.flatMap((row, index) => {
     const fill = color === undefined ? config.fill : color[index];
     if (
-      !Number.isFinite(x.values[index]) ||
-      !Number.isFinite(y.values[index]) ||
+      (x !== undefined && !Number.isFinite(x.values[index])) ||
+      (y !== undefined && !Number.isFinite(y.values[index])) ||
       typeof fill !== "string"
     ) return [];
 
@@ -103,28 +109,22 @@ export function resolveRectRows(program, layer, dataset) {
         height
       };
     } else {
-      const endX = x2.values[index];
-      const endY = y2.values[index];
+      const startX = x?.values[index] ?? bounds.x;
+      const startY = y?.values[index] ?? bounds.y;
+      const endX = x2?.values[index] ?? bounds.x + bounds.width;
+      const endY = y2?.values[index] ?? bounds.y + bounds.height;
       if (!Number.isFinite(endX) || !Number.isFinite(endY)) return [];
       geometry = {
-        x: Math.min(x.values[index], endX),
-        y: Math.min(y.values[index], endY),
-        width: Math.abs(endX - x.values[index]),
-        height: Math.abs(endY - y.values[index])
+        x: Math.min(startX, endX),
+        y: Math.min(startY, endY),
+        width: Math.abs(endX - startX),
+        height: Math.abs(endY - startY)
       };
       if (geometry.width <= 0 || geometry.height <= 0) return [];
     }
     return [{
       row,
       sourceIndex: index,
-      channels: Object.fromEntries(
-        ["x", "y", "x2", "y2", "color"].flatMap(channel => {
-          const encoding = layer.encoding?.[channel];
-          return encoding?.field === undefined
-            ? []
-            : [[channel, row[encoding.field]]];
-        })
-      ),
       properties: { ...geometry, ...appearance(config, fill) }
     }];
   });