ggaction 0.0.11 → 0.0.13

package/src/actions/scales/consumers/common.js

@@ -1,9 +1,7 @@
-import {
-  readNominalField,
-  readQuantitativeField,
-  readScaleField,
-  readTemporalField
-} from "../../../grammar/scales/index.js";
+import { isSourceOwnedText } from "../../../grammar/text.js";
+import { readSeriesIdentity } from "../../../grammar/pathSeries.js";
+import { readAreaEndpoint } from "../../../grammar/areaEndpoints.js";
+import { readScaleField } from "../../../grammar/scales/index.js";
 import { findDataset } from "../../../selectors/datasets.js";
 import { requireSemanticScale } from "../../../selectors/scales.js";
 import { SCALED_ENCODING_CHANNELS } from "../../../core/vocabulary.js";
@@ -15,6 +13,7 @@ export function findScale(program, id) {
 export function findScaleConsumers(program, id) {
   const consumers = [];
   for (const layer of program.semanticSpec.layers) {
+    if (isSourceOwnedText(layer)) continue;
     for (const channel of SCALED_ENCODING_CHANNELS) {
       const encoding = layer.encoding?.[channel];
       if (encoding?.scale === id) consumers.push({ layer, channel, encoding });
@@ -46,7 +45,7 @@ export function requireConsumerDataset(program, consumer) {
 export function isDirectCategoricalConsumer(consumer) {
   return ["color", "strokeDash", "xOffset", "yOffset", "shape"].includes(
     consumer.channel
-  ) && consumer.encoding.fieldType === "nominal";
+  ) && ["nominal", "ordinal"].includes(consumer.encoding.fieldType);
 }
 
 export function readConsumerFieldValues(
@@ -55,55 +54,23 @@ export function readConsumerFieldValues(
   dataset,
   scale = findScale(program, consumer.encoding.scale)
 ) {
-  const allowUnknown = Object.hasOwn(scale, "unknown");
-  if (consumer.role === "parallelDimension") {
-    return readScaleField(
-      dataset.values,
-      consumer.encoding.field,
-      consumer.encoding.fieldType,
-      { allowUnknown: true }
-    );
-  }
-  if (isDirectCategoricalConsumer(consumer)) {
-    return allowUnknown
-      ? readScaleField(
-          dataset.values,
-          consumer.encoding.field,
-          consumer.encoding.fieldType,
-          { allowUnknown: true }
-        )
-      : readNominalField(dataset.values, consumer.encoding.field);
-  }
-  if (consumer.encoding.fieldType === "temporal") {
-    return allowUnknown
-      ? readScaleField(dataset.values, consumer.encoding.field, "temporal", {
-          allowUnknown: true
-        })
-      : readTemporalField(dataset.values, consumer.encoding.field);
+  const { field, fieldType, temporalUnit } = consumer.encoding;
+  if (consumer.layer.mark.type === "bar" && consumer.layer.encoding?.group !== undefined && ["xOffset", "yOffset"].includes(consumer.channel)) {
+    return readSeriesIdentity(dataset.values, consumer.layer).values;
   }
-  if (["nominal", "ordinal"].includes(consumer.encoding.fieldType)) {
-    if (!["ordinal", "band", "point"].includes(scale.type)) {
-      throw new Error(
-        `Scale materialization requires a quantitative encoding on mark "${consumer.layer.id}".`
-      );
-    }
-    return allowUnknown
-      ? readScaleField(
-          dataset.values,
-          consumer.encoding.field,
-          consumer.encoding.fieldType,
-          { allowUnknown: true }
-        )
-      : readNominalField(dataset.values, consumer.encoding.field);
-  }
-  if (consumer.encoding.fieldType !== "quantitative") {
+  const parallel = consumer.role === "parallelDimension";
+  if (!parallel && !isDirectCategoricalConsumer(consumer) &&
+    fieldType !== "quantitative" && fieldType !== "temporal" &&
+    (!["nominal", "ordinal"].includes(fieldType) ||
+      !["ordinal", "band", "point"].includes(scale.type))) {
     throw new Error(
       `Scale materialization requires a quantitative encoding on mark "${consumer.layer.id}".`
     );
   }
-  return allowUnknown
-    ? readScaleField(dataset.values, consumer.encoding.field, "quantitative", {
-        allowUnknown: true
-      })
-    : readQuantitativeField(dataset.values, consumer.encoding.field);
+  if (consumer.layer.mark.type === "area" && ["x", "y", "x2", "y2"].includes(consumer.channel) && fieldType === "quantitative") {
+    return readAreaEndpoint(dataset.values, consumer.encoding, consumer.layer.mark.missing).filter(value => value != null);
+  }
+  return readScaleField(dataset.values, field, fieldType, {
+    allowUnknown: parallel || Object.hasOwn(scale, "unknown"), temporalUnit
+  });
 }

package/src/actions/scales/consumers/families.js

@@ -1,3 +1,5 @@
+import { isPendingMeasuredRadiusConsumer } from "../../../materialization/scales/policies/arc.js";
+import { deriveMeasuredArcValues } from "../../../grammar/arcs.js";
 import { deriveBarAggregates } from "../../../grammar/bars/aggregate.js";
 import {
   BAR_GRAINS,
@@ -5,9 +7,9 @@ import {
 } from "../../../grammar/bars/policy.js";
 import {
   deriveLineSeries,
-  deriveLineSeriesFieldValues,
   resolveLineBins
 } from "../../../grammar/lineSeries.js";
+import { derivePathSeriesFieldValues } from "../../../grammar/pathSeries.js";
 import { isAggregate } from "../../../grammar/aggregate.js";
 import {
   resolveRectConsumerValues
@@ -26,6 +28,11 @@ function lineDerivationOptions(program, consumer, dataset) {
 }
 
 export function resolveMarkFamilyConsumerValues(program, consumer, dataset) {
+  if (consumer.layer.mark?.type === "arc" && consumer.channel === "radius" &&
+    findScale(program, consumer.encoding.scale).radialMapping !== undefined) {
+    return { matched: true, values: isPendingMeasuredRadiusConsumer(consumer) ? [] : deriveMeasuredArcValues(dataset.values, consumer.layer).map(item => item.radius) };
+  }
+
   if (consumer.layer.mark?.type === "rect") {
     return {
       matched: true,
@@ -36,29 +43,35 @@ export function resolveMarkFamilyConsumerValues(program, consumer, dataset) {
       )
     };
   }
+  const { layer, channel } = consumer;
+  const encoding = layer.encoding ?? {};
+  const appearance = ["strokeWidth", "opacity"].includes(channel);
   if (
-    consumer.layer.mark?.type === "line" &&
-    ((consumer.layer.encoding?.x !== undefined &&
-      isAggregate(consumer.layer.encoding?.y?.aggregate) &&
-      !(consumer.channel === "x" &&
-        consumer.layer.encoding?.x?.bin !== undefined)) ||
-      consumer.channel === "strokeWidth")
+    layer.mark?.type === "line" &&
+    ((["x", "y"].includes(channel) && encoding.x !== undefined &&
+      isAggregate(encoding.y?.aggregate) &&
+      !(channel === "x" &&
+        encoding.x?.bin !== undefined)) ||
+      appearance) &&
+    encoding.parallel === undefined &&
+    ((encoding.x !== undefined && encoding.y !== undefined) ||
+      (encoding.theta !== undefined && encoding.radius !== undefined))
   ) {
     const derived = deriveLineSeries(
       dataset.values,
-      consumer.layer,
+      layer,
       lineDerivationOptions(program, consumer, dataset)
     );
     return {
       matched: true,
-      values: consumer.channel === "strokeWidth"
-        ? deriveLineSeriesFieldValues(
+      values: appearance
+        ? derivePathSeriesFieldValues(
             dataset.values,
-            consumer.layer,
-            derived,
-            consumer.encoding.field
+            derived.series,
+            consumer.encoding.field,
+            channel
           )
-        : consumer.channel === "x" ? derived.xValues : derived.yValues
+        : channel === "x" ? derived.xValues : derived.yValues
     };
   }
   if (resolveBarGrain(consumer.layer) === BAR_GRAINS.aggregate) {

package/src/actions/scales/consumers/index.js

@@ -1,4 +1,6 @@
+import { readAreaEndpoint } from "../../../grammar/areaEndpoints.js";
 import { normalizeRuleDatum } from "../../../grammar/rules.js";
+import { normalizePositionDatum } from "../../../grammar/positionDatum.js";
 import {
   findScale,
   isDirectCategoricalConsumer,
@@ -6,7 +8,7 @@ import {
   requireConsumerDataset
 } from "./common.js";
 import { resolveMarkFamilyConsumerValues } from "./families.js";
-import { resolveCategoryOrder } from "../../../grammar/categoryOrder.js";
+import { CATEGORY_ORDER_CHANNELS, resolveCategoryOrder } from "../../../grammar/categoryOrder.js";
 
 export { findScale, findScaleConsumers } from "./common.js";
 export {
@@ -16,11 +18,26 @@ export {
 
 export function resolveConsumerValues(program, consumer) {
   const dataset = requireConsumerDataset(program, consumer);
+  if (consumer.layer.mark.type === "rect") return resolveMarkFamilyConsumerValues(program, consumer, dataset).values;
   if (Object.hasOwn(consumer.encoding, "datum")) {
+    if (consumer.layer.mark.type === "area") {
+      readAreaEndpoint(dataset.values, consumer.encoding, consumer.layer.mark.missing);
+      return [consumer.encoding.datum];
+    }
+    if (consumer.layer.mark.type === "text") {
+      return [normalizePositionDatum(
+        consumer.encoding.datum,
+        consumer.encoding.fieldType,
+        consumer.channel,
+        consumer.encoding.temporalUnit,
+        "Text"
+      )];
+    }
     return [normalizeRuleDatum(
       consumer.encoding.datum,
       consumer.encoding.fieldType,
-      consumer.channel
+      consumer.channel,
+      consumer.encoding.temporalUnit
     )];
   }
   if (
@@ -44,6 +61,10 @@ export function resolveConsumerValues(program, consumer) {
 export function resolveConsumerCategoryOrder(program, consumer) {
   const order = consumer.encoding.categoryOrder;
   if (order === undefined) return undefined;
+  if (!CATEGORY_ORDER_CHANNELS.includes(consumer.channel) ||
+    !["nominal", "ordinal"].includes(consumer.encoding.fieldType)) {
+    throw new Error("Remove category order before assigning a non-categorical position.");
+  }
   const dataset = requireConsumerDataset(program, consumer);
   return resolveCategoryOrder(dataset.values, consumer.encoding.field, order);
 }

package/src/actions/scales/consumers/seriesLayout.js

@@ -1,3 +1,5 @@
+import { readSeriesIdentity } from "../../../grammar/pathSeries.js";
+import { deriveAreaSeries } from "../../../grammar/areaSeries.js";
 import { deriveBarAggregates } from "../../../grammar/bars/aggregate.js";
 import { validateGeneratedItemLimit } from "../../../core/validation.js";
 import {
@@ -67,6 +69,15 @@ function resolveHistogramPartitions(program, consumer) {
     zero: xScale.zero ?? false
   });
   const colorEncoding = layer.encoding?.color;
+  if (layer.encoding?.group !== undefined) {
+    const identity = readSeriesIdentity(dataset.values, layer);
+    validateGeneratedItemLimit((bins.boundaries.length - 1) * identity.domain.length, "Histogram layout cell count");
+    const counts = bins.boundaries.slice(0, -1).map(() => identity.domain.map(() => 0));
+    const groups = new Map(identity.domain.map((value, index) => [value, index]));
+    xValues.forEach((value, index) => { const bin = findHistogramBinIndex(value, bins.boundaries);
+      if (bin !== -1) counts[bin][groups.get(identity.values[index])] += 1; });
+    return counts;
+  }
   if (colorEncoding?.scale === undefined) {
     return countHistogramBins(xValues, bins.boundaries).map(value => [value]);
   }
@@ -101,6 +112,12 @@ function resolveAggregatePartitions(program, consumer) {
     : derived.yValues;
   const categoryDomain = resolveOrdinalDomain(categoryScale.domain, categoryValues);
   const colorEncoding = layer.encoding?.color;
+  if (layer.encoding?.group !== undefined) {
+    const series = readSeriesIdentity(dataset.values, layer).domain;
+    validateGeneratedItemLimit(categoryDomain.length * series.length, "Aggregate layout cell count");
+    const cells = new Map(derived.values.map(value => [JSON.stringify([value[channels.category], value.series]), value[channels.measure]]));
+    return categoryDomain.map(category => series.map(key => cells.get(JSON.stringify([category, key])) ?? 0));
+  }
   if (
     colorEncoding?.scale === undefined ||
     colorEncoding.fieldType === "quantitative"
@@ -181,11 +198,25 @@ export function resolveSeriesLayoutScaleValues(program, consumer) {
       values: resolveSeriesLayoutDomainValues(partitions, layout)
     };
   }
+  if (consumer.layer.mark?.type === "area" && consumer.layer.layout?.mode !== undefined) {
+    const layer = consumer.layer;
+    const dataset = findDataset(program, layer.data);
+    const density = dataset.transform?.some(transform => transform.type === "density");
+    if (!density && (layer.encoding?.x === undefined || layer.encoding?.y === undefined || (layer.encoding?.x2 === undefined && layer.encoding?.y2 === undefined))) return undefined;
+    if (!density && layer.encoding?.x !== undefined && layer.encoding?.y !== undefined && (layer.encoding?.x2 !== undefined || layer.encoding?.y2 !== undefined)) {
+      const derived = deriveAreaSeries(dataset.values, layer);
+      const measure = derived.orientation === "vertical" ? "y" : "x";
+      if (![measure, `${measure}2`].includes(consumer.channel)) return undefined;
+      const layout = layer.layout.mode;
+      if (layout === "overlay") return undefined;
+      return { layout, values: layout === "fill" ? [0, 1] : derived[`${measure}Values`] };
+    }
+  }
   if (consumer.channel !== "y") return undefined;
   if (consumer.layer.mark?.type === "area") {
-    const layout = consumer.layer.encoding?.y?.stack === "center"
+    const layout = consumer.layer.layout?.mode ?? (consumer.layer.encoding?.y?.stack === "center"
       ? "center"
-      : consumer.layer.encoding?.color?.layout;
+      : consumer.layer.encoding?.color?.layout);
     if (layout === undefined || layout === "overlay") return undefined;
     const partitions = resolveAreaPartitions(program, consumer);
     if (partitions === undefined) {

package/src/actions/scales/create.js

@@ -35,8 +35,8 @@ const CREATE_SCALE_OPTIONS = Object.freeze([
   "padding",
   "align",
   "palette",
-  "interpolate",
-  "unknown"
+  "interpolate", "midpoint",
+  "radialMapping", "unknown"
 ]);
 
 function validateOptions(args) {
@@ -133,8 +133,8 @@ export const createScale = action(
 
     for (const property of [
       "nice", "zero", "clamp", "reverse", "base", "exponent", "constant",
-      "paddingInner", "paddingOuter", "padding", "align", "interpolate",
-      "unknown"
+      "paddingInner", "paddingOuter", "padding", "align", "interpolate", "midpoint",
+      "radialMapping", "unknown"
     ]) {
       if (definition[property] === undefined) continue;
       next = next.editSemantic({

package/src/actions/scales/definitions.js

@@ -1,9 +1,11 @@
+import { prepareScaleEdit } from "./editPolicy.js";
 import { validateUserId } from "../../core/identifiers.js";
 import { isPlainObject } from "../../core/immutable.js";
 import { validateKeys } from "../../core/validation.js";
 import {
   validateColorRange,
   validateContinuousColorInterpolation,
+  validateSequentialMidpoint,
   validateLinearScaleType,
   validateOpacityRange,
   validateOrdinalDomain,
@@ -49,7 +51,7 @@ const POSITION_OPTIONS = [
 const COLOR_OPTIONS = [...BASE_OPTIONS, "palette", "unknown"];
 const SEQUENTIAL_COLOR_OPTIONS = [
   ...COLOR_OPTIONS,
-  "interpolate",
+  "interpolate", "midpoint",
   ...CLAMP_REVERSE
 ];
 const OPACITY_OPTIONS = [...BASE_OPTIONS, ...BOOLEAN_OPTIONS, "unknown"];
@@ -121,7 +123,7 @@ export function resolvePositionScaleDefinition(
     ...normalizeScaleDefinition({
       type,
       previous: existing,
-      patch: options,
+      patch: { ...options, ...(defaults.radialMapping === undefined ? {} : { radialMapping: defaults.radialMapping }) },
       defaults: {
         ...(existing === undefined && defaults.nice !== undefined
           ? { nice: defaults.nice }
@@ -210,6 +212,15 @@ export function resolveSequentialColorScaleDefinition(
       options.interpolate ?? existing?.interpolate ?? "rgb"
     )
   };
+  const midpoint = validateSequentialMidpoint(
+    Object.hasOwn(options, "midpoint") ? options.midpoint : existing?.midpoint, type, scale.domain
+  );
+  if (midpoint !== undefined) {
+    if (fieldType !== "quantitative") {
+      throw new Error("Scale midpoint requires quantitative color consumers.");
+    }
+    scale.midpoint = midpoint;
+  }
   return withScaleUnknown(
     assignOptions(scale, options, existing, CLAMP_REVERSE),
     { ...existing, ...options },
@@ -227,6 +238,12 @@ export function resolveQuantitativeColorScaleDefinition(
     program,
     options.id ?? "color"
   )?.type ?? "sequential";
+  const existing = findSemanticScale(program, options.id ?? "color");
+  if (existing !== undefined && existing.type !== type) {
+    validateKeys(options, type === "sequential" ? SEQUENTIAL_COLOR_OPTIONS : [...COLOR_OPTIONS, ...CLAMP_REVERSE], "scale");
+    if (fieldType !== "quantitative") throw new Error("Color scale type transition requires quantitative color.");
+    return { id: existing.id, ...prepareScaleEdit(program, existing, "color", [], options) };
+  }
   if (type === "sequential") {
     return resolveSequentialColorScaleDefinition(program, fieldType, options);
   }
@@ -238,7 +255,6 @@ export function resolveQuantitativeColorScaleDefinition(
   validatePaletteRange(options);
   validateBooleanOptions(options, CLAMP_REVERSE, type);
   const id = validateUserId(options.id ?? "color", "Scale id");
-  const existing = findSemanticScale(program, id);
   const previous = existing?.type === type ? existing : undefined;
   const requestedRange = options.palette === undefined
     ? options.range

package/src/actions/scales/edit.js

@@ -1,7 +1,9 @@
+import { withGuideLayoutValidation } from "../../materialization/guides/layout.js";
+import { planColorLegendTransition, applyColorLegendTransition } from "../guides/legends/transition.js";
 import { action } from "../../core/action.js";
 import { validateUserId } from "../../core/identifiers.js";
 import { validateOptionObject } from "../../core/validation.js";
-import { getMarkMaterializationStep } from "../../materialization/marks/index.js";
+import { getMarkMaterializationStep, getSourceDependentMarkSteps } from "../../materialization/marks/index.js";
 import {
   applyMaterializationPlan
 } from "../../materialization/dependencies.js";
@@ -18,7 +20,7 @@ import {
 const OPTIONS = Object.freeze([
   "id", "type", "domain", "range", "nice", "zero", "clamp", "reverse",
   "base", "exponent", "constant", "paddingInner", "paddingOuter", "padding",
-  "align", "interpolate", "unknown", "palette"
+  "align", "interpolate", "midpoint", "unknown", "palette", "radialMapping"
 ]);
 const EDITABLE = Object.freeze(
   OPTIONS.filter(option => !["id", "palette"].includes(option))
@@ -63,7 +65,41 @@ function planMarkRematerialization(program, consumers) {
     seen.add(consumer.layer.id);
     plan.push(step);
   }
-  return plan;
+  return [
+    ...plan,
+    ...consumers.flatMap(consumer => getSourceDependentMarkSteps(program, consumer.layer.id))
+  ];
+}
+
+function applyScaleEdit(program, { id, scale, consumers, definition, legendTransition }) {
+  let next = legendTransition === undefined ? program
+    : program.removeLegend({ target: legendTransition.args.target, channels: ["color"] });
+  for (const property of EDITABLE) {
+    if (
+      Object.hasOwn(scale, property) &&
+      !Object.hasOwn(definition, property)
+    ) {
+      next = next.editSemantic({
+        property: `scale[${id}].${property}`,
+        remove: true
+      });
+    }
+  }
+  for (const property of EDITABLE) {
+    if (
+      !Object.hasOwn(definition, property) ||
+      sameValue(scale[property], definition[property])
+    ) continue;
+    next = next.editSemantic({
+      property: `scale[${id}].${property}`,
+      value: definition[property]
+    });
+  }
+  if (consumers.length === 0) return next;
+
+  next = next.rematerializeScale({ id });
+  next = applyMaterializationPlan(next, planMarkRematerialization(next, consumers));
+  return legendTransition === undefined ? next : applyColorLegendTransition(next, legendTransition);
 }
 
 export const editScale = action(
@@ -71,7 +107,7 @@ export const editScale = action(
     op: "editScale",
     description: "Edit an existing scale and rematerialize its consumers."
   },
-  function (args = {}) {
+  withGuideLayoutValidation(function (args = {}) {
     validateOptionObject(args, OPTIONS, "editScale");
     if (!REQUESTED_CHANGES.some(property => Object.hasOwn(args, property))) {
       throw new Error("editScale requires at least one editable property.");
@@ -82,34 +118,10 @@ export const editScale = action(
     const channel = resolveScaleConsumerChannel(consumers, id);
     const definition = prepareScaleEdit(this, scale, channel, consumers, args);
 
-    let next = this;
-    for (const property of EDITABLE) {
-      if (
-        Object.hasOwn(scale, property) &&
-        !Object.hasOwn(definition, property)
-      ) {
-        next = next.editSemantic({
-          property: `scale[${id}].${property}`,
-          remove: true
-        });
-      }
-    }
-    for (const property of EDITABLE) {
-      if (
-        !Object.hasOwn(definition, property) ||
-        sameValue(scale[property], definition[property])
-      ) continue;
-      next = next.editSemantic({
-        property: `scale[${id}].${property}`,
-        value: definition[property]
-      });
-    }
-    if (consumers.length === 0) return next;
-
-    next = next.rematerializeScale({ id });
-    return applyMaterializationPlan(
-      next,
-      planMarkRematerialization(next, consumers)
-    );
-  }
+    const legendTransition = planColorLegendTransition(this, scale, definition.type);
+    const proposal = { id, scale, consumers, definition, legendTransition };
+    // Preflight every dependent mark and guide on a discarded immutable branch.
+    if (scale.type !== definition.type) applyScaleEdit(this, proposal);
+    return applyScaleEdit(this, proposal);
+  })
 );

package/src/actions/scales/editPolicy.js

@@ -1,3 +1,4 @@
+import { validateContinuousColorConsumer } from "../../grammar/scales/colorConsumers.js";
 import {
   hasOrdinalDomain,
   isDiscretizedColorScaleType,
@@ -14,6 +15,7 @@ import {
   validateScaleType,
   validateScaleTypeForRole,
   validateScaleUnknown,
+  validateSequentialMidpoint,
   validateSequentialColorRange,
   validateShapeRange,
   validateSizeRange,
@@ -60,18 +62,11 @@ 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))
-    )) {
-      throw new Error(
-        `Scale "${scale.id}" has a consumer incompatible with type "${nextType}".`
-      );
+    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 });
     }
     return;
   }
@@ -132,27 +127,17 @@ 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.`
-    );
-  }
-  if (
-    legends.interval?.scale === scale.id &&
-    !isDiscretizedColorScaleType(nextType)
-  ) {
-    throw new Error(
-      `Scale "${scale.id}" cannot change type while its interval legend is active.`
-    );
-  }
-}
-
 function normalizeDefinition(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.");
+  }
   const type = patch.type ?? scale.type;
   validateTypeTransition(scale, type, channel, consumers);
+  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 definition = normalizeScaleDefinition({
     type,
     previous: scale,
@@ -175,6 +160,12 @@ 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 => consumer.channel !== "color" || 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
@@ -209,6 +200,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);
 }