ggaction 0.0.13 → 0.0.15

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);
 }
 

package/src/actions/scales/materialize.js

@@ -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 = createOffsetScaleEditor("xOffset");
+export const editYOffsetScale = 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 = 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: {} });
 }