ggaction 0.0.13 → 0.0.16

package/src/actions/encodings/offset.js

@@ -18,7 +18,6 @@ import {
   resolveBarChannels,
   resolveBarGrain
 } from "../../grammar/bars/policy.js";
-import { normalizeOffsetPadding } from "../../grammar/bars/geometry.js";
 
 const ENCODING_OPTIONS = Object.freeze([
   "field", "target", "fieldType", "scale", "paddingInner", "paddingOuter"
@@ -69,30 +68,38 @@ function createOffsetEncoding(channel) {
         layer.encoding?.[channel],
         args.scale ?? {}
       );
-      const scale = resolveOffsetScaleDefinition(this, requestedScale, channel);
+      const scaleOptions = {
+        ...requestedScale,
+        ...Object.fromEntries(
+          ["paddingInner", "paddingOuter"]
+            .filter(property => Object.hasOwn(args, property))
+            .map(property => [property, args[property]])
+        )
+      };
+      const scale = resolveOffsetScaleDefinition(this, scaleOptions, channel);
       if (Object.hasOwn(scale, "unknown")) {
         throw new Error(
           `${channel} scale unknown is not supported for offset positions.`
         );
       }
-      const padding = normalizeOffsetPadding(
-        args,
-        this.markConfigs[target]?.[channel],
-        channel
-      );
 
       const grouped = layer.mark.type === "bar" ? inferSeriesGroup(this, layer, args.field, "offset") : this;
       let next = setEncodingProperties(grouped, target, channel, {
         field: args.field,
         fieldType,
         scale: scale.id
-      })._withMarkConfig(target, {
-          ...this.markConfigs[target],
-          [channel]: padding
-        });
-      next = applyEncodingScale(next, scale, requestedScale, {
-        reassignment: layer.encoding?.[channel]?.scale === scale.id
       });
+      next = applyEncodingScale(next, scale, {
+        ...Object.fromEntries(Object.entries(scaleOptions).filter(
+          ([property]) => property !== "range"
+        )),
+        paddingInner: scale.paddingInner,
+        paddingOuter: scale.paddingOuter,
+        align: scale.align
+      }, {
+        reassignment: findSemanticScale(this, scale.id) !== undefined
+      });
+      next = next._withoutMaterializationConfig(["marks", target, channel]);
       if (layer.mark.type === "bar") {
         if (findSemanticScale(this, scale.id) === undefined && args.scale?.id === undefined) next = next._withMarkConfig(target, { ...next.markConfigs[target], seriesOffsetScale: scale.id });
         if (layer.layout?.mode !== "group" || layer.encoding?.group?.field !== args.field) return next.layoutSeries({ target, mode: "group" });
@@ -103,8 +110,8 @@ function createOffsetEncoding(channel) {
   );
 }
 
-const encodeXOffset = createOffsetEncoding("xOffset");
-const encodeYOffset = createOffsetEncoding("yOffset");
+const encodeXOffset = /* @__PURE__ */ createOffsetEncoding("xOffset");
+const encodeYOffset = /* @__PURE__ */ createOffsetEncoding("yOffset");
 
 export function registerOffsetEncodingAction(ProgramClass) {
   ProgramClass.prototype.encodeXOffset = encodeXOffset;

package/src/actions/encodings/parallel.js

@@ -1,5 +1,5 @@
-import { action } from "../../core/action.js";
-import { validateOptionObject } from "../../core/validation.js";
+import { closedAction } from "../../core/action.js";
+
 import {
   normalizeParallelDimensions,
   validateParallelKeyField,
@@ -19,13 +19,12 @@ const OPTIONS = Object.freeze([
   "target", "coordinate", "dimensions", "key", "missing"
 ]);
 
-export const encodeParallelCoordinates = action(
+export const encodeParallelCoordinates = /* @__PURE__ */ closedAction(
   {
     op: "encodeParallelCoordinates",
     description: "Atomically encode ordered Parallel-coordinate dimensions."
-  },
+  }, OPTIONS,
   function (args = {}) {
-    validateOptionObject(args, OPTIONS, "encodeParallelCoordinates");
     const { id: target, dataset, layer } = resolveTarget(
       this,
       args.target,

package/src/actions/encodings/pathOrder.js

@@ -1,9 +1,6 @@
-import { action } from "../../core/action.js";
+import { closedAction } from "../../core/action.js";
 import { validateUserId } from "../../core/identifiers.js";
-import {
-  validateNonEmptyString,
-  validateOptionObject
-} from "../../core/validation.js";
+import { validateNonEmptyString } from "../../core/validation.js";
 import { readQuantitativeField } from "../../grammar/scales/index.js";
 import { validatePathOrderDirection } from "../../grammar/pathOrder.js";
 import {
@@ -76,13 +73,12 @@ function rematerializePath(program, layer) {
     : program;
 }
 
-const encodePathOrder = action(
+const encodePathOrder = /* @__PURE__ */ closedAction(
   {
     op: "encodePathOrder",
     description: "Order vertices within each Cartesian path series."
-  },
+  }, ENCODE_OPTIONS,
   function (args = {}) {
-    validateOptionObject(args, ENCODE_OPTIONS, "encodePathOrder");
     const field = validateNonEmptyString(args.field, "Path order field");
     const fieldType = args.fieldType ?? "quantitative";
     if (fieldType !== "quantitative") {
@@ -102,13 +98,12 @@ const encodePathOrder = action(
   }
 );
 
-const removePathOrder = action(
+const removePathOrder = /* @__PURE__ */ closedAction(
   {
     op: "removePathOrder",
     description: "Remove explicit path order and restore automatic ordering."
-  },
+  }, REMOVE_OPTIONS,
   function (args = {}) {
-    validateOptionObject(args, REMOVE_OPTIONS, "removePathOrder");
     const layer = resolvePathOrderLayer(this, args.target, { active: true });
     const next = this.editSemantic({
       property: `layer[${layer.id}].encoding.pathOrder`,

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

@@ -66,18 +66,35 @@ function applyBin(program, target, channel, previous, bin) {
   });
 }
 
-function applyArcThetaWeight(program, target, channel, previous, aggregate, weight) {
-  if (channel !== "theta") return program;
-  if (aggregate !== "sum") {
+function applyPositionWeight(
+  program,
+  target,
+  channel,
+  previous,
+  bin,
+  aggregate,
+  weight
+) {
+  const histogram = channel === "x" && bin !== undefined;
+  const arcSum = channel === "theta" && aggregate === "sum";
+  if (!histogram && !arcSum) {
+    return previous?.weight === undefined
+      ? program
+      : program.editSemantic({
+          property: `layer[${target}].encoding.${channel}.weight`,
+          remove: true
+        });
+  }
+  if (weight === undefined) {
     return previous?.weight === undefined
       ? program
       : program.editSemantic({
-          property: `layer[${target}].encoding.theta.weight`,
+          property: `layer[${target}].encoding.${channel}.weight`,
           remove: true
         });
   }
   return program.editSemantic({
-    property: `layer[${target}].encoding.theta.weight`,
+    property: `layer[${target}].encoding.${channel}.weight`,
     value: weight
   });
 }
@@ -104,6 +121,26 @@ function removeStaleArcThetaAggregate(
   });
 }
 
+function removeMeasuredRadiusAggregate(
+  program,
+  target,
+  channel,
+  previous,
+  clearRadialMapping
+) {
+  if (
+    channel !== "radius" ||
+    !clearRadialMapping ||
+    previous?.aggregate === undefined
+  ) {
+    return program;
+  }
+  return program.editSemantic({
+    property: `layer[${target}].encoding.radius.aggregate`,
+    remove: true
+  });
+}
+
 export function applyPositionSemantics(program, {
   target,
   channel,
@@ -117,7 +154,8 @@ export function applyPositionSemantics(program, {
   bin,
   aggregate,
   stack,
-  weight
+  weight,
+  clearRadialMapping
 }) {
   let next = reconcileInheritedRulePosition(program, {
     target,
@@ -160,11 +198,19 @@ export function applyPositionSemantics(program, {
     fieldType,
     aggregate
   );
-  return applyArcThetaWeight(
+  next = removeMeasuredRadiusAggregate(
+    next,
+    target,
+    channel,
+    previous,
+    clearRadialMapping
+  );
+  return applyPositionWeight(
     next,
     target,
     channel,
     previous,
+    bin,
     aggregate,
     weight
   );

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

@@ -31,7 +31,8 @@ function encodePosition(program, channel, args, operation) {
     aggregate,
     stack,
     weight,
-    companion
+    companion,
+    clearRadialMapping
   } = resolvePositionEncoding(program, channel, args, operation);
 
   let next = program
@@ -53,13 +54,20 @@ function encodePosition(program, channel, args, operation) {
     bin,
     aggregate,
     stack,
-    weight
+    weight,
+    clearRadialMapping
   });
 
   next = next.editSemantic({
       property: `layer[${target}].encoding.${channel}.scale`,
       value: scale.id
     });
+  if (
+    clearRadialMapping &&
+    findSemanticScale(next, scale.id)?.radialMapping !== undefined
+  ) {
+    next = next.editScale({ id: scale.id, radialMapping: undefined });
+  }
   next = applyEncodingScale(next, scale, requestedScale, {
     reassignment: previous?.scale === scale.id,
     allowTypeChange: layer.mark.type === "area"
@@ -133,7 +141,7 @@ function encodePosition(program, channel, args, operation) {
   return applyDetachedScaleRematerialization(next, [layer]);
 }
 
-const encodeX = action(
+const encodeX = /* @__PURE__ */ action(
   {
     op: "encodeX",
     description: "Encode a field as horizontal position."
@@ -143,7 +151,7 @@ const encodeX = action(
   }
 );
 
-const encodeY = action(
+const encodeY = /* @__PURE__ */ action(
   {
     op: "encodeY",
     description: "Encode a field as vertical position."
@@ -153,7 +161,7 @@ const encodeY = action(
   }
 );
 
-const encodeTheta = action(
+const encodeTheta = /* @__PURE__ */ action(
   {
     op: "encodeTheta",
     description: "Encode a field as Polar angle in clockwise degrees."
@@ -163,7 +171,7 @@ const encodeTheta = action(
   }
 );
 
-const encodeR = action(
+const encodeR = /* @__PURE__ */ action(
   {
     op: "encodeR",
     description: "Encode a quantitative field as Polar radius."

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

@@ -10,6 +10,8 @@ import {
   resolveBarOrientation
 } from "../../../../grammar/bars/policy.js";
 import { resolveBin, validateStack } from "./common.js";
+import { normalizeStatisticalWeight } from
+  "../../../../grammar/weightedStatistics.js";
 
 function resolveBarChannelPolicy({
   program,
@@ -37,6 +39,10 @@ function resolveBarChannelPolicy({
       throw new Error("Binned bar x encoding does not support aggregate or stack.");
     }
     bin = resolveBin(args.bin);
+    const weight = args.weight === undefined
+      ? undefined
+      : normalizeStatisticalWeight(args.weight, "Histogram weight");
+    return { bin, aggregate, stack, weight };
   } else if (
     fieldType === "quantitative" &&
     channel === "y" &&
@@ -89,6 +95,9 @@ function resolveBarChannelPolicy({
     );
   }
 
+  if (args.weight !== undefined) {
+    throw new Error("Bar weight is supported only for a binned x encoding.");
+  }
   return { bin, aggregate, stack };
 }
 

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

@@ -97,19 +97,26 @@ export function resolvePositionEncoding(program, channel, args, operation) {
     args.target,
     getPositionChannelDefinition(channel).markTypes
   );
+  const previous = layer.encoding?.[channel];
   if (isSourceOwnedText(layer)) {
     throw new Error(`${operation} cannot replace source-owned Text positions; edit the source, use dx/dy, or create independent Text with data.`);
   }
   if (
     Object.hasOwn(args, "weight") &&
-    !(layer.mark.type === "arc" && channel === "theta")
+    !(layer.mark.type === "arc" && channel === "theta") &&
+    !(layer.mark.type === "bar" && channel === "x" &&
+      (args.bin !== undefined || previous?.bin !== undefined))
   ) {
-    throw new Error(`${operation} weight is supported only for arc theta encoding.`);
+      throw new Error(
+        `${operation} weight is supported only for arc theta encoding or histogram x encoding.`
+      );
   }
   if (Object.hasOwn(args, "mapping") && (layer.mark.type !== "arc" || channel !== "radius")) {
     throw new Error(`${operation} mapping requires Arc radius.`);
   }
   validateCoordinateFamily(layer, channel, operation);
+  const clearRadialMapping =
+    layer.mark.type === "arc" && channel === "radius" && args.mapping === false;
   const hasField = Object.hasOwn(args, "field");
   const hasDatum = Object.hasOwn(args, "datum");
   if (["rule", "rect", "text", "point", "tick"].includes(layer.mark.type)) {
@@ -128,9 +135,10 @@ export function resolvePositionEncoding(program, channel, args, operation) {
   } else if (hasDatum) {
     throw new Error(`${operation} does not support datum for a ${layer.mark.type} mark.`);
   }
-  const previous = layer.encoding?.[channel];
   const mapping = channel === "radius" && layer.mark.type === "arc"
-    ? args.mapping ?? findSemanticScale(program, previous?.scale)?.radialMapping
+    ? clearRadialMapping
+      ? undefined
+      : args.mapping ?? findSemanticScale(program, previous?.scale)?.radialMapping
     : undefined;
   const countRadius = mapping !== undefined && (args.aggregate ?? previous?.aggregate) === "count";
   const requestedFieldType = args.fieldType ?? previous?.fieldType ?? (
@@ -165,7 +173,9 @@ export function resolvePositionEncoding(program, channel, args, operation) {
       validateAggregateFieldValues(dataset.values, field, fieldType);
     } else readScaleField(dataset.values, field, fieldType, { temporalUnit });
   }
-  const effectiveArgs = { ...args, ...(mapping === undefined ? {} : { mapping }) };
+  const effectiveArgs = { ...args };
+  if (clearRadialMapping) delete effectiveArgs.mapping;
+  else if (mapping !== undefined) effectiveArgs.mapping = mapping;
   const directQuantitativeArcTheta =
     layer.mark.type === "arc" &&
     channel === "theta" &&
@@ -173,7 +183,8 @@ export function resolvePositionEncoding(program, channel, args, operation) {
   for (const property of ["aggregate", "bin", "stack"]) {
     if (!Object.hasOwn(effectiveArgs, property) && previous !== undefined &&
       Object.hasOwn(previous, property) &&
-      !(directQuantitativeArcTheta && property === "aggregate")) {
+      !(directQuantitativeArcTheta && property === "aggregate") &&
+      !(clearRadialMapping && property === "aggregate")) {
       effectiveArgs[property] = previous[property];
     }
   }
@@ -201,7 +212,7 @@ export function resolvePositionEncoding(program, channel, args, operation) {
     previous,
     Object.hasOwn(args, "scale") ? args.scale : {}
   );
-  const scale = resolvePositionScaleDefinition(
+  const resolvedScale = resolvePositionScaleDefinition(
     program,
     channel,
     aggregateOutput ? "quantitative" : fieldType,
@@ -229,6 +240,11 @@ export function resolvePositionEncoding(program, channel, args, operation) {
           }
         : {}
   );
+  const scale = clearRadialMapping
+    ? Object.fromEntries(
+        Object.entries(resolvedScale).filter(([property]) => property !== "radialMapping")
+      )
+    : resolvedScale;
   if (
     layer.mark.type === "bar" &&
     program.markConfigs[target]?.boxPlot === undefined &&
@@ -310,6 +326,7 @@ export function resolvePositionEncoding(program, channel, args, operation) {
     temporalUnit,
     scale,
     coordinate: resolveCoordinate(program, channel, layer, args.coordinate),
+    clearRadialMapping,
     ...policy
   };
 }

package/src/actions/encodings/ranged.js

@@ -159,7 +159,7 @@ function encodeSecondaryPosition(program, channel, args, operation, types) {
   return next;
 }
 
-const encodeX2 = action(
+const encodeX2 = /* @__PURE__ */ action(
   {
     op: "encodeX2",
     description: "Encode a secondary horizontal endpoint."
@@ -175,7 +175,7 @@ const encodeX2 = action(
   }
 );
 
-const encodeY2 = action(
+const encodeY2 = /* @__PURE__ */ action(
   {
     op: "encodeY2",
     description: "Encode a secondary vertical endpoint."
@@ -222,10 +222,10 @@ function rangeAction(channel) {
   });
 }
 
-const encodeYRange = rangeAction("y");
-const encodeXRange = rangeAction("x");
+const encodeYRange = /* @__PURE__ */ rangeAction("y");
+const encodeXRange = /* @__PURE__ */ rangeAction("x");
 
-const encodeGroup = action(
+const encodeGroup = /* @__PURE__ */ action(
   {
     op: "encodeGroup",
     description: "Split path geometry by nominal identity fields without a scale."

package/src/actions/encodings/remove.js

@@ -1,6 +1,6 @@
-import { action } from "../../core/action.js";
+import { closedAction } from "../../core/action.js";
 import { validateUserId } from "../../core/identifiers.js";
-import { validateOptionObject } from "../../core/validation.js";
+
 import {
   getPositionChannelDefinition,
   POSITION_ENCODING_CHANNELS
@@ -25,11 +25,12 @@ import { applyDetachedScaleRematerialization } from "../../materialization/depen
 import { findDataset } from "../../selectors/datasets.js";
 import { assertPathGroupCompatible, validatePathGroupAppearance } from "../../materialization/marks/grouping.js";
 import { assertEncodingSelectionCompatibility } from "../../materialization/selection/compatibility.js";
+import { planLegendBlockTransitions } from "../guides/legends/transition.js";
 
 const OPTIONS = Object.freeze(["target", "channel"]);
 const REMOVABLE_CHANNELS = Object.freeze([
   "x", "y", "x2", "y2", "xOffset", "yOffset", "theta", "radius",
-  "color", "strokeDash", "strokeWidth", "size", "shape", "group",
+  "color", "stroke", "strokeDash", "strokeWidth", "size", "shape", "group",
   "angle", "opacity", "text"
 ]);
 const REMOVE_AXIS = Object.freeze({
@@ -40,6 +41,7 @@ const REMOVE_AXIS = Object.freeze({
 });
 const SPECIALIZED_LEGEND_KIND = Object.freeze({
   color: Object.freeze(["gradient", "interval"]),
+  stroke: Object.freeze(["strokeGradient", "strokeInterval"]),
   size: Object.freeze(["size"]),
   opacity: Object.freeze(["opacity"]),
   strokeWidth: Object.freeze(["strokeWidth"])
@@ -157,7 +159,7 @@ function cleanupPositionGuides(program, removed) {
 }
 
 function reconcileCategoricalLegend(program, target, channels) {
-  const entry = ["series", "color"]
+  const entry = ["series", "color", "stroke"]
     .map(kind => [kind, program.guideConfigs.legend?.[kind]])
     .find(([, config]) =>
       config?.target === target &&
@@ -172,7 +174,10 @@ function reconcileCategoricalLegend(program, target, channels) {
   if (remaining.length === 0) {
     return removeLegendKinds(program, [kind]);
   }
-  const revision = resolveCategoricalLegendRevision(program, kind, config, remaining);
+  const resolved = resolveCategoricalLegendRevision(program, kind, config, remaining);
+  const revision = planLegendBlockTransitions(program, target, [
+    { ...resolved, kind: resolved.config.kind }
+  ])[0];
   const next = removeLegendKinds(program, [kind]);
   return createCategoricalLegendFromConfig(next, revision.config, revision.order);
 }
@@ -198,13 +203,12 @@ function rematerializeTarget(program, target) {
   return next;
 }
 
-export const removeEncoding = action(
+export const removeEncoding = /* @__PURE__ */ closedAction(
   {
     op: "removeEncoding",
     description: "Remove one semantic encoding and its owned materialized state."
-  },
+  }, OPTIONS,
   function (args = {}) {
-    validateOptionObject(args, OPTIONS, "removeEncoding");
     if (!REMOVABLE_CHANNELS.includes(args.channel)) {
       throw new Error(
         `Unsupported removable encoding channel "${args.channel}".`
@@ -218,7 +222,7 @@ export const removeEncoding = action(
     }
     const channels = activeCascade(layer, args.channel);
     assertEncodingSelectionCompatibility(this, layer.id, channels);
-    for (const kind of ["series", "color"]) {
+    for (const kind of ["series", "color", "stroke"]) {
       const config = this.guideConfigs.legend?.[kind];
       const order = this.semanticSpec.guides.legend?.[kind]?.order;
       if (config?.target === layer.id && channels.includes(order?.channel) &&

package/src/actions/encodings/ruleAppearance.js

@@ -1,8 +1,5 @@
 import { action } from "../../core/action.js";
-import {
-  validateRuleStroke,
-  validateRuleStrokeWidth
-} from "../../grammar/ruleAppearance.js";
+import { validateRuleStrokeWidth } from "../../grammar/ruleAppearance.js";
 import { readQuantitativeField } from "../../grammar/scales/index.js";
 import { resolveStrokeWidthScaleDefinition } from "../scales/definitions.js";
 import {
@@ -18,29 +15,11 @@ import { findLayer } from "../../selectors/layers.js";
 import { validatePathSeriesAppearance } from "../../grammar/pathSeries.js";
 import { assertEncodingSelectionCompatibility } from "../../materialization/selection/compatibility.js";
 
-const STROKE_OPTIONS = Object.freeze(["target", "value"]);
 const WIDTH_OPTIONS = Object.freeze([
   "target", "value", "field", "fieldType", "scale"
 ]);
 
-const encodeStroke = action(
-  {
-    op: "encodeStroke",
-    description: "Set a constant graphical stroke on a rule mark."
-  },
-  function (args = {}) {
-    validateOptions(args, STROKE_OPTIONS, "encodeStroke");
-    const { id } = resolveTarget(this, args.target, ["rule"], "rule mark");
-    return this
-      ._withMarkConfig(id, {
-        ...this.markConfigs[id],
-        stroke: validateRuleStroke(args.value)
-      })
-      .rematerializeRuleMark({ id });
-  }
-);
-
-const encodeStrokeWidth = action(
+const encodeStrokeWidth = /* @__PURE__ */ action(
   {
     op: "encodeStrokeWidth",
     description: "Assign constant or field-driven line or rule stroke width."
@@ -119,6 +98,5 @@ const encodeStrokeWidth = action(
 );
 
 export function registerRuleAppearanceEncodingActions(ProgramClass) {
-  ProgramClass.prototype.encodeStroke = encodeStroke;
   ProgramClass.prototype.encodeStrokeWidth = encodeStrokeWidth;
 }

package/src/actions/encodings/seriesLayout.js

@@ -15,7 +15,7 @@ export function stackLayoutMode(stack) {
   return stack === "normalize" ? "fill" : stack === "center" ? "center" : stack === null ? "overlay" : "stack";
 }
 
-export const layoutSeries = action({ op: "layoutSeries", description: "Assign series placement independently of color." }, function (args = {}) {
+export const layoutSeries = /* @__PURE__ */ action({ op: "layoutSeries", description: "Assign series placement independently of color." }, function (args = {}) {
   validateOptions(args, ["target", "mode"], "layoutSeries");
   const mode = validateColorLayout(args.mode);
   const { id: target, layer, dataset } = resolveTarget(this, args.target, ["bar", "area"], "series mark");
@@ -85,6 +85,7 @@ export const layoutSeries = action({ op: "layoutSeries", description: "Assign se
       next = offset.field === undefined
         ? setEncodingProperties(next, target, offsetChannel, offset).createScale(offsetScale)
         : next[offsetChannel === "xOffset" ? "encodeXOffset" : "encodeYOffset"]({ target, field: offset.field, fieldType: offset.fieldType, scale: offsetScale });
+      next = next._withoutMaterializationConfig(["marks", target, offsetChannel]);
       if (findSemanticScale(this, offsetScale.id) === undefined) next = next._withMarkConfig(target, { ...next.markConfigs[target], seriesOffsetScale: offsetScale.id });
     } else {
       const owned = next.markConfigs[target]?.seriesOffsetScale;