waveform-analysis 0.1.59 → 0.1.60

package/dist/types/components/core/layout.d.ts

@@ -3,6 +3,12 @@ import type { DisplaySeries, DisplayTrack, TrackLayout } from './types';
 import { type WaveformYDomain } from './yDomain';
 export { MAX_MULTI_Y_AXIS_COUNT } from './constants';
 export declare function resolveYAxisTickCount(_plotHeight: number, splitNumber?: number): number;
+export interface ResolvedYAxisTicks {
+    domain: [number, number];
+    values: number[];
+}
+export declare function resolveYAxisTicks(domain: [number, number], tickCount?: number, nice?: boolean): ResolvedYAxisTicks;
+export declare function formatYAxisTickLabel(value: number, domain: [number, number], tickValues: readonly number[], unit?: string): string;
 export interface YAxisSeriesGroup {
     index: number;
     side: 'left' | 'right';
@@ -19,7 +25,8 @@ export interface YAxisSlot {
 }
 export declare function buildYAxisSeriesGroups(track: DisplayTrack, overlayMode: WaveformOverlayMode): YAxisSeriesGroup[];
 export declare function resolveYAxisSeriesGroups(track: DisplayTrack, overlayMode: WaveformOverlayMode, yDomain?: WaveformYDomain, yDomains?: Record<string, WaveformYDomain>): YAxisSeriesGroup[];
-export declare function axisTextMetrics(domain: [number, number], nice?: boolean, tickValues?: number[], unit?: string, tickCount?: number): {
+export declare function resolveRenderedYAxisSeriesGroups(track: DisplayTrack, overlayMode: WaveformOverlayMode, yDomain?: WaveformYDomain, yDomains?: Record<string, WaveformYDomain>, viewportYDomains?: Record<string, [number, number]>): YAxisSeriesGroup[];
+export declare function axisTextMetrics(domain: [number, number], nice?: boolean, tickValues?: number[], unit?: string, tickCount?: number, includeWithoutLastTick?: boolean): {
     tickTextWidth: number;
 };
 export declare function measureYAxisGroupClearance(group: YAxisSeriesGroup, tickCount?: number, nice?: boolean): number;
@@ -31,7 +38,7 @@ export declare function measureTrackYAxisClearance(track: DisplayTrack, overlayM
  * Reserves stable Y-axis positions for every visible track on the current page.
  * Slots are ordered from the plot edge outward for each side.
  */
-export declare function buildYAxisSlots(tracks: readonly DisplayTrack[], overlayMode: WaveformOverlayMode, yDomain?: WaveformYDomain, yDomains?: Record<string, WaveformYDomain>, tickCount?: number, nice?: boolean): {
+export declare function buildYAxisSlots(tracks: readonly DisplayTrack[], overlayMode: WaveformOverlayMode, yDomain?: WaveformYDomain, yDomains?: Record<string, WaveformYDomain>, tickCount?: number, nice?: boolean, includeWithoutLastTick?: boolean, viewportYDomains?: Record<string, [number, number]>): {
     slots: YAxisSlot[];
     clearance: {
         left: number;

package/dist/types/components/core/yAxisLayoutMetrics.d.ts

@@ -0,0 +1,10 @@
+import type { WaveformOverlayMode } from '../data/types';
+import type { DisplayTrack } from './types';
+import type { WaveformYDomain } from './yDomain';
+export interface YAxisLayoutMetrics {
+    tickClearance: number;
+    fullClearance: number;
+    labelCenterX: number;
+}
+export declare function resolveViewportYDomains(displayMode: 'independent' | 'separated' | 'compact', chartTracks: DisplayTrack[], sharedYDomains: Record<string, [number, number]>, independentYDomains: Record<number, [number, number]>): Record<string, [number, number]>;
+export declare function resolveYAxisLayoutMetrics(chartTracks: DisplayTrack[], overlayMode: WaveformOverlayMode, yDomain: WaveformYDomain | undefined, yDomains: Record<string, WaveformYDomain> | undefined, viewportYDomains: Record<string, [number, number]>, nice: boolean, tickCount: number, compact: boolean): YAxisLayoutMetrics;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "waveform-analysis",
-  "version": "0.1.59",
+  "version": "0.1.60",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "types": "./dist/types/index.d.ts",

package/src/components/core/layout.test.ts

@@ -4,11 +4,14 @@ import { describe, expect, it } from 'vitest'
 import { DEFAULT_WAVEFORM_RENDERING_OPTIONS } from '../../core'
 import type { DisplaySeries, DisplayTrack } from './types'
 import {
+  axisTextMetrics,
   buildTrackLayouts,
   buildYAxisSeriesGroups,
+  formatYAxisTickLabel,
   findClosestTrackAtPointer,
   MAX_MULTI_Y_AXIS_COUNT,
   measureYAxisGroupClearance,
+  resolveYAxisTicks,
   resolveYAxisTickCount,
 } from './layout'
 
@@ -143,6 +146,27 @@ describe('multi-value Y-axis grouping', () => {
     expect(resolveYAxisTickCount(220)).toBe(5)
   })
 
+  it('measures the same final endpoint label that Y-axis rendering uses', () => {
+    const ticks = resolveYAxisTicks([-0.7434, -0.3434], 5, false)
+    const labels = ticks.values.map((value) =>
+      formatYAxisTickLabel(value, ticks.domain, ticks.values, 'V'),
+    )
+
+    expect(labels).toEqual(['-0.7434', '-0.6434', '-0.5434', '-0.4434', '(V) -0.3434'])
+    expect(axisTextMetrics(ticks.domain, false, undefined, 'V', 5).tickTextWidth).toBe(77)
+  })
+
+  it('includes the compact-axis unit label after its top tick is hidden', () => {
+    const ticks = resolveYAxisTicks([0.12345, 100], 5, false)
+    const compactTicks = ticks.values.slice(0, -1)
+
+    expect(formatYAxisTickLabel(compactTicks.at(-1)!, ticks.domain, compactTicks, 'V')).toBe(
+      '(V) 75.031',
+    )
+    expect(axisTextMetrics(ticks.domain, false, undefined, 'V', 5).tickTextWidth).toBe(49)
+    expect(axisTextMetrics(ticks.domain, false, undefined, 'V', 5, true).tickTextWidth).toBe(70)
+  })
+
   it('keeps every overlaid series on one axis in single-axis mode', () => {
     const groups = buildYAxisSeriesGroups(
       track([series('a', 0, 1), series('b', 10, 20)]),

package/src/components/core/layout.ts

@@ -27,6 +27,47 @@ export function resolveYAxisTickCount(_plotHeight: number, splitNumber?: number)
   return 5
 }
 
+export interface ResolvedYAxisTicks {
+  domain: [number, number]
+  values: number[]
+}
+
+export function resolveYAxisTicks(
+  domain: [number, number],
+  tickCount = 5,
+  nice = true,
+): ResolvedYAxisTicks {
+  const effectiveTickCount =
+    typeof tickCount === 'number' && Number.isFinite(tickCount)
+      ? Math.max(2, Math.floor(tickCount))
+      : 5
+  const scale = scaleLinear(domain, [1, 0])
+  if (nice) scale.nice(Math.max(1, effectiveTickCount - 1))
+  const resolvedDomain = scale.domain() as [number, number]
+  const [axisStart, axisEnd] = resolvedDomain
+  return {
+    domain: resolvedDomain,
+    values: Array.from(
+      { length: effectiveTickCount },
+      (_, index) => axisStart + ((axisEnd - axisStart) * index) / (effectiveTickCount - 1),
+    ),
+  }
+}
+
+export function formatYAxisTickLabel(
+  value: number,
+  domain: [number, number],
+  tickValues: readonly number[],
+  unit?: string,
+): string {
+  return formatScientificAxisLabel(value, {
+    axisMin: domain[0],
+    axisMax: domain[1],
+    topTickValue: Math.max(...tickValues),
+    unit,
+  })
+}
+
 export interface YAxisSeriesGroup {
   index: number
   side: 'left' | 'right'
@@ -114,26 +155,38 @@ export function resolveYAxisSeriesGroups(
   })
 }
 
+export function resolveRenderedYAxisSeriesGroups(
+  track: DisplayTrack,
+  overlayMode: WaveformOverlayMode,
+  yDomain?: WaveformYDomain,
+  yDomains?: Record<string, WaveformYDomain>,
+  viewportYDomains?: Record<string, [number, number]>,
+): YAxisSeriesGroup[] {
+  const viewportYDomain = viewportYDomains?.[track.id]
+  return resolveYAxisSeriesGroups(track, overlayMode, yDomain, yDomains).map((group) =>
+    !group.fixed && viewportYDomain ? { ...group, domain: viewportYDomain } : group,
+  )
+}
+
 export function axisTextMetrics(
   domain: [number, number],
   nice = true,
   tickValues?: number[],
   unit?: string,
-  tickCount = 10,
+  tickCount = 5,
+  includeWithoutLastTick = false,
 ): { tickTextWidth: number } {
-  const effectiveTickCount =
-    typeof tickCount === 'number' && Number.isFinite(tickCount)
-      ? Math.max(2, Math.floor(tickCount))
-      : 10
-  const scale = scaleLinear(domain, [1, 0])
-  if (nice) scale.nice(effectiveTickCount)
-  const [axisMin, axisMax] = scale.domain()
-  const values = tickValues ?? scale.ticks(effectiveTickCount)
-  const topTickValue = Math.max(...values)
+  const resolvedTicks = tickValues
+    ? { domain, values: tickValues }
+    : resolveYAxisTicks(domain, tickCount, nice)
+  const tickValueSets = [resolvedTicks.values]
+  if (includeWithoutLastTick && resolvedTicks.values.length > 1) {
+    tickValueSets.push(resolvedTicks.values.slice(0, -1))
+  }
   const maximumTickCharacters = Math.max(
     1,
-    ...values.map(
-      (value) => formatScientificAxisLabel(value, { axisMin, axisMax, topTickValue, unit }).length,
+    ...tickValueSets.flatMap((values) =>
+      values.map((value) => formatYAxisTickLabel(value, resolvedTicks.domain, values, unit).length),
     ),
   )
   return {
@@ -200,11 +253,19 @@ export function buildYAxisSlots(
   yDomains?: Record<string, WaveformYDomain>,
   tickCount?: number,
   nice = true,
+  includeWithoutLastTick = false,
+  viewportYDomains?: Record<string, [number, number]>,
 ): { slots: YAxisSlot[]; clearance: { left: number; right: number } } {
   const widths = new Map<string, number>()
   tracks.forEach((track) => {
     const sideIndexes = { left: 0, right: 0 }
-    resolveYAxisSeriesGroups(track, overlayMode, yDomain, yDomains).forEach((group) => {
+    resolveRenderedYAxisSeriesGroups(
+      track,
+      overlayMode,
+      yDomain,
+      yDomains,
+      viewportYDomains,
+    ).forEach((group) => {
       const sideIndex = sideIndexes[group.side]++
       const key = `${group.side}:${sideIndex}`
       const width = axisTextMetrics(
@@ -213,6 +274,7 @@ export function buildYAxisSlots(
         undefined,
         group.seriesList[0]?.unit,
         tickCount,
+        includeWithoutLastTick,
       ).tickTextWidth
       widths.set(key, Math.max(widths.get(key) ?? Y_AXIS_CHARACTER_WIDTH, width))
     })

package/src/components/core/trackLayoutBuilder.ts

@@ -27,7 +27,8 @@ import {
 } from './grid'
 import {
   axisTextMetrics,
-  resolveYAxisSeriesGroups,
+  resolveRenderedYAxisSeriesGroups,
+  resolveYAxisTicks,
   resolveYAxisTickCount,
   type YAxisSlot,
 } from './layout'
@@ -115,28 +116,21 @@ export function buildTrackLayouts(options: BuildTrackLayoutsOptions): TrackLayou
         ? (options.independentTransforms[index] ?? zoomIdentity)
         : zoomIdentity
     const xScale = transform.rescaleX(baseXScale)
-    const configuredYDomain = options.yDomains?.[displayTrack.id]
-    const yAxisGroups = resolveYAxisSeriesGroups(
+    const yAxisGroups = resolveRenderedYAxisSeriesGroups(
       displayTrack,
       options.overlayMode,
       options.fixedYDomain,
       options.fixedYDomains,
-    ).map((group) =>
-      !group.fixed && configuredYDomain ? { ...group, domain: configuredYDomain } : group,
+      options.yDomains,
     )
     const sideIndexes = { left: 0, right: 0 }
     const sideOffsets = { left: 0, right: 0 }
     const yAxes: WaveformYAxisLayout[] = yAxisGroups.map((group) => {
       const sideIndex = sideIndexes[group.side]++
       const tickCount = resolveYAxisTickCount(cell.plotHeight, options.yAxisSplitNumber)
-      const niceCount = Math.max(1, tickCount - 1)
-      const scale = scaleLinear(group.domain, [cell.plotHeight, 0])
-      if (options.yAxisNice !== false) scale.nice(niceCount)
-      const [axisStart, axisEnd] = scale.domain()
-      const majorTicks = Array.from(
-        { length: tickCount },
-        (_, index) => axisStart + ((axisEnd - axisStart) * index) / (tickCount - 1),
-      )
+      const resolvedTicks = resolveYAxisTicks(group.domain, tickCount, options.yAxisNice !== false)
+      const scale = scaleLinear(resolvedTicks.domain, [cell.plotHeight, 0])
+      const majorTicks = resolvedTicks.values
       const showAxisEnd = options.displayMode !== 'compact' || cell.row === 0
       const visibleMajorTicks = showAxisEnd ? majorTicks : majorTicks.slice(0, -1)
       const tickValues = visibleMajorTicks

package/src/components/core/useWaveformLayout.ts

@@ -7,16 +7,7 @@ import {
   type AnnotationSeriesInfo,
   type AnnotationTrackLayout,
 } from '../annotation'
-import {
-  channelColors,
-  margin,
-  MINIMUM_PLOT_WIDTH,
-  Y_AXIS_CHARACTER_WIDTH,
-  Y_AXIS_LABEL_BAND_WIDTH,
-  Y_AXIS_LABEL_GAP,
-  Y_AXIS_OUTER_PADDING,
-  Y_AXIS_TICK_PADDING,
-} from './constants'
+import { channelColors, margin, MINIMUM_PLOT_WIDTH } from './constants'
 import {
   getGridGap,
   getPageCount,
@@ -24,17 +15,13 @@ import {
   paginateSeries,
   resolveGridCellGeometry,
 } from './grid'
-import {
-  buildTrackLayouts,
-  axisTextMetrics,
-  buildYAxisSlots,
-  resolveYAxisSeriesGroups,
-} from './layout'
+import { buildTrackLayouts, buildYAxisSlots, resolveYAxisTickCount } from './layout'
 import type { DisplaySeries, DisplayTrack, TrackLayout } from './types'
 import { createFrameNumberResolver, resolvePageableTracks } from './trackPagination'
 import type { PreparedWaveformSeries } from './useWaveformData'
 import type { ResolvedWaveformChartProps } from './waveformChartTypes'
 import { applyXDomainStrategy } from './xDomain'
+import { resolveYAxisLayoutMetrics, resolveViewportYDomains } from './yAxisLayoutMetrics'
 import type { useWaveformAnnotationInteraction } from '../annotation'
 interface LayoutContext {
   props: ResolvedWaveformChartProps
@@ -121,38 +108,29 @@ export function useWaveformLayout(context: LayoutContext) {
       ? tracksWithSeries
       : pagedTracks.value
   })
-  const yAxisMetrics = computed(() => {
-    const axisText = chartTracks.value
-      .filter((track) => track.visibleSeries.length > 0)
-      .flatMap((track) =>
-        resolveYAxisSeriesGroups(track, props.overlayMode, props.yDomain, props.yDomains),
-      )
-      .map(
-        (group) =>
-          axisTextMetrics(
-            group.domain,
-            props.axes?.y?.nice !== false,
-            undefined,
-            group.seriesList[0]?.unit,
-            props.axes?.y?.splitNumber,
-          ).tickTextWidth,
-      )
-    const tickTextWidth = Math.max(Y_AXIS_CHARACTER_WIDTH, ...axisText)
-    const tickClearance = tickTextWidth + Y_AXIS_TICK_PADDING + Y_AXIS_OUTER_PADDING
-    const labelCenterX = -(
-      Y_AXIS_TICK_PADDING +
-      tickTextWidth +
-      Y_AXIS_LABEL_GAP +
-      Y_AXIS_LABEL_BAND_WIDTH / 2
-    )
-    const fullClearance =
-      tickTextWidth +
-      Y_AXIS_TICK_PADDING +
-      Y_AXIS_LABEL_GAP +
-      Y_AXIS_LABEL_BAND_WIDTH +
-      Y_AXIS_OUTER_PADDING
-    return { tickClearance, fullClearance, labelCenterX }
-  })
+  const yAxisTickCount = computed(() =>
+    resolveYAxisTickCount(innerHeight.value, props.axes?.y?.splitNumber),
+  )
+  const viewportYDomains = computed(() =>
+    resolveViewportYDomains(
+      props.displayMode,
+      chartTracks.value,
+      sharedYDomains.value,
+      independentYDomains.value,
+    ),
+  )
+  const yAxisMetrics = computed(() =>
+    resolveYAxisLayoutMetrics(
+      chartTracks.value,
+      props.overlayMode,
+      props.yDomain,
+      props.yDomains,
+      viewportYDomains.value,
+      props.axes?.y?.nice !== false,
+      yAxisTickCount.value,
+      props.displayMode === 'compact',
+    ),
+  )
   const hasYAxisLabels = computed(() =>
     chartTracks.value.some(
       (track) =>
@@ -179,8 +157,10 @@ export function useWaveformLayout(context: LayoutContext) {
       props.overlayMode,
       props.yDomain,
       props.yDomains,
-      props.axes?.y?.splitNumber,
+      yAxisTickCount.value,
       props.axes?.y?.nice !== false,
+      props.displayMode === 'compact',
+      viewportYDomains.value,
     ),
   )
   const resolvedChartLeftMargin = computed(() =>
@@ -302,15 +282,7 @@ export function useWaveformLayout(context: LayoutContext) {
       xDomainStrategy: props.xDomainStrategy,
       fixedYDomain: props.yDomain,
       fixedYDomains: props.yDomains,
-      yDomains:
-        props.displayMode === 'independent'
-          ? Object.fromEntries(
-              chartTracks.value.flatMap((track, index) => {
-                const domain = independentYDomains.value[index]
-                return domain ? [[track.id, domain]] : []
-              }),
-            )
-          : sharedYDomains.value,
+      yDomains: viewportYDomains.value,
       timeUnit: props.timeUnit,
       xAxisLabelFormatter: props.axes?.x?.labelFormatter,
       yAxisSplitNumber: props.axes?.y?.splitNumber,

package/src/components/core/yAxisLayoutMetrics.ts

@@ -0,0 +1,75 @@
+import type { WaveformOverlayMode } from '../data/types'
+import {
+  Y_AXIS_CHARACTER_WIDTH,
+  Y_AXIS_LABEL_BAND_WIDTH,
+  Y_AXIS_LABEL_GAP,
+  Y_AXIS_OUTER_PADDING,
+  Y_AXIS_TICK_PADDING,
+} from './constants'
+import { axisTextMetrics, resolveRenderedYAxisSeriesGroups } from './layout'
+import type { DisplayTrack } from './types'
+import type { WaveformYDomain } from './yDomain'
+
+export interface YAxisLayoutMetrics {
+  tickClearance: number
+  fullClearance: number
+  labelCenterX: number
+}
+
+export function resolveViewportYDomains(
+  displayMode: 'independent' | 'separated' | 'compact',
+  chartTracks: DisplayTrack[],
+  sharedYDomains: Record<string, [number, number]>,
+  independentYDomains: Record<number, [number, number]>,
+): Record<string, [number, number]> {
+  if (displayMode !== 'independent') return sharedYDomains
+  return Object.fromEntries(
+    chartTracks.flatMap((track, index) => {
+      const domain = independentYDomains[index]
+      return domain ? [[track.id, domain]] : []
+    }),
+  )
+}
+
+export function resolveYAxisLayoutMetrics(
+  chartTracks: DisplayTrack[],
+  overlayMode: WaveformOverlayMode,
+  yDomain: WaveformYDomain | undefined,
+  yDomains: Record<string, WaveformYDomain> | undefined,
+  viewportYDomains: Record<string, [number, number]>,
+  nice: boolean,
+  tickCount: number,
+  compact: boolean,
+): YAxisLayoutMetrics {
+  const axisText = chartTracks
+    .filter((track) => track.visibleSeries.length > 0)
+    .flatMap((track) =>
+      resolveRenderedYAxisSeriesGroups(track, overlayMode, yDomain, yDomains, viewportYDomains),
+    )
+    .map(
+      (group) =>
+        axisTextMetrics(
+          group.domain,
+          nice,
+          undefined,
+          group.seriesList[0]?.unit,
+          tickCount,
+          compact,
+        ).tickTextWidth,
+    )
+  const tickTextWidth = Math.max(Y_AXIS_CHARACTER_WIDTH, ...axisText)
+  const tickClearance = tickTextWidth + Y_AXIS_TICK_PADDING + Y_AXIS_OUTER_PADDING
+  const labelCenterX = -(
+    Y_AXIS_TICK_PADDING +
+    tickTextWidth +
+    Y_AXIS_LABEL_GAP +
+    Y_AXIS_LABEL_BAND_WIDTH / 2
+  )
+  const fullClearance =
+    tickTextWidth +
+    Y_AXIS_TICK_PADDING +
+    Y_AXIS_LABEL_GAP +
+    Y_AXIS_LABEL_BAND_WIDTH +
+    Y_AXIS_OUTER_PADDING
+  return { tickClearance, fullClearance, labelCenterX }
+}

package/src/components/core/yAxisSlotLayout.test.ts

@@ -2,7 +2,7 @@ import { zoomIdentity } from 'd3'
 import { describe, expect, it } from 'vitest'
 
 import { DEFAULT_WAVEFORM_RENDERING_OPTIONS } from '../../core'
-import { buildTrackLayouts, buildYAxisSlots } from './layout'
+import { buildTrackLayouts, buildYAxisSlots, resolveRenderedYAxisSeriesGroups } from './layout'
 import type { DisplaySeries, DisplayTrack } from './types'
 import { Y_AXIS_RIGHT_LABEL_OFFSET } from './yAxisConstants'
 
@@ -126,4 +126,40 @@ describe('Y-axis slots', () => {
     expect(fourAxisSlots.slots[1]!.axisOffset).toBeLessThan(0)
     expect(fourAxisSlots.slots[3]!.axisOffset).toBeGreaterThan(0)
   })
+
+  it('uses dynamic Y domains when measuring multi-axis slots', () => {
+    const negativeVoltage = series('negative-voltage', 0, 1)
+    negativeVoltage.unit = 'V'
+    const longUnit = series('long-unit', 0, 1)
+    longUnit.unit = 'volt-amperes-per-phase'
+    const sourceTrack = track([negativeVoltage, longUnit])
+    const viewportYDomains = { [sourceTrack.id]: [-0.7434, -0.3434] as [number, number] }
+
+    expect(
+      resolveRenderedYAxisSeriesGroups(
+        sourceTrack,
+        'multi-axis',
+        undefined,
+        undefined,
+        viewportYDomains,
+      ).map((group) => group.domain),
+    ).toEqual([
+      [-0.7434, -0.3434],
+      [-0.7434, -0.3434],
+    ])
+
+    const slots = buildYAxisSlots(
+      [sourceTrack],
+      'multi-axis',
+      undefined,
+      undefined,
+      5,
+      false,
+      false,
+      viewportYDomains,
+    )
+
+    expect(slots.clearance.left).toBe(100)
+    expect(slots.clearance.right).toBeGreaterThan(180)
+  })
 })

package/src/components/rendering/WaveformTrackAxes.vue

@@ -3,7 +3,8 @@ import { axisBottom, axisLeft, axisRight, select } from 'd3'
 import { nextTick, onMounted, ref, watch } from 'vue'
 
 import type { WaveformAxesOptions } from '../../types'
-import { formatScientificAxisLabel, formatXAxisLabel } from '../../utils'
+import { formatXAxisLabel } from '../../utils'
+import { formatYAxisTickLabel } from '../core/layout'
 import type { DisplaySeries, TrackLayout, WaveformYAxisLayout } from '../core/types'
 import { Y_AXIS_LABEL_BAND_WIDTH } from '../core/yAxisConstants'
 
@@ -43,12 +44,15 @@ function renderAxes() {
   props.track.yAxes.forEach((axis, index) => {
     const element = yAxisElements.value[index]
     if (!element) return
-    const [axisMin, axisMax] = axis.scale.domain()
-    const topTickValue = Math.max(...axis.tickValues)
     const unit = axis.seriesList[0]?.unit
     const yAxis = (axis.side === 'left' ? axisLeft(axis.scale) : axisRight(axis.scale))
       .tickFormat((value) =>
-        formatScientificAxisLabel(Number(value), { axisMin, axisMax, topTickValue, unit }),
+        formatYAxisTickLabel(
+          Number(value),
+          axis.scale.domain() as [number, number],
+          axis.tickValues,
+          unit,
+        ),
       )
       .tickSize(-4)
       .tickPadding(7)

package/src/components/waveformChartCases/layoutAndDomains.test.ts

@@ -6,26 +6,6 @@ import { resizeObservers } from '../../test/setup'
 import { gridSeries, mountSizedChart } from '../../test/waveformChart'
 
 describe('WaveformChart', () => {
-  it('applies the configured Y-axis split number', async () => {
-    const wrapper = await mountSizedChart(
-      {
-        kind: 'points',
-        points: [
-          { x: 0, y: 3 },
-          { x: 1, y: 97 },
-        ],
-      },
-      { axes: { y: { splitNumber: 5 } } },
-    )
-
-    expect(
-      wrapper
-        .get('.waveform-chart__axis--y')
-        .findAll('.tick text')
-        .map((tick) => tick.text()),
-    ).toEqual(['0', '25', '50', '75', '100'])
-  })
-
   it('expands the Y-axis label gutter for signed values and long exponents', async () => {
     const wrapper = await mountSizedChart(
       {
@@ -52,10 +32,13 @@ describe('WaveformChart', () => {
     const labelBackgroundX = Number(
       tracks[0].get('.waveform-chart__y-axis-label-bg').attributes('x'),
     )
+    const longestTickLabel = Math.max(
+      ...tracks[0].findAll('.waveform-chart__axis--y .tick text').map((tick) => tick.text().length),
+    )
 
-    expect(labelX).toBe(-62)
+    expect(Math.abs(labelX)).toBeGreaterThanOrEqual(7 + longestTickLabel * 7 + 6)
     expect(labelBackgroundX).toBe(labelX - 6)
-    expect(Number(wrapper.attributes('data-chart-left-margin'))).toBe(80)
+    expect(Number(wrapper.attributes('data-chart-left-margin'))).toBeGreaterThanOrEqual(80)
     expect(secondLeft - firstWidth).toBeGreaterThanOrEqual(72)
   })
 
@@ -118,12 +101,28 @@ describe('WaveformChart', () => {
       { grid: { rowCount: 1, columnCount: 1 } },
     )
     const initialMargin = wrapper.attributes('data-chart-left-margin')
-    expect(wrapper.get('.waveform-chart__track').attributes('data-y-axis-label-x')).toBe('-34')
+    const initialTrack = wrapper.get('.waveform-chart__track')
+    const initialLongestTickLabel = Math.max(
+      ...initialTrack
+        .findAll('.waveform-chart__axis--y .tick text')
+        .map((tick) => tick.text().length),
+    )
+    expect(initialTrack.attributes('data-y-axis-label-x')).toBe(
+      String(-(7 + initialLongestTickLabel * 7 + 6)),
+    )
 
     await wrapper.get('.ant-pagination-next button').trigger('click')
 
     expect(wrapper.attributes('data-chart-left-margin')).toBe(initialMargin)
-    expect(wrapper.get('.waveform-chart__track').attributes('data-y-axis-label-x')).toBe('-62')
+    const pagedTrack = wrapper.get('.waveform-chart__track')
+    const pagedLongestTickLabel = Math.max(
+      ...pagedTrack
+        .findAll('.waveform-chart__axis--y .tick text')
+        .map((tick) => tick.text().length),
+    )
+    expect(pagedTrack.attributes('data-y-axis-label-x')).toBe(
+      String(-(7 + pagedLongestTickLabel * 7 + 6)),
+    )
   })
 
   it('hides only secondary-column Y-axis labels when the grid is too narrow', async () => {