ggaction 0.0.5 → 0.0.6

package/src/actions/gradientPlots/edit.js

@@ -1,20 +1,34 @@
 import { action } from "../../core/action.js";
 import { isPlainObject } from "../../core/immutable.js";
+import { validateUserId } from "../../core/identifiers.js";
 import { validateKeys } from "../../core/validation.js";
 import { planDerivedDataRevision } from "../../materialization/dataProvenance.js";
 import { findDataset } from "../../selectors/datasets.js";
 import { findLayer } from "../../selectors/layers.js";
+import { GRADIENT_PROFILE_FIELDS } from "../../grammar/gradientProfile.js";
 import { removeGradientPlotLegend } from "./components.js";
+import {
+  assertDistributionScaleHandoff,
+  clearCartesianPositions,
+  rebindDistributionGuides,
+  resolveDistributionScalePlan,
+  setCartesianPosition,
+  setCartesianRange
+} from "../distributions/revision.js";
 import {
   resolveGradientAppearance,
   resolveGradientCenter,
   resolveGradientDensity,
+  resolveGradientPosition,
   resolveGradientWidth
 } from "./options.js";
-import { resolveGradientOwner } from "./resolve.js";
+import {
+  normalizeGradientPositionTypes,
+  resolveGradientOwner
+} from "./resolve.js";
 
 const OPTIONS = Object.freeze([
-  "target", "density", "width", "gradient", "center"
+  "target", "data", "x", "y", "density", "width", "gradient", "center"
 ]);
 
 function patch(value, label) {
@@ -26,13 +40,224 @@ function patch(value, label) {
 
 function removeCenter(program, id) {
   let next = program;
+  const selections = Object.entries(
+    program.materializationConfigs.selections ?? {}
+  ).filter(([, config]) => config.target === id).map(([selection]) => selection);
+  for (const [highlight, config] of Object.entries(
+    program.materializationConfigs.highlights ?? {}
+  )) {
+    if (config.target === id || selections.includes(config.selection)) {
+      next = next._withoutMaterializationConfig(["highlights", highlight]);
+    }
+  }
+  for (const selection of selections) {
+    next = next._withoutMaterializationConfig(["selections", selection]);
+  }
   if (findLayer(next, id) !== undefined) {
     next = next.editSemantic({ property: `layer[${id}]`, remove: true });
   }
   if (next.graphicSpec.objects[id] !== undefined) {
     next = next.editGraphics({ target: id, remove: true });
   }
-  return next._withoutMaterializationConfig(["marks", id]);
+  return next
+    ._withoutMaterializationConfig(["marks", id])
+    ._withContext({
+      ...(program.context.currentMark === id ? { currentMark: undefined } : {}),
+      ...(selections.includes(program.context.currentSelection)
+        ? { currentSelection: undefined }
+        : {})
+    });
+}
+
+function currentGradientPositions(owner, current) {
+  const categoryChannel = current.orientation === "vertical" ? "x" : "y";
+  const measureChannel = current.orientation === "vertical" ? "y" : "x";
+  const categoryEncoding = owner.encoding[categoryChannel];
+  const measureEncoding = owner.encoding[measureChannel];
+  return {
+    x: current.orientation === "vertical"
+      ? {
+          field: current.category,
+          fieldType: current.categoryType,
+          scale: categoryEncoding.scale
+        }
+      : {
+          field: current.measure,
+          fieldType: "quantitative",
+          scale: measureEncoding.scale
+        },
+    y: current.orientation === "vertical"
+      ? {
+          field: current.measure,
+          fieldType: "quantitative",
+          scale: measureEncoding.scale
+        }
+      : {
+          field: current.category,
+          fieldType: current.categoryType,
+          scale: categoryEncoding.scale
+        },
+    categoryScale: categoryEncoding.scale,
+    measureScale: measureEncoding.scale
+  };
+}
+
+function requirePositionField(position, label) {
+  if (typeof position?.field !== "string" || position.field.length === 0) {
+    throw new TypeError(`${label} field must be a non-empty string.`);
+  }
+  return position;
+}
+
+function roleCandidate(program, owner, current, args) {
+  const previous = currentGradientPositions(owner, current);
+  const positions = normalizeGradientPositionTypes(
+    requirePositionField(
+      Object.hasOwn(args, "x")
+        ? resolveGradientPosition(args.x, "x", "editGradientPlot")
+        : previous.x,
+      "editGradientPlot x"
+    ),
+    requirePositionField(
+      Object.hasOwn(args, "y")
+        ? resolveGradientPosition(args.y, "y", "editGradientPlot")
+        : previous.y,
+      "editGradientPlot y"
+    )
+  );
+  if (positions.orientation === undefined) {
+    throw new Error(
+      "editGradientPlot requires one categorical axis and one quantitative axis."
+    );
+  }
+  const xRoleScale = positions.orientation === "vertical"
+    ? previous.categoryScale
+    : previous.measureScale;
+  const yRoleScale = positions.orientation === "vertical"
+    ? previous.measureScale
+    : previous.categoryScale;
+  const xScale = resolveDistributionScalePlan(program, {
+    channel: "x",
+    fieldType: positions.x.fieldType,
+    requested: positions.x.scale,
+    fallback: xRoleScale,
+    defaults: ["ordinal", "nominal"].includes(positions.x.fieldType)
+      ? { discreteType: "band" }
+      : {}
+  });
+  const yScale = resolveDistributionScalePlan(program, {
+    channel: "y",
+    fieldType: positions.y.fieldType,
+    requested: positions.y.scale,
+    fallback: yRoleScale,
+    defaults: ["ordinal", "nominal"].includes(positions.y.fieldType)
+      ? { discreteType: "band" }
+      : {}
+  });
+  return {
+    source: Object.hasOwn(args, "data")
+      ? validateUserId(args.data, "Gradient-plot data id")
+      : current.source,
+    orientation: positions.orientation,
+    x: { ...positions.x, scale: xScale.id },
+    y: { ...positions.y, scale: yScale.id },
+    xScale,
+    yScale,
+    category: positions.orientation === "vertical"
+      ? positions.x.field
+      : positions.y.field,
+    categoryType: positions.orientation === "vertical"
+      ? positions.x.fieldType
+      : positions.y.fieldType,
+    measure: positions.orientation === "vertical"
+      ? positions.y.field
+      : positions.x.field,
+    previous
+  };
+}
+
+function sameRoleCandidate(current, candidate) {
+  return candidate.source === current.source &&
+    candidate.orientation === current.orientation &&
+    candidate.category === current.category &&
+    candidate.categoryType === current.categoryType &&
+    candidate.measure === current.measure &&
+    candidate.xScale.id === candidate.previous.x.scale &&
+    candidate.yScale.id === candidate.previous.y.scale &&
+    candidate.xScale.edit === undefined &&
+    candidate.yScale.edit === undefined;
+}
+
+function updateGradientPositions(program, owner, current, candidate, hasCenter) {
+  const owned = [owner.id, ...(hasCenter ? [current.centerId] : [])];
+  assertDistributionScaleHandoff(program, {
+    owned,
+    oldXScale: candidate.previous.x.scale,
+    oldYScale: candidate.previous.y.scale,
+    newXScale: candidate.xScale.id,
+    newYScale: candidate.yScale.id
+  });
+  let next = program;
+  for (const id of owned) next = clearCartesianPositions(next, id);
+  for (const scale of [candidate.xScale, candidate.yScale]) {
+    if (scale.create) next = next.createScale(scale.definition);
+  }
+  const category = candidate.orientation === "vertical" ? candidate.x : candidate.y;
+  const measure = candidate.orientation === "vertical" ? candidate.y : candidate.x;
+  const categoryChannel = candidate.orientation === "vertical" ? "x" : "y";
+  const measureChannel = candidate.orientation === "vertical" ? "y" : "x";
+  next = setCartesianPosition(next, owner.id, categoryChannel, {
+    field: candidate.category,
+    fieldType: candidate.categoryType,
+    scale: category.scale
+  });
+  next = setCartesianRange(
+    next,
+    owner.id,
+    measureChannel,
+    GRADIENT_PROFILE_FIELDS.lower,
+    GRADIENT_PROFILE_FIELDS.upper,
+    measure.scale
+  );
+  if (hasCenter) {
+    next = setCartesianPosition(next, current.centerId, categoryChannel, {
+      field: candidate.category,
+      fieldType: candidate.categoryType,
+      scale: category.scale
+    });
+    next = setCartesianPosition(next, current.centerId, measureChannel, {
+      field: GRADIENT_PROFILE_FIELDS.center,
+      fieldType: "quantitative",
+      scale: measure.scale
+    })._withMarkConfig(current.centerId, {
+      ...next.markConfigs[current.centerId],
+      fixedSpan: {
+        ...next.markConfigs[current.centerId].fixedSpan,
+        orientation: candidate.orientation === "vertical"
+          ? "horizontal"
+          : "vertical"
+      }
+    });
+  }
+  for (const id of new Set([candidate.xScale.id, candidate.yScale.id])) {
+    next = next.rematerializeScale({ id, marks: false, guides: false });
+  }
+  next = rebindDistributionGuides(next, {
+    oldXScale: candidate.previous.x.scale,
+    oldYScale: candidate.previous.y.scale,
+    newXScale: candidate.xScale.id,
+    newYScale: candidate.yScale.id,
+    oldXTitle: candidate.previous.x.field,
+    oldYTitle: candidate.previous.y.field,
+    newXTitle: candidate.x.field,
+    newYTitle: candidate.y.field,
+    oldMeasureChannel: current.orientation === "vertical" ? "y" : "x",
+    newMeasureChannel: candidate.orientation === "vertical" ? "y" : "x"
+  });
+  for (const scale of [candidate.xScale, candidate.yScale]) {
+    if (scale.edit !== undefined) next = next.editScale(scale.edit);
+  }
+  return next;
 }
 
 export const editGradientPlot = action(
@@ -67,6 +292,129 @@ export const editGradientPlot = action(
           "editGradientPlot"
         )
       : current.center;
+    const candidate = roleCandidate(this, owner, current, args);
+    const sourceDataset = findDataset(this, candidate.source);
+    if (sourceDataset === undefined) {
+      throw new Error(`Unknown gradient-plot data "${candidate.source}".`);
+    }
+    const roleRequested = ["data", "x", "y"].some(
+      key => Object.hasOwn(args, key)
+    );
+    const changesRoles = !sameRoleCandidate(current, candidate);
+    if (changesRoles) {
+      const hadCenter = findLayer(this, current.centerId) !== undefined;
+      const revision = planDerivedDataRevision(this, {
+        owner: owner.id,
+        role: "ProfileData",
+        previous: current.profileId,
+        consumers: [owner.id, ...(hadCenter ? [current.centerId] : [])]
+      });
+      const applyEdit = program => {
+        let next = program.createGradientProfileData({
+          id: revision.id,
+          source: candidate.source,
+          category: candidate.category,
+          field: candidate.measure,
+          ...density,
+          center: center === false ? "median" : center.type
+        });
+        for (const rebind of revision.rebinds) {
+          next = next.rebindLayerData(rebind);
+        }
+        const profile = findDataset(next, revision.id);
+        next = next._withMarkConfig(owner.id, {
+          ...next.markConfigs[owner.id],
+          gradientPlot: {
+            ...current,
+            source: candidate.source,
+            orientation: candidate.orientation,
+            category: candidate.category,
+            categoryType: candidate.categoryType,
+            measure: candidate.measure,
+            density,
+            width,
+            gradient,
+            center,
+            profileId: revision.id,
+            intensityDomain: profile.transform[0].resolved.intensityDomain
+          }
+        });
+        if (center === false && hadCenter) {
+          next = removeCenter(next, current.centerId);
+        }
+        const retainedCenter = center !== false && hadCenter;
+        next = updateGradientPositions(
+          next,
+          owner,
+          current,
+          candidate,
+          retainedCenter
+        ).rematerializeRectMark({ id: owner.id });
+        const category = candidate.orientation === "vertical"
+          ? candidate.x
+          : candidate.y;
+        const measure = candidate.orientation === "vertical"
+          ? candidate.y
+          : candidate.x;
+        const categoryScale = next.resolvedScales[category.scale];
+        const spanSize = Math.max(
+          1,
+          categoryScale.bandwidth * width.band - 16
+        );
+        if (center !== false && !hadCenter) {
+          next = next.createGradientPlotCenter({
+            id: current.centerId,
+            owner: owner.id,
+            data: revision.id,
+            category: candidate.category,
+            categoryType: candidate.categoryType,
+            coordinate: owner.coordinate,
+            categoryScale: category.scale,
+            measureScale: measure.scale,
+            orientation: candidate.orientation,
+            size: spanSize,
+            stroke: center.stroke,
+            strokeWidth: center.strokeWidth
+          });
+        } else if (retainedCenter) {
+          next = next
+            .encodeStroke({ target: current.centerId, value: center.stroke })
+            .encodeStrokeWidth({
+              target: current.centerId,
+              value: center.strokeWidth
+            })
+            .materializeRuleSpan({
+              id: current.centerId,
+              orientation: candidate.orientation === "vertical"
+                ? "horizontal"
+                : "vertical",
+              size: spanSize
+            });
+        }
+        if (current.guides?.legend !== false && current.guides?.legend !== undefined) {
+          next = removeGradientPlotLegend(next, owner.id)
+            .createGradientPlotLegend({
+              owner: owner.id,
+              ...current.guides.legend
+            });
+        }
+        next = next.releaseDerivedData(revision.release);
+        return next._withContext({
+          currentMark: owner.id,
+          currentData: candidate.source
+        });
+      };
+      applyEdit(this);
+      return applyEdit(this);
+    }
+    if (roleRequested && !OPTIONS.slice(4).some(
+      key => Object.hasOwn(args, key)
+    )) {
+      return this._withContext({
+        currentMark: owner.id,
+        currentData: current.source
+      });
+    }
     const densityChanged = JSON.stringify(density) !== JSON.stringify(current.density);
     const centerTypeChanged = center !== false && current.center !== false &&
       center.type !== current.center.type;
@@ -131,7 +479,7 @@ export const editGradientPlot = action(
         .encodeStroke({ target: current.centerId, value: center.stroke })
         .encodeStrokeWidth({ target: current.centerId, value: center.strokeWidth });
     }
-    next = next.materializeGradientPlotFill({ id: owner.id });
+    next = next.rematerializeRectMark({ id: owner.id });
     if (center !== false && findLayer(next, current.centerId) !== undefined) {
       const categoryChannel = current.orientation === "vertical" ? "x" : "y";
       const categoryScale = next.resolvedScales[owner.encoding[categoryChannel].scale];

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

@@ -18,11 +18,19 @@ const TITLE_OPTIONS = Object.freeze([
   "text", "at", "offset", "rotation", "color", "fontSize",
   "fontFamily", "fontWeight"
 ]);
+const COMPONENTS = Object.freeze({
+  line: Object.freeze({ suffix: "Line", config: "line" }),
+  ticks: Object.freeze({ suffix: "Ticks", config: "ticks" }),
+  labels: Object.freeze({ suffix: "Labels", config: "labels" }),
+  title: Object.freeze({ suffix: "Title", config: "title" })
+});
 
-function validateNested(args, key, options, operation) {
+function validateNested(args, key, options, operation, { allowFalse = false } = {}) {
   if (!Object.hasOwn(args, key)) return;
+  if (allowFalse && args[key] === false) return;
   if (!isPlainObject(args[key])) {
-    throw new TypeError(`${operation}.${key} must be a plain object.`);
+    const accepted = allowFalse ? "false or a plain object" : "a plain object";
+    throw new TypeError(`${operation}.${key} must be ${accepted}.`);
   }
   validateKeys(args[key], options, `${operation}.${key}`);
 }
@@ -33,11 +41,12 @@ function validateArgs(args, operation) {
     emptyMessage: `${operation} requires at least one axis change.`,
     emptyError: Error
   });
-  validateNested(args, "line", LINE_OPTIONS, operation);
-  validateNested(args, "ticks", TICK_OPTIONS, operation);
-  validateNested(args, "labels", LABEL_OPTIONS, operation);
-  validateNested(args, "ticksAndLabels", GROUP_OPTIONS, operation);
-  validateNested(args, "title", TITLE_OPTIONS, operation);
+  const removable = { allowFalse: true };
+  validateNested(args, "line", LINE_OPTIONS, operation, removable);
+  validateNested(args, "ticks", TICK_OPTIONS, operation, removable);
+  validateNested(args, "labels", LABEL_OPTIONS, operation, removable);
+  validateNested(args, "ticksAndLabels", GROUP_OPTIONS, operation, removable);
+  validateNested(args, "title", TITLE_OPTIONS, operation, removable);
   if (args.ticksAndLabels !== undefined && (
     args.ticks !== undefined || args.labels !== undefined
   )) {
@@ -45,10 +54,10 @@ function validateArgs(args, operation) {
       `${operation} cannot combine ticksAndLabels with ticks or labels.`
     );
   }
-  if (args.ticksAndLabels?.ticks !== undefined) {
+  if (args.ticksAndLabels !== false && args.ticksAndLabels?.ticks !== undefined) {
     validateNested(args.ticksAndLabels, "ticks", ["length", "color", "lineWidth"], `${operation}.ticksAndLabels`);
   }
-  if (args.ticksAndLabels?.labels !== undefined) {
+  if (args.ticksAndLabels !== false && args.ticksAndLabels?.labels !== undefined) {
     validateNested(args.ticksAndLabels, "labels", [
       "offset", "format", "color", "fontSize", "fontFamily", "fontWeight"
     ], `${operation}.ticksAndLabels`);
@@ -63,10 +72,114 @@ function names(channel) {
     ticks: `edit${prefix}AxisTicks`,
     labels: `edit${prefix}AxisLabels`,
     group: `edit${prefix}AxisTicksAndLabels`,
-    title: `edit${prefix}AxisTitle`
+    title: `edit${prefix}AxisTitle`,
+    remove: `remove${prefix}Axis`
   };
 }
 
+function graphicId(channel, component) {
+  return `${channel}Axis${COMPONENTS[component].suffix}`;
+}
+
+function hasComponent(program, channel, component) {
+  return program.graphicSpec.objects[graphicId(channel, component)] !== undefined ||
+    program.guideConfigs.axis?.[channel]?.[COMPONENTS[component].config] !== undefined ||
+    (component === "title" &&
+      program.semanticSpec.guides.axis?.[channel]?.title !== undefined);
+}
+
+function assertRemovable(program, channel, component, operation) {
+  if (!hasComponent(program, channel, component)) {
+    throw new Error(
+      `${operation}.${component} requires an existing ${channel}-axis ${component}.`
+    );
+  }
+}
+
+function removeComponent(program, channel, component) {
+  const id = graphicId(channel, component);
+  let next = program;
+
+  if (
+    component === "title" &&
+    next.semanticSpec.guides.axis?.[channel]?.title !== undefined
+  ) {
+    next = next.editSemantic({
+      property: `guide.axis.${channel}.title`,
+      remove: true
+    });
+  }
+  if (next.graphicSpec.objects[id] !== undefined) {
+    next = next.editGraphics({ target: id, remove: true });
+  }
+  return next._withoutMaterializationConfig([
+    "guides", "axis", channel, COMPONENTS[component].config
+  ]);
+}
+
+function buildPlan(program, channel, args, operation) {
+  const shared = Object.hasOwn(args, "position")
+    ? { position: args.position }
+    : {};
+  const plan = [];
+  const addLeaf = (component, edit) => {
+    const value = args[component];
+    if (value === false) {
+      assertRemovable(program, channel, component, operation.operation);
+      plan.push({ kind: "remove", component });
+    } else if (value !== undefined) {
+      plan.push({ kind: "edit", operation: edit, args: { ...shared, ...value } });
+    } else if (args.position !== undefined && hasComponent(program, channel, component)) {
+      plan.push({ kind: "edit", operation: edit, args: shared });
+    }
+  };
+
+  addLeaf("line", operation.line);
+  if (args.ticksAndLabels === false) {
+    assertRemovable(program, channel, "ticks", operation.operation);
+    assertRemovable(program, channel, "labels", operation.operation);
+    plan.push(
+      { kind: "remove", component: "ticks" },
+      { kind: "remove", component: "labels" }
+    );
+  } else if (args.ticksAndLabels !== undefined) {
+    plan.push({
+      kind: "edit",
+      operation: operation.group,
+      args: { ...shared, ...args.ticksAndLabels }
+    });
+  } else {
+    addLeaf("ticks", operation.ticks);
+    addLeaf("labels", operation.labels);
+  }
+  addLeaf("title", operation.title);
+
+  if (plan.length === 0) {
+    throw new Error(`${operation.operation} requires an existing ${channel}-axis component.`);
+  }
+  return plan;
+}
+
+function applyPlan(program, channel, plan, operation) {
+  let next = program;
+  for (const step of plan) {
+    next = step.kind === "remove"
+      ? removeComponent(next, channel, step.component)
+      : next[step.operation](step.args);
+  }
+
+  const hasRetainedGraphic = Object.keys(COMPONENTS).some(
+    component => next.graphicSpec.objects[graphicId(channel, component)] !== undefined
+  );
+  if (!hasRetainedGraphic && (
+    next.semanticSpec.guides.axis?.[channel] !== undefined ||
+    next.guideConfigs.axis?.[channel] !== undefined
+  )) {
+    next = next[operation.remove]();
+  }
+  return next;
+}
+
 function makeEditAxis(channel) {
   const operation = names(channel);
   return action(
@@ -76,43 +189,12 @@ function makeEditAxis(channel) {
     },
     function (args = {}) {
       validateArgs(args, operation.operation);
-      const shared = Object.hasOwn(args, "position")
-        ? { position: args.position }
-        : {};
-      const has = id => this.graphicSpec.objects[id] !== undefined;
-      let next = this;
-
-      if (args.line !== undefined || (args.position !== undefined && has(`${channel}AxisLine`))) {
-        next = next[operation.line]({ ...shared, ...(args.line ?? {}) });
-      }
-
-      if (args.ticksAndLabels !== undefined) {
-        next = next[operation.group]({
-          ...shared,
-          ...args.ticksAndLabels
-        });
-      } else if (args.ticks !== undefined || args.labels !== undefined) {
-        if (args.ticks !== undefined) {
-          next = next[operation.ticks]({ ...shared, ...args.ticks });
-        }
-        if (args.labels !== undefined) {
-          next = next[operation.labels]({ ...shared, ...args.labels });
-        }
-      } else if (args.position !== undefined) {
-        const hasTicks = has(`${channel}AxisTicks`);
-        const hasLabels = has(`${channel}AxisLabels`);
-        if (hasTicks && hasLabels) {
-          next = next[operation.group](shared);
-        } else {
-          if (hasTicks) next = next[operation.ticks](shared);
-          if (hasLabels) next = next[operation.labels](shared);
-        }
-      }
-
-      if (args.title !== undefined || (args.position !== undefined && has(`${channel}AxisTitle`))) {
-        next = next[operation.title]({ ...shared, ...(args.title ?? {}) });
-      }
-      return next;
+      const plan = buildPlan(this, channel, args, operation);
+
+      // Run the complete proposal against an immutable speculative branch so a
+      // later leaf failure cannot begin the returned action trace or state.
+      applyPlan(this, channel, plan, operation);
+      return applyPlan(this, channel, plan, operation);
     }
   );
 }

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

@@ -360,14 +360,25 @@ export const createLegend = action(
         symbol
       });
       if (requestedPoint.encoding?.size?.scale !== undefined) {
-        next = next.createSizeLegend({
-          target: requestedPoint.id,
-          ...(count === undefined ? {} : { count }),
-          inheritAppearance:
-            categoricalArgs.position === "left" ||
-            categoricalArgs.labels !== undefined ||
-            categoricalArgs.titleStyle !== undefined
-        });
+        const existingSize = next.guideConfigs.legend?.size;
+        if (existingSize === undefined) {
+          next = next.createSizeLegend({
+            target: requestedPoint.id,
+            ...(count === undefined ? {} : { count }),
+            inheritAppearance:
+              categoricalArgs.position === "left" ||
+              categoricalArgs.labels !== undefined ||
+              categoricalArgs.titleStyle !== undefined
+          });
+        } else if (existingSize.target !== requestedPoint.id) {
+          throw new Error(
+            "Combined point series legend requires the active size legend to share its target."
+          );
+        } else if (count !== undefined && count !== existingSize.count) {
+          throw new Error(
+            "Existing size legend count must be edited before recreating the categorical block."
+          );
+        }
         next = next.rematerializeLegend();
       }
       return next;

package/src/actions/guides/legends/continuous/common.js

@@ -49,7 +49,7 @@ const DEFAULT_BORDER = Object.freeze({
 export const validatePositive = validatePositiveFinite;
 export const validateNonNegative = validateNonNegativeFinite;
 
-function validateTextOptions(value, label, defaults) {
+export function normalizeLegendTextOptions(value, label, defaults) {
   if (value === undefined) return { ...defaults };
   if (!isPlainObject(value)) {
     throw new TypeError(`${label} must be a plain object.`);
@@ -132,12 +132,12 @@ export function normalizeContinuousLegend(args, kind) {
     count,
     title: args.title,
     inferredTitle: args.title === undefined,
-    labels: validateTextOptions(
+    labels: normalizeLegendTextOptions(
       args.labels,
       "createLegend.labels",
       DEFAULT_LABELS
     ),
-    titleStyle: validateTextOptions(
+    titleStyle: normalizeLegendTextOptions(
       args.titleStyle,
       "createLegend.titleStyle",
       DEFAULT_TITLE