ggaction 0.0.13 → 0.0.16

package/src/actions/scales/create.js

@@ -14,9 +14,11 @@ import {
   isColorScaleType,
   isContinuousColorScaleType,
   isDiscretizedColorScaleType,
+  normalizeSizeScaleDefinition,
   normalizeScaleDefinition
 } from "../../grammar/scales/index.js";
 import { findSemanticScale } from "../../selectors/scales.js";
+import { findScaleConsumers } from "./consumers/index.js";
 
 const CREATE_SCALE_OPTIONS = Object.freeze([
   "id",
@@ -75,7 +77,7 @@ function assertEquivalentScale(existing, expected) {
   }
 }
 
-export const createScale = action(
+export const createScale = /* @__PURE__ */ action(
   {
     op: "createScale",
     description: "Create a named semantic scale."
@@ -97,28 +99,58 @@ export const createScale = action(
     const requestedRange = args.palette === undefined
       ? args.range
       : { palette: args.palette };
-    const definition = normalizeScaleDefinition({
-      type,
-      patch: {
-        ...args,
-        ...(requestedRange === undefined ? {} : { range: requestedRange })
-      },
-      validateDomain: (scaleType, value) =>
-        isDiscretizedColorScaleType(scaleType)
-          ? validateDiscretizedColorDomain(scaleType, value)
-          : hasOrdinalDomain(scaleType)
-            ? validateOrdinalDomain(value)
-            : validateScaleDomain(value),
-      validateRange: (scaleType, value) =>
-        isDiscretizedColorScaleType(scaleType)
-          ? validateDiscretizedColorRange(value)
-          : isContinuousColorScaleType(scaleType)
-            ? validateSequentialColorRange(value)
-            : scaleType === "ordinal"
-              ? validateOrdinalRange(value)
-              : validateScaleRange(value)
-    });
-    if (Object.hasOwn(args, "unknown")) definition.unknown = args.unknown;
+    const consumers = findScaleConsumers(this, id);
+    const offsetScale = consumers.length > 0 && consumers.every(
+      consumer => ["xOffset", "yOffset"].includes(consumer.channel)
+    );
+    const sizeScale = consumers.length > 0 && consumers.every(
+      consumer => consumer.channel === "size"
+    );
+    if (offsetScale && type !== "ordinal") {
+      throw new Error(`Scale type "${type}" is not valid for offset positions.`);
+    }
+    if (
+      offsetScale &&
+      Object.hasOwn(args, "range") &&
+      args.range !== "auto"
+    ) {
+      throw new Error(
+        "Offset scale range is derived from its parent categorical slot."
+      );
+    }
+    const definition = sizeScale
+      ? normalizeSizeScaleDefinition({
+          patch: {
+            ...args,
+            type,
+            ...(requestedRange === undefined ? {} : { range: requestedRange })
+          }
+        })
+      : normalizeScaleDefinition({
+          type,
+          patch: {
+            ...args,
+            ...(requestedRange === undefined ? {} : { range: requestedRange })
+          },
+          allowOrdinalBandParameters: offsetScale,
+          validateDomain: (scaleType, value) =>
+            isDiscretizedColorScaleType(scaleType)
+              ? validateDiscretizedColorDomain(scaleType, value)
+              : hasOrdinalDomain(scaleType)
+                ? validateOrdinalDomain(value)
+                : validateScaleDomain(value),
+          validateRange: (scaleType, value) =>
+            isDiscretizedColorScaleType(scaleType)
+              ? validateDiscretizedColorRange(value)
+              : isContinuousColorScaleType(scaleType)
+                ? validateSequentialColorRange(value)
+                : scaleType === "ordinal"
+                  ? validateOrdinalRange(value)
+                  : validateScaleRange(value)
+        });
+    if (Object.hasOwn(args, "unknown") && !sizeScale) {
+      definition.unknown = args.unknown;
+    }
     const existing = findSemanticScale(this, id);
 
     if (existing !== undefined) {

package/src/actions/scales/definitions.js

@@ -13,7 +13,6 @@ import {
   validateScaleDomain,
   validateScaleRange,
   validateShapeRange,
-  validateSizeRange,
   validateStrokeDashRange,
   validateStrokeWidthRange,
   validateSequentialColorRange,
@@ -25,6 +24,7 @@ import {
   validateScalePropertyForType,
   validateScaleTypeForRole,
   isDiscretePositionScaleType,
+  normalizeSizeScaleDefinition,
   withScaleUnknown
 } from "../../grammar/scales/index.js";
 import {
@@ -32,6 +32,10 @@ import {
   validateThetaRange
 } from "../../grammar/polar.js";
 import { findSemanticScale } from "../../selectors/scales.js";
+import { normalizeOffsetScalePolicy } from "../../grammar/bars/geometry.js";
+import { resolveRequestedOffsetPolicy } from
+  "../../materialization/scales/policies/offset.js";
+import { findScaleConsumers } from "./consumers/index.js";
 
 const BASE_OPTIONS = ["id", "type", "domain", "range"];
 const UNKNOWN_OPTIONS = [...BASE_OPTIONS, "unknown"];
@@ -58,6 +62,9 @@ const OPACITY_OPTIONS = [...BASE_OPTIONS, ...BOOLEAN_OPTIONS, "unknown"];
 const STROKE_WIDTH_OPTIONS = [
   ...BASE_OPTIONS, ...BOOLEAN_OPTIONS, ...TRANSFORM_OPTIONS
 ];
+const SIZE_OPTIONS = [
+  ...UNKNOWN_OPTIONS, "clamp", "reverse", "base", "exponent"
+];
 
 function optionsObject(options) {
   if (!isPlainObject(options)) {
@@ -151,21 +158,22 @@ export function resolvePositionScaleDefinition(
   return withScaleUnknown(scale, { ...existing, ...options }, channel);
 }
 
-export function resolveColorScaleDefinition(program, options) {
+export function resolveColorScaleDefinition(program, options, channel = "color") {
   optionsObject(options);
   validateKeys(options, COLOR_OPTIONS, "scale");
   validatePaletteRange(options);
-  const id = validateUserId(options.id ?? "color", "Scale id");
+  const id = validateUserId(options.id ?? channel, "Scale id");
   const existing = findSemanticScale(program, id);
+  const previous = existing?.type === "ordinal" ? existing : undefined;
   const range = options.palette === undefined
     ? options.range
     : { palette: options.palette };
   return withScaleUnknown({
     id,
-    type: validateOrdinalScaleType(options.type ?? existing?.type ?? "ordinal"),
-    domain: validateOrdinalDomain(options.domain ?? existing?.domain ?? "auto"),
-    range: validateColorRange(range ?? existing?.range ?? "auto")
-  }, { ...existing, ...options }, "color");
+    type: validateOrdinalScaleType(options.type ?? previous?.type ?? "ordinal"),
+    domain: validateOrdinalDomain(options.domain ?? previous?.domain ?? "auto"),
+    range: validateColorRange(range ?? previous?.range ?? "auto")
+  }, { ...previous, ...options }, channel);
 }
 
 function continuousDomain(value, fieldType) {
@@ -186,14 +194,16 @@ function continuousDomain(value, fieldType) {
 export function resolveSequentialColorScaleDefinition(
   program,
   fieldType,
-  options
+  options,
+  channel = "color"
 ) {
   optionsObject(options);
   validateKeys(options, SEQUENTIAL_COLOR_OPTIONS, "scale");
   validatePaletteRange(options);
-  const id = validateUserId(options.id ?? "color", "Scale id");
+  const id = validateUserId(options.id ?? channel, "Scale id");
   const existing = findSemanticScale(program, id);
-  const type = options.type ?? existing?.type ?? "sequential";
+  const previous = existing?.type === "sequential" ? existing : undefined;
+  const type = options.type ?? previous?.type ?? "sequential";
   if (type !== "sequential") {
     throw new Error(`Unsupported continuous color scale type "${type}".`);
   }
@@ -204,16 +214,16 @@ export function resolveSequentialColorScaleDefinition(
   const scale = {
     id,
     type,
-    domain: continuousDomain(options.domain ?? existing?.domain ?? "auto", fieldType),
+    domain: continuousDomain(options.domain ?? previous?.domain ?? "auto", fieldType),
     range: validateSequentialColorRange(
-      requestedRange ?? existing?.range ?? { palette: "viridis" }
+      requestedRange ?? previous?.range ?? { palette: "viridis" }
     ),
     interpolate: validateContinuousColorInterpolation(
-      options.interpolate ?? existing?.interpolate ?? "rgb"
+      options.interpolate ?? previous?.interpolate ?? "rgb"
     )
   };
   const midpoint = validateSequentialMidpoint(
-    Object.hasOwn(options, "midpoint") ? options.midpoint : existing?.midpoint, type, scale.domain
+    Object.hasOwn(options, "midpoint") ? options.midpoint : previous?.midpoint, type, scale.domain
   );
   if (midpoint !== undefined) {
     if (fieldType !== "quantitative") {
@@ -222,30 +232,34 @@ export function resolveSequentialColorScaleDefinition(
     scale.midpoint = midpoint;
   }
   return withScaleUnknown(
-    assignOptions(scale, options, existing, CLAMP_REVERSE),
-    { ...existing, ...options },
-    "color"
+    assignOptions(scale, options, previous, CLAMP_REVERSE),
+    { ...previous, ...options },
+    channel
   );
 }
 
 export function resolveQuantitativeColorScaleDefinition(
   program,
   fieldType,
-  options
+  options,
+  channel = "color"
 ) {
   optionsObject(options);
-  const type = options.type ?? findSemanticScale(
-    program,
-    options.id ?? "color"
-  )?.type ?? "sequential";
-  const existing = findSemanticScale(program, options.id ?? "color");
-  if (existing !== undefined && existing.type !== type) {
+  const existing = findSemanticScale(program, options.id ?? channel);
+  const existingContinuous = existing !== undefined && (
+    existing.type === "sequential" ||
+    ["quantize", "quantile", "threshold"].includes(existing.type)
+  );
+  const type = options.type ?? (
+    existingContinuous ? existing.type : "sequential"
+  );
+  if (existingContinuous && 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) };
+    return { id: existing.id, ...prepareScaleEdit(program, existing, channel, [], options) };
   }
   if (type === "sequential") {
-    return resolveSequentialColorScaleDefinition(program, fieldType, options);
+    return resolveSequentialColorScaleDefinition(program, fieldType, options, channel);
   }
   validateKeys(options, [...COLOR_OPTIONS, ...CLAMP_REVERSE], "scale");
   if (fieldType !== "quantitative") {
@@ -254,7 +268,7 @@ export function resolveQuantitativeColorScaleDefinition(
   validateScaleTypeForRole(type, SCALE_ROLES.discretizedColor);
   validatePaletteRange(options);
   validateBooleanOptions(options, CLAMP_REVERSE, type);
-  const id = validateUserId(options.id ?? "color", "Scale id");
+  const id = validateUserId(options.id ?? channel, "Scale id");
   const previous = existing?.type === type ? existing : undefined;
   const requestedRange = options.palette === undefined
     ? options.range
@@ -273,7 +287,7 @@ export function resolveQuantitativeColorScaleDefinition(
   return withScaleUnknown(
     assignOptions(scale, options, previous, CLAMP_REVERSE),
     { ...existing, ...options },
-    "color"
+    channel
   );
 }
 
@@ -298,21 +312,23 @@ export function resolveStrokeDashScaleDefinition(program, options) {
 
 export function resolveAppearanceScaleDefinition(program, channel, options) {
   optionsObject(options);
+  if (channel === "size") {
+    validateKeys(options, SIZE_OPTIONS, "scale");
+    const id = validateUserId(options.id ?? channel, "Scale id");
+    const existing = findSemanticScale(program, id);
+    return {
+      id,
+      ...normalizeSizeScaleDefinition({ previous: existing, patch: options })
+    };
+  }
   validateKeys(options, UNKNOWN_OPTIONS, "scale");
   const id = validateUserId(options.id ?? channel, "Scale id");
   const existing = findSemanticScale(program, id);
-  const shape = channel === "shape";
   return withScaleUnknown({
     id,
-    type: shape
-      ? validateOrdinalScaleType(options.type ?? existing?.type ?? "ordinal")
-      : validateLinearScaleType(options.type ?? existing?.type ?? "linear"),
-    domain: shape
-      ? validateOrdinalDomain(options.domain ?? existing?.domain ?? "auto")
-      : validateScaleDomain(options.domain ?? existing?.domain ?? "auto"),
-    range: shape
-      ? validateShapeRange(options.range ?? existing?.range ?? "auto")
-      : validateSizeRange(options.range ?? existing?.range ?? "auto")
+    type: validateOrdinalScaleType(options.type ?? existing?.type ?? "ordinal"),
+    domain: validateOrdinalDomain(options.domain ?? existing?.domain ?? "auto"),
+    range: validateShapeRange(options.range ?? existing?.range ?? "auto")
   }, { ...existing, ...options }, channel);
 }
 
@@ -365,7 +381,45 @@ export function resolveStrokeWidthScaleDefinition(program, options) {
 }
 
 export function resolveOffsetScaleDefinition(program, options, channel = "xOffset") {
-  return resolveOrdinalScaleDefinition(
-    program, options, channel, validateScaleRange
+  optionsObject(options);
+  validateKeys(options, [
+    "id", "type", "domain", "range", "reverse",
+    "padding", "paddingInner", "paddingOuter", "align"
+  ], "scale");
+  const id = validateUserId(options.id ?? channel, "Scale id");
+  const existing = findSemanticScale(program, id);
+  const type = options.type ?? existing?.type ?? "ordinal";
+  if (type !== "ordinal") {
+    throw new Error(`Scale type "${type}" is not valid for ${channel}.`);
+  }
+  if (Object.hasOwn(options, "range") && options.range !== "auto") {
+    throw new Error(
+      `${channel} scale range is derived from its parent categorical slot.`
+    );
+  }
+  const consumers = findScaleConsumers(program, id).filter(
+    consumer => consumer.channel === channel
   );
+  const currentPolicy = resolveRequestedOffsetPolicy({
+    scale: existing,
+    consumers,
+    markConfigs: program.markConfigs,
+    id,
+    channel
+  });
+  const policy = normalizeOffsetScalePolicy(options, currentPolicy, channel);
+  const patch = Object.fromEntries(Object.entries(options).filter(
+    ([property]) => !["id", "padding"].includes(property)
+  ));
+  return {
+    id,
+    ...normalizeScaleDefinition({
+      type,
+      previous: existing,
+      patch: { ...patch, ...policy },
+      allowOrdinalBandParameters: true,
+      validateDomain: (_scaleType, value) => validateOrdinalDomain(value),
+      validateRange: (_scaleType, value) => validateScaleRange(value)
+    })
+  };
 }

package/src/actions/scales/edit.js

@@ -1,12 +1,18 @@
 import { withGuideLayoutValidation } from "../../materialization/guides/layout.js";
-import { planColorLegendTransition, applyColorLegendTransition } from "../guides/legends/transition.js";
+import {
+  applyColorLegendTransition,
+  planColorLegendTransitions
+} 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, getSourceDependentMarkSteps } from "../../materialization/marks/index.js";
 import {
-  applyMaterializationPlan
+  applyMaterializationPlan,
+  planCoordinateRematerialization
 } from "../../materialization/dependencies.js";
+import { findDataAspectCoordinatesForScale } from
+  "../../materialization/coordinateBounds.js";
 import {
   findSemanticScale,
   requireSemanticScale
@@ -16,6 +22,8 @@ import {
   prepareScaleEdit,
   resolveScaleConsumerChannel
 } from "./editPolicy.js";
+import { hasExactLegendSamplingForScale } from
+  "../guides/legends/sampling.js";
 
 const OPTIONS = Object.freeze([
   "id", "type", "domain", "range", "nice", "zero", "clamp", "reverse",
@@ -71,9 +79,21 @@ function planMarkRematerialization(program, consumers) {
   ];
 }
 
-function applyScaleEdit(program, { id, scale, consumers, definition, legendTransition }) {
-  let next = legendTransition === undefined ? program
-    : program.removeLegend({ target: legendTransition.args.target, channels: ["color"] });
+function applyScaleEdit(program, {
+  id,
+  scale,
+  channel,
+  consumers,
+  definition,
+  legendTransitions
+}) {
+  let next = program;
+  for (const transition of legendTransitions) {
+    next = next.removeLegend({
+      target: transition.args.target,
+      channels: [transition.channel]
+    });
+  }
   for (const property of EDITABLE) {
     if (
       Object.hasOwn(scale, property) &&
@@ -97,12 +117,35 @@ function applyScaleEdit(program, { id, scale, consumers, definition, legendTrans
   }
   if (consumers.length === 0) return next;
 
-  next = next.rematerializeScale({ id });
-  next = applyMaterializationPlan(next, planMarkRematerialization(next, consumers));
-  return legendTransition === undefined ? next : applyColorLegendTransition(next, legendTransition);
+  const aspectCoordinates = findDataAspectCoordinatesForScale(next, id);
+  if (aspectCoordinates.length > 0) {
+    for (const coordinate of aspectCoordinates) {
+      next = applyMaterializationPlan(
+        next,
+        planCoordinateRematerialization(next, coordinate.id)
+      );
+    }
+  } else {
+    next = next.rematerializeScale({ id });
+    next = applyMaterializationPlan(
+      next,
+      planMarkRematerialization(next, consumers)
+    );
+  }
+  if (["xOffset", "yOffset"].includes(channel)) {
+    for (const consumer of consumers) {
+      next = next._withoutMaterializationConfig([
+        "marks", consumer.layer.id, channel
+      ]);
+    }
+  }
+  for (const transition of legendTransitions) {
+    next = applyColorLegendTransition(next, transition);
+  }
+  return next;
 }
 
-export const editScale = action(
+export const editScale = /* @__PURE__ */ action(
   {
     op: "editScale",
     description: "Edit an existing scale and rematerialize its consumers."
@@ -118,10 +161,22 @@ export const editScale = action(
     const channel = resolveScaleConsumerChannel(consumers, id);
     const definition = prepareScaleEdit(this, scale, channel, consumers, args);
 
-    const legendTransition = planColorLegendTransition(this, scale, definition.type);
-    const proposal = { id, scale, consumers, definition, legendTransition };
+    const legendTransitions = planColorLegendTransitions(this, scale, definition.type);
+    const proposal = {
+      id,
+      scale,
+      channel,
+      consumers,
+      definition,
+      legendTransitions
+    };
     // Preflight every dependent mark and guide on a discarded immutable branch.
-    if (scale.type !== definition.type) applyScaleEdit(this, proposal);
+    if (
+      scale.type !== definition.type ||
+      hasExactLegendSamplingForScale(this, id)
+    ) {
+      applyScaleEdit(this, proposal);
+    }
     return applyScaleEdit(this, proposal);
   })
 );

package/src/actions/scales/editPolicy.js

@@ -4,6 +4,7 @@ import {
   isDiscretizedColorScaleType,
   isDiscretePositionScaleType,
   isTransformedScaleType,
+  normalizeSizeScaleDefinition,
   normalizeScaleDefinition,
   SCALE_ROLES,
   validateColorRange,
@@ -26,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.`);
@@ -40,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") {
@@ -49,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);
@@ -66,7 +77,23 @@ function validateTypeTransition(scale, nextType, channel, consumers) {
       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 });
+      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 "ordinal".`
+      );
     }
     return;
   }
@@ -127,23 +154,65 @@ function validateTypeTransition(scale, nextType, channel, consumers) {
   }
 }
 
-function normalizeDefinition(scale, channel, consumers, patch) {
+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 (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 });
+  }
   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)
@@ -162,13 +231,14 @@ function normalizeDefinition(scale, channel, consumers, patch) {
   }
   validateSequentialMidpoint(definition.midpoint, type, definition.domain);
   if (definition.midpoint !== undefined && consumers.some(
-    consumer => consumer.channel !== "color" || consumer.encoding.fieldType !== "quantitative"
+    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")) {
@@ -188,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)
   ) {
@@ -200,5 +270,5 @@ export function prepareScaleEdit(program, scale, channel, consumers, args) {
         ...Object.entries(args).filter(([key]) => key !== "palette"),
         ["range", { palette: args.palette }]
       ]);
-  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);
 }