ggaction 0.0.12 → 0.0.15

package/src/actions/scales/editPolicy.js

@@ -1,8 +1,10 @@
+import { validateContinuousColorConsumer } from "../../grammar/scales/colorConsumers.js";
 import {
   hasOrdinalDomain,
   isDiscretizedColorScaleType,
   isDiscretePositionScaleType,
   isTransformedScaleType,
+  normalizeSizeScaleDefinition,
   normalizeScaleDefinition,
   SCALE_ROLES,
   validateColorRange,
@@ -14,6 +16,7 @@ import {
   validateScaleType,
   validateScaleTypeForRole,
   validateScaleUnknown,
+  validateSequentialMidpoint,
   validateSequentialColorRange,
   validateShapeRange,
   validateSizeRange,
@@ -24,11 +27,20 @@ import {
   validateRadialRange,
   validateThetaRange
 } from "../../grammar/polar.js";
-import { normalizePositionScaleChannel } from "../../core/vocabulary.js";
+import {
+  normalizePositionScaleChannel,
+  OFFSET_POSITION_CHANNELS
+} from "../../core/vocabulary.js";
+import { normalizeOffsetScalePolicy } from "../../grammar/bars/geometry.js";
+import { resolveRequestedOffsetPolicy } from
+  "../../materialization/scales/policies/offset.js";
 
 export function resolveScaleConsumerChannel(consumers, id) {
   const channels = new Set(
-    consumers.map(consumer => normalizePositionScaleChannel(consumer.channel))
+    consumers.map(consumer => {
+      const channel = normalizePositionScaleChannel(consumer.channel);
+      return channel === "stroke" ? "color" : channel;
+    })
   );
   if (channels.size > 1) {
     throw new Error(`Scale "${id}" cannot be shared across channels.`);
@@ -38,6 +50,7 @@ export function resolveScaleConsumerChannel(consumers, id) {
 
 function validateRangeForChannel(scale, channel, value) {
   if (value === "auto") return value;
+  if (channel === "size") return validateSizeRange(value);
   if (channel === "theta") return validateThetaRange(value);
   if (channel === "radius") return validateRadialRange(value);
   if (scale.type === "sequential") {
@@ -47,7 +60,7 @@ function validateRangeForChannel(scale, channel, value) {
     return validateDiscretizedColorRange(value);
   }
   if (scale.type !== "ordinal") return validateScaleRange(value);
-  if (channel === "color") return validateColorRange(value);
+  if (["color", "stroke"].includes(channel)) return validateColorRange(value);
   if (channel === "shape") return validateShapeRange(value);
   if (channel === "strokeDash") return validateStrokeDashRange(value);
   if (channel === "size") return validateSizeRange(value);
@@ -60,17 +73,26 @@ function validateTypeTransition(scale, nextType, channel, consumers) {
   validateScaleType(nextType);
   if (consumers.length === 0) return;
   if (nextType === "sequential" || isDiscretizedColorScaleType(nextType)) {
-    const discretized = isDiscretizedColorScaleType(nextType);
-    if (channel !== "color" || consumers.some(consumer =>
-      ["nominal", "ordinal"].includes(consumer.encoding.fieldType) ||
-      (discretized && (
-        consumer.encoding.fieldType !== "quantitative" ||
-        consumer.layer.mark?.type !== "point"
-      )) ||
-      (!discretized && !["point", "bar"].includes(consumer.layer.mark?.type))
+    if (channel !== "color") {
+      throw new Error(`Scale "${scale.id}" has a consumer incompatible with type "${nextType}".`);
+    }
+    for (const consumer of consumers) {
+      validateContinuousColorConsumer(
+        consumer.layer,
+        consumer.encoding,
+        { type: nextType },
+        { channel: consumer.channel }
+      );
+    }
+    return;
+  }
+  if (nextType === "ordinal" && channel === "color") {
+    if (consumers.some(consumer =>
+      !["color", "stroke"].includes(consumer.channel) ||
+      !["nominal", "ordinal"].includes(consumer.encoding.fieldType)
     )) {
       throw new Error(
-        `Scale "${scale.id}" has a consumer incompatible with type "${nextType}".`
+        `Scale "${scale.id}" has a consumer incompatible with type "ordinal".`
       );
     }
     return;
@@ -132,33 +154,65 @@ function validateTypeTransition(scale, nextType, channel, consumers) {
   }
 }
 
-function validateLegendTypeTransition(program, scale, nextType) {
-  if (nextType === scale.type) return;
-  const legends = program.guideConfigs.legend ?? {};
-  if (legends.gradient?.scale === scale.id && nextType !== "sequential") {
-    throw new Error(
-      `Scale "${scale.id}" cannot change type while its gradient legend is active.`
-    );
+function normalizeDefinition(program, scale, channel, consumers, patch) {
+  if (scale.radialMapping !== undefined && Object.hasOwn(patch, "radialMapping") &&
+    patch.radialMapping === undefined && consumers.some(consumer => consumer.encoding.aggregate !== undefined)) {
+    throw new Error("Remove measured radius encodings before clearing their scale mapping.");
   }
-  if (
-    legends.interval?.scale === scale.id &&
-    !isDiscretizedColorScaleType(nextType)
-  ) {
-    throw new Error(
-      `Scale "${scale.id}" cannot change type while its interval legend is active.`
-    );
+  if (channel === "size") {
+    if (consumers.some(consumer =>
+      consumer.layer.mark?.type !== "point" ||
+      consumer.encoding.fieldType !== "quantitative"
+    )) {
+      throw new Error(
+        `Scale "${scale.id}" has a consumer incompatible with size mapping.`
+      );
+    }
+    return normalizeSizeScaleDefinition({ previous: scale, patch });
   }
-}
-
-function normalizeDefinition(scale, channel, consumers, patch) {
   const type = patch.type ?? scale.type;
   validateTypeTransition(scale, type, channel, consumers);
+  const offset = OFFSET_POSITION_CHANNELS.includes(channel);
+  if (offset && Object.hasOwn(patch, "range")) {
+    throw new Error(
+      `${channel} scale range is derived from its parent categorical slot.`
+    );
+  }
+  if (offset && Object.hasOwn(patch, "unknown")) {
+    throw new Error(`${channel} scale unknown is not supported for offset positions.`);
+  }
+  if (type !== scale.type && scale.domain !== "auto" && !Object.hasOwn(patch, "domain") &&
+    (["quantile", "threshold"].includes(type) || ["quantile", "threshold"].includes(scale.type))) {
+    throw new Error("Color scale type transition requires an explicit domain when its meaning changes.");
+  }
+  const offsetPolicy = offset
+    ? normalizeOffsetScalePolicy(
+        patch,
+        resolveRequestedOffsetPolicy({
+          scale,
+          consumers,
+          markConfigs: program.markConfigs,
+          id: scale.id,
+          channel
+        }),
+        channel
+      )
+    : undefined;
+  const normalizedPatch = offset
+    ? {
+        ...Object.fromEntries(Object.entries(patch).filter(
+          ([property]) => property !== "padding"
+        )),
+        ...offsetPolicy
+      }
+    : patch;
   const definition = normalizeScaleDefinition({
     type,
     previous: scale,
-    patch,
+    patch: normalizedPatch,
     retainCoreOnTypeChange: true,
     retainCompatibleOnTypeChange: true,
+    allowOrdinalBandParameters: offset,
     validateDomain: (scaleType, value) =>
       isDiscretizedColorScaleType(scaleType)
         ? validateDiscretizedColorDomain(scaleType, value)
@@ -175,9 +229,16 @@ function normalizeDefinition(scale, channel, consumers, patch) {
   ) {
     throw new RangeError("StrokeWidth scale domain cannot contain negative values.");
   }
+  validateSequentialMidpoint(definition.midpoint, type, definition.domain);
+  if (definition.midpoint !== undefined && consumers.some(
+    consumer => !["color", "stroke"].includes(consumer.channel) ||
+      consumer.encoding.fieldType !== "quantitative"
+  )) {
+    throw new Error("Scale midpoint requires quantitative color consumers.");
+  }
   const typeChanged = type !== scale.type;
-  const unknown = Object.hasOwn(patch, "unknown")
-    ? patch.unknown
+  const unknown = Object.hasOwn(normalizedPatch, "unknown")
+    ? normalizedPatch.unknown
     : typeChanged ? undefined : scale.unknown;
   if (unknown !== undefined) {
     if (consumers.some(consumer => consumer.layer.mark?.type !== "point")) {
@@ -197,7 +258,7 @@ export function prepareScaleEdit(program, scale, channel, consumers, args) {
   }
   if (
     hasPalette &&
-    channel !== "color" &&
+    !["color", "stroke"].includes(channel) &&
     scale.type !== "sequential" &&
     !isDiscretizedColorScaleType(scale.type)
   ) {
@@ -209,6 +270,5 @@ export function prepareScaleEdit(program, scale, channel, consumers, args) {
         ...Object.entries(args).filter(([key]) => key !== "palette"),
         ["range", { palette: args.palette }]
       ]);
-  validateLegendTypeTransition(program, scale, args.type ?? scale.type);
-  return normalizeDefinition(scale, channel, consumers, patch);
+  return normalizeDefinition(program, scale, channel, consumers, patch);
 }

package/src/actions/scales/index.js

@@ -2,9 +2,15 @@ import { createScale } from "./create.js";
 import { editScale } from "./edit.js";
 import { rematerializeScale } from "./materialize.js";
 import { setQuantitativeColorScale } from "./quantitativeColor.js";
+import { registerChannelScaleActions } from "./channels.js";
+import { editParallelScale } from "./parallel.js";
+import { registerOffsetScaleActions } from "./offset.js";
 
 export function registerScaleActions(ProgramClass) {
   ProgramClass.prototype.editScale = editScale;
+  ProgramClass.prototype.editParallelScale = editParallelScale;
+  registerOffsetScaleActions(ProgramClass);
+  registerChannelScaleActions(ProgramClass);
   registerBasicScaleActions(ProgramClass);
 }
 

package/src/actions/scales/materialize.js

@@ -1,8 +1,9 @@
+import { isPendingMeasuredRadiusConsumer } from "../../materialization/scales/policies/arc.js";
+import { findScale, findScaleConsumers } from "./consumers/index.js";
+import { resolveScalePreview, validatePendingMeasuredScale } from "./preview.js";
 import { action } from "../../core/action.js";
 import { validateUserId } from "../../core/identifiers.js";
-import { normalizePositionScaleChannel } from "../../core/vocabulary.js";
 import { validateKeys } from "../../core/validation.js";
-import { resolveGraphicBounds } from "../../layout/canvas.js";
 import {
   applyMaterializationPlan,
   planScaleGuideRematerialization
@@ -14,16 +15,6 @@ import {
 } from "../../materialization/marks/index.js";
 import { mapScaleConsumerValues } from
   "../../materialization/scales/map.js";
-import { resolveScaleMaterialization } from
-  "../../materialization/scales/resolve.js";
-import {
-  findScale,
-  findScaleConsumers,
-  resolveConsumerCategoryOrder,
-  resolveConsumerValues,
-  resolveSeriesLayoutScaleValues
-} from "./consumers/index.js";
-
 const OPTIONS = Object.freeze(["id", "guides", "marks"]);
 
 function validateOptions(args) {
@@ -36,16 +27,6 @@ function validateOptions(args) {
   }
 }
 
-function resolveScaleChannel(id, consumers) {
-  const channels = new Set(
-    consumers.map(consumer => normalizePositionScaleChannel(consumer.channel))
-  );
-  if (channels.size !== 1) {
-    throw new Error(`Scale "${id}" cannot be shared across channels.`);
-  }
-  return normalizePositionScaleChannel(consumers[0].channel);
-}
-
 export const rematerializeScale = action(
   {
     op: "rematerializeScale",
@@ -54,31 +35,14 @@ export const rematerializeScale = action(
   function (args = {}) {
     validateOptions(args);
     const id = validateUserId(args.id, "Scale id");
-    const scale = findScale(this, id);
+    const semanticScale = findScale(this, id);
     const consumers = findScaleConsumers(this, id);
-    if (consumers.length === 0) {
-      throw new Error(`Scale "${id}" has no supported consumers.`);
+    if (semanticScale.radialMapping !== undefined && consumers.length > 0 &&
+      consumers.every(isPendingMeasuredRadiusConsumer)) {
+      validatePendingMeasuredScale(this, semanticScale, consumers);
+      return this._withoutResolvedScale(id);
     }
-    const channel = resolveScaleChannel(id, consumers);
-    const valuesByConsumer = consumers.map(consumer => ({
-      consumer,
-      values: resolveConsumerValues(this, consumer),
-      categoryOrder: resolveConsumerCategoryOrder(this, consumer),
-      seriesLayout: resolveSeriesLayoutScaleValues(this, consumer)
-    }));
-    const resolvedScale = resolveScaleMaterialization({
-      id,
-      scale,
-      channel,
-      consumers,
-      valuesByConsumer,
-      bounds: ["color", "strokeDash", "strokeWidth", "shape", "size", "opacity", "xOffset", "yOffset"]
-        .includes(channel)
-        ? undefined
-        : resolveGraphicBounds(this),
-      resolvedScales: this.resolvedScales,
-      markConfigs: this.markConfigs
-    });
+    const { channel, valuesByConsumer, resolvedScale } = resolveScalePreview(this, id);
     let next = this._withResolvedScale(id, resolvedScale);
 
     for (const { consumer, values } of valuesByConsumer) {
@@ -88,13 +52,14 @@ export const rematerializeScale = action(
       ) {
         continue;
       }
+      const consumerChannel = consumer.channel;
       const materializationMode = getScaleConsumerMaterializationMode(
         consumer.layer,
-        channel
+        consumerChannel
       );
       if (materializationMode === "rematerialize") {
         if (args.marks !== false) {
-          const step = getMarkRematerializationStep(consumer.layer);
+          const step = getMarkRematerializationStep(this, consumer.layer);
           if (step !== undefined) next = next[step.op](step.args);
         }
         continue;
@@ -107,8 +72,8 @@ export const rematerializeScale = action(
       }
       next = next.editGraphics({
         target: consumer.layer.id,
-        property: channel === "color" ? "fill" : channel,
-        value: mapScaleConsumerValues(values, resolvedScale, channel)
+        property: consumerChannel === "color" ? "fill" : consumerChannel,
+        value: mapScaleConsumerValues(values, resolvedScale, consumerChannel)
       });
     }
 

package/src/actions/scales/offset.js

@@ -0,0 +1,48 @@
+import { action } from "../../core/action.js";
+import { validateUserId } from "../../core/identifiers.js";
+import { validateOptionObject } from "../../core/validation.js";
+import { requireLayer } from "../../selectors/layers.js";
+import { requireSemanticScale } from "../../selectors/scales.js";
+
+const EDITABLE = Object.freeze([
+  "domain", "reverse", "padding", "paddingInner", "paddingOuter", "align"
+]);
+
+function createOffsetScaleEditor(channel) {
+  const operation = channel === "xOffset"
+    ? "editXOffsetScale"
+    : "editYOffsetScale";
+  return action(
+    {
+      op: operation,
+      description: `Edit the nested ${channel} scale for one mark.`
+    },
+    function (args = {}) {
+      validateOptionObject(args, ["target", ...EDITABLE], operation);
+      const target = validateUserId(args.target, `${operation} target`);
+      if (!EDITABLE.some(property => Object.hasOwn(args, property))) {
+        throw new Error(`${operation} requires at least one editable property.`);
+      }
+      const layer = requireLayer(this, target, `${operation} target "${target}"`);
+      const scaleId = layer.encoding?.[channel]?.scale;
+      if (typeof scaleId !== "string") {
+        throw new Error(
+          `${operation} target "${target}" has no ${channel} scale.`
+        );
+      }
+      requireSemanticScale(this, scaleId);
+      const patch = Object.fromEntries(Object.entries(args).filter(
+        ([property]) => property !== "target"
+      ));
+      return this.editScale({ id: scaleId, ...patch });
+    }
+  );
+}
+
+export const editXOffsetScale = createOffsetScaleEditor("xOffset");
+export const editYOffsetScale = createOffsetScaleEditor("yOffset");
+
+export function registerOffsetScaleActions(ProgramClass) {
+  ProgramClass.prototype.editXOffsetScale = editXOffsetScale;
+  ProgramClass.prototype.editYOffsetScale = editYOffsetScale;
+}

package/src/actions/scales/parallel.js

@@ -0,0 +1,71 @@
+import { action } from "../../core/action.js";
+import { validateUserId } from "../../core/identifiers.js";
+import { validateOptionObject } from "../../core/validation.js";
+import { findCoordinate } from "../../selectors/coordinates.js";
+import { requireLayer } from "../../selectors/layers.js";
+import { requireSemanticScale } from "../../selectors/scales.js";
+
+const QUANTITATIVE_OPTIONS = Object.freeze([
+  "type", "domain", "range", "nice", "zero", "clamp", "reverse",
+  "base", "exponent", "constant", "unknown"
+]);
+const ORDINAL_OPTIONS = Object.freeze([
+  "type", "domain", "range", "reverse", "padding", "align", "unknown"
+]);
+const ALL_OPTIONS = Object.freeze([
+  "target", "dimension",
+  ...new Set([...QUANTITATIVE_OPTIONS, ...ORDINAL_OPTIONS])
+]);
+
+function resolveParallelDimension(program, args) {
+  validateOptionObject(args, ALL_OPTIONS, "editParallelScale");
+  const target = validateUserId(args.target, "Parallel scale target");
+  if (typeof args.dimension !== "string" || args.dimension.length === 0) {
+    throw new TypeError("Parallel scale dimension must be a non-empty field string.");
+  }
+  const layer = requireLayer(program, target, `Parallel scale target "${target}"`);
+  if (
+    findCoordinate(program, layer.coordinate)?.type !== "parallel" ||
+    !Array.isArray(layer.encoding?.parallel?.dimensions)
+  ) {
+    throw new Error(`Parallel scale target "${target}" is not a Parallel layer.`);
+  }
+  const matches = layer.encoding.parallel.dimensions.filter(
+    dimension => dimension.field === args.dimension
+  );
+  if (matches.length !== 1) {
+    throw new Error(
+      matches.length === 0
+        ? `Parallel scale target "${target}" has no dimension field "${args.dimension}".`
+        : `Parallel scale dimension field "${args.dimension}" is ambiguous on target "${target}".`
+    );
+  }
+  const dimension = matches[0];
+  requireSemanticScale(program, dimension.scale);
+  return dimension;
+}
+
+export const editParallelScale = action(
+  {
+    op: "editParallelScale",
+    description: "Edit a Parallel-coordinate dimension scale by field identity."
+  },
+  function (args = {}) {
+    const dimension = resolveParallelDimension(this, args);
+    const editable = dimension.fieldType === "quantitative"
+      ? QUANTITATIVE_OPTIONS
+      : ORDINAL_OPTIONS;
+    validateOptionObject(
+      args,
+      ["target", "dimension", ...editable],
+      "editParallelScale"
+    );
+    if (!editable.some(property => Object.hasOwn(args, property))) {
+      throw new Error("editParallelScale requires at least one editable property.");
+    }
+    const patch = Object.fromEntries(Object.entries(args).filter(
+      ([property]) => !["target", "dimension"].includes(property)
+    ));
+    return this.editScale({ id: dimension.scale, ...patch });
+  }
+);

package/src/actions/scales/patch.js

@@ -1,7 +1,7 @@
 const SCALE_EDIT_PROPERTIES = Object.freeze([
   "type", "domain", "range", "nice", "zero", "clamp", "reverse",
   "base", "exponent", "constant", "paddingInner", "paddingOuter",
-  "padding", "align", "interpolate", "unknown"
+  "padding", "align", "interpolate", "midpoint", "unknown"
 ]);
 
 function sameValue(left, right) {

package/src/actions/scales/preview.js

@@ -0,0 +1,140 @@
+import { resolveScaleRange } from "../../grammar/scales/index.js";
+import { resolvePolarFrame } from "../../grammar/polar.js";
+import { resolveArcAutoPositionRange, validateMeasuredRadiusConsumers } from "../../materialization/scales/policies/arc.js";
+import { findSemanticScale } from "../../selectors/scales.js";
+import { normalizePositionScaleChannel } from "../../core/vocabulary.js";
+import { resolveGraphicBounds } from "../../layout/canvas.js";
+import {
+  resolveDataAspectScalePair,
+  resolveScaleConsumerBounds
+} from "../../materialization/coordinateBounds.js";
+import { requireCoordinate } from "../../selectors/coordinates.js";
+import { resolveScaleMaterialization } from "../../materialization/scales/resolve.js";
+import { findScale, findScaleConsumers, resolveConsumerCategoryOrder,
+  resolveConsumerValues, resolveSeriesLayoutScaleValues } from "./consumers/index.js";
+
+function resolveScalePreviewAtBounds(program, id, bounds) {
+  const scale = findScale(program, id);
+  const consumers = findScaleConsumers(program, id);
+  if (consumers.length === 0) throw new Error(`Scale "${id}" has no supported consumers.`);
+  const consumerChannels = new Set(consumers.map(
+    consumer => normalizePositionScaleChannel(consumer.channel)
+  ));
+  const families = new Set([...consumerChannels].map(
+    channel => channel === "stroke" ? "color" : channel
+  ));
+  if (families.size !== 1) {
+    throw new Error(`Scale "${id}" cannot be shared across channels.`);
+  }
+  const channel = consumerChannels.size === 1
+    ? consumerChannels.values().next().value
+    : families.values().next().value;
+  const valuesByConsumer = consumers.map(consumer => {
+    if (
+      program.markConfigs?.[consumer.layer.id]?.markFilter?.empty === true ||
+      program.markConfigs?.[consumer.layer.id]?.statisticalReference !== undefined
+    ) {
+      return {
+        consumer,
+        values: [],
+        categoryOrder: undefined,
+        seriesLayout: undefined,
+        ...(program.markConfigs?.[consumer.layer.id]?.statisticalReference === undefined
+          ? {}
+          : { scalePolicy: false })
+      };
+    }
+    return { consumer,
+      values: resolveConsumerValues(program, consumer),
+      categoryOrder: resolveConsumerCategoryOrder(program, consumer),
+      seriesLayout: resolveSeriesLayoutScaleValues(program, consumer) };
+  });
+  const polarFrame = channel === "radius"
+    ? resolveSharedRadiusFrame(program, consumers, bounds)
+    : undefined;
+  const resolvedScale = resolveScaleMaterialization({ id, scale, channel, consumers, valuesByConsumer,
+    bounds: ["color", "stroke", "strokeDash", "strokeWidth", "shape", "size", "opacity", "xOffset", "yOffset"].includes(channel)
+      ? undefined : bounds,
+    resolvedScales: program.resolvedScales, markConfigs: program.markConfigs, polarFrame,
+    thetaScales: scale.radialMapping === undefined ? undefined : Object.fromEntries(consumers.map(({ layer }) =>
+      [layer.id, findSemanticScale(program, layer.encoding?.theta?.scale)])) });
+  return { channel, consumers, valuesByConsumer, resolvedScale };
+}
+
+function resolveSharedRadiusFrame(program, consumers, bounds) {
+  const coordinateIds = [...new Set(consumers.map(({ layer }) => layer.coordinate))];
+  if (coordinateIds.some(id => id === undefined)) {
+    throw new Error("Radius scale consumers require stored Polar coordinates.");
+  }
+  const frames = coordinateIds.map(id => {
+    const coordinate = requireCoordinate(program, id);
+    if (coordinate.type !== "polar") {
+      throw new Error("Radius scale consumers require Polar coordinates.");
+    }
+    return resolvePolarFrame(bounds, coordinate.polarFrame);
+  });
+  if (frames.slice(1).some(
+    frame => Math.abs(frame.availableRadius - frames[0].availableRadius) > 1e-9
+  )) {
+    throw new Error(
+      "A radius scale cannot be shared across coordinates with different Polar frames."
+    );
+  }
+  return frames[0];
+}
+
+function dataAspectScaleIds(program) {
+  const ids = new Set();
+  for (const coordinate of program.semanticSpec.coordinates) {
+    if (coordinate.aspect?.mode !== "data") continue;
+    const pair = resolveDataAspectScalePair(program, coordinate);
+    ids.add(pair.x);
+    ids.add(pair.y);
+  }
+  return ids;
+}
+
+export function resolveScalePreview(program, id) {
+  const requestedConsumers = findScaleConsumers(program, id);
+  const positionChannels = new Set([
+    "x", "y", "x2", "y2", "theta", "radius"
+  ]);
+  const positional = requestedConsumers.some(consumer =>
+    consumer.role === "parallelDimension" ||
+    positionChannels.has(consumer.channel)
+  );
+  const allocated = positional ? resolveGraphicBounds(program) : undefined;
+  const provisional = resolveScalePreviewAtBounds(program, id, allocated);
+  if (!positional) return provisional;
+  const resolvedScales = {
+    ...program.resolvedScales,
+    [id]: provisional.resolvedScale
+  };
+  for (const scaleId of dataAspectScaleIds(program)) {
+    if (scaleId === id) continue;
+    resolvedScales[scaleId] = resolveScalePreviewAtBounds(
+      program,
+      scaleId,
+      allocated
+    ).resolvedScale;
+  }
+  const bounds = resolveScaleConsumerBounds(
+    program,
+    provisional.consumers,
+    { resolvedScales }
+  );
+  return resolveScalePreviewAtBounds(program, id, bounds);
+}
+
+export function validatePendingMeasuredScale(program, scale, consumers) {
+  const bounds = resolveScaleConsumerBounds(program, consumers);
+  const range = resolveArcAutoPositionRange({ consumers, scale, channel: "radius",
+    range: resolveScaleRange(
+      scale.range,
+      "radius",
+      bounds,
+      resolveSharedRadiusFrame(program, consumers, bounds)
+    ), markConfigs: program.markConfigs });
+  validateMeasuredRadiusConsumers({ scale, domain: scale.domain, range, consumers,
+    markConfigs: program.markConfigs, thetaScales: {} });
+}

package/src/actions/scales/quantitativeColor.js

@@ -7,7 +7,7 @@ const OPTIONS = Object.freeze([
   "type",
   "domain",
   "range",
-  "interpolate",
+  "interpolate", "midpoint",
   "clamp",
   "reverse",
   "unknown"
@@ -25,13 +25,17 @@ export const setQuantitativeColorScale = action(
     }
     const existing = findSemanticScale(this, args.id);
     if (existing !== undefined && existing.type !== args.type) {
-      throw new Error(
-        `Scale "${args.id}" cannot change type from "${existing.type}" to "${args.type}".`
-      );
+      if (typeof this.editScale !== "function") {
+        throw new Error("Color scale type transitions require the Full ChartProgram; use a new scale id in Basic.");
+      }
+      return this.editScale(args);
     }
     let next = this;
+    if (existing?.midpoint !== undefined && args.midpoint === undefined) {
+      next = next.editSemantic({ property: `scale[${args.id}].midpoint`, remove: true });
+    }
     for (const property of [
-      "type", "domain", "range", "interpolate", "clamp", "reverse", "unknown"
+      "type", "domain", "range", "interpolate", "midpoint", "clamp", "reverse", "unknown"
     ]) {
       if (!Object.hasOwn(args, property)) continue;
       if (existing?.[property] === args[property]) continue;