ggaction 0.0.13 → 0.0.16

package/src/actions/regression/edit.js

@@ -1,4 +1,4 @@
-import { action } from "../../core/action.js";
+import { closedAction } from "../../core/action.js";
 import { isPlainObject } from "../../core/immutable.js";
 import { validateUserId } from "../../core/identifiers.js";
 import {
@@ -9,6 +9,10 @@ import {
 } from "../../core/validation.js";
 import { normalizeRegressionParameters } from "../../grammar/regression/index.js";
 import { validateCurveInterpolation } from "../../grammar/curveCommands.js";
+import {
+  requestedStrokeDetails,
+  STROKE_STYLE_PROPERTIES
+} from "../../grammar/strokeStyle.js";
 import { planDerivedDataRevision } from
   "../../materialization/dataProvenance.js";
 import { findLayer } from "../../selectors/layers.js";
@@ -21,9 +25,12 @@ const OPTIONS = Object.freeze([
   "confidenceMethod", "level", "confidence", "interval", "band", "line"
 ]);
 const BAND_OPTIONS = Object.freeze([
-  "color", "opacity", "stroke", "strokeWidth", "curve"
+  "color", "opacity", "stroke", "strokeWidth", "curve",
+  ...STROKE_STYLE_PROPERTIES
+]);
+const LINE_OPTIONS = Object.freeze([
+  "strokeWidth", "curve", ...STROKE_STYLE_PROPERTIES
 ]);
-const LINE_OPTIONS = Object.freeze(["strokeWidth", "curve"]);
 
 function resolveRegressionOwner(program, requested) {
   const eligible = program.semanticSpec.layers.filter(
@@ -80,6 +87,7 @@ function validateBandPatch(value) {
   if (Object.hasOwn(patch, "curve")) {
     validateCurveInterpolation(patch.curve);
   }
+  requestedStrokeDetails(patch, "editRegression band");
   return patch;
 }
 
@@ -94,6 +102,7 @@ function validateLinePatch(value) {
   if (Object.hasOwn(patch, "curve")) {
     validateCurveInterpolation(patch.curve);
   }
+  requestedStrokeDetails(patch, "editRegression line");
   return patch;
 }
 
@@ -225,13 +234,12 @@ function updateRegressionBandSemantics(program, bandId, { x, groupBy }) {
   });
 }
 
-export const editRegression = action(
+export const editRegression = /* @__PURE__ */ closedAction(
   {
     op: "editRegression",
     description: "Revise a regression model and its owned visible components."
-  },
+  }, OPTIONS,
   function (args = {}) {
-    validateKeys(args, OPTIONS, "editRegression");
     if (!OPTIONS.slice(1).some(key => Object.hasOwn(args, key))) {
       throw new Error("editRegression requires a statistical or component option.");
     }
@@ -325,7 +333,11 @@ export const editRegression = action(
         const bandConfig = next.markConfigs[bandId];
         next = next._withMarkConfig(bandId, {
             ...bandConfig,
-            errorBand: { ...bandConfig.errorBand, data: dataId }
+            errorBand: {
+              ...bandConfig.errorBand,
+              source: dataId,
+              data: dataId
+            }
           });
       }
 
@@ -356,10 +368,7 @@ export const editRegression = action(
         next = next.rematerializeLineMark({ id: current.lineId });
       }
 
-      if (changesStatistics) {
-        next = next.releaseDerivedData(revision.release);
-      }
-      return next._withMarkConfig(owner.id, {
+      next = next._withMarkConfig(owner.id, {
         ...next.markConfigs[owner.id],
         regression: {
           ...current,
@@ -373,6 +382,10 @@ export const editRegression = action(
           parameters
         }
       });
+      if (changesStatistics) {
+        next = next.releaseDerivedData(revision.release);
+      }
+      return next;
     };
     return applyEdit(this);
   }

package/src/actions/resources/index.js

@@ -0,0 +1,7 @@
+import { removeCoordinate, removeData, removeScale } from "./remove.js";
+
+export function registerResourceActions(ProgramClass) {
+  ProgramClass.prototype.removeData = removeData;
+  ProgramClass.prototype.removeScale = removeScale;
+  ProgramClass.prototype.removeCoordinate = removeCoordinate;
+}

package/src/actions/resources/remove.js

@@ -0,0 +1,173 @@
+import { annotateError } from "../../core/diagnostics.js";
+import { action } from "../../core/action.js";
+import { validateUserId } from "../../core/identifiers.js";
+import { validateOptionObject } from "../../core/validation.js";
+import {
+  canonicalResourcePath,
+  collectResourceReferences
+} from "../../core/resourceReferences.js";
+import { releaseNamedResourceOwnership } from "../../core/programState.js";
+import { findCoordinate } from "../../selectors/coordinates.js";
+import { findDataset } from "../../selectors/datasets.js";
+import { findLayer } from "../../selectors/layers.js";
+import { findSemanticScale } from "../../selectors/scales.js";
+
+const OPTIONS = Object.freeze(["id"]);
+
+function dataOwners(program) {
+  return Object.entries(program.materializationConfigs.data ?? {}).flatMap(
+    ([family, owners]) => Object.entries(owners ?? {}).flatMap(([owner, config]) =>
+      typeof config?.current === "string"
+        ? [{ family, owner, current: config.current }]
+        : []
+    )
+  );
+}
+
+function ownedGeneratedDatasetIds(program) {
+  const result = new Set();
+  for (const [id, config] of Object.entries(program.markConfigs)) {
+    const layer = findLayer(program, id);
+    for (const value of [
+      config.errorBar?.data,
+      config.errorBand?.data,
+      config.regression?.dataId,
+      config.boxPlot?.summaryId,
+      config.boxPlot?.outlierDataId,
+      config.gradientPlot?.profileId,
+      config.violinPlot?.materialized === true ? layer?.data : undefined,
+      config.ecdfPlot?.data,
+      config.endpointPlot?.data,
+      config.statisticalReference?.dataId
+    ]) {
+      if (typeof value === "string") result.add(value);
+    }
+    const dataset = findDataset(program, layer?.data);
+    if (dataset?.transform?.[0]?.type === "markFilter") result.add(dataset.id);
+  }
+  return Object.freeze([...result].sort());
+}
+
+function exactResource(program, kind, id) {
+  if (kind === "data") return findDataset(program, id);
+  if (kind === "scale") return findSemanticScale(program, id);
+  return findCoordinate(program, id);
+}
+
+function existingKind(program, id) {
+  if (findDataset(program, id) !== undefined ||
+      dataOwners(program).some(owner => owner.owner === id)) return "data";
+  if (findSemanticScale(program, id) !== undefined) return "scale";
+  if (findCoordinate(program, id) !== undefined) {
+    return "coordinate";
+  }
+  if (findLayer(program, id) !== undefined) return "mark";
+  return undefined;
+}
+
+export function resolveResourceOwnership(program, { kind, id }) {
+  const resource = exactResource(program, kind, id);
+  if (kind !== "data") {
+    if (resource !== undefined) return { ownership: "named", resource };
+    const other = existingKind(program, id);
+    if (other !== undefined) {
+      throw annotateError(new Error(`Resource "${id}" exists as ${other}, not ${kind}.`), { code: "incompatible-resource", resourceId: id });
+    }
+    throw annotateError(new Error(`Unknown ${kind} "${id}".`), { code: "missing-resource", resourceId: id });
+  }
+
+  const owners = dataOwners(program).filter(owner => owner.owner === id);
+  if (owners.length > 1) {
+    throw annotateError(new Error(`Data resource "${id}" has ambiguous logical ownership.`), { code: "ambiguous-resource", resourceId: id });
+  }
+  if (owners.length === 1) {
+    const owner = owners[0];
+    const current = exactResource(program, "data", owner.current);
+    if (current === undefined) {
+      throw annotateError(new Error(`Data owner "${id}" has no current dataset.`), { code: "missing-resource", resourceId: id });
+    }
+    return { ownership: "standalone", resource: current, dataOwner: owner };
+  }
+  if (resource !== undefined) {
+    if (ownedGeneratedDatasetIds(program).includes(id) ||
+        dataOwners(program).some(owner => owner.current === id)) {
+      throw new Error(
+        `Dataset "${id}" is chart-owned; use its owning resource action.`
+      );
+    }
+    return { ownership: "named", resource };
+  }
+  const other = existingKind(program, id);
+  if (other !== undefined) {
+    throw annotateError(new Error(`Resource "${id}" exists as ${other}, not data.`), { code: "incompatible-resource", resourceId: id });
+  }
+  throw annotateError(new Error(`Unknown data "${id}".`), { code: "missing-resource", resourceId: id });
+}
+
+function assertSupportedProgram(program, operation) {
+  if (program.compositionSpec !== undefined && program.compositionSpec.type !== "facet") {
+    throw new Error(`${operation} supports unit and facet composition programs.`);
+  }
+}
+
+function formatReference(value) {
+  return `${value.ownerKind} "${value.ownerId}" at ` +
+    canonicalResourcePath(value.path);
+}
+
+export function planResourceRemoval(program, { kind, id, operation }) {
+  assertSupportedProgram(program, operation);
+  const resolved = resolveResourceOwnership(program, { kind, id });
+  const actualId = resolved.resource.id;
+  const references = collectResourceReferences(program, { kind, id: actualId });
+  const live = references.filter(value => value.strength === "live" && !(
+    resolved.ownership === "standalone" &&
+    value.ownerKind === "dataOwner" &&
+    value.ownerId === resolved.dataOwner.owner &&
+    value.path.at(-1) === "current"
+  ));
+  if (live.length > 0) {
+    throw annotateError(new Error(
+      `Cannot remove ${kind} "${id}"; live references: ` +
+      live.map(formatReference).join("; ")
+    ), { code: "resource-in-use", resourceId: id, candidates: [...new Set(live.map(value => value.ownerId))] });
+  }
+  return Object.freeze({
+    kind,
+    id,
+    semanticIds: Object.freeze([actualId]),
+    ...(resolved.dataOwner === undefined
+      ? {}
+      : { dataOwner: Object.freeze({ ...resolved.dataOwner }) })
+  });
+}
+
+function removeResource(kind, operation, description) {
+  return action(
+    { op: operation, description, scope: "any" },
+    function (args = {}) {
+      validateOptionObject(args, OPTIONS, operation);
+      const id = validateUserId(args.id, `${operation} id`);
+      const plan = planResourceRemoval(this, { kind, id, operation });
+      // Release a validated logical owner before removing its physical revision.
+      // The primitive then checks the remaining consumers without mistaking the
+      // owner's own replay entry for an independently chart-owned resource.
+      let next = releaseNamedResourceOwnership(this, plan);
+      const selector = kind === "data" ? "dataset" : kind;
+      for (const semanticId of plan.semanticIds) {
+        next = next.editSemantic({ property: `${selector}[${semanticId}]`, remove: true });
+      }
+      return next;
+    }
+  );
+}
+
+export const removeData = /* @__PURE__ */ removeResource(
+  "data", "removeData", "Remove one unreferenced named dataset."
+);
+export const removeScale = /* @__PURE__ */ removeResource(
+  "scale", "removeScale", "Remove one unreferenced named scale."
+);
+export const removeCoordinate = /* @__PURE__ */ removeResource(
+  "coordinate", "removeCoordinate", "Remove one unreferenced named coordinate."
+);

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

@@ -43,7 +43,7 @@ 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
   ) && ["nominal", "ordinal"].includes(consumer.encoding.fieldType);
 }

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

@@ -45,7 +45,7 @@ export function resolveMarkFamilyConsumerValues(program, consumer, dataset) {
   }
   const { layer, channel } = consumer;
   const encoding = layer.encoding ?? {};
-  const appearance = ["strokeWidth", "opacity"].includes(channel);
+  const appearance = ["stroke", "strokeWidth", "opacity"].includes(channel);
   if (
     layer.mark?.type === "line" &&
     ((["x", "y"].includes(channel) && encoding.x !== undefined &&
@@ -69,7 +69,8 @@ export function resolveMarkFamilyConsumerValues(program, consumer, dataset) {
             dataset.values,
             derived.series,
             consumer.encoding.field,
-            channel
+            channel,
+            consumer.encoding
           )
         : channel === "x" ? derived.xValues : derived.yValues
     };

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

@@ -9,6 +9,8 @@ import {
 } from "./common.js";
 import { resolveMarkFamilyConsumerValues } from "./families.js";
 import { CATEGORY_ORDER_CHANNELS, resolveCategoryOrder } from "../../../grammar/categoryOrder.js";
+import { resolveHistogramInput } from
+  "../../../materialization/bars/histogram.js";
 
 export { findScale, findScaleConsumers } from "./common.js";
 export {
@@ -16,8 +18,7 @@ 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") {
@@ -49,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);
   }
@@ -58,6 +67,14 @@ 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;

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

@@ -9,7 +9,6 @@ import {
   resolveBarGrain
 } from "../../../grammar/bars/policy.js";
 import {
-  countHistogramBins,
   findHistogramBinIndex,
   resolveHistogramBins
 } from "../../../grammar/histogram.js";
@@ -22,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;
@@ -44,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,
@@ -52,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) {
@@ -60,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,
@@ -70,19 +77,24 @@ function resolveHistogramPartitions(program, consumer) {
   });
   const colorEncoding = layer.encoding?.color;
   if (layer.encoding?.group !== undefined) {
-    const identity = readSeriesIdentity(dataset.values, layer);
+    const identity = readSeriesIdentity(input.rows, layer);
     validateGeneratedItemLimit((bins.boundaries.length - 1) * identity.domain.length, "Histogram layout cell count");
-    const counts = bins.boundaries.slice(0, -1).map(() => identity.domain.map(() => 0));
+    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) counts[bin][groups.get(identity.values[index])] += 1; });
-    return counts;
+      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,
@@ -90,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) {