waveform-analysis 0.1.71 → 0.1.73

package/src/components/controls/useChartCommands.ts

@@ -0,0 +1,294 @@
+import { computed, nextTick, watch, type Ref, type ShallowRef } from 'vue'
+import type { ZoomTransform } from 'd3'
+import type {
+  WaveformControlAction,
+  WaveformControlResult,
+  WaveformControlState,
+  WaveformControlTarget,
+  WaveformTargetResult,
+  WaveformViewportSnapshot,
+} from '../../types/controls'
+import type { TrackLayout } from '../core/types'
+import type { useWaveformLayout } from '../core/useWaveformLayout'
+import type { ResolvedWaveformChartProps, WaveformChartEmit } from '../core/waveformChartTypes'
+import { applyXDomainStrategy } from '../core/xDomain'
+import { paddedDomain } from '../../utils'
+import { transformForDomain } from '../interaction/zoomConstraints'
+import { constrainViewportZoom } from '../interaction/remoteViewport'
+import { normalizeIntegerZoomDomain } from '../interaction/integerZoom'
+import type { useControlMode } from './useControlMode'
+
+type Domain = [number, number]
+interface Context {
+  props: ResolvedWaveformChartProps
+  emit: WaveformChartEmit
+  layout: ReturnType<typeof useWaveformLayout>
+  mode: ReturnType<typeof useControlMode>
+  boundaries: ShallowRef<Record<string, Domain>>
+  independentTransforms: ShallowRef<ZoomTransform[]>
+  sharedTransform: ShallowRef<ZoomTransform>
+  independentYDomains: Ref<Record<number, Domain>>
+  sharedYDomains: Ref<Record<string, Domain>>
+  cancel: () => void
+  configure: () => void
+  legacyReset: (index?: number) => void
+  legacySet: (domain: Domain, index?: number) => void
+}
+const same = (a: Domain, b: Domain) => a.every((v, i) => Math.abs(v - b[i]!) < 1e-12)
+export function useChartCommands(c: Context) {
+  let sequence = 0
+  const independent = computed(() => c.props.displayMode === 'independent')
+  const groups = () =>
+    independent.value
+      ? c.layout.trackLayouts.value.map((t) => ({ id: t.id, tracks: [t] }))
+      : [{ id: 'shared', tracks: c.layout.trackLayouts.value }]
+  const snapshot = (tracks: TrackLayout[]): WaveformViewportSnapshot => ({
+    xDomain: [
+      ...(independent.value ? tracks[0]!.xScale.domain() : c.layout.sharedZoomDomain.value),
+    ] as Domain,
+    yDomains: Object.fromEntries(
+      tracks.flatMap((t) => t.seriesPaths.map((p) => [p.series.id, p.yScale.domain() as Domain])),
+    ),
+  })
+  const boundary = (tracks: TrackLayout[], original = false): Domain =>
+    independent.value
+      ? (original ? c.layout.resolveOriginalTrackDomain : c.layout.resolveInitialTrackDomain)(
+          tracks[0]!,
+        )
+      : (original ? c.layout.originalXDomain : c.layout.initialXDomain).value
+  const clearBoundaries = (index?: number) => {
+    if (!independent.value || index === undefined) c.boundaries.value = {}
+    else {
+      const id = c.layout.trackLayouts.value.find((t) => t.index === index)?.id
+      const next = { ...c.boundaries.value }
+      if (id) delete next[id]
+      c.boundaries.value = next
+    }
+  }
+  function restoreInitialBoundaries() {
+    if (!Object.keys(c.boundaries.value).length) return
+    const previous = groups()
+      .filter((g) => g.tracks.length)
+      .map((g) => ({
+        index: independent.value ? g.tracks[0]!.index : undefined,
+        domain: snapshot(g.tracks).xDomain,
+      }))
+    clearBoundaries()
+    previous.forEach((p) => c.legacySet(p.domain, p.index))
+  }
+  function plan(
+    action: WaveformControlAction,
+    target: WaveformControlTarget = {},
+    domain?: Domain,
+  ) {
+    const all = groups()
+    if (
+      target.trackId !== undefined &&
+      (!independent.value || !all.some((g) => g.id === target.trackId))
+    )
+      return { error: 'invalid-target' as const, entries: [] }
+    if (
+      action === 'set-domain' &&
+      (!domain || !domain.every(Number.isFinite) || domain[0] === domain[1])
+    )
+      return { error: 'invalid-domain' as const, entries: [] }
+    const selected = target.trackId === undefined ? all : all.filter((g) => g.id === target.trackId)
+    const entries = selected.map(({ id, tracks }) => {
+      const nonempty = tracks.some((t) =>
+        t.seriesList.some((s) => (s.source?.length ?? s.points.length) > 0),
+      )
+      const before = tracks.length ? snapshot(tracks) : undefined
+      let bounds: Domain = tracks.length ? boundary(tracks, action === 'reset') : [0, 1]
+      if (action === 'fit')
+        bounds = applyXDomainStrategy(
+          paddedDomain(tracks.flatMap((t) => t.seriesList.flatMap((s) => s.xDomain))),
+          c.props.xDomainStrategy,
+        )
+      let requested: Domain = domain ?? bounds
+      if (before && (action === 'zoom-in' || action === 'zoom-out')) {
+        const [a, b] = before.xDomain
+        const half = (b - a) * (action === 'zoom-in' ? 0.25 : 1)
+        requested = [(a + b) / 2 - half, (a + b) / 2 + half]
+      }
+      const xDomain = constrainViewportZoom(
+        normalizeIntegerZoomDomain(requested, c.props),
+        bounds,
+        tracks.filter((t) => t.hasVisibleSeries).map((t) => t.seriesList),
+        c.props,
+      )
+      const resetsY = action === 'reset' || action === 'fit'
+      const hasY =
+        resetsY &&
+        (independent.value
+          ? tracks.some((t) => c.independentYDomains.value[t.index])
+          : Object.keys(c.sharedYDomains.value).length > 0)
+      const boundaryChanged = tracks.length && !same(bounds, boundary(tracks))
+      const status: WaveformTargetResult['status'] = !nonempty
+        ? 'empty-data'
+        : c.props.presentationMode || !c.props.zoomable
+          ? 'disabled'
+          : before && same(before.xDomain, xDomain) && !hasY && !boundaryChanged
+            ? 'unchanged'
+            : 'applied'
+      return { id, tracks, before, bounds, xDomain, status, resetsY }
+    })
+    return { entries }
+  }
+  function execute(
+    action: WaveformControlAction,
+    target: WaveformControlTarget = {},
+    domain?: Domain,
+    source: 'toolbar' | 'api' = 'api',
+  ): WaveformControlResult {
+    const planned = plan(action, target, domain)
+    if (planned.error) return { kind: 'viewport', status: planned.error, targets: [] }
+    const { entries } = planned
+    const isIndependent = independent.value
+    const metadata = { commandId: `command-${++sequence}`, source, action }
+    // Capture identities before host event handlers can replace the data.
+    const identities = entries.map((e) => ({
+      trackIndex: isIndependent ? e.tracks[0]?.index : undefined,
+      seriesIds: e.tracks.flatMap((t) => t.seriesList.map((s) => s.id)),
+    }))
+    if (
+      entries.some(
+        (e) => e.status === 'applied' || (action === 'reset' && e.status === 'unchanged'),
+      )
+    )
+      c.cancel()
+    const transforms = [...c.independentTransforms.value]
+    const bounds = { ...c.boundaries.value }
+    const ys = { ...c.independentYDomains.value }
+    for (const e of entries) {
+      if (e.status !== 'applied') continue
+      if (action === 'fit') bounds[e.id] = e.bounds
+      if (action === 'reset') delete bounds[e.id]
+      if (isIndependent) {
+        const track = e.tracks[0]!
+        transforms[track.index] = transformForDomain(e.xDomain, e.bounds, track.width)
+        if (e.resetsY) delete ys[track.index]
+      } else {
+        c.sharedTransform.value = transformForDomain(e.xDomain, e.bounds, c.layout.innerWidth.value)
+        if (e.resetsY) c.sharedYDomains.value = {}
+      }
+    }
+    if (entries.some((e) => e.status === 'applied')) {
+      c.boundaries.value = bounds
+      c.independentTransforms.value = transforms
+      c.independentYDomains.value = ys
+    }
+    const current = groups()
+    const targets: WaveformTargetResult[] = entries.map((e) => ({
+      trackId: e.id,
+      status: e.status,
+      before: e.before,
+      after: current.find((g) => g.id === e.id)?.tracks.length
+        ? snapshot(current.find((g) => g.id === e.id)!.tracks)
+        : undefined,
+    }))
+    const yPayloads = entries.map((e) => {
+      const tracks = current.find((g) => g.id === e.id)?.tracks ?? []
+      const ranges = Object.fromEntries(
+        tracks.map((t) => [t.series?.trackId ?? t.series?.id ?? t.id, t.yScale.domain()]),
+      )
+      const range = Object.values(ranges)[0]
+      return isIndependent || tracks.length === 1
+        ? { yStart: range?.[0], yEnd: range?.[1] }
+        : { yRanges: ranges as Record<string, Domain> }
+    })
+    targets.forEach((result, index) => {
+      if (action === 'reset' && (result.status === 'applied' || result.status === 'unchanged')) {
+        c.emit('zoom-reset', { ...metadata, ...identities[index] })
+      } else if (result.status === 'applied' && result.after) {
+        const [start, end] = result.after.xDomain
+        const payload = {
+          ...metadata,
+          ...identities[index],
+          start,
+          end,
+          gesture: 'command' as const,
+          ...yPayloads[index],
+        }
+        if (action !== 'fit') c.emit('zoom-intent', payload)
+        c.emit('zoom-change', [start, end])
+        c.emit('zoom-end', payload)
+      }
+    })
+    if (targets.some((t) => t.status === 'applied')) void nextTick(c.configure)
+    const status =
+      (['applied', 'unchanged', 'disabled', 'empty-data'] as const).find((value) =>
+        targets.some((t) => t.status === value),
+      ) ?? 'empty-data'
+    return { kind: 'viewport', status, targets }
+  }
+  function resetViewport(index?: number): void
+  function resetViewport(target: WaveformControlTarget): WaveformControlResult
+  function resetViewport(target?: number | WaveformControlTarget) {
+    if (typeof target === 'object') return execute('reset', target)
+    c.legacyReset(target)
+  }
+  function setViewportDomain(domain: Domain, index?: number): void
+  function setViewportDomain(domain: Domain, target: WaveformControlTarget): WaveformControlResult
+  function setViewportDomain(domain: Domain, target?: number | WaveformControlTarget) {
+    if (typeof target === 'object') return execute('set-domain', target, domain)
+    if (domain.every(Number.isFinite) && domain[0] !== domain[1]) clearBoundaries(target)
+    c.legacySet(domain, target)
+  }
+  const state = computed<WaveformControlState>(() => {
+    const actions: WaveformControlAction[] = ['zoom-in', 'zoom-out', 'reset', 'fit', 'set-domain']
+    const targets = groups()
+      .filter((g) => g.tracks.length)
+      .map((g) => ({
+        trackId: g.id,
+        label: independent.value ? g.tracks[0]!.series?.name || g.id : '共享范围',
+        viewport: snapshot(g.tracks),
+        available: Object.fromEntries(
+          actions.map((action) => {
+            const p = plan(
+              action,
+              independent.value ? { trackId: g.id } : {},
+              snapshot(g.tracks).xDomain,
+            ).entries[0]
+            return [
+              action,
+              p?.status === 'applied' ||
+                ((action === 'reset' || action === 'set-domain') && p?.status === 'unchanged'),
+            ]
+          }),
+        ) as Record<WaveformControlAction, boolean>,
+      }))
+    return {
+      mode: c.mode.mode.value,
+      independent: independent.value,
+      targets,
+      available: {
+        'zoom-box': c.mode.canSetMode('zoom'),
+        pan: c.mode.canSetMode('pan'),
+        annotate: c.mode.canSetMode('annotation'),
+        export: true,
+        'zoom-in': targets.some((t) => t.available['zoom-in']),
+        'zoom-out': targets.some((t) => t.available['zoom-out']),
+        reset: targets.some((t) => t.available.reset),
+        fit: targets.some((t) => t.available.fit),
+      },
+    }
+  })
+  const getControlState = () => JSON.parse(JSON.stringify(state.value)) as WaveformControlState
+  watch(
+    () => JSON.stringify(state.value),
+    () => c.emit('control-state-change', getControlState()),
+  )
+  return {
+    controlState: state,
+    getControlState,
+    execute,
+    clearBoundaries,
+    restoreInitialBoundaries,
+    resetViewport,
+    setViewportDomain,
+    zoomIn: (target?: WaveformControlTarget) => execute('zoom-in', target),
+    zoomOut: (target?: WaveformControlTarget) => execute('zoom-out', target),
+    fitToData: (target?: WaveformControlTarget) => execute('fit', target),
+    setInteractionMode: c.mode.setInteractionMode,
+  }
+}

package/src/components/controls/useChartImageExport.ts

@@ -0,0 +1,155 @@
+import { nextTick, onBeforeUnmount, watch } from 'vue'
+import type {
+  WaveformImageExportError,
+  WaveformImageExportErrorCode,
+  WaveformImageExportOptions,
+} from '../../types/controls'
+import { updateMaximumTickVisibility } from '../rendering/yAxisTickVisibility'
+import { createChartSnapshot } from './chartSnapshot'
+export function imageExportError(code: WaveformImageExportErrorCode): WaveformImageExportError {
+  const messages = {
+    'export-invalid-options': '图片导出参数无效',
+    'export-unavailable': '图表尚未具备有效尺寸',
+    'export-busy': '已有导出正在执行',
+    'export-cancelled': '图表已卸载，导出取消',
+    'export-render-failed': '图片编码失败',
+    'export-stale': '图表已变化，请重新导出',
+    'export-timeout': '等待图表稳定超时，请重试',
+  }
+  return Object.assign(new Error(messages[code]), { code })
+}
+interface Context {
+  container: () => HTMLElement | undefined
+  svg: () => SVGSVGElement | undefined
+  size: () => { width: number; height: number; titleHeight: number }
+  version: () => unknown
+  ready: () => boolean
+}
+export function useChartImageExport(c: Context) {
+  let busy = false
+  let disposed = false
+  let revision = 0
+  let abort: ((error: WaveformImageExportError) => void) | undefined
+  watch(
+    c.version,
+    () => {
+      revision++
+      abort?.(imageExportError('export-stale'))
+    },
+    { flush: 'sync' },
+  )
+  onBeforeUnmount(() => {
+    disposed = true
+    abort?.(imageExportError('export-cancelled'))
+  })
+  async function exportImage(options: WaveformImageExportOptions = {}): Promise<Blob> {
+    const format = options.format ?? 'png'
+    const scale = options.scale ?? 1
+    if (
+      !['png', 'svg'].includes(format) ||
+      !Number.isFinite(scale) ||
+      scale <= 0 ||
+      scale > 4 ||
+      (format === 'svg' && scale !== 1) ||
+      (options.backgroundColor !== undefined &&
+        (typeof options.backgroundColor !== 'string' ||
+          !CSS.supports('color', options.backgroundColor)))
+    )
+      throw imageExportError('export-invalid-options')
+    if (disposed) throw imageExportError('export-cancelled')
+    if (busy) throw imageExportError('export-busy')
+    const container = c.container(),
+      svg = c.svg(),
+      size = c.size()
+    if (!container || !svg || size.width <= 0 || size.height <= 0)
+      throw imageExportError('export-unavailable')
+    busy = true
+    const captured = revision
+    let timer: ReturnType<typeof setTimeout> | undefined
+    let poll: ReturnType<typeof setTimeout> | undefined
+    let url: string | undefined
+    let img: HTMLImageElement | undefined
+    let canvas: HTMLCanvasElement | undefined
+    let stopped = false
+    const check = () => {
+      if (disposed) throw imageExportError('export-cancelled')
+      if (captured !== revision) throw imageExportError('export-stale')
+      if (stopped) throw imageExportError('export-timeout')
+    }
+    const cancelled = new Promise<never>((_, reject) => {
+      abort = reject
+      timer = setTimeout(() => reject(imageExportError('export-timeout')), 5000)
+    })
+    const generate = async () => {
+      await nextTick()
+      check()
+      await new Promise<void>((resolve) => {
+        const test = () => {
+          if (stopped) return
+          if (c.ready()) resolve()
+          else poll = setTimeout(test, 16)
+        }
+        test()
+      })
+      await document.fonts?.ready
+      await nextTick()
+      check()
+      updateMaximumTickVisibility(svg)
+      const snapshot = createChartSnapshot(
+        container,
+        svg,
+        size.width,
+        size.height,
+        size.titleHeight,
+        options.backgroundColor,
+      )
+      const blob = new Blob([snapshot], { type: 'image/svg+xml' })
+      if (format === 'svg') return blob
+      url = URL.createObjectURL(blob)
+      img = new Image()
+      await new Promise<void>((resolve, reject) => {
+        img!.onload = () => resolve()
+        img!.onerror = () => reject(imageExportError('export-render-failed'))
+        img!.src = url!
+      })
+      check()
+      canvas = document.createElement('canvas')
+      canvas.width = Math.round(size.width * scale)
+      canvas.height = Math.round(size.height * scale)
+      const ctx = canvas.getContext('2d')
+      if (!ctx) throw imageExportError('export-render-failed')
+      ctx.drawImage(img, 0, 0, canvas.width, canvas.height)
+      const png = await new Promise<Blob>((resolve, reject) =>
+        canvas!.toBlob(
+          (result) => (result ? resolve(result) : reject(imageExportError('export-render-failed'))),
+          'image/png',
+        ),
+      )
+      check()
+      return png
+    }
+    try {
+      return await Promise.race([cancelled, generate()])
+    } catch (error) {
+      if (error instanceof Error && 'code' in error) throw error
+      throw imageExportError('export-render-failed')
+    } finally {
+      stopped = true
+      clearTimeout(timer)
+      clearTimeout(poll)
+      if (img) {
+        img.onload = null
+        img.onerror = null
+        img.src = ''
+      }
+      if (url) URL.revokeObjectURL(url)
+      if (canvas) {
+        canvas.width = 0
+        canvas.height = 0
+      }
+      abort = undefined
+      busy = false
+    }
+  }
+  return { exportImage }
+}

package/src/components/controls/useControlMode.ts

@@ -0,0 +1,30 @@
+import { computed, ref, watch } from 'vue'
+import type { WaveformControlResult } from '../../types/controls'
+import type { WaveformInteractionMode } from '../../types'
+import type { ResolvedWaveformChartProps, WaveformChartEmit } from '../core/waveformChartTypes'
+
+export function useControlMode(props: ResolvedWaveformChartProps, emit: WaveformChartEmit) {
+  const internalMode = ref<WaveformInteractionMode>('zoom')
+  const mode = computed(() => props.interactionMode ?? internalMode.value)
+  const canSetMode = (value: WaveformInteractionMode) =>
+    !props.presentationMode &&
+    (value === 'none' ||
+      (value === 'zoom' && props.zoomable) ||
+      (value === 'pan' && props.pannable) ||
+      (value === 'annotation' && props.annotationsVisible))
+  function setInteractionMode(value: WaveformInteractionMode): WaveformControlResult {
+    let status: Extract<WaveformControlResult, { kind: 'mode' }>['status']
+    if (!canSetMode(value)) status = 'disabled'
+    else if (mode.value === value) status = 'unchanged'
+    else if (props.interactionMode !== undefined) {
+      emit('update:interactionMode', value)
+      status = 'requested'
+    } else {
+      internalMode.value = value
+      status = 'applied'
+    }
+    return { kind: 'mode', status, targets: [] }
+  }
+  watch(mode, (value) => emit('interaction-mode-change', value))
+  return { mode, canSetMode, setInteractionMode }
+}

package/src/components/core/latestTaskScheduler.ts

@@ -26,7 +26,9 @@ interface ScheduledTask {
 }
 
 /** Runs at most one task at a time and retains only the newest pending task. */
-export function createLatestTaskScheduler() {
+export function createLatestTaskScheduler(
+  onError: (error: unknown, generation: number) => void = () => undefined,
+) {
   let generation = 0
   let running = false
   let pending: ScheduledTask | undefined
@@ -40,7 +42,17 @@ export function createLatestTaskScheduler() {
       while (pending && !disposed) {
         const task = pending
         pending = undefined
-        await task.run(task.generation)
+        try {
+          await task.run(task.generation)
+        } catch (error) {
+          if (!disposed && task.generation === generation) {
+            try {
+              onError(error, task.generation)
+            } catch {
+              /* Reporting must not stall the queue. */
+            }
+          }
+        }
       }
     } finally {
       running = false

package/src/components/core/layout.ts

@@ -1,5 +1,3 @@
-import { scaleLinear } from 'd3'
-
 import type { WaveformOverlayMode } from '../../types'
 import { formatScientificAxisLabel, formatScientificAxisExponent, paddedDomain } from '../../utils'
 import type { DisplaySeries, DisplayTrack, TrackLayout } from './types'
@@ -10,6 +8,9 @@ import {
   resolveTrackFixedYDomain,
   type WaveformYDomain,
 } from './yDomain'
+import { resolveYAxisTicksECharts } from './niceScale'
+import { applyYAxisPadding, withMaximumTick, type YAxisPaddingOptions } from './yAxisPadding'
+import { resolveYAxisLabelBandWidth } from './yAxisLabelStyle'
 
 // 导出常量供外部使用
 export { MAX_MULTI_Y_AXIS_COUNT } from './constants'
@@ -37,21 +38,24 @@ export function resolveYAxisTicks(
   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),
-    ),
+  if (!nice) {
+    // 如果不需要 nice，使用简单的线性分割
+    const effectiveTickCount =
+      typeof tickCount === 'number' && Number.isFinite(tickCount)
+        ? Math.max(2, Math.floor(tickCount))
+        : 5
+    const [axisStart, axisEnd] = domain
+    return {
+      domain,
+      values: Array.from(
+        { length: effectiveTickCount },
+        (_, index) => axisStart + ((axisEnd - axisStart) * index) / (effectiveTickCount - 1),
+      ),
+    }
   }
+
+  // 使用 ECharts 兼容的 1/2/5 系列算法
+  return resolveYAxisTicksECharts(domain, tickCount)
 }
 
 export function formatYAxisTickLabel(
@@ -71,7 +75,8 @@ export function formatYAxisTickLabel(
   })
   if (suffixMetadata) {
     const unitLabel = unit?.trim()
-    return [label, formatScientificAxisExponent(...domain), unitLabel ? `(${unitLabel})` : null]
+    const exponent = formatScientificAxisExponent(...domain)
+    return [label, exponent, !exponent && unitLabel ? `(${unitLabel})` : null]
       .filter(Boolean)
       .join(' ')
   }
@@ -96,6 +101,8 @@ export interface YAxisSeriesGroup {
   seriesList: DisplaySeries[]
   domain: [number, number]
   fixed: boolean
+  maximumTick?: number
+  minimumTick?: number
 }
 
 export interface YAxisSlot {
@@ -183,26 +190,19 @@ export function resolveRenderedYAxisSeriesGroups(
   yDomain?: WaveformYDomain,
   yDomains?: Record<string, WaveformYDomain>,
   viewportYDomains?: Record<string, [number, number]>,
-  upperPaddingRatio = 0,
+  padding?: YAxisPaddingOptions | number,
 ): YAxisSeriesGroup[] {
   const viewportYDomain = viewportYDomains?.[track.id]
   const axisTrack =
     track.visibleSeries.length || !track.series.length
       ? track
       : { ...track, visibleSeries: track.series }
-  return resolveYAxisSeriesGroups(axisTrack, overlayMode, yDomain, yDomains).map((group) =>
-    !group.fixed && viewportYDomain
-      ? { ...group, domain: viewportYDomain }
-      : !group.fixed && Number.isFinite(upperPaddingRatio) && upperPaddingRatio > 0
-        ? {
-            ...group,
-            domain: [
-              group.domain[0],
-              group.domain[1] + (group.domain[1] - group.domain[0]) * upperPaddingRatio,
-            ] as WaveformYDomain,
-          }
-        : group,
-  )
+  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(
@@ -213,11 +213,19 @@ export function axisTextMetrics(
   tickCount = 5,
   includeWithoutLastTick = false,
   measureTextWidth?: (text: string) => number,
+  maximumTick?: number,
+  minimumTick?: number,
 ): { tickTextWidth: number } {
   const resolvedTicks = tickValues
     ? { domain, values: tickValues }
     : resolveYAxisTicks(domain, tickCount, nice)
-  const tickValueSets = [resolvedTicks.values]
+  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))
   }
@@ -296,10 +304,13 @@ export function buildYAxisSlots(
   nice = true,
   includeWithoutLastTick = false,
   viewportYDomains?: Record<string, [number, number]>,
-  upperPaddingRatio = 0,
+  padding?: YAxisPaddingOptions | number,
   showUnits = true,
   measureTextWidth?: (text: string) => number,
 ): { slots: YAxisSlot[]; clearance: { left: number; right: number } } {
+  const labelBandWidth = resolveYAxisLabelBandWidth(
+    typeof padding === 'object' ? padding.labelTextStyle : undefined,
+  )
   const widths = new Map<string, number>()
   tracks.forEach((track) => {
     const sideIndexes = { left: 0, right: 0 }
@@ -309,7 +320,7 @@ export function buildYAxisSlots(
       yDomain,
       yDomains,
       viewportYDomains,
-      upperPaddingRatio,
+      padding,
     ).forEach((group) => {
       const sideIndex = sideIndexes[group.side]++
       const key = `${group.side}:${sideIndex}`
@@ -321,6 +332,8 @@ export function buildYAxisSlots(
         tickCount,
         includeWithoutLastTick,
         measureTextWidth,
+        group.maximumTick,
+        group.minimumTick,
       ).tickTextWidth
       widths.set(key, Math.max(widths.get(key) ?? Y_AXIS_CHARACTER_WIDTH, width))
     })
@@ -337,13 +350,13 @@ export function buildYAxisSlots(
       const tickTextWidth = widths.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 + Y_AXIS_LABEL_BAND_WIDTH / 2
+        tickTextWidth + Y_AXIS_TICK_PADDING + Y_AXIS_LABEL_GAP + labelBandWidth / 2
       const labelOffset = axisOffset + labelDistance * (side === 'left' ? -1 : 1)
       const fullClearance =
         tickTextWidth +
         Y_AXIS_TICK_PADDING +
         Y_AXIS_LABEL_GAP +
-        Y_AXIS_LABEL_BAND_WIDTH +
+        labelBandWidth +
         Y_AXIS_OUTER_PADDING
       slots.push({ side, sideIndex, axisOffset, labelOffset, clearance: fullClearance })
       clearance[side] += fullClearance