waveform-analysis 0.1.72 → 0.1.74

package/src/components/core/layout.ts

@@ -83,7 +83,7 @@ export function formatYAxisTickLabel(
   return label
 }
 
-/** Scientific multipliers retain their rendered position but do not reserve horizontal space. */
+/** Name spacing excludes scientific multipliers; outer clearance measures the full label. */
 export function formatYAxisTickLayoutLabel(
   value: number,
   domain: [number, number],
@@ -102,6 +102,7 @@ export interface YAxisSeriesGroup {
   domain: [number, number]
   fixed: boolean
   maximumTick?: number
+  minimumTick?: number
 }
 
 export interface YAxisSlot {
@@ -196,9 +197,12 @@ export function resolveRenderedYAxisSeriesGroups(
     track.visibleSeries.length || !track.series.length
       ? track
       : { ...track, visibleSeries: track.series }
-  return resolveYAxisSeriesGroups(axisTrack, overlayMode, yDomain, yDomains).map((group) =>
-    applyYAxisPadding(group, viewportYDomain, padding),
-  )
+  return resolveYAxisSeriesGroups(axisTrack, overlayMode, yDomain, yDomains).map((group) => {
+    const padded = applyYAxisPadding(group, viewportYDomain, padding)
+    return track.visibleSeries.length
+      ? padded
+      : { ...padded, maximumTick: undefined, minimumTick: undefined }
+  })
 }
 
 export function axisTextMetrics(
@@ -210,25 +214,41 @@ export function axisTextMetrics(
   includeWithoutLastTick = false,
   measureTextWidth?: (text: string) => number,
   maximumTick?: number,
-): { tickTextWidth: number } {
+  minimumTick?: number,
+): { tickTextWidth: number; titleTextWidth: number } {
   const resolvedTicks = tickValues
     ? { domain, values: tickValues }
     : resolveYAxisTicks(domain, tickCount, nice)
-  const tickValueSets = [withMaximumTick(resolvedTicks.values, maximumTick)]
+  const inRange = (value?: number) =>
+    value !== undefined && value >= resolvedTicks.domain[0] && value <= resolvedTicks.domain[1]
+      ? value
+      : undefined
+  const tickValueSets = [
+    withMaximumTick(resolvedTicks.values, inRange(maximumTick), inRange(minimumTick)),
+  ]
   if (includeWithoutLastTick && resolvedTicks.values.length > 1) {
     tickValueSets.push(resolvedTicks.values.slice(0, -1))
   }
-  const maximumTickWidth = Math.max(
-    Y_AXIS_CHARACTER_WIDTH,
-    ...tickValueSets.flatMap((values) =>
-      values.map((value) => {
-        const text = formatYAxisTickLayoutLabel(value, resolvedTicks.domain, values, unit)
-        return measureTextWidth ? measureTextWidth(text) : text.length * Y_AXIS_CHARACTER_WIDTH
-      }),
-    ),
+  const width = (text: string) =>
+    measureTextWidth ? measureTextWidth(text) : text.length * Y_AXIS_CHARACTER_WIDTH
+  const labels = tickValueSets.flatMap((values) =>
+    values.map((value) => ({
+      full: width(formatYAxisTickLabel(value, resolvedTicks.domain, values, unit)),
+      title: width(formatYAxisTickLayoutLabel(value, resolvedTicks.domain, values, unit)),
+    })),
   )
+  // Collision handling can move metadata to any surviving tick in compact layouts.
+  if (includeWithoutLastTick) {
+    tickValueSets[0]!.forEach((value) => {
+      labels.push({
+        full: width(formatYAxisTickLabel(value, resolvedTicks.domain, [value], unit)),
+        title: width(formatYAxisTickLayoutLabel(value, resolvedTicks.domain, [value], unit)),
+      })
+    })
+  }
   return {
-    tickTextWidth: maximumTickWidth,
+    tickTextWidth: Math.max(Y_AXIS_CHARACTER_WIDTH, ...labels.map((label) => label.full)),
+    titleTextWidth: Math.max(Y_AXIS_CHARACTER_WIDTH, ...labels.map((label) => label.title)),
   }
 }
 
@@ -237,12 +257,16 @@ export function measureYAxisGroupClearance(
   tickCount?: number,
   nice = true,
 ): number {
+  const { tickTextWidth, titleTextWidth } = axisTextMetrics(
+    group.domain,
+    nice,
+    undefined,
+    group.seriesList[0]?.unit,
+    tickCount,
+  )
   return (
-    axisTextMetrics(group.domain, nice, undefined, group.seriesList[0]?.unit, tickCount)
-      .tickTextWidth +
+    Math.max(tickTextWidth, titleTextWidth + Y_AXIS_LABEL_GAP + Y_AXIS_LABEL_BAND_WIDTH) +
     Y_AXIS_TICK_PADDING +
-    Y_AXIS_LABEL_GAP +
-    Y_AXIS_LABEL_BAND_WIDTH +
     Y_AXIS_OUTER_PADDING
   )
 }
@@ -301,6 +325,7 @@ export function buildYAxisSlots(
     typeof padding === 'object' ? padding.labelTextStyle : undefined,
   )
   const widths = new Map<string, number>()
+  const titleWidths = new Map<string, number>()
   tracks.forEach((track) => {
     const sideIndexes = { left: 0, right: 0 }
     resolveRenderedYAxisSeriesGroups(
@@ -313,7 +338,7 @@ export function buildYAxisSlots(
     ).forEach((group) => {
       const sideIndex = sideIndexes[group.side]++
       const key = `${group.side}:${sideIndex}`
-      const width = axisTextMetrics(
+      const { tickTextWidth, titleTextWidth } = axisTextMetrics(
         group.domain,
         nice,
         undefined,
@@ -322,8 +347,10 @@ export function buildYAxisSlots(
         includeWithoutLastTick,
         measureTextWidth,
         group.maximumTick,
-      ).tickTextWidth
-      widths.set(key, Math.max(widths.get(key) ?? Y_AXIS_CHARACTER_WIDTH, width))
+        group.minimumTick,
+      )
+      widths.set(key, Math.max(widths.get(key) ?? Y_AXIS_CHARACTER_WIDTH, tickTextWidth))
+      titleWidths.set(key, Math.max(titleWidths.get(key) ?? Y_AXIS_CHARACTER_WIDTH, titleTextWidth))
     })
   })
 
@@ -336,15 +363,14 @@ export function buildYAxisSlots(
       .sort((first, second) => first - second)
     sideIndexes.forEach((sideIndex) => {
       const tickTextWidth = widths.get(`${side}:${sideIndex}`) ?? Y_AXIS_CHARACTER_WIDTH
+      const titleTextWidth = titleWidths.get(`${side}:${sideIndex}`) ?? Y_AXIS_CHARACTER_WIDTH
       const axisOffset = side === 'left' && clearance.left > 0 ? -clearance.left : clearance[side]
       const labelDistance =
-        tickTextWidth + Y_AXIS_TICK_PADDING + Y_AXIS_LABEL_GAP + labelBandWidth / 2
+        titleTextWidth + Y_AXIS_TICK_PADDING + Y_AXIS_LABEL_GAP + labelBandWidth / 2
       const labelOffset = axisOffset + labelDistance * (side === 'left' ? -1 : 1)
       const fullClearance =
-        tickTextWidth +
+        Math.max(tickTextWidth, titleTextWidth + Y_AXIS_LABEL_GAP + labelBandWidth) +
         Y_AXIS_TICK_PADDING +
-        Y_AXIS_LABEL_GAP +
-        labelBandWidth +
         Y_AXIS_OUTER_PADDING
       slots.push({ side, sideIndex, axisOffset, labelOffset, clearance: fullClearance })
       clearance[side] += fullClearance

package/src/components/core/trackLayoutBuilder.ts

@@ -163,8 +163,14 @@ export function buildTrackLayouts(options: BuildTrackLayoutsOptions): TrackLayou
         group.maximumTick <= resolvedTicks.domain[1]
           ? group.maximumTick
           : undefined
-      const tickValues = withMaximumTick(majorTicks, maximumTick)
-      const { tickTextWidth } = axisTextMetrics(
+      const minimumTick =
+        group.minimumTick !== undefined &&
+        group.minimumTick >= resolvedTicks.domain[0] &&
+        group.minimumTick <= resolvedTicks.domain[1]
+          ? group.minimumTick
+          : undefined
+      const tickValues = withMaximumTick(majorTicks, maximumTick, minimumTick)
+      const { tickTextWidth, titleTextWidth } = axisTextMetrics(
         scale.domain() as [number, number],
         false,
         tickValues,
@@ -172,10 +178,13 @@ export function buildTrackLayouts(options: BuildTrackLayoutsOptions): TrackLayou
         tickCount,
       )
       const clearance =
-        tickTextWidth +
+        Math.max(
+          tickTextWidth,
+          titleTextWidth +
+            Y_AXIS_LABEL_GAP +
+            resolveYAxisLabelBandWidth(options.yAxisPadding?.labelTextStyle),
+        ) +
         Y_AXIS_TICK_PADDING +
-        Y_AXIS_LABEL_GAP +
-        resolveYAxisLabelBandWidth(options.yAxisPadding?.labelTextStyle) +
         Y_AXIS_OUTER_PADDING
       const slot = options.yAxisSlots?.find(
         (candidate) => candidate.side === group.side && candidate.sideIndex === sideIndex,
@@ -186,7 +195,7 @@ export function buildTrackLayouts(options: BuildTrackLayoutsOptions): TrackLayou
           ? -sideOffsets.left
           : cell.width + sideOffsets.right
       const labelDistance =
-        tickTextWidth +
+        titleTextWidth +
         Y_AXIS_TICK_PADDING +
         Y_AXIS_LABEL_GAP +
         resolveYAxisLabelBandWidth(options.yAxisPadding?.labelTextStyle) / 2
@@ -203,6 +212,7 @@ export function buildTrackLayouts(options: BuildTrackLayoutsOptions): TrackLayou
         labelX,
         scale,
         maximumTick,
+        minimumTick,
         majorTicks,
         minorTicks: buildMinorTicks(majorTicks, 2),
         tickValues,

package/src/components/core/types.ts

@@ -28,6 +28,7 @@ export interface DisplaySeries {
   source?: WaveformPointSource
   xDomain: [number, number]
   rawYMaximum?: number
+  rawYMinimum?: number
   yDomain: [number, number]
   hasErrorPoints: boolean
 }
@@ -54,6 +55,7 @@ export interface TrackSeriesPath {
 
 export interface WaveformYAxisLayout {
   maximumTick?: number
+  minimumTick?: number
   index: number
   side: 'left' | 'right'
   x: number

package/src/components/core/useWaveformData.ts

@@ -26,6 +26,7 @@ export interface PreparedWaveformSeries {
   source: WaveformPointSource
   xDomain: [number, number]
   rawYMaximum?: number
+  rawYMinimum?: number
   yDomain: [number, number]
   hasErrorPoints: boolean
 }
@@ -50,6 +51,7 @@ export function prepareWaveformSeries(data: WaveformData): PreparedWaveformSerie
           : [],
       ),
       rawYMaximum: Number.isFinite(sourceMetrics.yMaximum) ? sourceMetrics.yMaximum : undefined,
+      rawYMinimum: Number.isFinite(sourceMetrics.yMinimum) ? sourceMetrics.yMinimum : undefined,
       hasErrorPoints: sourceMetrics.hasErrorPoints,
     }
   })

package/src/components/core/useWaveformLayout.ts

@@ -17,6 +17,7 @@ import type { ResolvedWaveformChartProps } from './waveformChartTypes'
 import { applyXDomainStrategy } from './xDomain'
 import { alignIntegerZoomDomain, normalizeIntegerZoomDomain } from '../interaction/integerZoom'
 import { resolveViewportYDomains } from './yAxisLayoutMetrics'
+import { useExtremaTickViewport } from '../interaction/useExtremaTickViewport'
 import { useWaveformYAxisLayout } from './useWaveformYAxisLayout'
 import type { useWaveformAnnotationInteraction } from '../annotation'
 interface LayoutContext {
@@ -279,6 +280,15 @@ export function useWaveformLayout(context: LayoutContext) {
       showEmptyTracks: hasWaveformData.value,
     }),
   )
+  useExtremaTickViewport(
+    () =>
+      Number(props.axes?.y?.maximumTickVisible !== false) * 2 +
+      Number(props.axes?.y?.minimumTickVisible !== false),
+    innerWidth,
+    trackLayouts,
+    sharedTransform,
+    independentTransforms,
+  )
   const annotationLayoutsForTrack = (track: TrackLayout): AnnotationTrackLayout[] =>
     track.seriesList.map((series) => ({
       ...track,

package/src/components/core/yAxisLayoutMetrics.ts

@@ -60,28 +60,37 @@ export function resolveYAxisLayoutMetrics(
         padding,
       ),
     )
-    .map(
-      (group) =>
-        axisTextMetrics(
-          group.domain,
-          nice,
-          undefined,
-          showUnits ? group.seriesList[0]?.unit : undefined,
-          tickCount,
-          compact,
-          measureTextWidth,
-          group.maximumTick,
-        ).tickTextWidth,
+    .map((group) =>
+      axisTextMetrics(
+        group.domain,
+        nice,
+        undefined,
+        showUnits ? group.seriesList[0]?.unit : undefined,
+        tickCount,
+        compact,
+        measureTextWidth,
+        group.maximumTick,
+        group.minimumTick,
+      ),
     )
-  const tickTextWidth = Math.max(Y_AXIS_CHARACTER_WIDTH, ...axisText)
+  const tickTextWidth = Math.max(
+    Y_AXIS_CHARACTER_WIDTH,
+    ...axisText.map((text) => text.tickTextWidth),
+  )
+  const titleTextWidth = Math.max(
+    Y_AXIS_CHARACTER_WIDTH,
+    ...axisText.map((text) => text.titleTextWidth),
+  )
   const tickClearance = tickTextWidth + Y_AXIS_TICK_PADDING + Y_AXIS_OUTER_PADDING
   const labelCenterX = -(
     Y_AXIS_TICK_PADDING +
-    tickTextWidth +
+    titleTextWidth +
     Y_AXIS_LABEL_GAP +
     labelBandWidth / 2
   )
   const fullClearance =
-    tickTextWidth + Y_AXIS_TICK_PADDING + Y_AXIS_LABEL_GAP + labelBandWidth + Y_AXIS_OUTER_PADDING
+    Math.max(tickTextWidth, titleTextWidth + Y_AXIS_LABEL_GAP + labelBandWidth) +
+    Y_AXIS_TICK_PADDING +
+    Y_AXIS_OUTER_PADDING
   return { tickClearance, fullClearance, labelCenterX }
 }

package/src/components/core/yAxisPadding.ts

@@ -14,26 +14,46 @@ export function applyYAxisPadding(
   viewport: [number, number] | undefined,
   options: YAxisPaddingOptions | number,
 ): YAxisSeriesGroup {
-  if (group.fixed) return group
   const config = typeof options === 'number' ? { upperPaddingRatio: options } : options
+  if (group.fixed) return withYAxisExtremaTicks(group, config)
   const upper = paddingRatio(config?.upperPaddingEnabled, config?.upperPaddingRatio)
   const lower = paddingRatio(config?.lowerPaddingEnabled, config?.lowerPaddingRatio)
-  const maxima = group.seriesList.flatMap((series) =>
-    Number.isFinite(series.rawYMaximum) ? [series.rawYMaximum!] : [],
-  )
-  const maximumTick = upper > 0 && maxima.length ? Math.max(...maxima) : undefined
   const [a, b] = group.domain
   const span = b - a
   const min = lower > 0 ? a - span * lower : a
   const max = upper > 0 ? b + span * upper : b
+  return withYAxisExtremaTicks(
+    {
+      ...group,
+      domain: viewport ?? [Number.isFinite(min) ? min : a, Number.isFinite(max) ? max : b],
+    },
+    config,
+  )
+}
+
+function withYAxisExtremaTicks(
+  group: YAxisSeriesGroup,
+  options: YAxisPaddingOptions,
+): YAxisSeriesGroup {
+  const maxima = group.seriesList.flatMap((series) =>
+    Number.isFinite(series.rawYMaximum) ? [series.rawYMaximum!] : [],
+  )
+  const minima = group.seriesList.flatMap((series) =>
+    Number.isFinite(series.rawYMinimum) ? [series.rawYMinimum!] : [],
+  )
   return {
     ...group,
-    maximumTick,
-    domain: viewport ?? [Number.isFinite(min) ? min : a, Number.isFinite(max) ? max : b],
+    maximumTick:
+      options?.maximumTickVisible !== false && maxima.length ? Math.max(...maxima) : undefined,
+    minimumTick:
+      options?.minimumTickVisible !== false && minima.length ? Math.min(...minima) : undefined,
   }
 }
 
-export function withMaximumTick(values: number[], maximum?: number): number[] {
+export function withMaximumTick(values: number[], maximum?: number, minimum?: number): number[] {
+  if (minimum !== undefined && Number.isFinite(minimum)) {
+    values = [...values.filter((value) => !sameTick(value, minimum)), minimum].sort((a, b) => a - b)
+  }
   if (maximum === undefined || !Number.isFinite(maximum)) return values
   return [...values.filter((value) => !sameTick(value, maximum)), maximum].sort((a, b) => a - b)
 }

package/src/components/core/yAxisTitleLayout.ts

@@ -1,13 +1,9 @@
 import { formatYAxisTickLayoutLabel } from './layout'
 import type { TrackLayout, WaveformYAxisLayout } from './types'
 import type { WaveformYAxisLabelTextStyle } from '../../types'
-import { resolveYAxisLabelBandWidth, resolveYAxisLabelFontSize } from './yAxisLabelStyle'
+import { resolveYAxisLabelBandWidth } from './yAxisLabelStyle'
 import { Y_AXIS_CHARACTER_WIDTH, Y_AXIS_TICK_PADDING } from './yAxisConstants'
 
-// Match the 11px ticks in WaveformTrack.css.
-const TICK_FONT_SIZE = 11
-const TEXT_GAP = 2
-
 interface TitleLayoutOptions {
   labelTextStyle?: WaveformYAxisLabelTextStyle
   showUnits?: boolean
@@ -15,52 +11,20 @@ interface TitleLayoutOptions {
   measureTextWidth?: (text: string) => number
 }
 
-function estimateTitleWidth(title: string, fontSize: number): number {
-  return Array.from(title).reduce((width, character) => {
-    // Latin labels average well below one em; full-width characters occupy one em.
-    const em = /[\u2e80-\u9fff\uf900-\ufaff\uff01-\uff60]/u.test(character)
-      ? 1
-      : /[MW@%]/u.test(character)
-        ? 0.95
-        : /[ilI1., :;|'!]/u.test(character)
-          ? 0.4
-          : 0.65
-    return width + em * fontSize
-  }, 0)
-}
-
 type TitleTrack = Pick<TrackLayout, 'height' | 'column' | 'yAxes'>
 
-function titleDistance(
-  track: TitleTrack,
-  axis: WaveformYAxisLayout,
-  yLabel: string | undefined,
-  options: TitleLayoutOptions,
-): number {
+function titleDistance(axis: WaveformYAxisLayout, options: TitleLayoutOptions): number {
   const series = axis.seriesList[0]
-  const title = series?.name.trim() || yLabel || ''
-  const halfTitleHeight =
-    estimateTitleWidth(title, resolveYAxisLabelFontSize(options.labelTextStyle)) / 2
-  const titleTop = track.height / 2 - halfTitleHeight - TEXT_GAP
-  const titleBottom = track.height / 2 + halfTitleHeight + TEXT_GAP
-  const lowestTick = Math.min(...axis.tickValues)
-  const highestTick = Math.max(...axis.tickValues)
-  const tickWidths = axis.tickValues.flatMap((value) => {
-    // D3 places ticks at scale(value) + 0.5. The lowest label is bottom-aligned;
-    // all other labels are vertically centered using dy="0.32em".
-    const y = axis.scale(value) + 0.5
-    const isTopAligned = options.compact && value === highestTick
-    const top = y - (value === lowestTick ? TICK_FONT_SIZE : isTopAligned ? 0 : TICK_FONT_SIZE / 2)
-    const bottom =
-      value === lowestTick ? y : y + (isTopAligned ? TICK_FONT_SIZE : TICK_FONT_SIZE / 2)
-    if (bottom < titleTop || top > titleBottom) return []
+  // Reserve the widest tick, including extrema, regardless of the frame height.
+  // The layout formatter excludes scientific multipliers but retains the numeric label.
+  const tickWidths = axis.tickValues.map((value) => {
     const text = formatYAxisTickLayoutLabel(
       value,
       axis.scale.domain() as [number, number],
       axis.tickValues,
       options.showUnits === false ? undefined : series?.unit,
     )
-    return [options.measureTextWidth?.(text) ?? text.length * Y_AXIS_CHARACTER_WIDTH]
+    return options.measureTextWidth?.(text) ?? text.length * Y_AXIS_CHARACTER_WIDTH
   })
   // The title band leaves 4px beside each glyph.
   return (
@@ -72,7 +36,7 @@ function titleDistance(
 
 export function alignLeftYAxisTitles(
   layouts: TitleTrack[],
-  yLabel?: string,
+  _yLabel?: string,
   options: TitleLayoutOptions = {},
 ): void {
   const distances = new Map<string, number>()
@@ -81,11 +45,8 @@ export function alignLeftYAxisTitles(
     for (const axis of track.yAxes) {
       if (axis.side !== 'left') continue
       const key = `${track.column}:${leftIndex++}`
-      const distance = titleDistance(track, axis, yLabel, options)
-      // Compact slots already reserve every tick. Only move names inward, so
-      // alignment can never push them beyond the space reserved at the chart edge.
-      const boundedDistance = options.compact ? Math.min(axis.x - axis.labelX, distance) : distance
-      distances.set(key, Math.max(distances.get(key) ?? 0, boundedDistance))
+      const distance = titleDistance(axis, options)
+      distances.set(key, Math.max(distances.get(key) ?? 0, distance))
     }
   }
   for (const track of layouts) {

package/src/components/interaction/useExtremaTickViewport.ts

@@ -0,0 +1,43 @@
+import { watch, type ComputedRef, type ShallowRef } from 'vue'
+import type { ZoomTransform } from 'd3'
+
+import type { TrackLayout } from '../core/types'
+
+/** Keep X coordinates stable when toggling extrema changes the reserved Y-label width. */
+export function useExtremaTickViewport(
+  visible: () => number,
+  innerWidth: ComputedRef<number>,
+  tracks: ComputedRef<TrackLayout[]>,
+  sharedTransform: ShallowRef<ZoomTransform>,
+  independentTransforms: ShallowRef<ZoomTransform[]>,
+) {
+  const resizeTransform = (transform: ZoomTransform, previous: number, next: number) =>
+    previous > 0 && next > 0
+      ? transform.translate(((next / previous - 1) * transform.x) / transform.k, 0)
+      : transform
+
+  watch(
+    () => ({
+      visible: visible(),
+      width: innerWidth.value,
+      tracks: tracks.value.map((track) => ({
+        id: track.id,
+        index: track.index,
+        width: track.width,
+      })),
+    }),
+    (next, previous) => {
+      if (next.visible === previous.visible) return
+      sharedTransform.value = resizeTransform(sharedTransform.value, previous.width, next.width)
+      const transforms = [...independentTransforms.value]
+      next.tracks.forEach((track) => {
+        const prior = previous.tracks.find((item) => item.id === track.id)
+        const transform = transforms[track.index]
+        if (prior && transform) {
+          transforms[track.index] = resizeTransform(transform, prior.width, track.width)
+        }
+      })
+      independentTransforms.value = transforms
+    },
+  )
+}

package/src/components/rendering/WaveformTrack.vue

@@ -111,6 +111,7 @@ const frameInset = computed(() =>
       :show-units="showAxisUnits"
       :show-label-units="showLabelUnits"
       :hide-y-axis-titles="hideYAxisTitles"
+      :hide-overlapping-maximum-label="displayMode === 'compact'"
     />
 
     <component

package/src/components/rendering/WaveformTrackAxes.vue

@@ -21,6 +21,7 @@ interface Props {
   showUnits?: boolean
   showLabelUnits?: boolean
   hideYAxisTitles?: boolean
+  hideOverlappingMaximumLabel?: boolean
 }
 
 const props = withDefaults(defineProps<Props>(), { showUnits: true })
@@ -56,6 +57,7 @@ function renderAxes() {
     const element = yAxisElements.value[index]
     if (!element) return
     const unit = props.showUnits ? axis.seriesList[0]?.unit : undefined
+    const highestTick = Math.max(...axis.tickValues)
     const yAxis = (axis.side === 'left' ? axisLeft(axis.scale) : axisRight(axis.scale))
       .tickFormat((value) =>
         formatYAxisTickLabel(
@@ -78,11 +80,26 @@ function renderAxes() {
       .attr('y', null)
       .attr('dy', '0')
       .attr('dominant-baseline', 'central')
+      .attr('data-axis-maximum-label', (value) =>
+        props.hideOverlappingMaximumLabel && sameTick(value, highestTick) ? 'true' : null,
+      )
+      .attr('data-axis-minimum-label', (value) =>
+        props.hideOverlappingMaximumLabel && sameTick(value, Math.min(...axis.tickValues))
+          ? 'true'
+          : null,
+      )
+    selection
+      .attr('data-label-domain-min', axis.scale.domain()[0])
+      .attr('data-label-domain-max', axis.scale.domain()[1])
+      .attr('data-label-unit', unit ?? null)
     selection
       .selectAll<SVGGElement, number>('.tick')
       .attr('data-maximum-tick', (value) =>
         axis.maximumTick !== undefined && sameTick(value, axis.maximumTick) ? 'true' : null,
       )
+      .attr('data-minimum-tick', (value) =>
+        axis.minimumTick !== undefined && sameTick(value, axis.minimumTick) ? 'true' : null,
+      )
       .attr('data-tick-value', (value) => value)
       .attr('data-tick-y', (value) => axis.scale(value))
     selection
@@ -147,6 +164,7 @@ watch(
     () => props.axes?.x?.labelFormatter,
     () => props.axes?.x?.lineVisible,
     () => props.axes?.y?.lineVisible,
+    () => props.hideOverlappingMaximumLabel,
   ],
   async () => {
     await nextTick()