ggaction 0.0.4 → 0.0.5

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

@@ -104,7 +104,17 @@ const createRuleMark = action(
         length: 0,
         ...resolveMarkGraphicPlacement(created, { data, markType: "rule" })
       })
-      ._withMarkConfig(id, DEFAULT_RULE_CONFIG);
+      ._withMarkConfig(id, {
+        ...DEFAULT_RULE_CONFIG,
+        ...(inherited === undefined
+          ? {}
+          : {
+              inheritedPosition: {
+                source: inherited.source,
+                channels: Object.keys(inherited.encoding)
+              }
+            })
+      });
     return materializeInheritedMark(created, id);
   }
 );
@@ -143,7 +153,7 @@ const rematerializeRuleMark = action(
     }
 
     const scaleIds = [...new Set(
-      ["x", "y", "x2", "y2", "strokeDash", "opacity"]
+      ["x", "y", "x2", "y2", "strokeDash", "strokeWidth", "opacity"]
         .map(channel => layer.encoding?.[channel]?.scale)
         .filter(scale => scale !== undefined)
     )];
@@ -153,6 +163,11 @@ const rematerializeRuleMark = action(
     }
 
     const derived = deriveRuleValues(dataset.values, layer);
+    if (derived.values.strokeWidth?.some(value => value < 0)) {
+      throw new RangeError(
+        `Rule strokeWidth field "${layer.encoding.strokeWidth.field}" cannot contain negative values.`
+      );
+    }
     const mapped = {};
     for (const channel of ["x", "y", "x2", "y2"]) {
       const encoding = layer.encoding?.[channel];
@@ -226,6 +241,7 @@ const rematerializeRuleMark = action(
     const resolvedConfig = resolved.markConfigs[id] ?? DEFAULT_RULE_CONFIG;
     const dashEncoding = layer.encoding?.strokeDash;
     const opacityEncoding = layer.encoding?.opacity;
+    const strokeWidthEncoding = layer.encoding?.strokeWidth;
     const strokeDash = dashEncoding?.scale === undefined
       ? Array.from(
           { length: derived.length },
@@ -244,6 +260,12 @@ const rematerializeRuleMark = action(
           derived.values.opacity,
           resolved.resolvedScales[opacityEncoding.scale]
         );
+    const strokeWidth = strokeWidthEncoding?.scale === undefined
+      ? resolvedConfig.strokeWidth
+      : mapContinuousScaleValues(
+          derived.values.strokeWidth,
+          resolved.resolvedScales[strokeWidthEncoding.scale]
+        );
 
     return resolved
       .editGraphics({ target: id, property: "length", value: derived.length })
@@ -255,7 +277,7 @@ const rematerializeRuleMark = action(
       .editGraphics({
         target: id,
         property: "strokeWidth",
-        value: resolvedConfig.strokeWidth
+        value: strokeWidth
       })
       .editGraphics({ target: id, property: "strokeDash", value: strokeDash })
       .editGraphics({ target: id, property: "opacity", value: opacity });

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

@@ -24,14 +24,19 @@ const STYLE_OPTIONS = Object.freeze([
 ]);
 const CREATE_OPTIONS = Object.freeze(["id", "data", "text", ...STYLE_OPTIONS]);
 const EDIT_OPTIONS = Object.freeze(["target", ...STYLE_OPTIONS]);
-const REMATERIALIZE_OPTIONS = Object.freeze(["id"]);
+const REMATERIALIZE_OPTIONS = Object.freeze(["id", "replayLayout"]);
 const SOURCE_TYPES = new Set(["point", "bar", "rule", "rect"]);
 
+function sourceMatchesData(program, layer, requestedData) {
+  if (requestedData === undefined || layer?.data === requestedData) return true;
+  return program.markConfigs[layer.id]?.gradientPlot?.source === requestedData;
+}
+
 function eligibleSource(program, layer, requestedData) {
   if (
     !SOURCE_TYPES.has(layer?.mark?.type) ||
     layer.data === undefined ||
-    (requestedData !== undefined && layer.data !== requestedData)
+    !sourceMatchesData(program, layer, requestedData)
   ) return false;
   const encodings = resolveCompatibleEncodings(program, layer, "text");
   return encodings.x !== undefined && encodings.y !== undefined;
@@ -133,6 +138,10 @@ const rematerializeTextMark = action(
   function (args = {}) {
     validateMarkOptions(args, REMATERIALIZE_OPTIONS, "rematerializeTextMark");
     const id = validateUserId(args.id, "Text mark id");
+    const replayLayout = args.replayLayout ?? true;
+    if (typeof replayLayout !== "boolean") {
+      throw new TypeError("rematerializeTextMark replayLayout must be a boolean.");
+    }
     const layer = findLayer(this, id);
     const graphic = this.graphicSpec.objects[id];
     if (layer?.mark?.type !== "text") throw new Error(`Unknown text mark "${id}".`);
@@ -140,11 +149,14 @@ const rematerializeTextMark = action(
       throw new Error(`Text mark "${id}" requires text collection graphics.`);
     }
     if (!canMaterializeText(this, layer)) {
-      return graphic.items.length === 0
+      const next = graphic.items.length === 0
         ? this
         : this.editGraphics({ target: id, property: "length", value: 0 });
+      return replayLayout && next.materializationConfigs.labelLayouts?.[id] !== undefined
+        ? next.materializeLabelLayout({ id, rematerializeBase: false })
+        : next;
     }
-    return this.editGraphics({
+    const next = this.editGraphics({
       target: id,
       property: "items",
       value: resolveTextGraphicItems(
@@ -153,6 +165,9 @@ const rematerializeTextMark = action(
         this.markConfigs[id] ?? DEFAULT_TEXT_MARK
       )
     });
+    return replayLayout && next.materializationConfigs.labelLayouts?.[id] !== undefined
+      ? next.materializeLabelLayout({ id, rematerializeBase: false })
+      : next;
   }
 );
 

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

@@ -1 +1,7 @@
-export { registerTextMarkActions } from "./actions.js";
+import { registerTextMarkActions as registerTextCoreActions } from "./actions.js";
+import { registerTextLabelLayoutActions } from "./layout.js";
+
+export function registerTextMarkActions(ProgramClass) {
+  registerTextCoreActions(ProgramClass);
+  registerTextLabelLayoutActions(ProgramClass);
+}

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

@@ -0,0 +1,321 @@
+import { action } 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 { findGraphicParent } from "../../../grammar/schemas/graphicTree.js";
+import { validateConcreteGraphicValue } from
+  "../../../grammar/schemas/concreteGraphic.js";
+import {
+  normalizeLabelLayoutGeometry,
+  resolveLabelLayout,
+  resolveLabelLeader
+} from "../../../layout/labels.js";
+import { resolveGraphicBounds } from "../../../layout/canvas.js";
+import { canMaterializeText } from "../../../materialization/marks/index.js";
+import { resolveTextGraphicEntries } from "../../../materialization/text.js";
+import { findLayer, resolveEligibleLayer } from "../../../selectors/layers.js";
+
+const LAYOUT_OPTIONS = Object.freeze([
+  "target", "axis", "padding", "maxDisplacement", "bounds", "leader"
+]);
+const REMOVE_OPTIONS = Object.freeze(["target"]);
+const MATERIALIZE_OPTIONS = Object.freeze(["id", "rematerializeBase"]);
+const LEADER_OPTIONS = Object.freeze([
+  "stroke", "strokeWidth", "strokeDash", "opacity"
+]);
+
+function normalizeLeader(value) {
+  if (value === false || value === undefined) return false;
+  validateOptionObject(value, LEADER_OPTIONS, "label leader");
+  const normalized = {
+    stroke: "#94a3b8",
+    strokeWidth: 1,
+    strokeDash: [],
+    opacity: 1,
+    ...value
+  };
+  for (const [property, propertyValue] of Object.entries(normalized)) {
+    validateConcreteGraphicValue("line", property, propertyValue);
+  }
+  return normalized;
+}
+
+function normalizePolicy(args) {
+  const geometry = normalizeLabelLayoutGeometry(Object.fromEntries(
+    Object.entries(args).filter(
+      ([key]) => key !== "target" && key !== "leader"
+    )
+  ));
+  return { ...geometry, leader: normalizeLeader(args.leader) };
+}
+
+function leaderId(target) {
+  return `${target}-label-leaders`;
+}
+
+function requireCompleteText(program, requested, operation) {
+  const target = requested === undefined
+    ? undefined
+    : validateUserId(requested, "Text mark id");
+  if (target !== undefined) {
+    const layer = findLayer(program, target);
+    if (layer?.mark?.type !== "text") {
+      throw new Error(`Unknown ${operation} text mark target "${target}".`);
+    }
+    if (!canMaterializeText(program, layer)) {
+      throw new Error(`${operation} requires a complete text mark.`);
+    }
+    return layer;
+  }
+  return resolveEligibleLayer(program, {
+    predicate: layer =>
+      layer.mark?.type === "text" && canMaterializeText(program, layer),
+    label: `${operation} text mark`
+  });
+}
+
+function requireConfiguredText(program, requested) {
+  const target = requested === undefined
+    ? undefined
+    : validateUserId(requested, "Text mark id");
+  return resolveEligibleLayer(program, {
+    target,
+    predicate: layer =>
+      layer.mark?.type === "text" &&
+      program.materializationConfigs.labelLayouts?.[layer.id] !== undefined,
+    label: "removeLabelLayout text mark"
+  });
+}
+
+function concreteBounds(program, kind) {
+  if (kind === "plot") {
+    const plot = resolveGraphicBounds(program);
+    return {
+      left: plot.x,
+      right: plot.x + plot.width,
+      top: plot.y,
+      bottom: plot.y + plot.height
+    };
+  }
+  const canvas = program.graphicSpec.objects.canvas;
+  if (
+    canvas?.type !== "canvas" ||
+    !Number.isFinite(canvas.properties.width) ||
+    !Number.isFinite(canvas.properties.height)
+  ) {
+    throw new Error("Canvas label bounds require concrete Canvas dimensions.");
+  }
+  const x = canvas.properties.x ?? 0;
+  const y = canvas.properties.y ?? 0;
+  return {
+    left: x,
+    right: x + canvas.properties.width,
+    top: y,
+    bottom: y + canvas.properties.height
+  };
+}
+
+function layoutInputs(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}" base materialization is inconsistent.`);
+  }
+  return entries.map((entry, index) => ({
+    id: graphic.items[index].id,
+    x: entry.graphic.properties.x,
+    y: entry.graphic.properties.y,
+    sourceX: entry.anchor.x,
+    sourceY: entry.anchor.y,
+    text: entry.graphic.properties.text,
+    fontSize: entry.graphic.properties.fontSize,
+    textAlign: entry.graphic.properties.textAlign,
+    textBaseline: entry.graphic.properties.textBaseline,
+    rotation: entry.graphic.properties.rotation
+  }));
+}
+
+function leaderPlacement(program, layer) {
+  const targetParent = findGraphicParent(program.graphicSpec, layer.id);
+  if (targetParent?.kind !== "parent") {
+    throw new Error("Label leaders require the text graphic to have a parent container.");
+  }
+  const source = layer.source === undefined
+    ? undefined
+    : program.graphicSpec.objects[layer.source];
+  const sourceParent = source === undefined
+    ? undefined
+    : findGraphicParent(program.graphicSpec, layer.source);
+  const before = sourceParent?.kind === "parent" && sourceParent.id === targetParent.id
+    ? layer.source
+    : layer.id;
+  return { parent: targetParent.id, before };
+}
+
+function removeLeaderGraphic(program, id) {
+  return program.graphicSpec.objects[id] === undefined
+    ? program
+    : program.editGraphics({ target: id, remove: true });
+}
+
+function materializeLeaders(program, layer, config, resolved) {
+  let next = removeLeaderGraphic(program, config.leaderId);
+  if (config.leader === false) return { program: next, count: 0 };
+  const leaders = resolved.items.map(resolveLabelLeader).filter(Boolean);
+  if (leaders.length === 0) return { program: next, count: 0 };
+  next = next
+    .createGraphics({
+      id: config.leaderId,
+      type: "line",
+      length: leaders.length,
+      ...leaderPlacement(next, layer)
+    })
+    .editGraphics({
+      target: config.leaderId,
+      property: "x1",
+      value: leaders.map(line => line.x1)
+    })
+    .editGraphics({
+      target: config.leaderId,
+      property: "y1",
+      value: leaders.map(line => line.y1)
+    })
+    .editGraphics({
+      target: config.leaderId,
+      property: "x2",
+      value: leaders.map(line => line.x2)
+    })
+    .editGraphics({
+      target: config.leaderId,
+      property: "y2",
+      value: leaders.map(line => line.y2)
+    });
+  for (const property of ["stroke", "strokeWidth", "strokeDash", "opacity"]) {
+    next = next.editGraphics({
+      target: config.leaderId,
+      property,
+      value: property === "strokeDash"
+        ? leaders.map(() => config.leader.strokeDash)
+        : config.leader[property]
+    });
+  }
+  return { program: next, count: leaders.length };
+}
+
+const materializeLabelLayout = action(
+  {
+    op: "materializeLabelLayout",
+    description: "Resolve concrete label positions and optional leader lines."
+  },
+  function (args = {}) {
+    validateOptionObject(args, MATERIALIZE_OPTIONS, "materializeLabelLayout");
+    const id = validateUserId(args.id, "Text mark id");
+    const rematerializeBase = args.rematerializeBase ?? true;
+    if (typeof rematerializeBase !== "boolean") {
+      throw new TypeError("materializeLabelLayout rematerializeBase must be a boolean.");
+    }
+    const layer = findLayer(this, id);
+    if (layer?.mark?.type !== "text") throw new Error(`Unknown text mark "${id}".`);
+    const config = this.materializationConfigs.labelLayouts?.[id];
+    if (config === undefined) {
+      throw new Error(`Text mark "${id}" has no label layout policy.`);
+    }
+    let next = rematerializeBase
+      ? this.rematerializeTextMark({ id, replayLayout: false })
+      : this;
+    const resolved = resolveLabelLayout({
+      items: canMaterializeText(next, layer) ? layoutInputs(next, layer) : [],
+      bounds: concreteBounds(next, config.bounds),
+      axis: config.axis,
+      padding: config.padding,
+      maxDisplacement: config.maxDisplacement
+    });
+    next = next
+      .editGraphics({
+        target: id,
+        property: "x",
+        value: resolved.items.map(item => item.x)
+      })
+      .editGraphics({
+        target: id,
+        property: "y",
+        value: resolved.items.map(item => item.y)
+      });
+    const leaders = materializeLeaders(next, layer, config, resolved);
+    next = leaders.program;
+    return next._withMaterializationConfig(["labelLayouts", id], {
+      axis: config.axis,
+      padding: config.padding,
+      maxDisplacement: config.maxDisplacement,
+      bounds: config.bounds,
+      leader: config.leader,
+      leaderId: config.leaderId,
+      resolution: {
+        overlapBefore: resolved.overlapBefore,
+        overlapAfter: resolved.overlapAfter,
+        displaced: resolved.items.filter(item => item.distance > 0).length,
+        leaders: leaders.count,
+        maximumDisplacement: resolved.items.reduce(
+          (maximum, item) => Math.max(maximum, item.distance),
+          0
+        ),
+        warnings: resolved.warnings
+      }
+    });
+  }
+);
+
+const layoutLabels = action(
+  {
+    op: "layoutLabels",
+    description: "Assign deterministic collision-aware layout to a text mark."
+  },
+  function (args = {}) {
+    validateOptionObject(args, LAYOUT_OPTIONS, "layoutLabels");
+    const layer = requireCompleteText(this, args.target, "layoutLabels");
+    const policy = normalizePolicy(args);
+    const generatedId = leaderId(layer.id);
+    const existingConfig = this.materializationConfigs.labelLayouts?.[layer.id];
+    if (
+      this.graphicSpec.objects[generatedId] !== undefined &&
+      existingConfig?.leaderId !== generatedId
+    ) {
+      throw new Error(`Label layout leader graphic "${generatedId}" already exists.`);
+    }
+    return this
+      ._withMaterializationConfig(["labelLayouts", layer.id], {
+        ...policy,
+        leaderId: generatedId
+      })
+      .materializeLabelLayout({ id: layer.id });
+  }
+);
+
+const removeLabelLayout = action(
+  {
+    op: "removeLabelLayout",
+    description: "Remove label layout and restore semantic base text positions."
+  },
+  function (args = {}) {
+    validateOptionObject(args, REMOVE_OPTIONS, "removeLabelLayout");
+    const layer = requireConfiguredText(this, args.target);
+    const config = this.materializationConfigs.labelLayouts[layer.id];
+    return removeLeaderGraphic(
+      this._withoutMaterializationConfig(["labelLayouts", layer.id]),
+      config.leaderId
+    ).rematerializeTextMark({ id: layer.id });
+  }
+);
+
+export function registerTextLabelLayoutActions(ProgramClass) {
+  ProgramClass.prototype.layoutLabels = layoutLabels;
+  ProgramClass.prototype.removeLabelLayout = removeLabelLayout;
+  ProgramClass.prototype.materializeLabelLayout = materializeLabelLayout;
+}

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

@@ -0,0 +1,22 @@
+import { validateUserId } from "../../../core/identifiers.js";
+import { isPlainObject } from "../../../core/immutable.js";
+import { validateDatasetTransforms } from "../../../grammar/transforms.js";
+import { hasDataset } from "../../../selectors/datasets.js";
+
+export function validateDatasetSemanticValue(program, parsed, value) {
+  const property = parsed.path[0];
+  if (property === "values") {
+    if (!Array.isArray(value) || !value.every(isPlainObject)) {
+      throw new TypeError("Dataset values must be an array of plain row objects.");
+    }
+    return;
+  }
+  if (property === "source") {
+    validateUserId(value, "Dataset source id");
+    if (!hasDataset(program, value)) {
+      throw new Error(`Unknown source dataset "${value}".`);
+    }
+    return;
+  }
+  if (property === "transform") validateDatasetTransforms(value);
+}

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

@@ -0,0 +1,43 @@
+import { validateUserId } from "../../../core/identifiers.js";
+import { CATEGORICAL_LEGEND_CHANNELS } from "../../../core/vocabulary.js";
+import { validateNonEmptySemanticString } from "./shared.js";
+
+function validateLegend(property, value) {
+  if (property === "title") {
+    validateNonEmptySemanticString(value, "Legend title");
+    return;
+  }
+  if (!Array.isArray(value) || value.length === 0) {
+    throw new TypeError(`Legend ${property} must be a non-empty array.`);
+  }
+  if (new Set(value).size !== value.length) {
+    throw new Error(`Legend ${property} must not contain duplicates.`);
+  }
+  if (property === "channels") {
+    if (!value.every(channel => CATEGORICAL_LEGEND_CHANNELS.includes(channel))) {
+      throw new Error("Legend channels support only color, strokeDash, and shape.");
+    }
+    return;
+  }
+  for (const id of value) validateUserId(id, "Legend scale id");
+}
+
+export function validateGuideSemanticValue(_program, parsed, value) {
+  const property = parsed.path.at(-1);
+  if (parsed.id === "legend.series") {
+    validateLegend(property, value);
+    return;
+  }
+  if (!parsed.id.startsWith("grid.") && !parsed.id.startsWith("axis.")) return;
+  if (parsed.id === "axis.parallel" && property === "scales") {
+    if (!Array.isArray(value) || value.length < 2) {
+      throw new TypeError("Parallel axis scales must contain at least two ids.");
+    }
+    value.forEach(id => validateUserId(id, "Parallel axis scale id"));
+  } else if (property === "title") {
+    validateNonEmptySemanticString(value, "Axis title");
+  } else {
+    const guideKind = parsed.id.startsWith("grid.") ? "Grid" : "Axis";
+    validateUserId(value, `${guideKind} ${property} id`);
+  }
+}

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

@@ -0,0 +1,23 @@
+import { validateCoordinateType } from "../../../grammar/coordinates.js";
+import { validateDatasetSemanticValue } from "./dataset.js";
+import { validateGuideSemanticValue } from "./guide.js";
+import { validateLayerSemanticValue } from "./layer.js";
+import { validateScaleSemanticValue } from "./scale.js";
+import { validateNonEmptySemanticString } from "./shared.js";
+
+const VALIDATORS = Object.freeze({
+  dataset: validateDatasetSemanticValue,
+  layer: validateLayerSemanticValue,
+  scale: validateScaleSemanticValue,
+  coordinate(_program, parsed, value) {
+    if (parsed.path[0] === "type") validateCoordinateType(value);
+  },
+  guide: validateGuideSemanticValue,
+  title(_program, parsed, value) {
+    validateNonEmptySemanticString(value, `Chart title ${parsed.path[0]}`);
+  }
+});
+
+export function validateSemanticValue(program, parsed, value) {
+  VALIDATORS[parsed.kind]?.(program, parsed, value);
+}

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

@@ -0,0 +1,74 @@
+import { validateUserId } from "../../../core/identifiers.js";
+import {
+  COLOR_LAYOUTS,
+  MARK_TYPES,
+  STACK_MODES
+} from "../../../core/vocabulary.js";
+import { validateAggregate } from "../../../grammar/aggregate.js";
+import {
+  normalizeHistogramBin,
+  validateHistogramBinBoundaries,
+  validateHistogramBinStep
+} from "../../../grammar/histogram.js";
+import {
+  validateParallelDimensions,
+  validateParallelKeyField,
+  validateParallelMissingPolicy
+} from "../../../grammar/parallelCoordinates.js";
+import { validatePathOrderDirection } from "../../../grammar/pathOrder.js";
+import { validateSemanticFieldType } from "../../../grammar/scales/index.js";
+import { findLayer } from "../../../selectors/layers.js";
+import { validateNonEmptySemanticString } from "./shared.js";
+
+function validateLayerSource(program, parsed, value) {
+  validateUserId(value, "Layer source id");
+  if (value === parsed.id) {
+    throw new Error("A layer cannot use itself as its source.");
+  }
+  const source = findLayer(program, value);
+  if (source === undefined) {
+    throw new Error(`Unknown source layer "${value}".`);
+  }
+  if (!["point", "bar", "rule", "rect"].includes(source.mark?.type)) {
+    throw new Error(
+      `Layer source "${value}" must be a point, bar, rule, or rect mark.`
+    );
+  }
+}
+
+export function validateLayerSemanticValue(program, parsed, value) {
+  const property = parsed.path.join(".");
+  if (property === "mark.type" && !MARK_TYPES.includes(value)) {
+    throw new Error(`Unknown mark type "${value}".`);
+  }
+  if (property === "source") validateLayerSource(program, parsed, value);
+  if (property.endsWith(".title")) {
+    validateNonEmptySemanticString(value, "Encoding title");
+  }
+  if (property === "encoding.pathOrder.fieldType" && value !== "quantitative") {
+    throw new Error("Path order field type must be quantitative.");
+  }
+  if (property.endsWith(".fieldType")) validateSemanticFieldType(value);
+  if (property === "encoding.pathOrder.order") validatePathOrderDirection(value);
+  if (property === "encoding.parallel.dimensions") {
+    validateParallelDimensions(value, { normalized: true });
+  }
+  if (property === "encoding.parallel.key") validateParallelKeyField(value);
+  if (property === "encoding.parallel.missing") {
+    validateParallelMissingPolicy(value);
+  }
+  if (property.endsWith(".aggregate")) validateAggregate(value);
+  if (property.endsWith(".bin.maxBins")) normalizeHistogramBin({ maxBins: value });
+  if (property.endsWith(".bin.step")) validateHistogramBinStep(value);
+  if (property.endsWith(".bin.boundaries")) validateHistogramBinBoundaries(value);
+  if (
+    property.endsWith(".stack") &&
+    value !== null &&
+    !STACK_MODES.includes(value)
+  ) {
+    throw new Error(`Unsupported stack "${value}".`);
+  }
+  if (property === "encoding.color.layout" && !COLOR_LAYOUTS.includes(value)) {
+    throw new Error(`Unsupported color layout "${value}".`);
+  }
+}