ggaction 0.0.11 → 0.0.12

package/src/actions/encodings/position/apply.js

@@ -80,6 +80,28 @@ function applyArcThetaWeight(program, target, channel, previous, aggregate, weig
   });
 }
 
+function removeStaleArcThetaAggregate(
+  program,
+  target,
+  channel,
+  previous,
+  fieldType,
+  aggregate
+) {
+  if (
+    channel !== "theta" ||
+    fieldType !== "quantitative" ||
+    aggregate !== undefined ||
+    previous?.aggregate === undefined
+  ) {
+    return program;
+  }
+  return program.editSemantic({
+    property: `layer[${target}].encoding.theta.aggregate`,
+    remove: true
+  });
+}
+
 export function applyPositionSemantics(program, {
   target,
   channel,
@@ -124,6 +146,14 @@ export function applyPositionSemantics(program, {
       value
     });
   }
+  next = removeStaleArcThetaAggregate(
+    next,
+    target,
+    channel,
+    previous,
+    fieldType,
+    aggregate
+  );
   return applyArcThetaWeight(
     next,
     target,

package/src/actions/encodings/position/policies/arc.js

@@ -2,7 +2,7 @@ import { validateAggregate } from "../../../../grammar/aggregate.js";
 import { validateNonEmptyString } from "../../../../core/validation.js";
 import { emptyPositionPolicy } from "./common.js";
 
-export function resolveArcPositionPolicy({ channel, args, fieldType }) {
+export function resolveArcPositionPolicy({ channel, args, fieldType, layer }) {
   if (args.bin !== undefined) {
     throw new Error(`Arc ${channel} encoding does not support bin.`);
   }
@@ -10,6 +10,11 @@ export function resolveArcPositionPolicy({ channel, args, fieldType }) {
     throw new Error(`Arc ${channel} encoding does not support stack.`);
   }
   if (channel === "radius") {
+    if (layer.encoding?.theta?.fieldType === "quantitative") {
+      throw new Error(
+        "Arc radius encoding cannot be combined with quantitative theta."
+      );
+    }
     if (args.aggregate !== undefined) {
       throw new Error("Arc radius encoding does not support aggregate.");
     }
@@ -18,8 +23,24 @@ export function resolveArcPositionPolicy({ channel, args, fieldType }) {
     }
     return emptyPositionPolicy();
   }
+  if (fieldType === "quantitative") {
+    if (layer.encoding?.radius !== undefined) {
+      throw new Error(
+        "Quantitative arc theta cannot be combined with radius encoding."
+      );
+    }
+    if (args.aggregate !== undefined) {
+      throw new Error("Quantitative arc theta does not support aggregate.");
+    }
+    if (args.weight !== undefined) {
+      throw new Error("Quantitative arc theta does not support weight.");
+    }
+    return emptyPositionPolicy();
+  }
   if (!["ordinal", "nominal"].includes(fieldType)) {
-    throw new Error("Arc theta encoding requires an ordinal or nominal field.");
+    throw new Error(
+      "Arc theta encoding requires a quantitative, ordinal, or nominal field."
+    );
   }
   if (args.aggregate === undefined) {
     if (args.weight !== undefined) {

package/src/actions/encodings/position/resolve.js

@@ -22,7 +22,10 @@ import {
   validateAggregateFieldValues,
 } from "../../../grammar/aggregate.js";
 import { normalizeRuleDatum } from "../../../grammar/rules.js";
-import { readArcThetaWeights } from "../../../grammar/arcs.js";
+import {
+  readArcThetaValues,
+  readArcThetaWeights
+} from "../../../grammar/arcs.js";
 import { resolveMarkPositionPolicy } from "./policies/index.js";
 import {
   getPositionChannelDefinition,
@@ -128,9 +131,14 @@ export function resolvePositionEncoding(program, channel, args, operation) {
     : args.field;
   const datum = args.datum;
   const effectiveArgs = { ...args };
+  const directQuantitativeArcTheta =
+    layer.mark.type === "arc" &&
+    channel === "theta" &&
+    fieldType === "quantitative";
   for (const property of ["aggregate", "bin", "stack"]) {
     if (!Object.hasOwn(effectiveArgs, property) && previous !== undefined &&
-      Object.hasOwn(previous, property)) {
+      Object.hasOwn(previous, property) &&
+      !(directQuantitativeArcTheta && property === "aggregate")) {
       effectiveArgs[property] = previous[property];
     }
   }
@@ -220,6 +228,8 @@ export function resolvePositionEncoding(program, channel, args, operation) {
     policy.aggregate === "sum"
   ) {
     readArcThetaWeights(dataset.values, policy.weight, layer.id);
+  } else if (directQuantitativeArcTheta) {
+    readArcThetaValues(dataset.values, field, layer.id);
   } else if (program.markConfigs[target]?.boxPlot !== undefined) {
     for (const [index, row] of dataset.values.entries()) {
       const value = row[field];

package/src/actions/errorBars/create.js

@@ -1,7 +1,16 @@
 import { action } from "../../core/action.js";
-import { validateKeys } from "../../core/validation.js";
+import {
+  validateKeys,
+  validateOptionObject
+} from "../../core/validation.js";
 import { findLayer } from "../../selectors/layers.js";
+import { findDataset } from "../../selectors/datasets.js";
 import { DEFAULT_COLORS } from "../../theme/defaults.js";
+import {
+  readNominalField,
+  validateCategoricalFieldType
+} from "../../grammar/scales/index.js";
+import { normalizeOffsetPadding } from "../../grammar/bars/geometry.js";
 import { createResolvedIntervalData, ownOptions } from
   "../data/intervalEdit.js";
 import { resolveIntervalComposite } from "../intervals/resolve.js";
@@ -13,6 +22,8 @@ const OPTIONS = Object.freeze([
   "data",
   "x",
   "y",
+  "xOffset",
+  "yOffset",
   "groupBy",
   "coordinate",
   "caps",
@@ -23,30 +34,88 @@ const OPTIONS = Object.freeze([
   "opacity"
 ]);
 
+const OFFSET_OPTIONS = Object.freeze([
+  "field", "fieldType", "scale", "paddingInner", "paddingOuter"
+]);
+
 const ERROR_BAR_POLICY = Object.freeze({
   operation: "createErrorBar",
   resourceLabel: "error-bar",
   defaultId: "errorBar",
   ownerLabel: "Error-bar id",
-  positionTypes: Object.freeze(["nominal", "ordinal", "temporal"]),
+  positionTypes: Object.freeze([
+    "quantitative", "nominal", "ordinal", "temporal"
+  ]),
   defaultPositionType: "nominal",
   defaultIntervalChannel: "y",
   scaleDefaults: () => ({}),
   intervalScaleDefaults: Object.freeze({ nice: true, zero: false }),
   allowExplicitGrouping: false,
   ambiguousMessage:
-    "createErrorBar requires one quantitative interval axis and one nominal, ordinal, or temporal position axis."
+    "createErrorBar requires one quantitative interval axis and one compatible position axis; use interval options to disambiguate two quantitative channels."
 });
 
 function resolveErrorBar(program, args) {
   const resolved = resolveIntervalComposite(program, args, ERROR_BAR_POLICY);
+  const offset = resolveErrorBarOffset(program, args, resolved);
+  const groupBy = resolved.interval.mode === "statistical" && offset !== undefined
+    ? [...new Set([...resolved.groupBy, offset.field])]
+    : resolved.groupBy;
   return {
     ...resolved,
+    groupBy,
+    offset,
     lowerCapId: `${resolved.id}LowerCap`,
     upperCapId: `${resolved.id}UpperCap`
   };
 }
 
+function resolveErrorBarOffset(program, args, resolved) {
+  const channel = `${resolved.position.channel}Offset`;
+  const incompatible = channel === "xOffset" ? "yOffset" : "xOffset";
+  if (args[incompatible] !== undefined) {
+    throw new Error(
+      `createErrorBar ${incompatible} does not match the ${resolved.orientation} interval orientation.`
+    );
+  }
+  const explicit = args[channel] === undefined
+    ? undefined
+    : validateOptionObject(args[channel], OFFSET_OPTIONS, `createErrorBar ${channel}`);
+  const inferred = resolved.sourceLayer?.encoding?.[channel];
+  if (explicit === undefined && inferred === undefined) return undefined;
+  if (!["nominal", "ordinal"].includes(resolved.position.fieldType)) {
+    throw new Error(
+      `createErrorBar ${channel} requires a categorical ${resolved.position.channel} position.`
+    );
+  }
+  const field = explicit?.field ?? inferred?.field;
+  if (typeof field !== "string" || field.length === 0) {
+    throw new TypeError(`createErrorBar ${channel} field must be a non-empty string.`);
+  }
+  const fieldType = validateCategoricalFieldType(
+    explicit?.fieldType ?? inferred?.fieldType ?? "nominal"
+  );
+  const dataset = findDataset(program, resolved.source);
+  readNominalField(dataset.values, field);
+  const padding = normalizeOffsetPadding(
+    explicit ?? {},
+    resolved.sourceLayer === undefined
+      ? undefined
+      : program.markConfigs[resolved.sourceLayer.id]?.[channel],
+    channel
+  );
+  return {
+    channel,
+    field,
+    fieldType,
+    scale: {
+      ...(inferred?.scale === undefined ? {} : { id: inferred.scale }),
+      ...(explicit?.scale ?? {})
+    },
+    ...padding
+  };
+}
+
 function resolveAppearance(args) {
   return resolveErrorBarAppearance(ownOptions(args, [
     "caps", "capSize", "stroke", "strokeWidth", "strokeDash", "opacity"
@@ -72,15 +141,26 @@ export const createErrorBarCap = action(
     validateKeys(args, [
       "id", "data", "orientation", "positionField", "positionFieldType",
       "intervalField", "coordinate", "positionScale", "intervalScale",
+      "offsetChannel", "offsetField", "offsetFieldType", "offsetScale",
+      "offsetPaddingInner", "offsetPaddingOuter",
       "capSize", "stroke", "strokeWidth", "strokeDash", "opacity"
     ], "createErrorBarCap");
     if (!["vertical", "horizontal"].includes(args.orientation)) {
       throw new Error(`Unsupported error-bar orientation "${args.orientation}".`);
     }
     const vertical = args.orientation === "vertical";
+    const expectedOffset = vertical ? "xOffset" : "yOffset";
+    if (
+      args.offsetChannel !== undefined &&
+      args.offsetChannel !== expectedOffset
+    ) {
+      throw new Error(
+        `createErrorBarCap requires ${expectedOffset} for ${args.orientation} intervals.`
+      );
+    }
     const positionAction = vertical ? "encodeX" : "encodeY";
     const intervalAction = vertical ? "encodeY" : "encodeX";
-    return this
+    let next = this
       .createRuleMark({ id: args.id, data: args.data })
       [positionAction]({
         target: args.id,
@@ -95,7 +175,21 @@ export const createErrorBarCap = action(
         fieldType: "quantitative",
         coordinate: args.coordinate,
         scale: { id: args.intervalScale }
-      })
+      });
+    if (args.offsetChannel !== undefined) {
+      const offsetAction = args.offsetChannel === "xOffset"
+        ? "encodeXOffset"
+        : "encodeYOffset";
+      next = next[offsetAction]({
+        target: args.id,
+        field: args.offsetField,
+        fieldType: args.offsetFieldType,
+        scale: { id: args.offsetScale },
+        paddingInner: args.offsetPaddingInner,
+        paddingOuter: args.offsetPaddingOuter
+      });
+    }
+    return next
       .encodeStroke({ target: args.id, value: args.stroke })
       .encodeStrokeWidth({ target: args.id, value: args.strokeWidth })
       .encodeStrokeDash({ target: args.id, value: args.strokeDash })
@@ -118,6 +212,19 @@ function positionArgs(resolved) {
   };
 }
 
+function offsetArgs(resolved) {
+  return resolved.offset === undefined
+    ? undefined
+    : {
+        target: resolved.id,
+        field: resolved.offset.field,
+        fieldType: resolved.offset.fieldType,
+        scale: resolved.offset.scale,
+        paddingInner: resolved.offset.paddingInner,
+        paddingOuter: resolved.offset.paddingOuter
+      };
+}
+
 function intervalArgs(resolved, field) {
   return {
     target: resolved.id,
@@ -154,8 +261,14 @@ export const createErrorBar = action(
       target: resolved.id,
       field: resolved.fields.upper,
       fieldType: "quantitative"
-    })
-      .encodeStroke({ target: resolved.id, value: appearance.stroke })
+    });
+    if (resolved.offset !== undefined) {
+      const offsetAction = resolved.offset.channel === "xOffset"
+        ? "encodeXOffset"
+        : "encodeYOffset";
+      next = next[offsetAction](offsetArgs(resolved));
+    }
+    next = next.encodeStroke({ target: resolved.id, value: appearance.stroke })
       .encodeStrokeWidth({ target: resolved.id, value: appearance.strokeWidth })
       .encodeStrokeDash({ target: resolved.id, value: appearance.strokeDash })
       .encodeOpacity({ target: resolved.id, value: appearance.opacity });
@@ -173,6 +286,16 @@ export const createErrorBar = action(
           coordinate: resolved.coordinate,
           positionScale: intervalLayer.encoding[resolved.position.channel].scale,
           intervalScale: intervalLayer.encoding[resolved.interval.channel].scale,
+          ...(resolved.offset === undefined
+            ? {}
+            : {
+                offsetChannel: resolved.offset.channel,
+                offsetField: resolved.offset.field,
+                offsetFieldType: resolved.offset.fieldType,
+                offsetScale: intervalLayer.encoding[resolved.offset.channel].scale,
+                offsetPaddingInner: resolved.offset.paddingInner,
+                offsetPaddingOuter: resolved.offset.paddingOuter
+              }),
           capSize: appearance.capSize,
           stroke: appearance.stroke,
           strokeWidth: appearance.strokeWidth,
@@ -193,6 +316,14 @@ export const createErrorBar = action(
         coordinate: resolved.coordinate,
         positionScale: intervalLayer.encoding[resolved.position.channel].scale,
         intervalScale: intervalLayer.encoding[resolved.interval.channel].scale,
+        ...(resolved.offset === undefined
+          ? {}
+          : {
+              offset: {
+                ...resolved.offset,
+                scale: intervalLayer.encoding[resolved.offset.channel].scale
+              }
+            }),
         lowerCapId: resolved.lowerCapId,
         upperCapId: resolved.upperCapId,
         ...appearance

package/src/actions/errorBars/edit.js

@@ -94,6 +94,16 @@ function capArgs(config, id, intervalField) {
     coordinate: config.coordinate,
     positionScale: config.positionScale,
     intervalScale: config.intervalScale,
+    ...(config.offset === undefined
+      ? {}
+      : {
+          offsetChannel: config.offset.channel,
+          offsetField: config.offset.field,
+          offsetFieldType: config.offset.fieldType,
+          offsetScale: config.offset.scale,
+          offsetPaddingInner: config.offset.paddingInner,
+          offsetPaddingOuter: config.offset.paddingOuter
+        }),
     capSize: config.capSize,
     stroke: config.stroke,
     strokeWidth: config.strokeWidth,

package/src/actions/marks/point/materialize.js

@@ -22,7 +22,10 @@ import {
 import { findDataset } from "../../../selectors/datasets.js";
 import { findLayer } from "../../../selectors/layers.js";
 import { rematerializeHighlightBaseline } from "../lifecycle.js";
-import { resolveRowEncodingValues } from
+import {
+  resolveRowEncodingValues,
+  resolveRowPositionValues
+} from
   "../../../materialization/rowEncoding.js";
 
 const REMATERIALIZE_OPTIONS = Object.freeze(["id"]);
@@ -33,8 +36,8 @@ function resolvePointPositions(program, layer, dataset) {
     layer.encoding?.radius !== undefined;
   if (!hasPolar) {
     return {
-      x: resolveRowEncodingValues(program, layer, dataset, "x"),
-      y: resolveRowEncodingValues(program, layer, dataset, "y")
+      x: resolveRowPositionValues(program, layer, dataset, "x"),
+      y: resolveRowPositionValues(program, layer, dataset, "y")
     };
   }
   const theta = resolveRowEncodingValues(program, layer, dataset, "theta");
@@ -222,8 +225,20 @@ export const rematerializePointMark = action(
       resetValue: []
     });
     if (highlighted !== undefined) return highlighted;
-    const layer = findLayer(this, id);
-    const graphic = this.graphicSpec.objects[id];
+    let resolved = this;
+    const initialLayer = findLayer(resolved, id);
+    for (const channel of ["xOffset", "yOffset"]) {
+      const scaleId = initialLayer?.encoding?.[channel]?.scale;
+      if (scaleId !== undefined) {
+        resolved = resolved.rematerializeScale({
+          id: scaleId,
+          guides: false,
+          marks: false
+        });
+      }
+    }
+    const layer = findLayer(resolved, id);
+    const graphic = resolved.graphicSpec.objects[id];
 
     if (layer?.mark?.type !== "point") {
       throw new Error(`Unknown point mark "${id}".`);
@@ -231,18 +246,23 @@ export const rematerializePointMark = action(
     if (!["circle", "rect", "path", "collection"].includes(graphic?.type)) {
       throw new Error(`Point mark "${id}" requires point graphics.`);
     }
-    const dataset = findDataset(this, layer.data);
+    const dataset = findDataset(resolved, layer.data);
     if (dataset === undefined) {
       throw new Error(`Point mark "${id}" requires an existing dataset.`);
     }
 
-    const positions = resolvePointPositions(this, layer, dataset);
-    const mappedFill = resolveRowEncodingValues(this, layer, dataset, "color");
-    const area = resolveRowEncodingValues(this, layer, dataset, "size");
-    const encodedShape = resolveRowEncodingValues(this, layer, dataset, "shape");
-    const encodedOpacity = resolveRowEncodingValues(this, layer, dataset, "opacity");
+    const positions = resolvePointPositions(resolved, layer, dataset);
+    const mappedFill = resolveRowEncodingValues(resolved, layer, dataset, "color");
+    const area = resolveRowEncodingValues(resolved, layer, dataset, "size");
+    const encodedShape = resolveRowEncodingValues(resolved, layer, dataset, "shape");
+    const encodedOpacity = resolveRowEncodingValues(
+      resolved,
+      layer,
+      dataset,
+      "opacity"
+    );
     const angles = resolveDirectionValues(dataset.values, layer.encoding?.angle);
-    const config = this.markConfigs[id] ?? {};
+    const config = resolved.markConfigs[id] ?? {};
     const fill = mappedFill ?? config.fill ?? DEFAULT_POINT_FILL;
     const shapes = encodedShape ?? dataset.values.map(() => config.shape ?? "circle");
     const existingChildren = graphic.items ?? [];
@@ -252,7 +272,7 @@ export const rematerializePointMark = action(
       angles !== undefined ||
       graphic.type === "collection" ||
       getPointGraphicType(constantShape) !== graphic.type;
-    const jittered = applyPointJitter(this, {
+    const jittered = applyPointJitter(resolved, {
       id,
       layer,
       dataset,

package/src/actions/marks/rule/actions.js

@@ -3,6 +3,7 @@ import { validateUserId } from "../../../core/identifiers.js";
 import { validatePositiveFinite } from "../../../core/validation.js";
 import {
   mapContinuousScaleValues,
+  mapOrdinalOffsetValues,
   mapOrdinalPositionValues,
   mapOrdinalValues,
   normalizeStrokeDashPattern
@@ -25,6 +26,8 @@ import {
 import { resolveMarkGraphicPlacement } from
   "../../../materialization/graphicHierarchy.js";
 import { rematerializeHighlightBaseline } from "../lifecycle.js";
+import { applyOffsetPositionValues } from
+  "../../../materialization/rowEncoding.js";
 
 const CREATE_OPTIONS = Object.freeze(["id", "data"]);
 const REMATERIALIZE_OPTIONS = Object.freeze(["id"]);
@@ -154,7 +157,10 @@ const rematerializeRuleMark = action(
     }
 
     const scaleIds = [...new Set(
-      ["x", "y", "x2", "y2", "strokeDash", "strokeWidth", "opacity"]
+      [
+        "x", "y", "x2", "y2", "xOffset", "yOffset",
+        "strokeDash", "strokeWidth", "opacity"
+      ]
         .map(channel => layer.encoding?.[channel]?.scale)
         .filter(scale => scale !== undefined)
     )];
@@ -178,6 +184,25 @@ const rematerializeRuleMark = action(
         resolved.resolvedScales[encoding.scale]
       );
     }
+    for (const [channel, offsetChannel] of [
+      ["x", "xOffset"],
+      ["y", "yOffset"]
+    ]) {
+      const encoding = layer.encoding?.[offsetChannel];
+      if (encoding === undefined || mapped[channel] === undefined) continue;
+      const offsetScale = resolved.resolvedScales[encoding.scale];
+      const offset = mapOrdinalOffsetValues(
+        derived.values[offsetChannel],
+        offsetScale
+      );
+      mapped[channel] = applyOffsetPositionValues({
+        base: mapped[channel],
+        offset,
+        parentScale: resolved.resolvedScales[layer.encoding[channel].scale],
+        offsetScale,
+        channel
+      });
+    }
     const bounds = resolveGraphicBounds(resolved);
     const x1 = [];
     const y1 = [];

package/src/core/vocabulary.js

@@ -86,14 +86,14 @@ export const POSITION_CHANNEL_DEFINITIONS = Object.freeze({
     role: "offset",
     scaleChannel: "xOffset",
     coordinate: Object.freeze({ id: "main", type: "cartesian" }),
-    markTypes: Object.freeze(["bar"])
+    markTypes: Object.freeze(["bar", "point", "rule"])
   }),
   yOffset: Object.freeze({
     family: "cartesian",
     role: "offset",
     scaleChannel: "yOffset",
     coordinate: Object.freeze({ id: "main", type: "cartesian" }),
-    markTypes: Object.freeze(["bar"])
+    markTypes: Object.freeze(["bar", "point", "rule"])
   }),
   theta: Object.freeze({
     family: "polar",