ggaction 0.0.2 → 0.0.4

package/src/actions/guides/grids/grid.js

@@ -1,6 +1,10 @@
 import { action } from "../../../core/action.js";
 import { isPlainObject } from "../../../core/immutable.js";
-import { validateKeys } from "../../../core/validation.js";
+import {
+  noOptions,
+  validateKeys,
+  validateOptionObject
+} from "../../../core/validation.js";
 import {
   gridNames,
   editGridConfig,
@@ -11,8 +15,29 @@ import {
   validateGridCreateArgs,
   validateGridEditArgs
 } from "./resolve.js";
+import { polarGuideNames } from "../polar/resolve.js";
+import { resolveAutomaticGridOptions } from "../applicability.js";
 
-const AGGREGATE_OPTIONS = Object.freeze(["horizontal", "vertical"]);
+const CARTESIAN_OPTIONS = Object.freeze(["horizontal", "vertical"]);
+const POLAR_OPTIONS = Object.freeze(["theta", "radial"]);
+const AGGREGATE_OPTIONS = Object.freeze([
+  ...CARTESIAN_OPTIONS,
+  ...POLAR_OPTIONS
+]);
+
+function removeDirection(program, direction) {
+  const graphic = POLAR_OPTIONS.includes(direction)
+    ? polarGuideNames(direction).grid
+    : gridNames(direction).graphic;
+  let next = program.editSemantic({
+    property: `guide.grid.${direction}`,
+    remove: true
+  });
+  if (next.graphicSpec.objects[graphic] !== undefined) {
+    next = next.editGraphics({ target: graphic, remove: true });
+  }
+  return next._withoutMaterializationConfig(["guides", "grid", direction]);
+}
 
 function makeRematerialize(direction) {
   const operation = gridNames(direction);
@@ -22,9 +47,7 @@ function makeRematerialize(direction) {
       description: `Recompute concrete ${direction} grid lines.`
     },
     function (args = {}) {
-      if (!isPlainObject(args) || Object.keys(args).length !== 0) {
-        throw new TypeError(`${operation.rematerialize} does not accept options.`);
-      }
+      noOptions(args, operation.rematerialize);
       const storedConfig = this.guideConfigs.grid?.[direction];
       const semantic = this.semanticSpec.guides.grid?.[direction];
       if (
@@ -160,21 +183,76 @@ const createVerticalGrid = makeCreate("vertical");
 const editHorizontalGrid = makeEdit("horizontal");
 const editVerticalGrid = makeEdit("vertical");
 
+const editGrid = action(
+  {
+    op: "editGrid",
+    description: "Edit selected existing Cartesian grid directions."
+  },
+  function (args = {}) {
+    validateOptionObject(args, AGGREGATE_OPTIONS, "editGrid", {
+      allowEmpty: false,
+      emptyMessage: "editGrid requires horizontal or vertical changes.",
+      emptyError: Error
+    });
+    for (const direction of AGGREGATE_OPTIONS) {
+      if (!Object.hasOwn(args, direction)) continue;
+      if (!isPlainObject(args[direction])) {
+        throw new TypeError(`editGrid ${direction} must be a plain object.`);
+      }
+      validateGridEditArgs(
+        args[direction],
+        `edit${direction === "horizontal" ? "Horizontal" : "Vertical"}Grid`
+      );
+    }
+    let next = this;
+    if (args.horizontal !== undefined) {
+      next = next.editHorizontalGrid(args.horizontal);
+    }
+    if (args.vertical !== undefined) {
+      next = next.editVerticalGrid(args.vertical);
+    }
+    if (args.theta !== undefined) next = next.editThetaGrid(args.theta);
+    if (args.radial !== undefined) next = next.editRadialGrid(args.radial);
+    return next;
+  }
+);
+
 const createGrid = action(
   {
     op: "createGrid",
     description: "Create selected Cartesian grid directions."
   },
   function (args = {}) {
-    if (!isPlainObject(args)) {
-      throw new TypeError("createGrid options must be a plain object.");
-    }
-    validateKeys(args, AGGREGATE_OPTIONS, "createGrid");
-    const horizontal = normalizeDirection(args.horizontal, "horizontal");
-    const vertical = args.vertical === undefined
+    validateOptionObject(args, AGGREGATE_OPTIONS, "createGrid");
+    const automatic = Object.keys(args).length === 0
+      ? resolveAutomaticGridOptions(this)
+      : undefined;
+    const hasExplicitPolar = Object.hasOwn(args, "theta") ||
+      Object.hasOwn(args, "radial");
+    const polarDefault = automatic !== undefined &&
+      (Object.hasOwn(automatic, "theta") || Object.hasOwn(automatic, "radial"));
+    const horizontal = automatic !== undefined
+      ? automatic.horizontal === false ? undefined : automatic.horizontal
+      : polarDefault ||
+      (hasExplicitPolar && args.horizontal === undefined)
+      ? undefined
+      : normalizeDirection(args.horizontal, "horizontal");
+    const vertical = automatic !== undefined
+      ? automatic.vertical === false ? undefined : automatic.vertical
+      : args.vertical === undefined
       ? undefined
       : normalizeDirection(args.vertical, "vertical");
-    if (horizontal === undefined && vertical === undefined) {
+    const theta = automatic !== undefined
+      ? automatic.theta
+      : args.theta === undefined
+        ? undefined
+        : normalizeDirection(args.theta, "theta");
+    const radial = automatic !== undefined
+      ? automatic.radial
+      : args.radial === undefined
+        ? undefined
+        : normalizeDirection(args.radial, "radial");
+    if ([horizontal, vertical, theta, radial].every(value => value === undefined)) {
       throw new Error("createGrid requires at least one selected direction.");
     }
 
@@ -185,6 +263,8 @@ const createGrid = action(
     if (vertical !== undefined) {
       next = next.createVerticalGrid(vertical);
     }
+    if (radial !== undefined) next = next.createRadialGrid(radial);
+    if (theta !== undefined) next = next.createThetaGrid(theta);
     return next;
   }
 );
@@ -195,9 +275,7 @@ const rematerializeGrid = action(
     description: "Recompute every existing grid direction."
   },
   function (args = {}) {
-    if (!isPlainObject(args) || Object.keys(args).length !== 0) {
-      throw new TypeError("rematerializeGrid does not accept options.");
-    }
+    noOptions(args, "rematerializeGrid");
     let next = this;
     let count = 0;
     if (this.guideConfigs.grid?.horizontal !== undefined) {
@@ -208,6 +286,14 @@ const rematerializeGrid = action(
       next = next.rematerializeVerticalGrid();
       count += 1;
     }
+    if (this.guideConfigs.grid?.theta !== undefined) {
+      next = next.rematerializeThetaGrid();
+      count += 1;
+    }
+    if (this.guideConfigs.grid?.radial !== undefined) {
+      next = next.rematerializeRadialGrid();
+      count += 1;
+    }
     if (count === 0) {
       throw new Error("rematerializeGrid requires an existing grid.");
     }
@@ -215,12 +301,55 @@ const rematerializeGrid = action(
   }
 );
 
+const removeGrid = action(
+  {
+    op: "removeGrid",
+    description: "Remove selected Cartesian grid directions."
+  },
+  function (args = {}) {
+    validateOptionObject(args, AGGREGATE_OPTIONS, "removeGrid");
+    for (const direction of AGGREGATE_OPTIONS) {
+      if (
+        Object.hasOwn(args, direction) &&
+        typeof args[direction] !== "boolean"
+      ) {
+        throw new TypeError(`removeGrid ${direction} must be a boolean.`);
+      }
+    }
+    const existing = AGGREGATE_OPTIONS.filter(direction =>
+      this.semanticSpec.guides.grid?.[direction] !== undefined ||
+      this.guideConfigs.grid?.[direction] !== undefined ||
+      this.graphicSpec.objects[
+        POLAR_OPTIONS.includes(direction)
+          ? polarGuideNames(direction).grid
+          : gridNames(direction).graphic
+      ] !== undefined
+    );
+    const selected = Object.keys(args).length === 0
+      ? existing
+      : AGGREGATE_OPTIONS.filter(direction => args[direction] === true);
+    if (selected.length === 0) {
+      throw new Error("removeGrid requires at least one selected direction.");
+    }
+    for (const direction of selected) {
+      if (!existing.includes(direction)) {
+        throw new Error(`removeGrid requires an existing ${direction} grid.`);
+      }
+    }
+    let next = this;
+    for (const direction of selected) next = removeDirection(next, direction);
+    return next;
+  }
+);
+
 export function registerGridActions(ProgramClass) {
   ProgramClass.prototype.createGrid = createGrid;
   ProgramClass.prototype.createHorizontalGrid = createHorizontalGrid;
   ProgramClass.prototype.createVerticalGrid = createVerticalGrid;
   ProgramClass.prototype.editHorizontalGrid = editHorizontalGrid;
   ProgramClass.prototype.editVerticalGrid = editVerticalGrid;
+  ProgramClass.prototype.editGrid = editGrid;
+  ProgramClass.prototype.removeGrid = removeGrid;
   ProgramClass.prototype.rematerializeGrid = rematerializeGrid;
   ProgramClass.prototype.rematerializeHorizontalGrid =
     rematerializeHorizontalGrid;

package/src/actions/guides/grids/resolve.js

@@ -1,14 +1,13 @@
 import { validateUserId } from "../../../core/identifiers.js";
-import { isPlainObject } from "../../../core/immutable.js";
 import {
-  validateKeys,
+  validateOptionObject,
   validateNonEmptyString,
   validateNonNegativeFinite
 } from "../../../core/validation.js";
 import {
   isTransformedScaleType,
   mapContinuousScaleValues
-} from "../../../grammar/scales.js";
+} from "../../../grammar/scales/index.js";
 import { resolveGraphicBounds } from "../../../layout/canvas.js";
 import { resolveGridLineGeometry } from "../../../layout/grid.js";
 import { DEFAULT_COLORS } from "../../../theme/defaults.js";
@@ -58,10 +57,7 @@ function validateStrokeDash(value) {
 }
 
 export function validateGridCreateArgs(args, operation) {
-  if (!isPlainObject(args)) {
-    throw new TypeError(`${operation} options must be a plain object.`);
-  }
-  validateKeys(args, GRID_OPTIONS, operation);
+  validateOptionObject(args, GRID_OPTIONS, operation);
   if (Object.hasOwn(args, "count") && Object.hasOwn(args, "values")) {
     throw new Error(`${operation} cannot use count and values together.`);
   }
@@ -85,13 +81,9 @@ export function validateGridCreateArgs(args, operation) {
 }
 
 export function validateGridEditArgs(args, operation) {
-  if (!isPlainObject(args)) {
-    throw new TypeError(`${operation} options must be a plain object.`);
-  }
-  validateKeys(args, GRID_EDIT_OPTIONS, operation);
-  if (Object.keys(args).length === 0) {
-    throw new TypeError(`${operation} requires at least one option.`);
-  }
+  validateOptionObject(args, GRID_EDIT_OPTIONS, operation, {
+    allowEmpty: false
+  });
   if (Object.hasOwn(args, "count") && Object.hasOwn(args, "values")) {
     throw new Error(`${operation} cannot use count and values together.`);
   }

package/src/actions/guides/guides.js

@@ -1,10 +1,10 @@
 import { action } from "../../core/action.js";
 import { isPlainObject } from "../../core/immutable.js";
+import { validateOptionObject } from "../../core/validation.js";
 import {
-  BAR_ORIENTATIONS,
-  resolveBarOrientation
-} from "../../grammar/bars/policy.js";
-import { findSemanticScale } from "../../selectors/scales.js";
+  resolveAutomaticGridOptions,
+  resolveGuideApplicability
+} from "./applicability.js";
 
 const OPTIONS = Object.freeze(["axes", "grid", "legend"]);
 
@@ -15,54 +15,12 @@ function validateGuideOption(value, label) {
 }
 
 function validateOptions(args) {
-  if (!isPlainObject(args)) {
-    throw new TypeError("createGuides options must be a plain object.");
-  }
-  for (const key of Object.keys(args)) {
-    if (!OPTIONS.includes(key)) {
-      throw new Error(`Unknown createGuides option "${key}".`);
-    }
-  }
+  validateOptionObject(args, OPTIONS, "createGuides");
   validateGuideOption(args.axes, "createGuides axes");
   validateGuideOption(args.grid, "createGuides grid");
   validateGuideOption(args.legend, "createGuides legend");
 }
 
-function hasCartesianEncoding(program) {
-  return program.semanticSpec.layers.some(
-    layer => layer.encoding?.x !== undefined || layer.encoding?.y !== undefined
-  );
-}
-
-function hasGridEncoding(program) {
-  return program.semanticSpec.layers.some(
-    layer => layer.encoding?.x?.scale !== undefined ||
-      layer.encoding?.y?.scale !== undefined
-  );
-}
-
-function inferGridOptions(program) {
-  const barOrientations = program.semanticSpec.layers
-    .map(resolveBarOrientation)
-    .filter(Boolean);
-  const positionedLayers = program.semanticSpec.layers.filter(
-    layer => layer.encoding?.x !== undefined && layer.encoding?.y !== undefined
-  );
-  const horizontalQuantitative = positionedLayers.length > 0 &&
-    positionedLayers.every(layer =>
-      layer.encoding.x.fieldType === "quantitative" &&
-      ["nominal", "ordinal", "temporal"].includes(layer.encoding.y.fieldType)
-    );
-  if (
-    horizontalQuantitative ||
-    (barOrientations.length > 0 &&
-      barOrientations.every(value => value === BAR_ORIENTATIONS.horizontal))
-  ) {
-    return { horizontal: false, vertical: true };
-  }
-  return { horizontal: true, vertical: false };
-}
-
 function inferAxesOptions(program) {
   const horizontalInterval = program.semanticSpec.layers.some(layer =>
     layer.mark?.type === "rule" &&
@@ -75,28 +33,6 @@ function inferAxesOptions(program) {
     : {};
 }
 
-function hasLegendEncoding(program) {
-  return program.semanticSpec.layers.some(
-    layer =>
-      (layer.mark?.type === "point" &&
-        layer.encoding?.opacity?.scale !== undefined) ||
-      (layer.mark?.type === "point" &&
-        layer.encoding?.color?.scale !== undefined &&
-        (layer.encoding?.shape?.scale !== undefined ||
-          ["sequential", "quantize", "quantile", "threshold"].includes(
-            findSemanticScale(program, layer.encoding.color.scale)?.type
-          ))) ||
-      (layer.mark?.type === "line" &&
-        ["color", "strokeDash"].some(
-          channel => layer.encoding?.[channel]?.scale !== undefined
-        )) ||
-      (layer.mark?.type === "bar" &&
-        layer.encoding?.color?.scale !== undefined) ||
-      (layer.mark?.type === "area" &&
-        layer.encoding?.color?.scale !== undefined)
-  );
-}
-
 function selectOption(explicit, applicable) {
   if (explicit === false) return undefined;
   if (explicit !== undefined) return explicit;
@@ -110,15 +46,21 @@ const createGuides = action(
   },
   function (args = {}) {
     validateOptions(args);
-    const axes = args.axes === undefined && hasCartesianEncoding(this)
+    const applicability = resolveGuideApplicability(this);
+    const hasAxes = applicability.axes.cartesian || applicability.axes.polar;
+    const axes = args.axes === undefined && applicability.axes.cartesian
       ? inferAxesOptions(this)
-      : selectOption(args.axes, hasCartesianEncoding(this));
-    const grid = args.grid === undefined && hasGridEncoding(this)
-      ? inferGridOptions(this)
-      : selectOption(args.grid, hasGridEncoding(this));
+      : selectOption(args.axes, hasAxes);
+    const grid = args.grid === undefined &&
+        (applicability.grid.cartesian || applicability.grid.polar)
+      ? resolveAutomaticGridOptions(this)
+      : selectOption(
+          args.grid,
+          applicability.grid.cartesian || applicability.grid.polar
+        );
     const legend = selectOption(
       args.legend,
-      hasLegendEncoding(this)
+      applicability.legend
     );
 
     if (axes === undefined && grid === undefined && legend === undefined) {

package/src/actions/guides/index.js

@@ -2,10 +2,16 @@ import { registerGuideAxisActions } from "./axes/index.js";
 import { registerGuideCollectionActions } from "./guides.js";
 import { registerGridActions } from "./grids/index.js";
 import { registerLegendActions } from "./legends/index.js";
+import {
+  registerPolarAxisActions,
+  registerPolarGridActions
+} from "./polar/index.js";
 
 export function registerGuideActions(ProgramClass) {
   registerGuideAxisActions(ProgramClass);
   registerLegendActions(ProgramClass);
   registerGridActions(ProgramClass);
+  registerPolarGridActions(ProgramClass);
+  registerPolarAxisActions(ProgramClass);
   registerGuideCollectionActions(ProgramClass);
 }

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

@@ -1,9 +1,10 @@
 import { action } from "../../../../core/action.js";
-import { isPlainObject } from "../../../../core/immutable.js";
+import { validateOptionObject } from "../../../../core/validation.js";
 import { noOptions, resolveLayout, activeConfig } from "./layout.js";
 import { normalizeOptions } from "./options.js";
 import { findLayer } from "../../../../selectors/layers.js";
 import { findSemanticScale } from "../../../../selectors/scales.js";
+import { isSizeLegendPoint } from "../size.js";
 import {
   resolveCurrentDefinition,
   resolveDefinition,
@@ -69,11 +70,11 @@ export const rematerializeLegend = action(
           });
         }
       }
-      if (config.border !== false) next = next.editLegendBackground();
+      if (config.border !== false) next = next.rematerializeLegendBackground();
       next = next
-        .editLegendSymbols()
-        .editLegendLabels();
-      if (config.titleVisible !== false) next = next.editLegendTitle();
+        .rematerializeLegendSymbols()
+        .rematerializeLegendLabels();
+      if (config.titleVisible !== false) next = next.rematerializeLegendTitle();
       const hasHighlight = Object.values(
         next.materializationConfigs.highlights ?? {}
       ).some(highlight => highlight.target === config.target);
@@ -170,13 +171,51 @@ export const createCategoricalLegend = action(
 export const createLegend = action(
   { op: "createLegend", description: "Create an inferred legend for selected channels." },
   function (args = {}) {
-    if (!isPlainObject(args)) {
-      throw new TypeError("createLegend options must be a plain object.");
-    }
+    validateOptionObject(args, undefined, "createLegend");
     const channels = args.channels;
     if (channels !== undefined && !Array.isArray(channels)) {
       throw new TypeError("createLegend channels must be an array.");
     }
+    const explicitSize = channels?.length === 1 && channels[0] === "size";
+    const requestedSizeLayer = args.target === undefined
+      ? undefined
+      : findLayer(this, args.target);
+    const sizeCandidates = this.semanticSpec.layers.filter(isSizeLegendPoint);
+    const hasNonSizeLegendEncoding = layer =>
+      ["color", "shape", "strokeDash", "opacity"].some(channel =>
+        layer.encoding?.[channel]?.scale !== undefined
+      );
+    const hasNonSizeLegendCandidate = this.semanticSpec.layers.some(
+      hasNonSizeLegendEncoding
+    );
+    const inferredSize = channels === undefined && (
+      (args.target !== undefined && isSizeLegendPoint(requestedSizeLayer) &&
+        !hasNonSizeLegendEncoding(requestedSizeLayer)) ||
+      (args.target === undefined && sizeCandidates.length === 1 &&
+        !hasNonSizeLegendCandidate)
+    );
+    if (explicitSize || inferredSize) {
+      const {
+        target,
+        count,
+        position,
+        channels: _channels,
+        ...unsupported
+      } = args;
+      const unsupportedKeys = Object.keys(unsupported);
+      if (unsupportedKeys.length > 0) {
+        throw new Error(
+          `Standalone size legend does not support option "${unsupportedKeys[0]}".`
+        );
+      }
+      if (position !== undefined && position !== "right") {
+        throw new Error('Standalone size legends currently require position "right".');
+      }
+      return this.createSizeLegend({
+        ...(target === undefined ? {} : { target }),
+        ...(count === undefined ? {} : { count })
+      });
+    }
     const opacityCandidates = this.semanticSpec.layers.filter(layer =>
       layer.mark?.type === "point" && layer.encoding?.opacity?.scale !== undefined
     );
@@ -193,7 +232,7 @@ export const createLegend = action(
       return this.createOpacityLegend(args);
     }
     const continuousColorCandidates = this.semanticSpec.layers.filter(layer => {
-      const encoding = ["point", "bar"].includes(layer.mark?.type)
+      const encoding = ["point", "bar", "rect"].includes(layer.mark?.type)
         ? layer.encoding?.color
         : undefined;
       const scale = findSemanticScale(this, encoding?.scale);

package/src/actions/guides/legends/categorical/components.js

@@ -3,14 +3,14 @@ import { activeConfig, graphic, noOptions, resolveLayout } from "./layout.js";
 import { resolveLegendGraphicPlacement } from
   "../../../../materialization/graphicHierarchy.js";
 
-export const editLegendLabels = action(
-  { op: "editLegendLabels", description: "Rematerialize categorical legend labels." },
+export const rematerializeLegendLabels = action(
+  { op: "rematerializeLegendLabels", description: "Rematerialize categorical legend labels." },
   function (args = {}) {
-    noOptions(args, "editLegendLabels");
+    noOptions(args, "rematerializeLegendLabels");
     const { config } = activeConfig(this);
     const id = graphic(config, "Labels");
     if (this.graphicSpec.objects[id]?.type !== "text") {
-      throw new Error("editLegendLabels requires existing legend labels.");
+      throw new Error("rematerializeLegendLabels requires existing legend labels.");
     }
     const layout = resolveLayout(this, config);
     return this
@@ -43,18 +43,18 @@ export const createLegendLabels = action(
         length: config.domain.length,
         ...resolveLegendGraphicPlacement(this)
       })
-      .editLegendLabels();
+      .rematerializeLegendLabels();
   }
 );
 
-export const editLegendTitle = action(
-  { op: "editLegendTitle", description: "Rematerialize the categorical legend title." },
+export const rematerializeLegendTitle = action(
+  { op: "rematerializeLegendTitle", description: "Rematerialize the categorical legend title." },
   function (args = {}) {
-    noOptions(args, "editLegendTitle");
+    noOptions(args, "rematerializeLegendTitle");
     const { config } = activeConfig(this);
     const id = graphic(config, "Title");
     if (this.graphicSpec.objects[id]?.type !== "text") {
-      throw new Error("editLegendTitle requires an existing legend title.");
+      throw new Error("rematerializeLegendTitle requires an existing legend title.");
     }
     const layout = resolveLayout(this, config);
     return this
@@ -92,21 +92,21 @@ export const createLegendTitle = action(
         type: "text",
         ...resolveLegendGraphicPlacement(this)
       })
-      .editLegendTitle();
+      .rematerializeLegendTitle();
   }
 );
 
-export const editLegendBackground = action(
-  { op: "editLegendBackground", description: "Rematerialize the legend background." },
+export const rematerializeLegendBackground = action(
+  { op: "rematerializeLegendBackground", description: "Rematerialize the legend background." },
   function (args = {}) {
-    noOptions(args, "editLegendBackground");
+    noOptions(args, "rematerializeLegendBackground");
     const { config } = activeConfig(this);
     if (config.border === false) {
-      throw new Error("editLegendBackground requires border configuration.");
+      throw new Error("rematerializeLegendBackground requires border configuration.");
     }
     const id = graphic(config, "Background");
     if (this.graphicSpec.objects[id]?.type !== "rect") {
-      throw new Error("editLegendBackground requires an existing background.");
+      throw new Error("rematerializeLegendBackground requires an existing background.");
     }
     const layout = resolveLayout(this, config).background;
     return this
@@ -135,6 +135,6 @@ export const createLegendBackground = action(
         type: "rect",
         ...resolveLegendGraphicPlacement(this)
       })
-      .editLegendBackground();
+      .rematerializeLegendBackground();
   }
 );

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

@@ -8,19 +8,19 @@ import {
   createLegendBackground,
   createLegendLabels,
   createLegendTitle,
-  editLegendBackground,
-  editLegendLabels,
-  editLegendTitle
+  rematerializeLegendBackground,
+  rematerializeLegendLabels,
+  rematerializeLegendTitle
 } from "./components.js";
 import {
   createLegendSymbolLines,
   createLegendSymbolPoints,
   createLegendSymbolSwatches,
   createLegendSymbols,
-  editLegendSymbolLines,
-  editLegendSymbolPoints,
-  editLegendSymbolSwatches,
-  editLegendSymbols,
+  rematerializeLegendSymbolLines,
+  rematerializeLegendSymbolPoints,
+  rematerializeLegendSymbolSwatches,
+  rematerializeLegendSymbols,
   rematerializeLegendHighlights
 } from "./symbols.js";
 import { editLegend } from "../edit.js";
@@ -31,19 +31,19 @@ export function registerCategoricalLegendActions(ProgramClass) {
   ProgramClass.prototype.createCategoricalLegend = createCategoricalLegend;
   ProgramClass.prototype.removeCategoricalLegend = removeCategoricalLegend;
   ProgramClass.prototype.createLegendBackground = createLegendBackground;
-  ProgramClass.prototype.editLegendBackground = editLegendBackground;
+  ProgramClass.prototype.rematerializeLegendBackground = rematerializeLegendBackground;
   ProgramClass.prototype.createLegendSymbols = createLegendSymbols;
-  ProgramClass.prototype.editLegendSymbols = editLegendSymbols;
+  ProgramClass.prototype.rematerializeLegendSymbols = rematerializeLegendSymbols;
   ProgramClass.prototype.rematerializeLegendHighlights = rematerializeLegendHighlights;
   ProgramClass.prototype.createLegendSymbolLines = createLegendSymbolLines;
-  ProgramClass.prototype.editLegendSymbolLines = editLegendSymbolLines;
+  ProgramClass.prototype.rematerializeLegendSymbolLines = rematerializeLegendSymbolLines;
   ProgramClass.prototype.createLegendSymbolPoints = createLegendSymbolPoints;
-  ProgramClass.prototype.editLegendSymbolPoints = editLegendSymbolPoints;
+  ProgramClass.prototype.rematerializeLegendSymbolPoints = rematerializeLegendSymbolPoints;
   ProgramClass.prototype.createLegendSymbolSwatches = createLegendSymbolSwatches;
-  ProgramClass.prototype.editLegendSymbolSwatches = editLegendSymbolSwatches;
+  ProgramClass.prototype.rematerializeLegendSymbolSwatches = rematerializeLegendSymbolSwatches;
   ProgramClass.prototype.createLegendLabels = createLegendLabels;
-  ProgramClass.prototype.editLegendLabels = editLegendLabels;
+  ProgramClass.prototype.rematerializeLegendLabels = rematerializeLegendLabels;
   ProgramClass.prototype.createLegendTitle = createLegendTitle;
-  ProgramClass.prototype.editLegendTitle = editLegendTitle;
+  ProgramClass.prototype.rematerializeLegendTitle = rematerializeLegendTitle;
   ProgramClass.prototype.rematerializeLegend = rematerializeLegend;
 }