ggaction 0.0.12 → 0.0.15

package/src/actions/marks/remove.js

@@ -1,12 +1,19 @@
+import { isSourceOwnedText } from "../../grammar/text.js";
 import { action } from "../../core/action.js";
 import { validateUserId } from "../../core/identifiers.js";
 import { validateKeys } from "../../core/validation.js";
 import { findDataset } from "../../selectors/datasets.js";
 import { findLayer } from "../../selectors/layers.js";
+import { applyDetachedScaleRematerialization } from "../../materialization/dependencies.js";
+import { markLabelPlacementLeaderId } from "../../layout/labels.js";
 import {
   getPositionChannelDefinition,
   POSITION_CHANNELS
 } from "../../core/vocabulary.js";
+import {
+  canonicalResourcePath,
+  collectResourceReferences
+} from "../../core/resourceReferences.js";
 
 const OPTIONS = Object.freeze(["target"]);
 const REMOVE_AXIS = Object.freeze({
@@ -28,18 +35,32 @@ function ownedChildren(program, id) {
     config.boxPlot?.whiskerId,
     config.boxPlot?.medianId,
     config.boxPlot?.outlierId,
-    config.gradientPlot?.centerId
+    config.gradientPlot?.centerId,
+    config.intervalPlot?.intervalId,
+    config.endpointPlot?.roles?.stemId,
+    config.endpointPlot?.roles?.startId,
+    config.endpointPlot?.roles?.connectorId,
+    ...(config.raincloudPlot?.ownedChildIds ?? [])
   ].concat(
     program.semanticSpec.layers
       .filter(layer => layer.source === id)
       .map(layer => layer.id)
-  ).filter(child => child !== undefined && findLayer(program, child) !== undefined);
+  ).concat(
+    program.semanticSpec.layers
+      .filter(layer =>
+        program.markConfigs[layer.id]?.statisticalReference?.source === id
+      )
+      .map(layer => layer.id)
+  ).filter(child => child !== undefined && child !== id && findLayer(program, child) !== undefined);
 }
 
 function ownership(program) {
   const ownerByChild = new Map();
   for (const layer of program.semanticSpec.layers) {
     for (const child of ownedChildren(program, layer.id)) {
+      if (program.markConfigs[child]?.statisticalReference !== undefined) {
+        continue;
+      }
       ownerByChild.set(child, layer.id);
     }
   }
@@ -79,6 +100,37 @@ function collectClosure(program, root) {
   return result;
 }
 
+function externalMarkReferences(program, ids) {
+  const closure = new Set(ids);
+  const references = ids.flatMap(id => collectResourceReferences(program, {
+    kind: "mark",
+    id
+  })).filter(reference => {
+    if (reference.strength === "context") return false;
+    if (["layer", "markConfig"].includes(reference.ownerKind)) {
+      return !closure.has(reference.ownerId);
+    }
+    if (["selection", "highlight", "legend"].includes(reference.ownerKind)) {
+      return false;
+    }
+    if (
+      reference.ownerKind === "axis" &&
+      reference.ownerId === "parallel.axes"
+    ) {
+      return false;
+    }
+    return true;
+  });
+  const unique = new Map(references.map(reference => [[
+    reference.ownerKind,
+    reference.ownerId,
+    canonicalResourcePath(reference.path)
+  ].join("\u0000"), reference]));
+  return [...unique.entries()]
+    .sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0)
+    .map(([, reference]) => reference);
+}
+
 function ownedDerivedData(program, ids) {
   const candidates = new Set();
   for (const id of ids) {
@@ -90,7 +142,11 @@ function ownedDerivedData(program, ids) {
       config.regression?.dataId,
       config.boxPlot?.summaryId,
       config.boxPlot?.outlierDataId,
-      config.gradientPlot?.profileId
+      config.gradientPlot?.profileId,
+      config.violinPlot?.materialized === true ? layer?.data : undefined,
+      config.ecdfPlot?.data,
+      config.endpointPlot?.data,
+      config.statisticalReference?.dataId
     ]) {
       if (candidate !== undefined) candidates.add(candidate);
     }
@@ -161,7 +217,7 @@ export function removeOwnedMark(program, id, partial = false) {
 
 function hasScaleConsumer(program, channel, scale) {
   return program.semanticSpec.layers.some(
-    layer => layer.encoding?.[channel]?.scale === scale
+    layer => !isSourceOwnedText(layer) && layer.encoding?.[channel]?.scale === scale
   );
 }
 
@@ -198,10 +254,26 @@ export const removeMark = action(
     validateKeys(args, OPTIONS, "removeMark");
     const owner = resolveOwner(this, args.target);
     const ids = collectClosure(this, owner.id);
+    const external = externalMarkReferences(this, ids);
+    if (external.length > 0) {
+      throw new Error(
+        `removeMark cannot remove externally referenced marks: ${external.map(
+          reference => `${reference.ownerKind} "${reference.ownerId}" at ` +
+            canonicalResourcePath(reference.path)
+        ).join("; ")}.`
+      );
+    }
+    const previousLayers = ids.map(id => findLayer(this, id));
     const derived = ownedDerivedData(this, ids);
     const positionScales = usedPositionScales(this, ids);
     let next = this;
 
+    if (ids.includes(next.guideConfigs.axis?.parallel?.axes?.target)) {
+      next = next.removeParallelAxes({
+        target: next.guideConfigs.axis.parallel.axes.target
+      });
+    }
+
     const legendTargets = [...new Set(Object.values(next.guideConfigs.legend ?? {})
       .filter(config => ids.includes(config?.target))
       .map(config => config.target))];
@@ -219,6 +291,15 @@ export const removeMark = action(
       ) {
         next = next.editGraphics({ target: labelLayout.leaderId, remove: true });
       }
+      const placement = next.markConfigs[id]?.labelAuthoring?.placement;
+      const placementLeaderId = markLabelPlacementLeaderId(id);
+      if (
+        placement?.leader !== undefined &&
+        placement.leader !== false &&
+        next.graphicSpec.objects[placementLeaderId] !== undefined
+      ) {
+        next = next.editGraphics({ target: placementLeaderId, remove: true });
+      }
       if (findLayer(next, id) !== undefined) {
         next = next.editSemantic({ property: `layer[${id}]`, remove: true });
       }
@@ -227,6 +308,7 @@ export const removeMark = action(
       }
       next = next._withoutMaterializationConfig(["marks", id]);
       next = next._withoutMaterializationConfig(["jitters", id]);
+      next = next._withoutMaterializationConfig(["pointPacking", id]);
       next = next._withoutMaterializationConfig(["labelLayouts", id]);
     }
 
@@ -236,6 +318,7 @@ export const removeMark = action(
         next = next.releaseDerivedData({ id });
       }
     }
+    next = applyDetachedScaleRematerialization(next, previousLayers);
     return next._withContext({
       ...(ids.includes(this.context.currentMark) ? { currentMark: undefined } : {}),
       ...(selectionCleanup.selectionIds.includes(this.context.currentSelection)

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

@@ -9,10 +9,13 @@ import {
   normalizeStrokeDashPattern
 } from "../../../grammar/scales/index.js";
 import { deriveRuleValues, resolveRuleMode } from "../../../grammar/rules.js";
-import { resolveGraphicBounds } from "../../../layout/canvas.js";
+import { resolveCoordinateBounds } from "../../../materialization/coordinateBounds.js";
+import { readRectItemGeometry } from "../../../grammar/roundedRect.js";
 import { findDataset } from "../../../selectors/datasets.js";
-import { findLayer } from "../../../selectors/layers.js";
+import { findLayer, resolveEligibleLayer } from "../../../selectors/layers.js";
+import { applyRuleAppearance, planRuleAppearance } from "./appearance.js";
 import { DEFAULT_COLORS } from "../../../theme/defaults.js";
+import { rematerializeExistingLegend } from "../../encodings/shared.js";
 import {
   assertMarkAvailable,
   applyLayeredMarkInheritance,
@@ -28,8 +31,21 @@ import { resolveMarkGraphicPlacement } from
 import { rematerializeHighlightBaseline } from "../lifecycle.js";
 import { applyOffsetPositionValues } from
   "../../../materialization/rowEncoding.js";
+import { resolveCategorySlotOffset } from
+  "../../../materialization/categorySlotOffset.js";
+import { mapScaleConsumerValues } from
+  "../../../materialization/scales/map.js";
+import {
+  requestedStrokeDetails,
+  STROKE_STYLE_PROPERTIES
+} from "../../../grammar/strokeStyle.js";
 
-const CREATE_OPTIONS = Object.freeze(["id", "data"]);
+const APPEARANCE_OPTIONS = Object.freeze([
+  "stroke", "strokeWidth", "strokeDash", "opacity",
+  ...STROKE_STYLE_PROPERTIES
+]);
+const CREATE_OPTIONS = Object.freeze(["id", "data", ...APPEARANCE_OPTIONS]);
+const EDIT_OPTIONS = Object.freeze(["target", ...APPEARANCE_OPTIONS]);
 const REMATERIALIZE_OPTIONS = Object.freeze(["id"]);
 const SPAN_OPTIONS = Object.freeze(["id", "orientation", "size"]);
 const DEFAULT_RULE_CONFIG = Object.freeze({
@@ -83,6 +99,7 @@ const createRuleMark = action(
   },
   function (args = {}) {
     validateMarkOptions(args, CREATE_OPTIONS, "createRuleMark");
+    const strokeDetails = requestedStrokeDetails(args, "createRuleMark");
     const id = resolveMarkId(this, args.id, {
       defaultId: "rule",
       label: "Rule mark id",
@@ -96,6 +113,7 @@ const createRuleMark = action(
         inherited?.data !== undefined ? { data: inherited.data } : {})
     });
     assertMarkAvailable(this, id);
+    const appearance = planRuleAppearance(args, inherited);
 
     let created = this
       .editSemantic({ property: `layer[${id}].mark.type`, value: "rule" })
@@ -110,6 +128,7 @@ const createRuleMark = action(
       })
       ._withMarkConfig(id, {
         ...DEFAULT_RULE_CONFIG,
+        ...strokeDetails,
         ...(inherited === undefined
           ? {}
           : {
@@ -119,7 +138,33 @@ const createRuleMark = action(
               }
             })
       });
-    return materializeInheritedMark(created, id);
+    return applyRuleAppearance(materializeInheritedMark(created, id), id, appearance);
+  }
+);
+
+const editRuleMark = action(
+  { op: "editRuleMark", description: "Edit constant rule appearance through its encoding owners." },
+  function (args = {}) {
+    validateMarkOptions(args, EDIT_OPTIONS, "editRuleMark");
+    const strokeDetails = requestedStrokeDetails(args, "editRuleMark");
+    if (args.target !== undefined) validateUserId(args.target, "Rule mark id");
+    const layer = resolveEligibleLayer(this, {
+      target: args.target,
+      predicate: candidate => candidate.mark?.type === "rule",
+      label: "rule mark"
+    });
+    const appearance = planRuleAppearance(args, layer);
+    if (appearance.length === 0 && Object.keys(strokeDetails).length === 0) {
+      throw new Error("editRuleMark requires an appearance change.");
+    }
+    const configured = this._withMarkConfig(layer.id, {
+      ...this.markConfigs[layer.id],
+      ...strokeDetails
+    });
+    const materialized = appearance.length === 0
+      ? configured.rematerializeRuleMark({ id: layer.id })
+      : applyRuleAppearance(configured, layer.id, appearance);
+    return rematerializeExistingLegend(materialized);
   }
 );
 
@@ -159,7 +204,7 @@ const rematerializeRuleMark = action(
     const scaleIds = [...new Set(
       [
         "x", "y", "x2", "y2", "xOffset", "yOffset",
-        "strokeDash", "strokeWidth", "opacity"
+        "stroke", "strokeDash", "strokeWidth", "opacity"
       ]
         .map(channel => layer.encoding?.[channel]?.scale)
         .filter(scale => scale !== undefined)
@@ -203,7 +248,7 @@ const rematerializeRuleMark = action(
         channel
       });
     }
-    const bounds = resolveGraphicBounds(resolved);
+    const bounds = resolveCoordinateBounds(resolved, layer.coordinate);
     const x1 = [];
     const y1 = [];
     const x2 = [];
@@ -231,7 +276,11 @@ const rematerializeRuleMark = action(
         startY = endY = mapped.y[index];
       } else if (mode === "box-span") {
         const owner = resolved.graphicSpec.objects[boxSpan];
-        const box = owner?.items?.[index]?.properties;
+        const item = owner?.items?.[index];
+        const box = readRectItemGeometry({
+          type: item?.type ?? owner?.type,
+          properties: item?.properties
+        });
         if (box === undefined) throw new Error(`Rule mark "${id}" requires box span owner "${boxSpan}".`);
         if (layer.encoding?.x?.fieldType === "quantitative") {
           startX = endX = mapped.x[index];
@@ -263,12 +312,22 @@ const rematerializeRuleMark = action(
       x2.push(endX);
       y2.push(endY);
     }
+    const categoryOffset = resolveCategorySlotOffset(resolved, layer);
+    if (categoryOffset?.pixels) {
+      const targets = categoryOffset.channel === "x" ? [x1, x2] : [y1, y2];
+      for (const values of targets) {
+        for (let index = 0; index < values.length; index += 1) {
+          if (Number.isFinite(values[index])) values[index] += categoryOffset.pixels;
+        }
+      }
+    }
 
     const resolvedConfig = {
       ...DEFAULT_RULE_CONFIG,
       ...resolved.markConfigs[id]
     };
     const dashEncoding = layer.encoding?.strokeDash;
+    const strokeEncoding = layer.encoding?.stroke;
     const opacityEncoding = layer.encoding?.opacity;
     const strokeWidthEncoding = layer.encoding?.strokeWidth;
     const strokeDash = dashEncoding?.scale === undefined
@@ -295,6 +354,13 @@ const rematerializeRuleMark = action(
           derived.values.strokeWidth,
           resolved.resolvedScales[strokeWidthEncoding.scale]
         );
+    const stroke = strokeEncoding?.scale === undefined
+      ? resolvedConfig.stroke
+      : mapScaleConsumerValues(
+          derived.values.stroke,
+          resolved.resolvedScales[strokeEncoding.scale],
+          "stroke"
+        );
 
     return editMarkGraphic(resolved, id, {
       length: derived.length,
@@ -302,10 +368,11 @@ const rematerializeRuleMark = action(
       y1,
       x2,
       y2,
-      stroke: resolvedConfig.stroke,
+      stroke,
       strokeWidth,
       strokeDash,
-      opacity
+      opacity,
+      ...requestedStrokeDetails(resolvedConfig, "Rule mark")
     });
   }
 );
@@ -337,6 +404,7 @@ export const materializeRuleSpan = action(
 export function registerRuleMarkActions(ProgramClass) {
   Object.assign(ProgramClass.prototype, {
     createRuleMark,
+    editRuleMark,
     rematerializeRuleMark,
     materializeRuleSpan
   });

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

@@ -0,0 +1,26 @@
+import { validateRuleStroke, validateRuleStrokeWidth } from "../../../grammar/ruleAppearance.js";
+import { normalizeStrokeDashPattern, validateOpacityValue } from "../../../grammar/scales/index.js";
+
+const STYLE_ACTIONS = Object.freeze({
+  stroke: ["encodeStroke", validateRuleStroke],
+  strokeWidth: ["encodeStrokeWidth", validateRuleStrokeWidth],
+  strokeDash: ["encodeStrokeDash", normalizeStrokeDashPattern],
+  opacity: ["encodeOpacity", validateOpacityValue]
+});
+
+export function planRuleAppearance(args, layer) {
+  return Object.entries(STYLE_ACTIONS).flatMap(([property, [op, validate]]) => {
+    if (!Object.hasOwn(args, property)) return [];
+    if (layer?.encoding?.[property]?.field !== undefined) {
+      throw new Error(`Rule ${property} conflicts with a field encoding; use ${op} with value to replace it.`);
+    }
+    validate(args[property], `Rule ${property}`);
+    return [{ op, value: args[property] }];
+  });
+}
+
+export function applyRuleAppearance(program, target, plan) {
+  let next = program;
+  for (const { op, value } of plan) next = next[op]({ target, value });
+  return next;
+}

package/src/actions/marks/shared.js

@@ -1,8 +1,9 @@
+import { isSourceOwnedText } from "../../grammar/text.js";
 import {
   resolveOptionalUserId,
   validateUserId
 } from "../../core/identifiers.js";
-import { findDataset } from "../../selectors/datasets.js";
+import { findDataset, requireMaterializedDataset } from "../../selectors/datasets.js";
 import { findLayer, hasLayer } from "../../selectors/layers.js";
 import { findSemanticScale } from "../../selectors/scales.js";
 import { resolveMarkPositionPolicy } from "../encodings/position/policies/index.js";
@@ -27,13 +28,8 @@ export function resolveMarkData(program, requested) {
     throw new Error("Mark creation requires data or a current dataset.");
   }
 
-  const dataset = findDataset(program, data);
-
-  if (dataset === undefined) {
-    throw new Error(`Unknown dataset "${data}".`);
-  }
-
-  return { data, dataset };
+  const dataset = requireMaterializedDataset(program, data);
+  return { data: dataset.id, dataset };
 }
 
 export function resolveMarkId(program, requested, {
@@ -60,7 +56,7 @@ export function assertMarkAvailable(program, id) {
     throw new Error(`Mark "${id}" already exists.`);
   }
 
-  if (program.graphicSpec.objects[id] !== undefined) {
+  if (Object.hasOwn(program.graphicSpec.objects, id)) {
     throw new Error(`Graphic "${id}" already exists.`);
   }
 }
@@ -78,9 +74,9 @@ const POSITION_POLICY_SUBSETS = Object.freeze([
 ]);
 
 function inheritedPositionEncodings(encoding) {
-  if (encoding?.field === undefined) return undefined;
+  if (encoding?.field === undefined && encoding?.aggregate !== "count") return undefined;
   const base = Object.fromEntries(
-    ["field", "fieldType", "scale", "title"]
+    ["field", "fieldType", "scale", "title", "temporalUnit"]
       .filter(property => Object.hasOwn(encoding, property))
       .map(property => [property, encoding[property]])
   );
@@ -104,6 +100,9 @@ function inheritedPositionEncodings(encoding) {
 function scaleSupportsEncoding(program, markType, channel, encoding) {
   const scale = findSemanticScale(program, encoding.scale);
   if (scale === undefined) return false;
+  if (scale.radialMapping !== undefined) {
+    return markType === "arc" && channel === "radius" && ["count", "sum"].includes(encoding.aggregate);
+  }
   const categorical = ["nominal", "ordinal"].includes(encoding.fieldType);
   if (categorical) {
     if (["bar", "rect"].includes(markType)) return scale.type === "band";
@@ -143,7 +142,8 @@ export function resolveCompatibleEncodings(program, source, markType) {
             layer: candidate,
             dataset,
             channel,
-            args: encoding,
+            args: { ...encoding, ...(channel === "radius" && findSemanticScale(program, encoding.scale)?.radialMapping !== undefined
+              ? { mapping: findSemanticScale(program, encoding.scale).radialMapping } : {}) },
             field: encoding.field,
             fieldType: encoding.fieldType
           });
@@ -163,7 +163,7 @@ export function resolveCompatibleEncodings(program, source, markType) {
 }
 
 function eligibleLayeredSource(program, layer, requestedData, markType) {
-  if (layer?.data === undefined) return false;
+  if (layer?.data === undefined || isSourceOwnedText(layer)) return false;
   if (requestedData !== undefined && layer.data !== requestedData) return false;
   return Object.keys(resolveCompatibleEncodings(program, layer, markType)).length > 0;
 }