ggaction 0.0.13 → 0.0.16

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

@@ -1,18 +1,24 @@
-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";
+import { isSourceOwnedText } from "../../../grammar/text.js";
 import { findGraphicParent } from "../../../grammar/schemas/graphicTree.js";
 import { validateConcreteGraphicValue } from
   "../../../grammar/schemas/concreteGraphic.js";
 import {
+  markLabelPlacementLeaderId,
   normalizeLabelLayoutGeometry,
   resolveLabelLayout,
   resolveLabelLeader
 } from "../../../layout/labels.js";
+import { resolveTextBounds } from "../../../core/textMetrics.js";
 import { resolveGraphicBounds } from "../../../layout/canvas.js";
 import { canMaterializeText } from "../../../materialization/marks/index.js";
-import { resolveTextGraphicEntries } from "../../../materialization/text.js";
+import {
+  resolveTextGraphicEntries,
+  validateSourceMarkLabelPlacement
+} from "../../../materialization/text.js";
 import { findLayer, resolveEligibleLayer } from "../../../selectors/layers.js";
 import { editMarkGraphic } from "../shared.js";
 
@@ -21,6 +27,8 @@ export const TEXT_LABEL_LAYOUT_OPTIONS = Object.freeze([
 ]);
 const REMOVE_OPTIONS = Object.freeze(["target"]);
 const MATERIALIZE_OPTIONS = Object.freeze(["id", "rematerializeBase"]);
+const MATERIALIZE_PLACEMENT_OPTIONS = Object.freeze(["id"]);
+const EDIT_PLACEMENT_OPTIONS = Object.freeze(["target", "placement"]);
 const LEADER_OPTIONS = Object.freeze([
   "stroke", "strokeWidth", "strokeDash", "opacity"
 ]);
@@ -166,10 +174,10 @@ function removeLeaderGraphic(program, id) {
     : program.editGraphics({ target: id, remove: true });
 }
 
-function materializeLeaders(program, layer, config, resolved) {
+function materializeLeaders(program, layer, config, items) {
   let next = removeLeaderGraphic(program, config.leaderId);
   if (config.leader === false) return { program: next, count: 0 };
-  const leaders = resolved.items.map(resolveLabelLeader).filter(Boolean);
+  const leaders = items.map(resolveLabelLeader).filter(Boolean);
   if (leaders.length === 0) return { program: next, count: 0 };
   next = next.createGraphics({
       id: config.leaderId,
@@ -190,13 +198,76 @@ function materializeLeaders(program, layer, config, resolved) {
   return { program: next, count: leaders.length };
 }
 
-const materializeLabelLayout = action(
+function placementLeaderItems(program, layer) {
+  const entries = resolveTextGraphicEntries(
+    program,
+    layer,
+    program.markConfigs[layer.id] ?? DEFAULT_TEXT_MARK
+  );
+  const graphic = program.graphicSpec.objects[layer.id];
+  if (graphic?.type !== "text" || !Array.isArray(graphic.items)) {
+    throw new Error(`Text mark "${layer.id}" requires text collection graphics.`);
+  }
+  if (entries.length !== graphic.items.length) {
+    throw new Error(`Text mark "${layer.id}" placement materialization is inconsistent.`);
+  }
+  return entries.map((entry, index) => {
+    const properties = graphic.items[index].properties;
+    return {
+      id: graphic.items[index].id,
+      x: properties.x,
+      y: properties.y,
+      sourceX: entry.anchor.x,
+      sourceY: entry.anchor.y,
+      dx: properties.x - entry.anchor.x,
+      dy: properties.y - entry.anchor.y,
+      bounds: resolveTextBounds(properties, program.materializationConfigs.textMetrics)
+    };
+  });
+}
+
+const materializeMarkLabelPlacement = /* @__PURE__ */ closedAction(
+  {
+    op: "materializeMarkLabelPlacement",
+    description: "Reconcile semantic attached-label placement leaders."
+  }, MATERIALIZE_PLACEMENT_OPTIONS,
+  function (args = {}) {
+    const id = validateUserId(args.id, "Attached label id");
+    const layer = findLayer(this, id);
+    if (!isSourceOwnedText(layer)) {
+      throw new Error(`Unknown attached label target "${id}".`);
+    }
+    const leaderId = markLabelPlacementLeaderId(id);
+    const placement = this.markConfigs[id]?.labelAuthoring?.placement;
+    if (placement?.leader === undefined || placement.leader === false) {
+      return this;
+    }
+    const layout = this.materializationConfigs.labelLayouts?.[id];
+    if (layout !== undefined && layout.leader !== false) {
+      throw new Error(
+        "Semantic label placement leader conflicts with the active collision-layout leader."
+      );
+    }
+    if (!canMaterializeText(this, layer)) {
+      return removeLeaderGraphic(this, leaderId);
+    }
+    return materializeLeaders(this, layer, {
+      leaderId,
+      leader: {
+        ...placement.leader,
+        strokeDash: [],
+        opacity: 1
+      }
+    }, placementLeaderItems(this, layer)).program;
+  }
+);
+
+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") {
@@ -217,14 +288,14 @@ 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)
     });
-    const leaders = materializeLeaders(next, layer, config, resolved);
+    const leaders = materializeLeaders(next, layer, config, resolved.items);
     next = leaders.program;
-    return next._withMaterializationConfig(["labelLayouts", id], {
+    next = next._withMaterializationConfig(["labelLayouts", id], {
       axis: config.axis,
       padding: config.padding,
       maxDisplacement: config.maxDisplacement,
@@ -243,18 +314,26 @@ const materializeLabelLayout = action(
         warnings: resolved.warnings
       }
     });
+    return layer.source === undefined
+      ? next
+      : next.materializeMarkLabelPlacement({ id });
   }
 );
 
-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;
+    if (policy.leader !== false && placement?.leader !== false && placement?.leader !== undefined) {
+      throw new Error(
+        "Collision-layout leader conflicts with the active semantic label placement leader."
+      );
+    }
     const generatedId = leaderId(layer.id);
     const existingConfig = this.materializationConfigs.labelLayouts?.[layer.id];
     if (
@@ -272,13 +351,72 @@ const layoutLabels = action(
   }
 );
 
-const removeLabelLayout = action(
+const editMarkLabelPlacement = /* @__PURE__ */ action(
+  {
+    op: "editMarkLabelPlacement",
+    description: "Replace or reset semantic placement for one attached label layer."
+  },
+  function (args = {}) {
+    validateOptionObject(args, EDIT_PLACEMENT_OPTIONS, "editMarkLabelPlacement", {
+      allowEmpty: false,
+      emptyError: Error
+    });
+    if (!Object.hasOwn(args, "target") || !Object.hasOwn(args, "placement")) {
+      throw new Error("editMarkLabelPlacement requires target and placement.");
+    }
+    const id = validateUserId(args.target, "Attached label id");
+    const layer = findLayer(this, id);
+    if (!isSourceOwnedText(layer)) {
+      throw new Error(`Unknown attached label target "${id}".`);
+    }
+    let placement;
+    if (args.placement !== "auto") {
+      placement = validateSourceMarkLabelPlacement(this, layer.source, args.placement);
+      if (
+        placement.leader !== false &&
+        this.materializationConfigs.labelLayouts?.[id]?.leader !== false &&
+        this.materializationConfigs.labelLayouts?.[id]?.leader !== undefined
+      ) {
+        throw new Error(
+          "Semantic label placement leader conflicts with the active collision-layout leader."
+        );
+      }
+      const generatedId = markLabelPlacementLeaderId(id);
+      const previous = this.markConfigs[id]?.labelAuthoring?.placement;
+      if (
+        placement.leader !== false &&
+        this.graphicSpec.objects[generatedId] !== undefined &&
+        (previous?.leader === undefined || previous.leader === false)
+      ) {
+        throw new Error(`Mark label placement leader graphic "${generatedId}" already exists.`);
+      }
+    }
+    const config = this.markConfigs[id] ?? DEFAULT_TEXT_MARK;
+    const previousPlacement = config.labelAuthoring?.placement;
+    let base = this;
+    if (
+      previousPlacement?.leader !== undefined &&
+      previousPlacement.leader !== false &&
+      (placement === undefined || placement.leader === false)
+    ) {
+      base = removeLeaderGraphic(base, markLabelPlacementLeaderId(id));
+    }
+    const labelAuthoring = { ...config.labelAuthoring };
+    if (placement === undefined) delete labelAuthoring.placement;
+    else labelAuthoring.placement = placement;
+    const next = base._withMarkConfig(id, { ...config, labelAuthoring });
+    return canMaterializeText(next, layer)
+      ? next.rematerializeTextMark({ id })
+      : next.materializeMarkLabelPlacement({ id });
+  }
+);
+
+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(
@@ -292,6 +430,8 @@ export function registerTextLabelLayoutActions(ProgramClass) {
   Object.assign(ProgramClass.prototype, {
     layoutLabels,
     removeLabelLayout,
-    materializeLabelLayout
+    materializeLabelLayout,
+    editMarkLabelPlacement,
+    materializeMarkLabelPlacement
   });
 }

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

@@ -0,0 +1,173 @@
+import { action } from "../../../core/action.js";
+import { validateUserId } from "../../../core/identifiers.js";
+import { validateOptionObject } from "../../../core/validation.js";
+import { isSourceOwnedText } from "../../../grammar/text.js";
+import { isTextSource } from "../../../materialization/marks/index.js";
+import { findLayer } from "../../../selectors/layers.js";
+import { markLabelPlacementLeaderId } from "../../../layout/labels.js";
+
+const REMOVE_MARK_LABELS_OPTIONS = Object.freeze(["target", "source"]);
+
+function compareIds(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+
+function attachedLabels(program, source) {
+  return program.semanticSpec.layers
+    .filter(layer => isSourceOwnedText(layer) && layer.source === source)
+    .sort((left, right) => compareIds(left.id, right.id));
+}
+
+function resolveAttachedLabelTargets(program, args) {
+  const hasTarget = Object.hasOwn(args, "target");
+  const hasSource = Object.hasOwn(args, "source");
+  if (hasTarget === hasSource) {
+    throw new Error("removeMarkLabels requires exactly one of target or source.");
+  }
+  if (hasTarget) {
+    const target = validateUserId(args.target, "Attached label id");
+    const layer = findLayer(program, target);
+    if (!isSourceOwnedText(layer) || !isTextSource(findLayer(program, layer.source))) {
+      throw new Error(`Unknown attached label target "${target}".`);
+    }
+    return [layer];
+  }
+  const source = validateUserId(args.source, "Label source id");
+  const layer = findLayer(program, source);
+  if (!isTextSource(layer)) {
+    throw new Error(`Unknown label source "${source}".`);
+  }
+  return attachedLabels(program, source);
+}
+
+function collectAttachedLabelRemoval(program, labels) {
+  const labelIds = labels.map(layer => layer.id);
+  const targets = new Set(labelIds);
+  const sourceByLabel = new Map(labels.map(layer => [layer.id, layer.source]));
+  const leaderIds = labelIds.flatMap(id => {
+    const ids = [];
+    const layoutLeader = program.materializationConfigs.labelLayouts?.[id]?.leaderId;
+    if (layoutLeader !== undefined) ids.push(layoutLeader);
+    const placement = program.markConfigs[id]?.labelAuthoring?.placement;
+    if (placement?.leader !== undefined && placement.leader !== false) {
+      ids.push(markLabelPlacementLeaderId(id));
+    }
+    return ids;
+  });
+  const selectionIds = Object.entries(
+    program.materializationConfigs.selections ?? {}
+  ).filter(([, config]) => targets.has(config.target)).map(([id]) => id).sort();
+  const selected = new Set(selectionIds);
+  const highlightIds = Object.entries(
+    program.materializationConfigs.highlights ?? {}
+  ).filter(([, config]) =>
+    targets.has(config.target) || selected.has(config.selection)
+  ).map(([id]) => id).sort();
+  return Object.freeze({
+    sourceByLabel,
+    labelIds: Object.freeze(labelIds),
+    leaderIds: Object.freeze([...new Set(leaderIds)].sort()),
+    selectionIds: Object.freeze(selectionIds),
+    highlightIds: Object.freeze(highlightIds)
+  });
+}
+
+function externalAttachedLabelReferences(program, plan) {
+  const labels = new Set(plan.labelIds);
+  const leaders = new Set(plan.leaderIds);
+  const selections = new Set(plan.selectionIds);
+  const references = [];
+  for (const layer of program.semanticSpec.layers) {
+    if (!labels.has(layer.id) && labels.has(layer.source)) {
+      references.push(`layer[${layer.id}].source`);
+    }
+  }
+  for (const [kind, config] of Object.entries(program.guideConfigs.legend ?? {})) {
+    if (labels.has(config?.target)) references.push(`guide.legend.${kind}.target`);
+  }
+  for (const [id, config] of Object.entries(
+    program.materializationConfigs.labelLayouts ?? {}
+  )) {
+    if (!labels.has(id) && leaders.has(config?.leaderId)) {
+      references.push(`materialization.labelLayouts[${id}].leaderId`);
+    }
+  }
+  for (const [id, config] of Object.entries(program.markConfigs)) {
+    if (labels.has(id)) continue;
+    const selection = config?.labelAuthoring?.selection;
+    if (selection?.kind === "named" && selections.has(selection.id)) {
+      references.push(`markConfig[${id}].labelAuthoring.selection`);
+    }
+  }
+  return references.sort();
+}
+
+function removeLabelState(program, plan) {
+  let next = program;
+  for (const id of plan.highlightIds) {
+    next = next._withoutMaterializationConfig(["highlights", id]);
+  }
+  for (const id of plan.selectionIds) {
+    next = next._withoutMaterializationConfig(["selections", id]);
+  }
+  for (const id of plan.labelIds) {
+    next = next
+      ._withoutMaterializationConfig(["labelLayouts", id])
+      ._withoutMaterializationConfig(["marks", id])
+      ._withoutMaterializationConfig(["jitters", id])
+      ._withoutMaterializationConfig(["pointPacking", id]);
+  }
+  for (const id of plan.leaderIds) {
+    if (next.graphicSpec.objects[id] !== undefined) {
+      next = next.editGraphics({ target: id, remove: true });
+    }
+  }
+  for (const id of plan.labelIds) {
+    if (next.graphicSpec.objects[id] !== undefined) {
+      next = next.editGraphics({ target: id, remove: true });
+    }
+    if (findLayer(next, id) !== undefined) {
+      next = next.editSemantic({ property: `layer[${id}]`, remove: true });
+    }
+  }
+  const currentLabel = plan.sourceByLabel.get(program.context.currentMark);
+  const context = {
+    ...(currentLabel === undefined ? {} : { currentMark: currentLabel }),
+    ...(plan.selectionIds.includes(program.context.currentSelection)
+      ? { currentSelection: undefined }
+      : {})
+  };
+  return Object.keys(context).length === 0 ? next : next._withContext(context);
+}
+
+export const removeMarkLabels = /* @__PURE__ */ action(
+  {
+    op: "removeMarkLabels",
+    description: "Remove attached label layers while preserving their source mark."
+  },
+  function (args = {}) {
+    validateOptionObject(
+      args,
+      REMOVE_MARK_LABELS_OPTIONS,
+      "removeMarkLabels",
+      {
+        allowEmpty: false,
+        emptyError: Error,
+        emptyMessage: "removeMarkLabels requires exactly one of target or source."
+      }
+    );
+    const labels = resolveAttachedLabelTargets(this, args);
+    const plan = collectAttachedLabelRemoval(this, labels);
+    const external = externalAttachedLabelReferences(this, plan);
+    if (external.length > 0) {
+      throw new Error(
+        `removeMarkLabels cannot remove externally referenced labels: ${external.join(", ")}.`
+      );
+    }
+    return removeLabelState(this, plan);
+  }
+);
+
+export function registerTextLabelRemovalActions(ProgramClass) {
+  ProgramClass.prototype.removeMarkLabels = removeMarkLabels;
+}

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

@@ -0,0 +1,72 @@
+import { closedAction } from "../../../core/action.js";
+import { validateUserId } from "../../../core/identifiers.js";
+
+import { normalizeLabelSelectionEdit } from
+  "../../../grammar/markLabelSelection.js";
+import { isSourceOwnedText } from "../../../grammar/text.js";
+import { isTextSource } from "../../../materialization/marks/index.js";
+import { resolveMarkSelection } from
+  "../../../materialization/selection/state.js";
+import { findLayer } from "../../../selectors/layers.js";
+import { rematerializeLabelsBeforeHighlights } from
+  "../../selection/actions.js";
+
+const OPTIONS = Object.freeze(["target", "select", "selection", "all"]);
+
+function requireAttachedLabel(program, target) {
+  const id = validateUserId(target, "Attached label id");
+  const layer = findLayer(program, id);
+  if (!isSourceOwnedText(layer) || !isTextSource(findLayer(program, layer.source))) {
+    throw new Error(`Unknown attached label target "${id}".`);
+  }
+  return layer;
+}
+
+function validateSelectionSource(program, source, requested) {
+  if (requested.kind === "all") return;
+  if (requested.kind === "inline") {
+    resolveMarkSelection(program, source, requested.selector);
+    return;
+  }
+  const definition = program.materializationConfigs.selections?.[requested.id];
+  if (definition === undefined) {
+    throw new Error(`Unknown label selection "${requested.id}".`);
+  }
+  if (definition.target !== source) {
+    throw new Error(
+      `Label selection "${requested.id}" must target source mark "${source}".`
+    );
+  }
+  resolveMarkSelection(program, source, definition.selector);
+}
+
+const editMarkLabelSelection = /* @__PURE__ */ closedAction(
+  {
+    op: "editMarkLabelSelection",
+    description: "Replace the final-item membership requested by an attached label."
+  }, OPTIONS,
+  function (args = {}) {
+    if (!Object.hasOwn(args, "target")) {
+      throw new Error("editMarkLabelSelection requires target.");
+    }
+    const layer = requireAttachedLabel(this, args.target);
+    const selection = normalizeLabelSelectionEdit(args);
+    validateSelectionSource(this, layer.source, selection);
+    const next = this._withMarkConfig(layer.id, {
+      ...this.markConfigs[layer.id],
+      labelAuthoring: {
+        ...this.markConfigs[layer.id]?.labelAuthoring,
+        selection
+      }
+    });
+    return rematerializeLabelsBeforeHighlights(
+      next,
+      layer.source,
+      [layer.id]
+    );
+  }
+);
+
+export function registerTextLabelSelectionActions(ProgramClass) {
+  ProgramClass.prototype.editMarkLabelSelection = editMarkLabelSelection;
+}

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

@@ -17,7 +17,12 @@ import { resolveRowEncodingValues } from
 import { findDataset } from "../../../selectors/datasets.js";
 import { findLayer } from "../../../selectors/layers.js";
 import { DEFAULT_COLORS } from "../../../theme/defaults.js";
+import {
+  requestedStrokeDetails,
+  STROKE_STYLE_PROPERTIES
+} from "../../../grammar/strokeStyle.js";
 import { rematerializeHighlightBaseline } from "../lifecycle.js";
+import { rematerializeExistingLegend } from "../../encodings/shared.js";
 import {
   applyLayeredMarkInheritance,
   assertMarkAvailable,
@@ -30,7 +35,7 @@ import {
 } from "../shared.js";
 
 const APPEARANCE_OPTIONS = Object.freeze([
-  "length", "stroke", "strokeWidth", "opacity"
+  "length", "stroke", "strokeWidth", "opacity", ...STROKE_STYLE_PROPERTIES
 ]);
 const CREATE_OPTIONS = Object.freeze(["id", "data", ...APPEARANCE_OPTIONS]);
 const EDIT_OPTIONS = Object.freeze(["target", ...APPEARANCE_OPTIONS]);
@@ -66,6 +71,7 @@ function resolveTick(program, requested, operation) {
 
 function validateTickConfig(args, current = DEFAULT_TICK_CONFIG) {
   return {
+    ...current,
     length: Object.hasOwn(args, "length")
       ? validatePositiveFinite(args.length, "Tick length")
       : current.length,
@@ -77,17 +83,19 @@ function validateTickConfig(args, current = DEFAULT_TICK_CONFIG) {
       : current.strokeWidth,
     opacity: Object.hasOwn(args, "opacity")
       ? validateUnitInterval(args.opacity, "Tick opacity")
-      : current.opacity
+      : current.opacity,
+    ...requestedStrokeDetails(args, "Tick")
   };
 }
 
-export const createTickMark = action(
+export const createTickMark = /* @__PURE__ */ action(
   {
     op: "createTickMark",
     description: "Create a centered fixed-length Tick mark."
   },
   function (args = {}) {
     validateMarkOptions(args, CREATE_OPTIONS, "createTickMark");
+    requestedStrokeDetails(args, "createTickMark");
     const id = resolveMarkId(this, args.id, {
       defaultId: "tick",
       label: "Tick mark id",
@@ -125,30 +133,37 @@ export const createTickMark = action(
   }
 );
 
-export const editTickMark = action(
+export const editTickMark = /* @__PURE__ */ action(
   {
     op: "editTickMark",
     description: "Edit Tick length and constant line appearance."
   },
   function (args = {}) {
     validateMarkOptions(args, EDIT_OPTIONS, "editTickMark");
+    requestedStrokeDetails(args, "editTickMark");
     if (!APPEARANCE_OPTIONS.some(property => Object.hasOwn(args, property))) {
       throw new Error(
         "editTickMark requires length, stroke, strokeWidth, or opacity."
       );
     }
     const layer = resolveTick(this, args.target, "editTickMark");
+    if (Object.hasOwn(args, "stroke") && layer.encoding?.stroke !== undefined) {
+      throw new Error(
+        "editTickMark stroke conflicts with a field encoding; use encodeStroke with value to replace it."
+      );
+    }
     const config = validateTickConfig(args, {
       ...DEFAULT_TICK_CONFIG,
       ...this.markConfigs[layer.id]
     });
-    return this
+    const materialized = this
       ._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,6 +205,7 @@ export const rematerializeTickMark = action(
 
     const x = resolveRowEncodingValues(this, layer, dataset, "x");
     const y = resolveRowEncodingValues(this, layer, dataset, "y");
+    const stroke = resolveRowEncodingValues(this, layer, dataset, "stroke");
     const angles = resolveDirectionValues(dataset.values, layer.encoding?.angle);
     const config = validateTickConfig({}, {
       ...DEFAULT_TICK_CONFIG,
@@ -210,9 +226,10 @@ export const rematerializeTickMark = action(
       y1: segments.map(item => item.y1),
       x2: segments.map(item => item.x2),
       y2: segments.map(item => item.y2),
-      stroke: config.stroke,
+      stroke: stroke ?? config.stroke,
       strokeWidth: config.strokeWidth,
-      opacity: config.opacity
+      opacity: config.opacity,
+      ...requestedStrokeDetails(config, "Tick mark")
     });
   }
 );

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 -."