ggaction 0.0.13 → 0.0.16

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

@@ -1,3 +1,4 @@
+import { editGraphicProperties } from "../../primitives/graphicProperties.js";
 import { action } from "../../../core/action.js";
 import { validateUserId } from "../../../core/identifiers.js";
 import { validateMarkOptions } from "../shared.js";
@@ -12,47 +13,36 @@ import {
 import { rematerializeHighlightBaseline } from "../lifecycle.js";
 import { offsetCategoryRectangles } from
   "../../../materialization/categorySlotOffset.js";
+import { materializeRectItem } from "../../../grammar/roundedRect.js";
+import { STROKE_STYLE_PROPERTIES } from
+  "../../../grammar/strokeStyle.js";
+import { replaceGraphicItems } from "../../primitives/editGraphics.js";
 
 const REMATERIALIZE_OPTIONS = Object.freeze(["id", "scales"]);
 
 function editRectangles(program, id, rectangles) {
-  let next = program
-    .editGraphics({ target: id, property: "length", value: rectangles.length })
-    .editGraphics({
-      target: id,
-      property: "x",
-      value: rectangles.map(rect => rect.x)
-    })
-    .editGraphics({
-      target: id,
-      property: "y",
-      value: rectangles.map(rect => rect.y)
-    })
-    .editGraphics({
-      target: id,
-      property: "width",
-      value: rectangles.map(rect => rect.width)
-    })
-    .editGraphics({
-      target: id,
-      property: "height",
-      value: rectangles.map(rect => rect.height)
-    })
-    .editGraphics({
-      target: id,
-      property: "fill",
-      value: rectangles.map(rect => rect.fill)
-    })
-    .editGraphics({
-      target: id,
-      property: "stroke",
-      value: rectangles.map(rect => rect.stroke)
-    })
-    .editGraphics({
-      target: id,
-      property: "strokeWidth",
-      value: rectangles.map(rect => rect.strokeWidth)
-    });
+  const appearance = program.markConfigs[id]?.barAppearance ?? {};
+  const hasShapeStyle = ["cornerRadius", ...STROKE_STYLE_PROPERTIES]
+    .some(property => Object.hasOwn(appearance, property));
+  if (hasShapeStyle) {
+    const radius = appearance.cornerRadius ?? 0;
+    return replaceGraphicItems(
+      program,
+      id,
+      "rect",
+      rectangles.map(rectangle => materializeRectItem(rectangle, radius))
+    );
+  }
+  let next = editGraphicProperties(program, id, {
+    length: rectangles.length,
+    x: rectangles.map(rect => rect.x),
+    y: rectangles.map(rect => rect.y),
+    width: rectangles.map(rect => rect.width),
+    height: rectangles.map(rect => rect.height),
+    fill: rectangles.map(rect => rect.fill),
+    stroke: rectangles.map(rect => rect.stroke),
+    strokeWidth: rectangles.map(rect => rect.strokeWidth)
+  });
   if (rectangles.some(rect => rect.opacity !== undefined)) {
     next = next.editGraphics({
       target: id,
@@ -63,7 +53,7 @@ function editRectangles(program, id, rectangles) {
   return next;
 }
 
-export const rematerializeBarMark = action(
+export const rematerializeBarMark = /* @__PURE__ */ action(
   {
     op: "rematerializeBarMark",
     description: "Recompute concrete bar graphics from complete semantics."
@@ -81,8 +71,8 @@ export const rematerializeBarMark = action(
     const highlighted = rematerializeHighlightBaseline(this, {
       target: id,
       operation: "rematerializeBarMark",
-      resetProperty: "length",
-      resetValue: 0
+      resetProperty: "items",
+      resetValue: []
     });
     if (highlighted !== undefined) return highlighted;
     const required = requireCompleteBar(this, id);
@@ -97,6 +87,10 @@ export const rematerializeBarMark = action(
     if (colorScaleId !== undefined && args.scales !== false) {
       resolved = resolved.rematerializeScale({ id: colorScaleId });
     }
+    const strokeScaleId = required.layer.encoding?.stroke?.scale;
+    if (strokeScaleId !== undefined && args.scales !== false) {
+      resolved = resolved.rematerializeScale({ id: strokeScaleId });
+    }
 
     if (required.materialization === "aggregate") {
       const offsetChannel = resolveBarOffsetChannel(required.layer);

package/src/actions/marks/index.js

@@ -1,5 +1,10 @@
 import { removeMark } from "./remove.js";
-import { createReferenceLine, createReferenceBand } from "./references.js";
+import {
+  createReferenceLine,
+  createReferenceBand,
+  materializeStatisticalReferenceData,
+  rematerializeStatisticalReference
+} from "./references.js";
 import { registerRuleMarkActions } from "./rule/index.js";
 import { registerAreaMarkActions } from "./area/index.js";
 import { registerTickMarkActions } from "./tick/index.js";
@@ -29,4 +34,8 @@ export function registerMarkActions(ProgramClass) {
   ProgramClass.prototype.removeMark = removeMark;
   ProgramClass.prototype.createReferenceLine = createReferenceLine;
   ProgramClass.prototype.createReferenceBand = createReferenceBand;
+  ProgramClass.prototype.materializeStatisticalReferenceData =
+    materializeStatisticalReferenceData;
+  ProgramClass.prototype.rematerializeStatisticalReference =
+    rematerializeStatisticalReference;
 }

package/src/actions/marks/line/actions.js

@@ -19,7 +19,11 @@ import { DEFAULT_COLORS } from "../../../theme/defaults.js";
 import { findDataset } from "../../../selectors/datasets.js";
 import { findLayer, resolveEligibleLayer } from "../../../selectors/layers.js";
 import { validateCurveInterpolation } from "../../../grammar/curveCommands.js";
-import { resolveGraphicBounds } from "../../../layout/canvas.js";
+import {
+  resolveCoordinateBounds,
+  resolveCoordinatePolarFrame
+} from "../../../materialization/coordinateBounds.js";
+import { rematerializeExistingLegend } from "../../encodings/shared.js";
 import { canMaterializeLine } from "../../../materialization/marks/index.js";
 import { resolveMarkGraphicPlacement } from
   "../../../materialization/graphicHierarchy.js";
@@ -31,14 +35,20 @@ import {
 } from "./materialize.js";
 import { resolveLineBins } from "../../../grammar/lineSeries.js";
 import { requireSemanticScale } from "../../../selectors/scales.js";
+import {
+  requestedStrokeDetails,
+  STROKE_STYLE_PROPERTIES
+} from "../../../grammar/strokeStyle.js";
 
 const DEFAULT_LINE_STROKE = DEFAULT_COLORS.mark;
 const DEFAULT_LINE_WIDTH = 2;
 const CREATE_OPTIONS = Object.freeze([
-  "id", "data", "stroke", "strokeWidth", "opacity", "curve", "closed"
+  "id", "data", "stroke", "strokeWidth", "opacity", "curve", "closed",
+  ...STROKE_STYLE_PROPERTIES
 ]);
 const EDIT_OPTIONS = Object.freeze([
-  "target", "stroke", "strokeWidth", "opacity", "curve", "closed"
+  "target", "stroke", "strokeWidth", "opacity", "curve", "closed",
+  ...STROKE_STYLE_PROPERTIES
 ]);
 const REMATERIALIZE_OPTIONS = Object.freeze(["id", "scales"]);
 
@@ -71,24 +81,26 @@ function validatePolarLineConfig(layer, config) {
   }
 }
 
-function applyLineMaterialization(program, id, materialization) {
+function applyLineMaterialization(program, id, materialization, config) {
   return editMarkGraphic(program, id, {
     length: materialization.commands.length,
     commands: materialization.commands,
     stroke: materialization.strokes,
     strokeWidth: materialization.strokeWidths,
     strokeDash: materialization.strokeDashes,
-    ...(materialization.opacities === undefined ? {} : { opacity: materialization.opacities })
+    ...(materialization.opacities === undefined ? {} : { opacity: materialization.opacities }),
+    ...requestedStrokeDetails(config, "Line mark")
   });
 }
 
-const createLineMark = action(
+const createLineMark = /* @__PURE__ */ action(
   {
     op: "createLineMark",
     description: "Create a semantic line mark and empty path collection."
   },
   function (args = {}) {
     validateMarkOptions(args, CREATE_OPTIONS, "createLineMark");
+    const strokeDetails = requestedStrokeDetails(args, "createLineMark");
     const id = resolveMarkId(this, args.id, {
       defaultId: "line",
       label: "Line mark id",
@@ -139,7 +151,8 @@ const createLineMark = action(
         {
           ...(Object.hasOwn(args, "strokeWidth") ? { strokeWidth } : {}),
           ...(Object.hasOwn(args, "curve") ? { curve } : {}),
-          ...(Object.hasOwn(args, "closed") ? { closed } : {})
+          ...(Object.hasOwn(args, "closed") ? { closed } : {}),
+          ...strokeDetails
         }
       );
     created = materializeInheritedMark(created, id);
@@ -173,7 +186,7 @@ function requireLine(program, id) {
   return { dataset, layer };
 }
 
-const rematerializeLineMark = action(
+const rematerializeLineMark = /* @__PURE__ */ action(
   {
     op: "rematerializeLineMark",
     description: "Recompute aggregate series and concrete line paths."
@@ -214,7 +227,7 @@ const rematerializeLineMark = action(
     }
     let resolved = this;
     if (args.scales !== false) {
-      const appearance = ["color", "strokeDash", "strokeWidth", "opacity"]
+      const appearance = ["color", "stroke", "strokeDash", "strokeWidth", "opacity"]
         .map(channel => layer.encoding?.[channel]?.scale).filter(scale => scale !== undefined);
       for (const scale of [...positions, ...appearance]) {
         resolved = resolved.rematerializeScale({ id: scale });
@@ -223,12 +236,12 @@ const rematerializeLineMark = action(
     const shared = {
       rows: dataset.values, layer, config, existingChildren,
       resolvedScales: resolved.resolvedScales,
-      bounds: resolveGraphicBounds(resolved),
+      bounds: resolveCoordinateBounds(resolved, layer.coordinate),
       defaults: { stroke: DEFAULT_LINE_STROKE, strokeWidth: DEFAULT_LINE_WIDTH }
     };
     if (parallel !== undefined) {
       return applyLineMaterialization(resolved, id,
-        resolveParallelLineMaterialization({ ...shared, parallel }));
+        resolveParallelLineMaterialization({ ...shared, parallel }), config);
     }
 
     const materialization = resolvePositionedLineMaterialization({
@@ -240,24 +253,29 @@ const rematerializeLineMark = action(
             layer,
             requireSemanticScale(resolved, xScaleId)
           ).boundaries,
-      polar
+      polar,
+      ...(polar
+        ? { polarFrame: resolveCoordinatePolarFrame(resolved, layer.coordinate) }
+        : {})
     });
 
     return applyLineMaterialization(
       resolved,
       id,
-      materialization
+      materialization,
+      config
     );
   }
 );
 
-const editLineMark = action(
+const editLineMark = /* @__PURE__ */ action(
   {
     op: "editLineMark",
     description: "Edit line-mark curve and stroke width."
   },
   function (args = {}) {
     validateMarkOptions(args, EDIT_OPTIONS, "editLineMark");
+    const strokeDetails = requestedStrokeDetails(args, "editLineMark");
     if (!EDIT_OPTIONS.slice(1).some(key => Object.hasOwn(args, key))) {
       throw new Error("editLineMark requires stroke, strokeWidth, opacity, curve, or closed.");
     }
@@ -269,9 +287,12 @@ const editLineMark = action(
       predicate: candidate => candidate.mark?.type === "line",
       label: "line mark"
     });
-    if (Object.hasOwn(args, "stroke") && layer.encoding?.color !== undefined) {
+    if (Object.hasOwn(args, "stroke") && (
+      layer.encoding?.color !== undefined ||
+      layer.encoding?.stroke !== undefined
+    )) {
       throw new Error(
-        "editLineMark stroke cannot be combined with a color encoding."
+        "editLineMark stroke cannot be combined with a color encoding or a stroke encoding; use encodeStroke with value to replace it."
       );
     }
     for (const channel of ["strokeWidth", "opacity"]) {
@@ -284,6 +305,7 @@ const editLineMark = action(
       throw new Error("Line closed requires theta/radius Polar position encodings.");
     }
     const config = { ...this.markConfigs[layer.id] };
+    Object.assign(config, strokeDetails);
     for (const [key, validate] of Object.entries({
       stroke: validateNonEmptyString,
       strokeWidth: validateNonNegativeFinite,
@@ -295,9 +317,10 @@ const editLineMark = action(
     }
     validatePolarLineConfig(layer, config);
     const next = this._withMarkConfig(layer.id, config);
-    return canMaterializeLine(next, layer)
+    const materialized = canMaterializeLine(next, layer)
       ? next.rematerializeLineMark({ id: layer.id })
       : next;
+    return rematerializeExistingLegend(materialized);
   }
 );
 

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

@@ -27,7 +27,11 @@ function appearanceMapper(layer, scales, fieldValues) {
       return fallback.map(() => normalizeStrokeDashPattern(encoding.datum));
     }
     if (encoding?.scale === undefined) return fallback;
-    return mapScaleConsumerValues(fieldValues(encoding.field, channel), scales[encoding.scale], channel);
+    return mapScaleConsumerValues(
+      fieldValues(encoding.field, channel, encoding),
+      scales[encoding.scale],
+      channel
+    );
   };
 }
 
@@ -53,11 +57,15 @@ export function resolveParallelLineMaterialization({
     field => sourceRows.map(row => row[field]));
   return {
     commands: items.map(item => item.commands),
-    strokes: mapAppearance(
-      "color",
-      items.map((_, index) => config.stroke ??
-        existingValue(existingChildren, index, "stroke", defaults.stroke))
-    ),
+    strokes: layer.encoding?.stroke?.scale !== undefined
+      ? mapAppearance("stroke", items.map(() => defaults.stroke))
+      : config.stroke !== undefined
+        ? items.map(() => config.stroke)
+        : mapAppearance(
+            "color",
+            items.map((_, index) =>
+              existingValue(existingChildren, index, "stroke", defaults.stroke))
+          ),
     strokeWidths: mapAppearance(
       "strokeWidth",
       items.map((_, index) => config.strokeWidth ??
@@ -80,6 +88,7 @@ export function resolvePositionedLineMaterialization({
   config,
   existingChildren,
   polar,
+  polarFrame,
   defaults
 }) {
   const xScaleId = layer.encoding?.x?.scale;
@@ -98,7 +107,7 @@ export function resolvePositionedLineMaterialization({
         thetaFieldType: derived.thetaFieldType,
         thetaScale: resolvedScales[thetaScaleId],
         radiusScale: resolvedScales[radiusScaleId],
-        frame: resolvePolarFrame(bounds),
+        frame: polarFrame ?? resolvePolarFrame(bounds),
         closed: config.closed ?? false
       }))
     : derived.series.map(series => {
@@ -116,11 +125,21 @@ export function resolvePositionedLineMaterialization({
         );
       });
   const appearance = appearanceMapper(layer, resolvedScales,
-    (field, channel) => derivePathSeriesFieldValues(rows, derived.series, field, channel));
+    (field, channel, encoding) => derivePathSeriesFieldValues(
+      rows,
+      derived.series,
+      field,
+      channel,
+      encoding
+    ));
   return {
     commands,
-    strokes: appearance("color", commands.map((_, index) => config.stroke ??
-      existingValue(existingChildren, index, "stroke", defaults.stroke))),
+    strokes: layer.encoding?.stroke?.scale !== undefined
+      ? appearance("stroke", commands.map(() => defaults.stroke))
+      : config.stroke !== undefined
+        ? commands.map(() => config.stroke)
+        : appearance("color", commands.map((_, index) =>
+            existingValue(existingChildren, index, "stroke", defaults.stroke))),
     strokeWidths: appearance("strokeWidth", commands.map((_, index) => config.strokeWidth ??
       existingValue(existingChildren, index, "strokeWidth", defaults.strokeWidth))),
     strokeDashes: appearance("strokeDash", commands.map((_, index) =>

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

@@ -1,6 +1,10 @@
 import { action } from "../../../core/action.js";
 import { validatePointShape } from "../../../grammar/pointShapes.js";
 import { getPointGraphicType } from "../../../grammar/schemas/mark.js";
+import {
+  requestedStrokeDetails,
+  STROKE_STYLE_PROPERTIES
+} from "../../../grammar/strokeStyle.js";
 import { resolveMarkGraphicPlacement } from
   "../../../materialization/graphicHierarchy.js";
 import {
@@ -14,16 +18,18 @@ import {
 } from "../shared.js";
 
 const OPTIONS = Object.freeze([
-  "id", "data", "shape", "fill", "opacity", "stroke", "strokeWidth"
+  "id", "data", "shape", "fill", "opacity", "stroke", "strokeWidth",
+  ...STROKE_STYLE_PROPERTIES
 ]);
 
-export const createPointMark = action(
+export const createPointMark = /* @__PURE__ */ action(
   {
     op: "createPointMark",
     description: "Create a semantic point mark and concrete point graphics."
   },
   function (args = {}) {
     validateMarkOptions(args, OPTIONS, "createPointMark");
+    requestedStrokeDetails(args, "createPointMark");
     const id = resolveMarkId(this, args.id, {
       defaultId: "point",
       label: "Point mark id",
@@ -65,7 +71,7 @@ export const createPointMark = action(
       ._withMarkConfig(id, { shape });
     const created = materializeInheritedMark(next, id);
     const appearance = Object.fromEntries(
-      ["fill", "opacity", "stroke", "strokeWidth"]
+      ["fill", "opacity", "stroke", "strokeWidth", ...STROKE_STYLE_PROPERTIES]
         .filter(property => Object.hasOwn(args, property))
         .map(property => [property, args[property]])
     );

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

@@ -6,22 +6,31 @@ import {
   validateUnitInterval
 } from "../../../core/validation.js";
 import { validatePointShape } from "../../../grammar/pointShapes.js";
+import {
+  requestedStrokeDetails,
+  STROKE_STYLE_PROPERTIES
+} from "../../../grammar/strokeStyle.js";
 import { resolveEligibleLayer } from "../../../selectors/layers.js";
 import { rematerializeExistingLegend } from "../../encodings/shared.js";
 import { validateMarkOptions } from "../shared.js";
 
 const OPTIONS = Object.freeze([
-  "target", "shape", "fill", "opacity", "stroke", "strokeWidth"
+  "target", "shape", "fill", "opacity", "stroke", "strokeWidth",
+  ...STROKE_STYLE_PROPERTIES
 ]);
 
-export const editPointMark = action(
+export const editPointMark = /* @__PURE__ */ action(
   {
     op: "editPointMark",
     description: "Edit constant point-mark appearance."
   },
   function (args = {}) {
     validateMarkOptions(args, OPTIONS, "editPointMark");
-    const editable = ["shape", "fill", "opacity", "stroke", "strokeWidth"];
+    const strokeDetails = requestedStrokeDetails(args, "editPointMark");
+    const editable = [
+      "shape", "fill", "opacity", "stroke", "strokeWidth",
+      ...STROKE_STYLE_PROPERTIES
+    ];
     if (!editable.some(property => Object.hasOwn(args, property))) {
       throw new Error(
         "editPointMark requires shape, fill, opacity, stroke, or strokeWidth."
@@ -44,10 +53,16 @@ export const editPointMark = action(
         "editPointMark fill cannot be combined with a color encoding."
       );
     }
+    if (Object.hasOwn(args, "stroke") && layer.encoding?.stroke !== undefined) {
+      throw new Error(
+        "editPointMark stroke conflicts with a field encoding; use encodeStroke with value to replace it."
+      );
+    }
     if (Object.hasOwn(args, "opacity") && layer.encoding?.opacity?.field !== undefined) {
       throw new Error("editPointMark opacity conflicts with a field encoding; use encodeOpacity with value to replace it.");
     }
     const config = { ...this.markConfigs[id] };
+    Object.assign(config, strokeDetails);
     if (Object.hasOwn(args, "shape")) {
       config.shape = validatePointShape(args.shape);
     }
@@ -85,9 +100,6 @@ export const editPointMark = action(
     const next = this
       ._withMarkConfig(id, config)
       .rematerializePointMark({ id });
-    const legend = next.guideConfigs.legend?.series;
-    return legend?.target === id && legend.channels.includes("shape")
-      ? rematerializeExistingLegend(next)
-      : next;
+    return rematerializeExistingLegend(next);
   }
 );

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

@@ -1,6 +1,6 @@
-import { action } from "../../../core/action.js";
+import { closedAction } from "../../../core/action.js";
 import { validateUserId } from "../../../core/identifiers.js";
-import { validateKeys } from "../../../core/validation.js";
+
 import { normalizePointJitterPolicy } from "../../../grammar/jitter.js";
 import { findCoordinate } from "../../../selectors/coordinates.js";
 import { resolveEligibleLayer } from "../../../selectors/layers.js";
@@ -28,13 +28,12 @@ function resolveJitterTarget(program, target, channel) {
   });
 }
 
-export const jitterPoints = action(
+export const jitterPoints = /* @__PURE__ */ closedAction(
   {
     op: "jitterPoints",
     description: "Apply deterministic bounded graphical jitter to a point mark."
-  },
+  }, JITTER_OPTIONS,
   function (args = {}) {
-    validateKeys(args, JITTER_OPTIONS, "jitterPoints");
     const policy = normalizePointJitterPolicy(args);
     const layer = resolveJitterTarget(this, args.target, policy.channel);
     if (this.materializationConfigs.pointPacking?.[layer.id] !== undefined) {
@@ -46,13 +45,12 @@ export const jitterPoints = action(
   }
 );
 
-export const removeJitter = action(
+export const removeJitter = /* @__PURE__ */ closedAction(
   {
     op: "removeJitter",
     description: "Remove point jitter and restore semantic scale positions."
-  },
+  }, REMOVE_OPTIONS,
   function (args = {}) {
-    validateKeys(args, REMOVE_OPTIONS, "removeJitter");
     const requested = args.target === undefined
       ? undefined
       : validateUserId(args.target, "Point jitter target");