ggaction 0.0.17 → 0.0.18

package/src/actions/charts/pie.js

@@ -1,52 +1,8 @@
 import { action } from "../../core/action.js";
-import { STROKE_STYLE_PROPERTIES } from "../../grammar/strokeStyle.js";
-import {
-  applyFacadeGuides, normalizeAppearance, normalizeCategoricalColor, normalizeCategoricalGuides,
-  normalizeArcCategory, normalizeCategoryAggregate, omitUndefinedOptions,
-  resolveFacadeData, resolveFacadeId, validateFacadeOptions
-} from "./shared.js";
-
-const OPERATION = "createPiePlot";
-const OPTIONS = ["id", "data", "coordinate", "category", "value", "aggregate", "color", "arc", "guides"];
-const ARC_OPTIONS = [
-  "innerRadius", "padAngle", "fill", "opacity", "stroke", "strokeWidth",
-  ...STROKE_STYLE_PROPERTIES
-];
-function guideOptions(value, color) {
-  const guides = normalizeCategoricalGuides(value, OPERATION, color);
-  if (guides === false) return false;
-  for (const key of ["axes", "grid"]) {
-    if (guides[key] !== undefined && guides[key] !== false) {
-      throw new TypeError(`${OPERATION} guides.${key} only accepts false.`);
-    }
-  }
-  return { ...guides, axes: false, grid: false };
-}
+import { createArcPlot } from "./radial.js";
 
 export const createPiePlot = /* @__PURE__ */ action({
-  op: OPERATION, description: "Create a categorical count or weighted-sum pie or donut plot."
+  op: "createPiePlot", description: "Create a categorical count or weighted-sum pie or donut plot."
 }, function (args = {}) {
-  validateFacadeOptions(args, OPTIONS, OPERATION);
-  const id = resolveFacadeId(this, args.id, { defaultId: "piePlot", operation: OPERATION });
-  const data = resolveFacadeData(this, args.data, OPERATION);
-  const category = normalizeArcCategory(args.category, OPERATION);
-  const aggregate = normalizeCategoryAggregate(args, OPERATION);
-  const arc = omitUndefinedOptions(normalizeAppearance(args.arc, ARC_OPTIONS, `${OPERATION} arc`));
-  const color = args.color === false ? undefined
-    : normalizeCategoricalColor(args.color === undefined ? category.field : args.color, `${OPERATION} color`);
-  if (color !== undefined && arc.fill !== undefined) {
-    throw new Error(`${OPERATION} arc.fill cannot be combined with color; use color:false.`);
-  }
-  const guides = guideOptions(args.guides, color);
-  let next = this.createArcMark({ id, data, ...arc }).encodeTheta({
-    ...category, target: id, aggregate,
-    ...(args.coordinate === undefined ? {} : { coordinate: args.coordinate }),
-    ...(aggregate === "sum" ? { weight: args.value } : {})
-  });
-  if (color !== undefined) next = next.encodeColor({ ...color, target: id });
-  next = applyFacadeGuides(next, guides, id, args.guides ?? {});
-  return next._withMarkConfig(id, {
-    ...next.markConfigs[id],
-    compositionRole: "pie"
-  });
+  return createArcPlot(this, args, { operation: "createPiePlot", defaultId: "piePlot" });
 });

package/src/actions/charts/radial.js

@@ -1,3 +1,4 @@
+import { findSemanticScale } from "../../selectors/scales.js";
 import { action } from "../../core/action.js";
 import { STROKE_STYLE_PROPERTIES } from "../../grammar/strokeStyle.js";
 import {
@@ -6,21 +7,22 @@ import {
   resolveFacadeData, resolveFacadeId, validateFacadeOptions
 } from "./shared.js";
 
-const OPTIONS = ["id", "data", "coordinate", "category", "value", "aggregate", "radiusScale", "color", "arc", "guides"];
+const OPTIONS = ["id", "data", "coordinate", "category", "value", "aggregate", "color", "arc", "guides"];
 const ARC_OPTIONS = [
   "innerRadius", "padAngle", "fill", "opacity", "stroke", "strokeWidth",
   ...STROKE_STYLE_PROPERTIES
 ];
 const RADIUS_OPTIONS = ["id", "type", "domain", "range", "zero", "nice", "reverse", "clamp"];
 
-function createMeasuredPlot(program, args, { operation, defaultId, mapping }) {
-  validateFacadeOptions(args, OPTIONS, operation);
+export function createArcPlot(program, args, { operation, defaultId, mapping }) {
+  const measured = mapping !== undefined;
+  validateFacadeOptions(args, [...OPTIONS, measured ? "radiusScale" : "radius"], operation);
   const id = resolveFacadeId(program, args.id, { defaultId, operation });
   const data = resolveFacadeData(program, args.data, operation);
   const category = normalizeArcCategory(args.category, operation);
   const aggregate = normalizeCategoryAggregate(args, operation);
   const arc = omitUndefinedOptions(normalizeAppearance(args.arc, ARC_OPTIONS, `${operation} arc`));
-  if (arc.padAngle !== undefined && arc.padAngle !== 0) throw new Error(`${operation} requires padAngle 0.`);
+  if (measured && arc.padAngle !== undefined && arc.padAngle !== 0) throw new Error(`${operation} requires padAngle 0.`);
   const radiusScale = args.radiusScale === undefined ? undefined
     : omitUndefinedOptions(normalizeAppearance(args.radiusScale, RADIUS_OPTIONS, `${operation} radiusScale`));
   const color = args.color === false ? undefined
@@ -28,23 +30,43 @@ function createMeasuredPlot(program, args, { operation, defaultId, mapping }) {
   if (color !== undefined && arc.fill !== undefined) {
     throw new Error(`${operation} arc.fill cannot be combined with color; use color:false.`);
   }
-  const guides = normalizeCategoricalGuides(args.guides, operation, color);
+  let guides = normalizeCategoricalGuides(args.guides, operation, color);
+  if (!measured && guides !== false) {
+    for (const key of ["axes", "grid"]) {
+      if (guides[key] !== undefined && guides[key] !== false) {
+        throw new TypeError(`${operation} guides.${key} only accepts false.`);
+      }
+    }
+    guides = { ...guides, axes: false, grid: false };
+  }
   let next = program.createArcMark({ id, data, ...arc }).encodeTheta({
-    ...category, target: id, ...(args.coordinate === undefined ? {} : { coordinate: args.coordinate })
-  }).encodeR({ target: id, aggregate, mapping,
-    ...(aggregate === "sum" ? { field: args.value } : {}),
-    ...(radiusScale === undefined ? {} : { scale: radiusScale }) });
+    ...category, target: id, ...(args.coordinate === undefined ? {} : { coordinate: args.coordinate }),
+    ...(!measured ? { aggregate, ...(aggregate === "sum" ? { weight: args.value } : {}) } : {})
+  });
+  if (measured) {
+    next = next.encodeR({ target: id, aggregate, mapping,
+      ...(aggregate === "sum" ? { field: args.value } : {}),
+      ...(radiusScale === undefined ? {} : { scale: radiusScale }) });
+  } else if (args.radius !== undefined) {
+    const radius = typeof args.radius === "string" ? { field: args.radius }
+      : normalizeAppearance(args.radius, ["field", "aggregate", "scale"], `${operation} radius`);
+    const scale = radius.scale ?? {};
+    next = next.encodeR({ target: id, ...omitUndefinedOptions(radius), scale: {
+      ...(scale.type !== "log" && findSemanticScale(next, scale.id ?? "radius") === undefined ? { zero: true } : {}),
+      ...scale
+    } });
+  }
   if (color !== undefined) next = next.encodeColor({ ...color, target: id });
   next = applyFacadeGuides(next, guides, id, args.guides ?? {});
   return next._withMarkConfig(id, {
     ...next.markConfigs[id],
-    compositionRole: "rose"
+    compositionRole: measured ? "rose" : "pie"
   });
 }
 
 export const createRosePlot = /* @__PURE__ */ action({ op: "createRosePlot", description: "Create equal-angle sectors with area proportional to category count or sum." }, function (args = {}) {
-  return createMeasuredPlot(this, args, { operation: "createRosePlot", defaultId: "rosePlot", mapping: "area" });
+  return createArcPlot(this, args, { operation: "createRosePlot", defaultId: "rosePlot", mapping: "area" });
 });
 export const createRadialBarPlot = /* @__PURE__ */ action({ op: "createRadialBarPlot", description: "Create equal-angle sectors with radial length proportional to category count or sum." }, function (args = {}) {
-  return createMeasuredPlot(this, args, { operation: "createRadialBarPlot", defaultId: "radialBarPlot", mapping: "radius-length" });
+  return createArcPlot(this, args, { operation: "createRadialBarPlot", defaultId: "radialBarPlot", mapping: "radius-length" });
 });

package/src/actions/charts/scatter.js

@@ -1,3 +1,4 @@
+import { encodeStroke } from "../encodings/stroke.js";
 import { action } from "../../core/action.js";
 import { validateNonNegativeFinite } from "../../core/validation.js";
 import { STROKE_STYLE_PROPERTIES } from "../../grammar/strokeStyle.js";
@@ -15,7 +16,7 @@ import {
 } from "./shared.js";
 
 const OPTIONS = Object.freeze([
-  "id", "data", "coordinate", "x", "y", "color", "size", "shape",
+  "id", "data", "coordinate", "x", "y", "color", "stroke", "size", "shape",
   "point", "guides"
 ]);
 const POINT_OPTIONS = Object.freeze([
@@ -43,6 +44,13 @@ export const createScatterPlot = /* @__PURE__ */ action(
     const x = normalizeFieldEncoding(args.x, "createScatterPlot x");
     const y = normalizeFieldEncoding(args.y, "createScatterPlot y");
     const color = normalizeEncoding(args.color, "createScatterPlot color");
+    const stroke = normalizeEncoding(args.stroke, "createScatterPlot stroke");
+    if (stroke !== undefined) {
+      if (typeof stroke.field !== "string" || stroke.field.length === 0 || Object.hasOwn(stroke, "value")) {
+        throw new TypeError("createScatterPlot stroke requires a field; constant stroke belongs in point.");
+      }
+      if (Object.hasOwn(point, "stroke")) throw new Error("createScatterPlot stroke conflicts with point.stroke.");
+    }
     const size = normalizeEncoding(args.size, "createScatterPlot size");
     const shape = normalizeEncoding(args.shape, "createScatterPlot shape");
     const guides = normalizeGuides(args.guides, "createScatterPlot");
@@ -51,12 +59,18 @@ export const createScatterPlot = /* @__PURE__ */ action(
       if (size !== undefined) throw new Error("createScatterPlot point radius conflicts with size.");
     }
 
+    const initialPoint = { ...point };
+    if (stroke !== undefined) delete initialPoint.strokeWidth;
     let next = this
-      .createPointMark({ id, data, ...point })
+      .createPointMark({ id, data, ...initialPoint })
       .encodeX(positionArgs(x, { target: id, coordinate: args.coordinate }))
       .encodeY(positionArgs(y, { target: id, coordinate: args.coordinate }));
     if (radius !== undefined) next = next.encodePointRadius({ target: id, value: radius });
     if (color !== undefined) next = next.encodeColor(targetArgs(color, id));
+    if (stroke !== undefined) {
+      next = encodeStroke.call(next, targetArgs(stroke, id));
+      if (Object.hasOwn(point, "strokeWidth")) next = next.editPointMark({ target: id, strokeWidth: point.strokeWidth });
+    }
     if (size !== undefined) next = next.encodeSize(targetArgs(size, id));
     if (shape !== undefined) next = next.encodeShape(targetArgs(shape, id));
     return applyFacadeGuides(next, guides, id);

package/src/actions/charts/shared.js

@@ -191,9 +191,9 @@ export function normalizeArcCategory(value, operation) {
 }
 
 export function normalizeCategoryAggregate(args, operation) {
-  const aggregate = args.aggregate === undefined ? "count" : args.aggregate;
+  const aggregate = args.aggregate === undefined ? args.value === undefined ? "count" : "sum" : args.aggregate;
   if (!["count", "sum"].includes(aggregate) || (aggregate === "sum") !== (args.value !== undefined)) {
-    throw new Error(`${operation} requires count without value or explicit sum with value.`);
+    throw new Error(`${operation} requires count without value or sum with value.`);
   }
   if (args.value !== undefined) validateNonEmptyString(args.value, `${operation} value`);
   return aggregate;

package/src/actions/charts/text.js

@@ -0,0 +1,35 @@
+import { action } from "../../core/action.js";
+import { TEXT_MARK_STYLE_OPTIONS } from "../../grammar/text.js";
+import {
+  applyFacadeGuides, normalizeAppearance, normalizeEncoding, normalizeFieldEncoding,
+  normalizeGuides, positionArgs, resolveFacadeData, resolveFacadeId, targetArgs,
+  validateFacadeOptions
+} from "./shared.js";
+
+const OPTIONS = Object.freeze(["id", "data", "coordinate", "x", "y", "text", "color", "style", "guides"]);
+const STYLE_OPTIONS = Object.freeze(["missing", ...TEXT_MARK_STYLE_OPTIONS.filter(key => key !== "inheritColor")]);
+
+export const createTextPlot = /* @__PURE__ */ action({
+  op: "createTextPlot", description: "Create a Cartesian text plot from existing chart data."
+}, function (args = {}) {
+  validateFacadeOptions(args, OPTIONS, "createTextPlot");
+  const id = resolveFacadeId(this, args.id, { defaultId: "textPlot", operation: "createTextPlot" });
+  const data = resolveFacadeData(this, args.data, "createTextPlot");
+  const x = normalizeFieldEncoding(args.x, "createTextPlot x");
+  const y = normalizeFieldEncoding(args.y, "createTextPlot y");
+  const text = normalizeEncoding(args.text, "createTextPlot text");
+  if (text === undefined) throw new Error("createTextPlot requires text.");
+  const color = normalizeEncoding(args.color, "createTextPlot color");
+  const style = normalizeAppearance(args.style, STYLE_OPTIONS, "createTextPlot style");
+  const guides = normalizeGuides(args.guides, "createTextPlot");
+  const apply = program => {
+    let next = program.createTextMark({ id, data, ...style })
+      .encodeX(positionArgs(x, { target: id, coordinate: args.coordinate }))
+      .encodeY(positionArgs(y, { target: id, coordinate: args.coordinate }))
+      .encodeText(targetArgs(text, id));
+    if (color !== undefined) next = next.encodeColor(targetArgs(color, id));
+    return applyFacadeGuides(next, guides, id);
+  };
+  apply(this);
+  return apply(this);
+});

package/src/actions/composition/actions.js

@@ -1,3 +1,4 @@
+import { resolveGraphicBounds } from "../../layout/canvas.js";
 import { inheritTextMetrics } from "../textMetrics/index.js";
 import { action, closedAction } from "../../core/action.js";
 import { ChartProgram as CoreChartProgram } from "../../core/ChartProgram.js";
@@ -19,7 +20,7 @@ const CONCAT_OPTIONS = Object.freeze([
   "id", "programs", "gap", "align", "padding"
 ]);
 const LAYOUT_EDIT_OPTIONS = Object.freeze([
-  "columns", "gap", "align", "padding"
+  "columns", "gap", "spacing", "align", "padding"
 ]);
 const REPLACEMENT_OPTIONS = Object.freeze(["target", "program"]);
 const INSERTION_OPTIONS = Object.freeze(["id", "program", "before", "after"]);
@@ -179,6 +180,7 @@ const editCompositionLayout = /* @__PURE__ */ closedAction(
         "editCompositionLayout columns is available only on a facet composition."
       );
     }
+    if (current.type !== "facet" && Object.hasOwn(args, "spacing")) throw new Error("Plot spacing requires a facet composition.");
     const padding = Object.hasOwn(args, "padding")
       ? normalizeCompositionPadding(args.padding, current.padding)
       : current.padding;
@@ -188,6 +190,8 @@ const editCompositionLayout = /* @__PURE__ */ closedAction(
         (current.facet.grid?.cells ?? []).map(cell => [cell.id, cell])
       );
       layout = resolveFacetLayout({
+        spacing: option(args, "spacing", current.spacing),
+        plots: current.children.map(id => ({ id, ...resolveGraphicBounds(this.children[id]) })),
         children: current.children.map((id, index) => ({
           ...childDescriptor({ id, program: this.children[id] }),
           value: current.facet.values[index],
@@ -218,7 +222,7 @@ const editCompositionLayout = /* @__PURE__ */ closedAction(
       children: this.children,
       compositionSpec: {
         ...current,
-        ...(current.type === "facet" ? { columns: layout.columns } : {}),
+        ...(current.type === "facet" ? { columns: layout.columns, ...(layout.spacing !== undefined ? { spacing: layout.spacing } : current.spacing !== undefined ? { spacing: "canvas" } : {}) } : {}),
         gap: layout.gap,
         align: layout.align,
         padding: layout.padding

package/src/actions/data/box.js

@@ -2,7 +2,7 @@ import { BOX_FIELDS, deriveBoxData, normalizeBoxTransform } from "../../grammar/
 import { derivedCreator, derivedMaterializer } from "./shared.js";
 
 const OPTIONS = Object.freeze([
-  "id", "source", "category", "field", "whisker", "factor", "as"
+  "id", "source", "category", "field", "whisker", "factor", "as", "summary"
 ]);
 
 function materializer(type, op, select) {
@@ -28,6 +28,7 @@ function creator(type, op, materialize) {
       type,
       category: args.category,
       field: args.field,
+      ...(args.summary === undefined ? {} : { summary: args.summary }),
       ...(args.whisker === undefined ? {} : { whisker: args.whisker }),
       ...(args.factor === undefined ? {} : { factor: args.factor }),
       as: args.as ?? BOX_FIELDS

package/src/actions/data/edit.js

@@ -509,7 +509,7 @@ export const editStackData = /* @__PURE__ */ focusedEditor(
 );
 export const editRegressionData = /* @__PURE__ */ focusedEditor(
   "editRegressionData", "regression", [
-    "x", "y", "groupBy", "method", "degree", "span", "confidenceMethod",
+    "x", "y", "groupBy", "method", "degree", "span", "robustIterations", "confidenceMethod",
     "level", "confidence", "interval", "predict"
   ]
 );

package/src/actions/data/regression.js

@@ -9,7 +9,7 @@ import { resolveDatasetReference } from "../../selectors/datasets.js";
 import { derivedMaterializer } from "./shared.js";
 
 const OPTIONS = Object.freeze([
-  "id", "source", "x", "y", "groupBy", "method", "degree", "span",
+  "id", "source", "x", "y", "groupBy", "method", "degree", "span", "robustIterations",
   "confidenceMethod", "level", "confidence", "interval"
   , "predict", "missing"
 ]);
@@ -25,6 +25,7 @@ export const materializeRegressionData = /* @__PURE__ */ derivedMaterializer(
       method: transform.method,
       degree: transform.degree,
       span: transform.span,
+      robustIterations: transform.robustIterations,
       confidenceMethod: transform.confidenceMethod,
       level: transform.level,
       confidence: transform.confidence,

package/src/actions/data/shared.js

@@ -87,11 +87,12 @@ export function derivedCreator(
   sourceLabel,
   transform,
   materialize,
-  requireSource = false
+  requireSource = false,
+  defaultId
 ) {
   return action({ op, description }, function (args = {}) {
     validateKeys(args, options, op);
-    const id = validateUserId(args.id, idLabel);
+    const id = validateUserId(args.id === undefined ? defaultId : args.id, idLabel);
     const requestedSource = validateUserId(
       requireSource ? args.source : args.source ?? this.context.currentData,
       sourceLabel

package/src/actions/data/stack.js

@@ -22,5 +22,7 @@ export const createStackData = /* @__PURE__ */ derivedCreator(
   "Stack dataset id",
   "Stack source dataset id",
   normalizeStackTransform,
-  "materializeStackData"
+  "materializeStackData",
+  false,
+  "stacked"
 );

package/src/actions/encodings/appearance.js

@@ -1,9 +1,8 @@
+import { canMaterializeBar } from "../../materialization/marks/index.js";
 import { action } from "../../core/action.js";
 import { validatePathSeriesAppearance } from "../../grammar/pathSeries.js";
 import { assertEncodingSelectionCompatibility } from "../../materialization/selection/compatibility.js";
 import {
-  readNominalField,
-  readQuantitativeField,
   readScaleField,
   validateOpacityValue
 } from "../../grammar/scales/index.js";
@@ -42,11 +41,11 @@ function encodeAppearanceField(program, channel, args, operation) {
     ["point"],
     "point mark"
   );
-  const expectedFieldType = channel === "shape" ? "nominal" : "quantitative";
+  const fieldTypes = channel === "shape" ? ["nominal"] : ["quantitative", "nominal", "ordinal"];
   const dataset = applyRequestedItemMissingPolicy(layer, sourceDataset, args.field);
-  const fieldType = args.fieldType ?? expectedFieldType;
-  if (fieldType !== expectedFieldType) {
-    throw new Error(`${operation} requires a ${expectedFieldType} field.`);
+  const fieldType = args.fieldType ?? fieldTypes[0];
+  if (!fieldTypes.includes(fieldType)) {
+    throw new Error(`${operation} requires a ${fieldTypes.join(" or ")} field.`);
   }
   if (channel === "size" && program.markConfigs[target]?.radius !== undefined) {
     throw new Error("encodeSize cannot be combined with a constant radius.");
@@ -59,17 +58,12 @@ function encodeAppearanceField(program, channel, args, operation) {
   const scale = resolveAppearanceScaleDefinition(
     program,
     channel,
-    requestedScale
+    requestedScale,
+    fieldType
   );
-  if (Object.hasOwn(scale, "unknown")) {
-    readScaleField(dataset.values, args.field, fieldType, {
-      allowUnknown: true
-    });
-  } else if (channel === "shape") {
-    readNominalField(dataset.values, args.field);
-  } else {
-    readQuantitativeField(dataset.values, args.field);
-  }
+  readScaleField(dataset.values, args.field, fieldType, {
+    allowUnknown: Object.hasOwn(scale, "unknown")
+  });
 
   let next = setEncodingProperties(program, target, channel, {
     field: args.field,
@@ -152,7 +146,7 @@ const removePointRadius = /* @__PURE__ */ action(
 const encodeSize = /* @__PURE__ */ action(
   {
     op: "encodeSize",
-    description: "Encode a quantitative field as equal-area point size."
+    description: "Encode a field as equal-area point size."
   },
   function (args = {}) {
     return encodeAppearanceField(this, "size", args, "encodeSize");
@@ -184,6 +178,17 @@ const clearOpacityEncoding = /* @__PURE__ */ action(
   }
 );
 
+function withoutConstantOpacity(program, target) {
+  const { opacity, ...config } = program.markConfigs[target] ?? {};
+  void opacity;
+  if (config.barAppearance?.opacity !== undefined) {
+    const { opacity: barOpacity, ...appearance } = config.barAppearance;
+    void barOpacity;
+    config.barAppearance = appearance;
+  }
+  return program._withMarkConfig(target, config);
+}
+
 const encodeOpacity = /* @__PURE__ */ action(
   {
     op: "encodeOpacity",
@@ -202,14 +207,13 @@ const encodeOpacity = /* @__PURE__ */ action(
     const { id: target, dataset: sourceDataset, layer } = resolveTarget(
       this,
       args.target,
-      ["point", "rule", "line"],
-      "point, rule or line mark"
+      ["point", "rule", "line", "bar"],
+      "point, rule, line or bar mark"
     );
     if (hasValue) {
       validateOpacityValue(args.value, "encodeOpacity");
       assertEncodingSelectionCompatibility(this, target, ["opacity"]);
-      const { opacity, ...config } = this.markConfigs[target] ?? {};
-      void opacity;
+      const config = withoutConstantOpacity(this, target).markConfigs[target];
       const withoutLegend = this.guideConfigs.legend?.opacity?.target === target
         ? this.removeOpacityLegend()
         : this;
@@ -220,6 +224,11 @@ const encodeOpacity = /* @__PURE__ */ action(
       if (layer.mark.type === "line") {
         return rematerializeEncoding(next, target, "opacity", undefined, layer);
       }
+      if (layer.mark.type === "bar") {
+        return canMaterializeBar(next, findLayer(next, target))
+          ? applyDetachedScaleRematerialization(next.rematerializeBarMark({ id: target }), [layer])
+          : next;
+      }
       const materialized = layer.mark.type === "rule"
         ? next.rematerializeRuleMark({ id: target })
         : next.rematerializePointMark({ id: target });
@@ -244,17 +253,13 @@ const encodeOpacity = /* @__PURE__ */ action(
         ...layer, encoding: { ...layer.encoding, opacity: { field: args.field, fieldType } }
       });
     }
-    if (Object.hasOwn(scale, "unknown")) {
-      readScaleField(dataset.values, args.field, fieldType, {
-        allowUnknown: true
-      });
-    } else {
-      readQuantitativeField(dataset.values, args.field);
-    }
+    readScaleField(dataset.values, args.field, fieldType, {
+      allowUnknown: Object.hasOwn(scale, "unknown")
+    });
     const { opacity, ...config } = this.markConfigs[target] ?? {};
     void opacity;
     let next = setEncodingProperties(
-      this._withoutMaterializationConfig(["marks", target, "opacity"]),
+      withoutConstantOpacity(this, target),
       target,
       "opacity",
       { field: args.field, fieldType, scale: scale.id }
@@ -262,6 +267,9 @@ const encodeOpacity = /* @__PURE__ */ action(
     next = applyEncodingScale(next, scale, requestedScale, {
       reassignment: previous?.scale === scale.id
     });
+    if (layer.mark.type === "bar" && !canMaterializeBar(next, findLayer(next, target))) {
+      return next.rematerializeScale({ id: scale.id });
+    }
     return rematerializeEncoding(next, target, "opacity", scale.id, layer);
   }
 );

package/src/actions/encodings/barWidth.js

@@ -4,11 +4,33 @@ import {
   BAR_GRAINS,
   resolveBarColorLayout,
   resolveBarOffsetChannel,
+  resolveBarChannels,
   resolveBarGrain
 } from "../../grammar/bars/policy.js";
 import { normalizeBarWidth } from "../../grammar/bars/geometry.js";
+import { applyMaterializationPlan } from "../../materialization/dependencies.js";
+import {
+  getScaleConsumerMarkSteps,
+  getSourceDependentMarkSteps
+} from "../../materialization/marks/index.js";
+
+function rematerializeWidth(program, target, layer, width) {
+  const next = program._withMarkConfig(target, {
+    ...program.markConfigs[target], barWidth: width
+  }).rematerializeBarMark({ id: target });
+  const category = resolveBarChannels(layer)?.category;
+  const encoding = layer.encoding?.[category];
+  if (encoding?.fieldType !== "temporal") return next;
+  const marks = getScaleConsumerMarkSteps(next, [encoding.scale])
+    .filter(step => step.args.id !== target);
+  return applyMaterializationPlan(next, [
+    ...marks,
+    ...[target, ...marks.map(step => step.args.id)]
+      .flatMap(id => getSourceDependentMarkSteps(next, id))
+  ]);
+}
 
-const OPTIONS = Object.freeze(["band", "pixels", "target"]);
+const OPTIONS = Object.freeze(["band", "pixels", "interval", "target"]);
 
 const encodeBarWidth = /* @__PURE__ */ action(
   {
@@ -26,22 +48,30 @@ const encodeBarWidth = /* @__PURE__ */ action(
     const layout = resolveBarColorLayout(layer);
     const width = normalizeBarWidth(
       args,
-      this.markConfigs[target]?.barWidth
+      this.markConfigs[target]?.barWidth ?? (layer.mark.orientation === undefined ? undefined : { pixels: 5 })
     );
     const grouped = layout === "group";
     const offsetChannel = resolveBarOffsetChannel(layer);
     const grain = resolveBarGrain(layer);
+    if (layer.mark.orientation !== undefined && width.band !== undefined) {
+      throw new Error("Numeric-center bars require pixel width.");
+    }
     if (grain === undefined && this.markConfigs[target]?.boxPlot === undefined && (
       layer.encoding?.x === undefined || layer.encoding?.y === undefined
     )) {
       return this._withMarkConfig(target, { ...this.markConfigs[target], barWidth: width });
     }
+    if (width.interval !== undefined && grain !== undefined) {
+      const category = resolveBarChannels(layer)?.category;
+      if (grain !== BAR_GRAINS.aggregate || grouped || layer.encoding?.[category]?.fieldType !== "temporal") {
+        throw new Error("Bar interval width requires ungrouped aggregate temporal categories.");
+      }
+    }
     if (grain === BAR_GRAINS.histogram) {
       throw new Error("encodeBarWidth requires an aggregate or ranged category slot, not histogram bins.");
     }
-    if (grain === BAR_GRAINS.ranged) {
-      return this._withMarkConfig(target, { ...this.markConfigs[target], barWidth: width })
-        .rematerializeBarMark({ id: target });
+    if ([BAR_GRAINS.ranged, BAR_GRAINS.centered].includes(grain)) {
+      return rematerializeWidth(this, target, layer, width);
     }
     if (
       grain !== BAR_GRAINS.aggregate ||
@@ -56,12 +86,7 @@ const encodeBarWidth = /* @__PURE__ */ action(
       );
     }
 
-    return this
-      ._withMarkConfig(target, {
-        ...this.markConfigs[target],
-        barWidth: width
-      })
-      .rematerializeBarMark({ id: target });
+    return rematerializeWidth(this, target, layer, width);
   }
 );
 

package/src/actions/encodings/channels.js

@@ -155,7 +155,6 @@ function resolveScaleOnly(program, id) {
   }
   const consumers = findScaleConsumers(program, id);
   if (
-    semanticScale.radialMapping !== undefined &&
     consumers.length > 0 &&
     consumers.every(isPendingMeasuredRadiusConsumer)
   ) {

package/src/actions/encodings/color/continuous.js

@@ -39,7 +39,7 @@ export function encodeContinuousColor(program, args) {
   const { id: target, dataset: sourceDataset, layer } = resolveTarget(
     program,
     args.target,
-    ["point", "bar", "rect"],
+    ["point", "bar", "rect", "text"],
     "continuous color mark"
   );
   const dataset = applyRequestedItemMissingPolicy(layer, sourceDataset, args.field);

package/src/actions/encodings/color/index.js

@@ -63,7 +63,7 @@ const encodeColor = /* @__PURE__ */ action(
     const { id: target, dataset: sourceDataset, layer } = resolveTarget(
       this,
       args.target,
-      ["point", "line", "bar", "area", "arc", "rect"],
+      ["point", "line", "bar", "area", "arc", "rect", "text"],
       "color mark"
     );
     const dataset = applyRequestedItemMissingPolicy(layer, sourceDataset, args.field);

package/src/actions/encodings/color/policy.js

@@ -20,6 +20,9 @@ export function resolveColorScaleOptions(args) {
 }
 
 export function assertNoConstantColor(program, layer) {
+  if (layer.mark.type === "text" && layer.source !== undefined) {
+    throw new Error("Source-owned text uses inheritColor or constant fill; field color requires row-backed text.");
+  }
   const config = program.markConfigs[layer.id];
   const hasConstant = {
     point: config?.fill !== undefined,
@@ -27,7 +30,8 @@ export function assertNoConstantColor(program, layer) {
     area: config?.errorBand?.fill !== undefined,
     bar: config?.barAppearance?.fill !== undefined,
     arc: config?.fill !== undefined,
-    rect: config?.fillExplicit === true
+    rect: config?.fillExplicit === true,
+    text: config?.fillExplicit === true
   }[layer.mark.type] ?? false;
   if (hasConstant) {
     throw new Error(
@@ -58,15 +62,18 @@ export function resolveColorLayout(layer, requested, barGrain) {
     layer.mark.type === "bar"
       ? barGrain === BAR_GRAINS.histogram
         ? "stack"
-        : barGrain === BAR_GRAINS.ranged ? "overlay" : "group"
+        : [BAR_GRAINS.ranged, BAR_GRAINS.centered].includes(barGrain) ? "overlay" : "group"
       : layer.mark.type === "area"
         ? "overlay"
         : undefined
   );
 
-  if (["point", "line", "rect"].includes(layer.mark.type) && layout !== undefined) {
+  if (["point", "line", "rect", "text"].includes(layer.mark.type) && layout !== undefined) {
     throw new Error(`Color layout is not supported for ${layer.mark.type} marks.`);
   }
+  if (barGrain === BAR_GRAINS.centered && layout !== "overlay") {
+    throw new Error("Numeric-center bars support only overlay layout.");
+  }
   if (layer.mark.type === "area" && layout === "group") {
     throw new Error('Area color layout does not support "group".');
   }