ggaction 0.0.15 → 0.0.16

package/src/core/extensionRegistry.js

@@ -4,6 +4,32 @@ import { isPlainObject } from "./immutable.js";
 const ACTION_NAME_PATTERN = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
 const DEFINITION_KEYS = new Set(["name", "actions"]);
 const registeredExtensionNames = new Set();
+const extensionByAction = new Map();
+const builtinOpsByClass = new WeakMap();
+
+export function recordBuiltinActions(ProgramClass, additional = []) {
+  builtinOpsByClass.set(ProgramClass, new Set([
+    ...Object.getOwnPropertyNames(ProgramClass.prototype).flatMap(name => {
+      const metadata = getWrappedActionMetadata(ProgramClass.prototype[name]);
+      return metadata ? [metadata.op] : [];
+    }), ...additional
+  ]));
+}
+
+export function isBuiltinProgramClass(ProgramClass) {
+  return builtinOpsByClass.has(ProgramClass);
+}
+
+export function requiredTraceExtension(ProgramClass, op) {
+  if (op === "program" || builtinOpsByClass.get(ProgramClass)?.has(op)) return undefined;
+  const extension = extensionByAction.get(op);
+  if (extension !== undefined) return extension;
+  throw new TypeError(`Cannot persist unregistered action "${op}".`);
+}
+
+export function hasRegisteredExtension(name) {
+  return registeredExtensionNames.has(name);
+}
 
 function readDataProperty(object, key, owner) {
   const descriptor = Object.getOwnPropertyDescriptor(object, key);
@@ -101,4 +127,5 @@ export function registerProgramExtension(ProgramClass, definition) {
 
   Object.defineProperties(ProgramClass.prototype, descriptors);
   registeredExtensionNames.add(name);
+  for (const actionName of actionNames) extensionByAction.set(actionName, name);
 }

package/src/core/font.js

@@ -0,0 +1,18 @@
+export const DEFAULT_FONT_FAMILY = "sans-serif";
+
+export function normalizeRendererFontWeight(fontWeight) {
+  if (typeof fontWeight !== "number") return fontWeight;
+  return Math.min(900, Math.max(100, Math.round(fontWeight / 100) * 100));
+}
+
+export function textMetricKey({ text, fontFamily, fontSize, fontWeight }) {
+  return JSON.stringify([text, fontFamily, fontSize, fontWeight]);
+}
+
+export function textMetricFontWeight(value = "normal") {
+  if (typeof value === "number") return normalizeRendererFontWeight(value);
+  if (value === "normal") return 400;
+  if (value === "bold") return 700;
+  if (/^[1-9]00$/u.test(value)) return Number(value);
+  return undefined;
+}

package/src/core/identifiers.js

@@ -1,12 +1,13 @@
+import { annotateError } from "./diagnostics.js";
 export const USER_ID_SOURCE = "[A-Za-z0-9_-]+";
 
 const USER_ID_PATTERN = new RegExp(`^${USER_ID_SOURCE}$`);
 
 export function validateUserId(id, label = "ID") {
   if (typeof id !== "string" || !USER_ID_PATTERN.test(id)) {
-    throw new TypeError(
+    throw annotateError(new TypeError(
       `${label} must contain only letters, numbers, _ or - and must not be empty.`
-    );
+    ), { code: "invalid-value", optionPath: label });
   }
 
   return id;
@@ -20,9 +21,9 @@ export function resolveOptionalUserId(id, {
 }) {
   if (id !== undefined) return validateUserId(id, label);
   if (ambiguous) {
-    throw new Error(
+    throw annotateError(new Error(
       `${operation} requires an explicit ${label.toLowerCase()} because its default is ambiguous.`
-    );
+    ), { code: "ambiguous-resource", operation, optionPath: label });
   }
   return validateUserId(defaultId, label);
 }

package/src/core/immutable.js

@@ -22,11 +22,18 @@ export function isOwned(value) {
   return value !== null && typeof value === "object" && ownedValues.has(value);
 }
 
-export function cloneAndFreeze(value, ancestors = new WeakSet()) {
+export function cloneAndFreeze(value, ancestors = new WeakSet(), path = "state") {
+  if (typeof value === "function") {
+    throw new TypeError(`Cannot store a function at ${path} in a ChartProgram.`);
+  }
   if (value === null || typeof value !== "object") {
     return value;
   }
 
+  // Only library-owned values are recursively immutable; Object.freeze alone
+  // does not prove ownership of a caller's descendants.
+  if (isOwned(value)) return value;
+
   if (ancestors.has(value)) {
     throw new TypeError("Cannot store cyclic values in a ChartProgram.");
   }
@@ -36,12 +43,12 @@ export function cloneAndFreeze(value, ancestors = new WeakSet()) {
   let clone;
 
   if (Array.isArray(value)) {
-    clone = value.map(item => cloneAndFreeze(item, ancestors));
+    clone = value.map((item, index) => cloneAndFreeze(item, ancestors, `${path}[${index}]`));
   } else if (isPlainObject(value)) {
     clone = Object.fromEntries(
       Object.entries(value).map(([key, item]) => [
         key,
-        cloneAndFreeze(item, ancestors)
+        cloneAndFreeze(item, ancestors, `${path}.${key}`)
       ])
     );
   } else {

package/src/core/optionRequirements.js

@@ -0,0 +1,8 @@
+// The method's value-producing contract is shared by runtime validation and
+// authoring knowledge; editing can inherit these values from stored state.
+export const IMPUTE_REQUIRED_OPTIONS = Object.freeze({
+  constant: Object.freeze(["value"]),
+  forward: Object.freeze(["sortBy"]),
+  backward: Object.freeze(["sortBy"]),
+  linear: Object.freeze(["sortBy"])
+});

package/src/core/programState.js

@@ -23,7 +23,7 @@ export function ownChildPrograms(children, ProgramClass) {
     if (!(program instanceof ProgramClass)) {
       throw new TypeError(`ChartProgram child "${id}" must be a ChartProgram.`);
     }
-    owned[id] = program;
+    Object.defineProperty(owned, id, { value: program, enumerable: true });
   }
   return freezeOwned(owned);
 }

package/src/core/resourceReferences.js

@@ -148,14 +148,19 @@ export function collectMarkConfigReferences(program) {
           "coordinate", value, "markConfig", ownerId, path
         ));
       }
-      if ((key === "scale" || key.endsWith("Scale")) && typeof value === "string") {
+      const reservedScale = root === "regression" && key === "colorScale" && config.regression.groupBy === undefined;
+      if (!reservedScale && (key === "scale" || key.endsWith("Scale")) && typeof value === "string") {
         append(references, reference("scale", value, "markConfig", ownerId, path));
       } else if (key === "scale" && isPlainObject(value)) {
         append(references, reference(
           "scale", value.id, "markConfig", ownerId, [...path, "id"]
         ));
       }
-      if (MARK_ID_KEYS.has(key)) {
+      const inactiveMark = (root === "boxPlot" && key === "outlierId" && !Object.hasOwn(program.markConfigs, value)) ||
+        (root === "errorBar" && ["lowerCapId", "upperCapId"].includes(key) && config.errorBar.caps === false) ||
+        (root === "errorBand" && ["lowerBoundaryId", "upperBoundaryId"].includes(key) &&
+          !Object.hasOwn(program.markConfigs, value));
+      if (MARK_ID_KEYS.has(key) && !inactiveMark) {
         append(references, reference("mark", value, "markConfig", ownerId, path));
       }
       if (
@@ -316,7 +321,13 @@ export function collectResourceReferences(program, { kind, id }) {
     throw new Error(`Unknown resource kind "${kind}".`);
   }
   const target = validateUserId(id, "Resource id");
-  const combined = [
+  const combined = collectAllResourceReferences(program).filter(value => value.kind === kind && value.id === target);
+  const unique = new Map(combined.map(value => [referenceKey(value), value]));
+  return freezeOwned([...unique.values()].sort(compareReferences));
+}
+
+export function collectAllResourceReferences(program) {
+  return [
     ...collectSemanticDataReferences(program),
     ...collectSemanticScaleReferences(program),
     ...collectSemanticCoordinateReferences(program),
@@ -326,7 +337,5 @@ export function collectResourceReferences(program, { kind, id }) {
     ...collectDataOwnerReferences(program),
     ...collectCompositionReferences(program),
     ...collectContextReferences(program)
-  ].filter(value => value.kind === kind && value.id === target);
-  const unique = new Map(combined.map(value => [referenceKey(value), value]));
-  return freezeOwned([...unique.values()].sort(compareReferences));
+  ];
 }

package/src/core/textMetricProfile.js

@@ -0,0 +1,28 @@
+import { cloneAndFreeze } from "./immutable.js";
+import { validateUserId } from "./identifiers.js";
+import { validateOptionObject, validatePositiveFinite, validateNonNegativeFinite, validateNonEmptyString } from "./validation.js";
+
+import { textMetricKey } from "./font.js";
+
+export function normalizeTextMetricProfile(profile) {
+  validateOptionObject(profile, ["schemaVersion", "id", "measurements"], "Text metrics profile");
+  if (profile.schemaVersion !== 1) throw new Error("Text metrics require schemaVersion 1.");
+  validateUserId(profile.id, "Text metrics profile id");
+  if (!Array.isArray(profile.measurements)) throw new TypeError("Text metrics measurements must be an array.");
+  const seen = new Set();
+  for (const measurement of profile.measurements) {
+    validateOptionObject(measurement, ["text", "fontFamily", "fontSize", "fontWeight", "width"], "Text measurement");
+    if (typeof measurement.text !== "string") throw new TypeError("Text measurement text must be a string.");
+    validateNonEmptyString(measurement.fontFamily, "Text measurement fontFamily");
+    validatePositiveFinite(measurement.fontSize, "Text measurement fontSize");
+    validateNonNegativeFinite(measurement.width, "Text measurement width");
+    if (!Number.isInteger(measurement.fontWeight) || measurement.fontWeight < 100 ||
+        measurement.fontWeight > 900 || measurement.fontWeight % 100 !== 0) {
+      throw new RangeError("Text measurement fontWeight must be 100–900 in steps of 100.");
+    }
+    const key = textMetricKey(measurement);
+    if (seen.has(key)) throw new Error("Duplicate text measurement combination.");
+    seen.add(key);
+  }
+  return cloneAndFreeze(profile);
+}

package/src/core/textMetrics.js

@@ -1,3 +1,21 @@
+import { DEFAULT_FONT_FAMILY, textMetricFontWeight, textMetricKey } from "./font.js";
+
+import { isOwned } from "./immutable.js";
+
+const measurementIndexes = new WeakMap();
+
+function measuredWidth(profile, text, style) {
+  if (profile === undefined) return undefined;
+  let index = measurementIndexes.get(profile);
+  if (index === undefined) {
+    index = new Map(profile.measurements.map(measurement =>
+      [textMetricKey(measurement), measurement.width]));
+    if (isOwned(profile)) measurementIndexes.set(profile, index);
+  }
+  return index.get(textMetricKey({ text, fontFamily: style.fontFamily ?? DEFAULT_FONT_FAMILY,
+    fontSize: style.fontSize, fontWeight: textMetricFontWeight(style.fontWeight) }));
+}
+
 function codePointWidth(codePoint) {
   if (/\s/u.test(codePoint)) return 0.28;
   if (/[iIl.,:;!'|]/u.test(codePoint)) return 0.27;
@@ -25,7 +43,8 @@ export function textBoundsFitCanvas(bounds, canvas) {
 
 export function measureTextWidth(
   text,
-  { fontSize, fontFamily, fontWeight } = {}
+  { fontSize, fontFamily, fontWeight } = {},
+  profile
 ) {
   if (typeof text !== "string") {
     throw new TypeError("Text measurement requires a string.");
@@ -33,6 +52,8 @@ export function measureTextWidth(
   if (!Number.isFinite(fontSize) || fontSize <= 0) {
     throw new RangeError("Text measurement requires a positive fontSize.");
   }
+  const measured = measuredWidth(profile, text, { fontSize, fontFamily, fontWeight });
+  if (measured !== undefined) return measured;
   let joined = false;
   let width = 0;
   for (const codePoint of text) {
@@ -76,11 +97,11 @@ export function resolveTextBounds({
   textAlign = "left",
   textBaseline = "alphabetic",
   rotation = 0
-} = {}) {
+} = {}, profile) {
   if (![x, y, rotation].every(Number.isFinite)) {
     throw new TypeError("Text bounds require finite x, y, and rotation values.");
   }
-  const width = measureTextWidth(text, { fontSize, fontFamily, fontWeight });
+  const width = measureTextWidth(text, { fontSize, fontFamily, fontWeight }, profile);
   const [left, right] = textAlign === "center"
     ? [-width / 2, width / 2]
     : ["right", "end"].includes(textAlign) ? [-width, 0] : [0, width];

package/src/core/validation.js

@@ -1,15 +1,27 @@
+import { annotateError } from "./diagnostics.js";
 import { isPlainObject } from "./immutable.js";
 
 export const MAX_GENERATED_ITEMS = 10_000;
 export const MAX_WORK_ITEMS = 10_000_000;
 
+export function validateDataRows(values, label = "Dataset") {
+  if (!Array.isArray(values)) {
+    throw annotateError(new TypeError(`${label} requires values to be an array.`), { code: "invalid-value", optionPath: "values" });
+  }
+  for (let index = 0; index < values.length; index += 1) {
+    if (!Object.hasOwn(values, index) || !isPlainObject(values[index])) {
+      throw annotateError(new TypeError(`${label} requires every row to be a plain object; invalid row at index ${index}.`), { code: "invalid-value", optionPath: `values[${index}]` });
+    }
+  }
+}
+
 export function validateGeneratedItemLimit(
   value,
   label,
   maximum = MAX_GENERATED_ITEMS
 ) {
   if (value > maximum) {
-    throw new RangeError(`${label} must not exceed ${maximum}.`);
+    throw annotateError(new RangeError(`${label} must not exceed ${maximum}.`), { code: "resource-limit", optionPath: label, limit: maximum, actual: value });
   }
   return value;
 }
@@ -21,7 +33,7 @@ export function validateWorkLimit(value, label) {
 export function validateKeys(value, supported, label) {
   for (const key of Object.keys(value)) {
     if (!supported.includes(key)) {
-      throw new Error(`Unknown ${label} option "${key}".`);
+      throw annotateError(new Error(`Unknown ${label} option "${key}".`), { code: "invalid-option", optionPath: key });
     }
   }
 }
@@ -33,18 +45,18 @@ export function validateOptionObject(value, supported, label, {
   emptyError = TypeError
 } = {}) {
   if (!isPlainObject(value)) {
-    throw new TypeError(plainObjectMessage);
+    throw annotateError(new TypeError(plainObjectMessage), { code: "invalid-option" });
   }
   if (supported !== undefined) validateKeys(value, supported, label);
   if (!allowEmpty && Object.keys(value).length === 0) {
-    throw new emptyError(emptyMessage);
+    throw annotateError(new emptyError(emptyMessage), { code: "invalid-option" });
   }
   return value;
 }
 
 export function noOptions(args, operation) {
   if (!isPlainObject(args) || Object.keys(args).length > 0) {
-    throw new Error(`${operation} does not accept options.`);
+    throw annotateError(new Error(`${operation} does not accept options.`), { code: "invalid-option", operation });
   }
 }
 
@@ -59,30 +71,30 @@ export function sameOrderedValues(left, right) {
 
 export function validateNonEmptyString(value, label) {
   if (typeof value !== "string" || value.length === 0) {
-    throw new TypeError(`${label} must be a non-empty string.`);
+    throw annotateError(new TypeError(`${label} must be a non-empty string.`), { code: "invalid-value", optionPath: label });
   }
   return value;
 }
 
 export function validateUnitInterval(value, label) {
   if (!Number.isFinite(value) || value < 0 || value > 1) {
-    throw new RangeError(
+    throw annotateError(new RangeError(
       `${label} must be between 0 and 1 (values from 0 to 1).`
-    );
+    ), { code: "invalid-value", optionPath: label });
   }
   return value;
 }
 
 export function validatePositiveFinite(value, label) {
   if (!Number.isFinite(value) || value <= 0) {
-    throw new RangeError(`${label} must be a positive finite number.`);
+    throw annotateError(new RangeError(`${label} must be a positive finite number.`), { code: "invalid-value", optionPath: label });
   }
   return value;
 }
 
 export function validateNonNegativeFinite(value, label) {
   if (!Number.isFinite(value) || value < 0) {
-    throw new RangeError(`${label} must be a non-negative finite number.`);
+    throw annotateError(new RangeError(`${label} must be a non-negative finite number.`), { code: "invalid-value", optionPath: label });
   }
   return value;
 }

package/src/diagnostics.js

@@ -0,0 +1 @@
+export { getErrorDetails } from "./core/diagnostics.js";

package/src/grammar/impute.js

@@ -1,3 +1,4 @@
+import { IMPUTE_REQUIRED_OPTIONS } from "../core/optionRequirements.js";
 import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
 import { interpolateNumber, inverseLerp } from "./numeric.js";
 import { normalizeTemporalValue } from "./scales/fields.js";
@@ -6,7 +7,7 @@ const TRANSFORM_KEYS = Object.freeze([
   "type", "fields", "groupBy", "sortBy", "method", "value", "edges", "maxGap"
 ]);
 const SORT_KEYS = Object.freeze(["field", "order"]);
-const METHODS = Object.freeze(["constant", "forward", "backward", "linear"]);
+const METHODS = Object.freeze(Object.keys(IMPUTE_REQUIRED_OPTIONS));
 
 function rejectUnknownKeys(value, supported, label) {
   const unknown = Object.keys(value).find(key => !supported.includes(key));
@@ -98,7 +99,7 @@ export function validateImputeTransform(transform) {
     throw new Error(`Unsupported impute method "${transform.method}".`);
   }
   const hasValue = Object.hasOwn(transform, "value");
-  if (transform.method === "constant") {
+  if (IMPUTE_REQUIRED_OPTIONS[transform.method].includes("value")) {
     if (!hasValue) throw new TypeError("Impute constant requires a value.");
     if (transform.value === undefined) {
       throw new TypeError("Impute constant value must be a JSON-safe scalar.");

package/src/grammar/scales/types.js

@@ -26,6 +26,14 @@ export const COMPLETE_SCALE_TYPES = Object.freeze([
   ...new Set(Object.values(SCALE_TYPES_BY_ROLE).flat())
 ]);
 
+// Dimensionless scale spacing is shared by generic and focused editors.
+export const SCALE_OPTION_UNITS = Object.freeze({
+  padding: "band-fraction",
+  paddingInner: "band-fraction",
+  paddingOuter: "band-fraction",
+  align: "ratio"
+});
+
 const SCALE_PROPERTY_TYPES = Object.freeze({
   midpoint: Object.freeze(["sequential"]),
   nice: Object.freeze(["linear", "log", "pow", "sqrt", "symlog", "time"]),

package/src/grammar/schemas/graphicBounds.js

@@ -376,7 +376,7 @@ function hasActiveStroke(properties) {
     (properties.strokeWidth ?? 0) > 0;
 }
 
-function primitiveBounds(type, properties = {}) {
+function primitiveBounds(type, properties = {}, profile) {
   const strokeExtent = hasActiveStroke(properties)
     ? properties.strokeWidth / 2
     : 0;
@@ -420,7 +420,7 @@ function primitiveBounds(type, properties = {}) {
       !Number.isFinite(properties.fontSize) ||
       typeof properties.text !== "string"
     ) return undefined;
-    return resolveTextBounds(properties);
+    return resolveTextBounds(properties, profile);
   }
   if (type === "path") {
     const commands = properties.commands;
@@ -469,15 +469,15 @@ function ancestorOffset(graphicSpec, target) {
   }
 }
 
-function objectBounds(graphicSpec, id, object, ancestors, x, y) {
+function objectBounds(graphicSpec, id, object, ancestors, x, y, profile) {
   if (ancestors.has(id)) {
     throw new Error(`Graphic attachment cycle includes "${id}".`);
   }
   ancestors.add(id);
   let result = object.items === undefined
-    ? translateBounds(primitiveBounds(object.type, object.properties), x, y)
+    ? translateBounds(primitiveBounds(object.type, object.properties, profile), x, y)
     : unionBounds(object.items.map(item => translateBounds(
-        primitiveBounds(item.type ?? object.type, item.properties),
+        primitiveBounds(item.type ?? object.type, item.properties, profile),
         x,
         y
       )));
@@ -489,7 +489,7 @@ function objectBounds(graphicSpec, id, object, ancestors, x, y) {
       throw new Error(`Unknown attached graphic "${childId}".`);
     }
     const bounds = objectBounds(
-      graphicSpec, childId, child.object, ancestors, childX, childY
+      graphicSpec, childId, child.object, ancestors, childX, childY, profile
     );
     if (bounds !== undefined) {
       result = includeExtent(
@@ -501,23 +501,23 @@ function objectBounds(graphicSpec, id, object, ancestors, x, y) {
   return result;
 }
 
-export function resolveConcreteGraphicBounds(graphicSpec, target) {
+export function resolveConcreteGraphicBounds(graphicSpec, target, profile) {
   const found = requireGraphic(graphicSpec, target);
   const [x, y] = ancestorOffset(graphicSpec, target);
   return requireFiniteBounds(found.kind === "item"
     ? translateBounds(
-      primitiveBounds(found.object.type ?? found.owner.type, found.object.properties),
+      primitiveBounds(found.object.type ?? found.owner.type, found.object.properties, profile),
       x,
       y
     )
-    : objectBounds(graphicSpec, found.id, found.object, new Set(), x, y));
+    : objectBounds(graphicSpec, found.id, found.object, new Set(), x, y, profile));
 }
 
-export function unionConcreteGraphicBounds(graphicSpec, targets) {
+export function unionConcreteGraphicBounds(graphicSpec, targets, profile) {
   if (!Array.isArray(targets)) {
     throw new TypeError("Graphic bounds targets must be an array.");
   }
   return unionBounds(targets.map(target =>
-    resolveConcreteGraphicBounds(graphicSpec, target)
+    resolveConcreteGraphicBounds(graphicSpec, target, profile)
   ));
 }

package/src/layout/labels.js

@@ -172,7 +172,7 @@ export function assertMarkLabelPlacementSupport({ markType, coordinateType, inte
 }
 
 function localTextBounds(text) {
-  return resolveTextBounds({ ...text, x: 0, y: 0 });
+  return resolveTextBounds({ ...text, x: 0, y: 0 }, text.profile);
 }
 
 function projectionRange(bounds, direction) {
@@ -207,7 +207,7 @@ function centerCandidate(center, text) {
 }
 
 function candidateBounds(candidate, text) {
-  return resolveTextBounds({ ...text, x: candidate.x, y: candidate.y });
+  return resolveTextBounds({ ...text, x: candidate.x, y: candidate.y }, text.profile);
 }
 
 function intervalContains(bounds, container) {
@@ -328,7 +328,8 @@ function outsideFallback(anchor) {
   return anchor === "insideStart" ? "outsideStart" : "outsideEnd";
 }
 
-export function resolveMarkLabelPlacement({ placement, geometry, text } = {}) {
+export function resolveMarkLabelPlacement({ placement, geometry, text } = {}, profile) {
+  text = { ...text, profile };
   const normalized = normalizeMarkLabelPlacement(placement);
   validatePlacementGeometry(geometry, normalized.anchor);
   let anchor = normalized.anchor;
@@ -501,7 +502,7 @@ export function enumerateLabelOffsets({ axis, padding, maxDisplacement }) {
   return cloneAndFreeze(candidates);
 }
 
-function textBounds(item, offset = { x: 0, y: 0 }) {
+function textBounds(item, offset = { x: 0, y: 0 }, profile) {
   return resolveTextBounds({
     x: item.x + offset.x,
     y: item.y + offset.y,
@@ -512,7 +513,7 @@ function textBounds(item, offset = { x: 0, y: 0 }) {
     textAlign: item.textAlign,
     textBaseline: item.textBaseline,
     rotation: item.rotation
-  });
+  }, profile);
 }
 
 function candidateScore(bounds, boundary, placed, candidate, order) {
@@ -552,7 +553,7 @@ function overlapPairs(items) {
   return pairs;
 }
 
-export function resolveLabelLayout({ items, bounds, ...options } = {}) {
+export function resolveLabelLayout({ items, bounds, ...options } = {}, profile) {
   if (!Array.isArray(items)) {
     throw new TypeError("Label layout requires an item array.");
   }
@@ -567,14 +568,14 @@ export function resolveLabelLayout({ items, bounds, ...options } = {}) {
   );
   const base = items.map(item => ({
     id: item.id,
-    collisionBounds: expanded(textBounds(item), policy.padding)
+    collisionBounds: expanded(textBounds(item, undefined, profile), policy.padding)
   }));
   const placed = [];
   const resolved = [];
   for (const item of items) {
     let best;
     for (const [order, candidate] of candidates.entries()) {
-      const boundsAtCandidate = textBounds(item, candidate);
+      const boundsAtCandidate = textBounds(item, candidate, profile);
       const collisionBounds = expanded(boundsAtCandidate, policy.padding);
       const score = candidateScore(
         collisionBounds,
@@ -619,7 +620,7 @@ export function resolveLabelLayout({ items, bounds, ...options } = {}) {
   });
 }
 
-export function assertPolarTextLayout({ canvas, items, label }) {
+export function assertPolarTextLayout({ canvas, items, label }, profile) {
   const dimensions = canvas?.properties;
   if (
     ![dimensions?.width, dimensions?.height].every(Number.isFinite) ||
@@ -627,7 +628,7 @@ export function assertPolarTextLayout({ canvas, items, label }) {
   ) {
     throw new Error("Polar text layout requires finite Canvas dimensions.");
   }
-  const bounds = items.map(resolveTextBounds);
+  const bounds = items.map(item => resolveTextBounds(item, profile));
   const outside = bounds.some(item => !textBoundsFitCanvas(item, dimensions));
   let overlap = false;
   for (let first = 0; first < bounds.length && !overlap; first += 1) {

package/src/layout/legend.js

@@ -3,15 +3,15 @@ import {
   measureTextWidth
 } from "../core/textMetrics.js";
 
-export function measureLegendTextWidth(value, style = { fontSize: 12 }) {
-  return measureTextWidth(formatVisibleText(value), style);
+export function measureLegendTextWidth(value, style = { fontSize: 12 }, profile) {
+  return measureTextWidth(formatVisibleText(value), style, profile);
 }
 
-export function resolveLegendGrid(config, width, count, symbolHeight) {
+export function resolveLegendGrid(config, width, count, symbolHeight, profile) {
   const labels = config.domain.map(formatVisibleText);
   const itemWidths = labels.map(
     label => width + config.labels.offset +
-      measureLegendTextWidth(label, config.labels)
+      measureLegendTextWidth(label, config.labels, profile)
   );
   const columnCount = Math.min(config.columns ?? count, count);
   const rowCount = Math.ceil(count / columnCount);

package/src/layout/legendItems.js

@@ -3,7 +3,7 @@ import { alignLegendStart, resolveLegendGrid } from "./legend.js";
 
 // Measure item content before choosing its edge. Family owners supply the
 // sample dimensions and formatted labels; this module does not inspect scales.
-export function resolveLegendItemLayout(plot, config, labels, symbol, canvas) {
+export function resolveLegendItemLayout(plot, config, labels, symbol, canvas, profile) {
   const strokes = labels.map((_, index) => Array.isArray(symbol.strokeWidth)
     ? symbol.strokeWidth[index] : symbol.strokeWidth ?? 0);
   const sampleBounds = labels.map((_, index) => symbol.itemBounds?.[index] ?? {
@@ -19,17 +19,17 @@ export function resolveLegendItemLayout(plot, config, labels, symbol, canvas) {
     ...sampleBounds.map(bounds => 2 * Math.max(-bounds.top, bounds.bottom)));
   const side = ["left", "right"].includes(config.position);
   const titleVisible = config.titleVisible !== false;
-  const titleWidth = titleVisible ? measureTextWidth(config.title, config.titleStyle) : 0;
+  const titleWidth = titleVisible ? measureTextWidth(config.title, config.titleStyle, profile) : 0;
   const titleHeight = titleVisible ? config.titleStyle.fontSize : 0;
   const itemWidth = sampleWidth + config.labels.offset + Math.max(...labels.map(
-    text => measureTextWidth(text, config.labels)
+    text => measureTextWidth(text, config.labels, profile)
   ));
   let symbolX;
   let labelX;
   let itemY;
   let title;
   if (config.layout === "legacy-bottom") {
-    const widths = labels.map(text => sampleWidth + config.labels.offset + measureTextWidth(text, config.labels));
+    const widths = labels.map(text => sampleWidth + config.labels.offset + measureTextWidth(text, config.labels, profile));
     const width = widths.reduce((sum, value) => sum + value, 0) + config.itemGap * (labels.length - 1);
     const x = config.align === "center" ? (canvas.width - width) / 2 : alignLegendStart(plot, width, config.align);
     let cursor = x;
@@ -54,7 +54,7 @@ export function resolveLegendItemLayout(plot, config, labels, symbol, canvas) {
     itemY = labels.map((_, index) => firstY + index * pitch);
     title = { x, y: plot.y + 20, align: "left" };
   } else {
-    const grid = resolveLegendGrid({ ...config, domain: labels }, sampleWidth, labels.length, sampleHeight);
+    const grid = resolveLegendGrid({ ...config, domain: labels }, sampleWidth, labels.length, sampleHeight, profile);
     const inline = config.titlePosition === "left" && titleVisible;
     const prefix = inline ? titleWidth + 20 : 0;
     const width = inline ? prefix + grid.gridWidth : Math.max(titleWidth, grid.gridWidth);
@@ -79,7 +79,7 @@ export function resolveLegendItemLayout(plot, config, labels, symbol, canvas) {
   }
   const textBounds = (x, y, text, style, align = "left") => resolveTextBounds({
     x, y, text, ...style, textAlign: align, textBaseline: "middle"
-  });
+  }, profile);
   const bounds = [
     ...(titleVisible ? [textBounds(title.x, title.y, config.title, config.titleStyle, title.align)] : []),
     ...labels.map((label, index) => textBounds(labelX[index], itemY[index], label, config.labels)),