ggaction 0.0.15 → 0.0.17

package/src/actions/marks/remove.js

@@ -1,7 +1,8 @@
+import { ownedChildren, ownership } from "../../selectors/markOwners.js";
 import { isSourceOwnedText } from "../../grammar/text.js";
-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 { findDataset } from "../../selectors/datasets.js";
 import { findLayer } from "../../selectors/layers.js";
 import { applyDetachedScaleRematerialization } from "../../materialization/dependencies.js";
@@ -23,50 +24,6 @@ const REMOVE_AXIS = Object.freeze({
   radius: "removeRadialAxis"
 });
 
-function ownedChildren(program, id) {
-  const config = program.markConfigs[id] ?? {};
-  return [
-    config.errorBar?.lowerCapId,
-    config.errorBar?.upperCapId,
-    config.errorBand?.lowerBoundaryId,
-    config.errorBand?.upperBoundaryId,
-    config.regression?.bandId,
-    config.regression?.lineId,
-    config.boxPlot?.whiskerId,
-    config.boxPlot?.medianId,
-    config.boxPlot?.outlierId,
-    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)
-  ).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);
-    }
-  }
-  return ownerByChild;
-}
-
 function resolveOwner(program, requested) {
   const ownerByChild = ownership(program);
   const stable = program.semanticSpec.layers.filter(
@@ -248,10 +205,9 @@ function cleanupPositionGuides(program, scales) {
   return next;
 }
 
-export const removeMark = action(
-  { op: "removeMark", description: "Remove one stable mark owner and owned state." },
+export const removeMark = /* @__PURE__ */ closedAction(
+  { op: "removeMark", description: "Remove one stable mark owner and owned state." }, OPTIONS,
   function (args = {}) {
-    validateKeys(args, OPTIONS, "removeMark");
     const owner = resolveOwner(this, args.target);
     const ids = collectClosure(this, owner.id);
     const external = externalMarkReferences(this, ids);

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

@@ -39,13 +39,15 @@ import {
   requestedStrokeDetails,
   STROKE_STYLE_PROPERTIES
 } from "../../../grammar/strokeStyle.js";
+import { applyItemMissingPolicy, validateItemMissing } from
+  "../../../grammar/itemMissing.js";
 
 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 CREATE_OPTIONS = Object.freeze(["id", "data", "missing", ...APPEARANCE_OPTIONS]);
+const EDIT_OPTIONS = Object.freeze(["target", "missing", ...APPEARANCE_OPTIONS]);
 const REMATERIALIZE_OPTIONS = Object.freeze(["id"]);
 const SPAN_OPTIONS = Object.freeze(["id", "orientation", "size"]);
 const DEFAULT_RULE_CONFIG = Object.freeze({
@@ -66,10 +68,11 @@ function requireRule(program, id) {
   if (layer?.mark?.type !== "rule") {
     throw new Error(`Unknown rule mark "${id}".`);
   }
-  const dataset = findDataset(program, layer.data);
-  if (dataset === undefined) {
+  const sourceDataset = findDataset(program, layer.data);
+  if (sourceDataset === undefined) {
     throw new Error(`Rule mark "${id}" requires an existing dataset.`);
   }
+  const dataset = applyItemMissingPolicy(layer, sourceDataset);
   const graphic = program.graphicSpec.objects[id];
   if (graphic?.type !== "line" || graphic.items === undefined) {
     throw new Error(`Rule mark "${id}" requires line collection graphics.`);
@@ -92,7 +95,7 @@ function validateEndpointBindings(layer) {
   }
 }
 
-const createRuleMark = action(
+const createRuleMark = /* @__PURE__ */ action(
   {
     op: "createRuleMark",
     description: "Create a semantic rule mark and empty line collection."
@@ -118,6 +121,12 @@ const createRuleMark = action(
     let created = this
       .editSemantic({ property: `layer[${id}].mark.type`, value: "rule" })
       .editSemantic({ property: `layer[${id}].data`, value: data });
+    if (Object.hasOwn(args, "missing")) {
+      created = created.editSemantic({
+        property: `layer[${id}].mark.missing`,
+        value: validateItemMissing(args.missing, "Rule missing")
+      });
+    }
     created = applyLayeredMarkInheritance(created, id, inherited);
     created = created
       .createGraphics({
@@ -142,7 +151,7 @@ const createRuleMark = action(
   }
 );
 
-const editRuleMark = action(
+const editRuleMark = /* @__PURE__ */ action(
   { op: "editRuleMark", description: "Edit constant rule appearance through its encoding owners." },
   function (args = {}) {
     validateMarkOptions(args, EDIT_OPTIONS, "editRuleMark");
@@ -154,11 +163,18 @@ const editRuleMark = action(
       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.");
+    if (appearance.length === 0 && Object.keys(strokeDetails).length === 0 &&
+        !Object.hasOwn(args, "missing")) {
+      throw new Error("editRuleMark requires missing or an appearance change.");
     }
-    const configured = this._withMarkConfig(layer.id, {
-      ...this.markConfigs[layer.id],
+    const semantic = Object.hasOwn(args, "missing")
+      ? this.editSemantic({
+          property: `layer[${layer.id}].mark.missing`,
+          value: validateItemMissing(args.missing, "Rule missing")
+        })
+      : this;
+    const configured = semantic._withMarkConfig(layer.id, {
+      ...semantic.markConfigs[layer.id],
       ...strokeDetails
     });
     const materialized = appearance.length === 0
@@ -168,7 +184,7 @@ const editRuleMark = action(
   }
 );
 
-const rematerializeRuleMark = action(
+const rematerializeRuleMark = /* @__PURE__ */ action(
   {
     op: "rematerializeRuleMark",
     description: "Recompute concrete rule endpoints and appearance."
@@ -377,7 +393,7 @@ const rematerializeRuleMark = action(
   }
 );
 
-export const materializeRuleSpan = action(
+export const materializeRuleSpan = /* @__PURE__ */ action(
   {
     op: "materializeRuleSpan",
     description: "Materialize a fixed-pixel span around a rule anchor."

package/src/actions/marks/text/actions.js

@@ -39,13 +39,14 @@ import {
 } from "../../charts/shared.js";
 import { resolveMarkGraphicPlacement } from
   "../../../materialization/graphicHierarchy.js";
+import { validateItemMissing } from "../../../grammar/itemMissing.js";
 
 const STYLE_OPTIONS = Object.freeze([
   "fill", "opacity", "fontSize", "fontFamily", "fontWeight",
   "align", "baseline", "rotation", "dx", "dy"
 ]);
-const CREATE_OPTIONS = Object.freeze(["id", "data", "source", "text", ...STYLE_OPTIONS]);
-const EDIT_OPTIONS = Object.freeze(["target", ...STYLE_OPTIONS]);
+const CREATE_OPTIONS = Object.freeze(["id", "data", "source", "text", "missing", ...STYLE_OPTIONS]);
+const EDIT_OPTIONS = Object.freeze(["target", "missing", ...STYLE_OPTIONS]);
 const REMATERIALIZE_OPTIONS = Object.freeze(["id", "replayLayout"]);
 
 function sourceMatchesData(program, layer, requestedData) {
@@ -125,7 +126,7 @@ function requireTextLayer(program, requested, operation) {
   });
 }
 
-const createTextMark = action(
+const createTextMark = /* @__PURE__ */ action(
   {
     op: "createTextMark",
     description: "Create a semantic text annotation layer."
@@ -139,6 +140,9 @@ const createTextMark = action(
       operation: "createTextMark"
     });
     const inherited = resolveTextInheritance(this, args);
+    if (Object.hasOwn(args, "missing") && inherited?.source !== undefined) {
+      throw new Error("Text missing policy requires a row-backed text mark, not source-owned labels.");
+    }
     const { data } = resolveMarkData(this, {
       ...args,
       ...(args.data === undefined && inherited?.data !== undefined
@@ -150,6 +154,12 @@ const createTextMark = action(
     let next = this
       .editSemantic({ property: `layer[${id}].mark.type`, value: "text" })
       .editSemantic({ property: `layer[${id}].data`, value: data });
+    if (Object.hasOwn(args, "missing")) {
+      next = next.editSemantic({
+        property: `layer[${id}].mark.missing`,
+        value: validateItemMissing(args.missing, "Text missing")
+      });
+    }
     if (inherited?.source !== undefined) {
       next = next.editSemantic({
         property: `layer[${id}].source`,
@@ -254,7 +264,7 @@ function resolveAnnotationBinding(program, args) {
   };
 }
 
-const createAnnotation = action(
+const createAnnotation = /* @__PURE__ */ action(
   {
     op: "createAnnotation",
     description: "Create text at a final mark, data, or plot anchor."
@@ -327,7 +337,7 @@ const createAnnotation = action(
   }
 );
 
-const createMarkLabels = action(
+const createMarkLabels = /* @__PURE__ */ action(
   {
     op: "createMarkLabels",
     description: "Create final-item text labels attached to an existing mark."
@@ -412,7 +422,7 @@ const createMarkLabels = action(
   }
 );
 
-const rematerializeTextMark = action(
+const rematerializeTextMark = /* @__PURE__ */ action(
   {
     op: "rematerializeTextMark",
     description: "Recompute concrete text content, anchors, and typography."
@@ -458,27 +468,36 @@ const rematerializeTextMark = action(
   }
 );
 
-const editTextMark = action(
+const editTextMark = /* @__PURE__ */ action(
   {
     op: "editTextMark",
     description: "Edit text typography, alignment, rotation, and offsets."
   },
   function (args = {}) {
     validateMarkOptions(args, EDIT_OPTIONS, "editTextMark");
-    if (!STYLE_OPTIONS.some(option => Object.hasOwn(args, option))) {
+    if (!["missing", ...STYLE_OPTIONS].some(option => Object.hasOwn(args, option))) {
       throw new Error("editTextMark requires at least one editable property.");
     }
     const layer = requireTextLayer(this, args.target, "editTextMark");
-    const next = this._withMarkConfig(
+    if (Object.hasOwn(args, "missing") && layer.source !== undefined) {
+      throw new Error("Text missing policy requires a row-backed text mark, not source-owned labels.");
+    }
+    const semantic = Object.hasOwn(args, "missing")
+      ? this.editSemantic({
+          property: `layer[${layer.id}].mark.missing`,
+          value: validateItemMissing(args.missing, "Text missing")
+        })
+      : this;
+    const next = semantic._withMarkConfig(
       layer.id,
       {
         ...normalizeTextMarkConfig(
           args,
-          this.markConfigs[layer.id] ?? DEFAULT_TEXT_MARK
+          semantic.markConfigs[layer.id] ?? DEFAULT_TEXT_MARK
         ),
         fillExplicit: Object.hasOwn(args, "fill")
           ? true
-          : this.markConfigs[layer.id]?.fillExplicit ?? false
+          : semantic.markConfigs[layer.id]?.fillExplicit ?? false
       }
     );
     return canMaterializeText(next, layer)

package/src/actions/marks/text/layout.js

@@ -1,4 +1,4 @@
-import { action } from "../../../core/action.js";
+import { action, closedAction } from "../../../core/action.js";
 import { validateUserId } from "../../../core/identifiers.js";
 import { validateOptionObject } from "../../../core/validation.js";
 import { DEFAULT_TEXT_MARK } from "../../../grammar/text.js";
@@ -221,22 +221,17 @@ function placementLeaderItems(program, layer) {
       sourceY: entry.anchor.y,
       dx: properties.x - entry.anchor.x,
       dy: properties.y - entry.anchor.y,
-      bounds: resolveTextBounds(properties)
+      bounds: resolveTextBounds(properties, program.materializationConfigs.textMetrics)
     };
   });
 }
 
-const materializeMarkLabelPlacement = action(
+const materializeMarkLabelPlacement = /* @__PURE__ */ closedAction(
   {
     op: "materializeMarkLabelPlacement",
     description: "Reconcile semantic attached-label placement leaders."
-  },
+  }, MATERIALIZE_PLACEMENT_OPTIONS,
   function (args = {}) {
-    validateOptionObject(
-      args,
-      MATERIALIZE_PLACEMENT_OPTIONS,
-      "materializeMarkLabelPlacement"
-    );
     const id = validateUserId(args.id, "Attached label id");
     const layer = findLayer(this, id);
     if (!isSourceOwnedText(layer)) {
@@ -267,13 +262,12 @@ const materializeMarkLabelPlacement = action(
   }
 );
 
-const materializeLabelLayout = action(
+const materializeLabelLayout = /* @__PURE__ */ closedAction(
   {
     op: "materializeLabelLayout",
     description: "Resolve concrete label positions and optional leader lines."
-  },
+  }, MATERIALIZE_OPTIONS,
   function (args = {}) {
-    validateOptionObject(args, MATERIALIZE_OPTIONS, "materializeLabelLayout");
     const id = validateUserId(args.id, "Text mark id");
     const rematerializeBase = args.rematerializeBase ?? true;
     if (typeof rematerializeBase !== "boolean") {
@@ -294,7 +288,7 @@ const materializeLabelLayout = action(
       axis: config.axis,
       padding: config.padding,
       maxDisplacement: config.maxDisplacement
-    });
+    }, next.materializationConfigs.textMetrics);
     next = editMarkGraphic(next, id, {
       x: resolved.items.map(item => item.x),
       y: resolved.items.map(item => item.y)
@@ -326,13 +320,12 @@ const materializeLabelLayout = action(
   }
 );
 
-const layoutLabels = action(
+const layoutLabels = /* @__PURE__ */ closedAction(
   {
     op: "layoutLabels",
     description: "Assign deterministic collision-aware layout to a text mark."
-  },
+  }, TEXT_LABEL_LAYOUT_OPTIONS,
   function (args = {}) {
-    validateOptionObject(args, TEXT_LABEL_LAYOUT_OPTIONS, "layoutLabels");
     const layer = requireCompleteText(this, args.target, "layoutLabels");
     const policy = normalizePolicy(args);
     const placement = this.markConfigs[layer.id]?.labelAuthoring?.placement;
@@ -358,7 +351,7 @@ const layoutLabels = action(
   }
 );
 
-const editMarkLabelPlacement = action(
+const editMarkLabelPlacement = /* @__PURE__ */ action(
   {
     op: "editMarkLabelPlacement",
     description: "Replace or reset semantic placement for one attached label layer."
@@ -418,13 +411,12 @@ const editMarkLabelPlacement = action(
   }
 );
 
-const removeLabelLayout = action(
+const removeLabelLayout = /* @__PURE__ */ closedAction(
   {
     op: "removeLabelLayout",
     description: "Remove label layout and restore semantic base text positions."
-  },
+  }, REMOVE_OPTIONS,
   function (args = {}) {
-    validateOptionObject(args, REMOVE_OPTIONS, "removeLabelLayout");
     const layer = requireConfiguredText(this, args.target);
     const config = this.materializationConfigs.labelLayouts[layer.id];
     return removeLeaderGraphic(

package/src/actions/marks/text/removal.js

@@ -140,7 +140,7 @@ function removeLabelState(program, plan) {
   return Object.keys(context).length === 0 ? next : next._withContext(context);
 }
 
-export const removeMarkLabels = action(
+export const removeMarkLabels = /* @__PURE__ */ action(
   {
     op: "removeMarkLabels",
     description: "Remove attached label layers while preserving their source mark."

package/src/actions/marks/text/selection.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 { normalizeLabelSelectionEdit } from
   "../../../grammar/markLabelSelection.js";
 import { isSourceOwnedText } from "../../../grammar/text.js";
@@ -40,13 +40,12 @@ function validateSelectionSource(program, source, requested) {
   resolveMarkSelection(program, source, definition.selector);
 }
 
-const editMarkLabelSelection = action(
+const editMarkLabelSelection = /* @__PURE__ */ closedAction(
   {
     op: "editMarkLabelSelection",
     description: "Replace the final-item membership requested by an attached label."
-  },
+  }, OPTIONS,
   function (args = {}) {
-    validateOptionObject(args, OPTIONS, "editMarkLabelSelection");
     if (!Object.hasOwn(args, "target")) {
       throw new Error("editMarkLabelSelection requires target.");
     }

package/src/actions/marks/tick/actions.js

@@ -21,6 +21,8 @@ import {
   requestedStrokeDetails,
   STROKE_STYLE_PROPERTIES
 } from "../../../grammar/strokeStyle.js";
+import { applyItemMissingPolicy, validateItemMissing } from
+  "../../../grammar/itemMissing.js";
 import { rematerializeHighlightBaseline } from "../lifecycle.js";
 import { rematerializeExistingLegend } from "../../encodings/shared.js";
 import {
@@ -37,8 +39,8 @@ import {
 const APPEARANCE_OPTIONS = Object.freeze([
   "length", "stroke", "strokeWidth", "opacity", ...STROKE_STYLE_PROPERTIES
 ]);
-const CREATE_OPTIONS = Object.freeze(["id", "data", ...APPEARANCE_OPTIONS]);
-const EDIT_OPTIONS = Object.freeze(["target", ...APPEARANCE_OPTIONS]);
+const CREATE_OPTIONS = Object.freeze(["id", "data", "missing", ...APPEARANCE_OPTIONS]);
+const EDIT_OPTIONS = Object.freeze(["target", "missing", ...APPEARANCE_OPTIONS]);
 const REMATERIALIZE_OPTIONS = Object.freeze(["id"]);
 
 export const DEFAULT_TICK_CONFIG = Object.freeze({
@@ -88,7 +90,7 @@ function validateTickConfig(args, current = DEFAULT_TICK_CONFIG) {
   };
 }
 
-export const createTickMark = action(
+export const createTickMark = /* @__PURE__ */ action(
   {
     op: "createTickMark",
     description: "Create a centered fixed-length Tick mark."
@@ -114,6 +116,12 @@ export const createTickMark = action(
     let created = this
       .editSemantic({ property: `layer[${id}].mark.type`, value: "tick" })
       .editSemantic({ property: `layer[${id}].data`, value: data });
+    if (Object.hasOwn(args, "missing")) {
+      created = created.editSemantic({
+        property: `layer[${id}].mark.missing`,
+        value: validateItemMissing(args.missing, "Tick missing")
+      });
+    }
     created = applyLayeredMarkInheritance(created, id, inherited)
       .createGraphics({
         id,
@@ -133,7 +141,7 @@ export const createTickMark = action(
   }
 );
 
-export const editTickMark = action(
+export const editTickMark = /* @__PURE__ */ action(
   {
     op: "editTickMark",
     description: "Edit Tick length and constant line appearance."
@@ -141,9 +149,9 @@ export const editTickMark = action(
   function (args = {}) {
     validateMarkOptions(args, EDIT_OPTIONS, "editTickMark");
     requestedStrokeDetails(args, "editTickMark");
-    if (!APPEARANCE_OPTIONS.some(property => Object.hasOwn(args, property))) {
+    if (!["missing", ...APPEARANCE_OPTIONS].some(property => Object.hasOwn(args, property))) {
       throw new Error(
-        "editTickMark requires length, stroke, strokeWidth, or opacity."
+        "editTickMark requires length, stroke, strokeWidth, opacity, or missing."
       );
     }
     const layer = resolveTick(this, args.target, "editTickMark");
@@ -152,18 +160,24 @@ export const editTickMark = action(
         "editTickMark stroke conflicts with a field encoding; use encodeStroke with value to replace it."
       );
     }
+    const semantic = Object.hasOwn(args, "missing")
+      ? this.editSemantic({
+          property: `layer[${layer.id}].mark.missing`,
+          value: validateItemMissing(args.missing, "Tick missing")
+        })
+      : this;
     const config = validateTickConfig(args, {
       ...DEFAULT_TICK_CONFIG,
-      ...this.markConfigs[layer.id]
+      ...semantic.markConfigs[layer.id]
     });
-    const materialized = this
+    const materialized = semantic
       ._withMarkConfig(layer.id, config)
       .rematerializeTickMark({ id: layer.id });
     return rematerializeExistingLegend(materialized);
   }
 );
 
-export const rematerializeTickMark = action(
+export const rematerializeTickMark = /* @__PURE__ */ action(
   {
     op: "rematerializeTickMark",
     description: "Recompute concrete centered Tick endpoints and appearance."
@@ -190,10 +204,11 @@ export const rematerializeTickMark = action(
     if (graphic?.type !== "line" || !Array.isArray(graphic.items)) {
       throw new Error(`Tick mark "${id}" requires line collection graphics.`);
     }
-    const dataset = findDataset(this, layer.data);
-    if (dataset === undefined) {
+    const sourceDataset = findDataset(this, layer.data);
+    if (sourceDataset === undefined) {
       throw new Error(`Tick mark "${id}" requires an existing dataset.`);
     }
+    const dataset = applyItemMissingPolicy(layer, sourceDataset);
     if (
       layer.encoding?.x?.scale === undefined ||
       layer.encoding?.y?.scale === undefined

package/src/actions/primitives/createGraphics.js

@@ -1,4 +1,4 @@
-import { action } from "../../core/action.js";
+import { closedAction } from "../../core/action.js";
 import { validateUserId } from "../../core/identifiers.js";
 import { freezeOwned } from "../../core/immutable.js";
 import { validateGeneratedItemLimit } from "../../core/validation.js";
@@ -100,13 +100,14 @@ function insertSibling(siblings, id, { before, after }) {
   return freezeOwned(next);
 }
 
-const createGraphics = action(
+const createGraphics = /* @__PURE__ */ closedAction(
   {
     op: "createGraphics",
     description: "Create and optionally attach a concrete graphic.",
     scope: "any"
-  },
-  function ({ id, type, length, parent, before, after } = {}) {
+  }, ["id", "type", "length", "parent", "before", "after"],
+  function (args = {}) {
+    const { id, type, length, parent, before, after } = args;
     if (typeof id !== "string" || !GRAPHIC_ID_PATTERN.test(id)) {
       throw new TypeError(
         "createGraphics requires an id containing only letters, numbers, _ or -."

package/src/actions/primitives/editGraphics.js

@@ -1,4 +1,4 @@
-import { action } from "../../core/action.js";
+import { closedAction } from "../../core/action.js";
 import { cloneAndFreeze, freezeOwned, isPlainObject } from "../../core/immutable.js";
 import { validateGeneratedItemLimit } from "../../core/validation.js";
 import {
@@ -162,13 +162,14 @@ function removeGraphicTree(graphicSpec, id) {
   return freezeOwned({ objects: freezeOwned(objects), order });
 }
 
-const editGraphics = action(
+const editGraphics = /* @__PURE__ */ closedAction(
   {
     op: "editGraphics",
     description: "Replace or remove concrete graphic state.",
     scope: "any"
-  },
-  function ({ target, property, value, remove = false } = {}) {
+  }, ["target", "property", "value", "remove"],
+  function (args = {}) {
+    const { target, property, value, remove = false } = args;
     if (typeof target !== "string" || target.length === 0) {
       throw new TypeError("editGraphics requires a non-empty target string.");
     }

package/src/actions/primitives/graphicProperties.js

@@ -0,0 +1,6 @@
+export function editGraphicProperties(program, target, properties) {
+  for (const [property, value] of Object.entries(properties)) {
+    program = program.editGraphics({ target, property, value });
+  }
+  return program;
+}

package/src/actions/primitives/semantic.js

@@ -18,12 +18,19 @@ function validateParallel(property, value) {
   }
 }
 
-export function registerSemanticPrimitiveAction(ProgramClass) {
-  const validateSemanticValue = createSemanticValueValidator({
+function fullSemanticValidator() {
+  return createSemanticValueValidator({
     validateDatasetTransforms,
     validateParallel,
     sourceMarkTypes: ["point", "bar", "line", "rule", "rect", "arc"]
   });
+}
+
+export function validateStoredSemanticValue(program, parsed, value) {
+  return fullSemanticValidator()(program, parsed, value);
+}
+
+export function registerSemanticPrimitiveAction(ProgramClass) {
   ProgramClass.prototype.editSemantic =
-    createSemanticPrimitiveAction(validateSemanticValue, planResourceRemoval);
+    createSemanticPrimitiveAction(fullSemanticValidator(), planResourceRemoval);
 }