waveform-analysis 0.1.48 → 0.1.51

package/src/components/interaction/zoomConstraints.ts

@@ -1,10 +1,12 @@
 import { scaleLinear, zoomIdentity, type ZoomTransform } from 'd3'
 
 import type { WaveformPoint } from '../../types'
+import { pointSourceFromPoints, type WaveformPointSource } from '../../core/waveformPointSource'
 import { ZOOM_CONSTRAINTS } from '../core/constants'
 
 interface PointSeriesSource {
   points: WaveformPoint[]
+  source?: WaveformPointSource
 }
 
 export type ZoomSeriesGroup = readonly PointSeriesSource[]
@@ -30,7 +32,9 @@ function uniqueXValues(group: ZoomSeriesGroup, boundary: [number, number]): numb
   if (cached) return cached
   const values = new Set<number>()
   for (const series of group) {
-    for (const point of series.points) {
+    const source = series.source ?? pointSourceFromPoints(series.points)
+    for (let index = 0; index < source.length; index += 1) {
+      const point = source.pointAt(index)!
       if (point.x >= boundary[0] && point.x <= boundary[1]) values.add(point.x)
     }
   }

package/src/components/waveform.ts

@@ -12,12 +12,21 @@ export type {
   WaveformXDomainStrategy,
   WaveformAnnotationStyle,
   WaveformAnnotation,
+  WaveformSamplingMode,
+  WaveformSamplingStrategy,
+  WaveformSamplingOptions,
+  WaveformSamplingBackend,
+  WaveformSamplingDiagnostics,
+  WaveformSamplingError,
   WaveformRenderingOptions,
   WaveformPlotMargin,
   WaveformTitleTextStyle,
   WaveformTitleOptions,
   WaveformFrameStyle,
   SingleWaveformData,
+  WaveformTypedValues,
+  TypedSampleData,
+  TypedPointData,
   WaveformSeries,
   WaveformLineStyle,
   WaveformData,

package/src/components/waveformChartCases/compactAndSharedHover.test.ts

@@ -74,8 +74,7 @@ describe('WaveformChart', () => {
 
   it('removes the later compact row top tick when the Y-axis end has a floating-point tail', async () => {
     const yDomain: [number, number] = [-1, 0.2]
-    const calculatedAxisEnd =
-      yDomain[0] + ((yDomain[1] - yDomain[0]) * 4) / 4
+    const calculatedAxisEnd = yDomain[0] + ((yDomain[1] - yDomain[0]) * 4) / 4
     expect(calculatedAxisEnd).not.toBe(yDomain[1])
 
     const wrapper = await mountSizedChart(
@@ -84,11 +83,23 @@ describe('WaveformChart', () => {
         series: [
           {
             name: 'top',
-            data: { kind: 'points', points: [{ x: 0, y: -0.8 }, { x: 1, y: 0.1 }] },
+            data: {
+              kind: 'points',
+              points: [
+                { x: 0, y: -0.8 },
+                { x: 1, y: 0.1 },
+              ],
+            },
           },
           {
             name: 'bottom',
-            data: { kind: 'points', points: [{ x: 0, y: -0.7 }, { x: 1, y: 0 }] },
+            data: {
+              kind: 'points',
+              points: [
+                { x: 0, y: -0.7 },
+                { x: 1, y: 0 },
+              ],
+            },
           },
         ],
       },

package/src/components/waveformChartCases/dataAndHoverPerformance.test.ts

@@ -99,12 +99,17 @@ describe('WaveformChart', () => {
       { rendering: { downsampleThreshold: 1_000, maxPointsPerPixel: 4 } },
     )
     const overlayWidth = Number(wrapper.get('.waveform-chart__overlay').attributes('width'))
-    const path = wrapper.get('.waveform-chart__line').attributes('d') ?? ''
-    const renderedPointCount = path.match(/[ML]/g)?.length ?? 0
-
-    expect(renderedPointCount).toBeGreaterThan(0)
-    expect(renderedPointCount).toBeLessThanOrEqual(Math.floor(overlayWidth * 4) + 2)
-    expect(path).toContain(',0')
+    await vi.waitFor(
+      () => {
+        expect(wrapper.emitted('sampling-complete')?.length).toBeGreaterThan(0)
+        const path = wrapper.get('.waveform-chart__line').attributes('d') ?? ''
+        const renderedPointCount = path.match(/[ML]/g)?.length ?? 0
+        expect(renderedPointCount).toBeGreaterThan(0)
+        expect(renderedPointCount).toBeLessThanOrEqual(Math.floor(overlayWidth * 4) + 2)
+        expect(path).toContain(',0')
+      },
+      { timeout: 5_000 },
+    )
   })
 
   it('bounds dense decorations by pixel spacing while keeping one SVG path per series', async () => {

package/src/components/waveformChartCases/dataLifecycle.test.ts

@@ -169,9 +169,7 @@ describe('WaveformChart', () => {
       yAxisLabels[0].attributes('transform')?.match(/^translate\(([-\d.]+),/)?.[1],
     )
     expect(labelX).toBeLessThan(-46)
-    expect(Number(wrapper.get('.waveform-chart__y-axis-label-bg').attributes('x'))).toBe(
-      labelX - 6,
-    )
+    expect(Number(wrapper.get('.waveform-chart__y-axis-label-bg').attributes('x'))).toBe(labelX - 6)
     expect(yAxisLabels.every((label) => !label.text().includes('(T)'))).toBe(true)
     expect(wrapper.findAll('.waveform-chart__track-label')).toHaveLength(0)
     expect(

package/src/components/waveformChartCases/workerSamplingIntegration.test.ts

@@ -0,0 +1,117 @@
+import { flushPromises } from '@vue/test-utils'
+import { describe, expect, it } from 'vitest'
+
+import { flushAnimationFrames } from '../../test/setup'
+import { mountSizedChart } from '../../test/waveformChart'
+
+function densePoints(count: number) {
+  return Array.from({ length: count }, (_, index) => ({
+    x: index,
+    y: index === count - 1 ? 100 : Math.sin(index / 10),
+  }))
+}
+
+async function samplingEvents(count: number, rendering = {}) {
+  const wrapper = await mountSizedChart(
+    { kind: 'points', points: densePoints(count) },
+    { rendering, grid: { rowCount: 1, columnCount: 1 } },
+  )
+  await flushPromises()
+  await new Promise((resolve) => setTimeout(resolve, 120))
+  return wrapper
+}
+
+async function compactSamplingEvents(count: number, rendering = {}) {
+  const wrapper = await mountSizedChart(
+    {
+      kind: 'typed-points',
+      x: Float64Array.from({ length: count }, (_, index) => index),
+      y: Float32Array.from({ length: count }, (_, index) =>
+        index === count - 1 ? 100 : Math.sin(index / 10),
+      ),
+    },
+    { rendering, grid: { rowCount: 1, columnCount: 1 } },
+  )
+  await flushPromises()
+  await new Promise((resolve) => setTimeout(resolve, 120))
+  return wrapper
+}
+
+describe('WaveformChart worker sampling integration', () => {
+  it('uses raw source points at the auto threshold and JavaScript fallback above it', async () => {
+    const threshold = await samplingEvents(1_000)
+    const sampled = await samplingEvents(1_001)
+
+    expect(threshold.emitted('sampling-complete')?.at(-1)?.[0]).toMatchObject({
+      mode: 'auto',
+      backend: 'raw',
+      visiblePointCount: 1_000,
+      renderedPointCount: 1_000,
+    })
+    expect(sampled.emitted('sampling-complete')?.at(-1)?.[0]).toMatchObject({
+      mode: 'auto',
+      backend: 'javascript',
+      visiblePointCount: 1_001,
+    })
+    const path = sampled.get('.waveform-chart__line').attributes('d') ?? ''
+    expect(path.match(/[ML]/g)?.length).toBeLessThan(4_000)
+  })
+
+  it('bypasses worker sampling in raw mode and reports a forced-WASM failure without a fallback', async () => {
+    const raw = await samplingEvents(1_001, { sampling: { mode: 'raw' } })
+    const wasm = await samplingEvents(1_001, {
+      sampling: { mode: 'wasm', wasmFailureFallback: 'error' },
+    })
+
+    expect(raw.emitted('sampling-complete')?.at(-1)?.[0]).toMatchObject({
+      mode: 'raw',
+      backend: 'raw',
+      renderedPointCount: 1_001,
+    })
+    expect(raw.emitted('sampling-error')).toBeUndefined()
+    expect(wasm.emitted('sampling-complete')?.at(-1)?.[0]).toMatchObject({
+      mode: 'wasm',
+      backend: 'unavailable',
+    })
+    expect(wasm.emitted('sampling-error')?.at(-1)?.[0]).toMatchObject({
+      mode: 'wasm',
+      fallback: 'none',
+    })
+  })
+
+  it('keeps hover bound to complete source data after sampled SVG geometry is applied', async () => {
+    const wrapper = await samplingEvents(1_001)
+    const overlay = wrapper.get('.waveform-chart__overlay')
+    const width = Number(overlay.attributes('width'))
+    Object.defineProperty(overlay.element, 'getBoundingClientRect', {
+      value: () => ({ left: 0, top: 0, width, height: 290 }),
+    })
+    overlay.element.dispatchEvent(
+      new MouseEvent('pointermove', { clientX: width, clientY: 120, bubbles: true }),
+    )
+    flushAnimationFrames()
+    await flushPromises()
+
+    expect(wrapper.emitted('point-hover')?.at(-1)).toEqual([{ x: 1_000, y: 100 }])
+  })
+
+  it('samples dense typed coordinates while retaining the full compact source for hover', async () => {
+    const wrapper = await compactSamplingEvents(1_001)
+    expect(wrapper.emitted('sampling-complete')?.at(-1)?.[0]).toMatchObject({
+      backend: 'javascript',
+      sourcePointCount: 1_001,
+      visiblePointCount: 1_001,
+    })
+    const overlay = wrapper.get('.waveform-chart__overlay')
+    const width = Number(overlay.attributes('width'))
+    Object.defineProperty(overlay.element, 'getBoundingClientRect', {
+      value: () => ({ left: 0, top: 0, width, height: 290 }),
+    })
+    overlay.element.dispatchEvent(
+      new MouseEvent('pointermove', { clientX: width, clientY: 120, bubbles: true }),
+    )
+    flushAnimationFrames()
+    await flushPromises()
+    expect(wrapper.emitted('point-hover')?.at(-1)).toEqual([{ x: 1_000, y: 100 }])
+  })
+})

package/src/components/waveformChartCases/xDomainStrategy.test.ts

@@ -128,12 +128,24 @@ describe('WaveformChart x domain strategy', () => {
           {
             id: 'first',
             name: '第一轨',
-            data: { kind: 'points', points: [{ x: 0, y: 0 }, { x: 10, y: 1 }] },
+            data: {
+              kind: 'points',
+              points: [
+                { x: 0, y: 0 },
+                { x: 10, y: 1 },
+              ],
+            },
           },
           {
             id: 'second',
             name: '第二轨',
-            data: { kind: 'points', points: [{ x: 100, y: 0 }, { x: 110, y: 1 }] },
+            data: {
+              kind: 'points',
+              points: [
+                { x: 100, y: 0 },
+                { x: 110, y: 1 },
+              ],
+            },
           },
         ],
       },

package/src/core/compactSamplePointSource.ts

@@ -0,0 +1,76 @@
+import type { WaveformPoint, WaveformTypedValues } from '../types'
+import type { WaveformPointSource, WorkerSamplingDataset } from './waveformPointSource'
+
+function bound(length: number, xAt: (index: number) => number, value: number, upper: boolean) {
+  let start = 0
+  let end = length
+  while (start < end) {
+    const middle = start + Math.floor((end - start) / 2)
+    if (upper ? xAt(middle) <= value : xAt(middle) < value) start = middle + 1
+    else end = middle
+  }
+  return start
+}
+
+export function createCompactSamplePointSource(
+  y: WaveformTypedValues,
+  sampleRate: number,
+  startTime: number,
+  sourceIndexes?: Uint32Array,
+): WaveformPointSource {
+  const xAt = (index: number) => startTime + (sourceIndexes?.[index] ?? index) / sampleRate
+  const pointAt = (index: number) =>
+    index < 0 || index >= y.length ? undefined : { x: xAt(index), y: y[index]! }
+  return {
+    isCompact: true,
+    length: y.length,
+    pointAt,
+    pointsInRange(start = 0, end = y.length) {
+      const rangeStart = Math.max(0, Math.min(y.length, Math.floor(start)))
+      const rangeEnd = Math.max(rangeStart, Math.min(y.length, Math.ceil(end)))
+      return Array.from({ length: rangeEnd - rangeStart }, (_, offset) =>
+        pointAt(rangeStart + offset),
+      ).filter((point): point is WaveformPoint => point !== undefined)
+    },
+    visibleRange(domain: [number, number]) {
+      const start = Math.min(domain[0], domain[1])
+      const end = Math.max(domain[0], domain[1])
+      return {
+        start: bound(y.length, xAt, start, false),
+        end: bound(y.length, xAt, end, true),
+      }
+    },
+    nearestPoint(x: number) {
+      if (!Number.isFinite(x) || !y.length) return undefined
+      if (x <= xAt(0)) return pointAt(0)
+      if (x >= xAt(y.length - 1)) return pointAt(y.length - 1)
+      const right = bound(y.length, xAt, x, false)
+      const left = Math.max(0, right - 1)
+      return Math.abs(x - xAt(left)) < Math.abs(xAt(right) - x) ? pointAt(left) : pointAt(right)
+    },
+    metrics() {
+      let yMinimum = Number.POSITIVE_INFINITY
+      let yMaximum = Number.NEGATIVE_INFINITY
+      for (const value of y) {
+        yMinimum = Math.min(yMinimum, value)
+        yMaximum = Math.max(yMaximum, value)
+      }
+      return {
+        xMinimum: y.length ? xAt(0) : Number.POSITIVE_INFINITY,
+        xMaximum: y.length ? xAt(y.length - 1) : Number.NEGATIVE_INFINITY,
+        yMinimum,
+        yMaximum,
+        hasErrorPoints: false,
+      }
+    },
+    toWorkerDataset(): WorkerSamplingDataset {
+      return {
+        kind: 'samples',
+        values: y.slice(),
+        sampleRate,
+        startTime,
+        ...(sourceIndexes ? { sourceIndexes: sourceIndexes.slice() } : {}),
+      }
+    },
+  }
+}

package/src/core/data.test.ts

@@ -17,6 +17,97 @@ describe('waveform data normalization', () => {
     ])
   })
 
+  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 {
@@ -124,4 +215,27 @@ describe('waveform data normalization', () => {
 
     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 },
+    ])
+  })
 })