ggaction 0.0.11 → 0.0.13

package/src/materialization/rowEncoding.js

@@ -1,11 +1,17 @@
-import { POSITION_CHANNELS } from "../core/vocabulary.js";
 import {
+  OFFSET_POSITION_CHANNELS,
+  POSITION_CHANNELS
+} from "../core/vocabulary.js";
+import {
+  mapOrdinalOffsetValues,
   mapOrdinalPositionValues,
-  readNominalField,
-  readQuantitativeField,
-  readScaleField,
-  readTemporalField
+  readScaleField
 } from "../grammar/scales/index.js";
+import {
+  finiteMidpoint,
+  requireFiniteResult
+} from "../grammar/numeric.js";
+import { normalizePositionDatum } from "../grammar/positionDatum.js";
 import { mapScaleConsumerValues } from "./scales/map.js";
 
 export function resolveRowEncodingValues(program, layer, dataset, channel) {
@@ -18,16 +24,66 @@ export function resolveRowEncodingValues(program, layer, dataset, channel) {
     );
   }
   const categorical = ["nominal", "ordinal"].includes(encoding.fieldType);
-  const values = Object.hasOwn(scale, "unknown")
-    ? readScaleField(dataset.values, encoding.field, encoding.fieldType, {
-        allowUnknown: true
-      })
-    : categorical
-      ? readNominalField(dataset.values, encoding.field)
-      : encoding.fieldType === "temporal"
-        ? readTemporalField(dataset.values, encoding.field)
-        : readQuantitativeField(dataset.values, encoding.field);
+  const values = Object.hasOwn(encoding, "datum")
+    ? Array(dataset.values.length).fill(normalizePositionDatum(
+        encoding.datum,
+        encoding.fieldType,
+        channel,
+        encoding.temporalUnit,
+        layer.mark.type[0].toUpperCase() + layer.mark.type.slice(1)
+      ))
+    : readScaleField(dataset.values, encoding.field, encoding.fieldType, {
+        allowUnknown: Object.hasOwn(scale, "unknown"), temporalUnit: encoding.temporalUnit
+      });
+  if (categorical && OFFSET_POSITION_CHANNELS.includes(channel)) {
+    return mapOrdinalOffsetValues(values, scale);
+  }
   return categorical && POSITION_CHANNELS.includes(channel)
     ? mapOrdinalPositionValues(values, scale)
     : mapScaleConsumerValues(values, scale, channel);
 }
+
+export function applyOffsetPositionValues({
+  base,
+  offset,
+  parentScale,
+  offsetScale,
+  channel
+}) {
+  if (base.length !== offset.length) {
+    throw new Error(`${channel} offset values must match the base position grain.`);
+  }
+  const midpoint = finiteMidpoint(offsetScale.range[0], offsetScale.range[1]);
+  const direction = Math.sign(parentScale.step) ||
+    Math.sign(parentScale.range[1] - parentScale.range[0]) || 1;
+  return Object.freeze(base.map((value, index) => {
+    if (!Number.isFinite(value) || !Number.isFinite(offset[index])) {
+      return undefined;
+    }
+    return requireFiniteResult(
+      value + direction * (offset[index] - midpoint),
+      `${channel} offset position`
+    );
+  }));
+}
+
+export function resolveRowPositionValues(program, layer, dataset, channel) {
+  const base = resolveRowEncodingValues(program, layer, dataset, channel);
+  if (base === undefined) return undefined;
+  const offsetChannel = channel === "x" ? "xOffset" : "yOffset";
+  const offsetEncoding = layer.encoding?.[offsetChannel];
+  if (offsetEncoding === undefined) return base;
+  const offset = resolveRowEncodingValues(
+    program,
+    layer,
+    dataset,
+    offsetChannel
+  );
+  return applyOffsetPositionValues({
+    base,
+    offset,
+    parentScale: program.resolvedScales[layer.encoding[channel].scale],
+    offsetScale: program.resolvedScales[offsetEncoding.scale],
+    channel
+  });
+}

package/src/materialization/scaleGuideDependencies.js

@@ -1,3 +1,4 @@
+import { isSourceOwnedText } from "../grammar/text.js";
 import { POSITION_ENCODING_CHANNELS } from "../core/vocabulary.js";
 import { materializedLegendUsesScale } from "./legends.js";
 import { buildMaterializationPlan } from "./planner.js";
@@ -19,10 +20,12 @@ const GRIDS = Object.freeze([
 
 function usesPositionalScale(program, id) {
   return program.semanticSpec.layers.some(layer =>
-    POSITION_ENCODING_CHANNELS.some(
-      channel => layer.encoding?.[channel]?.scale === id
-    ) || (layer.encoding?.parallel?.dimensions ?? []).some(
-      dimension => dimension.scale === id
+    !isSourceOwnedText(layer) && (
+      POSITION_ENCODING_CHANNELS.some(
+        channel => layer.encoding?.[channel]?.scale === id
+      ) || (layer.encoding?.parallel?.dimensions ?? []).some(
+        dimension => dimension.scale === id
+      )
     )
   );
 }
@@ -50,7 +53,7 @@ export function needsCanvasScaleRematerialization(program, scale) {
     (scale.range === "auto" ||
       usesRadialScale(program, scale.id) ||
       semanticGuideUsesScale(program, scale.id)) &&
-    program.resolvedScales[scale.id] !== undefined &&
+    (program.resolvedScales[scale.id] !== undefined || scale.radialMapping !== undefined) &&
     usesPositionalScale(program, scale.id)
   );
 }

package/src/materialization/scales/map.js

@@ -19,6 +19,7 @@ export function mapScaleConsumerValues(values, resolvedScale, channel) {
       resolvedScale.range,
       {
         interpolation: resolvedScale.interpolate,
+        midpoint: resolvedScale.midpoint,
         clamp: resolvedScale.clamp ?? false,
         ...(Object.hasOwn(resolvedScale, "unknown")
           ? { unknown: resolvedScale.unknown }

package/src/materialization/scales/policies/arc.js

@@ -1,3 +1,4 @@
+import { validateMeasuredRadiusScale } from "../../../grammar/scales/radial.js";
 export function resolveArcAutoPositionRange({
   consumers,
   scale,
@@ -35,3 +36,44 @@ export function resolveArcAutoPositionRange({
   }
   return range;
 }
+
+
+export function resolveMeasuredRadiusDomain({ scale, channel, allValues }) {
+  if (scale.radialMapping === undefined) return undefined;
+  if (channel !== "radius") throw new Error("Measured radius scales support only radius consumers.");
+  const maximum = allValues.reduce((maximum, value) => Math.max(maximum, value), -Infinity);
+  if (!Number.isFinite(maximum) || maximum <= 0 || allValues.some(value => value < 0)) {
+    throw new Error("Measured radius requires finite non-negative aggregates and a positive maximum.");
+  }
+  const domain = scale.domain === "auto" ? [0, maximum] : scale.domain;
+  if (Array.isArray(domain) && domain[1] < maximum) {
+    throw new RangeError("Measured radius domain maximum must cover every category aggregate.");
+  }
+  return domain;
+}
+
+export function validateMeasuredRadiusConsumers({ scale, domain, range, consumers, markConfigs, thetaScales }) {
+  if (scale.radialMapping === undefined) return;
+  validateMeasuredRadiusScale({ ...scale, domain, range }, { allowAuto: true });
+  for (const consumer of consumers) {
+    const { layer, encoding } = consumer;
+    const theta = layer.encoding?.theta;
+    const thetaScale = thetaScales[layer.id];
+    if (!isPendingMeasuredRadiusConsumer(consumer) && (layer.mark?.type !== "arc" || !["count", "sum"].includes(encoding.aggregate) ||
+      !["nominal", "ordinal"].includes(theta?.fieldType) || theta.aggregate !== undefined ||
+      thetaScale?.type !== "band" || (thetaScale.paddingInner ?? 0) !== 0 || (thetaScale.paddingOuter ?? 0) !== 0)) {
+      throw new Error("Measured radius requires only equal-angle categorical Arc consumers.");
+    }
+    const config = markConfigs[layer.id] ?? {};
+    if ((config.padAngle ?? 0) !== 0) throw new Error("Measured Arc requires padAngle 0.");
+    if (scale.range !== "auto" && config.innerRadiusExplicit === true &&
+      Math.abs(config.innerRadius - range[0] / range[1]) > Number.EPSILON * 8) {
+      throw new Error("Measured Arc innerRadius must agree with its explicit radius range.");
+    }
+  }
+}
+
+export function isPendingMeasuredRadiusConsumer({ layer, channel, encoding }) {
+  return layer.mark?.type === "arc" && channel === "radius" &&
+    ["count", "sum"].includes(encoding.aggregate) && layer.encoding?.theta === undefined;
+}

package/src/materialization/scales/policies/bar.js

@@ -1,4 +1,3 @@
-import { normalizeOffsetPadding } from "../../../grammar/bars/geometry.js";
 import {
   BAR_GRAINS,
   resolveBarChannels,
@@ -8,48 +7,6 @@ import {
   interpolateNumber,
   inverseLerp
 } from "../../../grammar/numeric.js";
-export function resolveOffsetScalePolicy({
-  consumers,
-  resolvedScales,
-  markConfigs,
-  id,
-  channel
-}) {
-  const parentChannel = channel === "xOffset" ? "x" : "y";
-  const bandwidths = consumers.map(consumer => {
-    if (parentChannel === "x" && consumer.layer.encoding?.x?.bin !== undefined) {
-      return 1;
-    }
-    const parentScaleId = consumer.layer.encoding?.[parentChannel]?.scale;
-    return resolvedScales[parentScaleId]?.bandwidth;
-  });
-  if (
-    bandwidths.some(value => !Number.isFinite(value)) ||
-    new Set(bandwidths).size !== 1
-  ) {
-    throw new Error(
-      `${channel} scale "${id}" requires one shared resolved ${parentChannel} bandwidth.`
-    );
-  }
-  const paddings = consumers.map(consumer => normalizeOffsetPadding(
-    markConfigs[consumer.layer.id]?.[channel],
-    undefined,
-    channel
-  ));
-  const signatures = new Set(
-    paddings.map(padding => JSON.stringify(padding))
-  );
-  if (signatures.size !== 1) {
-    throw new Error(
-      `${channel} scale "${id}" requires one shared padding policy.`
-    );
-  }
-  return {
-    parentBandwidth: bandwidths[0],
-    ...paddings[0]
-  };
-}
-
 export function resolveTemporalBarBand(valuesByConsumer, domain, range) {
   const temporalBars = valuesByConsumer.filter(({ consumer }) => {
     const channels = resolveBarChannels(consumer.layer);

package/src/materialization/scales/policies/binnedPosition.js

@@ -1,11 +1,11 @@
+import { isSourceOwnedText } from "../../../grammar/text.js";
 import { resolveHistogramBins } from "../../../grammar/histogram.js";
 
 export function resolveBinnedPositionDomain({
   valuesByConsumer,
   channel,
   scale,
-  id,
-  allValues
+  id
 }) {
   const binnedPositions = valuesByConsumer.filter(
     ({ consumer }) =>
@@ -13,7 +13,10 @@ export function resolveBinnedPositionDomain({
       consumer.encoding.bin !== undefined
   );
   if (binnedPositions.length === 0) return undefined;
-  if (channel !== "x" || binnedPositions.length !== valuesByConsumer.length) {
+  const independentConsumers = valuesByConsumer.filter(({ consumer }) =>
+    !isSourceOwnedText(consumer.layer)
+  );
+  if (channel !== "x" || binnedPositions.length !== independentConsumers.length) {
     throw new Error(
       `Binned scale "${id}" cannot be shared with an unbinned consumer.`
     );
@@ -25,7 +28,7 @@ export function resolveBinnedPositionDomain({
     throw new Error(`Binned scale "${id}" requires one shared bin definition.`);
   }
   return resolveHistogramBins({
-    values: allValues,
+    values: binnedPositions.flatMap(item => item.values).filter(value => value !== undefined),
     bin: binnedPositions[0].consumer.encoding.bin,
     domain: scale.domain,
     nice: scale.nice ?? true,

package/src/materialization/scales/policies/offset.js

@@ -0,0 +1,54 @@
+import { normalizeOffsetPadding } from "../../../grammar/bars/geometry.js";
+
+function resolveParentSlot(consumer, resolvedScales, parentChannel) {
+  if (parentChannel === "x" && consumer.layer.encoding?.x?.bin !== undefined) {
+    return 1;
+  }
+  const parentScaleId = consumer.layer.encoding?.[parentChannel]?.scale;
+  const parentScale = resolvedScales[parentScaleId];
+  if (Number.isFinite(parentScale?.bandwidth) && parentScale.bandwidth > 0) {
+    return parentScale.bandwidth;
+  }
+  if (parentScale?.type === "point" && Number.isFinite(parentScale.step)) {
+    return Math.abs(parentScale.step);
+  }
+  return undefined;
+}
+
+export function resolveOffsetScalePolicy({
+  consumers,
+  resolvedScales,
+  markConfigs,
+  id,
+  channel
+}) {
+  const parentChannel = channel === "xOffset" ? "x" : "y";
+  const slots = consumers.map(consumer =>
+    resolveParentSlot(consumer, resolvedScales, parentChannel)
+  );
+  if (
+    slots.some(value => !Number.isFinite(value) || value <= 0) ||
+    new Set(slots).size !== 1
+  ) {
+    throw new Error(
+      `${channel} scale "${id}" requires one shared resolved ${parentChannel} categorical slot.`
+    );
+  }
+  const paddings = consumers.map(consumer => normalizeOffsetPadding(
+    markConfigs[consumer.layer.id]?.[channel],
+    undefined,
+    channel
+  ));
+  const signatures = new Set(
+    paddings.map(padding => JSON.stringify(padding))
+  );
+  if (signatures.size !== 1) {
+    throw new Error(
+      `${channel} scale "${id}" requires one shared padding policy.`
+    );
+  }
+  return {
+    parentBandwidth: slots[0],
+    ...paddings[0]
+  };
+}

package/src/materialization/scales/policies/series.js

@@ -1,3 +1,4 @@
+import { isSourceOwnedText } from "../../../grammar/text.js";
 import {
   isTransformedScaleType,
   resolveContinuousDomain,
@@ -21,7 +22,7 @@ export function resolveSeriesLayoutDomain({
     (_, index) => seriesLayouts[index] !== undefined
   );
   const directConsumers = valuesByConsumer.filter(
-    (_, index) => seriesLayouts[index] === undefined
+    ({ consumer }, index) => seriesLayouts[index] === undefined && !isSourceOwnedText(consumer.layer)
   );
   const compatibleDirect = directConsumers.every(({ consumer }) =>
     layoutConsumers.every(({ consumer: layoutConsumer }) => {

package/src/materialization/scales/resolve.js

@@ -1,3 +1,4 @@
+import { validateContinuousColorConsumer } from "../../grammar/scales/colorConsumers.js";
 import {
   isContinuousColorScaleType,
   isDiscretePositionScaleType,
@@ -21,16 +22,15 @@ import {
   resolveStrokeWidthRange,
   resolveTransformedDomain,
   SCALE_ROLES,
+  validateSequentialMidpoint,
   validateLinearScaleType,
   validateOrdinalScaleType,
   validateScaleTypeForRole,
   validateTimeScaleType
 } from "../../grammar/scales/index.js";
-import { resolveArcAutoPositionRange } from "./policies/arc.js";
-import {
-  resolveOffsetScalePolicy,
-  resolveTemporalBarBand
-} from "./policies/bar.js";
+import { resolveArcAutoPositionRange, resolveMeasuredRadiusDomain, validateMeasuredRadiusConsumers } from "./policies/arc.js";
+import { resolveTemporalBarBand } from "./policies/bar.js";
+import { resolveOffsetScalePolicy } from "./policies/offset.js";
 import { resolveBinnedPositionDomain } from "./policies/binnedPosition.js";
 import { resolveSeriesLayoutDomain } from "./policies/series.js";
 import { OFFSET_POSITION_CHANNELS } from "../../core/vocabulary.js";
@@ -141,7 +141,9 @@ function resolveContinuousScale({
             : validateLinearScaleType(scale.type),
     domain,
     range,
+    ...(scale.midpoint === undefined ? {} : { midpoint: scale.midpoint }),
     ...(scale.clamp === undefined ? {} : { clamp: scale.clamp }),
+    ...(scale.radialMapping === undefined ? {} : { radialMapping: scale.radialMapping }),
     ...(scale.type === "log"
       ? {
           base: normalizeTransformParameters("log", {
@@ -184,19 +186,38 @@ function reverseResolvedScale(scale) {
   };
 }
 
-export function resolveScaleMaterialization({
-  id,
-  scale,
-  channel,
-  consumers,
-  valuesByConsumer,
-  bounds,
-  resolvedScales,
-  markConfigs
-}) {
+export function resolveScaleMaterialization(options) {
+  const {
+    id,
+    scale,
+    channel,
+    consumers,
+    valuesByConsumer,
+    bounds,
+    resolvedScales,
+    markConfigs,
+    thetaScales
+  } = options;
   const allValues = valuesByConsumer
     .flatMap(item => item.values)
     .filter(value => value !== undefined);
+  const preserved = resolvedScales[id]?.domain;
+  if (
+    scale.domain === "auto" &&
+    Array.isArray(preserved) &&
+    consumers.some(({ layer }) =>
+      markConfigs?.[layer.id]?.markFilter?.empty === true
+    )
+  ) {
+    return resolveScaleMaterialization({
+      ...options,
+      scale: { ...scale, domain: preserved },
+      valuesByConsumer: valuesByConsumer.map(item => ({
+        ...item,
+        categoryOrder: undefined
+      }))
+    });
+  }
   const isSequentialColor = channel === "color" &&
     isContinuousColorScaleType(scale.type);
   const isDiscretizedColor = channel === "color" &&
@@ -212,6 +233,9 @@ export function resolveScaleMaterialization({
     !isOrdinalOffset &&
     isDiscretePositionScaleType(scale.type);
 
+  if (isSequentialColor || isDiscretizedColor) {
+    for (const consumer of consumers) validateContinuousColorConsumer(consumer.layer, consumer.encoding, scale);
+  }
   let discretizedScale;
   if (isDiscretizedColor) {
     discretizedScale = resolveDiscretizedColorScale({
@@ -227,8 +251,7 @@ export function resolveScaleMaterialization({
         valuesByConsumer,
         channel,
         scale,
-        id,
-        allValues
+        id
       });
   const seriesLayouts = valuesByConsumer.map(item => item.seriesLayout);
   const seriesDomain = isDiscretizedColor || binnedDomain !== undefined
@@ -249,7 +272,7 @@ export function resolveScaleMaterialization({
   }
   const domain = isDiscretizedColor
     ? discretizedScale.domain
-    : categoryOrderDomain ?? binnedDomain ?? seriesDomain ?? resolveDefaultDomain({
+    : resolveMeasuredRadiusDomain({ scale, channel, allValues }) ?? categoryOrderDomain ?? binnedDomain ?? seriesDomain ?? resolveDefaultDomain({
         scale,
         allValues,
         isOrdinalAppearance,
@@ -269,6 +292,13 @@ export function resolveScaleMaterialization({
     isOrdinalOffset,
     discretizedScale
   });
+  validateSequentialMidpoint(scale.midpoint, scale.type, domain);
+  if (scale.midpoint !== undefined && (channel !== "color" || consumers.some(
+    consumer => consumer.encoding.fieldType !== "quantitative"
+  ))) {
+    throw new Error("Scale midpoint requires quantitative color consumers.");
+  }
+  validateMeasuredRadiusConsumers({ scale, domain, range, consumers, markConfigs, thetaScales });
   if (channel === "shape" && domain.length > range.length) {
     throw new Error(
       `Shape scale "${id}" requires at least one distinct shape per domain value.`

package/src/materialization/selection/compatibility.js

@@ -0,0 +1,11 @@
+export function assertEncodingSelectionCompatibility(program, target, channels) {
+  for (const [id, selection] of Object.entries(
+    program.materializationConfigs.selections ?? {}
+  )) {
+    if (selection.target === target && channels.includes(selection.selector?.channel)) {
+      throw new Error(
+        `Cannot remove ${selection.selector.channel} encoding while selection "${id}" references that channel.`
+      );
+    }
+  }
+}

package/src/materialization/selection/items/bar.js

@@ -1,4 +1,5 @@
-import { deriveBarAggregates } from "../../../grammar/bars/aggregate.js";
+import { deriveSeriesBarCells } from "../../../grammar/bars/aggregate.js";
+import { readSeriesIdentity } from "../../../grammar/pathSeries.js";
 import {
   BAR_GRAINS,
   resolveBarChannels,
@@ -7,7 +8,6 @@ import {
   resolveBarGrain
 } from "../../../grammar/bars/policy.js";
 import { numericExtent } from "../../../grammar/numeric.js";
-import { layoutSeriesPartition } from "../../../grammar/seriesLayout.js";
 import {
   readNominalField,
   readTemporalField
@@ -24,7 +24,7 @@ import {
 
 function categoryValues(rows, encoding) {
   return encoding.fieldType === "temporal"
-    ? readTemporalField(rows, encoding.field)
+    ? readTemporalField(rows, encoding.field, encoding.temporalUnit)
     : readNominalField(rows, encoding.field);
 }
 
@@ -36,20 +36,17 @@ function aggregateMembers(rows, layer, cell, channels) {
   const colors = !["nominal", "ordinal"].includes(color?.fieldType)
     ? undefined
     : readNominalField(rows, color.field);
+  const identity = layer.encoding?.group === undefined ? undefined : readSeriesIdentity(rows, layer);
   return rows.filter((_, index) =>
     categories[index] === categoryValue &&
-    (colors === undefined || colors[index] === cell.color)
+    (identity === undefined ? colors === undefined || colors[index] === cell.color : identity.values[index] === cell.series)
   );
 }
 
 function aggregateCellDefinitions(program, layer, dataset) {
   const channels = resolveBarChannels(layer);
-  const derived = deriveBarAggregates(dataset.values, layer).values;
   const categoryEncoding = layer.encoding[channels.category];
   const categoryScale = program.resolvedScales[categoryEncoding.scale];
-  const measureScale = program.resolvedScales[
-    layer.encoding[channels.measure].scale
-  ];
   const colorEncoding = layer.encoding?.color;
   const colorScale = program.resolvedScales[colorEncoding?.scale];
   const offsetChannel = resolveBarOffsetChannel(layer);
@@ -67,70 +64,17 @@ function aggregateCellDefinitions(program, layer, dataset) {
         ...(cell.color === undefined ? {} : { color: cell.color }),
         ...(layer.encoding?.[offsetChannel] === undefined
           ? {}
-          : { [offsetChannel]: cell.color })
+          : { [offsetChannel]: cell.series ?? cell.color })
       },
       members
     };
   }
 
-  if (colorEncoding?.fieldType === "quantitative") {
-    const cells = new Map(derived.map(cell => [
-      cell[channels.category],
-      cell
-    ]));
-    const categories = ["ordinal", "band", "point"].includes(categoryScale.type)
-      ? categoryScale.domain
-      : [...new Set(derived.map(cell => cell[channels.category]))]
-          .sort((left, right) => left - right);
-    return categories.flatMap(category => {
-      const cell = cells.get(category);
-      return cell === undefined
-        ? []
-        : [definition(cell, measureScale.domain[0], cell[channels.measure])];
-    });
-  }
-
-  if (layout === "group" && offsetScale !== undefined) {
-    const categoryIndex = new Map(
-      categoryScale.domain.map((value, index) => [value, index])
-    );
-    const offsetIndex = new Map(
-      offsetScale.domain.map((value, index) => [value, index])
-    );
-    const cells = [...derived].sort((left, right) =>
-      categoryIndex.get(left[channels.category]) -
-        categoryIndex.get(right[channels.category]) ||
-      offsetIndex.get(left.color) - offsetIndex.get(right.color)
-    );
-    return cells.map(cell => definition(
-      cell,
-      measureScale.domain[0],
-      cell[channels.measure]
-    ));
-  }
-
-  const categories = ["ordinal", "band", "point"].includes(categoryScale.type)
-    ? categoryScale.domain
-    : [...new Set(derived.map(cell => cell[channels.category]))]
-        .sort((left, right) => left - right);
-  const series = colorScale?.domain ?? [undefined];
-  const lookup = new Map(derived.map(cell => [
-    JSON.stringify([cell[channels.category], cell.color]),
-    cell
-  ]));
-  const baseline = layout === "overlay" ? measureScale.domain[0] : 0;
-  return categories.flatMap(category => {
-    const cells = series.map(color =>
-      lookup.get(JSON.stringify([category, color]))
-    );
-    const values = cells.map(cell => cell?.[channels.measure] ?? 0);
-    return layoutSeriesPartition(values, layout, { baseline }).flatMap(segment => {
-      const cell = cells[segment.index];
-      return cell === undefined
-        ? []
-        : [definition(cell, segment.start, segment.end)];
-    });
-  });
+  const categories = categoryScale.type === "time" ? undefined : categoryScale.domain;
+  const series = layout === "group" ? offsetScale?.domain
+    : layer.encoding.group === undefined && colorEncoding?.fieldType !== "quantitative" ? colorScale?.domain : undefined;
+  return deriveSeriesBarCells(dataset.values, layer, categories, series)
+    .map(({ cell, start, end }) => definition(cell, start, end));
 }
 
 function histogramDefinitions(program, layer, dataset) {
@@ -145,7 +89,7 @@ function histogramDefinitions(program, layer, dataset) {
   });
   const colorScale = program.resolvedScales[colorEncoding?.scale];
   return segments.map(segment => {
-    const colorValue = colorScale?.domain[segment.category];
+    const colorValue = segment.colorValue ?? colorScale?.domain[segment.category];
     return {
       fields: uniqueFields(segment.members),
       channels: {

package/src/materialization/selection/items/common.js

@@ -1,3 +1,4 @@
+import { normalizeTemporalValue } from "../../../grammar/scales/fields.js";
 import { cloneAndFreeze, isPlainObject } from "../../../core/immutable.js";
 import {
   MARK_GRAPHIC_PROPERTIES,
@@ -16,8 +17,13 @@ function graphicId(layer, index) {
 
 function encodingValue(row, encoding) {
   if (encoding === undefined) return undefined;
-  if (Object.hasOwn(encoding, "field")) return row?.[encoding.field];
-  return encoding.datum;
+  const value = Object.hasOwn(encoding, "field") ? row?.[encoding.field] : encoding.datum;
+  if (encoding.fieldType !== "temporal") return value;
+  try {
+    return normalizeTemporalValue(value, encoding.field, 0, encoding.temporalUnit);
+  } catch {
+    return undefined;
+  }
 }
 
 export function channelMapFromRow(row, layer) {

package/src/materialization/selection/items/path.js

@@ -25,20 +25,10 @@ function rowsForSeries(rows, key) {
 
 function seriesDefinitions(layer, rows, series) {
   return series.map(item => {
-    const members = rowsForSeries(rows, item.key);
+    const members = item.sourceIndices === undefined ? rowsForSeries(rows, item.key)
+      : item.sourceIndices.map(index => rows[index]);
     const fields = { ...uniqueFields(members), ...item.key };
-    const channels = Object.fromEntries(
-      Object.entries(layer.encoding ?? {}).flatMap(([channel, encoding]) => {
-        if (encoding.field === undefined) {
-          return Object.hasOwn(encoding, "datum")
-            ? [[channel, encoding.datum]]
-            : [];
-        }
-        return Object.hasOwn(fields, encoding.field)
-          ? [[channel, fields[encoding.field]]]
-          : [];
-      })
-    );
+    const channels = channelMapFromRow(fields, layer);
     return { fields, channels, members };
   });
 }