ggaction 0.0.13 → 0.0.16

package/src/actions/scales/materialize.js

@@ -27,7 +27,7 @@ function validateOptions(args) {
   }
 }
 
-export const rematerializeScale = action(
+export const rematerializeScale = /* @__PURE__ */ action(
   {
     op: "rematerializeScale",
     description: "Recompute every concrete consumer of a scale."
@@ -52,9 +52,10 @@ export const rematerializeScale = action(
       ) {
         continue;
       }
+      const consumerChannel = consumer.channel;
       const materializationMode = getScaleConsumerMaterializationMode(
         consumer.layer,
-        channel
+        consumerChannel
       );
       if (materializationMode === "rematerialize") {
         if (args.marks !== false) {
@@ -71,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 = /* @__PURE__ */ createOffsetScaleEditor("xOffset");
+export const editYOffsetScale = /* @__PURE__ */ 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 = /* @__PURE__ */ 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/preview.js

@@ -1,39 +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";
 
-export function resolveScalePreview(program, id) {
+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 channels = new Set(consumers.map(consumer => normalizePositionScaleChannel(consumer.channel)));
-  if (channels.size !== 1) throw new Error(`Scale "${id}" cannot be shared across channels.`);
-  const channel = channels.values().next().value;
+  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) {
-      return { consumer, values: [], categoryOrder: undefined, seriesLayout: undefined };
+    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", "strokeDash", "strokeWidth", "shape", "size", "opacity", "xOffset", "yOffset"].includes(channel)
-      ? undefined : resolveGraphicBounds(program),
-    resolvedScales: program.resolvedScales, markConfigs: program.markConfigs, thetaScales: scale.radialMapping === undefined ? undefined : Object.fromEntries(consumers.map(({ layer }) =>
+    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", resolveGraphicBounds(program)), markConfigs: program.markConfigs });
+    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

@@ -1,5 +1,5 @@
-import { action } from "../../core/action.js";
-import { validateKeys } from "../../core/validation.js";
+import { closedAction } from "../../core/action.js";
+
 import { findSemanticScale } from "../../selectors/scales.js";
 
 const OPTIONS = Object.freeze([
@@ -13,13 +13,12 @@ const OPTIONS = Object.freeze([
   "unknown"
 ]);
 
-export const setQuantitativeColorScale = action(
+export const setQuantitativeColorScale = /* @__PURE__ */ closedAction(
   {
     op: "setQuantitativeColorScale",
     description: "Create or update an internal quantitative color scale."
-  },
+  }, OPTIONS,
   function (args = {}) {
-    validateKeys(args, OPTIONS, "setQuantitativeColorScale");
     if (!["sequential", "quantize", "quantile", "threshold"].includes(args.type)) {
       throw new Error(`Unsupported quantitative color scale type "${args.type}".`);
     }