waveform-analysis 0.1.62 → 0.1.64

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

@@ -1,373 +0,0 @@
-import { zoomIdentity } from 'd3'
-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'
-
-function series(id: string, minimum: number, maximum: number): DisplaySeries {
-  return {
-    id,
-    name: id,
-    color: '#1677ff',
-    lineType: 'linear',
-    lineStyle: 'solid',
-    pointType: 'none',
-    errorBar: { visible: false, width: 1.5, capWidth: 8 },
-    points: [
-      { x: 0, y: minimum },
-      { x: 1, y: maximum },
-    ],
-    xDomain: [0, 1],
-    yDomain: [minimum, maximum],
-    hasErrorPoints: false,
-  }
-}
-
-function track(seriesList: DisplaySeries[]): DisplayTrack {
-  return {
-    id: 'track',
-    series: seriesList,
-    visibleSeries: seriesList,
-    xDomain: [0, 1],
-    yDomain: [0, 50],
-  }
-}
-
-function layoutForSeries(
-  sourceSeries: DisplaySeries,
-  rendering = DEFAULT_WAVEFORM_RENDERING_OPTIONS,
-  transform = zoomIdentity,
-) {
-  const sourceTrack = track([sourceSeries])
-  sourceTrack.xDomain = sourceSeries.xDomain
-  sourceTrack.yDomain = sourceSeries.yDomain
-  return buildTrackLayouts({
-    cells: [
-      {
-        slotIndex: 0,
-        row: 0,
-        column: 0,
-        left: 0,
-        top: 0,
-        width: 120,
-        height: 100,
-        plotHeight: 100,
-        cellHeight: 130,
-        xAxisBand: 30,
-        series: sourceTrack,
-      },
-    ],
-    grid: {
-      rowCount: 1,
-      columnCount: 1,
-      showPagination: false,
-      fillIncompleteLastRow: false,
-      trackLines: {},
-    },
-    displayMode: 'independent',
-    overlayMode: 'single-axis',
-    independentTransforms: [transform],
-    sharedZoomDomain: sourceSeries.xDomain,
-    yDomains: undefined,
-    timeUnit: 'ms',
-    rendering,
-    hideSecondaryLabels: false,
-    yAxisLabelX: -50,
-    showCompactEmptyTracks: false,
-  })[0]!.seriesPaths[0]!
-}
-
-describe('multi-value Y-axis grouping', () => {
-  it('rebuilds Y scales when the same track ID receives a different domain', () => {
-    const first = layoutForSeries(series('shared', 0, 1))
-    const second = layoutForSeries(series('shared', 10_000, 20_000))
-
-    expect(first.yScale.domain()).toEqual([0, 1])
-    expect(second.yScale.domain()).toEqual([10_000, 20_000])
-  })
-
-  it('uses a configured visible Y domain for axis and series scales', () => {
-    const source = series('a', 0, 100)
-    const sourceTrack = track([source])
-    const result = buildTrackLayouts({
-      cells: [
-        {
-          slotIndex: 0,
-          row: 0,
-          column: 0,
-          left: 0,
-          top: 0,
-          width: 120,
-          height: 100,
-          plotHeight: 100,
-          cellHeight: 130,
-          xAxisBand: 30,
-          series: sourceTrack,
-        },
-      ],
-      grid: {
-        rowCount: 1,
-        columnCount: 1,
-        showPagination: false,
-        fillIncompleteLastRow: false,
-        trackLines: {},
-      },
-      displayMode: 'independent',
-      overlayMode: 'single-axis',
-      independentTransforms: [zoomIdentity],
-      sharedZoomDomain: [0, 1],
-      yDomains: { track: [25, 75] },
-      timeUnit: 'ms',
-      rendering: DEFAULT_WAVEFORM_RENDERING_OPTIONS,
-      hideSecondaryLabels: false,
-      yAxisLabelX: -50,
-      showCompactEmptyTracks: false,
-    })[0]
-
-    expect(result?.yScale.domain()).toEqual([20, 80])
-    expect(result?.seriesPaths[0]?.yScale.domain()).toEqual([20, 80])
-  })
-
-  it('normalizes configured Y-axis split counts', () => {
-    expect(resolveYAxisTickCount(100, 0)).toBe(2)
-    expect(resolveYAxisTickCount(100, 4.8)).toBe(4)
-    expect(resolveYAxisTickCount(100, Number.NaN)).toBe(5)
-    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)]),
-      'single-axis',
-    )
-
-    expect(groups).toHaveLength(1)
-    expect(groups[0]?.seriesList.map((item) => item.id)).toEqual(['a', 'b'])
-    expect(groups[0]?.domain).toEqual([0, 50])
-  })
-
-  it('uses the reference left-right axis order and merges overflow into axis four', () => {
-    const groups = buildYAxisSeriesGroups(
-      track([
-        series('a', 0, 1),
-        series('b', 10, 11),
-        series('c', 20, 21),
-        series('d', 30, 31),
-        series('e', 40, 50),
-      ]),
-      'multi-axis',
-    )
-
-    expect(groups).toHaveLength(MAX_MULTI_Y_AXIS_COUNT)
-    expect(groups.map((group) => group.side)).toEqual(['left', 'left', 'right', 'right'])
-    expect(groups.map((group) => group.seriesList.map((item) => item.id))).toEqual([
-      ['a'],
-      ['b'],
-      ['c'],
-      ['d', 'e'],
-    ])
-    expect(groups[3]?.domain[0]).toBeLessThanOrEqual(30)
-    expect(groups[3]?.domain[1]).toBeGreaterThanOrEqual(50)
-  })
-
-  it('derives merged multi-axis domains from precomputed series domains', () => {
-    const first = series('a', -20, -10)
-    const second = series('b', 40, 60)
-    first.points = [{ x: 0, y: -15 }]
-    second.points = [{ x: 0, y: 50 }]
-
-    const groups = buildYAxisSeriesGroups(
-      track([
-        series('left', 0, 1),
-        series('middle', 10, 11),
-        series('right', 20, 21),
-        first,
-        second,
-      ]),
-      'multi-axis',
-    )
-
-    expect(groups[3]?.domain[0]).toBeLessThanOrEqual(-20)
-    expect(groups[3]?.domain[1]).toBeGreaterThanOrEqual(60)
-  })
-
-  it('places two and three axes on the expected sides', () => {
-    const source = [series('a', 0, 1), series('b', 10, 11), series('c', 20, 21)]
-
-    expect(
-      buildYAxisSeriesGroups(track(source.slice(0, 2)), 'multi-axis').map((g) => g.side),
-    ).toEqual(['left', 'right'])
-    expect(buildYAxisSeriesGroups(track(source), 'multi-axis').map((g) => g.side)).toEqual([
-      'left',
-      'right',
-      'right',
-    ])
-  })
-
-  it('reserves label clearance for exponent-prefixed ticks on both axis sides', () => {
-    const layout = buildTrackLayouts({
-      cells: [
-        {
-          slotIndex: 0,
-          row: 0,
-          column: 0,
-          left: 0,
-          top: 0,
-          width: 600,
-          height: 300,
-          plotHeight: 300,
-          cellHeight: 330,
-          xAxisBand: 30,
-          series: track([series('left', 1000, 3000), series('right', 1000, 3000)]),
-        },
-      ],
-      grid: {
-        rowCount: 1,
-        columnCount: 1,
-        showPagination: false,
-        fillIncompleteLastRow: false,
-        trackLines: {},
-      },
-      displayMode: 'independent',
-      overlayMode: 'multi-axis',
-      independentTransforms: [zoomIdentity],
-      sharedZoomDomain: [0, 1],
-      timeUnit: 'ms',
-      rendering: DEFAULT_WAVEFORM_RENDERING_OPTIONS,
-      hideSecondaryLabels: false,
-      yAxisLabelX: -50,
-      showCompactEmptyTracks: false,
-    })[0]
-
-    expect(
-      layout?.yAxes.map(({ side, x, labelX }) => ({
-        side,
-        labelOffset: Math.abs(labelX - x),
-      })),
-    ).toEqual([
-      { side: 'left', labelOffset: 55 },
-      { side: 'right', labelOffset: 45 },
-    ])
-  })
-
-  it('retains enough outer clearance for long scientific exponents', () => {
-    const [group] = buildYAxisSeriesGroups(track([series('long', -1e120, 1e120)]), 'multi-axis')
-
-    expect(group).toBeDefined()
-    expect(measureYAxisGroupClearance(group!)).toBe(72)
-  })
-})
-
-describe('track hit testing', () => {
-  const tracks = [
-    { id: 'first', left: 0, top: 0, width: 100, height: 40 },
-    { id: 'second', left: 0, top: 50, width: 100, height: 40 },
-  ]
-
-  it('switches tracks immediately across a boundary less than five pixels apart', () => {
-    expect(findClosestTrackAtPointer(tracks, 50, 44)?.id).toBe('first')
-    expect(findClosestTrackAtPointer(tracks, 50, 46)?.id).toBe('second')
-  })
-})
-
-describe('decoration sampling', () => {
-  const denseSeries = (): DisplaySeries => ({
-    ...series('dense', -1, 1),
-    pointType: 'circle',
-    errorBar: { visible: true, width: 1.5, capWidth: 8 },
-    points: Array.from({ length: 1_000 }, (_, index) => ({
-      x: index,
-      y: Math.sin(index / 20),
-      error: index % 200 === 1 ? 0.1 : 0,
-    })),
-    xDomain: [0, 999],
-    hasErrorPoints: true,
-  })
-
-  it('shares prioritized source points between dense symbols and error bars', () => {
-    const sourceSeries = denseSeries()
-    const path = layoutForSeries(sourceSeries, {
-      ...DEFAULT_WAVEFORM_RENDERING_OPTIONS,
-      pointMinSpacing: 10,
-      errorBarMinSpacing: 12,
-    })
-    const sourceErrorPoints = sourceSeries.points.filter((point) => point.error !== 0)
-
-    expect(path.errorBarRenderPoints).toEqual(sourceErrorPoints)
-    expect(path.errorBarRenderPoints.every((point) => path.pointRenderPoints.includes(point))).toBe(
-      true,
-    )
-    expect(path.pointRenderPoints.length).toBeLessThanOrEqual(Math.ceil(120 / 12) + 2)
-  })
-
-  it('keeps standalone, zero-error, and non-downsampled decoration behavior', () => {
-    const noErrors = denseSeries()
-    noErrors.points = noErrors.points.map((point) => ({ x: point.x, y: point.y }))
-    noErrors.hasErrorPoints = false
-    const zeroErrorPath = layoutForSeries(noErrors)
-    expect(zeroErrorPath.errorBarRenderPoints).toEqual([])
-    expect(zeroErrorPath.pointRenderPoints.length).toBeLessThanOrEqual(Math.ceil(120 / 10) + 2)
-
-    const errorsOnly = denseSeries()
-    errorsOnly.pointType = 'none'
-    const errorsOnlyPath = layoutForSeries(errorsOnly)
-    expect(errorsOnlyPath.pointRenderPoints).toEqual([])
-    expect(errorsOnlyPath.errorBarRenderPoints.length).toBeLessThanOrEqual(Math.ceil(120 / 12) + 2)
-
-    const pointsOnly = denseSeries()
-    pointsOnly.errorBar.visible = false
-    const pointsOnlyPath = layoutForSeries(pointsOnly)
-    expect(pointsOnlyPath.errorBarRenderPoints).toEqual([])
-    expect(pointsOnlyPath.pointRenderPoints.length).toBeLessThanOrEqual(Math.ceil(120 / 10) + 2)
-
-    const completePath = layoutForSeries(denseSeries(), {
-      ...DEFAULT_WAVEFORM_RENDERING_OPTIONS,
-      downsample: false,
-    })
-    expect(completePath.pointRenderPoints).toHaveLength(1_000)
-    expect(completePath.errorBarRenderPoints).toHaveLength(5)
-  })
-
-  it('restores every visible source decoration after zooming to sparse spacing', () => {
-    const path = layoutForSeries(
-      denseSeries(),
-      DEFAULT_WAVEFORM_RENDERING_OPTIONS,
-      zoomIdentity.scale(200),
-    )
-
-    expect(path.pointRenderPoints.map((point) => point.x)).toEqual([0, 1, 2, 3, 4])
-    expect(path.errorBarRenderPoints.map((point) => point.x)).toEqual([1])
-  })
-})

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

@@ -1,76 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { calculateRotatedTitleLayout, TITLE_AREA_MAX_HEIGHT, TITLE_AREA_MIN_HEIGHT } from './title'
-
-describe('calculateRotatedTitleLayout', () => {
-  it('reserves the available width for an unrotated title that fits', () => {
-    expect(
-      calculateRotatedTitleLayout({
-        naturalWidth: 200,
-        naturalHeight: 20,
-        availableWidth: 300,
-        rotation: 0,
-      }),
-    ).toEqual({
-      textWidth: 300,
-      textHeight: 20,
-      visualWidth: 300,
-      visualHeight: 20,
-      areaHeight: TITLE_AREA_MIN_HEIGHT,
-      scale: 1,
-      wrapped: false,
-    })
-  })
-
-  it.each([45, 90, -90, 180])('keeps a %s degree title inside the maximum area', (rotation) => {
-    const layout = calculateRotatedTitleLayout({
-      naturalWidth: 400,
-      naturalHeight: 20,
-      availableWidth: 600,
-      rotation,
-    })
-
-    expect(layout.areaHeight).toBeGreaterThanOrEqual(TITLE_AREA_MIN_HEIGHT)
-    expect(layout.areaHeight).toBeLessThanOrEqual(TITLE_AREA_MAX_HEIGHT)
-    expect(layout.visualHeight).toBeLessThanOrEqual(TITLE_AREA_MAX_HEIGHT)
-    expect(layout.textWidth).toBe(400)
-    expect(layout.scale).toBeLessThanOrEqual(1)
-    expect(layout.wrapped).toBe(false)
-  })
-
-  it('wraps an unrotated title to the available width without scaling', () => {
-    const layout = calculateRotatedTitleLayout({
-      naturalWidth: 1_000,
-      naturalHeight: 20,
-      availableWidth: 120,
-      rotation: 0,
-    })
-
-    expect(layout.textWidth).toBe(120)
-    expect(layout.textHeight).toBe(180)
-    expect(layout.visualWidth).toBe(120)
-    expect(layout.visualHeight).toBe(180)
-    expect(layout.areaHeight).toBe(198)
-    expect(layout.scale).toBe(1)
-    expect(layout.wrapped).toBe(true)
-  })
-
-  it('falls back safely for non-finite dimensions and rotation', () => {
-    const layout = calculateRotatedTitleLayout({
-      naturalWidth: Number.NaN,
-      naturalHeight: Number.POSITIVE_INFINITY,
-      availableWidth: Number.NaN,
-      rotation: Number.NaN,
-    })
-
-    expect(layout).toEqual({
-      textWidth: 1,
-      textHeight: 1,
-      visualWidth: 1,
-      visualHeight: 1,
-      areaHeight: TITLE_AREA_MIN_HEIGHT,
-      scale: 1,
-      wrapped: false,
-    })
-  })
-})

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

@@ -1,95 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { prepareWaveformSeries } from './useWaveformData'
-
-describe('prepareWaveformSeries compact inputs', () => {
-  it('keeps dense typed samples as numeric columns until individual points are requested', () => {
-    const values = Float32Array.from({ length: 100_001 }, (_, index) => index / 10)
-    const snapshot = values.slice()
-    const [series] = prepareWaveformSeries({
-      kind: 'typed-samples',
-      values,
-      sampleRate: 1_000,
-      startTime: 2,
-    })
-
-    expect(series?.source.isCompact).toBe(true)
-    expect(series?.points).toHaveLength(values.length)
-    expect(series?.xDomain[0]).toBeLessThanOrEqual(2)
-    expect(series?.xDomain[1]).toBeGreaterThanOrEqual(102)
-    expect(series?.source.pointAt(50_000)).toEqual({ x: 52, y: 5_000 })
-    expect(values).toEqual(snapshot)
-
-    const workerDataset = series?.source.toWorkerDataset()
-    expect(workerDataset).toMatchObject({
-      kind: 'samples',
-      sampleRate: 1_000,
-      startTime: 2,
-    })
-    if (workerDataset?.kind === 'samples') {
-      expect(workerDataset).not.toHaveProperty('sourceIndexes')
-      expect(workerDataset.values.buffer).not.toBe(values.buffer)
-      expect(workerDataset.values).toEqual(values)
-    }
-  })
-
-  it('preserves invalid-sample time gaps without allocating an X column', () => {
-    const [series] = prepareWaveformSeries({
-      kind: 'typed-samples',
-      values: new Float64Array([1, Number.NaN, 3]),
-      sampleRate: 2,
-      startTime: 10,
-    })
-
-    expect(series?.source.pointsInRange()).toEqual([
-      { x: 10, y: 1 },
-      { x: 11, y: 3 },
-    ])
-    expect(series?.source.toWorkerDataset()).toMatchObject({
-      kind: 'samples',
-      values: new Float64Array([1, 3]),
-      sourceIndexes: new Uint32Array([0, 2]),
-    })
-  })
-
-  it('filters and stably orders compact typed points without materializing source point objects', () => {
-    const [series] = prepareWaveformSeries({
-      kind: 'typed-points',
-      x: new Float64Array([2, 1, 1, Number.NaN]),
-      y: new Float32Array([20, 10, 11, 12]),
-      error: new Float32Array([1, -1, Number.NaN, 4]),
-    })
-
-    expect(series?.source.isCompact).toBe(true)
-    expect(series?.source.pointsInRange()).toEqual([
-      { x: 1, y: 10 },
-      { x: 1, y: 11 },
-      { x: 2, y: 20, error: 1 },
-    ])
-    expect(series?.source.visibleRange([1, 1])).toEqual({ start: 0, end: 2 })
-    expect(series?.source.nearestPoint(-10)).toEqual({ x: 1, y: 10 })
-    expect(series?.source.nearestPoint(10)).toEqual({ x: 2, y: 20, error: 1 })
-  })
-
-  it('retains normal array access, iteration, slicing, mapping, and enumeration semantics', () => {
-    const [series] = prepareWaveformSeries({
-      kind: 'typed-samples',
-      values: new Float32Array([2, 4, 6]),
-      sampleRate: 2,
-    })
-
-    expect(series?.points[1]).toEqual({ x: 0.5, y: 4 })
-    expect(series?.points.at(-1)).toEqual({ x: 1, y: 6 })
-    expect([...(series?.points ?? [])]).toEqual([
-      { x: 0, y: 2 },
-      { x: 0.5, y: 4 },
-      { x: 1, y: 6 },
-    ])
-    expect(series?.points.slice(1)).toEqual([
-      { x: 0.5, y: 4 },
-      { x: 1, y: 6 },
-    ])
-    expect(series?.points.map((point) => point.y)).toEqual([2, 4, 6])
-    expect(Object.keys(series?.points ?? [])).toEqual(['0', '1', '2'])
-  })
-})

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

@@ -1,17 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { resolveAutoSelectedMode } from './latestTaskScheduler'
-
-describe('resolveAutoSelectedMode', () => {
-  it('uses the exact threshold when no interaction selection is supplied', () => {
-    expect(resolveAutoSelectedMode(1_000, 1_000, 200)).toBe('raw')
-    expect(resolveAutoSelectedMode(1_001, 1_000, 200)).toBe('sampled')
-  })
-
-  it('keeps the previous mode inside the configured interaction hysteresis band', () => {
-    expect(resolveAutoSelectedMode(1_100, 1_000, 200, 'raw')).toBe('raw')
-    expect(resolveAutoSelectedMode(1_201, 1_000, 200, 'raw')).toBe('sampled')
-    expect(resolveAutoSelectedMode(900, 1_000, 200, 'sampled')).toBe('sampled')
-    expect(resolveAutoSelectedMode(800, 1_000, 200, 'sampled')).toBe('raw')
-  })
-})

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

@@ -1,28 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { applyXDomainStrategy } from './xDomain'
-
-describe('applyXDomainStrategy', () => {
-  it('keeps the exact data domain by default', () => {
-    expect(applyXDomainStrategy([0, 4999.999], { type: 'data' })).toEqual([0, 4999.999])
-  })
-
-  it('expands both bounds to stable nice values', () => {
-    expect(applyXDomainStrategy([123, 456], { type: 'nice' })).toEqual([100, 500])
-  })
-
-  it('can expand only the end bound', () => {
-    expect(applyXDomainStrategy([123, 456], { type: 'nice', bounds: 'end' })).toEqual([123, 500])
-  })
-
-  it('keeps explicit domains exact unless they are included', () => {
-    expect(applyXDomainStrategy([123, 456], { type: 'nice' }, true)).toEqual([123, 456])
-    expect(applyXDomainStrategy([123, 456], { type: 'nice', includeExplicit: true }, true)).toEqual(
-      [100, 500],
-    )
-  })
-
-  it('falls back to the default tick count for invalid values', () => {
-    expect(applyXDomainStrategy([0, 4999.999], { type: 'nice', tickCount: 0 })).toEqual([0, 5000])
-  })
-})