ggaction 0.0.2 → 0.0.4

package/src/actions/encodings/text.js

@@ -0,0 +1,73 @@
+import { action } from "../../core/action.js";
+import { formatTextValue, validateTextFormat } from "../../grammar/text.js";
+import { canMaterializeText } from "../../materialization/marks/index.js";
+import { findLayer } from "../../selectors/layers.js";
+import { resolveTarget, validateOptions } from "./shared.js";
+
+const OPTIONS = Object.freeze(["target", "field", "value", "format"]);
+
+function validateTextField(rows, field, format) {
+  if (typeof field !== "string" || field.length === 0) {
+    throw new TypeError("encodeText field must be a non-empty string.");
+  }
+  let found = false;
+  for (const row of rows) {
+    if (!Object.hasOwn(row, field)) continue;
+    found = true;
+    formatTextValue(row[field], format);
+  }
+  if (!found) throw new Error(`Unknown text field "${field}".`);
+}
+
+export const encodeText = action(
+  {
+    op: "encodeText",
+    description: "Assign field-driven or constant text content."
+  },
+  function (args = {}) {
+    validateOptions(args, OPTIONS, "encodeText");
+    const hasField = Object.hasOwn(args, "field");
+    const hasValue = Object.hasOwn(args, "value");
+    if (hasField === hasValue) {
+      throw new Error("encodeText requires exactly one of field or value.");
+    }
+    const { id: target, dataset, layer } = resolveTarget(
+      this,
+      args.target,
+      ["text"],
+      "text mark"
+    );
+    const previous = layer.encoding?.text;
+    const format = validateTextFormat(args.format ?? previous?.format ?? "auto");
+    if (hasField) validateTextField(dataset.values, args.field, format);
+    else if (formatTextValue(args.value, format) === undefined) {
+      throw new Error("encodeText value must produce non-empty text.");
+    }
+
+    let next = this;
+    const alternate = hasField ? "datum" : "field";
+    if (Object.hasOwn(previous ?? {}, alternate)) {
+      next = next.editSemantic({
+        property: `layer[${target}].encoding.text.${alternate}`,
+        remove: true
+      });
+    }
+    next = next
+      .editSemantic({
+        property: `layer[${target}].encoding.text.${hasField ? "field" : "datum"}`,
+        value: hasField ? args.field : args.value
+      })
+      .editSemantic({
+        property: `layer[${target}].encoding.text.format`,
+        value: format
+      });
+    const updated = findLayer(next, target);
+    return canMaterializeText(next, updated)
+      ? next.rematerializeTextMark({ id: target })
+      : next;
+  }
+);
+
+export function registerTextEncodingAction(ProgramClass) {
+  ProgramClass.prototype.encodeText = encodeText;
+}

package/src/actions/errorBands/create.js

@@ -2,13 +2,10 @@ import { action } from "../../core/action.js";
 import { isPlainObject } from "../../core/immutable.js";
 import {
   validateKeys,
-  validateNonEmptyString,
-  validateNonNegativeFinite,
-  validateUnitInterval
 } from "../../core/validation.js";
 import { DEFAULT_COLORS } from "../../theme/defaults.js";
 import { validateCurveInterpolation } from "../../grammar/curveCommands.js";
-import { normalizeStrokeDashPattern } from "../../grammar/scales.js";
+import { resolveBoundaryAppearance } from "./options.js";
 import { resolveErrorBand } from "./resolve.js";
 
 const OPTIONS = Object.freeze([
@@ -24,35 +21,21 @@ const OPTIONS = Object.freeze([
   "curve",
   "boundaries"
 ]);
-const BOUNDARY_OPTIONS = Object.freeze([
-  "stroke", "strokeWidth", "strokeDash", "opacity", "curve"
-]);
-
 function resolveBoundaries(value, areaCurve) {
   if (value === undefined || value === false) return undefined;
   if (!isPlainObject(value)) {
     throw new TypeError("createErrorBand boundaries must be false or a plain object.");
   }
-  validateKeys(value, BOUNDARY_OPTIONS, "createErrorBand boundaries");
-  const stroke = value.stroke ?? DEFAULT_COLORS.mark;
-  const strokeWidth = value.strokeWidth ?? 1;
-  const strokeDash = value.strokeDash ?? "solid";
-  const opacity = value.opacity ?? 1;
-  const curve = validateCurveInterpolation(value.curve ?? areaCurve);
-  validateNonEmptyString(stroke, "Error-band boundary stroke");
-  validateNonNegativeFinite(
-    strokeWidth,
-    "Error-band boundary strokeWidth"
-  );
-  const resolvedStrokeDash = normalizeStrokeDashPattern(strokeDash);
-  validateUnitInterval(opacity, "Error-band boundary opacity");
-  return {
-    stroke,
-    strokeWidth,
-    strokeDash: resolvedStrokeDash,
-    opacity,
-    curve
-  };
+  return resolveBoundaryAppearance(value, {
+    defaults: {
+      stroke: DEFAULT_COLORS.mark,
+      strokeWidth: 1,
+      strokeDash: "solid",
+      opacity: 1,
+      curve: areaCurve
+    },
+    operation: "createErrorBand boundaries"
+  });
 }
 
 function positionArgs(resolved) {
@@ -153,7 +136,32 @@ export const createErrorBand = action(
           id: `${resolved.id}UpperBoundary`,
           bound: resolved.fields.upper
         });
+      for (const [id, bound] of [
+        [`${resolved.id}LowerBoundary`, "lower"],
+        [`${resolved.id}UpperBoundary`, "upper"]
+      ]) {
+        next = next._withMarkConfig(id, {
+          ...next.markConfigs[id],
+          ...boundaries,
+          errorBandBoundary: { owner: resolved.id, bound }
+        });
+      }
     }
-    return next;
+    return next._withMarkConfig(resolved.id, {
+      ...next.markConfigs[resolved.id],
+      errorBand: {
+        data: resolved.dataId,
+        orientation: resolved.orientation,
+        position: resolved.position,
+        coordinate: resolved.coordinate,
+        intervalScale: resolved.interval.scale.id ?? resolved.interval.channel,
+        positionScale: resolved.position.scale.id ?? resolved.position.channel,
+        groupBy: resolved.groupField,
+        lowerField: resolved.fields.lower,
+        upperField: resolved.fields.upper,
+        lowerBoundaryId: `${resolved.id}LowerBoundary`,
+        upperBoundaryId: `${resolved.id}UpperBoundary`
+      }
+    });
   }
 );

package/src/actions/errorBands/edit.js

@@ -0,0 +1,206 @@
+import { action } from "../../core/action.js";
+import { validateUserId } from "../../core/identifiers.js";
+import {
+  validateOptionObject,
+  validateNonEmptyString,
+  validateUnitInterval
+} from "../../core/validation.js";
+import { validateCurveInterpolation } from "../../grammar/curveCommands.js";
+import { findLayer, resolveEligibleLayer } from "../../selectors/layers.js";
+import { DEFAULT_COLORS } from "../../theme/defaults.js";
+import {
+  ERROR_BAND_BOUNDARY_OPTIONS,
+  resolveBoundaryAppearance
+} from "./options.js";
+
+const EDIT_OPTIONS = Object.freeze(["target", "fill", "opacity", "curve"]);
+const BOUNDARY_EDIT_OPTIONS = Object.freeze([
+  "target", "boundary", ...ERROR_BAND_BOUNDARY_OPTIONS
+]);
+const REMATERIALIZE_OPTIONS = Object.freeze([
+  "id", ...ERROR_BAND_BOUNDARY_OPTIONS
+]);
+
+function resolveOwner(program, requested) {
+  const target = requested === undefined
+    ? undefined
+    : validateUserId(requested, "Error-band id");
+  return resolveEligibleLayer(program, {
+    target,
+    label: "error band",
+    predicate: layer =>
+      layer.mark?.type === "area" &&
+      program.markConfigs[layer.id]?.errorBand !== undefined
+  });
+}
+
+function currentBoundaryAppearance(program, id) {
+  const config = program.markConfigs[id];
+  if (findLayer(program, id)?.mark?.type !== "line" || config === undefined) {
+    throw new Error(`Unknown error-band boundary "${id}".`);
+  }
+  return {
+    stroke: config.stroke,
+    strokeWidth: config.strokeWidth,
+    strokeDash: config.strokeDash,
+    opacity: config.opacity,
+    curve: config.curve ?? "linear"
+  };
+}
+
+function defaultBoundaryAppearance(program, owner) {
+  return {
+    stroke: DEFAULT_COLORS.mark,
+    strokeWidth: 1,
+    strokeDash: "solid",
+    opacity: 1,
+    curve: program.markConfigs[owner]?.curve ?? "linear"
+  };
+}
+
+function createBoundary(program, owner, id, bound, appearance) {
+  const config = program.markConfigs[owner].errorBand;
+  const next = program.createErrorBandBoundary({
+    id,
+    data: config.data,
+    orientation: config.orientation,
+    bound,
+    position: config.position,
+    coordinate: config.coordinate,
+    intervalScale: config.intervalScale,
+    positionScale: config.positionScale,
+    groupBy: config.groupBy,
+    ...appearance
+  });
+  return next._withMarkConfig(id, {
+    ...next.markConfigs[id],
+    ...appearance,
+    errorBandBoundary: {
+      owner,
+      bound: id === config.lowerBoundaryId ? "lower" : "upper"
+    }
+  });
+}
+
+export const rematerializeErrorBandBoundary = action(
+  {
+    op: "rematerializeErrorBandBoundary",
+    description: "Rematerialize one owned error-band boundary."
+  },
+  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];
+    const next = this
+      ._withMarkConfig(id, {
+        ...this.markConfigs[id],
+        stroke: args.stroke,
+        strokeWidth: args.strokeWidth,
+        strokeDash: args.strokeDash,
+        opacity: args.opacity,
+        curve: args.curve
+      })
+      .editGraphics({
+        target: id,
+        property: "strokeDash",
+        value: graphic.items.map(() => args.strokeDash)
+      });
+    return next.rematerializeLineMark({ id });
+  }
+);
+
+export const editErrorBand = action(
+  {
+    op: "editErrorBand",
+    description: "Edit one error-band body appearance."
+  },
+  function (args = {}) {
+    validateOptionObject(args, EDIT_OPTIONS, "editErrorBand");
+    if (!["fill", "opacity", "curve"].some(key => Object.hasOwn(args, key))) {
+      throw new Error("editErrorBand requires fill, opacity, or curve.");
+    }
+    const owner = resolveOwner(this, args.target);
+    const config = { ...this.markConfigs[owner.id] };
+    const errorBand = { ...config.errorBand };
+    if (Object.hasOwn(args, "fill")) {
+      errorBand.fill = validateNonEmptyString(args.fill, "Error-band fill");
+    }
+    if (Object.hasOwn(args, "opacity")) {
+      config.opacity = validateUnitInterval(args.opacity, "Error-band opacity");
+    }
+    if (Object.hasOwn(args, "curve")) {
+      config.curve = validateCurveInterpolation(args.curve);
+    }
+    return this
+      ._withMarkConfig(owner.id, { ...config, errorBand })
+      .rematerializeAreaMark({ id: owner.id });
+  }
+);
+
+export const editErrorBandBoundary = action(
+  {
+    op: "editErrorBandBoundary",
+    description: "Edit one or both owned error-band boundaries."
+  },
+  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.");
+    }
+    const boundary = args.boundary ?? "both";
+    if (!["both", "lower", "upper"].includes(boundary)) {
+      throw new Error(`Unsupported error-band boundary "${boundary}".`);
+    }
+    const owner = resolveOwner(this, args.target);
+    const config = this.markConfigs[owner.id].errorBand;
+    const patch = Object.fromEntries(
+      ERROR_BAND_BOUNDARY_OPTIONS
+        .filter(key => Object.hasOwn(args, key))
+        .map(key => [key, args[key]])
+    );
+    const ids = boundary === "both"
+      ? [config.lowerBoundaryId, config.upperBoundaryId]
+      : [boundary === "lower" ? config.lowerBoundaryId : config.upperBoundaryId];
+    const plans = ids.map(id => {
+      const existing = findLayer(this, id) !== undefined;
+      return {
+        id,
+        existing,
+        bound: id === config.lowerBoundaryId
+          ? config.lowerField
+          : config.upperField,
+        appearance: resolveBoundaryAppearance(patch, {
+          defaults: existing
+            ? currentBoundaryAppearance(this, id)
+            : defaultBoundaryAppearance(this, owner.id),
+          operation: "editErrorBandBoundary"
+        })
+      };
+    });
+    let next = this;
+    for (const plan of plans) {
+      next = plan.existing
+        ? next.rematerializeErrorBandBoundary({
+            id: plan.id,
+            ...plan.appearance
+          })
+        : createBoundary(
+            next,
+            owner.id,
+            plan.id,
+            plan.bound,
+            plan.appearance
+          );
+    }
+    return next;
+  }
+);

package/src/actions/errorBands/index.js

@@ -1,7 +1,16 @@
 import { createErrorBand } from "./create.js";
 import { createErrorBandBoundary } from "./components.js";
+import {
+  editErrorBand,
+  editErrorBandBoundary,
+  rematerializeErrorBandBoundary
+} from "./edit.js";
 
 export function registerErrorBandActions(ProgramClass) {
   ProgramClass.prototype.createErrorBand = createErrorBand;
   ProgramClass.prototype.createErrorBandBoundary = createErrorBandBoundary;
+  ProgramClass.prototype.editErrorBand = editErrorBand;
+  ProgramClass.prototype.editErrorBandBoundary = editErrorBandBoundary;
+  ProgramClass.prototype.rematerializeErrorBandBoundary =
+    rematerializeErrorBandBoundary;
 }

package/src/actions/errorBands/options.js

@@ -0,0 +1,39 @@
+import { isPlainObject } from "../../core/immutable.js";
+import {
+  validateKeys,
+  validateNonEmptyString,
+  validateNonNegativeFinite,
+  validateUnitInterval
+} from "../../core/validation.js";
+import { validateCurveInterpolation } from "../../grammar/curveCommands.js";
+import { normalizeStrokeDashPattern } from "../../grammar/scales/index.js";
+
+export const ERROR_BAND_BOUNDARY_OPTIONS = Object.freeze([
+  "stroke", "strokeWidth", "strokeDash", "opacity", "curve"
+]);
+
+export function resolveBoundaryAppearance(value, {
+  defaults,
+  operation
+}) {
+  if (!isPlainObject(value)) {
+    throw new TypeError(`${operation} must be a plain object.`);
+  }
+  validateKeys(value, ERROR_BAND_BOUNDARY_OPTIONS, operation);
+  const stroke = value.stroke ?? defaults.stroke;
+  const strokeWidth = value.strokeWidth ?? defaults.strokeWidth;
+  const strokeDash = value.strokeDash ?? defaults.strokeDash;
+  const opacity = value.opacity ?? defaults.opacity;
+  const curve = validateCurveInterpolation(value.curve ?? defaults.curve);
+  validateNonEmptyString(stroke, `${operation} stroke`);
+  validateNonNegativeFinite(strokeWidth, `${operation} strokeWidth`);
+  const resolvedStrokeDash = normalizeStrokeDashPattern(strokeDash);
+  validateUnitInterval(opacity, `${operation} opacity`);
+  return {
+    stroke,
+    strokeWidth,
+    strokeDash: resolvedStrokeDash,
+    opacity,
+    curve
+  };
+}

package/src/actions/errorBars/create.js

@@ -1,15 +1,8 @@
 import { action } from "../../core/action.js";
-import { validateKeys, validatePositiveFinite } from "../../core/validation.js";
-import {
-  normalizeStrokeDashPattern,
-  validateOpacityValue
-} from "../../grammar/scales.js";
-import {
-  validateRuleStroke,
-  validateRuleStrokeWidth
-} from "../../grammar/ruleAppearance.js";
+import { validateKeys } from "../../core/validation.js";
 import { findLayer } from "../../selectors/layers.js";
 import { DEFAULT_COLORS } from "../../theme/defaults.js";
+import { resolveErrorBarAppearance } from "./options.js";
 import { resolveErrorBar } from "./resolve.js";
 
 const OPTIONS = Object.freeze([
@@ -29,24 +22,22 @@ const OPTIONS = Object.freeze([
 ]);
 
 function resolveAppearance(args) {
-  const caps = args.caps ?? true;
-  if (typeof caps !== "boolean") {
-    throw new TypeError("createErrorBar caps must be a boolean.");
-  }
-  const capSize = args.capSize ?? 8;
-  validatePositiveFinite(capSize, "createErrorBar capSize");
-  const stroke = validateRuleStroke(
-    args.stroke ?? DEFAULT_COLORS.mark,
-    "createErrorBar stroke"
-  );
-  const strokeWidth = validateRuleStrokeWidth(
-    args.strokeWidth ?? 1.5,
-    "createErrorBar strokeWidth"
+  const appearanceArgs = Object.fromEntries(
+    ["caps", "capSize", "stroke", "strokeWidth", "strokeDash", "opacity"]
+      .filter(key => Object.hasOwn(args, key))
+      .map(key => [key, args[key]])
   );
-  const strokeDash = args.strokeDash ?? "solid";
-  normalizeStrokeDashPattern(strokeDash);
-  const opacity = validateOpacityValue(args.opacity ?? 1, "createErrorBar opacity");
-  return { caps, capSize, stroke, strokeWidth, strokeDash, opacity };
+  return resolveErrorBarAppearance(appearanceArgs, {
+    defaults: {
+      caps: true,
+      capSize: 8,
+      stroke: DEFAULT_COLORS.mark,
+      strokeWidth: 1.5,
+      strokeDash: "solid",
+      opacity: 1
+    },
+    operation: "createErrorBar"
+  });
 }
 
 function positionArgs(resolved) {
@@ -115,30 +106,46 @@ export const createErrorBar = action(
       .encodeStrokeDash({ target: resolved.id, value: appearance.strokeDash })
       .encodeOpacity({ target: resolved.id, value: appearance.opacity });
 
-    if (!appearance.caps) return next;
-
     const intervalLayer = findLayer(next, resolved.id);
-    for (const [id, field] of [
-      [resolved.lowerCapId, resolved.fields.lower],
-      [resolved.upperCapId, resolved.fields.upper]
-    ]) {
-      next = next.createErrorBarCap({
-        id,
+    if (appearance.caps) {
+      for (const [id, field] of [
+        [resolved.lowerCapId, resolved.fields.lower],
+        [resolved.upperCapId, resolved.fields.upper]
+      ]) {
+        next = next.createErrorBarCap({
+          id,
+          data: resolved.dataId,
+          orientation: resolved.orientation,
+          positionField: resolved.position.field,
+          positionFieldType: resolved.position.fieldType,
+          intervalField: field,
+          coordinate: resolved.coordinate,
+          positionScale: intervalLayer.encoding[resolved.position.channel].scale,
+          intervalScale: intervalLayer.encoding[resolved.interval.channel].scale,
+          capSize: appearance.capSize,
+          stroke: appearance.stroke,
+          strokeWidth: appearance.strokeWidth,
+          strokeDash: appearance.strokeDash,
+          opacity: appearance.opacity
+        });
+      }
+    }
+    return next._withMarkConfig(resolved.id, {
+      ...next.markConfigs[resolved.id],
+      errorBar: {
         data: resolved.dataId,
         orientation: resolved.orientation,
         positionField: resolved.position.field,
         positionFieldType: resolved.position.fieldType,
-        intervalField: field,
+        lowerField: resolved.fields.lower,
+        upperField: resolved.fields.upper,
         coordinate: resolved.coordinate,
         positionScale: intervalLayer.encoding[resolved.position.channel].scale,
         intervalScale: intervalLayer.encoding[resolved.interval.channel].scale,
-        capSize: appearance.capSize,
-        stroke: appearance.stroke,
-        strokeWidth: appearance.strokeWidth,
-        strokeDash: appearance.strokeDash,
-        opacity: appearance.opacity
-      });
-    }
-    return next;
+        lowerCapId: resolved.lowerCapId,
+        upperCapId: resolved.upperCapId,
+        ...appearance
+      }
+    });
   }
 );

package/src/actions/errorBars/edit.js

@@ -0,0 +1,130 @@
+import { action } from "../../core/action.js";
+import { validateUserId } from "../../core/identifiers.js";
+import { validateKeys } from "../../core/validation.js";
+import { findLayer, resolveEligibleLayer } from "../../selectors/layers.js";
+import {
+  ERROR_BAR_EDIT_OPTIONS,
+  resolveErrorBarAppearance
+} from "./options.js";
+
+const REMATERIALIZE_OPTIONS = Object.freeze(["id"]);
+
+function resolveOwner(program, requested) {
+  const target = requested === undefined
+    ? undefined
+    : validateUserId(requested, "Error-bar id");
+  return resolveEligibleLayer(program, {
+    target,
+    label: "error bar",
+    predicate: layer =>
+      layer.mark?.type === "rule" &&
+      program.markConfigs[layer.id]?.errorBar !== undefined
+  });
+}
+
+function removeCap(program, id) {
+  if (findLayer(program, id) === undefined) return program;
+  return program
+    .editSemantic({ property: `layer[${id}]`, remove: true })
+    .editGraphics({ target: id, remove: true })
+    ._withoutMaterializationConfig(["marks", id]);
+}
+
+function capArgs(config, id, intervalField) {
+  return {
+    id,
+    data: config.data,
+    orientation: config.orientation,
+    positionField: config.positionField,
+    positionFieldType: config.positionFieldType,
+    intervalField,
+    coordinate: config.coordinate,
+    positionScale: config.positionScale,
+    intervalScale: config.intervalScale,
+    capSize: config.capSize,
+    stroke: config.stroke,
+    strokeWidth: config.strokeWidth,
+    strokeDash: config.strokeDash,
+    opacity: config.opacity
+  };
+}
+
+function rematerializeRuleAppearance(program, id, config, fixedSpan) {
+  return program
+    .editSemantic({
+      property: `layer[${id}].encoding.strokeDash.datum`,
+      value: config.strokeDash
+    })
+    ._withMarkConfig(id, {
+      ...program.markConfigs[id],
+      stroke: config.stroke,
+      strokeWidth: config.strokeWidth,
+      strokeDash: config.strokeDash,
+      opacity: config.opacity,
+      ...(fixedSpan === undefined ? {} : { fixedSpan })
+    })
+    .rematerializeRuleMark({ id });
+}
+
+export const rematerializeErrorBar = action(
+  {
+    op: "rematerializeErrorBar",
+    description: "Reconcile one error bar and its owned caps."
+  },
+  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;
+    if (layer?.mark?.type !== "rule" || config === undefined) {
+      throw new Error(`Unknown error bar "${id}".`);
+    }
+    let next = rematerializeRuleAppearance(this, id, config);
+    const capDefinitions = [
+      [config.lowerCapId, config.lowerField],
+      [config.upperCapId, config.upperField]
+    ];
+    if (!config.caps) {
+      for (const [capId] of capDefinitions) next = removeCap(next, capId);
+      return next;
+    }
+    const span = {
+      orientation: config.orientation === "vertical" ? "horizontal" : "vertical",
+      size: config.capSize
+    };
+    for (const [capId, field] of capDefinitions) {
+      if (findLayer(next, capId) === undefined) {
+        next = next.createErrorBarCap(capArgs(config, capId, field));
+      } else {
+        next = rematerializeRuleAppearance(next, capId, config, span);
+      }
+    }
+    return next;
+  }
+);
+
+export const editErrorBar = action(
+  {
+    op: "editErrorBar",
+    description: "Edit one error bar and its owned cap appearance."
+  },
+  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 appearance change.");
+    }
+    const owner = resolveOwner(this, args.target);
+    const current = this.markConfigs[owner.id].errorBar;
+    const appearance = resolveErrorBarAppearance(args, {
+      defaults: current,
+      operation: "editErrorBar"
+    });
+    return this
+      ._withMarkConfig(owner.id, {
+        ...this.markConfigs[owner.id],
+        errorBar: { ...current, ...appearance }
+      })
+      .rematerializeErrorBar({ id: owner.id });
+  }
+);