ggaction 0.0.4 → 0.0.6

package/src/actions/scales/definitions.js

@@ -13,6 +13,7 @@ import {
   validateShapeRange,
   validateSizeRange,
   validateStrokeDashRange,
+  validateStrokeWidthRange,
   validateSequentialColorRange,
   validateDiscretizedColorDomain,
   validateDiscretizedColorRange,
@@ -314,6 +315,35 @@ export function resolveOpacityScaleDefinition(program, options) {
   return withScaleUnknown(scale, { ...existing, ...options }, "opacity");
 }
 
+export function resolveStrokeWidthScaleDefinition(program, options) {
+  optionsObject(options);
+  validateKeys(options, OPACITY_OPTIONS, "scale");
+  const id = validateUserId(options.id ?? "strokeWidth", "Scale id");
+  const existing = findSemanticScale(program, id);
+  const type = options.type ?? existing?.type ?? "linear";
+  validateScaleTypeForRole(type, SCALE_ROLES.quantitativePosition);
+  for (const property of ["nice", "zero", "clamp", "reverse"]) {
+    if (options[property] !== undefined && typeof options[property] !== "boolean") {
+      throw new TypeError(`Scale ${property} must be a boolean.`);
+    }
+  }
+  const domain = validateScaleDomain(options.domain ?? existing?.domain ?? "auto");
+  if (domain !== "auto" && domain.some(value => value < 0)) {
+    throw new RangeError("StrokeWidth scale domain cannot contain negative values.");
+  }
+  const scale = {
+    id,
+    type,
+    domain,
+    range: validateStrokeWidthRange(options.range ?? existing?.range ?? "auto")
+  };
+  for (const property of ["nice", "zero", "clamp", "reverse", "base", "exponent", "constant"]) {
+    const value = options[property] ?? existing?.[property];
+    if (value !== undefined) scale[property] = value;
+  }
+  return scale;
+}
+
 export function resolveOffsetScaleDefinition(program, options, channel = "xOffset") {
   optionsObject(options);
   validateKeys(options, [...BASE_OPTIONS, "unknown"], "scale");

package/src/actions/scales/edit.js

@@ -1,31 +1,6 @@
 import { action } from "../../core/action.js";
 import { validateUserId } from "../../core/identifiers.js";
 import { validateOptionObject } from "../../core/validation.js";
-import {
-  isTransformedScaleType,
-  SCALE_ROLES,
-  validateColorRange,
-  validateDiscretizedColorDomain,
-  validateDiscretizedColorRange,
-  validateOrdinalDomain,
-  validateScaleDomain,
-  validateScaleRange,
-  validateScaleType,
-  validateScaleTypeForRole,
-  validateShapeRange,
-  validateSizeRange,
-  validateStrokeDashRange,
-  validateSequentialColorRange,
-  validateScaleUnknown,
-  isDiscretizedColorScaleType,
-  isDiscretePositionScaleType,
-  hasOrdinalDomain,
-  normalizeScaleDefinition
-} from "../../grammar/scales/index.js";
-import {
-  validateRadialRange,
-  validateThetaRange
-} from "../../grammar/polar.js";
 import { getMarkMaterializationStep } from "../../materialization/marks/index.js";
 import {
   applyMaterializationPlan
@@ -35,7 +10,10 @@ import {
   requireSemanticScale
 } from "../../selectors/scales.js";
 import { findScaleConsumers } from "./consumers/index.js";
-import { normalizePositionScaleChannel } from "../../core/vocabulary.js";
+import {
+  prepareScaleEdit,
+  resolveScaleConsumerChannel
+} from "./editPolicy.js";
 
 const OPTIONS = Object.freeze([
   "id", "type", "domain", "range", "nice", "zero", "clamp", "reverse",
@@ -67,162 +45,6 @@ function resolveScaleId(program, requested) {
   );
 }
 
-function resolveChannel(consumers, id) {
-  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 channels.values().next().value;
-}
-
-function validateRangeForChannel(scale, channel, value) {
-  if (value === "auto") return value;
-  if (channel === "theta") return validateThetaRange(value);
-  if (channel === "radius") return validateRadialRange(value);
-  if (scale.type === "sequential") {
-    return validateSequentialColorRange(value);
-  }
-  if (isDiscretizedColorScaleType(scale.type)) {
-    return validateDiscretizedColorRange(value);
-  }
-  if (scale.type !== "ordinal") return validateScaleRange(value);
-  if (channel === "color") return validateColorRange(value);
-  if (channel === "shape") return validateShapeRange(value);
-  if (channel === "strokeDash") return validateStrokeDashRange(value);
-  if (channel === "size") return validateSizeRange(value);
-  return validateScaleRange(value);
-}
-
-function validateTypeTransition(scale, nextType, channel, consumers) {
-  if (nextType === scale.type) return;
-  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}".`
-      );
-    }
-    return;
-  }
-  if (nextType === "time") {
-    if (
-      consumers.length > 0 &&
-      (!["x", "y", "theta"].includes(channel) ||
-        consumers.some(consumer => consumer.encoding.fieldType !== "temporal"))
-    ) {
-      throw new Error(
-        `Scale "${scale.id}" has a consumer incompatible with type "time".`
-      );
-    }
-    return;
-  }
-  const discrete = isDiscretePositionScaleType(nextType);
-  if (discrete) {
-    if (
-      consumers.length > 0 &&
-      (!["x", "y", "theta"].includes(channel) || consumers.some(consumer =>
-        !["nominal", "ordinal"].includes(consumer.encoding.fieldType)
-      ))
-    ) {
-      throw new Error(
-        `Scale "${scale.id}" has a consumer incompatible with type "${nextType}".`
-      );
-    }
-    if (
-      nextType === "point" &&
-      consumers.some(consumer => consumer.layer.mark?.type === "bar")
-    ) {
-      throw new Error("Point scales cannot provide bar bandwidth.");
-    }
-    return;
-  }
-  const quantitative = nextType === "linear" || isTransformedScaleType(nextType);
-  if (
-    !quantitative ||
-    (consumers.length > 0 && !["x", "y", "theta", "radius"].includes(channel))
-  ) {
-    throw new Error(
-      "editScale type transition currently requires a quantitative position scale."
-    );
-  }
-  validateScaleTypeForRole(nextType, SCALE_ROLES.quantitativePosition);
-  if (channel === "theta" && nextType !== "linear") {
-    throw new Error("Theta quantitative position currently requires a linear scale.");
-  }
-  if (consumers.some(consumer => consumer.encoding.fieldType !== "quantitative")) {
-    throw new Error(
-      `Scale "${scale.id}" has a consumer incompatible with type "${nextType}".`
-    );
-  }
-}
-
-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, args) {
-  const type = args.type ?? scale.type;
-  validateTypeTransition(scale, type, channel, consumers);
-  const definition = normalizeScaleDefinition({
-    type,
-    previous: scale,
-    patch: args,
-    retainCoreOnTypeChange: true,
-    retainCompatibleOnTypeChange: true,
-    validateDomain: (scaleType, value) =>
-      isDiscretizedColorScaleType(scaleType)
-        ? validateDiscretizedColorDomain(scaleType, value)
-        : hasOrdinalDomain(scaleType)
-          ? validateOrdinalDomain(value)
-          : validateScaleDomain(value),
-    validateRange: (scaleType, value) =>
-      validateRangeForChannel({ type: scaleType }, channel, value)
-  });
-  const typeChanged = type !== scale.type;
-  const unknown = Object.hasOwn(args, "unknown")
-    ? args.unknown
-    : typeChanged ? undefined : scale.unknown;
-  if (unknown !== undefined) {
-    if (consumers.some(consumer => consumer.layer.mark?.type !== "point")) {
-      throw new Error(
-        "Scale unknown currently requires row-owned point consumers."
-      );
-    }
-    definition.unknown = consumers.length === 0
-      ? unknown
-      : validateScaleUnknown(channel, unknown);
-  }
-  return definition;
-}
-
 function sameValue(left, right) {
   return JSON.stringify(left) === JSON.stringify(right);
 }
@@ -254,31 +76,11 @@ export const editScale = action(
     if (!REQUESTED_CHANGES.some(property => Object.hasOwn(args, property))) {
       throw new Error("editScale requires at least one editable property.");
     }
-    const hasPalette = Object.hasOwn(args, "palette");
-    if (hasPalette && Object.hasOwn(args, "range")) {
-      throw new Error("editScale cannot specify both palette and range.");
-    }
-
     const id = resolveScaleId(this, args.id);
     const scale = requireSemanticScale(this, id);
     const consumers = findScaleConsumers(this, id);
-    const channel = resolveChannel(consumers, id);
-    if (
-      hasPalette &&
-      channel !== "color" &&
-      scale.type !== "sequential" &&
-      !isDiscretizedColorScaleType(scale.type)
-    ) {
-      throw new Error("editScale palette requires a color scale.");
-    }
-    const patch = !hasPalette
-      ? args
-      : Object.fromEntries([
-          ...Object.entries(args).filter(([key]) => key !== "palette"),
-          ["range", { palette: args.palette }]
-        ]);
-    validateLegendTypeTransition(this, scale, args.type ?? scale.type);
-    const definition = normalizeDefinition(scale, channel, consumers, patch);
+    const channel = resolveScaleConsumerChannel(consumers, id);
+    const definition = prepareScaleEdit(this, scale, channel, consumers, args);
 
     let next = this;
     for (const property of EDITABLE) {

package/src/actions/scales/editPolicy.js

@@ -0,0 +1,214 @@
+import {
+  hasOrdinalDomain,
+  isDiscretizedColorScaleType,
+  isDiscretePositionScaleType,
+  isTransformedScaleType,
+  normalizeScaleDefinition,
+  SCALE_ROLES,
+  validateColorRange,
+  validateDiscretizedColorDomain,
+  validateDiscretizedColorRange,
+  validateOrdinalDomain,
+  validateScaleDomain,
+  validateScaleRange,
+  validateScaleType,
+  validateScaleTypeForRole,
+  validateScaleUnknown,
+  validateSequentialColorRange,
+  validateShapeRange,
+  validateSizeRange,
+  validateStrokeDashRange,
+  validateStrokeWidthRange
+} from "../../grammar/scales/index.js";
+import {
+  validateRadialRange,
+  validateThetaRange
+} from "../../grammar/polar.js";
+import { normalizePositionScaleChannel } from "../../core/vocabulary.js";
+
+export function resolveScaleConsumerChannel(consumers, id) {
+  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 channels.values().next().value;
+}
+
+function validateRangeForChannel(scale, channel, value) {
+  if (value === "auto") return value;
+  if (channel === "theta") return validateThetaRange(value);
+  if (channel === "radius") return validateRadialRange(value);
+  if (scale.type === "sequential") {
+    return validateSequentialColorRange(value);
+  }
+  if (isDiscretizedColorScaleType(scale.type)) {
+    return validateDiscretizedColorRange(value);
+  }
+  if (scale.type !== "ordinal") return validateScaleRange(value);
+  if (channel === "color") return validateColorRange(value);
+  if (channel === "shape") return validateShapeRange(value);
+  if (channel === "strokeDash") return validateStrokeDashRange(value);
+  if (channel === "size") return validateSizeRange(value);
+  if (channel === "strokeWidth") return validateStrokeWidthRange(value);
+  return validateScaleRange(value);
+}
+
+function validateTypeTransition(scale, nextType, channel, consumers) {
+  if (nextType === scale.type) return;
+  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}".`
+      );
+    }
+    return;
+  }
+  if (nextType === "time") {
+    if (
+      !["x", "y", "theta"].includes(channel) ||
+      consumers.some(consumer => consumer.encoding.fieldType !== "temporal")
+    ) {
+      throw new Error(
+        `Scale "${scale.id}" has a consumer incompatible with type "time".`
+      );
+    }
+    return;
+  }
+  if (isDiscretePositionScaleType(nextType)) {
+    if (
+      !["x", "y", "theta"].includes(channel) || consumers.some(consumer =>
+        !["nominal", "ordinal"].includes(consumer.encoding.fieldType)
+      )
+    ) {
+      throw new Error(
+        `Scale "${scale.id}" has a consumer incompatible with type "${nextType}".`
+      );
+    }
+    if (
+      nextType === "point" &&
+      consumers.some(consumer => consumer.layer.mark?.type === "bar")
+    ) {
+      throw new Error("Point scales cannot provide bar bandwidth.");
+    }
+    return;
+  }
+  const quantitative = nextType === "linear" || isTransformedScaleType(nextType);
+  if (
+    !quantitative ||
+    !["x", "y", "theta", "radius", "strokeWidth"].includes(channel)
+  ) {
+    throw new Error(
+      "editScale type transition currently requires a quantitative position scale."
+    );
+  }
+  validateScaleTypeForRole(nextType, SCALE_ROLES.quantitativePosition);
+  if (channel === "theta" && nextType !== "linear") {
+    throw new Error("Theta quantitative position currently requires a linear scale.");
+  }
+  if (
+    channel === "strokeWidth" &&
+    consumers.some(consumer => !["line", "rule"].includes(consumer.layer.mark?.type))
+  ) {
+    throw new Error(
+      `Scale "${scale.id}" has a consumer incompatible with type "${nextType}".`
+    );
+  }
+  if (consumers.some(consumer => consumer.encoding.fieldType !== "quantitative")) {
+    throw new Error(
+      `Scale "${scale.id}" has a consumer incompatible with type "${nextType}".`
+    );
+  }
+}
+
+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) {
+  const type = patch.type ?? scale.type;
+  validateTypeTransition(scale, type, channel, consumers);
+  const definition = normalizeScaleDefinition({
+    type,
+    previous: scale,
+    patch,
+    retainCoreOnTypeChange: true,
+    retainCompatibleOnTypeChange: true,
+    validateDomain: (scaleType, value) =>
+      isDiscretizedColorScaleType(scaleType)
+        ? validateDiscretizedColorDomain(scaleType, value)
+        : hasOrdinalDomain(scaleType)
+          ? validateOrdinalDomain(value)
+          : validateScaleDomain(value),
+    validateRange: (scaleType, value) =>
+      validateRangeForChannel({ type: scaleType }, channel, value)
+  });
+  if (
+    channel === "strokeWidth" &&
+    definition.domain !== "auto" &&
+    definition.domain.some(value => value < 0)
+  ) {
+    throw new RangeError("StrokeWidth scale domain cannot contain negative values.");
+  }
+  const typeChanged = type !== scale.type;
+  const unknown = Object.hasOwn(patch, "unknown")
+    ? patch.unknown
+    : typeChanged ? undefined : scale.unknown;
+  if (unknown !== undefined) {
+    if (consumers.some(consumer => consumer.layer.mark?.type !== "point")) {
+      throw new Error("Scale unknown currently requires row-owned point consumers.");
+    }
+    definition.unknown = consumers.length === 0
+      ? unknown
+      : validateScaleUnknown(channel, unknown);
+  }
+  return definition;
+}
+
+export function prepareScaleEdit(program, scale, channel, consumers, args) {
+  const hasPalette = Object.hasOwn(args, "palette");
+  if (hasPalette && Object.hasOwn(args, "range")) {
+    throw new Error("editScale cannot specify both palette and range.");
+  }
+  if (
+    hasPalette &&
+    channel !== "color" &&
+    scale.type !== "sequential" &&
+    !isDiscretizedColorScaleType(scale.type)
+  ) {
+    throw new Error("editScale palette requires a color scale.");
+  }
+  const patch = !hasPalette
+    ? args
+    : Object.fromEntries([
+        ...Object.entries(args).filter(([key]) => key !== "palette"),
+        ["range", { palette: args.palette }]
+      ]);
+  validateLegendTypeTransition(program, scale, args.type ?? scale.type);
+  return normalizeDefinition(scale, channel, consumers, patch);
+}

package/src/actions/scales/materialize.js

@@ -70,7 +70,7 @@ export const rematerializeScale = action(
       channel,
       consumers,
       valuesByConsumer,
-      bounds: ["color", "strokeDash", "shape", "size", "opacity", "xOffset", "yOffset"]
+      bounds: ["color", "strokeDash", "strokeWidth", "shape", "size", "opacity", "xOffset", "yOffset"]
         .includes(channel)
         ? undefined
         : resolveGraphicBounds(this),

package/src/actions/scales/patch.js

@@ -0,0 +1,26 @@
+const SCALE_EDIT_PROPERTIES = Object.freeze([
+  "type", "domain", "range", "nice", "zero", "clamp", "reverse",
+  "base", "exponent", "constant", "paddingInner", "paddingOuter",
+  "padding", "align", "interpolate", "unknown"
+]);
+
+function sameValue(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+
+export function scaleEditPatch(id, definition) {
+  return {
+    id,
+    ...Object.fromEntries(SCALE_EDIT_PROPERTIES
+      .filter(property => Object.hasOwn(definition, property))
+      .map(property => [property, definition[property]]))
+  };
+}
+
+export function changedScaleEditPatch(current, definition) {
+  const patch = scaleEditPatch(current.id, definition);
+  return Object.entries(patch).some(
+    ([property, value]) => property !== "id" &&
+      !sameValue(current[property], value)
+  ) ? patch : undefined;
+}