ggaction 0.0.13 → 0.0.15

package/src/actions/facets/derive.js

@@ -4,10 +4,14 @@ import { readQuantitativeField } from "../../grammar/scales/index.js";
 import { BAR_GRAINS, resolveBarGrain } from "../../grammar/bars/policy.js";
 import { resolveFacetScaleDomains } from "../../grammar/facets/scales.js";
 import {
+  applyLayerEmptyDataView,
   applyMaterializationPlan,
   planScaleGuideRematerialization
 } from "../../materialization/dependencies.js";
-import { getMarkMaterializationStep } from "../../materialization/marks/index.js";
+import {
+  getLayerScaleIds,
+  getMarkMaterializationStep
+} from "../../materialization/marks/index.js";
 import { buildMaterializationPlan } from "../../materialization/planner.js";
 import { requireDataset } from "../../selectors/datasets.js";
 import { requireLayer } from "../../selectors/layers.js";
@@ -56,7 +60,7 @@ function applySharedHistogramBoundaries(program, layerId, boundaries) {
   });
 }
 
-function deriveCellProgram(
+function buildFacetCellCandidate(
   base,
   definition,
   cell,
@@ -81,12 +85,6 @@ function deriveCellProgram(
     });
     source = id;
   }
-  if (requireDataset(child, cell.data).values.length === 0) {
-    while (child.semanticSpec.layers.length > 0) {
-      child = child.removeMark({ target: child.semanticSpec.layers[0].id });
-    }
-    return child;
-  }
   const datasets = new Map([[definition.data, cell.data]]);
   for (const replay of definition.dependencies.replay) {
     const source = datasets.get(replay.source);
@@ -108,6 +106,7 @@ function deriveCellProgram(
     });
     datasets.set(replay.id, id);
   }
+  const reboundData = new Map();
   for (const layer of definition.dependencies.layers) {
     const data = datasets.get(layer.data);
     if (data === undefined) {
@@ -115,6 +114,14 @@ function deriveCellProgram(
         `Facet layer "${layer.id}" has no replayed dataset in cell "${cell.id}".`
       );
     }
+    reboundData.set(layer.id, data);
+    const statistical = child.markConfigs[layer.id]?.statisticalReference;
+    if (statistical !== undefined) {
+      child = child._withMarkConfig(layer.id, {
+        ...child.markConfigs[layer.id],
+        statisticalReference: { ...statistical, dataId: data }
+      });
+    }
     child = child.rebindLayerData({ id: layer.id, data });
     child = applySharedHistogramBoundaries(
       child,
@@ -134,20 +141,35 @@ function deriveCellProgram(
     }
     child = child.rebindGradientPlotProfile({ id, profile, source });
   }
-  const scaleIds = [...new Set(child.semanticSpec.layers.flatMap(layer =>
-    Object.values(layer.encoding ?? {})
-      .map(encoding => encoding?.scale)
-      .filter(id => id !== undefined)
-  ))];
-  return applyMaterializationPlan(child, buildMaterializationPlan({
+  const primaryLayers = definition.dependencies.primaryLayers ??
+    definition.dependencies.layers.map(layer => layer.id);
+  const populated = primaryLayers.some(id => {
+    const data = reboundData.get(id);
+    return data !== undefined && requireDataset(child, data).values.length > 0;
+  });
+  if (!populated) {
+    for (const layer of definition.dependencies.layers) {
+      child = applyLayerEmptyDataView(child, layer.id);
+    }
+    return { program: child, populated: false };
+  }
+  const scaleIds = [...new Set(child.semanticSpec.layers.flatMap(getLayerScaleIds))];
+  const program = applyMaterializationPlan(child, buildMaterializationPlan({
     scales: scaleIds.map(id => ({
       op: "rematerializeScale",
       args: { id, guides: false, marks: false }
     }))
   }));
+  return { program, populated: true };
 }
 
-function applyResolvedDomains(program, childId, resolution, baseResolved) {
+function applyResolvedDomains(
+  program,
+  childId,
+  resolution,
+  baseResolved,
+  { marks: materializeMarks = true } = {}
+) {
   let next = program;
   for (const [id, scaleResolution] of Object.entries(resolution.scales)) {
     const current = next.resolvedScales[id];
@@ -157,19 +179,22 @@ function applyResolvedDomains(program, childId, resolution, baseResolved) {
     const shared = scaleResolution.policy === "shared"
       ? baseResolved?.[id]
       : undefined;
+    const semanticDomain = findSemanticScale(next, id)?.domain;
+    const domain = scaleResolution.childDomains[childId] ??
+      scaleResolution.domain ?? semanticDomain;
     next = next._withResolvedScale(id, {
       ...current,
       ...shared,
-      domain: scaleResolution.childDomains[childId]
+      domain
     });
   }
-  const marks = next.semanticSpec.layers.flatMap(layer => {
+  const marks = materializeMarks ? next.semanticSpec.layers.flatMap(layer => {
     const step = getMarkMaterializationStep(next, layer);
     if (step === undefined) return [];
-    return ["bar", "line", "area"].includes(layer.mark?.type)
+    return ["bar", "line", "area", "arc"].includes(layer.mark?.type)
       ? [{ ...step, args: { ...step.args, scales: false } }]
       : [step];
-  });
+  }) : [];
   const guides = Object.keys(resolution.scales).flatMap(id =>
     planScaleGuideRematerialization(next, id)
   );
@@ -179,6 +204,22 @@ function applyResolvedDomains(program, childId, resolution, baseResolved) {
   );
 }
 
+function materializeFacetCell(
+  child,
+  childId,
+  resolution,
+  baseResolved,
+  populated
+) {
+  return applyResolvedDomains(
+    child,
+    childId,
+    resolution,
+    baseResolved,
+    { marks: populated }
+  );
+}
+
 export function deriveFacetChildren(
   base,
   definition,
@@ -196,16 +237,23 @@ export function deriveFacetChildren(
   const bins = xPolicy === "shared"
     ? sharedHistogramBoundaries(template)
     : new Map();
-  const independentlyResolved = Object.fromEntries(definition.cells.map(cell => [
+  const candidates = Object.fromEntries(definition.cells.map(cell => [
     cell.id,
-    deriveCellProgram(template, definition, cell, bins, scales)
+    buildFacetCellCandidate(template, definition, cell, bins, scales)
   ]));
+  const independentlyResolved = Object.fromEntries(Object.entries(candidates).map(
+    ([id, candidate]) => [id, candidate.program]
+  ));
+  const populatedIds = new Set(Object.entries(candidates).flatMap(
+    ([id, candidate]) => candidate.populated ? [id] : []
+  ));
   return resolveFacetChildrenScales(
     template,
     definition.cells.map(cell => cell.id),
     independentlyResolved,
     scales,
-    closeInheritedAction
+    closeInheritedAction,
+    populatedIds
   );
 }
 
@@ -214,14 +262,18 @@ export function resolveFacetChildrenScales(
   cellIds,
   independentlyResolved,
   scales = {},
-  closeInheritedAction = false
+  closeInheritedAction = false,
+  populatedIds = undefined
 ) {
   const populated = Object.fromEntries(cellIds.flatMap(id => {
     const child = independentlyResolved[id];
     if (child === undefined) {
       throw new Error(`Facet derivation is missing child "${id}".`);
     }
-    return child.semanticSpec.layers.length > 0 ? [[id, child]] : [];
+    const populated = populatedIds === undefined
+      ? child.semanticSpec.layers.length > 0
+      : populatedIds.has(id);
+    return populated ? [[id, child]] : [];
   }));
   if (Object.keys(populated).length === 0) {
     throw new Error("Facet derivation requires at least one populated cell.");
@@ -235,17 +287,30 @@ export function resolveFacetChildrenScales(
     scales,
     template.resolvedScales
   );
+  const emptyIds = cellIds.filter(id => !Object.hasOwn(populated, id));
+  const scalesById = new Map(template.semanticSpec.scales.map(scale => [scale.id, scale]));
+  for (const childId of emptyIds) {
+    const unresolved = Object.entries(resolution.scales).find(([id, value]) =>
+      value.policy === "independent" && scalesById.get(id)?.domain === "auto"
+    );
+    if (unresolved !== undefined) {
+      throw new Error(
+        `Facet child "${childId}" cannot resolve independent scale "${unresolved[0]}" from an empty partition.`
+      );
+    }
+  }
   const resolvedChildren = Object.fromEntries(
     cellIds.map(id => {
       const child = independentlyResolved[id];
       if (child.semanticSpec.layers.length === 0) {
         return [id, closeInheritedAction ? child._exitAction() : child];
       }
-      const resolved = applyResolvedDomains(
+      const resolved = materializeFacetCell(
         child,
         id,
         resolution,
-        template.resolvedScales
+        template.resolvedScales,
+        Object.hasOwn(populated, id)
       );
       return [id, closeInheritedAction ? resolved._exitAction() : resolved];
     })

package/src/actions/gradientPlots/components.js

@@ -2,6 +2,10 @@ import { assertGuideOptions, guideConflict } from "../guides/reuse.js";
 import { action } from "../../core/action.js";
 import { validateKeys } from "../../core/validation.js";
 import { GRADIENT_PROFILE_FIELDS } from "../../grammar/gradientProfile.js";
+import {
+  requestedStrokeDetails,
+  STROKE_STYLE_PROPERTIES
+} from "../../grammar/strokeStyle.js";
 import { resolveGraphicBounds } from "../../layout/canvas.js";
 import { findLayer } from "../../selectors/layers.js";
 import { createDensityLegendPaint } from "./paint.js";
@@ -9,7 +13,7 @@ import { createDensityLegendPaint } from "./paint.js";
 const CENTER_OPTIONS = Object.freeze([
   "id", "owner", "data", "category", "categoryType", "coordinate",
   "categoryScale", "measureScale", "orientation", "size", "stroke",
-  "strokeWidth"
+  "strokeWidth", ...STROKE_STYLE_PROPERTIES
 ]);
 const LEGEND_OPTIONS = Object.freeze(["owner", "title", "position"]);
 
@@ -23,7 +27,11 @@ export const createGradientPlotCenter = action(
     const categoryAction = args.orientation === "vertical" ? "encodeX" : "encodeY";
     const measureAction = args.orientation === "vertical" ? "encodeY" : "encodeX";
     const spanOrientation = args.orientation === "vertical" ? "horizontal" : "vertical";
-    let next = this.createRuleMark({ id: args.id, data: args.data });
+    let next = this.createRuleMark({
+      id: args.id,
+      data: args.data,
+      ...requestedStrokeDetails(args, "createGradientPlotCenter")
+    });
     next = next[categoryAction]({
       target: args.id,
       field: args.category,

package/src/actions/gradientPlots/edit.js

@@ -7,6 +7,7 @@ import { findDataset } from "../../selectors/datasets.js";
 import { findLayer } from "../../selectors/layers.js";
 import { removeOwnedMark } from "../marks/remove.js";
 import { GRADIENT_PROFILE_FIELDS } from "../../grammar/gradientProfile.js";
+import { requestedStrokeDetails } from "../../grammar/strokeStyle.js";
 import { removeGradientPlotLegend } from "./components.js";
 import {
   resolveDistributionRoles,
@@ -40,6 +41,13 @@ function removeCenter(program, id) {
   return removeOwnedMark(program, id, true);
 }
 
+function editCenterStrokeDetails(program, id, center) {
+  const details = requestedStrokeDetails(center, "Gradient plot center");
+  return Object.keys(details).length === 0
+    ? program
+    : program.editRuleMark({ target: id, ...details });
+}
+
 function roleCandidate(program, owner, current, args) {
   return {
     source: Object.hasOwn(args, "data")
@@ -219,10 +227,11 @@ export const editGradientPlot = action(
             orientation: candidate.orientation,
             size: spanSize,
             stroke: center.stroke,
-            strokeWidth: center.strokeWidth
+            strokeWidth: center.strokeWidth,
+            ...requestedStrokeDetails(center, "Gradient plot center")
           });
         } else if (retainedCenter) {
-          next = next
+          next = editCenterStrokeDetails(next, current.centerId, center)
             .encodeStroke({ target: current.centerId, value: center.stroke })
             .encodeStrokeWidth({
               target: current.centerId,
@@ -291,10 +300,11 @@ export const editGradientPlot = action(
         orientation: current.orientation,
         size: 1,
         stroke: center.stroke,
-        strokeWidth: center.strokeWidth
+        strokeWidth: center.strokeWidth,
+        ...requestedStrokeDetails(center, "Gradient plot center")
       });
     } else if (center !== false) {
-      next = next
+      next = editCenterStrokeDetails(next, current.centerId, center)
         .encodeStroke({ target: current.centerId, value: center.stroke })
         .encodeStrokeWidth({ target: current.centerId, value: center.strokeWidth });
     }

package/src/actions/gradientPlots/materialize.js

@@ -4,6 +4,7 @@ import { action } from "../../core/action.js";
 import { validateUserId } from "../../core/identifiers.js";
 import { isPlainObject } from "../../core/immutable.js";
 import { GRADIENT_PROFILE_FIELDS } from "../../grammar/gradientProfile.js";
+import { requestedStrokeDetails } from "../../grammar/strokeStyle.js";
 import {
   mapContinuousScaleValues,
   mapOrdinalPositionValues
@@ -248,7 +249,8 @@ export const materializeGradientPlot = action(
         orientation,
         size: Math.max(1, categoryScale.bandwidth * config.width.band - 16),
         stroke: config.center.stroke,
-        strokeWidth: config.center.strokeWidth
+        strokeWidth: config.center.strokeWidth,
+        ...requestedStrokeDetails(config.center, "Gradient plot center")
       });
     }
     const guides = config.guides;

package/src/actions/gradientPlots/options.js

@@ -5,6 +5,10 @@ import {
   validateUnitInterval
 } from "../../core/validation.js";
 import { normalizePalette } from "../../grammar/palettes.js";
+import {
+  requestedStrokeDetails,
+  STROKE_STYLE_PROPERTIES
+} from "../../grammar/strokeStyle.js";
 
 export const GRADIENT_PLOT_OPTIONS = Object.freeze([
   "id", "target", "data", "x", "y", "coordinate", "density", "width",
@@ -90,7 +94,7 @@ export function resolveGradientCenter(
   if (value === false) return false;
   const options = plain(
     value,
-    ["type", "stroke", "strokeWidth"],
+    ["type", "stroke", "strokeWidth", ...STROKE_STYLE_PROPERTIES],
     "center",
     operation
   );
@@ -108,7 +112,11 @@ export function resolveGradientCenter(
       : validateNonNegativeFinite(
           options.strokeWidth,
           `${operation} center.strokeWidth`
-        )
+        ),
+    ...requestedStrokeDetails(
+      { ...(previous ?? {}), ...options },
+      `${operation} center`
+    )
   });
 }
 

package/src/actions/guides/applicability.js

@@ -51,6 +51,8 @@ export function hasInferableLegend(program, layers = program.semanticSpec.layers
       isOpacityLegendLayer(layer) ||
       (layer.mark?.type === "point" &&
         layer.encoding?.size?.scale !== undefined) ||
+      (layer.mark?.type === "point" &&
+        layer.encoding?.stroke?.scale !== undefined) ||
       (layer.mark?.type === "point" &&
         layer.encoding?.color?.scale !== undefined &&
         (layer.encoding?.shape?.scale !== undefined ||
@@ -58,11 +60,15 @@ export function hasInferableLegend(program, layers = program.semanticSpec.layers
             findSemanticScale(program, layer.encoding.color.scale)?.type
           ))) ||
       (layer.mark?.type === "line" &&
-        ["color", "strokeDash"].some(
+        ["color", "stroke", "strokeDash"].some(
           channel => layer.encoding?.[channel]?.scale !== undefined
         )) ||
       (["bar", "area", "arc", "rect"].includes(layer.mark?.type) &&
-        layer.encoding?.color?.scale !== undefined)
+        ["color", "stroke"].some(
+          channel => layer.encoding?.[channel]?.scale !== undefined
+        )) ||
+      (["rule", "tick"].includes(layer.mark?.type) &&
+        layer.encoding?.stroke?.scale !== undefined)
     )
   );
 }

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.`);
@@ -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({
@@ -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);
@@ -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);

package/src/actions/guides/axes/lines.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 { DEFAULT_COLORS } from "../../../theme/defaults.js";
 import {
   defaultAxisPosition,
@@ -53,7 +53,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}".`);

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/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"]);

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

@@ -7,7 +7,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 +69,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) &&

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,
@@ -50,7 +50,11 @@ function titleBounds(geometry, config, text) {
 }
 
 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`)
@@ -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) &&