ggaction 0.0.17 → 0.0.18

package/src/grammar/curveCommands.js

@@ -1,6 +1,5 @@
 import { freezeOwned, isPlainObject } from "../core/immutable.js";
-import { validateGeneratedItemLimit } from "../core/validation.js";
-import { buildLinearPathCommands } from "./pathCommands.js";
+import { buildLinearPathCommands, validatePathCommandCount } from "./pathCommands.js";
 
 export const CURVE_INTERPOLATIONS = Object.freeze([
   "linear",
@@ -42,6 +41,15 @@ function validatePoints(points) {
   return points;
 }
 
+export function validateCardinalTension(tension, curve) {
+  if (tension === undefined) return 0;
+  if (curve !== "cardinal") throw new Error("Line tension requires cardinal interpolation.");
+  if (!Number.isFinite(tension) || tension < 0 || tension > 1) {
+    throw new RangeError("Cardinal tension must be between 0 and 1.");
+  }
+  return tension;
+}
+
 export function validateCurveInterpolation(curve) {
   if (!CURVE_INTERPOLATIONS.includes(curve)) {
     throw new Error(`Unsupported curve interpolation "${curve}".`);
@@ -134,7 +142,7 @@ function buildBasisCommands(points) {
   return ownCommands(commands);
 }
 
-function buildCardinalCommands(points) {
+function buildCardinalCommands(points, tension = 0) {
   const commands = [{ op: "M", x: points[0].x, y: points[0].y }];
   for (let index = 0; index < points.length - 1; index += 1) {
     const before = points[index - 1] ?? points[index];
@@ -143,10 +151,10 @@ function buildCardinalCommands(points) {
     const after = points[index + 2] ?? next;
     commands.push({
       op: "C",
-      x1: current.x + (next.x - before.x) / 6,
-      y1: current.y + (next.y - before.y) / 6,
-      x2: next.x - (after.x - current.x) / 6,
-      y2: next.y - (after.y - current.y) / 6,
+      x1: current.x + (next.x - before.x) / 6 * (1 - tension),
+      y1: current.y + (next.y - before.y) / 6 * (1 - tension),
+      x2: next.x - (after.x - current.x) / 6 * (1 - tension),
+      y2: next.y - (after.y - current.y) / 6 * (1 - tension),
       x: next.x,
       y: next.y
     });
@@ -265,7 +273,7 @@ function buildNaturalCommands(points) {
   return ownCommands(commands);
 }
 
-function buildValidatedCurvePathCommands(points, curve) {
+function buildValidatedCurvePathCommands(points, curve, tension) {
   if (curve === "linear" ||
       (SMOOTH_CURVES.has(curve) &&
         curve !== "monotone" &&
@@ -277,7 +285,7 @@ function buildValidatedCurvePathCommands(points, curve) {
   }
   if (curve === "basis") return buildBasisCommands(points);
   if (curve === "cardinal") {
-    return buildCardinalCommands(points);
+    return buildCardinalCommands(points, tension);
   }
   if (curve === "monotone") {
     return buildMonotoneCommands(points);
@@ -301,17 +309,19 @@ function curveCommandCount(pointCount, curve) {
     : pointCount;
 }
 
-export function buildCurvePathCommands(points, curve = "linear") {
+export function buildCurvePathCommands(points, curve = "linear", tension) {
+  validateCardinalTension(tension, curve);
   const validatedPoints = validatePoints(points);
   const validatedCurve = validateCurveInterpolation(curve);
-  validateGeneratedItemLimit(
+  validatePathCommandCount(
     curveCommandCount(validatedPoints.length, validatedCurve),
     "Curve path command count"
   );
   const direct = buildValidatedCurvePathCommands(
     validatedPoints,
-    validatedCurve
+    validatedCurve, tension
   );
+  validatePathCommandCount(direct.length, "Curve path command count");
   if (finiteCommands(direct)) return direct;
 
   let xScale = 0;
@@ -327,7 +337,7 @@ export function buildCurvePathCommands(points, curve = "linear") {
       x: point.x / xScale,
       y: point.y / yScale
     })),
-    validatedCurve
+    validatedCurve, tension
   );
   const restored = normalized.map(command => {
     const copy = {};
@@ -341,6 +351,7 @@ export function buildCurvePathCommands(points, curve = "linear") {
   if (!finiteCommands(restored)) {
     throw new RangeError("Curve interpolation exceeds the finite numeric range.");
   }
+  validatePathCommandCount(restored.length, "Curve path command count");
   return ownCommands(restored);
 }
 
@@ -403,7 +414,7 @@ export function buildAreaCurvePathCommands(
   const validatedCurve = validateCurveInterpolation(curve);
   const validatedLower = validatePoints(lowerPoints);
   const validatedUpper = validatePoints(upperPoints);
-  validateGeneratedItemLimit(
+  validatePathCommandCount(
     curveCommandCount(validatedLower.length, validatedCurve) +
       curveCommandCount(validatedUpper.length, validatedCurve) + 1,
     "Area path command count"
@@ -416,10 +427,12 @@ export function buildAreaCurvePathCommands(
   const upper = reverseOpenPathCommands(
     buildOrientedCurvePathCommands(validatedUpper, validatedCurve, independentAxis)
   );
-  return ownCommands([
+  const commands = [
     ...lower,
     { op: "L", x: upper[0].x, y: upper[0].y },
     ...upper.slice(1),
     { op: "Z" }
-  ]);
+  ];
+  validatePathCommandCount(commands.length, "Area path command count");
+  return ownCommands(commands);
 }

package/src/grammar/datasetSchema.js

@@ -1,3 +1,4 @@
+import { requireStringValue as requireName } from "../core/validation.js";
 import { annotateError } from "../core/diagnostics.js";
 import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
 
@@ -19,12 +20,6 @@ function rejectUnknownKeys(value, keys, label) {
   if (unknown !== undefined) throw new Error(`Unknown ${label} property "${unknown}".`);
 }
 
-function requireName(value, label) {
-  if (typeof value !== "string" || value.length === 0) {
-    throw new TypeError(`${label} must be a non-empty string.`);
-  }
-  return value;
-}
 
 function valueStorageType(value) {
   if (typeof value === "number") return "number";
@@ -61,7 +56,8 @@ function normalizeField(value, index, { declared = false } = {}) {
     declared ? SOURCE_FIELD_KEYS : FIELD_KEYS,
     `dataset schema field ${index}`
   );
-  const name = requireName(value.name, `Dataset schema field ${index} name`);
+  // Stored row keys are lossless; action field references still require non-empty names.
+  const name = value.name === "" ? "" : requireName(value.name, `Dataset schema field ${index} name`);
   const allowed = declared ? DECLARED_STORAGE_TYPES : STORAGE_TYPES;
   if (!allowed.has(value.storageType)) {
     throw new Error(`Unsupported dataset schema storageType "${value.storageType}".`);

package/src/grammar/displayLabels.js

@@ -1,4 +1,5 @@
 import { isPlainObject } from "../core/immutable.js";
+import { validateNonEmptyString } from "../core/validation.js";
 
 const ENTRY_KEYS = Object.freeze(["value", "label"]);
 
@@ -55,3 +56,30 @@ export function resolveDisplayLabel(value, map, fallback) {
   }
   return resolved;
 }
+
+
+export function normalizeDisplayColorMap(value, label = "colorMap") {
+  if (!Array.isArray(value)) throw new TypeError(`${label} must be an array.`);
+  const normalized = [];
+  for (const [index, entry] of value.entries()) {
+    if (!isPlainObject(entry)) throw new TypeError(`${label}[${index}] must be a plain object.`);
+    if (Reflect.ownKeys(entry).length !== 2 ||
+        !Object.hasOwn(entry, "value") || !Object.hasOwn(entry, "color")) {
+      throw new Error(`${label}[${index}] must contain exactly value and color.`);
+    }
+    if (!isDisplayLabelValue(entry.value)) {
+      throw new TypeError(`${label}[${index}].value must be a string, boolean, null, or finite number.`);
+    }
+    validateNonEmptyString(entry.color, `${label}[${index}].color`);
+    if (normalized.some(previous => sameDisplayLabelValue(previous.value, entry.value))) {
+      throw new Error(`${label} contains a duplicate typed value.`);
+    }
+    normalized.push(Object.freeze({ value: entry.value, color: entry.color }));
+  }
+  return Object.freeze(normalized);
+}
+
+export function resolveDisplayLabelColor(value, map, fallback) {
+  const entry = map?.find(entry => sameDisplayLabelValue(entry.value, value));
+  return entry?.color ?? fallback;
+}

package/src/grammar/ecdf.js

@@ -1,3 +1,5 @@
+import { requireStringValue as nonEmptyString } from "../core/validation.js";
+import { isGroupValue as groupValue } from "./transformKeys.js";
 import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
 import { stableDecimal } from "./numeric.js";
 
@@ -6,11 +8,6 @@ const TRANSFORM_KEYS = Object.freeze([
 ]);
 const OUTPUT_KEYS = Object.freeze(["value", "cumulative", "probability"]);
 
-function nonEmptyString(value, label) {
-  if (typeof value !== "string" || value.length === 0) {
-    throw new TypeError(`${label} must be a non-empty string.`);
-  }
-}
 
 function normalizeGroupBy(groupBy) {
   const fields = groupBy === undefined
@@ -101,10 +98,6 @@ export function normalizeECDFTransform({ field, groupBy, weight, missing = "drop
   return cloneAndFreeze(transform);
 }
 
-function groupValue(value) {
-  return typeof value === "string" || typeof value === "boolean" ||
-    (typeof value === "number" && Number.isFinite(value));
-}
 
 function rejectOrDrop(transform, index, reason) {
   if (transform.missing === "error") {

package/src/grammar/facets/dependencies.js

@@ -6,12 +6,13 @@ import { resolveRectMode } from "../rects.js";
 import { resolveRuleMode } from "../rules.js";
 
 const CARTESIAN_MARKS = new Set([
-  "point", "line", "area", "bar", "rule", "tick", "rect"
+  "point", "line", "area", "bar", "rule", "tick", "rect", "text"
 ]);
 const FACET_BAR_GRAINS = new Set([
   BAR_GRAINS.histogram,
   BAR_GRAINS.aggregate,
-  BAR_GRAINS.ranged
+  BAR_GRAINS.ranged,
+  BAR_GRAINS.centered
 ]);
 const ORDINARY_SCALE_CHANNELS = Object.freeze([
   ["x", "x"], ["y", "y"], ["xOffset", "xOffset"], ["yOffset", "yOffset"],
@@ -66,6 +67,9 @@ function classifyPrimaryLayer(semanticSpec, layer) {
       `facet requires bar mark "${layer.id}" to be a complete histogram, aggregate, or ranged bar.`
     );
   }
+  if (type === "text" && layer.encoding?.text === undefined) {
+    throw new Error(`Facet text layer "${layer.id}" requires a text encoding.`);
+  }
   const complete = (
     layer.encoding?.x?.scale !== undefined &&
     layer.encoding?.y?.scale !== undefined

package/src/grammar/facets/guides.js

@@ -165,6 +165,11 @@ function scaleIds(config) {
 export function resolveSharedFacetLegends(children) {
   const normalized = requireLegendChildren(children);
   const first = normalized[0];
+  for (const child of normalized.slice(1)) {
+    if (!sameValue(first.guideConfigs.legendGroups, child.guideConfigs.legendGroups)) {
+      throw new Error(`Facet child "${child.id}" has incompatible legend group placement.`);
+    }
+  }
   const kinds = Object.keys(first.legends);
   const entries = kinds.map(kind => {
     const family = LEGEND_FAMILIES[kind];

package/src/grammar/facets/index.js

@@ -6,7 +6,6 @@ import {
 } from "../../core/validation.js";
 import { planFacetDependencies, resolveFacetFamily } from "./dependencies.js";
 import { readNominalField } from "../scales/index.js";
-const MAX_FACET_CHILDREN = 100;
 
 function requireFacetField(field, label = "facet") {
   if (typeof field !== "string" || field.length === 0) {
@@ -100,8 +99,7 @@ export function resolveFacetDefinition(semanticSpec, options = {}) {
   const values = resolveValues(observed, options.values);
   validateGeneratedItemLimit(
     values.length,
-    "Facet child count",
-    MAX_FACET_CHILDREN
+    "Facet child count"
   );
   validateWorkLimit(
     dataset.values.length * values.length,
@@ -175,8 +173,7 @@ export function resolveFacetGridDefinition(semanticSpec, options = {}) {
   }
   validateGeneratedItemLimit(
     selected.length,
-    "Facet grid child count",
-    MAX_FACET_CHILDREN
+    "Facet grid child count"
   );
   validateWorkLimit(
     dataset.values.length * selected.length,

package/src/grammar/fold.js

@@ -1,3 +1,5 @@
+import { rejectUnknownProperties as rejectUnknownKeys } from "../core/validation.js";
+import { requireStringValue as requireField } from "../core/validation.js";
 import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
 
 const TRANSFORM_KEYS = Object.freeze(["type", "fields", "as"]);
@@ -5,19 +7,7 @@ const AS_KEYS = Object.freeze(["key", "value"]);
 const MAX_FIELDS = 64;
 const MAX_OUTPUT_ROWS = 10_000;
 
-function rejectUnknownKeys(value, supported, label) {
-  const unknown = Object.keys(value).find(key => !supported.includes(key));
-  if (unknown !== undefined) {
-    throw new Error(`Unknown ${label} property "${unknown}".`);
-  }
-}
 
-function requireField(value, label) {
-  if (typeof value !== "string" || value.length === 0) {
-    throw new TypeError(`${label} must be a non-empty string.`);
-  }
-  return value;
-}
 
 function normalizeAs(value) {
   const requested = value ?? {};

package/src/grammar/gradientProfile.js

@@ -1,3 +1,4 @@
+import { requireStringValue as requireField } from "../core/validation.js";
 import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
 import {
   deriveKernelDensity,
@@ -23,12 +24,6 @@ const TRANSFORM_KEYS = [
 ];
 const OUTPUT_KEYS = Object.keys(GRADIENT_PROFILE_FIELDS);
 
-function requireField(value, label) {
-  if (typeof value !== "string" || value.length === 0) {
-    throw new TypeError(`${label} must be a non-empty string.`);
-  }
-  return value;
-}
 
 function validatePair(value, label) {
   if (

package/src/grammar/impute.js

@@ -1,26 +1,16 @@
+import { normalizeSortBy, validateSortBy } from "./transformKeys.js";
+import { rejectUnknownProperties as rejectUnknownKeys } from "../core/validation.js";
+import { requireStringValue as requireField } from "../core/validation.js";
 import { IMPUTE_REQUIRED_OPTIONS } from "../core/optionRequirements.js";
 import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
-import { interpolateNumber, inverseLerp } from "./numeric.js";
+import { interpolateNumber, inverseLerp, stableFiniteMean } from "./numeric.js";
 import { normalizeTemporalValue } from "./scales/fields.js";
 
 const TRANSFORM_KEYS = Object.freeze([
   "type", "fields", "groupBy", "sortBy", "method", "value", "edges", "maxGap"
 ]);
-const SORT_KEYS = Object.freeze(["field", "order"]);
 const METHODS = Object.freeze(Object.keys(IMPUTE_REQUIRED_OPTIONS));
 
-function rejectUnknownKeys(value, supported, label) {
-  const unknown = Object.keys(value).find(key => !supported.includes(key));
-  if (unknown !== undefined) throw new Error(`Unknown ${label} property "${unknown}".`);
-}
-
-function requireField(value, label) {
-  if (typeof value !== "string" || value.length === 0) {
-    throw new TypeError(`${label} must be a non-empty string.`);
-  }
-  return value;
-}
-
 function validateFieldList(value, label) {
   if (!Array.isArray(value) || value.length === 0 || value.some(field =>
     typeof field !== "string" || field.length === 0
@@ -35,33 +25,6 @@ function normalizeFieldList(value, { allowEmpty = false } = {}) {
   return Array.isArray(value) ? [...value] : [value];
 }
 
-function normalizeSortBy(value) {
-  if (value === undefined) return [];
-  if (!Array.isArray(value)) return value;
-  return value.map(sort => isPlainObject(sort)
-    ? { ...sort, order: sort.order ?? "ascending" }
-    : sort
-  );
-}
-
-function validateSortBy(sortBy) {
-  if (!Array.isArray(sortBy)) throw new TypeError("Impute sortBy must be an array.");
-  const fields = [];
-  sortBy.forEach((sort, index) => {
-    if (!isPlainObject(sort)) {
-      throw new TypeError(`Impute sortBy[${index}] must be a plain object.`);
-    }
-    rejectUnknownKeys(sort, SORT_KEYS, `impute sortBy[${index}]`);
-    fields.push(requireField(sort.field, `Impute sortBy[${index}].field`));
-    if (!["ascending", "descending"].includes(sort.order)) {
-      throw new Error(`Unsupported impute sort order "${sort.order}".`);
-    }
-  });
-  if (new Set(fields).size !== fields.length) {
-    throw new Error("Impute sortBy fields must be unique.");
-  }
-}
-
 function scalarType(value, label) {
   if (value === null || value === undefined) return undefined;
   if (typeof value === "string" || typeof value === "boolean") return typeof value;
@@ -94,7 +57,7 @@ export function validateImputeTransform(transform) {
   if (new Set(transform.groupBy).size !== transform.groupBy.length) {
     throw new Error("Impute groupBy fields must be unique.");
   }
-  validateSortBy(transform.sortBy);
+  validateSortBy(transform.sortBy, "Impute");
   if (!METHODS.includes(transform.method)) {
     throw new Error(`Unsupported impute method "${transform.method}".`);
   }
@@ -107,7 +70,7 @@ export function validateImputeTransform(transform) {
     scalarType(transform.value, "Impute constant value");
   } else {
     if (hasValue) throw new Error(`Impute value is not available for ${transform.method}.`);
-    if (transform.sortBy.length === 0) {
+    if (transform.method !== "mean" && transform.sortBy.length === 0) {
       throw new Error(`Impute ${transform.method} requires non-empty sortBy.`);
     }
   }
@@ -132,7 +95,7 @@ export function normalizeImputeTransform(args = {}) {
     fields: normalizeFieldList(args.fields),
     groupBy: normalizeFieldList(args.groupBy, { allowEmpty: true }),
     sortBy: normalizeSortBy(args.sortBy),
-    method: args.method,
+    method: args.method ?? "mean",
     edges: args.edges ?? "keep"
   };
   if (Object.hasOwn(args, "value")) transform.value = args.value;
@@ -212,9 +175,9 @@ function validateFieldTypes(entries, transform) {
     if (types.size > 1) {
       throw new TypeError(`Impute field "${field}" must contain one scalar type.`);
     }
-    if (transform.method === "linear" &&
+    if (["linear", "mean"].includes(transform.method) &&
       (types.size > 0 && !types.has("number"))) {
-      throw new TypeError(`Impute linear field "${field}" must contain finite numbers.`);
+      throw new TypeError(`Impute ${transform.method} field "${field}" must contain finite numbers.`);
     }
   }
 }
@@ -278,10 +241,18 @@ function setField(row, field, value) {
   });
 }
 
-function fillRun(partition, field, run, transform, positions) {
+function fillRun(partition, field, run, transform, positions, mean) {
   const [start, end] = run;
   const length = end - start + 1;
   if (transform.maxGap !== undefined && length > transform.maxGap) return;
+  if (transform.method === "mean") {
+    if (mean === undefined) {
+      if (transform.edges === "error") throw new RangeError(`Impute mean requires an observed value in field "${field}".`);
+      return;
+    }
+    for (let index = start; index <= end; index += 1) setField(partition[index].row, field, mean);
+    return;
+  }
   if (transform.method === "constant") {
     for (let index = start; index <= end; index += 1) {
       setField(partition[index].row, field, transform.value);
@@ -332,8 +303,10 @@ export function deriveImputedRows(rows, transform) {
     partition.sort((left, right) => compareEntries(left, right, transform.sortBy));
     const positions = linearPositions(partition, transform);
     for (const field of transform.fields) {
+      const observed = transform.method === "mean" ? partition.map(entry => entry.row[field]).filter(value => value !== null && value !== undefined) : [];
+      const mean = observed.length ? stableFiniteMean(observed, "Impute group mean") : undefined;
       for (const run of missingRuns(partition, field)) {
-        fillRun(partition, field, run, transform, positions);
+        fillRun(partition, field, run, transform, positions, mean);
       }
     }
   }

package/src/grammar/interval.js

@@ -1,3 +1,5 @@
+import { requireStringValue as nonEmptyString } from "../core/validation.js";
+import { isGroupValue } from "./transformKeys.js";
 import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
 import { aggregateScalarValues } from "./aggregate.js";
 import { requireFiniteResult, stableDecimal } from "./numeric.js";
@@ -21,11 +23,6 @@ const TRANSFORM_KEYS = [
 ];
 const OUTPUT_KEYS = ["center", "lower", "upper"];
 
-function nonEmptyString(value, label) {
-  if (typeof value !== "string" || value.length === 0) {
-    throw new TypeError(`${label} must be a non-empty string.`);
-  }
-}
 
 function validateGrouping(groupBy) {
   if (
@@ -166,10 +163,6 @@ function isMissing(value) {
     (typeof value === "number" && Number.isNaN(value));
 }
 
-function isGroupValue(value) {
-  return typeof value === "string" || typeof value === "boolean" ||
-    (typeof value === "number" && Number.isFinite(value));
-}
 
 function deriveGroup(values, transform) {
   if (transform.center === "median") {

package/src/grammar/legendGradient.js

@@ -0,0 +1,18 @@
+import { validateOptionObject, validatePositiveFinite, validateUnitInterval } from "../core/validation.js";
+
+export const DEFAULT_LEGEND_GRADIENT = Object.freeze({ length: 120, thickness: 12 });
+const OPTIONS = Object.freeze(["length", "thickness", "opacity"]);
+
+export function validateLegendGradient(value, label = "Legend gradient") {
+  validateOptionObject(value, OPTIONS, label);
+  validatePositiveFinite(value.length, `${label} length`);
+  validatePositiveFinite(value.thickness, `${label} thickness`);
+  if (Object.hasOwn(value, "opacity")) validateUnitInterval(value.opacity, `${label} opacity`);
+}
+
+export function normalizeLegendGradient(patch, previous = DEFAULT_LEGEND_GRADIENT) {
+  if (patch !== undefined) validateOptionObject(patch, OPTIONS, "Legend gradient");
+  const value = { ...previous, ...patch };
+  validateLegendGradient(value);
+  return value;
+}

package/src/grammar/legendGroups.js

@@ -0,0 +1 @@
+import{validateOptionObject as r,validateNonNegativeFinite as i}from"../core/validation.js";import{validateUserId as a}from"../core/identifiers.js";import{PLOT_LEGEND_POSITIONS as g,LEGEND_POSITIONS as d,LEGEND_BLOCK_LAYOUTS as f}from"../core/vocabulary.js";function s(n){r(n,void 0,"Legend groups");for(const[o,t]of Object.entries(n)){if(a(o,"Legend group target"),r(t,["placement","blockLayout","inferredOffset"],"Legend group"),!f.includes(t.blockLayout))throw new Error("Legend group blockLayout must be row, column or wrap.");if(t.inferredOffset!==void 0&&typeof t.inferredOffset!="boolean")throw new TypeError("Legend group inferredOffset must be boolean.");const e=t.placement;if(r(e,["at","position","align","offset"],"Legend group placement"),Object.hasOwn(e,"at")){if(Object.keys(e).length!==1)throw new Error("Legend group at cannot coexist with an edge anchor.");if(r(e.at,["x","y"],"Legend group at"),!Number.isFinite(e.at.x)||!Number.isFinite(e.at.y))throw new Error("Legend group at requires finite x and y.")}else{if(Object.keys(e).length!==3||!d.includes(e.position))throw new Error("Legend group requires a complete edge placement.");if(!["left","center","right"].includes(e.align))throw new Error("Unsupported legend group alignment.");if((g.includes(e.position)||["left","right"].includes(e.position))&&e.align!=="center")throw new Error("Side and in-plot legend groups require center alignment.");i(e.offset,"Legend group offset")}}return n}export{s as validateLegendGroupState};

package/src/grammar/legendTitleStyle.js

@@ -0,0 +1,22 @@
+import { validateOptionObject } from "../core/validation.js";
+
+export const LEGEND_TITLE_STYLE_KEYS = Object.freeze([
+  "color", "fontSize", "fontFamily", "fontWeight", "align"
+]);
+
+export function validateLegendTitleAlignment(style, titlePosition = "top") {
+  if (style?.align === undefined) {
+    if (style !== undefined && Object.hasOwn(style, "align")) throw new TypeError("Legend title align requires left, center or right.");
+    return;
+  }
+  if (!["left", "center", "right"].includes(style.align)) throw new Error("Legend title align requires left, center or right.");
+  if (titlePosition === "left") throw new Error("Inline legend titles do not accept title alignment.");
+}
+
+export function mergeLegendTitleStyle(previous, patch, { edit = false } = {}) {
+  if (patch !== undefined) validateOptionObject(patch, LEGEND_TITLE_STYLE_KEYS, "Legend titleStyle");
+  const result = { ...previous, ...patch };
+  if (edit && patch?.align === "auto") delete result.align;
+  validateLegendTitleAlignment(result);
+  return result;
+}