ggaction 0.0.13 → 0.0.15

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 = 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,73 @@
+import { action } 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";
+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 = action(
+  {
+    op: "editMarkLabelSelection",
+    description: "Replace the final-item membership requested by an attached label."
+  },
+  function (args = {}) {
+    validateOptionObject(args, OPTIONS, "editMarkLabelSelection");
+    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,7 +83,8 @@ 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")
   };
 }
 
@@ -88,6 +95,7 @@ export const createTickMark = action(
   },
   function (args = {}) {
     validateMarkOptions(args, CREATE_OPTIONS, "createTickMark");
+    requestedStrokeDetails(args, "createTickMark");
     const id = resolveMarkId(this, args.id, {
       defaultId: "tick",
       label: "Tick mark id",
@@ -132,19 +140,26 @@ export const editTickMark = action(
   },
   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);
   }
 );
 
@@ -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/editGraphics.js

@@ -63,6 +63,32 @@ function replaceDrawableItems(value, id, type) {
   });
 }
 
+export function replaceGraphicItems(program, target, baseType, items) {
+  let next = program.editGraphics({ target, property: "items", value: items });
+  const graphic = next.graphicSpec.objects[target];
+  if (
+    graphic.type !== "collection" ||
+    !graphic.items.every(item => item.type === baseType)
+  ) return next;
+  const normalized = freezeOwned({
+    ...graphic,
+    type: baseType,
+    items: freezeOwned(graphic.items.map(item => freezeOwned({
+      id: item.id,
+      properties: item.properties
+    })))
+  });
+  return next._clone({
+    graphicSpec: freezeOwned({
+      ...next.graphicSpec,
+      objects: freezeOwned({
+        ...next.graphicSpec.objects,
+        [target]: normalized
+      })
+    })
+  });
+}
+
 function editGeneratedItem(owner, itemIndex, property, value) {
   const items = [...owner.items];
   const item = items[itemIndex];

package/src/actions/primitives/semantic.js

@@ -1,4 +1,5 @@
 import { createSemanticPrimitiveAction } from "./semanticAction.js";
+import { planResourceRemoval } from "../resources/remove.js";
 import { validateDatasetTransforms } from "../../grammar/transforms.js";
 import {
   validateParallelDimensions,
@@ -24,5 +25,5 @@ export function registerSemanticPrimitiveAction(ProgramClass) {
     sourceMarkTypes: ["point", "bar", "line", "rule", "rect", "arc"]
   });
   ProgramClass.prototype.editSemantic =
-    createSemanticPrimitiveAction(validateSemanticValue);
+    createSemanticPrimitiveAction(validateSemanticValue, planResourceRemoval);
 }

package/src/actions/primitives/semanticAction.js

@@ -79,7 +79,7 @@ function removeEntity(spec, parsed) {
   if (parsed.kind === "scale" && parsed.path.length === 0) {
     if (hasSemanticScaleReferences(spec, parsed.id)) throw new Error(`Scale "${parsed.id}" is still referenced.`);
   }
-  if (["layer", "scale"].includes(parsed.kind) && parsed.path.length === 0) {
+  if (["layer", "scale", "coordinate"].includes(parsed.kind) && parsed.path.length === 0) {
     const nextCollection = collection.filter((_, itemIndex) => itemIndex !== index);
     return freezeOwned({
       ...spec,
@@ -87,10 +87,6 @@ function removeEntity(spec, parsed) {
     });
   }
   if (parsed.kind === "dataset" && parsed.path.length === 0) {
-    const dataset = collection[index];
-    if (dataset.source === undefined) {
-      throw new Error(`Source dataset "${parsed.id}" is immutable after creation.`);
-    }
     const referenced = spec.layers.some(layer => layer.data === parsed.id) ||
       spec.datasets.some(candidate => candidate.source === parsed.id);
     if (referenced) {
@@ -151,7 +147,50 @@ export function withPreviewDatasetValues(program, {
   return program._clone({ semanticSpec });
 }
 
-export function createSemanticPrimitiveAction(validateSemanticValue) {
+// Owned materializers may refresh a generated derived dataset at a stable ID.
+// Keep that privileged immutable transition inside the semantic primitive
+// boundary; public editSemantic still rejects every post-creation dataset edit.
+export function withRematerializedDerivedDataset(program, {
+  id,
+  source,
+  transform,
+  values
+}) {
+  const semanticSpec = {
+    ...program.semanticSpec,
+    datasets: program.semanticSpec.datasets.map(dataset =>
+      dataset.id === id
+        ? { ...dataset, source, transform: [transform], values }
+        : dataset
+    )
+  };
+  return program._clone({ semanticSpec });
+}
+
+// Final-state planners may need to remove mutually constrained roles before
+// replaying their canonical primitive owners. Keep that speculative clone in
+// the primitive boundary and preserve the caller's layer for later dependency
+// and guide reconciliation.
+export function withoutPreviewLayerEncodings(program, { id, channels }) {
+  const removed = new Set(channels);
+  const semanticSpec = {
+    ...program.semanticSpec,
+    layers: program.semanticSpec.layers.map(layer => {
+      if (layer.id !== id) return layer;
+      return {
+        ...layer,
+        encoding: Object.fromEntries(
+          Object.entries(layer.encoding ?? {}).filter(
+            ([channel]) => !removed.has(channel)
+          )
+        )
+      };
+    })
+  };
+  return program._clone({ semanticSpec });
+}
+
+export function createSemanticPrimitiveAction(validateSemanticValue, planNamedRemoval) {
   return action(
     {
       op: "editSemantic",
@@ -170,14 +209,37 @@ export function createSemanticPrimitiveAction(validateSemanticValue) {
       }
 
       const parsed = parseSemanticPath(property, { allowContainer: remove });
+      const removesNamedResource = remove && parsed.path.length === 0 &&
+        ["dataset", "scale", "coordinate"].includes(parsed.kind);
       if (this.compositionSpec !== undefined && !(
-        this.compositionSpec.type === "facet" && parsed.kind === "title"
+        this.compositionSpec.type === "facet" &&
+        (parsed.kind === "title" || removesNamedResource)
       )) {
         throw new Error(
-          "editSemantic on a composition parent currently supports only facet title state."
+          "editSemantic on a composition parent supports only facet title state and unreferenced named resource removal."
         );
       }
       if (remove) {
+        // Source/coordinate removal and facet-parent removal use the same full
+        // dependency policy as the domain lifecycle. Existing unit derived-data
+        // teardown retains its semantic-only primitive contract; its owning
+        // action coordinates configuration and graphics cleanup separately.
+        const resource = removesNamedResource
+          ? this.semanticSpec[parsed.collection].find(item => item.id === parsed.id)
+          : undefined;
+        if (resource !== undefined && (
+          parsed.kind === "coordinate" || this.compositionSpec?.type === "facet" ||
+          (parsed.kind === "dataset" && resource.source === undefined)
+        )) {
+          if (planNamedRemoval === undefined) {
+            throw new Error("Named resource removal requires the full ChartProgram.");
+          }
+          planNamedRemoval(this, {
+            kind: parsed.kind === "dataset" ? "data" : parsed.kind,
+            id: parsed.id,
+            operation: "editSemantic"
+          });
+        }
         const semanticSpec = parsed.kind === "guide"
           ? removeRootProperty(this.semanticSpec, "guides", parsed.path)
           : parsed.kind === "title"
@@ -192,17 +254,28 @@ export function createSemanticPrimitiveAction(validateSemanticValue) {
           parsed.kind === "layer" &&
           parsed.path.length === 0 &&
           this.context.currentMark === parsed.id;
+        const clearsCurrentCoordinate =
+          parsed.kind === "coordinate" &&
+          parsed.path.length === 0 &&
+          this.context.currentCoordinate === parsed.id;
+        const clearsCurrentGuide =
+          parsed.kind === "guide" &&
+          parsed.path.length === 2 &&
+          this.context.currentGuide === parsed.id;
         const removesScale = parsed.kind === "scale" && parsed.path.length === 0;
         const resolvedScales = removesScale ? Object.fromEntries(Object.entries(this.resolvedScales).filter(([id]) => id !== parsed.id)) : this.resolvedScales;
         return this._clone({
           semanticSpec,
           ...(removesScale ? { resolvedScales: freezeOwned(resolvedScales) } : {}),
-          ...(clearsCurrentData || clearsCurrentMark || (removesScale && this.context.currentScale === parsed.id)
+          ...(clearsCurrentData || clearsCurrentMark || clearsCurrentGuide || clearsCurrentCoordinate ||
+              (removesScale && this.context.currentScale === parsed.id)
             ? { context: freezeOwned({
                 ...this.context,
                 ...(removesScale && this.context.currentScale === parsed.id ? { currentScale: undefined } : {}),
                 ...(clearsCurrentData ? { currentData: undefined } : {}),
-                ...(clearsCurrentMark ? { currentMark: undefined } : {})
+                ...(clearsCurrentMark ? { currentMark: undefined } : {}),
+                ...(clearsCurrentCoordinate ? { currentCoordinate: undefined } : {}),
+                ...(clearsCurrentGuide ? { currentGuide: undefined } : {})
               }) }
             : {})
         });

package/src/actions/primitives/semanticValidation/guide.js

@@ -30,7 +30,7 @@ export function validateGuideSemanticValue(_program, parsed, value) {
     validateParallelAxisTitles(value);
     return;
   }
-  if (["legend.series", "legend.color"].includes(parsed.id) && property === "order") {
+  if (["legend.series", "legend.color", "legend.stroke"].includes(parsed.id) && property === "order") {
     normalizeLegendOrder(value);
     return;
   }

package/src/actions/primitives/semanticValidation/index.js

@@ -1,4 +1,8 @@
-import { validateCoordinateType } from "../../../grammar/coordinates.js";
+import {
+  normalizeCoordinateAspect,
+  validateCoordinateType
+} from "../../../grammar/coordinates.js";
+import { normalizePolarFrameOptions } from "../../../grammar/polar.js";
 import { validateScaleSemanticValue } from "./scale.js";
 import { validateDatasetSemanticValue } from "./dataset.js";
 import { validateLayerSemanticValue } from "./layer.js";
@@ -27,6 +31,10 @@ export function createSemanticValueValidator({
       validateScaleSemanticValue(program, parsed, value);
     } else if (parsed.kind === "coordinate" && parsed.path[0] === "type") {
       validateCoordinateType(value);
+    } else if (parsed.kind === "coordinate" && parsed.path[0] === "aspect") {
+      normalizeCoordinateAspect(value);
+    } else if (parsed.kind === "coordinate" && parsed.path[0] === "polarFrame") {
+      normalizePolarFrameOptions(value);
     } else if (parsed.kind === "guide") {
       validateGuideSemanticValue(program, parsed, value);
     } else if (parsed.kind === "title") {

package/src/actions/primitives/semanticValidation/layer.js

@@ -17,6 +17,8 @@ import { normalizeCategoryOrder } from "../../../grammar/categoryOrder.js";
 import { validateSemanticFieldType } from "../../../grammar/scales/index.js";
 import { findLayer } from "../../../selectors/layers.js";
 import { validateNonEmptySemanticString } from "./shared.js";
+import { normalizeStatisticalWeight } from
+  "../../../grammar/weightedStatistics.js";
 
 function validateLayerSource(program, parsed, value, sourceMarkTypes) {
   validateUserId(value, "Layer source id");
@@ -81,6 +83,9 @@ export function validateLayerSemanticValue(
     validateParallel?.(property, value);
   }
   if (property.endsWith(".aggregate")) validateAggregate(value);
+  if (property === "encoding.x.weight") {
+    normalizeStatisticalWeight(value, "Histogram weight");
+  }
   if (property.endsWith(".bin.maxBins")) normalizeHistogramBin({ maxBins: value });
   if (property.endsWith(".bin.step")) validateHistogramBinStep(value);
   if (property.endsWith(".bin.boundaries")) validateHistogramBinBoundaries(value);

package/src/actions/primitives/semanticValidation/scale.js

@@ -8,9 +8,22 @@ import {
   validateSemanticScaleType
 } from "../../../grammar/scales/index.js";
 import { findSemanticScale } from "../../../selectors/scales.js";
+import { findScaleConsumers } from "../../scales/consumers/index.js";
 
-function validateOwnedProperty(existing, property) {
+function isOffsetScale(program, id, existing) {
+  if (existing?.type !== "ordinal") return false;
+  const consumers = findScaleConsumers(program, id);
+  return consumers.length > 0 && consumers.every(
+    consumer => ["xOffset", "yOffset"].includes(consumer.channel)
+  );
+}
+
+function validateOwnedProperty(program, id, existing, property) {
   if (existing?.type !== undefined) {
+    if (
+      isOffsetScale(program, id, existing) &&
+      ["paddingInner", "paddingOuter", "align"].includes(property)
+    ) return;
     validateScalePropertyForType(existing.type, property);
   }
 }
@@ -31,7 +44,13 @@ export function validateScaleSemanticValue(program, parsed, value) {
       "nice", "zero", "clamp", "base", "exponent", "constant", "midpoint",
       "paddingInner", "paddingOuter", "padding", "align"
     ]) {
-      if (existing?.[owned] !== undefined) validateScalePropertyForType(value, owned);
+      if (existing?.[owned] === undefined) continue;
+      if (
+        value === "ordinal" &&
+        isOffsetScale(program, parsed.id, existing) &&
+        ["paddingInner", "paddingOuter", "align"].includes(owned)
+      ) continue;
+      validateScalePropertyForType(value, owned);
     }
     return;
   }
@@ -41,7 +60,9 @@ export function validateScaleSemanticValue(program, parsed, value) {
     if (typeof value !== "boolean") {
       throw new TypeError(`Scale ${property} must be a boolean.`);
     }
-    if (property !== "reverse") validateOwnedProperty(existing, property);
+    if (property !== "reverse") {
+      validateOwnedProperty(program, parsed.id, existing, property);
+    }
     return;
   }
   if (["base", "exponent", "constant"].includes(property)) {
@@ -51,7 +72,7 @@ export function validateScaleSemanticValue(program, parsed, value) {
     if (property === "base" && value === 1) {
       throw new RangeError("Scale base must not equal 1.");
     }
-    validateOwnedProperty(existing, property);
+    validateOwnedProperty(program, parsed.id, existing, property);
     return;
   }
   if (property === "interpolate") {
@@ -64,20 +85,20 @@ export function validateScaleSemanticValue(program, parsed, value) {
         "Scale paddingInner must be from 0 (inclusive) to 1 (exclusive)."
       );
     }
-    validateOwnedProperty(existing, property);
+    validateOwnedProperty(program, parsed.id, existing, property);
     return;
   }
   if (property === "paddingOuter" || property === "padding") {
     if (!Number.isFinite(value) || value < 0) {
       throw new RangeError(`Scale ${property} must be a non-negative finite number.`);
     }
-    validateOwnedProperty(existing, property);
+    validateOwnedProperty(program, parsed.id, existing, property);
     return;
   }
   if (property === "align") {
     if (!Number.isFinite(value) || value < 0 || value > 1) {
       throw new RangeError("Scale align must be between 0 and 1.");
     }
-    validateOwnedProperty(existing, property);
+    validateOwnedProperty(program, parsed.id, existing, property);
   }
 }