ggaction 0.0.13 → 0.0.15

package/src/actions/regression/components.js

@@ -9,19 +9,27 @@ import {
   REGRESSION_UPPER_FIELD
 } from "../../grammar/regression/index.js";
 import { validateAreaCreateOutline } from "../marks/area/index.js";
+import {
+  requestedStrokeDetails,
+  STROKE_STYLE_PROPERTIES
+} from "../../grammar/strokeStyle.js";
 
 const BAND_OPTIONS = Object.freeze([
   "id", "data", "x", "lower", "upper", "groupBy", "coordinate", "xScale", "yScale",
-  "color", "opacity", "stroke", "strokeWidth", "curve"
+  "color", "opacity", "stroke", "strokeWidth", "curve",
+  ...STROKE_STYLE_PROPERTIES
 ]);
 const LINE_OPTIONS = Object.freeze([
   "id", "data", "x", "y", "groupBy", "coordinate", "xScale", "yScale", "colorScale",
-  "strokeWidth", "curve"
+  "strokeWidth", "curve", ...STROKE_STYLE_PROPERTIES
 ]);
 const EDIT_BAND_OPTIONS = Object.freeze([
-  "target", "color", "opacity", "stroke", "strokeWidth", "curve"
+  "target", "color", "opacity", "stroke", "strokeWidth", "curve",
+  ...STROKE_STYLE_PROPERTIES
+]);
+const EDIT_LINE_OPTIONS = Object.freeze([
+  "target", "strokeWidth", "curve", ...STROKE_STYLE_PROPERTIES
 ]);
-const EDIT_LINE_OPTIONS = Object.freeze(["target", "strokeWidth", "curve"]);
 
 function isRegressionLayer(program, layer, type) {
   const dataset = findDataset(program, layer.data);
@@ -93,7 +101,8 @@ export const createRegressionBand = action(
         coordinate: args.coordinate,
         fill: args.color ?? DEFAULT_COLORS.regressionBand,
         opacity: args.opacity ?? 0.18,
-        ...(args.curve === undefined ? {} : { curve: args.curve })
+        ...(args.curve === undefined ? {} : { curve: args.curve }),
+        ...requestedStrokeDetails(args, "createRegressionBand")
       })
       .editSemantic({
         property: `layer[${id}].encoding.y.title`,
@@ -119,7 +128,10 @@ export const editRegressionBand = action(
   },
   function (args = {}) {
     validateKeys(args, EDIT_BAND_OPTIONS, "editRegressionBand");
-    const changes = ["color", "opacity", "stroke", "strokeWidth", "curve"];
+    const changes = [
+      "color", "opacity", "stroke", "strokeWidth", "curve",
+      ...STROKE_STYLE_PROPERTIES
+    ];
     if (!changes.some(key => Object.hasOwn(args, key))) {
       throw new Error(
         "editRegressionBand requires color, opacity, stroke, strokeWidth, or curve."
@@ -139,7 +151,8 @@ export const editRegressionBand = action(
       ...(Object.hasOwn(args, "strokeWidth")
         ? { strokeWidth: args.strokeWidth }
         : {}),
-      ...(Object.hasOwn(args, "curve") ? { curve: args.curve } : {})
+      ...(Object.hasOwn(args, "curve") ? { curve: args.curve } : {}),
+      ...requestedStrokeDetails(args, "editRegressionBand")
     });
   }
 );
@@ -152,8 +165,8 @@ export const editRegressionLine = action(
   function (args = {}) {
     validateKeys(args, EDIT_LINE_OPTIONS, "editRegressionLine");
     if (
-      !Object.hasOwn(args, "strokeWidth") &&
-      !Object.hasOwn(args, "curve")
+      !["strokeWidth", "curve", ...STROKE_STYLE_PROPERTIES]
+        .some(property => Object.hasOwn(args, property))
     ) {
       throw new Error("editRegressionLine requires strokeWidth or curve.");
     }
@@ -168,7 +181,8 @@ export const editRegressionLine = action(
       ...(Object.hasOwn(args, "strokeWidth")
         ? { strokeWidth: args.strokeWidth }
         : {}),
-      ...(Object.hasOwn(args, "curve") ? { curve: args.curve } : {})
+      ...(Object.hasOwn(args, "curve") ? { curve: args.curve } : {}),
+      ...requestedStrokeDetails(args, "editRegressionLine")
     });
   }
 );
@@ -186,7 +200,8 @@ export const createRegressionLine = action(
         id,
         data: args.data,
         strokeWidth: args.strokeWidth ?? 3,
-        ...(args.curve === undefined ? {} : { curve: args.curve })
+        ...(args.curve === undefined ? {} : { curve: args.curve }),
+        ...requestedStrokeDetails(args, "createRegressionLine")
       })
       .encodeX({
         target: id,

package/src/actions/regression/create.js

@@ -1,6 +1,7 @@
 import { action } from "../../core/action.js";
 import { validateKeys } from "../../core/validation.js";
 import { normalizeRegressionParameters } from "../../grammar/regression/index.js";
+import { STROKE_STYLE_PROPERTIES } from "../../grammar/strokeStyle.js";
 import {
   findRegressionPoint,
   inferRegressionGroup,
@@ -49,11 +50,18 @@ export const createRegression = action(
     if (band !== false) {
       validateKeys(
         band,
-        ["color", "opacity", "stroke", "strokeWidth", "curve"],
+        [
+          "color", "opacity", "stroke", "strokeWidth", "curve",
+          ...STROKE_STYLE_PROPERTIES
+        ],
         "regression band"
       );
     }
-    validateKeys(line, ["strokeWidth", "curve"], "regression line");
+    validateKeys(
+      line,
+      ["strokeWidth", "curve", ...STROKE_STYLE_PROPERTIES],
+      "regression line"
+    );
     const colorEncoding = point.encoding?.color;
     const namespace = point.id;
     const dataId = `${namespace}RegressionData`;

package/src/actions/regression/edit.js

@@ -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;
 }
 
@@ -325,7 +334,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 +369,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 +383,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,172 @@
+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 new Error(`Resource "${id}" exists as ${other}, not ${kind}.`);
+    }
+    throw new Error(`Unknown ${kind} "${id}".`);
+  }
+
+  const owners = dataOwners(program).filter(owner => owner.owner === id);
+  if (owners.length > 1) {
+    throw new Error(`Data resource "${id}" has ambiguous logical ownership.`);
+  }
+  if (owners.length === 1) {
+    const owner = owners[0];
+    const current = exactResource(program, "data", owner.current);
+    if (current === undefined) {
+      throw new Error(`Data owner "${id}" has no current dataset.`);
+    }
+    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 new Error(`Resource "${id}" exists as ${other}, not data.`);
+  }
+  throw new Error(`Unknown data "${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 new Error(
+      `Cannot remove ${kind} "${id}"; live references: ` +
+      live.map(formatReference).join("; ")
+    );
+  }
+  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 = removeResource(
+  "data", "removeData", "Remove one unreferenced named dataset."
+);
+export const removeScale = removeResource(
+  "scale", "removeScale", "Remove one unreferenced named scale."
+);
+export const removeCoordinate = 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;