waveform-analysis 0.1.62 → 0.1.64

package/src/components/waveformNormalization.test.ts

@@ -1,170 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { prepareWaveformSeries } from './core/useWaveformData'
-import { normalizeWaveformData, normalizeWaveformSeries } from './waveform'
-describe('normalizeWaveformData', () => {
-  it('converts samples into time-based points', () => {
-    expect(
-      normalizeWaveformData({
-        kind: 'samples',
-        values: [2, 4, 6],
-        sampleRate: 2,
-        startTime: 1,
-      }),
-    ).toEqual([
-      { x: 1, y: 2 },
-      { x: 1.5, y: 4 },
-      { x: 2, y: 6 },
-    ])
-  })
-
-  it('sorts explicit points and filters non-finite values', () => {
-    expect(
-      normalizeWaveformData({
-        kind: 'points',
-        points: [
-          { x: 2, y: 4 },
-          { x: Number.NaN, y: 3 },
-          { x: 1, y: 2 },
-        ],
-      }),
-    ).toEqual([
-      { x: 1, y: 2 },
-      { x: 2, y: 4 },
-    ])
-  })
-
-  it('returns no points for an invalid sample rate', () => {
-    expect(normalizeWaveformData({ kind: 'samples', values: [1, 2], sampleRate: 0 })).toEqual([])
-  })
-
-  it('keeps large-data error extrema in the prepared Y domain', () => {
-    const points = Array.from({ length: 10_001 }, (_, index) => ({
-      x: index,
-      y: 0,
-      ...(index === 5_555 ? { error: 10_000 } : {}),
-    }))
-    const [series] = prepareWaveformSeries({
-      kind: 'series',
-      series: [
-        {
-          name: 'errors',
-          errorBar: { visible: true },
-          data: { kind: 'points', points },
-        },
-      ],
-    })
-
-    expect(series?.points).toHaveLength(points.length)
-    expect(series?.hasErrorPoints).toBe(true)
-    expect(series?.yDomain[0]).toBeLessThanOrEqual(-10_000)
-    expect(series?.yDomain[1]).toBeGreaterThanOrEqual(10_000)
-  })
-
-  it('normalizes errors and preserves a pure error-bar series', () => {
-    const [series] = normalizeWaveformSeries({
-      kind: 'series',
-      series: [
-        {
-          name: 'styled',
-          lineType: 'none',
-          pointType: 'none',
-          errorBar: { visible: true, width: -1, capWidth: Number.NaN },
-          data: {
-            kind: 'points',
-            points: [
-              { x: 0, y: 2, error: 1, lowerError: -1, upperError: 2 },
-              { x: 1, y: 3, error: Number.NaN },
-            ],
-          },
-        },
-      ],
-    })
-
-    expect(series).toMatchObject({
-      lineType: 'none',
-      pointType: 'none',
-      errorBar: { visible: true, width: 1.5, capWidth: 8 },
-      points: [
-        { x: 0, y: 2, error: 1, upperError: 2 },
-        { x: 1, y: 3 },
-      ],
-    })
-  })
-
-  it('falls back to a line only when every series visual is disabled', () => {
-    const [series] = normalizeWaveformSeries({
-      kind: 'series',
-      series: [
-        {
-          name: 'invisible',
-          lineType: 'none',
-          pointType: 'none',
-          errorBar: { visible: false },
-          data: { kind: 'points', points: [{ x: 0, y: 1 }] },
-        },
-      ],
-    })
-
-    expect(series).toMatchObject({
-      lineType: 'linear',
-      pointType: 'none',
-      errorBar: { visible: false },
-    })
-  })
-
-  it('includes visible error bounds in the prepared Y domain', () => {
-    const [series] = prepareWaveformSeries({
-      kind: 'series',
-      series: [
-        {
-          name: 'errors',
-          errorBar: { visible: true },
-          data: {
-            kind: 'points',
-            points: [
-              { x: 0, y: 2, lowerError: 3, upperError: 4 },
-              { x: 1, y: 3 },
-            ],
-          },
-        },
-      ],
-    })
-
-    expect(series?.yDomain[0]).toBeLessThanOrEqual(-1)
-    expect(series?.yDomain[1]).toBeGreaterThanOrEqual(6)
-    expect(series?.hasErrorPoints).toBe(true)
-  })
-
-  it('normalizes multiple named series and removes empty series', () => {
-    expect(
-      normalizeWaveformSeries({
-        kind: 'series',
-        series: [
-          {
-            trackId: 'comparison-track',
-            name: 'BT2_2M',
-            unit: 'T',
-            data: { kind: 'points', points: [{ x: 1, y: 2 }] },
-          },
-          {
-            name: 'empty',
-            data: { kind: 'samples', values: [1], sampleRate: 0 },
-          },
-        ],
-      }),
-    ).toEqual([
-      {
-        id: 'series-0',
-        trackId: 'comparison-track',
-        name: 'BT2_2M',
-        unit: 'T',
-        color: undefined,
-        lineType: 'linear',
-        lineStyle: 'solid',
-        pointType: 'none',
-        errorBar: { visible: false, width: 1.5, capWidth: 8 },
-        points: [{ x: 1, y: 2 }],
-      },
-    ])
-  })
-})

package/src/core/data.test.ts

@@ -1,241 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-
-import { normalizeWaveformData, normalizeWaveformSeries } from './data'
-
-describe('waveform data normalization', () => {
-  it('builds sample points in one pass while preserving source indexes', () => {
-    expect(
-      normalizeWaveformData({
-        kind: 'samples',
-        values: [1, Number.NaN, 3],
-        sampleRate: 2,
-        startTime: 1,
-      }),
-    ).toEqual([
-      { x: 1, y: 1 },
-      { x: 2, y: 3 },
-    ])
-  })
-
-  it('normalizes typed samples without mutating their values or buffer', () => {
-    const values = new Float32Array([1, Number.NaN, 3])
-    const snapshot = values.slice()
-
-    expect(
-      normalizeWaveformData({
-        kind: 'typed-samples',
-        values,
-        sampleRate: 2,
-        startTime: 1,
-      }),
-    ).toEqual([
-      { x: 1, y: 1 },
-      { x: 2, y: 3 },
-    ])
-    expect(values).toEqual(snapshot)
-    expect(values.buffer.byteLength).toBe(snapshot.buffer.byteLength)
-  })
-
-  it('rejects malformed typed sample input without coercing numeric fields', () => {
-    expect(
-      normalizeWaveformData({
-        kind: 'typed-samples',
-        values: new Float64Array([1]),
-        sampleRate: Number.POSITIVE_INFINITY,
-      }),
-    ).toEqual([])
-    expect(
-      normalizeWaveformData({
-        kind: 'typed-samples',
-        values: new Float64Array([1]),
-        sampleRate: 1,
-        startTime: Number.NaN,
-      }),
-    ).toEqual([])
-    expect(
-      normalizeWaveformData({
-        kind: 'typed-samples',
-        values: new Int32Array([1]),
-        sampleRate: 1,
-      } as unknown as Parameters<typeof normalizeWaveformData>[0]),
-    ).toEqual([])
-  })
-
-  it('normalizes typed points, errors, and unordered coordinates without mutation', () => {
-    const x = new Float64Array([2, 1, 1, Number.NaN])
-    const y = new Float32Array([20, 10, 11, 12])
-    const error = new Float64Array([1, -1, Number.NaN, 4])
-    const lowerError = new Float32Array([2, 3, 4, 5])
-    const upperError = new Float64Array([3, 4, 5, 6])
-    const snapshots = [x.slice(), y.slice(), error.slice(), lowerError.slice(), upperError.slice()]
-
-    expect(
-      normalizeWaveformData({ kind: 'typed-points', x, y, error, lowerError, upperError }),
-    ).toEqual([
-      { x: 1, y: 10, lowerError: 3, upperError: 4 },
-      { x: 1, y: 11, lowerError: 4, upperError: 5 },
-      { x: 2, y: 20, error: 1, lowerError: 2, upperError: 3 },
-    ])
-    expect(x).toEqual(snapshots[0])
-    expect(y).toEqual(snapshots[1])
-    expect(error).toEqual(snapshots[2])
-    expect(lowerError).toEqual(snapshots[3])
-    expect(upperError).toEqual(snapshots[4])
-  })
-
-  it('rejects typed points with unsupported arrays or mismatched field lengths', () => {
-    expect(
-      normalizeWaveformData({
-        kind: 'typed-points',
-        x: new Float64Array([0, 1]),
-        y: new Float32Array([1]),
-      }),
-    ).toEqual([])
-    expect(
-      normalizeWaveformData({
-        kind: 'typed-points',
-        x: new Float64Array([0]),
-        y: new Float64Array([1]),
-        upperError: new Float32Array([1, 2]),
-      }),
-    ).toEqual([])
-    expect(
-      normalizeWaveformData({
-        kind: 'typed-points',
-        x: new Float32Array([0]),
-        y: new Float32Array([1]),
-      } as unknown as Parameters<typeof normalizeWaveformData>[0]),
-    ).toEqual([])
-  })
-
-  it('skips sorting already ordered points and normalizes errors', () => {
-    const sortSpy = vi.spyOn(Array.prototype, 'sort')
-    try {
-      const result = normalizeWaveformData({
-        kind: 'points',
-        points: [
-          { x: 0, y: 1, error: -1, upperError: 2 },
-          { x: 1, y: 2, lowerError: 3 },
-        ],
-      })
-
-      expect(sortSpy).not.toHaveBeenCalled()
-      expect(result).toEqual([
-        { x: 0, y: 1, upperError: 2 },
-        { x: 1, y: 2, lowerError: 3 },
-      ])
-    } finally {
-      sortSpy.mockRestore()
-    }
-  })
-
-  it('sorts only unordered points and preserves duplicate-x order', () => {
-    expect(
-      normalizeWaveformData({
-        kind: 'points',
-        points: [
-          { x: 2, y: 20 },
-          { x: 1, y: 10 },
-          { x: 1, y: 11 },
-          { x: Number.NaN, y: 12 },
-        ],
-      }),
-    ).toEqual([
-      { x: 1, y: 10 },
-      { x: 1, y: 11 },
-      { x: 2, y: 20 },
-    ])
-  })
-
-  it('preserves every valid point in large data sets', () => {
-    const points = Array.from({ length: 10_001 }, (_, index) => ({
-      x: index,
-      y: index === 5_555 ? 1 : 0,
-      ...(index === 5_555 ? { error: 10_000 } : {}),
-    }))
-
-    const result = normalizeWaveformData({ kind: 'points', points })
-
-    expect(result).toHaveLength(points.length)
-    expect(result[5_555]).toEqual({ x: 5_555, y: 1, error: 10_000 })
-  })
-
-  it('defaults and normalizes per-series line styles', () => {
-    const data = {
-      kind: 'series' as const,
-      series: [
-        { id: 'solid', name: 'Solid', data: { kind: 'points' as const, points: [{ x: 0, y: 1 }] } },
-        {
-          id: 'dashed',
-          name: 'Dashed',
-          lineStyle: 'dashed' as const,
-          data: { kind: 'points' as const, points: [{ x: 0, y: 1 }] },
-        },
-        {
-          id: 'dash-dot',
-          name: 'Dash dot',
-          lineStyle: 'dash-dot' as const,
-          data: { kind: 'points' as const, points: [{ x: 0, y: 1 }] },
-        },
-        {
-          id: 'invalid',
-          name: 'Invalid',
-          lineStyle: 'zigzag' as never,
-          data: { kind: 'points' as const, points: [{ x: 0, y: 1 }] },
-        },
-      ],
-    }
-
-    expect(normalizeWaveformSeries(data).map((series) => series.lineStyle)).toEqual([
-      'solid',
-      'dashed',
-      'dash-dot',
-      'solid',
-    ])
-  })
-
-  it('preserves trimmed shot numbers and omits blank values', () => {
-    const result = normalizeWaveformSeries({
-      kind: 'series',
-      series: [
-        {
-          id: 'with-shot',
-          shotNo: '  13300  ',
-          name: '通道 A',
-          data: { kind: 'points', points: [{ x: 0, y: 1 }] },
-        },
-        {
-          id: 'without-shot',
-          shotNo: '   ',
-          name: '通道 B',
-          data: { kind: 'points', points: [{ x: 0, y: 2 }] },
-        },
-      ],
-    })
-
-    expect(result.map((series) => series.shotNo)).toEqual(['13300', undefined])
-  })
-
-  it('accepts compact inputs inside regular series containers', () => {
-    const result = normalizeWaveformSeries({
-      kind: 'series',
-      series: [
-        {
-          id: 'typed',
-          name: 'Typed',
-          data: {
-            kind: 'typed-points',
-            x: new Float64Array([0, 1]),
-            y: new Float32Array([2, 3]),
-          },
-        },
-      ],
-    })
-
-    expect(result).toHaveLength(1)
-    expect(result[0]?.points).toEqual([
-      { x: 0, y: 2 },
-      { x: 1, y: 3 },
-    ])
-  })
-})

package/src/core/rendering.test.ts

@@ -1,267 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import type { WaveformPoint, WaveformRenderingOptions } from '../types'
-import {
-  DEFAULT_WAVEFORM_RENDERING_OPTIONS,
-  hasMinimumVisibleXValues,
-  resolveWaveformRenderingOptions,
-  selectDecorationPoints,
-  selectRenderablePoints,
-  selectSeriesRenderPoints,
-} from './rendering'
-
-describe('waveform rendering selection', () => {
-  const points = Array.from({ length: 10_000 }, (_, index): WaveformPoint => ({
-    x: index,
-    y: index === 5_001 ? 10_000 : Math.sin(index / 20),
-  }))
-
-  it('clips to the visible domain and retains one continuity point on each side', () => {
-    const selected = selectRenderablePoints(
-      points,
-      [4_000, 4_100],
-      500,
-      resolveWaveformRenderingOptions({ downsample: false }),
-    )
-
-    expect(selected[0].x).toBe(3_999)
-    expect(selected.at(-1)?.x).toBe(4_101)
-  })
-
-  it('bounds path density while preserving narrow extrema', () => {
-    const selected = selectRenderablePoints(
-      points,
-      [0, 9_999],
-      100,
-      resolveWaveformRenderingOptions({ downsampleThreshold: 100, maxPointsPerPixel: 4 }),
-    )
-
-    expect(selected.length).toBeLessThanOrEqual(402)
-    expect(selected).toContain(points[5_001])
-    expect(selected[0]).toBe(points[0])
-    expect(selected.at(-1)).toBe(points.at(-1))
-  })
-
-  it('normalizes invalid rendering options to stable defaults', () => {
-    expect(
-      resolveWaveformRenderingOptions({
-        downsampleThreshold: -1,
-        maxPointsPerPixel: 0,
-        pointMinSpacing: -1,
-        errorBarMinSpacing: Number.POSITIVE_INFINITY,
-      }),
-    ).toEqual(DEFAULT_WAVEFORM_RENDERING_OPTIONS)
-  })
-
-  it('accepts custom decoration spacing and uses zero to disable it', () => {
-    expect(resolveWaveformRenderingOptions({ pointMinSpacing: 6, errorBarMinSpacing: 0 })).toEqual({
-      ...DEFAULT_WAVEFORM_RENDERING_OPTIONS,
-      pointMinSpacing: 6,
-      errorBarMinSpacing: 0,
-    })
-  })
-
-  it('normalizes sampling options with strict runtime validation', () => {
-    const options: WaveformRenderingOptions = {
-      sampling: {
-        mode: 'wasm',
-        autoThreshold: 1_001.9,
-        autoHysteresis: 20.8,
-        strategy: 'minmax',
-        maxPointsPerPixel: 2.5,
-        maxPointCount: 1_000.9,
-        rawPointLimit: 50_000.2,
-        wasmFailureFallback: 'javascript',
-      },
-    }
-
-    expect(resolveWaveformRenderingOptions(options)).toMatchObject({
-      downsample: true,
-      maxPointsPerPixel: 2.5,
-      sampling: {
-        mode: 'wasm',
-        autoThreshold: 1_001,
-        autoHysteresis: 20,
-        strategy: 'minmax',
-        maxPointsPerPixel: 2.5,
-        maxPointCount: 1_000,
-        rawPointLimit: 50_000,
-        wasmFailureFallback: 'javascript',
-      },
-    })
-
-    expect(
-      resolveWaveformRenderingOptions({
-        sampling: {
-          mode: 'invalid',
-          autoThreshold: 0,
-          autoHysteresis: -1,
-          strategy: 'invalid',
-          maxPointsPerPixel: Number.POSITIVE_INFINITY,
-          maxPointCount: 0,
-          rawPointLimit: 0,
-          wasmFailureFallback: 'fallback',
-        },
-      } as unknown as WaveformRenderingOptions),
-    ).toMatchObject({ sampling: DEFAULT_WAVEFORM_RENDERING_OPTIONS.sampling })
-  })
-
-  it('maps legacy downsample flags and gives explicit sampling mode precedence', () => {
-    expect(resolveWaveformRenderingOptions({ downsample: false }).sampling.mode).toBe('raw')
-    expect(resolveWaveformRenderingOptions({ downsample: true }).sampling.mode).toBe('auto')
-    expect(
-      resolveWaveformRenderingOptions({ downsample: false, sampling: { mode: 'wasm' } }),
-    ).toMatchObject({ downsample: true, sampling: { mode: 'wasm' } })
-  })
-
-  it('prefers nested sampling density over the legacy rendering field', () => {
-    const legacy = resolveWaveformRenderingOptions({ maxPointsPerPixel: 2 })
-    const nested = resolveWaveformRenderingOptions({
-      maxPointsPerPixel: 2,
-      sampling: { maxPointsPerPixel: 3 },
-    })
-
-    expect(legacy.maxPointsPerPixel).toBe(2)
-    expect(legacy.sampling.maxPointsPerPixel).toBe(2)
-    expect(nested.maxPointsPerPixel).toBe(3)
-    expect(nested.sampling.maxPointsPerPixel).toBe(3)
-  })
-
-  it('selects evenly distributed source points for dense decorations', () => {
-    const selected = selectDecorationPoints(points, [0, 9_999], 100, 10, true)
-
-    expect(selected.length).toBeLessThanOrEqual(12)
-    expect(selected[0]).toBe(points[0])
-    expect(selected.at(-1)).toBe(points.at(-1))
-    expect(selected.every((point) => points.includes(point))).toBe(true)
-  })
-
-  it('clips decorations exactly to the visible domain and preserves sparse points', () => {
-    const sparsePoints = [
-      { x: 0, y: 0 },
-      { x: 40, y: 1 },
-      { x: 80, y: 2 },
-      { x: 120, y: 3 },
-    ]
-
-    expect(selectDecorationPoints(sparsePoints, [40, 80], 100, 10, true)).toEqual([
-      sparsePoints[1],
-      sparsePoints[2],
-    ])
-  })
-
-  it('supports filtering decoration candidates and disabling sampling', () => {
-    const errorPoints = Array.from({ length: 100 }, (_, index) => ({
-      x: index,
-      y: index,
-      error: index % 10 === 0 ? 1 : 0,
-    }))
-    const hasError = (point: WaveformPoint) => (point.error ?? 0) > 0
-
-    expect(selectDecorationPoints(errorPoints, [0, 99], 100, 12, true, hasError)).toHaveLength(10)
-    expect(selectDecorationPoints(errorPoints, [0, 99], 100, 12, false)).toHaveLength(100)
-    expect(selectDecorationPoints(errorPoints, [0, 99], 100, 0, true)).toHaveLength(100)
-  })
-
-  it('prefers priority candidates within dense decoration buckets', () => {
-    const priorityPoints = Array.from({ length: 100 }, (_, index) => ({
-      x: index,
-      y: index,
-      error: index % 20 === 1 ? 1 : 0,
-    }))
-    const hasError = (point: WaveformPoint) => (point.error ?? 0) > 0
-    const selected = selectDecorationPoints(
-      priorityPoints,
-      [0, 99],
-      100,
-      20,
-      true,
-      undefined,
-      hasError,
-    )
-
-    expect(selected.filter(hasError)).toEqual(priorityPoints.filter(hasError))
-    expect(selected.length).toBeLessThanOrEqual(Math.ceil(100 / 20) + 2)
-  })
-
-  it('shares visible-range selection for a dense 100k-point series', () => {
-    const densePoints = Array.from({ length: 100_000 }, (_, index): WaveformPoint => ({
-      x: index,
-      y: index === 50_001 ? 10_000 : Math.sin(index / 20),
-      error: index % 1_000 === 0 ? 1 : undefined,
-    }))
-    const selected = selectSeriesRenderPoints(
-      densePoints,
-      [99_999, 0],
-      500,
-      resolveWaveformRenderingOptions({
-        downsampleThreshold: 100,
-        sampling: { autoThreshold: 200_000 },
-      }),
-      {
-        lineVisible: true,
-        pointVisible: true,
-        errorBarVisible: true,
-        hasErrorPoints: true,
-      },
-    )
-
-    expect(selected.linePoints.length).toBeLessThanOrEqual(2_002)
-    expect(selected.linePoints).toContain(densePoints[50_001])
-    expect(selected.linePoints[0]).toBe(densePoints[0])
-    expect(selected.linePoints.at(-1)).toBe(densePoints.at(-1))
-    expect(selected.pointRenderPoints.length).toBeLessThanOrEqual(52)
-    expect(selected.errorBarRenderPoints.every((point) => (point.error ?? 0) > 0)).toBe(true)
-  })
-
-  it('uses a width-bounded placeholder while large-series Worker sampling is pending', () => {
-    const rendering = resolveWaveformRenderingOptions({
-      sampling: { mode: 'auto', autoThreshold: 1_000, maxPointsPerPixel: 2 },
-    })
-    const selected = selectSeriesRenderPoints(points, [0, 9_999], 100, rendering, {
-      lineVisible: true,
-      pointVisible: false,
-      errorBarVisible: false,
-      hasErrorPoints: false,
-    })
-
-    expect(selected.linePoints).toHaveLength(200)
-    expect(selected.linePoints[0]).toBe(points[0])
-    expect(selected.linePoints.at(-1)).toBe(points.at(-1))
-  })
-
-  it('counts unique visible x values across series and reversed domains', () => {
-    const first = {
-      points: [
-        { x: 0, y: 0 },
-        { x: 1, y: 1 },
-      ],
-    }
-    const second = {
-      points: [
-        { x: 0, y: 2 },
-        { x: 1, y: 3 },
-        { x: 2, y: 4 },
-      ],
-    }
-
-    expect(hasMinimumVisibleXValues([first, second], [2, 0], 3)).toBe(true)
-    expect(hasMinimumVisibleXValues([first, second], [0, 2], 4)).toBe(false)
-    expect(hasMinimumVisibleXValues([first, second], [1, 1], 1)).toBe(true)
-    expect(hasMinimumVisibleXValues([first, second], [3, 4], 1)).toBe(false)
-  })
-
-  it('stops scanning a 100k-point series after reaching the minimum', () => {
-    const source = Array.from({ length: 100_000 }, (_, index) => ({ x: index, y: index }))
-    let pointReads = 0
-    const points = new Proxy(source, {
-      get(target, property, receiver) {
-        if (typeof property === 'string' && /^\d+$/.test(property)) pointReads += 1
-        return Reflect.get(target, property, receiver)
-      },
-    })
-
-    expect(hasMinimumVisibleXValues([{ points }], [0, 99_999], 5)).toBe(true)
-    expect(pointReads).toBeLessThan(100)
-  })
-})