ggaction 0.0.13 → 0.0.16

package/src/actions/errorBands/edit.js

@@ -1,22 +1,19 @@
-import { action } from "../../core/action.js";
+import { currentIntervalRoleArgs, resolveIntervalRoleScales, applyIntervalStatistics } from "../intervals/revision.js";
+import { closedAction } from "../../core/action.js";
 import { isPlainObject } from "../../core/immutable.js";
 import { validateUserId } from "../../core/identifiers.js";
-import {
-  validateOptionObject,
-  validateKeys,
-  validateNonEmptyString,
-  validateNonNegativeFinite,
-  validateUnitInterval
-} from "../../core/validation.js";
+import { validateKeys, validateNonEmptyString, validateNonNegativeFinite, validateUnitInterval } from "../../core/validation.js";
 import { validateCurveInterpolation } from "../../grammar/curveCommands.js";
 import { normalizeStrokeDashPattern } from "../../grammar/scales/index.js";
+import {
+  requestedStrokeDetails,
+  STROKE_STYLE_PROPERTIES
+} from "../../grammar/strokeStyle.js";
 import { findLayer } from "../../selectors/layers.js";
-import { findSemanticScale } from "../../selectors/scales.js";
 import { removeOwnedMark } from "../marks/remove.js";
 import { DEFAULT_COLORS } from "../../theme/defaults.js";
 import { resolveIntervalComposite } from "../intervals/resolve.js";
 import {
-  resolveDistributionScalePlan,
   setCartesianPosition,
   updateDistributionPositions
 } from "../distributions/revision.js";
@@ -32,7 +29,8 @@ import {
 } from "../data/intervalEdit.js";
 
 export const ERROR_BAND_BOUNDARY_OPTIONS = Object.freeze([
-  "stroke", "strokeWidth", "strokeDash", "opacity", "curve"
+  "stroke", "strokeWidth", "strokeDash", "opacity", "curve",
+  ...STROKE_STYLE_PROPERTIES
 ]);
 
 export function resolveBoundaryAppearance(value, { defaults, operation }) {
@@ -49,14 +47,20 @@ export function resolveBoundaryAppearance(value, { defaults, operation }) {
   validateNonNegativeFinite(strokeWidth, `${operation} strokeWidth`);
   const resolvedStrokeDash = normalizeStrokeDashPattern(strokeDash);
   validateUnitInterval(opacity, `${operation} opacity`);
-  return { stroke, strokeWidth, strokeDash: resolvedStrokeDash, opacity, curve };
+  return {
+    stroke,
+    strokeWidth,
+    strokeDash: resolvedStrokeDash,
+    opacity,
+    curve,
+    ...requestedStrokeDetails({ ...defaults, ...value }, operation)
+  };
 }
 
 const EDIT_OPTIONS = Object.freeze([
   "target", "data", "x", "y", "groupBy", "fill", "opacity", "curve",
-  "statistics", "boundaries"
+  "statistics", "boundaries", ...STROKE_STYLE_PROPERTIES
 ]);
-const STATISTICS_OPTIONS = Object.freeze(["center", "extent", "method", "level"]);
 const EDIT_POLICY = Object.freeze({
   operation: "editErrorBand",
   resourceLabel: "error-band",
@@ -104,48 +108,13 @@ function resolveOwner(program, requested) {
   });
 }
 
-function currentRoleArgs(program, owner, current) {
-  const transform = findIntervalTransform(program, current.data);
-  const intervalChannel = current.orientation === "vertical" ? "y" : "x";
-  const positionChannel = intervalChannel === "x" ? "y" : "x";
-  const position = {
-    field: current.position.field,
-    fieldType: current.position.fieldType,
-    ...(current.position.temporalUnit === undefined
-      ? {}
-      : { temporalUnit: current.position.temporalUnit }),
-    scale: { id: current.positionScale }
-  };
-  const interval = transform === undefined
-    ? {
-        center: current.centerField ?? owner.encoding[intervalChannel].title,
-        lower: current.lowerField,
-        upper: current.upperField,
-        scale: { id: current.intervalScale }
-      }
-    : {
-        field: transform.field,
-        center: transform.center,
-        extent: transform.extent,
-        ...(transform.method === undefined ? {} : { method: transform.method }),
-        ...(transform.level === undefined ? {} : { level: transform.level }),
-        scale: { id: current.intervalScale }
-      };
-  return {
-    source: current.source ?? transform?.source ?? current.data,
-    x: positionChannel === "x" ? position : interval,
-    y: positionChannel === "y" ? position : interval,
-    groupBy: current.groupBy
-  };
-}
-
 function channelArgs(requested, fallback) {
   if (requested === undefined) return fallback;
   return requested;
 }
 
 function resolveRoleCandidate(program, owner, current, args) {
-  const previous = currentRoleArgs(program, owner, current);
+  const previous = currentIntervalRoleArgs(program, owner, current, false);
   const full = {
     data: Object.hasOwn(args, "data") ? args.data : previous.source,
     x: channelArgs(args.x, previous.x),
@@ -167,75 +136,11 @@ function resolveRoleCandidate(program, owner, current, args) {
       "editErrorBand groupBy must differ from the independent position field."
     );
   }
-  if (Object.hasOwn(args, "statistics")) {
-    if (!isPlainObject(args.statistics)) {
-      throw new TypeError("editErrorBand statistics must be a plain object.");
-    }
-    validateKeys(args.statistics, STATISTICS_OPTIONS, "editErrorBand statistics");
-    if (!STATISTICS_OPTIONS.some(key => Object.hasOwn(args.statistics, key))) {
-      throw new Error(
-        "editErrorBand statistics requires center, extent, method, or level."
-      );
-    }
-    full[resolved.interval.channel] = {
-      ...full[resolved.interval.channel],
-      ...args.statistics
-    };
-    resolved = resolveIntervalComposite(program, full, policy);
-  }
-  const positionRole = {
-    field: resolved.position.field,
-    fieldType: resolved.position.fieldType,
-    scale: resolved.position.scale
-  };
-  const intervalTitle = resolved.interval.mode === "statistical"
-    ? resolved.interval.field
-    : resolved.interval.title;
-  const intervalRole = {
-    field: intervalTitle,
-    fieldType: "quantitative",
-    scale: resolved.interval.scale
-  };
-  const x = resolved.position.channel === "x" ? positionRole : intervalRole;
-  const y = resolved.position.channel === "y" ? positionRole : intervalRole;
-  const plan = (channel, role) => {
-    const fallback = role === intervalRole
-      ? current.intervalScale
-      : current.positionScale;
-    const stored = findSemanticScale(program, fallback);
-    const compatible = role.fieldType === "temporal"
-      ? stored?.type === "time"
-      : ["linear", "log", "pow", "sqrt", "symlog"].includes(stored?.type);
-    const requested = role.scale.type !== undefined || compatible
-      ? role.scale
-      : { ...role.scale, type: role.fieldType === "temporal" ? "time" : "linear" };
-    return resolveDistributionScalePlan(program, {
-      channel,
-      fieldType: role.fieldType,
-      requested,
-      fallback,
-      defaults: role === intervalRole
-        ? EDIT_POLICY.intervalScaleDefaults
-        : EDIT_POLICY.scaleDefaults(role.fieldType)
-    });
-  };
-  const xScale = plan("x", x);
-  const yScale = plan("y", y);
+  resolved = applyIntervalStatistics(program, full, policy, args, resolved);
+  const roles = resolveIntervalRoleScales(program, resolved, current, EDIT_POLICY, owner, previous);
   return {
     ...resolved,
-    x: { ...x, scale: xScale.id },
-    y: { ...y, scale: yScale.id },
-    xScale,
-    yScale,
-    category: resolved.position.field,
-    categoryType: resolved.position.fieldType,
-    measure: intervalTitle,
-    previous: {
-      x: { field: previous.x.center ?? previous.x.field,
-        fieldType: owner.encoding.x.fieldType, scale: owner.encoding.x.scale },
-      y: { field: previous.y.center ?? previous.y.field,
-        fieldType: owner.encoding.y.fieldType, scale: owner.encoding.y.scale }
-    }
+    ...roles
   };
 }
 
@@ -331,7 +236,8 @@ function currentBoundaryAppearance(program, id) {
     strokeWidth: config.strokeWidth,
     strokeDash: config.strokeDash,
     opacity: config.opacity,
-    curve: config.curve ?? "linear"
+    curve: config.curve ?? "linear",
+    ...requestedStrokeDetails(config, "Error-band boundary")
   };
 }
 
@@ -376,17 +282,12 @@ function removeBoundary(program, id) {
   return removeOwnedMark(program, id);
 }
 
-export const rematerializeErrorBandBoundary = action(
+export const rematerializeErrorBandBoundary = /* @__PURE__ */ closedAction(
   {
     op: "rematerializeErrorBandBoundary",
     description: "Rematerialize one owned error-band boundary."
-  },
+  }, REMATERIALIZE_OPTIONS,
   function (args = {}) {
-    validateOptionObject(
-      args,
-      REMATERIALIZE_OPTIONS,
-      "rematerializeErrorBandBoundary"
-    );
     const id = validateUserId(args.id, "Error-band boundary id");
     currentBoundaryAppearance(this, id);
     const graphic = this.graphicSpec.objects[id];
@@ -397,7 +298,8 @@ export const rematerializeErrorBandBoundary = action(
         strokeWidth: args.strokeWidth,
         strokeDash: args.strokeDash,
         opacity: args.opacity,
-        curve: args.curve
+        curve: args.curve,
+        ...requestedStrokeDetails(args, "Error-band boundary")
       })
       .editGraphics({
         target: id,
@@ -408,20 +310,20 @@ export const rematerializeErrorBandBoundary = action(
   }
 );
 
-export const editErrorBand = action(
+export const editErrorBand = /* @__PURE__ */ closedAction(
   {
     op: "editErrorBand",
     description: "Revise one error band's roles, statistics, body, and boundaries."
-  },
+  }, EDIT_OPTIONS,
   function (args = {}) {
-    validateOptionObject(args, EDIT_OPTIONS, "editErrorBand");
     if (!["data", "x", "y", "groupBy", "fill", "opacity", "curve",
-      "statistics", "boundaries"]
+      "statistics", "boundaries", ...STROKE_STYLE_PROPERTIES]
       .some(key => Object.hasOwn(args, key))) {
       throw new Error("editErrorBand requires at least one change.");
     }
     const owner = resolveOwner(this, args.target);
     const config = { ...this.markConfigs[owner.id] };
+    Object.assign(config, requestedStrokeDetails(args, "editErrorBand"));
     const errorBand = { ...config.errorBand };
     if (Object.hasOwn(args, "fill")) {
       if (args.fill === false) {
@@ -570,17 +472,12 @@ export const editErrorBand = action(
   }
 );
 
-export const editErrorBandBoundary = action(
+export const editErrorBandBoundary = /* @__PURE__ */ closedAction(
   {
     op: "editErrorBandBoundary",
     description: "Edit one or both owned error-band boundaries."
-  },
+  }, BOUNDARY_EDIT_OPTIONS,
   function (args = {}) {
-    validateOptionObject(
-      args,
-      BOUNDARY_EDIT_OPTIONS,
-      "editErrorBandBoundary"
-    );
     if (!ERROR_BAND_BOUNDARY_OPTIONS.some(key => Object.hasOwn(args, key))) {
       throw new Error("editErrorBandBoundary requires an appearance change.");
     }

package/src/actions/errorBars/create.js

@@ -1,16 +1,15 @@
-import { action } from "../../core/action.js";
-import {
-  validateKeys,
-  validateOptionObject
-} from "../../core/validation.js";
+import { closedAction } from "../../core/action.js";
+import { validateOptionObject } from "../../core/validation.js";
 import { findLayer } from "../../selectors/layers.js";
 import { findDataset } from "../../selectors/datasets.js";
+import { findSemanticScale } from "../../selectors/scales.js";
 import { DEFAULT_COLORS } from "../../theme/defaults.js";
 import {
   readNominalField,
   validateCategoricalFieldType
 } from "../../grammar/scales/index.js";
 import { normalizeOffsetPadding } from "../../grammar/bars/geometry.js";
+import { STROKE_STYLE_PROPERTIES } from "../../grammar/strokeStyle.js";
 import { createResolvedIntervalData, ownOptions } from
   "../data/intervalEdit.js";
 import { resolveIntervalComposite } from "../intervals/resolve.js";
@@ -31,7 +30,8 @@ const OPTIONS = Object.freeze([
   "stroke",
   "strokeWidth",
   "strokeDash",
-  "opacity"
+  "opacity",
+  ...STROKE_STYLE_PROPERTIES
 ]);
 
 const OFFSET_OPTIONS = Object.freeze([
@@ -101,7 +101,15 @@ function resolveErrorBarOffset(program, args, resolved, operation) {
     explicit ?? {},
     resolved.sourceLayer === undefined
       ? undefined
-      : program.markConfigs[resolved.sourceLayer.id]?.[channel],
+      : (() => {
+          const semantic = inferred?.scale === undefined
+            ? undefined
+            : findSemanticScale(program, inferred.scale);
+          return semantic !== undefined && ["paddingInner", "paddingOuter"]
+            .some(property => Object.hasOwn(semantic, property))
+            ? semantic
+            : program.markConfigs[resolved.sourceLayer.id]?.[channel];
+        })(),
     channel
   );
   return {
@@ -118,7 +126,8 @@ function resolveErrorBarOffset(program, args, resolved, operation) {
 
 function resolveAppearance(args) {
   return resolveErrorBarAppearance(ownOptions(args, [
-    "caps", "capSize", "stroke", "strokeWidth", "strokeDash", "opacity"
+    "caps", "capSize", "stroke", "strokeWidth", "strokeDash", "opacity",
+    ...STROKE_STYLE_PROPERTIES
   ]), {
     defaults: {
       caps: true,
@@ -132,19 +141,19 @@ function resolveAppearance(args) {
   });
 }
 
-export const createErrorBarCap = action(
+export const createErrorBarCap = /* @__PURE__ */ closedAction(
   {
     op: "createErrorBarCap",
     description: "Create one fixed-pixel error-bar cap."
-  },
-  function (args = {}) {
-    validateKeys(args, [
+  }, [
       "id", "data", "orientation", "positionField", "positionFieldType",
       "intervalField", "coordinate", "positionScale", "intervalScale", "positionTemporalUnit",
       "offsetChannel", "offsetField", "offsetFieldType", "offsetScale",
       "offsetPaddingInner", "offsetPaddingOuter",
-      "capSize", "stroke", "strokeWidth", "strokeDash", "opacity"
-    ], "createErrorBarCap");
+      "capSize", "stroke", "strokeWidth", "strokeDash", "opacity",
+      ...STROKE_STYLE_PROPERTIES
+    ],
+  function (args = {}) {
     if (!["vertical", "horizontal"].includes(args.orientation)) {
       throw new Error(`Unsupported error-bar orientation "${args.orientation}".`);
     }
@@ -161,7 +170,13 @@ export const createErrorBarCap = action(
     const positionAction = vertical ? "encodeX" : "encodeY";
     const intervalAction = vertical ? "encodeY" : "encodeX";
     let next = this
-      .createRuleMark({ id: args.id, data: args.data })
+      .createRuleMark({
+        id: args.id,
+        data: args.data,
+        ...Object.fromEntries(STROKE_STYLE_PROPERTIES.flatMap(property =>
+          Object.hasOwn(args, property) ? [[property, args[property]]] : []
+        ))
+      })
       [positionAction]({
         target: args.id,
         field: args.positionField,
@@ -237,17 +252,22 @@ function intervalArgs(resolved, field) {
   };
 }
 
-export const createErrorBar = action(
+export const createErrorBar = /* @__PURE__ */ closedAction(
   {
     op: "createErrorBar",
     description: "Create a statistical or explicit vertical or horizontal interval."
-  },
+  }, OPTIONS,
   function (args = {}) {
-    validateKeys(args, OPTIONS, "createErrorBar");
     const resolved = resolveErrorBar(this, args);
     const appearance = resolveAppearance(args);
     let next = createResolvedIntervalData(this, resolved);
-    next = next.createRuleMark({ id: resolved.id, data: resolved.dataId });
+    next = next.createRuleMark({
+      id: resolved.id,
+      data: resolved.dataId,
+      ...Object.fromEntries(STROKE_STYLE_PROPERTIES.flatMap(property =>
+        Object.hasOwn(appearance, property) ? [[property, appearance[property]]] : []
+      ))
+    });
     const positionAction = resolved.position.channel === "x" ? "encodeX" : "encodeY";
     const intervalAction = resolved.interval.channel === "x" ? "encodeX" : "encodeY";
     const secondaryAction = resolved.interval.channel === "x" ? "encodeX2" : "encodeY2";
@@ -303,7 +323,10 @@ export const createErrorBar = action(
           stroke: appearance.stroke,
           strokeWidth: appearance.strokeWidth,
           strokeDash: appearance.strokeDash,
-          opacity: appearance.opacity
+          opacity: appearance.opacity,
+          ...Object.fromEntries(STROKE_STYLE_PROPERTIES.flatMap(property =>
+            Object.hasOwn(appearance, property) ? [[property, appearance[property]]] : []
+          ))
         });
       }
     }

package/src/actions/errorBars/edit.js

@@ -1,5 +1,5 @@
-import { action } from "../../core/action.js";
-import { isPlainObject } from "../../core/immutable.js";
+import { currentIntervalRoleArgs, resolveIntervalRoleScales, applyIntervalStatistics } from "../intervals/revision.js";
+import { closedAction } from "../../core/action.js";
 import { validateUserId } from "../../core/identifiers.js";
 import {
   validateKeys,
@@ -14,10 +14,8 @@ import {
   validateRuleStrokeWidth
 } from "../../grammar/ruleAppearance.js";
 import { findLayer } from "../../selectors/layers.js";
-import { findSemanticScale } from "../../selectors/scales.js";
 import { resolveIntervalComposite } from "../intervals/resolve.js";
 import {
-  resolveDistributionScalePlan,
   setCartesianPosition,
   updateDistributionPositions
 } from "../distributions/revision.js";
@@ -31,17 +29,21 @@ import {
   releaseIntervalRevision,
   resolveIntervalOwner
 } from "../data/intervalEdit.js";
+import {
+  requestedStrokeDetails,
+  STROKE_STYLE_PROPERTIES
+} from "../../grammar/strokeStyle.js";
 
 export const ERROR_BAR_EDIT_OPTIONS = Object.freeze([
   "target", "data", "x", "y", "xOffset", "yOffset", "groupBy",
   "caps", "capSize", "stroke", "strokeWidth", "strokeDash", "opacity",
-  "statistics"
+  "statistics", ...STROKE_STYLE_PROPERTIES
 ]);
 
 export const ERROR_BAR_APPEARANCE_OPTIONS = Object.freeze([
-  "caps", "capSize", "stroke", "strokeWidth", "strokeDash", "opacity"
+  "caps", "capSize", "stroke", "strokeWidth", "strokeDash", "opacity",
+  ...STROKE_STYLE_PROPERTIES
 ]);
-const STATISTICS_OPTIONS = Object.freeze(["center", "extent", "method", "level"]);
 const EDIT_POLICY = Object.freeze({
   operation: "editErrorBar",
   resourceLabel: "error-bar",
@@ -81,7 +83,15 @@ export function resolveErrorBarAppearance(args, { defaults, operation }) {
     args.opacity ?? defaults.opacity,
     `${operation} opacity`
   );
-  return { caps, capSize, stroke, strokeWidth, strokeDash, opacity };
+  return {
+    caps,
+    capSize,
+    stroke,
+    strokeWidth,
+    strokeDash,
+    opacity,
+    ...requestedStrokeDetails({ ...defaults, ...args }, operation)
+  };
 }
 
 const REMATERIALIZE_OPTIONS = Object.freeze(["id"]);
@@ -102,45 +112,8 @@ function resolveOwner(program, requested) {
   });
 }
 
-function currentRoleArgs(program, owner, current) {
-  const transform = findIntervalTransform(program, current.data);
-  const intervalChannel = current.orientation === "vertical" ? "y" : "x";
-  const positionChannel = intervalChannel === "x" ? "y" : "x";
-  const position = {
-    field: current.positionField,
-    fieldType: current.positionFieldType,
-    ...(current.positionTemporalUnit === undefined
-      ? {}
-      : { temporalUnit: current.positionTemporalUnit }),
-    scale: { id: current.positionScale }
-  };
-  const interval = transform === undefined
-    ? {
-        center: current.centerField ?? owner.encoding[intervalChannel].title,
-        lower: current.lowerField,
-        upper: current.upperField,
-        scale: { id: current.intervalScale }
-      }
-    : {
-        field: transform.field,
-        center: transform.center,
-        extent: transform.extent,
-        ...(transform.method === undefined ? {} : { method: transform.method }),
-        ...(transform.level === undefined ? {} : { level: transform.level }),
-        scale: { id: current.intervalScale }
-      };
-  return {
-    source: current.source ?? transform?.source ?? current.data,
-    x: positionChannel === "x" ? position : interval,
-    y: positionChannel === "y" ? position : interval,
-    groupBy: current.groupField ?? transform?.groupBy?.find(
-      field => field !== current.positionField
-    )
-  };
-}
-
 function resolveRoleCandidate(program, owner, current, args) {
-  const previous = currentRoleArgs(program, owner, current);
+  const previous = currentIntervalRoleArgs(program, owner, current, true);
   const full = {
     data: Object.hasOwn(args, "data") ? args.data : previous.source,
     x: Object.hasOwn(args, "x") ? args.x : previous.x,
@@ -157,65 +130,8 @@ function resolveRoleCandidate(program, owner, current, args) {
     generatedFields: findIntervalTransform(program, current.data)?.as
   };
   let resolved = resolveIntervalComposite(program, full, policy);
-  if (Object.hasOwn(args, "statistics")) {
-    if (!isPlainObject(args.statistics)) {
-      throw new TypeError("editErrorBar statistics must be a plain object.");
-    }
-    validateKeys(args.statistics, STATISTICS_OPTIONS, "editErrorBar statistics");
-    if (!STATISTICS_OPTIONS.some(key => Object.hasOwn(args.statistics, key))) {
-      throw new Error(
-        "editErrorBar statistics requires center, extent, method, or level."
-      );
-    }
-    full[resolved.interval.channel] = {
-      ...full[resolved.interval.channel],
-      ...args.statistics
-    };
-    resolved = resolveIntervalComposite(program, full, policy);
-  }
-  const positionRole = {
-    field: resolved.position.field,
-    fieldType: resolved.position.fieldType,
-    scale: resolved.position.scale
-  };
-  const intervalTitle = resolved.interval.mode === "statistical"
-    ? resolved.interval.field
-    : resolved.interval.title;
-  const intervalRole = {
-    field: intervalTitle,
-    fieldType: "quantitative",
-    scale: resolved.interval.scale
-  };
-  const x = resolved.position.channel === "x" ? positionRole : intervalRole;
-  const y = resolved.position.channel === "y" ? positionRole : intervalRole;
-  const plan = (channel, role) => {
-    const fallback = role === intervalRole
-      ? current.intervalScale
-      : current.positionScale;
-    const stored = findSemanticScale(program, fallback);
-    const compatible = role.fieldType === "temporal"
-      ? stored?.type === "time"
-      : ["nominal", "ordinal"].includes(role.fieldType)
-        ? ["band", "point"].includes(stored?.type)
-        : ["linear", "log", "pow", "sqrt", "symlog"].includes(stored?.type);
-    const defaultType = role.fieldType === "temporal"
-      ? "time"
-      : ["nominal", "ordinal"].includes(role.fieldType) ? "band" : "linear";
-    const requested = role.scale.type !== undefined || compatible
-      ? role.scale
-      : { ...role.scale, type: defaultType };
-    return resolveDistributionScalePlan(program, {
-      channel,
-      fieldType: role.fieldType,
-      requested,
-      fallback,
-      defaults: role === intervalRole
-        ? EDIT_POLICY.intervalScaleDefaults
-        : EDIT_POLICY.scaleDefaults(role.fieldType)
-    });
-  };
-  const xScale = plan("x", x);
-  const yScale = plan("y", y);
+  resolved = applyIntervalStatistics(program, full, policy, args, resolved);
+  const roles = resolveIntervalRoleScales(program, resolved, current, EDIT_POLICY, owner, previous);
   const expectedOffset = `${resolved.position.channel}Offset`;
   const incompatibleOffset = expectedOffset === "xOffset" ? "yOffset" : "xOffset";
   if (Object.hasOwn(args, incompatibleOffset)) {
@@ -257,19 +173,7 @@ function resolveRoleCandidate(program, owner, current, args) {
   return {
     ...resolved,
     offset: normalizedOffset,
-    x: { ...x, scale: xScale.id },
-    y: { ...y, scale: yScale.id },
-    xScale,
-    yScale,
-    category: resolved.position.field,
-    categoryType: resolved.position.fieldType,
-    measure: intervalTitle,
-    previous: {
-      x: { field: previous.x.center ?? previous.x.field,
-        fieldType: owner.encoding.x.fieldType, scale: owner.encoding.x.scale },
-      y: { field: previous.y.center ?? previous.y.field,
-        fieldType: owner.encoding.y.fieldType, scale: owner.encoding.y.scale }
-    }
+    ...roles
   };
 }
 
@@ -307,7 +211,8 @@ function capArgs(config, id, intervalField) {
     stroke: config.stroke,
     strokeWidth: config.strokeWidth,
     strokeDash: config.strokeDash,
-    opacity: config.opacity
+    opacity: config.opacity,
+    ...requestedStrokeDetails(config, "Error bar")
   };
 }
 
@@ -323,6 +228,7 @@ function rematerializeRuleAppearance(program, id, config, fixedSpan) {
       strokeWidth: config.strokeWidth,
       strokeDash: config.strokeDash,
       opacity: config.opacity,
+      ...requestedStrokeDetails(config, "Error bar"),
       ...(fixedSpan === undefined ? {} : { fixedSpan })
     })
     .rematerializeRuleMark({ id });
@@ -445,13 +351,12 @@ function updateErrorBarRoles(program, owner, current, candidate, dataId, capIds)
   return next.rematerializeErrorBar({ id: owner.id });
 }
 
-export const rematerializeErrorBar = action(
+export const rematerializeErrorBar = /* @__PURE__ */ closedAction(
   {
     op: "rematerializeErrorBar",
     description: "Reconcile one error bar and its owned caps."
-  },
+  }, REMATERIALIZE_OPTIONS,
   function (args = {}) {
-    validateKeys(args, REMATERIALIZE_OPTIONS, "rematerializeErrorBar");
     const id = validateUserId(args.id, "Error-bar id");
     const layer = findLayer(this, id);
     const config = this.markConfigs[id]?.errorBar;
@@ -479,13 +384,12 @@ export const rematerializeErrorBar = action(
   }
 );
 
-export const editErrorBar = action(
+export const editErrorBar = /* @__PURE__ */ closedAction(
   {
     op: "editErrorBar",
     description: "Revise one error bar's roles, statistics, and owned caps."
-  },
+  }, ERROR_BAR_EDIT_OPTIONS,
   function (args = {}) {
-    validateKeys(args, ERROR_BAR_EDIT_OPTIONS, "editErrorBar");
     const editable = ERROR_BAR_EDIT_OPTIONS.filter(option => option !== "target");
     if (!editable.some(option => Object.hasOwn(args, option))) {
       throw new Error("editErrorBar requires at least one change.");