ggaction 0.0.13 → 0.0.16

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

@@ -4,7 +4,6 @@ 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";
@@ -23,10 +22,17 @@ import {
 } from "./continuous/common.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, 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,
@@ -34,11 +40,13 @@ import {
   resolveStrokeWidthLegendLayout,
   createStrokeWidthLegendFromConfig
 } from "./strokeWidth.js";
+import { normalizeLegendSampling } from "./sampling.js";
+import { planLegendBlockTransitions } from "./transition.js";
 
 const OPTIONS = Object.freeze([
   "target", "channels", "position", "layout", "align", "direction", "columns", "offset",
   "titlePosition", "title", "symbol", "labels", "titleStyle", "itemGap",
-  "border", "count", "gradient", "order"
+  "border", "count", "values", "gradient", "order"
 ]);
 
 function mergeObject(previous, patch) {
@@ -70,11 +78,12 @@ function reconcileGraphic(program, id, shouldExist, definition) {
 }
 
 function resolveContinuousEdit(program, kind, previous, args) {
-  const allowed = kind === "gradient"
+  const gradient = ["gradient", "strokeGradient"].includes(kind);
+  const allowed = gradient
     ? ["target", "position", "align", "offset", "title", "labels",
       "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}.`);
   }
@@ -85,7 +94,9 @@ function resolveContinuousEdit(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;
@@ -93,12 +104,17 @@ function resolveContinuousEdit(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
@@ -110,14 +126,16 @@ function resolveContinuousEdit(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");
@@ -130,24 +148,29 @@ function resolveContinuousEdit(program, kind, previous, args) {
 
 function editContinuous(program, kind, previous, args) {
   const { config, titleMode, title, titleVisible } = resolveContinuousEdit(program, kind, previous, args);
-  const prefix = kind === "gradient" ? "colorGradient" : "opacityLegend";
+  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 resolveIntervalEdit(program, previous, args) {
+function resolveIntervalEdit(program, previous, args, channel = "color") {
   for (const key of Object.keys(args)) {
     if (![
       "target", "position", "align", "direction", "offset", "title",
@@ -165,7 +188,7 @@ function resolveIntervalEdit(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,
@@ -184,29 +207,45 @@ function resolveIntervalEdit(program, previous, args) {
     itemGap: args.itemGap ?? previous.itemGap,
     border: mergeBorder(previous.border, args.border)
   });
-  const config = { ...previous, ...normalized, inferredTitle, titleVisible };
-  const resolved = resolveIntervalConfig(program, config);
-  resolveIntervalLayout(program, resolved.config, resolved.scale);
+  const config = {
+    ...previous,
+    ...normalized,
+    inferredTitle,
+    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) {
-  const { normalized, config, titleMode, title, titleVisible } = resolveIntervalEdit(program, previous, args);
-  let next = program._withLegendConfig("interval", config);
+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();
 }
@@ -214,20 +253,23 @@ function editInterval(program, previous, args) {
 function resolveSampledLegendEdit(program, kind, previous, args) {
   const size = kind === "size";
   const label = size ? "size" : "stroke-width";
-  const allowed = ["target", "title", "count", "labels", "titleStyle",
+  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(`${label} legend does not accept ${key}.`);
     }
   }
-  const count = args.count ?? previous.count;
-  if (!Number.isInteger(count) || count < 2) {
-    throw new RangeError(
-      `${label} 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, `${label} 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"
@@ -239,12 +281,14 @@ function resolveSampledLegendEdit(program, kind, previous, args) {
   const title = titleMode === "auto"
     ? 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,
@@ -285,9 +329,25 @@ function editSampledLegend(program, kind, previous, args) {
   return next.rematerializeLegend();
 }
 
-function resolveCompanionSizeEdit(previous, size, args) {
+function resolveCompanionSizeEdit(program, previous, size, args) {
   if (size === undefined) return undefined;
-  const config = { ...size, count: args.count ?? size.count };
+  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;
@@ -299,6 +359,11 @@ function resolveCompanionSizeEdit(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.");
   }
@@ -319,6 +384,9 @@ function resolveCategoricalEdit(program, kind, previous, size, args, storedOrder
     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,
@@ -333,17 +401,23 @@ function resolveCategoricalEdit(program, kind, previous, size, args, storedOrder
     titlePosition: args.titlePosition ?? previous.titlePosition,
     title,
     symbol: args.symbol === undefined ? previous.symbol
-      : resolveLegendSymbol(program, findLayer(program, previous.target), previous.channels, args.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: args.symbol === undefined ? previous.inferredSymbol : args.symbol === "auto",
+    inferredSymbol,
     titleVisible
   };
   const order = args.order === undefined
@@ -351,13 +425,7 @@ function resolveCategoricalEdit(program, kind, previous, size, args, storedOrder
     : normalizeLegendOrder(args.order);
   // Resolve the final domain before changing semantic/config/graphic state.
   resolveDefinition(program, findLayer(program, previous.target), previous.channels, title, order);
-  if (args.count !== undefined) {
-    if (!Number.isInteger(args.count) || args.count < 2) {
-      throw new RangeError("Size legend count must be an integer of at least 2.");
-    }
-    validateGeneratedItemLimit(args.count, "Size legend count");
-  }
-  return { config, order, titleMode, title, titleVisible, sizeConfig: resolveCompanionSizeEdit(previous, size, args) };
+  return { config, order, titleMode, title, titleVisible, sizeConfig: resolveCompanionSizeEdit(program, previous, size, args) };
 }
 
 function editCategorical(program, kind, previous, size, args) {
@@ -381,12 +449,12 @@ function editCategorical(program, kind, previous, size, args) {
   }
   next = next._withLegendConfig(kind, config);
   next = reconcileCategoricalSymbols(next, previous, config);
-  next = reconcileGraphic(next, `${kind === "series" ? "series" : "color"}LegendBackground`,
+  next = reconcileGraphic(next, `${kind}LegendBackground`,
     config.border !== false, {
       type: "rect",
       before: [...newSymbols][0]
     });
-  const titleId = `${kind === "series" ? "series" : "color"}LegendTitle`;
+  const titleId = `${kind}LegendTitle`;
   next = reconcileGraphic(next, titleId, titleVisible, {
     type: "text",
     ...(next.graphicSpec.objects.sizeLegendSymbols === undefined
@@ -407,16 +475,16 @@ function editLegendContent(program, target, args) {
   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"].includes(kind));
-  const plans = creation.steps.map(step => {
+  const oldCategorical = removed.find(kind =>
+    ["series", "color", "stroke"].includes(kind)
+  );
+  let plans = creation.steps.map(step => {
     const descriptor = resolveLegendStepConfig(view, step);
     const { kind } = descriptor;
-    const otherCategorical = ["series", "color"].some(key => previous[key] !== undefined && previous[key].target !== target);
-    if (previous[kind] !== undefined && previous[kind].target !== target ||
-      ["series", "color"].includes(kind) && otherCategorical) {
+    if (previous[kind] !== undefined && previous[kind].target !== target) {
       throw new Error(`Legend ${kind} content already belongs to another target.`);
     }
-    if (["series", "color"].includes(kind) && oldCategorical !== undefined) {
+    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],
@@ -424,7 +492,9 @@ function editLegendContent(program, target, args) {
     }
     return { ...descriptor, config: previous[kind]?.target === target ? previous[kind] : descriptor.config };
   });
-  const categorical = plans.find(plan => ["series", "color"].includes(plan.kind));
+  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) {
@@ -444,23 +514,35 @@ function editLegendContent(program, target, args) {
     const plan = plans[0];
     if (plan.kind === "size" || plan.kind === "strokeWidth") {
       plan.config = resolveSampledLegendEdit(view, plan.kind, plan.config, patch).config;
-    } else if (plan.kind === "interval") plan.config = resolveIntervalEdit(view, 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"].includes(kind)) next = createCategoricalLegendFromConfig(next, config, order);
+    if (["series", "color", "stroke"].includes(kind)) {
+      next = createCategoricalLegendFromConfig(next, config, order);
+    }
     else next = ({ size: createSizeLegendFromConfig, strokeWidth: createStrokeWidthLegendFromConfig,
       gradient: createGradientLegendFromConfig, opacity: createOpacityLegendFromConfig,
-      interval: createIntervalLegendFromConfig })[kind](next, config);
+      interval: createIntervalLegendFromConfig,
+      strokeGradient: createStrokeGradientLegendFromConfig,
+      strokeInterval: createStrokeIntervalLegendFromConfig })[kind](next, config);
   }
   return next.rematerializeLegend();
 }
 
-export const editLegend = action(
+export const editLegend = /* @__PURE__ */ action(
   { op: "editLegend", description: "Edit one stable legend content, layout or appearance." },
   withGuideLayoutValidation(function (args = {}) {
     validateOptionObject(args, OPTIONS, "editLegend");
@@ -476,9 +558,23 @@ export const editLegend = action(
     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,
@@ -491,13 +587,16 @@ 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 editSampledLegend(this, "strokeWidth", configs.strokeWidth, args);
     }
     if (configs.size?.target === target) {
       return editSampledLegend(this, "size", configs.size, args);
     }
-    const continuousKind = ["gradient", "opacity"].find(
+    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

@@ -17,7 +17,7 @@ function makeFocusedLegendEdit({ name, options, map }) {
   );
 }
 
-const editLegendLayout = makeFocusedLegendEdit({
+const editLegendLayout = /* @__PURE__ */ makeFocusedLegendEdit({
   name: "editLegendLayout",
   options: [
     "position", "layout", "align", "direction", "columns", "offset",
@@ -26,13 +26,13 @@ const editLegendLayout = makeFocusedLegendEdit({
   map: args => args
 });
 
-const editLegendLabels = makeFocusedLegendEdit({
+const editLegendLabels = /* @__PURE__ */ makeFocusedLegendEdit({
   name: "editLegendLabels",
   options: ["offset", "color", "fontSize", "fontFamily", "fontWeight", "format"],
   map: ({ target, ...labels }) => ({ target, labels })
 });
 
-const editLegendTitle = makeFocusedLegendEdit({
+const editLegendTitle = /* @__PURE__ */ makeFocusedLegendEdit({
   name: "editLegendTitle",
   options: ["title", "color", "fontSize", "fontFamily", "fontWeight"],
   map: ({ target, title, ...titleStyle }) => ({
@@ -42,13 +42,13 @@ const editLegendTitle = makeFocusedLegendEdit({
   })
 });
 
-const editLegendSymbols = makeFocusedLegendEdit({
+const editLegendSymbols = /* @__PURE__ */ makeFocusedLegendEdit({
   name: "editLegendSymbols",
   options: ["symbol", "count", "gradient"],
   map: args => args
 });
 
-const editLegendBorder = makeFocusedLegendEdit({
+const editLegendBorder = /* @__PURE__ */ makeFocusedLegendEdit({
   name: "editLegendBorder",
   options: ["border"],
   map: args => args

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

@@ -4,6 +4,7 @@ import { registerSizeLegendActions } from "./size.js";
 import { registerStrokeWidthLegendActions } from "./strokeWidth.js";
 import { registerFocusedLegendActions } from "./focused.js";
 import { removeLegend } from "./remove.js";
+import { editLegendBlock } from "./blocks.js";
 
 export function registerLegendActions(ProgramClass) {
   registerCategoricalLegendActions(ProgramClass);
@@ -11,5 +12,6 @@ export function registerLegendActions(ProgramClass) {
   registerSizeLegendActions(ProgramClass);
   registerStrokeWidthLegendActions(ProgramClass);
   registerFocusedLegendActions(ProgramClass);
+  ProgramClass.prototype.editLegendBlock = editLegendBlock;
   ProgramClass.prototype.removeLegend = removeLegend;
 }