ggaction 0.0.2 → 0.0.4

package/src/actions/scales/definitions.js

@@ -22,8 +22,12 @@ import {
   validateScalePropertyForType,
   validateScaleTypeForRole,
   isDiscretePositionScaleType
-} from "../../grammar/scales.js";
-import { withScaleUnknown } from "../../grammar/scales.js";
+} from "../../grammar/scales/index.js";
+import {
+  validateRadialRange,
+  validateThetaRange
+} from "../../grammar/polar.js";
+import { withScaleUnknown } from "../../grammar/scales/index.js";
 import { findSemanticScale } from "../../selectors/scales.js";
 
 const BASE_OPTIONS = Object.freeze(["id", "type", "domain", "range"]);
@@ -87,6 +91,7 @@ export function resolvePositionScaleDefinition(
       );
     }
   }
+  else if (channel === "theta") validateLinearScaleType(type);
   else validateScaleTypeForRole(type, SCALE_ROLES.quantitativePosition);
   const scale = {
     id,
@@ -108,7 +113,11 @@ export function resolvePositionScaleDefinition(
         ["ordinal", "nominal"].includes(fieldType)
           ? validateOrdinalDomain(value)
           : validateScaleDomain(value),
-      validateRange: (_scaleType, value) => validateScaleRange(value)
+      validateRange: (_scaleType, value) => channel === "theta"
+        ? validateThetaRange(value)
+        : channel === "radius"
+          ? validateRadialRange(value)
+          : validateScaleRange(value)
     })
   };
   return withScaleUnknown(scale, { ...existing, ...options }, channel);
@@ -305,15 +314,15 @@ export function resolveOpacityScaleDefinition(program, options) {
   return withScaleUnknown(scale, { ...existing, ...options }, "opacity");
 }
 
-export function resolveOffsetScaleDefinition(program, options) {
+export function resolveOffsetScaleDefinition(program, options, channel = "xOffset") {
   optionsObject(options);
   validateKeys(options, [...BASE_OPTIONS, "unknown"], "scale");
-  const id = validateUserId(options.id ?? "xOffset", "Scale id");
+  const id = validateUserId(options.id ?? channel, "Scale id");
   const existing = findSemanticScale(program, id);
   return withScaleUnknown({
     id,
     type: validateOrdinalScaleType(options.type ?? existing?.type ?? "ordinal"),
     domain: validateOrdinalDomain(options.domain ?? existing?.domain ?? "auto"),
     range: validateScaleRange(options.range ?? existing?.range ?? "auto")
-  }, { ...existing, ...options }, "xOffset");
+  }, { ...existing, ...options }, channel);
 }

package/src/actions/scales/edit.js

@@ -1,7 +1,6 @@
 import { action } from "../../core/action.js";
 import { validateUserId } from "../../core/identifiers.js";
-import { isPlainObject } from "../../core/immutable.js";
-import { validateKeys } from "../../core/validation.js";
+import { validateOptionObject } from "../../core/validation.js";
 import {
   isTransformedScaleType,
   SCALE_ROLES,
@@ -22,8 +21,12 @@ import {
   isDiscretePositionScaleType,
   hasOrdinalDomain,
   normalizeScaleDefinition
-} from "../../grammar/scales.js";
-import { getMarkMaterializationStep } from "../../materialization/marks.js";
+} from "../../grammar/scales/index.js";
+import {
+  validateRadialRange,
+  validateThetaRange
+} from "../../grammar/polar.js";
+import { getMarkMaterializationStep } from "../../materialization/marks/index.js";
 import {
   applyMaterializationPlan
 } from "../../materialization/dependencies.js";
@@ -31,14 +34,18 @@ import {
   findSemanticScale,
   requireSemanticScale
 } from "../../selectors/scales.js";
-import { findScaleConsumers } from "./consumers.js";
+import { findScaleConsumers } from "./consumers/index.js";
+import { normalizePositionScaleChannel } from "../../core/vocabulary.js";
 
 const OPTIONS = Object.freeze([
   "id", "type", "domain", "range", "nice", "zero", "clamp", "reverse",
   "base", "exponent", "constant", "paddingInner", "paddingOuter", "padding",
-  "align", "interpolate", "unknown"
+  "align", "interpolate", "unknown", "palette"
 ]);
-const EDITABLE = Object.freeze(OPTIONS.filter(option => option !== "id"));
+const EDITABLE = Object.freeze(
+  OPTIONS.filter(option => !["id", "palette"].includes(option))
+);
+const REQUESTED_CHANGES = Object.freeze(OPTIONS.filter(option => option !== "id"));
 
 function resolveScaleId(program, requested) {
   if (requested !== undefined) {
@@ -60,13 +67,9 @@ function resolveScaleId(program, requested) {
   );
 }
 
-function normalizeChannel(channel) {
-  return channel === "x2" ? "x" : channel === "y2" ? "y" : channel;
-}
-
 function resolveChannel(consumers, id) {
   const channels = new Set(
-    consumers.map(consumer => normalizeChannel(consumer.channel))
+    consumers.map(consumer => normalizePositionScaleChannel(consumer.channel))
   );
   if (channels.size > 1) {
     throw new Error(`Scale "${id}" cannot be shared across channels.`);
@@ -76,6 +79,8 @@ function resolveChannel(consumers, id) {
 
 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);
   }
@@ -97,7 +102,7 @@ function validateTypeTransition(scale, nextType, channel, consumers) {
   if (nextType === "sequential" || isDiscretizedColorScaleType(nextType)) {
     const discretized = isDiscretizedColorScaleType(nextType);
     if (channel !== "color" || consumers.some(consumer =>
-      consumer.encoding.fieldType === "nominal" ||
+      ["nominal", "ordinal"].includes(consumer.encoding.fieldType) ||
       (discretized && (
         consumer.encoding.fieldType !== "quantitative" ||
         consumer.layer.mark?.type !== "point"
@@ -113,7 +118,7 @@ function validateTypeTransition(scale, nextType, channel, consumers) {
   if (nextType === "time") {
     if (
       consumers.length > 0 &&
-      (!["x", "y"].includes(channel) ||
+      (!["x", "y", "theta"].includes(channel) ||
         consumers.some(consumer => consumer.encoding.fieldType !== "temporal"))
     ) {
       throw new Error(
@@ -126,7 +131,7 @@ function validateTypeTransition(scale, nextType, channel, consumers) {
   if (discrete) {
     if (
       consumers.length > 0 &&
-      (!["x", "y"].includes(channel) || consumers.some(consumer =>
+      (!["x", "y", "theta"].includes(channel) || consumers.some(consumer =>
         !["nominal", "ordinal"].includes(consumer.encoding.fieldType)
       ))
     ) {
@@ -145,13 +150,16 @@ function validateTypeTransition(scale, nextType, channel, consumers) {
   const quantitative = nextType === "linear" || isTransformedScaleType(nextType);
   if (
     !quantitative ||
-    (consumers.length > 0 && !["x", "y"].includes(channel))
+    (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}".`
@@ -242,20 +250,35 @@ export const editScale = action(
     description: "Edit an existing scale and rematerialize its consumers."
   },
   function (args = {}) {
-    if (!isPlainObject(args)) {
-      throw new TypeError("editScale options must be a plain object.");
-    }
-    validateKeys(args, OPTIONS, "editScale");
-    if (!EDITABLE.some(property => Object.hasOwn(args, property))) {
+    validateOptionObject(args, OPTIONS, "editScale");
+    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, args);
+    const definition = normalizeDefinition(scale, channel, consumers, patch);
 
     let next = this;
     for (const property of EDITABLE) {