ggaction 0.0.13 → 0.0.16

package/src/actions/guides/axes/labels.js

@@ -9,7 +9,7 @@ import {
   validateNonNegativeFinite,
   validatePositiveFinite
 } from "../../../core/validation.js";
-import { resolveGraphicBounds } from "../../../layout/canvas.js";
+import { resolveGuideCoordinateBounds } from "../../../materialization/coordinateBounds.js";
 import {
   isTransformedScaleType,
   mapContinuousScaleValues,
@@ -38,11 +38,15 @@ import {
 import { resolveConcreteGraphicBounds } from
   "../../../grammar/schemas/graphicBounds.js";
 import { wrapText } from "../../../layout/text.js";
+import {
+  normalizeDisplayLabelMap,
+  resolveDisplayLabel
+} from "../../../grammar/displayLabels.js";
 
 const OPTIONS = [
   "scale", "position", "count", "values", "offset", "format", "color",
   "fontSize", "fontFamily", "fontWeight", "rotation", "maxWidth", "wrap",
-  "lineHeight", "overlap"
+  "lineHeight", "overlap", "labelMap"
 ];
 
 const DEFAULTS = {
@@ -136,6 +140,24 @@ function validateConfig(channel, config) {
   }
 }
 
+function normalizeAxisLabelMap(program, config, args, operation) {
+  if (!Object.hasOwn(args, "labelMap")) return config;
+  const scale = program.resolvedScales[config.scale];
+  if (!["ordinal", "band", "point"].includes(scale?.type)) {
+    throw new Error(`${operation} labelMap requires a categorical scale.`);
+  }
+  const next = { ...config };
+  if (args.labelMap === "auto") {
+    delete next.labelMap;
+  } else {
+    next.labelMap = normalizeDisplayLabelMap(
+      args.labelMap,
+      `${operation} labelMap`
+    );
+  }
+  return next;
+}
+
 function assertTickCompatibility(ticks, config, operation) {
   if (!ticks) return;
   if (ticks.scale !== config.scale || ticks.mode !== config.mode) throw new Error(`${operation} conflicts with axis ticks.`);
@@ -143,7 +165,7 @@ function assertTickCompatibility(ticks, config, operation) {
   if (config.mode === "values" && !sameOrderedValues(ticks.values, config.values)) throw new Error(`${operation} conflicts with axis ticks.`);
 }
 
-function expandWrappedLabels(resolved, text, config, channel) {
+function expandWrappedLabels(resolved, text, config, channel, profile) {
   if (config.maxWidth === undefined) {
     return {
       ...resolved,
@@ -162,7 +184,7 @@ function expandWrappedLabels(resolved, text, config, channel) {
     const lines = wrapText(text[index], {
       maxWidth: config.maxWidth,
       mode: config.wrap,
-      style
+      style, profile
     });
     validateGeneratedItemLimit(
       expanded.text.length + lines.length,
@@ -198,8 +220,15 @@ function unionLabelBounds(records) {
 
 function resolve(program, channel, config) {
   const scale = program.resolvedScales[config.scale];
-  const bounds = resolveGraphicBounds(program);
+  const bounds = resolveGuideCoordinateBounds(program, {
+    coordinate: program.semanticSpec.guides.axis?.[channel]?.coordinate,
+    scale: config.scale,
+    channel
+  });
   const discrete = ["ordinal", "band", "point"].includes(scale?.type);
+  if (config.labelMap !== undefined && !discrete) {
+    throw new Error("Axis labelMap requires a categorical scale.");
+  }
   if ((
     !["linear", "time", "ordinal", "band", "point"].includes(scale?.type) &&
     !isTransformedScaleType(scale?.type)
@@ -217,9 +246,7 @@ function resolve(program, channel, config) {
   const positions = discrete
     ? mapOrdinalPositionValues(values, scale)
     : mapContinuousScaleValues(values, scale);
-  const text = scale.type === "time" && config.format === "auto"
-    ? formatTimeTicks(values, scale.domain)
-    : values.map(value => formatAxisValue(
+  const fallback = value => formatAxisValue(
         value,
         scale.type,
         config.format,
@@ -228,7 +255,12 @@ function resolve(program, channel, config) {
           : isTransformedScaleType(scale.type)
             ? formatTransformedTick(scale.type, item)
             : String(item)
-      ));
+      );
+  const text = discrete
+    ? values.map(value => resolveDisplayLabel(value, config.labelMap, fallback))
+    : scale.type === "time" && config.format === "auto"
+      ? formatTimeTicks(values, scale.domain)
+      : values.map(fallback);
   const geometry = {
     values,
     ...resolveAxisLabelGeometry({
@@ -239,7 +271,7 @@ function resolve(program, channel, config) {
       offset: config.offset
     })
   };
-  const resolved = expandWrappedLabels(geometry, text, config, channel);
+  const resolved = expandWrappedLabels(geometry, text, config, channel, program.materializationConfigs.textMetrics);
   const canvas = findCanvasGraphic(program)?.properties;
   const labelBounds = resolved.text.map((value, index) => resolveTextBounds({
     x: Array.isArray(resolved.x) ? resolved.x[index] : resolved.x,
@@ -251,7 +283,7 @@ function resolve(program, channel, config) {
     textAlign: resolved.textAlign,
     textBaseline: resolved.textBaseline,
     rotation: config.rotation
-  }));
+  }, program.materializationConfigs.textMetrics));
   const groupedBounds = unionLabelBounds(labelBounds.map((bounds, index) => ({
     bounds,
     group: resolved.groups[index]
@@ -267,7 +299,7 @@ function resolve(program, channel, config) {
     throw new Error(`The ${channel}-axis labels overlap each other.`);
   }
   const title = program.graphicSpec.objects[`${channel}AxisTitle`]
-    ? resolveConcreteGraphicBounds(program.graphicSpec, `${channel}AxisTitle`)
+    ? resolveConcreteGraphicBounds(program.graphicSpec, `${channel}AxisTitle`, program.materializationConfigs.textMetrics)
     : undefined;
   if (title &&
     program.guideConfigs.axis?.[channel]?.title?.inferredOffset !== true &&
@@ -294,13 +326,14 @@ function makeEdit(channel) {
     const mode = Object.hasOwn(args, "values") || inferredValues !== undefined
       ? "values"
       : Object.hasOwn(args, "count") ? "count" : previous.mode;
-    const config = normalizeLabelLayout({
+    let config = normalizeLabelLayout({
       ...previous,
       ...args,
       ...(inferredValues === undefined ? {} : { values: inferredValues }),
       ...(explicitMode ? { inferredValues: false } : {}),
       mode
     }, args, op);
+    config = normalizeAxisLabelMap(this, config, args, op);
     if (mode === "values") delete config.count; else delete config.values;
     validateConfig(channel, config);
     assertTickCompatibility(this.guideConfigs.axis?.[channel]?.ticks, config, op);
@@ -333,8 +366,8 @@ function makeEdit(channel) {
   }));
 }
 
-const editXAxisLabels = makeEdit("x");
-const editYAxisLabels = makeEdit("y");
+const editXAxisLabels = /* @__PURE__ */ makeEdit("x");
+const editYAxisLabels = /* @__PURE__ */ makeEdit("y");
 
 function makeCreate(channel) {
   const op = channel === "x" ? "createXAxisLabels" : "createYAxisLabels";
@@ -349,8 +382,15 @@ function makeCreate(channel) {
     const ticks = this.guideConfigs.axis?.[channel]?.ticks;
     const hasValues = Object.hasOwn(args, "values");
     const hasCount = Object.hasOwn(args, "count");
-    const mode = hasValues ? "values" : hasCount ? "count" : ticks?.mode ?? "count";
-    const config = normalizeLabelLayout({
+    const resolvedScale = this.resolvedScales[scale];
+    const inferredDiscreteValues = !hasValues && !hasCount && ticks === undefined &&
+      ["ordinal", "band", "point"].includes(resolvedScale?.type)
+      ? resolvedScale.domain
+      : undefined;
+    const mode = hasValues || inferredDiscreteValues !== undefined
+      ? "values"
+      : hasCount ? "count" : ticks?.mode ?? "count";
+    let config = normalizeLabelLayout({
       scale,
       position: defaultAxisPosition(channel),
       offset: channel === "x" ? 18 : 12,
@@ -362,10 +402,16 @@ function makeCreate(channel) {
       rotation: DEFAULTS.rotation,
       overlap: DEFAULTS.overlap,
       ...args,
-      inferredValues: !hasValues && !hasCount && ticks?.inferredValues === true,
+      inferredValues: !hasValues && !hasCount &&
+        (ticks?.inferredValues === true || inferredDiscreteValues !== undefined),
       mode
     }, args, op);
-    if (mode === "values") config.values ??= ticks?.values; else config.count ??= ticks?.count ?? DEFAULTS.count;
+    config = normalizeAxisLabelMap(this, config, args, op);
+    if (mode === "values") {
+      config.values ??= ticks?.values ?? inferredDiscreteValues;
+    } else {
+      config.count ??= ticks?.count ?? DEFAULTS.count;
+    }
     validateConfig(channel, config);
     assertTickCompatibility(ticks, config, op);
     resolve(this, channel, config);
@@ -380,8 +426,8 @@ function makeCreate(channel) {
   }));
 }
 
-const createXAxisLabels = makeCreate("x");
-const createYAxisLabels = makeCreate("y");
+const createXAxisLabels = /* @__PURE__ */ makeCreate("x");
+const createYAxisLabels = /* @__PURE__ */ makeCreate("y");
 
 export function registerAxisLabelActions(Class) {
   Class.prototype.editXAxisLabels = editXAxisLabels;

package/src/actions/guides/axes/lines.js

@@ -1,3 +1,4 @@
+import { editGraphicProperties } from "../../primitives/graphicProperties.js";
 import { isSourceOwnedText } from "../../../grammar/text.js";
 import { withGuideLayoutValidation } from "../../../materialization/guides/layout.js";
 import { action } from "../../../core/action.js";
@@ -7,7 +8,7 @@ import {
   validateNonEmptyString,
   validateNonNegativeFinite
 } from "../../../core/validation.js";
-import { resolveGraphicBounds } from "../../../layout/canvas.js";
+import { resolveGuideCoordinateBounds } from "../../../materialization/coordinateBounds.js";
 import { DEFAULT_COLORS } from "../../../theme/defaults.js";
 import {
   defaultAxisPosition,
@@ -53,7 +54,11 @@ function resolveGeometry(program, channel, scaleId, position) {
 
   const resolvedScale = program.resolvedScales[scaleId];
   const range = resolvedScale?.range;
-  const bounds = resolveGraphicBounds(program);
+  const bounds = resolveGuideCoordinateBounds(program, {
+    coordinate: program.semanticSpec.guides.axis?.[channel]?.coordinate,
+    scale: scaleId,
+    channel
+  });
 
   if (!Array.isArray(range) || range.length !== 2 || !range.every(Number.isFinite)) {
     throw new Error(`Axis line requires a resolved numeric scale "${scaleId}".`);
@@ -115,15 +120,16 @@ function createEditAxisLine(channel) {
         next = next.editGraphics({ target: graphic, property, value: geometry[property] });
       }
 
-      return next
-        .editGraphics({ target: graphic, property: "stroke", value: color })
-        .editGraphics({ target: graphic, property: "strokeWidth", value: lineWidth });
+      return editGraphicProperties(next, graphic, {
+        stroke: color,
+        strokeWidth: lineWidth
+      });
     })
   );
 }
 
-const editXAxisLine = createEditAxisLine("x");
-const editYAxisLine = createEditAxisLine("y");
+const editXAxisLine = /* @__PURE__ */ createEditAxisLine("x");
+const editYAxisLine = /* @__PURE__ */ createEditAxisLine("y");
 
 function createAxisLine(channel) {
   const operation = channel === "x" ? "createXAxisLine" : "createYAxisLine";
@@ -160,8 +166,8 @@ function createAxisLine(channel) {
   );
 }
 
-const createXAxisLine = createAxisLine("x");
-const createYAxisLine = createAxisLine("y");
+const createXAxisLine = /* @__PURE__ */ createAxisLine("x");
+const createYAxisLine = /* @__PURE__ */ createAxisLine("y");
 
 export function registerAxisLineActions(ProgramClass) {
   ProgramClass.prototype.editXAxisLine = editXAxisLine;

package/src/actions/guides/axes/parallel/lifecycle.js

@@ -1,5 +1,5 @@
-import { action } from "../../../../core/action.js";
-import { validateNonEmptyString, validateOptionObject } from "../../../../core/validation.js";
+import { action, closedAction } from "../../../../core/action.js";
+import { validateNonEmptyString } from "../../../../core/validation.js";
 import { requireParallelAxisLayer, resolveParallelAxisTarget } from "./resolve.js";
 import {
   defaultParallelAxis, hasParallelAxisParts, PARALLEL_AXIS_GRAPHICS,
@@ -45,10 +45,10 @@ function withTitle(program, args, create) {
     ...(titles.length === 0 ? { remove: true } : { value: titles }) });
 }
 
-const createParallelAxes = action({
+const createParallelAxes = /* @__PURE__ */ closedAction({
   op: "createParallelAxes", description: "Create axes for every encoded Parallel dimension."
-}, function (args = {}) {
-  validateOptionObject(args, ["target", "coordinate"], "createParallelAxes");
+}, ["target", "coordinate"], function (args = {}) {
+
   const resolved = owner(this, args, "createParallelAxes");
   if (resolved.stored !== undefined || this.guideConfigs.axis?.parallel !== undefined ||
       Object.values(PARALLEL_AXIS_GRAPHICS).some(id => this.graphicSpec.objects[id] !== undefined)) {
@@ -76,13 +76,13 @@ function makeAxisAction(create) {
   });
 }
 
-const createParallelAxis = makeAxisAction(true);
-const editParallelAxis = makeAxisAction(false);
+const createParallelAxis = /* @__PURE__ */ makeAxisAction(true);
+const editParallelAxis = /* @__PURE__ */ makeAxisAction(false);
 
-const removeParallelAxis = action({
+const removeParallelAxis = /* @__PURE__ */ closedAction({
   op: "removeParallelAxis", description: "Remove every component of one Parallel field axis."
-}, function (args = {}) {
-  validateOptionObject(args, ["field", "target"], "removeParallelAxis");
+}, ["field", "target"], function (args = {}) {
+
   validateNonEmptyString(args.field, "Parallel axis field");
   const resolved = owner(this, args, "removeParallelAxis", true);
   const config = resolveParallelAxisConfigs(this, resolved.dimensions).dimensions.find(dimension => dimension.field === args.field);
@@ -91,10 +91,10 @@ const removeParallelAxis = action({
     ...Object.fromEntries(PARALLEL_AXIS_PARTS.filter(part => config[part] !== undefined).map(part => [part, false])) });
 });
 
-const removeParallelAxes = action({
+const removeParallelAxes = /* @__PURE__ */ closedAction({
   op: "removeParallelAxes", description: "Remove all Parallel axis semantics, recipes and graphics."
-}, function (args = {}) {
-  validateOptionObject(args, ["target", "coordinate"], "removeParallelAxes");
+}, ["target", "coordinate"], function (args = {}) {
+
   const stored = this.semanticSpec.guides.axis?.parallel;
   if (stored === undefined) throw new Error("removeParallelAxes requires existing Parallel axes.");
   if (args.target !== undefined && args.target !== stored.target ||

package/src/actions/guides/axes/parallel/resolve.js

@@ -6,7 +6,7 @@ import {
   transformedTicks
 } from "../../../../grammar/scales/index.js";
 import { niceTicks } from "../../../../grammar/ticks.js";
-import { resolveGraphicBounds } from "../../../../layout/canvas.js";
+import { resolveCoordinateBounds } from "../../../../materialization/coordinateBounds.js";
 import { findCoordinate } from "../../../../selectors/coordinates.js";
 import { findLayer } from "../../../../selectors/layers.js";
 import { formatAxisValue } from "../policy.js";
@@ -85,7 +85,11 @@ function componentValues(program, dimension, config) {
 }
 
 export function resolveStyledParallelAxes(program, dimensions) {
-  const bounds = resolveGraphicBounds(program);
+  const stored = program.guideConfigs.axis?.parallel?.axes;
+  const layer = stored === undefined
+    ? undefined
+    : findLayer(program, stored.target);
+  const bounds = resolveCoordinateBounds(program, layer?.coordinate);
   const step = bounds.width / (dimensions.length - 1);
   const configs = resolveParallelAxisConfigs(program, dimensions);
   const titles = program.semanticSpec.guides.axis?.parallel?.titles ?? [];

package/src/actions/guides/axes/parallel.js

@@ -1,5 +1,5 @@
-import { action } from "../../../core/action.js";
-import { validateGeneratedItemLimit, validateOptionObject } from "../../../core/validation.js";
+import { closedAction } from "../../../core/action.js";
+import { validateGeneratedItemLimit } from "../../../core/validation.js";
 import { resolvePlotGraphicPlacement } from "../../../materialization/graphicHierarchy.js";
 import { requireParallelAxisLayer, resolveParallelAxisTarget, resolveStyledParallelAxes } from "./parallel/resolve.js";
 import { PARALLEL_AXIS_GRAPHICS, PARALLEL_AXIS_PARTS, hasParallelAxisParts } from "./parallel/policy.js";
@@ -47,11 +47,11 @@ function collectionProperties(part, axes, bounds) {
   };
 }
 
-export const rematerializeParallelAxes = action({
+export const rematerializeParallelAxes = /* @__PURE__ */ closedAction({
   op: "rematerializeParallelAxes",
   description: "Recompute concrete Parallel dimension axes."
-}, function (args = {}) {
-  validateOptionObject(args, ["target"], "rematerializeParallelAxes");
+}, ["target"], function (args = {}) {
+
   const stored = this.semanticSpec.guides.axis?.parallel;
   if (stored === undefined) throw new Error("rematerializeParallelAxes requires existing Parallel axes.");
   const target = resolveParallelAxisTarget(this, args.target ?? stored.target);

package/src/actions/guides/axes/remove.js

@@ -54,7 +54,7 @@ function makeRemoveAxis(channel) {
   );
 }
 
-export const removeXAxis = makeRemoveAxis("x");
-export const removeYAxis = makeRemoveAxis("y");
-export const removeThetaAxis = makeRemoveAxis("theta");
-export const removeRadialAxis = makeRemoveAxis("radius");
+export const removeXAxis = /* @__PURE__ */ makeRemoveAxis("x");
+export const removeYAxis = /* @__PURE__ */ makeRemoveAxis("y");
+export const removeThetaAxis = /* @__PURE__ */ makeRemoveAxis("theta");
+export const removeRadialAxis = /* @__PURE__ */ makeRemoveAxis("radius");

package/src/actions/guides/axes/tickGroups.js

@@ -30,7 +30,8 @@ const LABEL_OPTIONS = Object.freeze([
   "maxWidth",
   "wrap",
   "lineHeight",
-  "overlap"
+  "overlap",
+  "labelMap"
 ]);
 const SHARED_CREATE = Object.freeze(["scale", "position", "count", "values"]);
 const SHARED_EDIT = Object.freeze(["position", "count", "values"]);
@@ -144,10 +145,10 @@ function makeEdit(channel) {
   );
 }
 
-const createXAxisTicksAndLabels = makeCreate("x");
-const createYAxisTicksAndLabels = makeCreate("y");
-const editXAxisTicksAndLabels = makeEdit("x");
-const editYAxisTicksAndLabels = makeEdit("y");
+const createXAxisTicksAndLabels = /* @__PURE__ */ makeCreate("x");
+const createYAxisTicksAndLabels = /* @__PURE__ */ makeCreate("y");
+const editXAxisTicksAndLabels = /* @__PURE__ */ makeEdit("x");
+const editYAxisTicksAndLabels = /* @__PURE__ */ makeEdit("y");
 
 export function registerAxisTickGroupActions(Class) {
   Class.prototype.createXAxisTicksAndLabels = createXAxisTicksAndLabels;

package/src/actions/guides/axes/ticks.js

@@ -1,4 +1,7 @@
+import { editGraphicProperties } from "../../primitives/graphicProperties.js";
 import { withGuideLayoutValidation } from "../../../materialization/guides/layout.js";
+import { applyMaterializationPlan } from "../../../materialization/planner.js";
+import { planAxisTickGridRematerialization } from "../../../materialization/scaleGuideDependencies.js";
 import { action } from "../../../core/action.js";
 import { validateUserId } from "../../../core/identifiers.js";
 import {
@@ -7,7 +10,7 @@ import {
   validateNonNegativeFinite,
   validateOptionObject
 } from "../../../core/validation.js";
-import { resolveGraphicBounds } from "../../../layout/canvas.js";
+import { resolveGuideCoordinateBounds } from "../../../materialization/coordinateBounds.js";
 import {
   isTransformedScaleType,
   mapContinuousScaleValues,
@@ -69,7 +72,11 @@ function validateConfig(channel, config) {
 
 function geometry(program, channel, config) {
   const scale = program.resolvedScales[config.scale];
-  const bounds = resolveGraphicBounds(program);
+  const bounds = resolveGuideCoordinateBounds(program, {
+    coordinate: program.semanticSpec.guides.axis?.[channel]?.coordinate,
+    scale: config.scale,
+    channel
+  });
   const discrete = ["ordinal", "band", "point"].includes(scale?.type);
   if ((
     !["linear", "time", "ordinal", "band", "point"].includes(scale?.type) &&
@@ -157,11 +164,16 @@ function makeEdit(channel) {
     const resolved = geometry(this, channel, config);
     let next = this._withGuideConfig(channel, config).editGraphics({ target: id, property: "length", value: resolved.values.length });
     for (const property of ["x1", "y1", "x2", "y2"]) next = next.editGraphics({ target: id, property, value: resolved[property] });
-    return next.editGraphics({ target: id, property: "stroke", value: config.color }).editGraphics({ target: id, property: "strokeWidth", value: config.lineWidth });
+    next = editGraphicProperties(next, id, {
+      stroke: config.color,
+      strokeWidth: config.lineWidth
+    });
+    // Structural dependency plans own grids during a scale/role handoff.
+    return explicitMode ? applyMaterializationPlan(next, planAxisTickGridRematerialization(next, channel)) : next;
   }));
 }
 
-const editXAxisTicks = makeEdit("x"), editYAxisTicks = makeEdit("y");
+const editXAxisTicks = /* @__PURE__ */ makeEdit("x"), editYAxisTicks = /* @__PURE__ */ makeEdit("y");
 
 function makeCreate(channel) {
   const op = channel === "x" ? "createXAxisTicks" : "createYAxisTicks";
@@ -185,7 +197,7 @@ function makeCreate(channel) {
     const config = { scale, position: defaultAxisPosition(channel), length: DEFAULTS.length, color: DEFAULTS.color, lineWidth: DEFAULTS.lineWidth, ...options, inferredValues: inferredValues !== undefined, mode: Object.hasOwn(options, "values") ? "values" : "count" };
     if (config.mode === "values") delete config.count; else config.count ??= DEFAULTS.count;
     validateConfig(channel, config); geometry(this, channel, config);
-    return this.editSemantic({ property: `guide.axis.${channel}.scale`, value: scale })
+    const next = this.editSemantic({ property: `guide.axis.${channel}.scale`, value: scale })
       .createGraphics({
         id,
         type: "line",
@@ -193,10 +205,11 @@ function makeCreate(channel) {
         ...resolvePlotGraphicPlacement(this)
       })
       ._withGuideConfig(channel, config)[edit]();
+    return applyMaterializationPlan(next, planAxisTickGridRematerialization(next, channel));
   }));
 }
 
-const createXAxisTicks = makeCreate("x"), createYAxisTicks = makeCreate("y");
+const createXAxisTicks = /* @__PURE__ */ makeCreate("x"), createYAxisTicks = /* @__PURE__ */ makeCreate("y");
 export function registerAxisTickActions(Class) {
   Class.prototype.editXAxisTicks = editXAxisTicks; Class.prototype.editYAxisTicks = editYAxisTicks;
   Class.prototype.createXAxisTicks = createXAxisTicks; Class.prototype.createYAxisTicks = createYAxisTicks;

package/src/actions/guides/axes/titles.js

@@ -7,7 +7,7 @@ import {
   validateNonEmptyString,
   validateNonNegativeFinite
 } from "../../../core/validation.js";
-import { resolveGraphicBounds } from "../../../layout/canvas.js";
+import { resolveGuideCoordinateBounds } from "../../../materialization/coordinateBounds.js";
 import {
   isTransformedScaleType,
   mapContinuousScaleValues,
@@ -36,7 +36,7 @@ import { resolveConcreteGraphicBounds } from
 import { validateAxisTextStyle } from "./labels.js";
 import { resolveRotation } from "../../../grammar/rotation.js";
 
-function titleBounds(geometry, config, text) {
+function titleBounds(geometry, config, text, profile) {
   return resolveTextBounds({
     ...geometry,
     text,
@@ -46,14 +46,18 @@ function titleBounds(geometry, config, text) {
     textAlign: "center",
     textBaseline: "middle",
     rotation: config.rotation
-  });
+  }, profile);
 }
 
 function inferredTitleOffset(program, channel, config) {
-  const plot = resolveGraphicBounds(program);
+  const plot = resolveGuideCoordinateBounds(program, {
+    coordinate: program.semanticSpec.guides.axis?.[channel]?.coordinate,
+    scale: config.scale,
+    channel
+  });
   const canvas = findCanvasGraphic(program)?.properties;
   const labels = program.graphicSpec.objects[`${channel}AxisLabels`]
-    ? resolveConcreteGraphicBounds(program.graphicSpec, `${channel}AxisLabels`)
+    ? resolveConcreteGraphicBounds(program.graphicSpec, `${channel}AxisLabels`, program.materializationConfigs.textMetrics)
     : undefined;
   const preferred = channel === "x" ? 42 : 52;
   if (!plot || !canvas || !labels) return preferred;
@@ -67,7 +71,7 @@ function inferredTitleOffset(program, channel, config) {
     position: config.position,
     along: 0,
     offset: preferred
-  }), config, program.semanticSpec.guides.axis?.[channel]?.title ?? "");
+  }), config, program.semanticSpec.guides.axis?.[channel]?.title ?? "", program.materializationConfigs.textMetrics);
   const needed = positive
     ? labels[far] + 4 - bounds[near]
     : bounds[far] - labels[near] + 4;
@@ -151,7 +155,11 @@ export function inferAxisTitleText(program, channel, scaleId) {
 
 function resolveGeometry(program, channel, config) {
   const scale = program.resolvedScales[config.scale];
-  const bounds = resolveGraphicBounds(program);
+  const bounds = resolveGuideCoordinateBounds(program, {
+    coordinate: program.semanticSpec.guides.axis?.[channel]?.coordinate,
+    scale: config.scale,
+    channel
+  });
   const discrete = ["ordinal", "band", "point"].includes(scale?.type);
   if ((
     !["linear", "time", "ordinal", "band", "point"].includes(scale?.type) &&
@@ -183,13 +191,13 @@ function resolveGeometry(program, channel, config) {
     geometry,
     config,
     program.semanticSpec.guides.axis?.[channel]?.title ?? ""
-  );
+  , program.materializationConfigs.textMetrics);
   const canvas = findCanvasGraphic(program)?.properties;
   if (!canvas || !textBoundsFitCanvas(resolvedBounds, canvas)) {
     throw new Error(`The ${channel}-axis title does not fit the Canvas margin.`);
   }
   const labelsBounds = program.graphicSpec.objects[`${channel}AxisLabels`]
-    ? resolveConcreteGraphicBounds(program.graphicSpec, `${channel}AxisLabels`)
+    ? resolveConcreteGraphicBounds(program.graphicSpec, `${channel}AxisLabels`, program.materializationConfigs.textMetrics)
     : undefined;
   if (labelsBounds && textBoundsIntersect(resolvedBounds, labelsBounds)) {
     throw new Error(`The ${channel}-axis title overlaps the axis labels.`);
@@ -261,8 +269,8 @@ function makeEdit(channel) {
   }));
 }
 
-const editXAxisTitle = makeEdit("x");
-const editYAxisTitle = makeEdit("y");
+const editXAxisTitle = /* @__PURE__ */ makeEdit("x");
+const editYAxisTitle = /* @__PURE__ */ makeEdit("y");
 
 function makeCreate(channel) {
   const operation = names(channel);
@@ -319,8 +327,8 @@ function makeCreate(channel) {
   }));
 }
 
-const createXAxisTitle = makeCreate("x");
-const createYAxisTitle = makeCreate("y");
+const createXAxisTitle = /* @__PURE__ */ makeCreate("x");
+const createYAxisTitle = /* @__PURE__ */ makeCreate("y");
 
 export function registerAxisTitleActions(Class) {
   Class.prototype.createXAxisTitle = createXAxisTitle;