waveform-analysis 0.1.62 → 0.1.64

package/src/core/workerSampling/repositoryTypedDataset.test.ts

@@ -1,89 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { WorkerSamplingRepository } from './repository'
-
-describe('WorkerSamplingRepository typed datasets', () => {
-  it('copies, filters, and stably orders typed columns without materializing point objects', () => {
-    const repository = new WorkerSamplingRepository()
-    const x = Float64Array.from([2, Number.NaN, 1, 1, 3])
-    const y = Float32Array.from([20, 99, 10, 11, Number.POSITIVE_INFINITY])
-    repository.handle({
-      type: 'register-dataset',
-      requestId: 80,
-      datasetId: 'typed',
-      revision: 0,
-      dataset: { kind: 'typed', x, y },
-    })
-    x[0] = 99
-    y[2] = 99
-
-    const sampled = repository.handle({
-      type: 'sample-viewport',
-      requestId: 81,
-      series: [
-        {
-          seriesId: 'typed',
-          datasetId: 'typed',
-          revision: 1,
-          xDomain: [1, 2],
-          plotWidth: 10,
-          mode: 'raw',
-          strategy: 'peak',
-        },
-      ],
-    })
-    const belowRange = repository.handle({
-      type: 'find-nearest-point',
-      requestId: 82,
-      datasetId: 'typed',
-      revision: 1,
-      x: 0,
-    })
-
-    expect(sampled).toMatchObject({
-      results: [
-        {
-          output: { kind: 'source-indexes', sourceIndexes: Uint32Array.from([0, 1, 2]) },
-        },
-      ],
-    })
-    expect(belowRange).toMatchObject({ status: 'ok', point: undefined })
-  })
-
-  it('derives sample X values from compact metadata and preserves source-time gaps', () => {
-    const repository = new WorkerSamplingRepository()
-    const values = new Float32Array([2, 6])
-    repository.handle({
-      type: 'register-dataset',
-      requestId: 90,
-      datasetId: 'samples',
-      revision: 0,
-      dataset: {
-        kind: 'samples',
-        values,
-        sampleRate: 2,
-        startTime: 10,
-        sourceIndexes: new Uint32Array([0, 2]),
-      },
-    })
-    values[0] = 99
-
-    expect(
-      repository.handle({
-        type: 'find-nearest-point',
-        requestId: 91,
-        datasetId: 'samples',
-        revision: 1,
-        x: 10.9,
-      }),
-    ).toMatchObject({ point: { x: 11, y: 6 } })
-    expect(
-      repository.handle({
-        type: 'get-dataset-metrics',
-        requestId: 92,
-        datasetId: 'samples',
-        revision: 1,
-      }),
-    ).toMatchObject({ metrics: { validPointCount: 2, xDomain: [10, 11], yDomain: [2, 6] } })
-  })
-})

package/src/core/workerSampling/repositoryWasmDataset.test.ts

@@ -1,70 +0,0 @@
-import { readFile } from 'node:fs/promises'
-import { resolve } from 'node:path'
-
-import { beforeAll, describe, expect, it } from 'vitest'
-
-import { createInitializedWasmSamplingBackend, initializeWasmSampling } from '../wasmSampling'
-import { WorkerSamplingRepository } from './repository'
-
-describe('WorkerSamplingRepository WASM datasets', () => {
-  beforeAll(async () => {
-    await initializeWasmSampling(
-      await readFile(resolve(process.cwd(), 'wasm/pkg/waveform_sampling_wasm_bg.wasm')),
-    )
-  })
-
-  it('registers typed columns in WASM, reports lazy index bytes, and releases handles on replace', () => {
-    const repository = new WorkerSamplingRepository({
-      wasmBackend: createInitializedWasmSamplingBackend(),
-      indexMaxBytes: 1024 * 1024,
-    })
-    const register = repository.handle({
-      type: 'register-dataset',
-      requestId: 1,
-      datasetId: 'typed',
-      revision: 0,
-      dataset: {
-        kind: 'typed',
-        x: Float64Array.from({ length: 65 }, (_, index) => index / 100),
-        y: Float32Array.from({ length: 65 }, (_, index) => (index === 31 ? 50 : index)),
-      },
-    })
-    const sampled = repository.handle({
-      type: 'sample-viewport',
-      requestId: 2,
-      series: [
-        {
-          seriesId: 'typed',
-          datasetId: 'typed',
-          revision: 1,
-          xDomain: [0.03, 0.61],
-          plotWidth: 4,
-          mode: 'wasm',
-          strategy: 'peak',
-          maxPointsPerPixel: 2,
-        },
-      ],
-    })
-
-    expect(register).toMatchObject({ status: 'ok', metrics: { indexBytes: 0 } })
-    expect(sampled).toMatchObject({ results: [{ diagnostics: { backend: 'wasm' } }] })
-    expect(repository.resourceMetrics.indexBytes).toBeGreaterThan(0)
-
-    const replaced = repository.handle({
-      type: 'replace-dataset',
-      requestId: 3,
-      datasetId: 'typed',
-      revision: 1,
-      dataset: {
-        kind: 'typed',
-        x: Float64Array.from([0, 1]),
-        y: Float32Array.from([1, 2]),
-      },
-    })
-
-    expect(replaced).toMatchObject({ status: 'ok', revision: 2, metrics: { indexBytes: 0 } })
-    expect(repository.resourceMetrics.indexBytes).toBe(0)
-    repository.handle({ type: 'dispose-all', requestId: 4 })
-    expect(repository.resourceMetrics).toMatchObject({ datasetCount: 0, indexBytes: 0 })
-  })
-})

package/src/data/simulatedWaveforms.test.ts

@@ -1,60 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { createSimulatedWaveformData } from './simulatedWaveforms'
-
-describe('simulated waveform data', () => {
-  it('creates deterministic, finite eight-channel data with a three-series second frame', () => {
-    const first = createSimulatedWaveformData()
-    const second = createSimulatedWaveformData()
-
-    expect(first).toEqual(second)
-    expect(first.kind).toBe('series')
-    if (first.kind !== 'series') return
-
-    expect(first.series).toHaveLength(8)
-    expect(new Set(first.series.map((series) => series.id)).size).toBe(8)
-    const secondFrame = first.series.filter(
-      (series) => series.trackId === 'simulated-harmonic-frame',
-    )
-    expect(secondFrame).toHaveLength(3)
-    expect(new Set(first.series.map((series) => series.shotNo))).toEqual(new Set(['13300']))
-    const firstSeries = first.series[0]
-    expect(firstSeries).toMatchObject({
-      id: 'simulated-sine',
-      lineType: 'linear',
-      pointType: 'circle',
-      errorBar: { visible: true, width: 1.5, capWidth: 10 },
-    })
-    if (firstSeries?.data.kind === 'points') {
-      const lowerErrors = firstSeries.data.points.map((point) => point.lowerError)
-      const upperErrors = firstSeries.data.points.map((point) => point.upperError)
-      expect(
-        lowerErrors.every((error) => error !== undefined && error >= 0.05 && error < 0.5),
-      ).toBe(true)
-      expect(
-        upperErrors.every((error) => error !== undefined && error >= 0.05 && error < 0.5),
-      ).toBe(true)
-      expect(new Set(lowerErrors).size).toBeGreaterThan(900)
-      expect(new Set(upperErrors).size).toBeGreaterThan(900)
-    }
-    first.series.forEach((series) => {
-      expect(series.data.kind).toBe('points')
-      if (series.data.kind !== 'points') return
-      if (series.id === 'simulated-step') {
-        expect(series.data.points).toHaveLength(500)
-        expect(series.data.points.every((point) => point.x >= 0)).toBe(true)
-      } else {
-        expect(series.data.points).toHaveLength(1_000)
-        expect(series.data.points[0]?.x).toBe(-5)
-      }
-      expect(series.data.points.at(-1)?.x).toBe(5)
-      series.data.points.forEach((point) => {
-        expect(Number.isFinite(point.x)).toBe(true)
-        expect(Number.isFinite(point.y)).toBe(true)
-        if (point.error !== undefined) expect(point.error).toBeGreaterThanOrEqual(0)
-        if (point.lowerError !== undefined) expect(point.lowerError).toBeGreaterThanOrEqual(0)
-        if (point.upperError !== undefined) expect(point.upperError).toBeGreaterThanOrEqual(0)
-      })
-    })
-  })
-})

package/src/demo/plotMarginControls.test.ts

@@ -1,29 +0,0 @@
-import { flushPromises, mount } from '@vue/test-utils'
-import { InputNumber } from 'ant-design-vue'
-import { describe, expect, it } from 'vitest'
-
-import App from '../App.vue'
-import { WaveformChart } from '../components'
-
-describe('plot margin demo controls', () => {
-  it('updates the chart top and bottom margins from the sidebar', async () => {
-    const wrapper = mount(App)
-    await flushPromises()
-    const chart = wrapper.getComponent(WaveformChart)
-    const controls = wrapper.get('.plot-margin-controls').findAllComponents(InputNumber)
-
-    expect(controls).toHaveLength(2)
-    expect(controls[0]?.props('value')).toBe(18)
-    expect(controls[1]?.props('value')).toBe(52)
-    expect(chart.props('plotMargin')).toEqual({ top: 18, bottom: 52 })
-
-    controls[0]?.vm.$emit('update:value', 30)
-    controls[1]?.vm.$emit('update:value', 70)
-    await flushPromises()
-
-    expect(chart.props('plotMargin')).toEqual({ top: 30, bottom: 70 })
-    expect(wrapper.get('.waveform-chart').attributes('data-plot-margin-top')).toBe('30')
-    expect(wrapper.get('.waveform-chart').attributes('data-plot-margin-bottom')).toBe('70')
-    wrapper.unmount()
-  })
-})

package/src/demo/xAxisLabelControls.test.ts

@@ -1,86 +0,0 @@
-import { flushPromises, mount } from '@vue/test-utils'
-import { InputNumber, Select } from 'ant-design-vue'
-import { describe, expect, it } from 'vitest'
-
-import App from '../App.vue'
-import { WaveformChart } from '../components'
-import { formatDemoTimestamp } from './useDemoXAxisLabelControls'
-
-describe('X-axis label demo controls', () => {
-  it('formats timestamps in fixed UTC and China-standard-time formats', () => {
-    expect(formatDemoTimestamp(0, 'UTC', false)).toBe('1970-01-01 00:00:00')
-    expect(formatDemoTimestamp(123, 'UTC', true)).toBe('1970-01-01 00:00:00.123')
-    expect(formatDemoTimestamp(0, 'Asia/Shanghai', false)).toBe('1970-01-01 08:00:00')
-    expect(formatDemoTimestamp(Number.NaN, 'UTC', false)).toBe('NaN')
-  })
-
-  it('configures numeric and timestamp labels from the sidebar', async () => {
-    const wrapper = mount(App)
-    await flushPromises()
-    const chart = wrapper.getComponent(WaveformChart)
-
-    expect(chart.props('axes')).toEqual({
-      x: { lineVisible: false },
-      y: { lineVisible: false },
-    })
-    expect(wrapper.find('[aria-label="自定义 X 轴 Label"]').exists()).toBe(true)
-    expect(wrapper.find('[aria-label="X 轴 Label 运算倍率"]').exists()).toBe(false)
-    expect(wrapper.find('[aria-label="X 轴 Label 小数位数"]').exists()).toBe(false)
-    expect(wrapper.find('[aria-label="X 轴 Label 格式类型"]').exists()).toBe(false)
-
-    await wrapper.get('[aria-label="自定义 X 轴 Label"]').trigger('click')
-    await flushPromises()
-    const inputNumbers = wrapper.findAllComponents(InputNumber)
-    const multiplierInput = inputNumbers.find((input) =>
-      input.find('[aria-label="X 轴 Label 运算倍率"]').exists(),
-    )
-    const fractionDigitsInput = inputNumbers.find((input) =>
-      input.find('[aria-label="X 轴 Label 小数位数"]').exists(),
-    )
-    expect(multiplierInput).toBeDefined()
-    expect(fractionDigitsInput).toBeDefined()
-    expect(multiplierInput?.props('value')).toBe(1)
-    expect(fractionDigitsInput?.props('value')).toBe(3)
-    expect(wrapper.get('.waveform-chart__axis-endpoint--start').text()).toMatch(/\.000$/)
-
-    multiplierInput?.vm.$emit('update:value', 2)
-    fractionDigitsInput?.vm.$emit('update:value', 2)
-    await flushPromises()
-    const formatter = chart.props('axes')?.x?.labelFormatter
-    expect(formatter).toBeTypeOf('function')
-    expect(formatter?.(1.234, {} as never)).toBe('2.47')
-    expect(wrapper.get('.waveform-chart__axis-endpoint--start').text()).toMatch(/\.00$/)
-
-    const formatSelect = wrapper
-      .findAllComponents(Select)
-      .find((select) => select.find('[aria-label="X 轴 Label 格式类型"]').exists())
-    expect(formatSelect?.props('value')).toBe('number')
-    formatSelect?.vm.$emit('update:value', 'datetime')
-    await flushPromises()
-    expect(wrapper.find('[aria-label="X 轴 Label 运算倍率"]').exists()).toBe(false)
-    expect(wrapper.find('[aria-label="X 轴 Label 小数位数"]').exists()).toBe(false)
-    expect(wrapper.find('[aria-label="X 轴 Label 时区"]').exists()).toBe(true)
-    expect(wrapper.find('[aria-label="X 轴 Label 显示毫秒"]').exists()).toBe(true)
-    expect(chart.props('axes')?.x?.labelFormatter?.(0, {} as never)).toBe('1970-01-01 08:00:00')
-
-    await wrapper.get('[aria-label="X 轴 Label 显示毫秒"]').trigger('click')
-    await flushPromises()
-    expect(chart.props('axes')?.x?.labelFormatter?.(123, {} as never)).toBe(
-      '1970-01-01 08:00:00.123',
-    )
-    const timeZoneSelect = wrapper
-      .findAllComponents(Select)
-      .find((select) => select.find('[aria-label="X 轴 Label 时区"]').exists())
-    timeZoneSelect?.vm.$emit('update:value', 'UTC')
-    await flushPromises()
-    expect(chart.props('axes')?.x?.labelFormatter?.(123, {} as never)).toBe(
-      '1970-01-01 00:00:00.123',
-    )
-
-    await wrapper.get('[aria-label="自定义 X 轴 Label"]').trigger('click')
-    await flushPromises()
-    expect(chart.props('axes')?.x?.labelFormatter).toBeUndefined()
-    expect(wrapper.find('[aria-label="X 轴 Label 运算倍率"]').exists()).toBe(false)
-    wrapper.unmount()
-  }, 10_000)
-})

package/src/test/setup.ts

@@ -1,82 +0,0 @@
-import { beforeEach, vi } from 'vitest'
-
-interface ResizeObserverEntryMock {
-  target: Element
-  contentRect: DOMRectReadOnly
-}
-
-type ResizeCallback = (entries: ResizeObserverEntryMock[]) => void
-
-export const resizeObservers: ResizeObserverMock[] = []
-const animationFrameCallbacks = new Map<number, FrameRequestCallback>()
-let animationFrameId = 0
-
-export class ResizeObserverMock {
-  private target?: Element
-
-  constructor(private readonly callback: ResizeCallback) {
-    resizeObservers.push(this)
-  }
-
-  observe = vi.fn((target: Element) => {
-    this.target = target
-  })
-
-  unobserve: () => void = vi.fn()
-  disconnect: () => void = vi.fn()
-
-  resize(width: number, height = 400) {
-    if (!this.target) return
-    this.callback([
-      {
-        target: this.target,
-        contentRect: { width, height } as DOMRectReadOnly,
-      },
-    ])
-  }
-}
-
-vi.stubGlobal('ResizeObserver', ResizeObserverMock)
-vi.stubGlobal(
-  'requestAnimationFrame',
-  vi.fn((callback: FrameRequestCallback) => {
-    animationFrameId += 1
-    animationFrameCallbacks.set(animationFrameId, callback)
-    return animationFrameId
-  }),
-)
-vi.stubGlobal(
-  'cancelAnimationFrame',
-  vi.fn((id: number) => {
-    animationFrameCallbacks.delete(id)
-  }),
-)
-vi.stubGlobal(
-  'matchMedia',
-  vi.fn((query: string): MediaQueryList => ({
-    matches: false,
-    media: query,
-    onchange: null,
-    addListener: vi.fn(),
-    removeListener: vi.fn(),
-    addEventListener: vi.fn(),
-    removeEventListener: vi.fn(),
-    dispatchEvent: vi.fn(),
-  })),
-)
-
-beforeEach(() => {
-  resizeObservers.length = 0
-  animationFrameCallbacks.clear()
-  animationFrameId = 0
-})
-
-export function flushAnimationFrames(timestamp = 0) {
-  const callbacks = Array.from(animationFrameCallbacks.values())
-  animationFrameCallbacks.clear()
-  callbacks.forEach((callback) => callback(timestamp))
-}
-
-export function pendingAnimationFrameCount(): number {
-  return animationFrameCallbacks.size
-}

package/src/test/waveformChart.ts

@@ -1,75 +0,0 @@
-import { flushPromises, mount } from '@vue/test-utils'
-
-import WaveformChart from '../components/WaveformChart.vue'
-import type { WaveformData } from '../components/waveform'
-import { resizeObservers } from './setup'
-
-export async function mountSizedChart(data: WaveformData, extraProps = {}) {
-  const wrapper = mount(WaveformChart, {
-    props: { data, ...extraProps },
-  })
-  resizeObservers.at(-1)?.resize(800, 360)
-  await flushPromises()
-  return wrapper
-}
-
-export function gridSeries(count: number): WaveformData {
-  return {
-    kind: 'series',
-    series: Array.from({ length: count }, (_, index) => ({
-      id: `channel-${index}`,
-      name: `通道 ${index + 1}`,
-      data: {
-        kind: 'points',
-        points: [
-          { x: 0, y: index },
-          { x: 1, y: index + 1 },
-        ],
-      },
-    })),
-  }
-}
-
-export function visibilitySeries(): WaveformData {
-  return {
-    kind: 'series',
-    series: [
-      {
-        id: 'low',
-        trackId: 'shared-frame',
-        name: '低量程',
-        data: {
-          kind: 'points',
-          points: [
-            { x: 0, y: 0 },
-            { x: 1, y: 10 },
-          ],
-        },
-      },
-      {
-        id: 'high',
-        trackId: 'shared-frame',
-        name: '高量程',
-        data: {
-          kind: 'points',
-          points: [
-            { x: 10, y: 1000 },
-            { x: 20, y: 2000 },
-          ],
-        },
-      },
-      {
-        id: 'mid',
-        trackId: 'shared-frame',
-        name: '中量程',
-        data: {
-          kind: 'points',
-          points: [
-            { x: 0, y: 100 },
-            { x: 1, y: 200 },
-          ],
-        },
-      },
-    ],
-  }
-}

package/src/utils/domain.test.ts

@@ -1,28 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { buildMinorTicks } from './domain'
-
-describe('buildMinorTicks', () => {
-  it('preserves the existing behavior when no domain is provided', () => {
-    expect(buildMinorTicks([0, 10, 20], 5)).toEqual([2, 4, 6, 8, 12, 14, 16, 18])
-  })
-
-  it('fills the partial interval after the final major tick', () => {
-    const majorTicks = Array.from({ length: 13 }, (_, index) => -8000 + index * 1000)
-
-    expect(buildMinorTicks(majorTicks, 5, [-8000, 4990.3]).slice(-4)).toEqual([
-      4200, 4400, 4600, 4800,
-    ])
-  })
-
-  it('fills both edge intervals and excludes the domain endpoints', () => {
-    const ticks = buildMinorTicks([-7000, -6000, -5000], 5, [-7950, -4100])
-
-    expect(ticks).toEqual([
-      -7800, -7600, -7400, -7200, -6800, -6600, -6400, -6200, -5800, -5600, -5400, -5200, -4800,
-      -4600, -4400, -4200,
-    ])
-    expect(ticks).not.toContain(-7950)
-    expect(ticks).not.toContain(-4100)
-  })
-})

package/src/utils/formatters.test.ts

@@ -1,131 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import type { WaveformXAxisLabelFormatter, WaveformXAxisLabelFormatterContext } from '../types'
-import {
-  formatAnnotationTime,
-  formatAxisTime,
-  formatEndpointTime,
-  formatPlainNumber,
-  formatScientificAxisExponent,
-  formatScientificAxisLabel,
-  formatTooltipNumber,
-  formatTooltipTime,
-  formatXAxisLabel,
-  resolveScientificAxisExponent,
-  shouldUseScientificAxisLabel,
-} from './formatters'
-
-describe('waveform number formatters', () => {
-  it('uses the reference Y-axis scientific notation boundaries', () => {
-    expect(shouldUseScientificAxisLabel(0)).toBe(false)
-    expect(shouldUseScientificAxisLabel(0.000999)).toBe(true)
-    expect(shouldUseScientificAxisLabel(0.001)).toBe(false)
-    expect(shouldUseScientificAxisLabel(999.999)).toBe(false)
-    expect(shouldUseScientificAxisLabel(1000)).toBe(true)
-  })
-
-  it('prefixes one shared exponent to the largest visible tick', () => {
-    const positiveAxis = { axisMin: 1000, axisMax: 3000 }
-    expect(formatScientificAxisLabel(1000, positiveAxis)).toBe('1')
-    expect(formatScientificAxisLabel(2000, positiveAxis)).toBe('2')
-    expect(formatScientificAxisLabel(3000, positiveAxis)).toBe('E+03 3')
-    expect(formatScientificAxisLabel(2000, { ...positiveAxis, topTickValue: 2000 })).toBe('E+03 2')
-    expect(formatScientificAxisExponent(1000, 3000)).toBe('E+03')
-    expect(formatScientificAxisExponent(0, 1e120)).toBe('E+120')
-
-    const tinyAxis = { axisMin: 0.0001, axisMax: 0.0003 }
-    expect(formatScientificAxisLabel(0.0001, tinyAxis)).toBe('1')
-    expect(formatScientificAxisLabel(0.0002, tinyAxis)).toBe('2')
-    expect(formatScientificAxisLabel(0.0003, tinyAxis)).toBe('E-04 3')
-    expect(formatScientificAxisExponent(0.0001, 0.0003)).toBe('E-04')
-  })
-
-  it('appends a unit to the top tick with or without scientific notation', () => {
-    expect(formatScientificAxisLabel(3000, { axisMin: 1000, axisMax: 3000, unit: 'V' })).toBe(
-      'E+03 (V) 3',
-    )
-    expect(formatScientificAxisLabel(3, { axisMin: 0, axisMax: 3, unit: 'A' })).toBe('(A) 3')
-    expect(formatScientificAxisLabel(2, { axisMin: 0, axisMax: 3, unit: 'A' })).toBe('2')
-    expect(formatScientificAxisLabel(3, { axisMin: 0, axisMax: 3, unit: '  ' })).toBe('3')
-  })
-
-  it('derives the exponent from the largest absolute endpoint', () => {
-    expect(resolveScientificAxisExponent(-9000, -1000)).toBe(3)
-    expect(resolveScientificAxisExponent(-100_000, -3000)).toBe(5)
-    expect(resolveScientificAxisExponent(-10_000, 3000)).toBe(4)
-    expect(resolveScientificAxisExponent(-1000, 0)).toBe(3)
-    expect(resolveScientificAxisExponent(0, 0)).toBeNull()
-  })
-
-  it('keeps five significant digits, removes trailing zeroes, and limits decimals to four', () => {
-    expect(formatScientificAxisLabel(123.456, { axisMin: 0, axisMax: 999 })).toBe('123.46')
-    expect(formatScientificAxisLabel(1234.56, { axisMin: 0, axisMax: 9999 })).toBe('1.2346')
-    expect(formatScientificAxisLabel(3000, { axisMin: 1000, axisMax: 3000 })).toBe('E+03 3')
-    expect(formatScientificAxisLabel(-0, { axisMin: -1, axisMax: 1 })).toBe('0')
-    expect(formatScientificAxisLabel(Number.NaN)).toBe('NaN')
-    expect(formatScientificAxisLabel(Number.POSITIVE_INFINITY)).toBe('Infinity')
-    expect(formatScientificAxisExponent(0, 0)).toBeNull()
-  })
-
-  it('formats X-axis ticks and endpoints as complete plain values in the display unit', () => {
-    const domain: [number, number] = [0, 1]
-    expect(formatAxisTime(0.5004, 'ms', domain)).toBe('500.4')
-    expect(formatEndpointTime(1, domain, 'ms')).toBe('1000')
-    expect(formatAxisTime(0.5, 's', domain)).toBe('0.5')
-    expect(formatEndpointTime(1, domain, 's')).toBe('1')
-
-    const tinyDomain: [number, number] = [0, 0.000001]
-    expect(formatEndpointTime(0.000001, tinyDomain, 's')).toBe('0.000001')
-    expect(formatAxisTime(-0.000001, 's', tinyDomain)).toBe('-0.000001')
-    expect(formatAxisTime(-0, 's')).toBe('0')
-    expect(formatAxisTime(1e21, 's')).toBe('1000000000000000000000')
-    expect(formatAxisTime(Number.POSITIVE_INFINITY, 's')).toBe('Infinity')
-  })
-
-  it('passes display values and complete source context to X-axis label formatters', () => {
-    const domain: [number, number] = [0.125, 1.875]
-    const formatter: WaveformXAxisLabelFormatter = (value, context) =>
-      `${context.kind}:${value / 10}`
-
-    expect(formatXAxisLabel(0.5, domain, 'ms', 'tick', formatter)).toBe('tick:50')
-    expect(formatXAxisLabel(domain[0], domain, 'ms', 'start', formatter)).toBe('start:12.5')
-    expect(formatXAxisLabel(domain[1], domain, 'ms', 'end', formatter)).toBe('end:187.5')
-
-    let receivedContext: WaveformXAxisLabelFormatterContext | undefined
-    formatXAxisLabel(0.5, domain, 'ms', 'tick', (value, context) => {
-      receivedContext = context
-      return String(value)
-    })
-    expect(receivedContext).toEqual({
-      kind: 'tick',
-      rawValue: 0.5,
-      timeUnit: 'ms',
-      domain: [0.125, 1.875],
-      displayDomain: [125, 1875],
-    })
-
-    expect(() =>
-      formatXAxisLabel(0.5, domain, 's', 'tick', () => {
-        throw new Error('formatter failed')
-      }),
-    ).toThrow('formatter failed')
-  })
-
-  it('formats tooltip and raw values for their display contexts', () => {
-    expect(formatTooltipNumber(12345.67891)).toBe('12,345.6789')
-    expect(formatTooltipNumber(-0)).toBe('0')
-    expect(formatTooltipNumber(Number.POSITIVE_INFINITY)).toBe('Infinity')
-    expect(formatTooltipTime(1.234567, 's')).toBe('1.2346')
-    expect(formatTooltipTime(1, 'ms')).toBe('1,000')
-    expect(formatPlainNumber(0.0000001)).toBe('0.0000001')
-    expect(formatPlainNumber(1e21)).toBe('1000000000000000000000')
-    expect(formatPlainNumber(-0)).toBe('0')
-  })
-
-  it('formats annotation time in the selected unit without changing source seconds', () => {
-    expect(formatAnnotationTime(1, 'ms')).toBe('1000.000')
-    expect(formatAnnotationTime(1, 's')).toBe('1.000')
-    expect(formatAnnotationTime(-0, 'ms')).toBe('0.000')
-    expect(formatAnnotationTime(Number.NaN, 's')).toBe('NaN')
-  })
-})