ggaction 0.0.13 → 0.0.16

package/src/actions/intervals/revision.js

@@ -0,0 +1,126 @@
+import { findSemanticScale } from "../../selectors/scales.js";
+import {
+  findIntervalTransform,
+  mergeIntervalStatistics,
+  validateIntervalStatistics
+} from "../data/intervalEdit.js";
+import { resolveDistributionScalePlan } from "../distributions/revision.js";
+import { resolveIntervalComposite } from "./resolve.js";
+
+export function currentIntervalRoleArgs(program, owner, current, bar) {
+  const transform = findIntervalTransform(program, current.data);
+  const intervalChannel = current.orientation === "vertical" ? "y" : "x";
+  const positionChannel = intervalChannel === "x" ? "y" : "x";
+  const storedPosition = bar
+    ? {
+        field: current.positionField,
+        fieldType: current.positionFieldType,
+        temporalUnit: current.positionTemporalUnit
+      }
+    : current.position;
+  const position = {
+    field: storedPosition.field,
+    fieldType: storedPosition.fieldType,
+    ...(storedPosition.temporalUnit === undefined
+      ? {}
+      : { temporalUnit: storedPosition.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: bar ? current.groupField ?? transform?.groupBy?.find(
+      field => field !== current.positionField
+    ) : current.groupBy
+  };
+}
+
+export function resolveIntervalRoleScales(program, resolved, current, policy, owner, previous) {
+  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
+        ? policy.intervalScaleDefaults
+        : policy.scaleDefaults(role.fieldType)
+    });
+  };
+  const xScale = plan("x", x);
+  const yScale = plan("y", y);
+  return {
+    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 }
+    }
+  };
+}
+
+export function applyIntervalStatistics(program, full, policy, args, resolved) {
+  if (Object.hasOwn(args, "statistics")) {
+    validateIntervalStatistics(args.statistics, policy.operation);
+    const { method, level, ...interval } = full[resolved.interval.channel];
+    full[resolved.interval.channel] = {
+      ...interval,
+      ...mergeIntervalStatistics(resolved.interval, args.statistics)
+    };
+    resolved = resolveIntervalComposite(program, full, policy);
+  }
+  return resolved;
+}

package/src/actions/marks/arc/actions.js

@@ -7,9 +7,12 @@ import {
 } from "../../../core/validation.js";
 import { deriveArcSectors } from "../../../grammar/arcs.js";
 import { buildAnnularSectorCommands } from "../../../grammar/polarPaths.js";
-import { resolvePolarFrame } from "../../../grammar/polar.js";
-import { mapOrdinalValues } from "../../../grammar/scales/index.js";
-import { resolveGraphicBounds } from "../../../layout/canvas.js";
+import {
+  mapOrdinalValues,
+  readScaleField
+} from "../../../grammar/scales/index.js";
+import { resolveCoordinatePolarFrame } from
+  "../../../materialization/coordinateBounds.js";
 import {
   canMaterializeArc,
   getSourceDependentMarkSteps
@@ -19,7 +22,10 @@ import { findLayer, resolveEligibleLayer } from "../../../selectors/layers.js";
 import { DEFAULT_COLORS } from "../../../theme/defaults.js";
 import { resolveMarkGraphicPlacement } from
   "../../../materialization/graphicHierarchy.js";
+import { rematerializeExistingLegend } from "../../encodings/shared.js";
 import { rematerializeHighlightBaseline } from "../lifecycle.js";
+import { mapScaleConsumerValues } from
+  "../../../materialization/scales/map.js";
 import {
   assertMarkAvailable,
   applyLayeredMarkInheritance,
@@ -30,13 +36,18 @@ import {
   resolveMarkId,
   validateMarkOptions
 } from "../shared.js";
+import {
+  requestedStrokeDetails,
+  STROKE_STYLE_PROPERTIES
+} from "../../../grammar/strokeStyle.js";
 
 const ARC_OPTIONS = Object.freeze([
-  "innerRadius", "padAngle", "fill", "opacity", "stroke", "strokeWidth"
+  "innerRadius", "padAngle", "fill", "opacity", "stroke", "strokeWidth",
+  ...STROKE_STYLE_PROPERTIES
 ]);
 const CREATE_OPTIONS = Object.freeze(["id", "data", ...ARC_OPTIONS]);
 const EDIT_OPTIONS = Object.freeze(["target", ...ARC_OPTIONS]);
-const REMATERIALIZE_OPTIONS = Object.freeze(["id"]);
+const REMATERIALIZE_OPTIONS = Object.freeze(["id", "scales"]);
 
 function validateInnerRadius(value) {
   if (!Number.isFinite(value) || value < 0 || value >= 1) {
@@ -47,9 +58,14 @@ function validateInnerRadius(value) {
   return value;
 }
 
-function normalizeConfig(args, previous = {}, { allowStrokeRemoval = false } = {}) {
+function normalizeConfig(
+  args,
+  previous = {},
+  { allowStrokeRemoval = false, strokeDetails = {} } = {}
+) {
   let config = {
     ...previous,
+    ...strokeDetails,
     ...(Object.hasOwn(args, "innerRadius")
       ? { innerRadius: validateInnerRadius(args.innerRadius), innerRadiusExplicit: true }
       : {}),
@@ -86,13 +102,14 @@ function normalizeConfig(args, previous = {}, { allowStrokeRemoval = false } = {
   return config;
 }
 
-const createArcMark = action(
+const createArcMark = /* @__PURE__ */ action(
   {
     op: "createArcMark",
     description: "Create a semantic arc mark and empty path collection."
   },
   function (args = {}) {
     validateMarkOptions(args, CREATE_OPTIONS, "createArcMark");
+    const strokeDetails = requestedStrokeDetails(args, "createArcMark");
     const id = resolveMarkId(this, args.id, {
       defaultId: "arc",
       label: "Arc mark id",
@@ -112,7 +129,7 @@ const createArcMark = action(
       opacity: 1,
       stroke: "#ffffff",
       strokeWidth: 1
-    });
+    }, { strokeDetails });
     let created = this
       .editSemantic({ property: `layer[${id}].mark.type`, value: "arc" })
       .editSemantic({ property: `layer[${id}].data`, value: data });
@@ -141,13 +158,16 @@ function requireArc(program, id) {
   return { layer, dataset };
 }
 
-const rematerializeArcMark = action(
+const rematerializeArcMark = /* @__PURE__ */ action(
   {
     op: "rematerializeArcMark",
     description: "Recompute concrete annular-sector paths."
   },
   function (args = {}) {
     validateMarkOptions(args, REMATERIALIZE_OPTIONS, "rematerializeArcMark");
+    if (args.scales !== undefined && typeof args.scales !== "boolean") {
+      throw new TypeError("rematerializeArcMark scales must be a boolean.");
+    }
     const id = validateUserId(args.id, "Arc mark id");
     const highlighted = rematerializeHighlightBaseline(this, {
       target: id,
@@ -163,15 +183,21 @@ const rematerializeArcMark = action(
     const thetaScaleId = layer.encoding.theta.scale;
     const radiusScaleId = layer.encoding?.radius?.scale;
     const colorScaleId = layer.encoding?.color?.scale;
-    let resolved = this.rematerializeScale({ id: thetaScaleId });
-    if (radiusScaleId !== undefined) {
+    const strokeScaleId = layer.encoding?.stroke?.scale;
+    let resolved = args.scales === false
+      ? this
+      : this.rematerializeScale({ id: thetaScaleId });
+    if (radiusScaleId !== undefined && args.scales !== false) {
       resolved = resolved.rematerializeScale({ id: radiusScaleId });
     }
-    if (colorScaleId !== undefined) {
+    if (colorScaleId !== undefined && args.scales !== false) {
       resolved = resolved.rematerializeScale({ id: colorScaleId });
     }
+    if (strokeScaleId !== undefined && args.scales !== false) {
+      resolved = resolved.rematerializeScale({ id: strokeScaleId });
+    }
     const config = resolved.markConfigs[id] ?? {};
-    const frame = resolvePolarFrame(resolveGraphicBounds(resolved));
+    const frame = resolveCoordinatePolarFrame(resolved, layer.coordinate);
     const derived = deriveArcSectors(dataset.values, layer, {
       thetaScale: resolved.resolvedScales[thetaScaleId],
       ...(radiusScaleId === undefined
@@ -195,25 +221,49 @@ const rematerializeArcMark = action(
           resolved.resolvedScales[colorScaleId].domain,
           resolved.resolvedScales[colorScaleId].range
         );
+    const strokeEncoding = layer.encoding?.stroke;
+    const strokeValues = strokeEncoding === undefined ? undefined : derived.sectors.map(
+      sector => {
+        const values = readScaleField(
+          sector.sourceIndices.map(index => dataset.values[index]),
+          strokeEncoding.field,
+          strokeEncoding.fieldType,
+          { temporalUnit: strokeEncoding.temporalUnit }
+        );
+        if (new Set(values).size !== 1) {
+          throw new Error("Arc stroke requires one value within each sector.");
+        }
+        return values[0];
+      }
+    );
+    const strokes = strokeValues === undefined ? undefined : mapScaleConsumerValues(
+      strokeValues,
+      resolved.resolvedScales[strokeScaleId],
+      "stroke"
+    );
     return editMarkGraphic(resolved, id, {
       length: commands.length,
       commands,
       fill: fills,
       opacity: config.opacity ?? 1,
-      stroke: config.stroke === false ? "transparent" : config.stroke ?? "#ffffff",
+      stroke: strokes ?? (
+        config.stroke === false ? "transparent" : config.stroke ?? "#ffffff"
+      ),
       strokeWidth: config.stroke === false ? 0 : config.strokeWidth ?? 1,
-      strokeDash: commands.map(() => [])
+      strokeDash: commands.map(() => []),
+      ...requestedStrokeDetails(config, "Arc mark")
     });
   }
 );
 
-const editArcMark = action(
+const editArcMark = /* @__PURE__ */ action(
   {
     op: "editArcMark",
     description: "Edit arc geometry and appearance."
   },
   function (args = {}) {
     validateMarkOptions(args, EDIT_OPTIONS, "editArcMark");
+    const strokeDetails = requestedStrokeDetails(args, "editArcMark");
     if (Object.keys(args).every(key => key === "target")) {
       throw new Error(
         "editArcMark requires innerRadius, padAngle, fill, opacity, stroke, or strokeWidth."
@@ -230,6 +280,11 @@ const editArcMark = action(
     if (Object.hasOwn(args, "fill") && layer.encoding?.color !== undefined) {
       throw new Error("editArcMark fill cannot be combined with a color encoding.");
     }
+    if (Object.hasOwn(args, "stroke") && layer.encoding?.stroke !== undefined) {
+      throw new Error(
+        "editArcMark stroke conflicts with a field encoding; use encodeStroke with value to replace it."
+      );
+    }
     if (args.stroke === false && Object.hasOwn(args, "strokeWidth")) {
       throw new Error(
         "editArcMark cannot set strokeWidth while removing stroke."
@@ -245,15 +300,18 @@ const editArcMark = action(
     const next = this._withMarkConfig(
       layer.id,
       normalizeConfig(args, this.markConfigs[layer.id], {
-        allowStrokeRemoval: true
+        allowStrokeRemoval: true,
+        strokeDetails
       })
     );
-    if (!canMaterializeArc(next, layer)) return next;
-    let rematerialized = next.rematerializeArcMark({ id: layer.id });
-    for (const step of getSourceDependentMarkSteps(rematerialized, layer.id)) {
-      rematerialized = rematerialized[step.op](step.args);
+    let materialized = next;
+    if (canMaterializeArc(next, layer)) {
+      materialized = next.rematerializeArcMark({ id: layer.id });
+      for (const step of getSourceDependentMarkSteps(materialized, layer.id)) {
+        materialized = materialized[step.op](step.args);
+      }
     }
-    return rematerialized;
+    return rematerializeExistingLegend(materialized);
   }
 );
 

package/src/actions/marks/area/actions.js

@@ -22,14 +22,20 @@ import { findLayer } from "../../../selectors/layers.js";
 import { validateCurveInterpolation } from "../../../grammar/curveCommands.js";
 import { resolveEligibleLayer } from "../../../selectors/layers.js";
 import { canMaterializeArea } from "../../../materialization/marks/index.js";
+import { rematerializeExistingLegend } from "../../encodings/shared.js";
 import { findUpstreamTransform } from "../../../materialization/dataProvenance.js";
 import { resolveMarkGraphicPlacement } from
   "../../../materialization/graphicHierarchy.js";
 import { rematerializeHighlightBaseline } from "../lifecycle.js";
 import { resolveAreaMaterialization } from "./materialize.js";
+import {
+  requestedStrokeDetails,
+  STROKE_STYLE_PROPERTIES
+} from "../../../grammar/strokeStyle.js";
 
 const AREA_OPTIONS = Object.freeze([
-  "fill", "opacity", "stroke", "strokeWidth", "curve"
+  "fill", "opacity", "stroke", "strokeWidth", "curve",
+  ...STROKE_STYLE_PROPERTIES
 ]);
 const CREATE_OPTIONS = Object.freeze(["id", "data", "missing", ...AREA_OPTIONS]);
 const EDIT_OPTIONS = Object.freeze(["target", "missing", ...AREA_OPTIONS]);
@@ -51,13 +57,14 @@ export function validateAreaCreateOutline(args, operation = "createAreaMark") {
   };
 }
 
-const createAreaMark = action(
+const createAreaMark = /* @__PURE__ */ action(
   {
     op: "createAreaMark",
     description: "Create a semantic area mark and empty path collection."
   },
   function (args = {}) {
     validateMarkOptions(args, CREATE_OPTIONS, "createAreaMark");
+    const strokeDetails = requestedStrokeDetails(args, "createAreaMark");
     const id = resolveMarkId(this, args.id, {
       defaultId: "area",
       label: "Area mark id",
@@ -95,13 +102,14 @@ const createAreaMark = action(
         fill,
         opacity,
         ...(Object.hasOwn(args, "curve") ? { curve } : {}),
-        ...(stroke === undefined ? {} : { stroke, strokeWidth })
+        ...(stroke === undefined ? {} : { stroke, strokeWidth }),
+        ...strokeDetails
       });
     return materializeInheritedMark(created, id);
   }
 );
 
-const configureAreaStrokeFromFill = action(
+const configureAreaStrokeFromFill = /* @__PURE__ */ action(
   {
     op: "configureAreaStrokeFromFill",
     description: "Use each area path fill as its outline color."
@@ -130,7 +138,7 @@ const configureAreaStrokeFromFill = action(
   }
 );
 
-const rematerializeAreaMark = action(
+const rematerializeAreaMark = /* @__PURE__ */ action(
   {
     op: "rematerializeAreaMark",
     description: "Recompute grouped closed area paths."
@@ -179,6 +187,7 @@ const rematerializeAreaMark = action(
       );
     }
     const colorEncoding = layer.encoding?.color;
+    const strokeEncoding = layer.encoding?.stroke;
     let resolved = args.scales === false
       ? this
       : this
@@ -187,8 +196,11 @@ const rematerializeAreaMark = action(
     if (args.scales !== false && colorEncoding?.scale !== undefined) {
       resolved = resolved.rematerializeScale({ id: colorEncoding.scale });
     }
+    if (args.scales !== false && strokeEncoding?.scale !== undefined) {
+      resolved = resolved.rematerializeScale({ id: strokeEncoding.scale });
+    }
     const config = this.markConfigs[id];
-    const { paths, fills } = resolveAreaMaterialization({
+    const { paths, fills, strokes } = resolveAreaMaterialization({
       rows: dataset.values,
       layer,
       densityTransform,
@@ -196,7 +208,8 @@ const rematerializeAreaMark = action(
       config
     });
     const existingChildren = resolved.graphicSpec.objects[id].items ?? [];
-    const hasOutline = config.stroke !== undefined || config.strokeFromFill === true;
+    const hasOutline = strokes !== undefined || config.stroke !== undefined ||
+      config.strokeFromFill === true;
     const removesOutline = !hasOutline && existingChildren.some(
       child => child.properties.stroke !== undefined
     );
@@ -210,21 +223,26 @@ const rematerializeAreaMark = action(
       fill: fills,
       opacity: config.opacity,
       ...(hasOutline ? {
-        stroke: config.strokeFromFill === true ? fills : config.stroke,
-        strokeWidth: config.strokeWidth
-      } : {})
+        stroke: strokes ?? (config.strokeFromFill === true ? fills : config.stroke),
+        strokeWidth: config.strokeWidth ?? (strokes === undefined ? undefined : 1)
+      } : {}),
+      ...requestedStrokeDetails(config, "Area mark")
     });
   }
 );
 
-const editAreaMark = action(
+const editAreaMark = /* @__PURE__ */ action(
   {
     op: "editAreaMark",
     description: "Edit area curve and constant appearance."
   },
   function (args = {}) {
     validateMarkOptions(args, EDIT_OPTIONS, "editAreaMark");
-    const changes = ["fill", "opacity", "stroke", "strokeWidth", "curve", "missing"];
+    const strokeDetails = requestedStrokeDetails(args, "editAreaMark");
+    const changes = [
+      "fill", "opacity", "stroke", "strokeWidth", "curve", "missing",
+      ...STROKE_STYLE_PROPERTIES
+    ];
     if (!changes.some(key => Object.hasOwn(args, key))) {
       throw new Error(
         "editAreaMark requires fill, opacity, stroke, strokeWidth, or curve."
@@ -243,11 +261,17 @@ const editAreaMark = action(
         "editAreaMark fill cannot be combined with a color encoding."
       );
     }
+    if (Object.hasOwn(args, "stroke") && layer.encoding?.stroke !== undefined) {
+      throw new Error(
+        "editAreaMark stroke conflicts with a field encoding; use encodeStroke with value to replace it."
+      );
+    }
     if (args.stroke === false && Object.hasOwn(args, "strokeWidth")) {
       throw new Error("editAreaMark cannot set strokeWidth while removing stroke.");
     }
 
     let config = { ...this.markConfigs[layer.id] };
+    Object.assign(config, strokeDetails);
     if (Object.hasOwn(args, "fill")) {
       config.fill = validateNonEmptyString(args.fill, "Area fill");
       if (config.errorBand !== undefined) config.errorBand = { ...config.errorBand, fill: config.fill };
@@ -298,9 +322,10 @@ const editAreaMark = action(
       }
       next = next.editSemantic({ property: `layer[${layer.id}].mark.missing`, value: missing });
     }
-    return canMaterializeArea(next, layer)
+    const materialized = canMaterializeArea(next, layer)
       ? next.rematerializeAreaMark({ id: layer.id })
       : next;
+    return rematerializeExistingLegend(materialized);
   }
 );
 

package/src/actions/marks/area/materialize.js

@@ -8,6 +8,8 @@ import {
   mapContinuousScaleValues,
   mapOrdinalValues
 } from "../../../grammar/scales/index.js";
+import { mapScaleConsumerValues } from
+  "../../../materialization/scales/map.js";
 import { buildAreaCurvePathCommands } from
   "../../../grammar/curveCommands.js";
 import { buildLinearPathCommands } from
@@ -171,5 +173,19 @@ export function resolveAreaMaterialization({
           resolvedScales[colorEncoding.scale].domain,
           resolvedScales[colorEncoding.scale].range
         );
-  return { paths, fills };
+  const strokeEncoding = layer.encoding?.stroke;
+  const strokes = strokeEncoding?.scale === undefined
+    ? undefined
+    : mapScaleConsumerValues(
+        derivePathSeriesFieldValues(
+          rows,
+          derived.series,
+          strokeEncoding.field,
+          "stroke",
+          strokeEncoding
+        ),
+        resolvedScales[strokeEncoding.scale],
+        "stroke"
+      );
+  return { paths, fills, strokes };
 }

package/src/actions/marks/bar/create.js

@@ -10,18 +10,24 @@ import {
 } from "../shared.js";
 import { resolveMarkGraphicPlacement } from
   "../../../materialization/graphicHierarchy.js";
+import { requestedRectStyleDetails } from
+  "../../../grammar/roundedRect.js";
+import { STROKE_STYLE_PROPERTIES } from
+  "../../../grammar/strokeStyle.js";
 
 const CREATE_OPTIONS = Object.freeze([
-  "id", "data", "fill", "opacity", "stroke", "strokeWidth"
+  "id", "data", "fill", "opacity", "stroke", "strokeWidth",
+  "cornerRadius", ...STROKE_STYLE_PROPERTIES
 ]);
 
-export const createBarMark = action(
+export const createBarMark = /* @__PURE__ */ action(
   {
     op: "createBarMark",
     description: "Create a semantic bar mark and empty rect collection."
   },
   function (args = {}) {
     validateMarkOptions(args, CREATE_OPTIONS, "createBarMark");
+    requestedRectStyleDetails(args, "createBarMark");
     const id = resolveMarkId(this, args.id, {
       defaultId: "bar",
       label: "Bar mark id",
@@ -56,7 +62,10 @@ export const createBarMark = action(
       });
     created = materializeInheritedMark(created, id);
     const appearance = Object.fromEntries(
-      ["fill", "opacity", "stroke", "strokeWidth"]
+      [
+        "fill", "opacity", "stroke", "strokeWidth", "cornerRadius",
+        ...STROKE_STYLE_PROPERTIES
+      ]
         .filter(property => Object.hasOwn(args, property))
         .map(property => [property, args[property]])
     );

package/src/actions/marks/bar/edit.js

@@ -9,19 +9,29 @@ import { canMaterializeBar } from "../../../materialization/marks/index.js";
 import { DEFAULT_BAR_STROKE_WIDTH } from "../../../materialization/bars/resolve.js";
 import { resolveEligibleLayer } from "../../../selectors/layers.js";
 import { validateMarkOptions } from "../shared.js";
+import { requestedRectStyleDetails } from
+  "../../../grammar/roundedRect.js";
+import { STROKE_STYLE_PROPERTIES } from
+  "../../../grammar/strokeStyle.js";
+import { rematerializeExistingLegend } from "../../encodings/shared.js";
 
 const EDIT_OPTIONS = Object.freeze([
-  "target", "fill", "opacity", "stroke", "strokeWidth"
+  "target", "fill", "opacity", "stroke", "strokeWidth", "cornerRadius",
+  ...STROKE_STYLE_PROPERTIES
 ]);
 
-export const editBarMark = action(
+export const editBarMark = /* @__PURE__ */ action(
   {
     op: "editBarMark",
     description: "Edit whole-bar fill, opacity, and outline appearance."
   },
   function (args = {}) {
     validateMarkOptions(args, EDIT_OPTIONS, "editBarMark");
-    const changes = ["fill", "opacity", "stroke", "strokeWidth"];
+    const styleDetails = requestedRectStyleDetails(args, "editBarMark");
+    const changes = [
+      "fill", "opacity", "stroke", "strokeWidth", "cornerRadius",
+      ...STROKE_STYLE_PROPERTIES
+    ];
     if (!changes.some(key => Object.hasOwn(args, key))) {
       throw new Error(
         "editBarMark requires fill, opacity, stroke, or strokeWidth."
@@ -40,6 +50,11 @@ export const editBarMark = action(
         "editBarMark fill cannot be combined with a color encoding."
       );
     }
+    if (Object.hasOwn(args, "stroke") && layer.encoding?.stroke !== undefined) {
+      throw new Error(
+        "editBarMark stroke conflicts with a field encoding; use encodeStroke with value to replace it."
+      );
+    }
     if (args.stroke === false && Object.hasOwn(args, "strokeWidth")) {
       throw new Error(
         "editBarMark cannot set strokeWidth while removing stroke."
@@ -48,6 +63,7 @@ export const editBarMark = action(
 
     const config = { ...this.markConfigs[layer.id] };
     const appearance = { ...config.barAppearance };
+    Object.assign(appearance, styleDetails);
     if (Object.hasOwn(args, "fill")) {
       appearance.fill = validateNonEmptyString(args.fill, "Bar fill");
     }
@@ -83,8 +99,9 @@ export const editBarMark = action(
       ...config,
       barAppearance: appearance
     });
-    return canMaterializeBar(next, layer)
+    const materialized = canMaterializeBar(next, layer)
       ? next.rematerializeBarMark({ id: layer.id })
       : next;
+    return rematerializeExistingLegend(materialized);
   }
 );