ggaction 0.0.12 → 0.0.15

package/src/actions/guides/legends/edit.js

@@ -1,30 +1,52 @@
+import { withGuideLayoutValidation } from "../../../materialization/guides/layout.js";
+import { resolveLegendStepConfig } from "./creation.js";
+import { normalizeLegendOrder } from "../../../grammar/categoryOrder.js";
+import { resolveDefinition } from "./categorical/resolve.js";
 import { action } from "../../../core/action.js";
 import {
-  validateGeneratedItemLimit,
   validateOptionObject
 } from "../../../core/validation.js";
 import { normalizeOptions } from "./categorical/options.js";
-import { symbolGraphic } from "./categorical/layout.js";
+import { resolveLegendSymbol } from "./categorical/recipes.js";
+import { resolveLayout } from "./categorical/layout.js";
+import { resolveLegendCreationPlan } from "./categorical/actions.js";
+import { categoricalSymbolIds, reconcileCategoricalSymbols, createCategoricalLegendFromConfig, resolveCategoricalLegendRevision, removeLegendKinds } from "./lifecycle.js";
+import { createGradientLegendFromConfig } from "./continuous/gradient.js";
 import {
+  normalizeItemLegendLayout,
+  normalizeLegendBorder,
   normalizeLegendTextOptions,
+  normalizeLegendTitleOptions,
   normalizeContinuousLegend,
   validatePositive
 } from "./continuous/common.js";
-import { normalizeOpacitySymbol } from "./continuous/opacity.js";
-import { normalizeIntervalLegend } from "./continuous/interval.js";
+import { normalizeOpacitySymbol, createOpacityLegendFromConfig } from "./continuous/opacity.js";
+import { normalizeIntervalLegend, resolveIntervalConfig, resolveIntervalLayout, createIntervalLegendFromConfig } from "./continuous/interval.js";
+import {
+  createStrokeGradientLegendFromConfig,
+  createStrokeIntervalLegendFromConfig,
+  resolveStrokeIntervalConfig,
+  resolveStrokeIntervalLayout
+} from "./continuous/stroke.js";
 import { findLayer } from "../../../selectors/layers.js";
 import { resolveLegendGraphicPlacement } from
   "../../../materialization/graphicHierarchy.js";
-import { resolveLegendTarget } from "./target.js";
+import { resolveLegendTarget, validateLegendChannels } from "./target.js";
+import { isDiscreteSizeScaleType } from "../../../grammar/scales/index.js";
+import { SIZE_LEGEND_LABELS, SIZE_LEGEND_TITLE_STYLE, resolveSizeLegendLayout, createSizeLegendFromConfig } from "./size.js";
 import {
   STROKE_WIDTH_LEGEND_LABELS,
-  STROKE_WIDTH_LEGEND_TITLE_STYLE
+  STROKE_WIDTH_LEGEND_TITLE_STYLE,
+  resolveStrokeWidthLegendLayout,
+  createStrokeWidthLegendFromConfig
 } from "./strokeWidth.js";
+import { normalizeLegendSampling } from "./sampling.js";
+import { planLegendBlockTransitions } from "./transition.js";
 
 const OPTIONS = Object.freeze([
-  "target", "position", "align", "direction", "columns", "offset",
+  "target", "channels", "position", "layout", "align", "direction", "columns", "offset",
   "titlePosition", "title", "symbol", "labels", "titleStyle", "itemGap",
-  "border", "count", "gradient"
+  "border", "count", "values", "gradient", "order"
 ]);
 
 function mergeObject(previous, patch) {
@@ -46,18 +68,22 @@ function reconcileGraphic(program, id, shouldExist, definition) {
     return program.createGraphics({
       id,
       ...definition,
-      ...resolveLegendGraphicPlacement(program)
+      ...resolveLegendGraphicPlacement(program, {
+        ...(definition.before === undefined ? {} : { before: definition.before }),
+        ...(definition.after === undefined ? {} : { after: definition.after })
+      })
     });
   }
   return program;
 }
 
-function editContinuous(program, kind, previous, args) {
-  const allowed = kind === "gradient"
+function resolveContinuousEdit(program, kind, previous, args) {
+  const gradient = ["gradient", "strokeGradient"].includes(kind);
+  const allowed = gradient
     ? ["target", "position", "align", "offset", "title", "labels",
-      "titleStyle", "border", "count", "gradient"]
+      "titleStyle", "titlePosition", "border", "count", "gradient"]
     : ["target", "position", "align", "offset", "title", "symbol", "labels",
-      "titleStyle", "titlePosition", "itemGap", "border", "count"];
+      "titleStyle", "titlePosition", "itemGap", "border", "count", "values"];
   for (const key of Object.keys(args)) {
     if (!allowed.includes(key)) throw new Error(`${kind} legend does not accept ${key}.`);
   }
@@ -68,7 +94,9 @@ function editContinuous(program, kind, previous, args) {
   const titleVisible = titleMode === false ? false
     : titleMode === undefined ? previous.titleVisible !== false : true;
   const layer = findLayer(program, previous.target);
-  const inferred = layer?.encoding?.[kind === "gradient" ? "color" : "opacity"]?.field;
+  const channel = kind === "gradient" ? "color"
+    : kind === "strokeGradient" ? "stroke" : "opacity";
+  const inferred = layer?.encoding?.[channel]?.field;
   const title = titleMode === "auto"
     ? inferred
     : typeof titleMode === "string" ? titleMode : previous.title;
@@ -76,12 +104,17 @@ function editContinuous(program, kind, previous, args) {
   const enteringInline = kind === "opacity" &&
     titlePosition === "left" && previous.titlePosition !== "left";
   const labels = mergeObject(previous.labels, args.labels);
+  const sampling = gradient ? undefined : normalizeLegendSampling(args, {
+    previous,
+    operation: "edit",
+    label: "Opacity legend"
+  });
   const normalized = normalizeContinuousLegend({
     target: previous.target,
     position: args.position ?? previous.position,
     align: args.align ?? previous.align,
     offset: args.offset ?? previous.offset,
-    count: args.count ?? previous.count,
+    ...(gradient ? { count: args.count ?? previous.count } : {}),
     titlePosition,
     title,
     labels: enteringInline && args.labels?.offset === undefined
@@ -93,14 +126,16 @@ function editContinuous(program, kind, previous, args) {
       itemGap: args.itemGap ?? (enteringInline ? 20 : previous.itemGap),
       symbol: args.symbol ?? previous.symbol
     } : {})
-  }, kind);
+  }, gradient ? "gradient" : kind);
+  const { count: _legacyCount, ...canonicalPrevious } = previous;
   const config = {
-    ...previous,
+    ...(gradient ? previous : canonicalPrevious),
     ...normalized,
+    ...(gradient ? {} : { sampling }),
     inferredTitle,
     titleVisible
   };
-  if (kind === "gradient") {
+  if (gradient) {
     const gradient = mergeObject(previous.gradient, args.gradient);
     validatePositive(gradient.length, "Gradient length");
     validatePositive(gradient.thickness, "Gradient thickness");
@@ -108,28 +143,38 @@ function editContinuous(program, kind, previous, args) {
   } else {
     config.symbol = normalizeOpacitySymbol(args.symbol ?? previous.symbol);
   }
-  const prefix = kind === "gradient" ? "colorGradient" : "opacityLegend";
+  return { config, titleMode, title, titleVisible };
+}
+
+function editContinuous(program, kind, previous, args) {
+  const { config, titleMode, title, titleVisible } = resolveContinuousEdit(program, kind, previous, args);
+  const prefix = kind === "gradient" ? "colorGradient"
+    : kind === "strokeGradient" ? "strokeGradient" : "opacityLegend";
+  const semanticKind = kind === "gradient" ? "color"
+    : kind === "strokeGradient" ? "stroke" : "opacity";
   let next = program;
   if (titleMode === "auto" || typeof titleMode === "string") {
     next = next.editSemantic({
-      property: `guide.legend.${kind === "gradient" ? "color" : "opacity"}.title`,
+      property: `guide.legend.${semanticKind}.title`,
       value: title
     });
   }
   next = next._withLegendConfig(kind, config);
   next = reconcileGraphic(next, `${prefix}Background`, config.border !== false, {
     type: "rect",
-    before: kind === "gradient" ? "colorGradientStrips" : "opacityLegendSymbols"
+    before: ["gradient", "strokeGradient"].includes(kind)
+      ? `${prefix}Strips`
+      : "opacityLegendSymbols"
   });
   next = reconcileGraphic(next, `${prefix}Title`, titleVisible, { type: "text" });
   return next.rematerializeLegend();
 }
 
-function editInterval(program, previous, args) {
+function resolveIntervalEdit(program, previous, args, channel = "color") {
   for (const key of Object.keys(args)) {
     if (![
       "target", "position", "align", "direction", "offset", "title",
-      "symbol", "labels", "titleStyle", "itemGap", "border"
+      "symbol", "labels", "titleStyle", "itemGap", "border", "layout", "columns", "titlePosition"
     ].includes(key)) {
       throw new Error(`interval legend does not accept ${key}.`);
     }
@@ -143,13 +188,17 @@ function editInterval(program, previous, args) {
     ? false
     : titleMode === undefined ? previous.titleVisible !== false : true;
   const title = titleMode === "auto"
-    ? layer?.encoding?.color?.field
+    ? layer?.encoding?.[channel]?.field
     : typeof titleMode === "string" ? titleMode : previous.title;
   const normalized = normalizeIntervalLegend({
     target: previous.target,
     position: args.position ?? previous.position,
     align: args.align ?? previous.align,
-    direction: args.direction ?? previous.direction,
+    direction: args.direction ?? (args.position !== undefined && args.position !== previous.position
+      ? undefined : previous.direction),
+    layout: args.layout === undefined ? previous.layout : args.layout,
+    columns: args.columns ?? previous.columns,
+    titlePosition: args.titlePosition ?? previous.titlePosition,
     offset: args.offset ?? previous.offset,
     title,
     symbol: mergeObject(previous.symbol, args.symbol),
@@ -158,44 +207,69 @@ function editInterval(program, previous, args) {
     itemGap: args.itemGap ?? previous.itemGap,
     border: mergeBorder(previous.border, args.border)
   });
-  let next = program._withLegendConfig("interval", {
+  const config = {
     ...previous,
     ...normalized,
     inferredTitle,
-    titleVisible
-  });
+    titleVisible,
+    ...(channel === "stroke" && args.symbol?.strokeWidth !== undefined
+      ? { inferredStrokeWidth: false }
+      : {})
+  };
+  const resolved = channel === "stroke"
+    ? resolveStrokeIntervalConfig(program, config)
+    : resolveIntervalConfig(program, config);
+  (channel === "stroke" ? resolveStrokeIntervalLayout : resolveIntervalLayout)(
+    program,
+    resolved.config,
+    resolved.scale
+  );
+  return { normalized, config, titleMode, title, titleVisible };
+}
+
+function editInterval(program, previous, args, channel = "color") {
+  const kind = channel === "stroke" ? "strokeInterval" : "interval";
+  const prefix = channel === "stroke" ? "strokeInterval" : "colorLegend";
+  const { normalized, config, titleMode, title, titleVisible } = resolveIntervalEdit(program, previous, args, channel);
+  let next = program._withLegendConfig(kind, config);
   if (titleMode === "auto" || typeof titleMode === "string") {
     next = next.editSemantic({
-      property: "guide.legend.color.title",
+      property: `guide.legend.${channel}.title`,
       value: title
     });
   }
-  next = reconcileGraphic(next, "colorLegendTitle", titleVisible, {
+  next = reconcileGraphic(next, `${prefix}Title`, titleVisible, {
     type: "text"
   });
   next = reconcileGraphic(
     next,
-    "colorLegendBackground",
+    `${prefix}Background`,
     normalized.border !== false,
-    { type: "rect", before: "colorLegendSymbols" }
+    { type: "rect", before: `${prefix}Symbols` }
   );
   return next.rematerializeLegend();
 }
 
-function editStrokeWidth(program, previous, args) {
-  const allowed = ["target", "title", "count", "labels", "titleStyle"];
+function resolveSampledLegendEdit(program, kind, previous, args) {
+  const size = kind === "size";
+  const label = size ? "size" : "stroke-width";
+  const allowed = ["target", "title", "count", "values", "labels", "titleStyle",
+    "position", "layout", "align", "direction", "columns", "titlePosition", "offset", "itemGap", "border"];
   for (const key of Object.keys(args)) {
     if (!allowed.includes(key)) {
-      throw new Error(`stroke-width legend does not accept ${key}.`);
+      throw new Error(`${label} legend does not accept ${key}.`);
     }
   }
-  const count = args.count ?? previous.count;
-  if (!Number.isInteger(count) || count < 2) {
-    throw new RangeError(
-      "Stroke-width legend count must be an integer of at least 2."
-    );
+  const discrete = size &&
+    isDiscreteSizeScaleType(program.resolvedScales[previous.scale]?.type);
+  if (discrete && (args.count !== undefined || args.values !== undefined)) {
+    throw new Error("Discrete size legends do not support count or exact values.");
   }
-  validateGeneratedItemLimit(count, "Stroke-width legend count");
+  const sampling = discrete ? undefined : normalizeLegendSampling(args, {
+    previous,
+    operation: "edit",
+    label: `${size ? "Size" : "Stroke-width"} legend`
+  });
   const layer = findLayer(program, previous.target);
   const titleMode = args.title;
   const inferredTitle = titleMode === "auto"
@@ -205,44 +279,91 @@ function editStrokeWidth(program, previous, args) {
     ? false
     : titleMode === undefined ? previous.titleVisible !== false : true;
   const title = titleMode === "auto"
-    ? layer?.encoding?.strokeWidth?.field
+    ? layer?.encoding?.[kind]?.field
     : typeof titleMode === "string" ? titleMode : previous.title;
+  const { count: _legacyCount, ...continuousPrevious } = previous;
+  const canonicalPrevious = discrete ? previous : continuousPrevious;
   const config = {
-    ...previous,
+    ...canonicalPrevious,
     title,
     inferredTitle,
     titleVisible,
-    count,
+    ...(discrete ? {} : { sampling }),
+    ...(size ? { inheritAppearance: false } : {}),
     labels: normalizeLegendTextOptions(
       args.labels,
       "editLegend.labels",
-      previous.labels ?? STROKE_WIDTH_LEGEND_LABELS
+      previous.labels ?? (size ? SIZE_LEGEND_LABELS : STROKE_WIDTH_LEGEND_LABELS)
     ),
-    titleStyle: normalizeLegendTextOptions(
+    titleStyle: normalizeLegendTitleOptions(
       args.titleStyle,
       "editLegend.titleStyle",
-      previous.titleStyle ?? STROKE_WIDTH_LEGEND_TITLE_STYLE
+      previous.titleStyle ?? (size ? SIZE_LEGEND_TITLE_STYLE : STROKE_WIDTH_LEGEND_TITLE_STYLE)
     )
   };
+  Object.assign(config, normalizeItemLegendLayout({ ...previous, ...args,
+    direction: args.direction ?? (args.position !== undefined && args.position !== previous.position
+      ? undefined : previous.direction) }));
+  config.border = normalizeLegendBorder(mergeBorder(previous.border, args.border));
+  (size ? resolveSizeLegendLayout : resolveStrokeWidthLegendLayout)(program, config);
+  return { config, titleMode, title, titleVisible };
+}
+
+function editSampledLegend(program, kind, previous, args) {
+  const { config, titleMode, title, titleVisible } = resolveSampledLegendEdit(program, kind, previous, args);
+  const prefix = kind === "size" ? "sizeLegend" : "strokeWidthLegend";
   let next = program;
   if (titleMode === "auto" || typeof titleMode === "string") {
     next = next.editSemantic({
-      property: "guide.legend.strokeWidth.title",
+      property: `guide.legend.${kind}.title`,
       value: title
     });
   }
-  next = next._withLegendConfig("strokeWidth", config);
-  next = reconcileGraphic(next, "strokeWidthLegendTitle", titleVisible, {
-    type: "text"
+  next = next._withLegendConfig(kind, config);
+  next = reconcileGraphic(next, `${prefix}Background`, config.border !== false, {
+    type: "rect", before: `${prefix}Symbols`
+  });
+  next = reconcileGraphic(next, `${prefix}Title`, titleVisible, {
+    type: "text", after: `${prefix}Labels`
   });
   return next.rematerializeLegend();
 }
 
-function categoricalSymbolIds(config) {
-  return new Set(config.symbol.layers.map(layer => symbolGraphic(config, layer.type)));
+function resolveCompanionSizeEdit(program, previous, size, args) {
+  if (size === undefined) return undefined;
+  const discrete = isDiscreteSizeScaleType(
+    program.resolvedScales[size.scale]?.type
+  );
+  if (discrete && (args.count !== undefined || args.values !== undefined)) {
+    throw new Error("Discrete size legends do not support count or exact values.");
+  }
+  const sampling = discrete ? undefined : normalizeLegendSampling(args, {
+    previous: size,
+    operation: "edit",
+    label: "Size legend"
+  });
+  const { count: _legacyCount, ...continuousSize } = size;
+  const canonicalSize = discrete ? size : continuousSize;
+  const config = {
+    ...canonicalSize,
+    ...(discrete ? {} : { sampling })
+  };
+  if (args.labels === undefined && args.titleStyle === undefined) return config;
+  const labels = size.inheritAppearance
+    ? { ...previous.labels, offset: size.labels.offset } : size.labels ?? SIZE_LEGEND_LABELS;
+  const titleStyle = size.inheritAppearance
+    ? previous.titleStyle : size.titleStyle ?? SIZE_LEGEND_TITLE_STYLE;
+  return { ...config, inheritAppearance: false,
+    labels: normalizeLegendTextOptions(args.labels, "editLegend.labels", labels),
+    titleStyle: normalizeLegendTitleOptions(args.titleStyle, "editLegend.titleStyle", titleStyle) };
 }
 
-function editCategorical(program, kind, previous, size, args) {
+function resolveCategoricalEdit(program, kind, previous, size, args, storedOrder = program.semanticSpec.guides.legend?.[kind]?.order) {
+  if (args.values !== undefined) {
+    throw new Error(
+      "Combined and categorical legends require a channel block selector for exact values."
+    );
+  }
   if (args.gradient !== undefined) {
     throw new Error("Categorical legends do not accept gradient.");
   }
@@ -258,32 +379,57 @@ function editCategorical(program, kind, previous, size, args) {
   const title = titleMode === "auto"
     ? previous.field
     : typeof titleMode === "string" ? titleMode : previous.title;
+  const mergedLabels = mergeObject(previous.labels, args.labels);
+  if (mergedLabels.format !== undefined && mergedLabels.format !== "auto" && size === undefined) {
+    throw new Error("Categorical legend labels do not accept format.");
+  }
+  const { format: _sizeFormat, ...categoricalLabels } = mergedLabels;
+  const inferredSymbol = args.symbol === undefined
+    ? previous.inferredSymbol
+    : args.symbol === "auto";
   const normalized = normalizeOptions({
     target: previous.target,
     channels: previous.channels,
+    layout: args.layout === undefined ? previous.layout : args.layout,
     position: args.position ?? previous.position,
     align: args.align ?? previous.align,
-    direction: args.direction ?? (args.position === "left"
-      ? "vertical"
-      : previous.direction),
+    direction: args.direction ?? (args.position !== undefined && args.position !== previous.position
+      ? undefined : previous.direction),
     ...(args.columns === undefined && previous.columns === undefined
       ? {} : { columns: args.columns ?? previous.columns }),
     offset: args.offset ?? previous.offset,
     titlePosition: args.titlePosition ?? previous.titlePosition,
     title,
-    symbol: args.symbol ?? previous.symbol,
-    labels: mergeObject(previous.labels, args.labels),
+    symbol: args.symbol === undefined ? previous.symbol
+      : resolveLegendSymbol(
+          program,
+          findLayer(program, previous.target),
+          previous.channels,
+          args.symbol,
+          kind
+        ),
+    labels: categoricalLabels,
     titleStyle: mergeObject(previous.titleStyle, args.titleStyle),
     itemGap: args.itemGap ?? previous.itemGap,
     border: mergeBorder(previous.border, args.border)
-  }, kind);
+  }, kind, { internalSymbol: inferredSymbol });
   const config = {
     ...previous,
     ...normalized,
     inferredTitle,
+    inferredSymbol,
     titleVisible
   };
-  const oldSymbols = categoricalSymbolIds(previous);
+  const order = args.order === undefined
+    ? storedOrder
+    : normalizeLegendOrder(args.order);
+  // Resolve the final domain before changing semantic/config/graphic state.
+  resolveDefinition(program, findLayer(program, previous.target), previous.channels, title, order);
+  return { config, order, titleMode, title, titleVisible, sizeConfig: resolveCompanionSizeEdit(program, previous, size, args) };
+}
+
+function editCategorical(program, kind, previous, size, args) {
+  const { config, order, titleMode, title, titleVisible, sizeConfig } = resolveCategoricalEdit(program, kind, previous, size, args);
   const newSymbols = categoricalSymbolIds(config);
   let next = program;
   if (titleMode === "auto" || typeof titleMode === "string") {
@@ -292,49 +438,113 @@ function editCategorical(program, kind, previous, size, args) {
       value: title
     });
   }
-  next = next._withLegendConfig(kind, config);
-  for (const id of oldSymbols) {
-    if (!newSymbols.has(id) && next.graphicSpec.objects[id] !== undefined) {
-      next = next.editGraphics({ target: id, remove: true });
+  if (args.order !== undefined) {
+    if (order === "scale") {
+      if (program.semanticSpec.guides.legend?.[kind]?.order !== undefined) {
+        next = next.editSemantic({ property: `guide.legend.${kind}.order`, remove: true });
+      }
+    } else {
+      next = next.editSemantic({ property: `guide.legend.${kind}.order`, value: order });
     }
   }
-  next = reconcileGraphic(next, `${kind === "series" ? "series" : "color"}LegendBackground`,
+  next = next._withLegendConfig(kind, config);
+  next = reconcileCategoricalSymbols(next, previous, config);
+  next = reconcileGraphic(next, `${kind}LegendBackground`,
     config.border !== false, {
       type: "rect",
       before: [...newSymbols][0]
     });
-  for (const layer of config.symbol.layers) {
-    const id = symbolGraphic(config, layer.type);
-    if (next.graphicSpec.objects[id] === undefined) {
-      const suffix = { line: "Lines", point: "Points", swatch: "Swatches" }[layer.type];
-      next = next[`createLegendSymbol${suffix}`]();
-    }
-  }
-  const titleId = `${kind === "series" ? "series" : "color"}LegendTitle`;
+  const titleId = `${kind}LegendTitle`;
   next = reconcileGraphic(next, titleId, titleVisible, {
     type: "text",
     ...(next.graphicSpec.objects.sizeLegendSymbols === undefined
-      ? {} : { before: "sizeLegendSymbols" })
+      ? {} : { before: next.graphicSpec.objects.sizeLegendBackground === undefined
+        ? "sizeLegendSymbols" : "sizeLegendBackground" })
   });
   if (size !== undefined) {
-    if (args.count !== undefined && (!Number.isInteger(args.count) || args.count < 2)) {
-      throw new RangeError("Size legend count must be an integer of at least 2.");
+    next = next._withLegendConfig("size", sizeConfig);
+  }
+  return next.rematerializeLegend();
+}
+
+
+function editLegendContent(program, target, args) {
+  validateLegendChannels(args.channels, "editLegend");
+  const { channels, target: _target, ...patch } = args;
+  const previous = program.guideConfigs.legend ?? {};
+  const removed = Object.keys(previous).filter(kind => previous[kind].target === target);
+  let view = removed.reduce((next, kind) => next._withoutMaterializationConfig(["guides", "legend", kind]), program);
+  const creation = resolveLegendCreationPlan(view, { target, channels });
+  const oldCategorical = removed.find(kind =>
+    ["series", "color", "stroke"].includes(kind)
+  );
+  let plans = creation.steps.map(step => {
+    const descriptor = resolveLegendStepConfig(view, step);
+    const { kind } = descriptor;
+    if (previous[kind] !== undefined && previous[kind].target !== target) {
+      throw new Error(`Legend ${kind} content already belongs to another target.`);
     }
-    if (args.count !== undefined) {
-      validateGeneratedItemLimit(args.count, "Size legend count");
+    if (["series", "color", "stroke"].includes(kind) && oldCategorical !== undefined) {
+      const order = patch.order === undefined ? program.semanticSpec.guides.legend?.[oldCategorical]?.order
+        : normalizeLegendOrder(patch.order);
+      return { ...resolveCategoricalLegendRevision(view, oldCategorical, previous[oldCategorical],
+        descriptor.config.channels, { order, validateLayout: false }), kind };
     }
-    next = next._withLegendConfig("size", {
-      ...size,
-      count: args.count ?? size.count,
-      inheritAppearance: true
-    });
+    return { ...descriptor, config: previous[kind]?.target === target ? previous[kind] : descriptor.config };
+  });
+  const categorical = plans.find(plan =>
+    ["series", "color", "stroke"].includes(plan.kind)
+  );
+  const size = plans.find(plan => plan.kind === "size");
+  if (categorical !== undefined) {
+    if (size !== undefined && previous.size?.target !== target) {
+      size.config = { ...size.config, inheritAppearance: categorical.config.position === "left" ||
+        patch.position === "left" || patch.labels !== undefined || patch.titleStyle !== undefined };
+    }
+    const edited = resolveCategoricalEdit(view, categorical.kind, categorical.config, size?.config, patch, categorical.order);
+    categorical.config = edited.config;
+    categorical.order = edited.order;
+    if (size !== undefined) {
+      size.config = edited.sizeConfig;
+      if (categorical.config.layout === "legacy-bottom") {
+        throw new Error('Combined size legends require layout "edge".');
+      }
+    }
+  } else {
+    const plan = plans[0];
+    if (plan.kind === "size" || plan.kind === "strokeWidth") {
+      plan.config = resolveSampledLegendEdit(view, plan.kind, plan.config, patch).config;
+    } else if (["interval", "strokeInterval"].includes(plan.kind)) {
+      plan.config = resolveIntervalEdit(
+        view,
+        plan.config,
+        patch,
+        plan.kind === "strokeInterval" ? "stroke" : "color"
+      ).config;
+    }
+    else plan.config = resolveContinuousEdit(view, plan.kind, plan.config, patch).config;
+  }
+  plans = planLegendBlockTransitions(program, target, plans);
+  // The complete final content and styles are validated before removing resources.
+  for (const { kind, config } of plans) view = view._withLegendConfig(kind, config);
+  if (categorical !== undefined) resolveLayout(view, categorical.config);
+  let next = removeLegendKinds(program, removed);
+  for (const { kind, config, order } of plans) {
+    if (["series", "color", "stroke"].includes(kind)) {
+      next = createCategoricalLegendFromConfig(next, config, order);
+    }
+    else next = ({ size: createSizeLegendFromConfig, strokeWidth: createStrokeWidthLegendFromConfig,
+      gradient: createGradientLegendFromConfig, opacity: createOpacityLegendFromConfig,
+      interval: createIntervalLegendFromConfig,
+      strokeGradient: createStrokeGradientLegendFromConfig,
+      strokeInterval: createStrokeIntervalLegendFromConfig })[kind](next, config);
   }
   return next.rematerializeLegend();
 }
 
 export const editLegend = action(
-  { op: "editLegend", description: "Edit one stable legend layout or appearance." },
-  function (args = {}) {
+  { op: "editLegend", description: "Edit one stable legend content, layout or appearance." },
+  withGuideLayoutValidation(function (args = {}) {
     validateOptionObject(args, OPTIONS, "editLegend");
     const changes = Object.keys(args).filter(key => key !== "target");
     if (changes.length === 0) {
@@ -346,10 +556,25 @@ export const editLegend = action(
       throw new TypeError('editLegend title must be a non-empty string, "auto", or false.');
     }
     const target = resolveLegendTarget(this, args.target, "editLegend");
+    if (args.channels !== undefined) return editLegendContent(this, target, args);
     const configs = this.guideConfigs.legend ?? {};
-    const categoricalKind = ["series", "color"].find(
+    const ownedKinds = Object.keys(configs).filter(
+      kind => configs[kind]?.target === target
+    );
+    if (args.values !== undefined && ownedKinds.length > 1) {
+      throw new Error(
+        "A target with multiple legend blocks requires a channel block selector for exact values."
+      );
+    }
+    const categoricalKinds = ["series", "color", "stroke"].filter(
       kind => configs[kind]?.target === target
     );
+    if (categoricalKinds.length > 1) {
+      throw new Error(
+        "editLegend requires channels when a target owns multiple categorical legend blocks."
+      );
+    }
+    const categoricalKind = categoricalKinds[0];
     if (categoricalKind !== undefined) {
       return editCategorical(
         this,
@@ -362,12 +587,18 @@ export const editLegend = action(
     if (configs.interval?.target === target) {
       return editInterval(this, configs.interval, args);
     }
+    if (configs.strokeInterval?.target === target) {
+      return editInterval(this, configs.strokeInterval, args, "stroke");
+    }
     if (configs.strokeWidth?.target === target) {
-      return editStrokeWidth(this, configs.strokeWidth, args);
+      return editSampledLegend(this, "strokeWidth", configs.strokeWidth, args);
     }
-    const continuousKind = ["gradient", "opacity"].find(
+    if (configs.size?.target === target) {
+      return editSampledLegend(this, "size", configs.size, args);
+    }
+    const continuousKind = ["gradient", "strokeGradient", "opacity"].find(
       kind => configs[kind]?.target === target
     );
     return editContinuous(this, continuousKind, configs[continuousKind], args);
-  }
+  })
 );

package/src/actions/guides/legends/focused.js

@@ -20,7 +20,7 @@ function makeFocusedLegendEdit({ name, options, map }) {
 const editLegendLayout = makeFocusedLegendEdit({
   name: "editLegendLayout",
   options: [
-    "position", "align", "direction", "columns", "offset",
+    "position", "layout", "align", "direction", "columns", "offset",
     "titlePosition", "itemGap"
   ],
   map: args => args
@@ -28,7 +28,7 @@ const editLegendLayout = makeFocusedLegendEdit({
 
 const editLegendLabels = makeFocusedLegendEdit({
   name: "editLegendLabels",
-  options: ["color", "fontSize", "fontFamily", "fontWeight"],
+  options: ["offset", "color", "fontSize", "fontFamily", "fontWeight", "format"],
   map: ({ target, ...labels }) => ({ target, labels })
 });