waveform-analysis 0.1.63 → 0.1.64

package/src/core/renderingStrategies.test.ts

@@ -1,90 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import type { WaveformPoint } from '../types'
-import { DEFAULT_WAVEFORM_RENDERING_OPTIONS } from './renderingOptions'
-import {
-  peakPreservingPointSelectionStrategy,
-  resolveRenderablePointSelectionStrategy,
-  type RenderablePointSelectionContext,
-} from './renderingStrategies'
-
-const denseOptions = {
-  ...DEFAULT_WAVEFORM_RENDERING_OPTIONS,
-  downsampleThreshold: 0,
-  maxPointsPerPixel: 1,
-}
-
-describe('renderable point selection strategies', () => {
-  it('resolves complete-point selection at the configured boundaries', () => {
-    const context: RenderablePointSelectionContext = {
-      points: [
-        { x: 0, y: 5 },
-        { x: 1, y: 1 },
-        { x: 2, y: 10 },
-        { x: 3, y: 3 },
-        { x: 4, y: 7 },
-      ],
-      range: { start: 0, end: 5 },
-      domain: [0, 4],
-      width: 100,
-      options: DEFAULT_WAVEFORM_RENDERING_OPTIONS,
-    }
-    const complete = resolveRenderablePointSelectionStrategy({
-      visibleCount: 100,
-      width: 100,
-      options: DEFAULT_WAVEFORM_RENDERING_OPTIONS,
-    })(context)
-    const disabled = resolveRenderablePointSelectionStrategy({
-      visibleCount: 10_000,
-      width: 100,
-      options: { ...denseOptions, downsample: false },
-    })(context)
-
-    expect(complete).toEqual(context.points)
-    expect(disabled).toEqual(context.points)
-  })
-
-  it('resolves peak-preserving selection for dense visible data', () => {
-    const context: RenderablePointSelectionContext = {
-      points: [
-        { x: 0, y: 5 },
-        { x: 1, y: 1 },
-        { x: 2, y: 10 },
-        { x: 3, y: 3 },
-        { x: 4, y: 7 },
-      ],
-      range: { start: 0, end: 5 },
-      domain: [0, 4],
-      width: 4,
-      options: denseOptions,
-    }
-    const selected = resolveRenderablePointSelectionStrategy({
-      visibleCount: 1_000,
-      width: 4,
-      options: denseOptions,
-    })(context)
-
-    expect(selected).toEqual(expect.arrayContaining([context.points[1], context.points[2]]))
-  })
-
-  it('retains first, last, minimum, and maximum points in a peak bucket', () => {
-    const points: WaveformPoint[] = [
-      { x: 0, y: 5 },
-      { x: 1, y: 1 },
-      { x: 2, y: 10 },
-      { x: 3, y: 3 },
-      { x: 4, y: 7 },
-    ]
-    const selected = peakPreservingPointSelectionStrategy({
-      points,
-      range: { start: 0, end: points.length },
-      domain: [0, 4],
-      width: 4,
-      options: denseOptions,
-    })
-
-    expect(selected[0]).toBe(points[0])
-    expect(selected.at(-1)).toBe(points.at(-1))
-    expect(selected.map((point) => point.y)).toEqual(expect.arrayContaining([1, 10]))
-  })
-})

package/src/core/samplingReference.test.ts

@@ -1,124 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import type { WaveformPoint } from '../types'
-import {
-  sampleWaveformReference,
-  type ReferenceSamplingStrategy,
-  type SourceIndexSamplingResult,
-} from './samplingReference'
-import {
-  REFERENCE_AGGREGATE_VECTORS,
-  REFERENCE_SAMPLING_POINTS,
-  REFERENCE_SOURCE_INDEX_VECTORS,
-} from './samplingReferenceVectors'
-
-function indexes(strategy: Exclude<ReferenceSamplingStrategy, 'average' | 'sum'>, target: number) {
-  const result = sampleWaveformReference({
-    points: REFERENCE_SAMPLING_POINTS,
-    strategy,
-    targetPointCount: target,
-  })
-  expect(result.kind).toBe('source-indexes')
-  return Array.from((result as SourceIndexSamplingResult).sourceIndexes)
-}
-
-describe('sampleWaveformReference', () => {
-  it('locks the source-index strategy vectors', () => {
-    for (const vector of REFERENCE_SOURCE_INDEX_VECTORS) {
-      expect(indexes(vector.strategy, vector.targetPointCount)).toEqual(
-        vector.expectedSourceIndexes,
-      )
-    }
-  })
-
-  it('locks the aggregate bucket and synthesized-X semantics', () => {
-    for (const vector of REFERENCE_AGGREGATE_VECTORS) {
-      const result = sampleWaveformReference({
-        points: REFERENCE_SAMPLING_POINTS,
-        strategy: vector.strategy,
-        targetPointCount: vector.targetPointCount,
-      })
-
-      expect(result).toMatchObject({ kind: 'aggregates', validPointCount: 8 })
-      expect(Array.from(result.kind === 'aggregates' ? result.x : [])).toEqual(vector.expectedX)
-      expect(Array.from(result.kind === 'aggregates' ? result.y : [])).toEqual(vector.expectedY)
-    }
-  })
-
-  it('uses the earliest point for equal extrema and removes duplicate peak entries', () => {
-    const tied = [
-      { x: 0, y: 0 },
-      { x: 1, y: -5 },
-      { x: 2, y: -5 },
-      { x: 3, y: 5 },
-      { x: 4, y: 5 },
-      { x: 5, y: 0 },
-      { x: 6, y: 0 },
-    ]
-
-    const minmax = sampleWaveformReference({
-      points: tied,
-      strategy: 'minmax',
-      targetPointCount: 4,
-    })
-    const peak = sampleWaveformReference({ points: tied, strategy: 'peak', targetPointCount: 6 })
-
-    expect(Array.from(minmax.kind === 'source-indexes' ? minmax.sourceIndexes : [])).toEqual([
-      0, 1, 3, 6,
-    ])
-    expect(Array.from(peak.kind === 'source-indexes' ? peak.sourceIndexes : [])).toEqual([
-      0, 1, 3, 5, 6,
-    ])
-  })
-
-  it('filters invalid points, stably orders X, and returns indexes into the original input', () => {
-    const input: WaveformPoint[] = [
-      { x: 2, y: 20 },
-      { x: Number.NaN, y: 99 },
-      { x: 1, y: 10 },
-      { x: 1, y: 11 },
-      { x: 3, y: Number.POSITIVE_INFINITY },
-    ]
-    const result = sampleWaveformReference({ points: input, strategy: 'none', targetPointCount: 1 })
-
-    expect(result).toMatchObject({ inputPointCount: 5, validPointCount: 3, kind: 'source-indexes' })
-    expect(Array.from(result.kind === 'source-indexes' ? result.sourceIndexes : [])).toEqual([
-      2, 3, 0,
-    ])
-    expect(input).toEqual([
-      { x: 2, y: 20 },
-      { x: Number.NaN, y: 99 },
-      { x: 1, y: 10 },
-      { x: 1, y: 11 },
-      { x: 3, y: Number.POSITIVE_INFINITY },
-    ])
-  })
-
-  it('defines empty, short, and low-target behavior without exceeding the target', () => {
-    const strategies: ReferenceSamplingStrategy[] = [
-      'none',
-      'peak',
-      'lttb',
-      'average',
-      'min',
-      'max',
-      'minmax',
-      'sum',
-    ]
-    for (const strategy of strategies) {
-      const empty = sampleWaveformReference({ points: [], strategy, targetPointCount: 3 })
-      expect(empty.kind === 'aggregates' ? empty.x : empty.sourceIndexes).toHaveLength(0)
-
-      const short = sampleWaveformReference({
-        points: REFERENCE_SAMPLING_POINTS.slice(0, 2),
-        strategy,
-        targetPointCount: 10,
-      })
-      expect(short.kind === 'aggregates' ? short.x : short.sourceIndexes).toHaveLength(2)
-    }
-
-    expect(indexes('lttb', 2)).toEqual([0, 7])
-    expect(indexes('minmax', 3)).toEqual([0, 7])
-    expect(indexes('peak', 6)).toHaveLength(5)
-  })
-})

package/src/core/wasmSampling.test.ts

@@ -1,205 +0,0 @@
-/// <reference types="node" />
-
-import { readFile } from 'node:fs/promises'
-import { resolve } from 'node:path'
-
-import { beforeAll, describe, expect, it } from 'vitest'
-
-import { sampleWaveformReference } from './samplingReference'
-import {
-  REFERENCE_AGGREGATE_VECTORS,
-  REFERENCE_SAMPLING_POINTS,
-  REFERENCE_SOURCE_INDEX_VECTORS,
-} from './samplingReferenceVectors'
-import {
-  calculateWasmRange,
-  createInitializedWasmSamplingBackend,
-  findWasmVisibleRange,
-  initializeWasmSampling,
-  sampleWaveformWasm,
-} from './wasmSampling'
-
-const x = Float64Array.from(REFERENCE_SAMPLING_POINTS, (point) => point.x)
-const y = Float64Array.from(REFERENCE_SAMPLING_POINTS, (point) => point.y)
-
-describe('sampleWaveformWasm', () => {
-  beforeAll(async () => {
-    await initializeWasmSampling(
-      await readFile(resolve(process.cwd(), 'wasm/pkg/waveform_sampling_wasm_bg.wasm')),
-    )
-  })
-
-  it('matches the shared source-index vectors and TypeScript reference', async () => {
-    for (const vector of REFERENCE_SOURCE_INDEX_VECTORS) {
-      const wasm = await sampleWaveformWasm({ x, y, ...vector })
-      const reference = sampleWaveformReference({
-        points: REFERENCE_SAMPLING_POINTS,
-        strategy: vector.strategy,
-        targetPointCount: vector.targetPointCount,
-      })
-
-      expect(wasm.kind).toBe('source-indexes')
-      expect(reference.kind).toBe('source-indexes')
-      if (wasm.kind === 'source-indexes' && reference.kind === 'source-indexes') {
-        expect(Array.from(wasm.sourceIndexes)).toEqual(vector.expectedSourceIndexes)
-        expect(Array.from(wasm.sourceIndexes)).toEqual(Array.from(reference.sourceIndexes))
-      }
-    }
-  })
-
-  it('matches the shared aggregate vectors and TypeScript reference', async () => {
-    for (const vector of REFERENCE_AGGREGATE_VECTORS) {
-      const wasm = await sampleWaveformWasm({ x, y, ...vector })
-      const reference = sampleWaveformReference({
-        points: REFERENCE_SAMPLING_POINTS,
-        strategy: vector.strategy,
-        targetPointCount: vector.targetPointCount,
-      })
-
-      expect(wasm.kind).toBe('aggregates')
-      expect(reference.kind).toBe('aggregates')
-      if (wasm.kind === 'aggregates' && reference.kind === 'aggregates') {
-        expect(Array.from(wasm.x)).toEqual(vector.expectedX)
-        expect(Array.from(wasm.y)).toEqual(vector.expectedY)
-        expect(Array.from(wasm.x)).toEqual(Array.from(reference.x))
-        expect(Array.from(wasm.y)).toEqual(Array.from(reference.y))
-      }
-    }
-  })
-
-  it('preserves reference filtering, stable sorting, and original source indexes', async () => {
-    const wasm = await sampleWaveformWasm({
-      x: Float64Array.from([2, Number.NaN, 1, 1, 3]),
-      y: Float64Array.from([20, 99, 10, 11, Number.POSITIVE_INFINITY]),
-      strategy: 'none',
-      targetPointCount: 1,
-    })
-
-    expect(wasm).toEqual({ kind: 'source-indexes', sourceIndexes: Uint32Array.from([2, 3, 0]) })
-  })
-
-  it('calculates full domains and normalized visible ranges', async () => {
-    const range = await calculateWasmRange(
-      Float64Array.from([2, Number.NaN, 1, 1, 3]),
-      Float64Array.from([20, 99, 10, 11, Number.POSITIVE_INFINITY]),
-    )
-    const visible = await findWasmVisibleRange(
-      Float64Array.from([2, Number.NaN, 1, 1, 3]),
-      Float64Array.from([20, 99, 10, 11, Number.POSITIVE_INFINITY]),
-      [1, 1],
-    )
-
-    expect(range).toEqual({ x: [1, 2], y: [10, 20] })
-    expect(visible).toEqual([0, 2])
-    await expect(calculateWasmRange(Float64Array.of(0), new Float64Array())).rejects.toThrow(
-      'x and y must have the same length',
-    )
-  })
-
-  it('matches the reference across strategy and target boundary cases', async () => {
-    const points = [
-      { x: 3, y: 3 },
-      { x: 1, y: -2 },
-      { x: 1, y: 4 },
-      { x: Number.NaN, y: 6 },
-      { x: 2, y: -1 },
-      { x: 4, y: Number.POSITIVE_INFINITY },
-      { x: 5, y: 0 },
-    ]
-    const caseX = Float64Array.from(points, (point) => point.x)
-    const caseY = Float64Array.from(points, (point) => point.y)
-    const strategies = ['none', 'peak', 'lttb', 'average', 'min', 'max', 'minmax', 'sum'] as const
-    const targets = [0, 1, 2, 3, 6, 20, Number.POSITIVE_INFINITY]
-
-    for (const strategy of strategies) {
-      for (const targetPointCount of targets) {
-        const wasm = await sampleWaveformWasm({
-          x: caseX,
-          y: caseY,
-          strategy,
-          targetPointCount,
-        })
-        const reference = sampleWaveformReference({ points, strategy, targetPointCount })
-
-        expect(wasm.kind).toBe(reference.kind)
-        if (wasm.kind === 'source-indexes' && reference.kind === 'source-indexes') {
-          expect(Array.from(wasm.sourceIndexes)).toEqual(Array.from(reference.sourceIndexes))
-        }
-        if (wasm.kind === 'aggregates' && reference.kind === 'aggregates') {
-          expect(Array.from(wasm.x)).toEqual(Array.from(reference.x))
-          expect(Array.from(wasm.y)).toEqual(Array.from(reference.y))
-        }
-      }
-    }
-  })
-
-  it('rejects coordinate arrays with unequal lengths', async () => {
-    await expect(
-      sampleWaveformWasm({
-        x: Float64Array.of(0),
-        y: new Float64Array(),
-        strategy: 'none',
-        targetPointCount: 1,
-      }),
-    ).rejects.toThrow('x and y must have the same length')
-  })
-
-  it('keeps a bounded dataset index in WASM for unaligned viewport queries and releases it', () => {
-    const backend = createInitializedWasmSamplingBackend()
-    const handle = backend.registerDataset(x, y, 1024 * 1024)
-    const visible = REFERENCE_SAMPLING_POINTS.slice(2, 9)
-
-    for (const strategy of ['peak', 'min', 'max', 'minmax'] as const) {
-      const actual = backend.sampleDataset(handle, 2, 9, strategy, 6)
-      const expected = sampleWaveformReference({
-        points: visible,
-        strategy,
-        targetPointCount: 6,
-      })
-      expect(actual.kind).toBe('source-indexes')
-      expect(expected.kind).toBe('source-indexes')
-      if (actual.kind === 'source-indexes' && expected.kind === 'source-indexes') {
-        expect(Array.from(actual.sourceIndexes)).toEqual(
-          Array.from(expected.sourceIndexes, (index) => index + 2),
-        )
-      }
-    }
-
-    const aggregates = backend.sampleDataset(handle, 2, 9, 'average', 4)
-    const expectedAggregates = sampleWaveformReference({
-      points: visible,
-      strategy: 'average',
-      targetPointCount: 4,
-    })
-    expect(aggregates.kind).toBe('aggregates')
-    expect(expectedAggregates.kind).toBe('aggregates')
-    if (aggregates.kind === 'aggregates' && expectedAggregates.kind === 'aggregates') {
-      aggregates.x.forEach((value, index) =>
-        expect(value).toBeCloseTo(expectedAggregates.x[index]!, 12),
-      )
-      aggregates.y.forEach((value, index) =>
-        expect(value).toBeCloseTo(expectedAggregates.y[index]!, 12),
-      )
-    }
-    expect(backend.datasetIndexBytes(handle)).toBeGreaterThan(0)
-    backend.disposeDataset(handle)
-    expect(backend.datasetIndexBytes(handle)).toBe(0)
-  })
-
-  it('registers evenly sampled values without an explicit X column', () => {
-    const backend = createInitializedWasmSamplingBackend()
-    const handle = backend.registerSamples(
-      new Float64Array([1, 9, 2]),
-      new Uint32Array([0, 2, 3]),
-      10,
-      2,
-      1024 * 1024,
-    )
-
-    expect(backend.sampleDataset(handle, 0, 3, 'max', 3)).toMatchObject({
-      kind: 'source-indexes',
-      sourceIndexes: Uint32Array.from([0, 1, 2]),
-    })
-    backend.disposeDataset(handle)
-  })
-})

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

@@ -1,69 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import type { WaveformPoint } from '@/types'
-import { sampleWaveformReference } from '../samplingReference'
-import { MultiResolutionSamplingIndex } from './multiresolution'
-
-const points: WaveformPoint[] = Array.from({ length: 65 }, (_, index) => ({
-  x: index,
-  y: index === 1 ? -90 : index === 31 ? 120 : Math.sin(index / 3) * 10 + index / 9,
-}))
-
-function outputPoints(result: ReturnType<MultiResolutionSamplingIndex['sample']>) {
-  if (!result || result.kind !== 'source-indexes') return []
-  return [...result.sourceIndexes]
-}
-
-describe('MultiResolutionSamplingIndex', () => {
-  it('matches reference source indexes for unaligned viewport boundaries', () => {
-    const index = new MultiResolutionSamplingIndex(points)
-    const visible = points.slice(3, 61)
-
-    for (const strategy of ['peak', 'min', 'max', 'minmax'] as const) {
-      const expected = sampleWaveformReference({
-        points: visible,
-        strategy,
-        targetPointCount: 17,
-      })
-      expect(expected.kind).toBe('source-indexes')
-      if (expected.kind !== 'source-indexes') continue
-      expect(outputPoints(index.sample(3, 61, strategy, 17))).toEqual(
-        [...expected.sourceIndexes].map((sourceIndex) => sourceIndex + 3),
-      )
-    }
-    expect(index.byteLength).toBeGreaterThan(0)
-  })
-
-  it('uses reusable sum and count layers for average and sum buckets', () => {
-    const index = new MultiResolutionSamplingIndex(points)
-    for (const strategy of ['average', 'sum'] as const) {
-      const expected = sampleWaveformReference({
-        points: points.slice(5, 62),
-        strategy,
-        targetPointCount: 13,
-      })
-      const actual = index.sample(5, 62, strategy, 13)
-      expect(expected.kind).toBe('aggregates')
-      expect(actual).toMatchObject({ kind: 'aggregates' })
-      if (expected.kind !== 'aggregates' || actual?.kind !== 'aggregates') continue
-      actual.x.forEach((value, index) => expect(value).toBeCloseTo(expected.x[index]!, 12))
-      actual.y.forEach((value, index) => expect(value).toBeCloseTo(expected.y[index]!, 12))
-    }
-  })
-
-  it('falls back when its bounded index memory cannot serve a query and releases all layers', () => {
-    const index = new MultiResolutionSamplingIndex(points, { maxBytes: 8 })
-
-    expect(index.sample(0, points.length, 'peak', 8)).toBeUndefined()
-    expect(index.byteLength).toBe(0)
-    index.dispose()
-    expect(index.byteLength).toBe(0)
-  })
-
-  it('leaves LTTB as a viewport-local calculation', () => {
-    const index = new MultiResolutionSamplingIndex(points)
-
-    expect(index.sample(5, 62, 'lttb', 13)).toBeUndefined()
-    expect(index.byteLength).toBe(0)
-  })
-})

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

@@ -1,34 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { isCurrentWorkerSamplingResponse } from './protocol'
-
-describe('worker sampling response validation', () => {
-  it('rejects old request ids and outdated per-series revisions before UI state is committed', () => {
-    const current = { requestId: 12, revisions: { alpha: 2, beta: 1 } }
-    const response = {
-      type: 'sample-viewport-response' as const,
-      requestId: 12,
-      results: [
-        { datasetId: 'alpha', revision: 2 },
-        { datasetId: 'beta', revision: 0 },
-      ],
-    }
-
-    expect(isCurrentWorkerSamplingResponse({ ...response, requestId: 11 } as never, current)).toBe(
-      false,
-    )
-    expect(isCurrentWorkerSamplingResponse(response as never, current)).toBe(false)
-    expect(
-      isCurrentWorkerSamplingResponse(
-        {
-          ...response,
-          results: [
-            { datasetId: 'alpha', revision: 2 },
-            { datasetId: 'beta', revision: 1 },
-          ],
-        } as never,
-        current,
-      ),
-    ).toBe(true)
-  })
-})