waveform-analysis 0.1.62 → 0.1.64

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

@@ -1,114 +0,0 @@
-import { flushPromises } from '@vue/test-utils'
-import { describe, expect, it, vi } from 'vitest'
-
-import { flushAnimationFrames } from '../../test/setup'
-import { mountSizedChart } from '../../test/waveformChart'
-
-describe('WaveformChart wheel zoom out', () => {
-  it('restores an independent initial domain after replacing data with a narrow window', async () => {
-    const createData = (start: number, end: number) => ({
-      kind: 'series' as const,
-      series: [
-        {
-          id: 'channel-a',
-          name: '通道 A',
-          data: {
-            kind: 'points' as const,
-            points: [
-              { x: start, y: 0 },
-              { x: end, y: 1 },
-            ],
-          },
-        },
-      ],
-    })
-    const wrapper = await mountSizedChart(createData(-5, 5), {
-      displayMode: 'independent',
-      initialXDomain: [-5, 5],
-    })
-    const overlay = wrapper.get('.waveform-chart__overlay--independent')
-    const overlayWidth = Number(overlay.attributes('width'))
-    Object.defineProperty(overlay.element, 'getBoundingClientRect', {
-      value: () => ({ left: 0, top: 0, width: overlayWidth, height: 290 }),
-    })
-    const dispatchWheel = async (deltaY: number) => {
-      overlay.element.dispatchEvent(
-        new WheelEvent('wheel', {
-          deltaY,
-          clientX: overlayWidth / 2,
-          clientY: 145,
-          bubbles: true,
-          cancelable: true,
-        }),
-      )
-      flushAnimationFrames()
-      await flushPromises()
-    }
-    const endpoints = () => ({
-      start: wrapper.get('.waveform-chart__axis-endpoint--start').text(),
-      end: wrapper.get('.waveform-chart__axis-endpoint--end').text(),
-    })
-
-    expect(endpoints()).toEqual({ start: '-5000', end: '5000' })
-    await dispatchWheel(-4000)
-    expect(endpoints()).not.toEqual({ start: '-5000', end: '5000' })
-
-    await wrapper.setProps({ data: createData(-0.125, 0.125) })
-    await flushPromises()
-    await dispatchWheel(4000)
-
-    expect(endpoints()).toEqual({ start: '-5000', end: '5000' })
-  })
-
-  it('emits one zoom-end payload after zooming a shared viewport out', async () => {
-    vi.useFakeTimers()
-    try {
-      const wrapper = await mountSizedChart({
-        kind: 'points',
-        points: [
-          { x: 0, y: 0 },
-          { x: 2, y: 1 },
-        ],
-      })
-      const overlay = wrapper.get('.waveform-chart__overlay')
-      const overlayWidth = Number(overlay.attributes('width'))
-      Object.defineProperty(overlay.element, 'getBoundingClientRect', {
-        value: () => ({ left: 0, top: 0, width: overlayWidth, height: 290 }),
-      })
-      const dispatchWheel = (deltaY: number) =>
-        overlay.element.dispatchEvent(
-          new WheelEvent('wheel', {
-            deltaY,
-            clientX: overlayWidth / 2,
-            clientY: 145,
-            bubbles: true,
-            cancelable: true,
-          }),
-        )
-
-      dispatchWheel(-4000)
-      flushAnimationFrames()
-      await vi.advanceTimersByTimeAsync(200)
-      await flushPromises()
-      const zoomedDomain = wrapper.emitted('zoom-change')?.at(-1)?.[0] as [number, number]
-      const zoomedSpan = zoomedDomain[1] - zoomedDomain[0]
-
-      dispatchWheel(1000)
-      flushAnimationFrames()
-      expect(wrapper.emitted('zoom-end')).toHaveLength(1)
-      await vi.advanceTimersByTimeAsync(200)
-      await flushPromises()
-
-      const zoomedOutPayload = wrapper.emitted('zoom-end')?.at(-1)?.[0] as {
-        start: number
-        end: number
-        gesture: string
-      }
-      expect(wrapper.emitted('zoom-end')).toHaveLength(2)
-      expect(zoomedOutPayload.end - zoomedOutPayload.start).toBeGreaterThan(zoomedSpan)
-      expect(zoomedOutPayload.gesture).toBe('wheel')
-    } finally {
-      vi.useRealTimers()
-    }
-  })
-})

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

@@ -1,117 +0,0 @@
-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

@@ -1,168 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { gridSeries, mountSizedChart } from '../../test/waveformChart'
-
-describe('WaveformChart x domain strategy', () => {
-  it('expands automatic x domains without changing source seconds', async () => {
-    const data = {
-      kind: 'points' as const,
-      points: [
-        { x: 0, y: 0 },
-        { x: 4.999999, y: 1 },
-      ],
-    }
-    const wrapper = await mountSizedChart(data, {
-      timeUnit: 'ms',
-      xDomainStrategy: { type: 'nice', bounds: 'end' },
-    })
-
-    expect(wrapper.get('.waveform-chart__axis-endpoint--start').text()).toBe('0')
-    expect(wrapper.get('.waveform-chart__axis-endpoint--end').text()).toBe('5000')
-    expect(data.points[1]?.x).toBe(4.999999)
-  })
-
-  it('keeps explicit initial x domains exact by default', async () => {
-    const wrapper = await mountSizedChart(
-      {
-        kind: 'points',
-        points: [
-          { x: 123, y: 0 },
-          { x: 456, y: 1 },
-        ],
-      },
-      {
-        timeUnit: 's',
-        initialXDomain: [120, 460],
-        xDomainStrategy: { type: 'nice' },
-      },
-    )
-
-    expect(wrapper.get('.waveform-chart__axis-endpoint--start').text()).toBe('120')
-    expect(wrapper.get('.waveform-chart__axis-endpoint--end').text()).toBe('460')
-  })
-
-  it('keeps explicit per-track initial x domains exact by default', async () => {
-    const wrapper = await mountSizedChart(gridSeries(1), {
-      displayMode: 'independent',
-      initialXDomains: { 'channel-0': [0, 4.999999] },
-      xDomainStrategy: { type: 'nice', bounds: 'end' },
-    })
-
-    expect(wrapper.get('.waveform-chart__axis-endpoint--start').text()).toBe('0')
-    expect(wrapper.get('.waveform-chart__axis-endpoint--end').text()).toBe('4999.999')
-  })
-
-  it('includes an explicit shared initial x domain when requested', async () => {
-    const wrapper = await mountSizedChart(
-      {
-        kind: 'points',
-        points: [
-          { x: 0, y: 0 },
-          { x: 4.999999, y: 1 },
-        ],
-      },
-      {
-        initialXDomain: [0, 4.999999],
-        xDomainStrategy: {
-          type: 'nice',
-          bounds: 'end',
-          tickCount: 10,
-          includeExplicit: true,
-        },
-      },
-    )
-
-    expect(wrapper.get('.waveform-chart__axis-endpoint--start').text()).toBe('0')
-    expect(wrapper.get('.waveform-chart__axis-endpoint--end').text()).toBe('5000')
-  })
-
-  it('includes explicit per-track initial x domains in independent mode', async () => {
-    const wrapper = await mountSizedChart(gridSeries(2), {
-      displayMode: 'independent',
-      grid: { rowCount: 1, columnCount: 2 },
-      initialXDomains: {
-        'channel-0': [0, 4.999999],
-        'channel-1': [10, 14.999999],
-      },
-      xDomainStrategy: { type: 'nice', bounds: 'end', tickCount: 10, includeExplicit: true },
-    })
-
-    const tracks = wrapper.findAll('.waveform-chart__track')
-    expect(tracks[0]?.get('.waveform-chart__axis-endpoint--start').text()).toBe('0')
-    expect(tracks[0]?.get('.waveform-chart__axis-endpoint--end').text()).toBe('5000')
-    expect(tracks[1]?.get('.waveform-chart__axis-endpoint--start').text()).toBe('10000')
-    expect(tracks[1]?.get('.waveform-chart__axis-endpoint--end').text()).toBe('15000')
-  })
-
-  it('keeps an explicit viewport wider than the data and leaves uncovered time blank', async () => {
-    const wrapper = await mountSizedChart(
-      {
-        kind: 'points',
-        points: [
-          { x: 0, y: 0 },
-          { x: 10, y: 1 },
-        ],
-      },
-      { timeUnit: 's', initialXDomain: [-5, 20] },
-    )
-
-    const track = wrapper.get('.waveform-chart__track')
-    const width = Number(track.attributes('data-track-width'))
-    const path = track.get('.waveform-chart__line').attributes('d') ?? ''
-    const xCoordinates = Array.from(path.matchAll(/(?:M|L)([\d.-]+)/g)).map((match) =>
-      Number(match[1]),
-    )
-
-    expect(track.get('.waveform-chart__axis-endpoint--start').text()).toBe('-5')
-    expect(track.get('.waveform-chart__axis-endpoint--end').text()).toBe('20')
-    expect(xCoordinates.length).toBeGreaterThan(0)
-    expect(Math.min(...xCoordinates)).toBeGreaterThanOrEqual(0)
-    expect(Math.max(...xCoordinates)).toBeLessThanOrEqual(width)
-  })
-
-  it('applies independent explicit viewports per track, including empty time regions', async () => {
-    const wrapper = await mountSizedChart(
-      {
-        kind: 'series',
-        series: [
-          {
-            id: 'first',
-            name: '第一轨',
-            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 },
-              ],
-            },
-          },
-        ],
-      },
-      {
-        displayMode: 'independent',
-        grid: { rowCount: 1, columnCount: 2 },
-        timeUnit: 's',
-        initialXDomains: { first: [-5, 20], second: [95, 120] },
-      },
-    )
-
-    const tracks = wrapper.findAll('.waveform-chart__track')
-    expect(tracks[0]?.get('.waveform-chart__axis-endpoint--start').text()).toBe('-5')
-    expect(tracks[0]?.get('.waveform-chart__axis-endpoint--end').text()).toBe('20')
-    expect(tracks[1]?.get('.waveform-chart__axis-endpoint--start').text()).toBe('95')
-    expect(tracks[1]?.get('.waveform-chart__axis-endpoint--end').text()).toBe('120')
-    expect(tracks[0]?.find('.waveform-chart__line').exists()).toBe(true)
-    expect(tracks[1]?.find('.waveform-chart__line').exists()).toBe(true)
-  })
-})

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

@@ -1,103 +0,0 @@
-import { flushPromises } from '@vue/test-utils'
-import { describe, expect, it } from 'vitest'
-
-import { resizeObservers } from '../../test/setup'
-
-import { mountSizedChart } from '../../test/waveformChart'
-
-describe('WaveformChart Y-axis layout', () => {
-  it('applies the configured Y-axis split number', async () => {
-    const wrapper = await mountSizedChart(
-      {
-        kind: 'points',
-        points: [
-          { x: 0, y: 3 },
-          { x: 1, y: 97 },
-        ],
-      },
-      { axes: { y: { splitNumber: 5 } } },
-    )
-
-    expect(
-      wrapper
-        .get('.waveform-chart__axis--y')
-        .findAll('.tick text')
-        .map((tick) => tick.text()),
-    ).toEqual(['0', '25', '50', '75', '100'])
-  })
-
-  it('reserves the rendered endpoint label width across tracks, pages, and resizes', async () => {
-    const wrapper = await mountSizedChart(
-      {
-        kind: 'series',
-        series: ['WE_2M', 'IP_VV_2M', 'SX2_7_07', 'BT1_2M'].map((name, index) => ({
-          id: name,
-          name,
-          unit: 'V',
-          data: {
-            kind: 'points' as const,
-            points: [
-              { x: 0, y: -0.7434 - index },
-              { x: 1, y: -0.3434 - index },
-            ],
-          },
-        })),
-      },
-      {
-        axes: { y: { lineVisible: false, nice: false } },
-        grid: { rowCount: 1, columnCount: 1 },
-      },
-    )
-    const firstTrack = wrapper.get('.waveform-chart__track')
-
-    expect(wrapper.attributes('data-chart-left-margin')).toBe('100')
-    expect(firstTrack.attributes('data-y-axis-label-x')).toBe('-90')
-    expect(firstTrack.findAll('.waveform-chart__axis--y .tick text').at(-1)?.text()).toBe(
-      '(V) -0.3434',
-    )
-
-    resizeObservers.at(-1)?.resize(520, 280)
-    await flushPromises()
-    expect(wrapper.attributes('data-chart-left-margin')).toBe('100')
-    expect(wrapper.get('.waveform-chart__track').attributes('data-y-axis-label-x')).toBe('-90')
-
-    await wrapper.get('.ant-pagination-next button').trigger('click')
-    expect(wrapper.attributes('data-chart-left-margin')).toBe('100')
-    expect(wrapper.get('.waveform-chart__track').attributes('data-y-axis-label-x')).toBe('-90')
-    expect(wrapper.get('.waveform-chart__axis--y').findAll('.tick text').at(-1)?.text()).toBe(
-      '(V) -1.3434',
-    )
-  })
-
-  it('measures the compact-row unit label after omitting the top endpoint', async () => {
-    const wrapper = await mountSizedChart(
-      {
-        kind: 'series',
-        series: ['first', 'second'].map((id) => ({
-          id,
-          name: id,
-          unit: 'V',
-          data: {
-            kind: 'points' as const,
-            points: [
-              { x: 0, y: 0.12345 },
-              { x: 1, y: 100 },
-            ],
-          },
-        })),
-      },
-      {
-        displayMode: 'compact',
-        axes: { y: { nice: false } },
-        grid: { rowCount: 2, columnCount: 1 },
-      },
-    )
-    const tracks = wrapper.findAll('.waveform-chart__track')
-
-    expect(wrapper.attributes('data-chart-left-margin')).toBe('93')
-    expect(tracks[1]?.attributes('data-y-axis-label-x')).toBe('-83')
-    expect(tracks[1]?.findAll('.waveform-chart__axis--y .tick text').at(-1)?.text()).toBe(
-      '(V) 75.031',
-    )
-  })
-})