waveform-analysis 0.1.63 → 0.1.64

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

@@ -1,213 +0,0 @@
-import { flushPromises, mount } from '@vue/test-utils'
-import { defineComponent, h, ref } from 'vue'
-import { describe, expect, it, vi } from 'vitest'
-
-import WaveformChart from '../WaveformChart.vue'
-import type { WaveformData } from '../waveform'
-import { resizeObservers } from '../../test/setup'
-import { gridSeries, mountSizedChart } from '../../test/waveformChart'
-
-function seriesWindow(ids: string[]) {
-  return {
-    kind: 'series' as const,
-    series: ids.map((id, index) => ({
-      id,
-      name: id,
-      data: {
-        kind: 'points' as const,
-        points: [
-          { x: 40, y: index },
-          { x: 50, y: index + 1 },
-          { x: 60, y: index + 2 },
-        ],
-      },
-    })),
-  }
-}
-
-function fullSeries(ids: string[]): WaveformData {
-  return {
-    kind: 'series',
-    series: ids.map((id, index) => ({
-      id,
-      name: id,
-      data: {
-        kind: 'points',
-        points: [
-          { x: 0, y: index },
-          { x: 50, y: index + 1 },
-          { x: 100, y: index + 2 },
-        ],
-      },
-    })),
-  }
-}
-
-function configureOverlay(overlay: ReturnType<typeof mount>['element']) {
-  const width = Number(overlay.getAttribute('width'))
-  const height = Number(overlay.getAttribute('height'))
-  Object.defineProperty(overlay, 'getBoundingClientRect', {
-    value: () => ({ left: 0, top: 0, width, height }),
-  })
-  return { width, height }
-}
-
-function dispatchWheel(overlay: Element, deltaY: number, width: number, height: number) {
-  overlay.dispatchEvent(
-    new WheelEvent('wheel', {
-      deltaY,
-      clientX: width / 2,
-      clientY: height / 2,
-      bubbles: true,
-      cancelable: true,
-    }),
-  )
-}
-
-describe('WaveformChart zoom intent and data rebind', () => {
-  it('keeps one shared wheel end after an immediate intent-driven data replacement', async () => {
-    vi.useFakeTimers()
-    try {
-      const data = ref<WaveformData>(fullSeries(['shared']))
-      const host = mount(
-        defineComponent({
-          setup() {
-            return () =>
-              h(WaveformChart, {
-                data: data.value,
-                displayMode: 'separated',
-                initialXDomain: [0, 100],
-                onZoomIntent: () => {
-                  data.value = seriesWindow(['shared'])
-                },
-              })
-          },
-        }),
-      )
-      resizeObservers.at(-1)?.resize(800, 360)
-      await flushPromises()
-
-      const chart = host.findComponent(WaveformChart)
-      const overlay = chart.get('.waveform-chart__overlay')
-      const { width, height } = configureOverlay(overlay.element)
-      dispatchWheel(overlay.element, -4_000, width, height)
-
-      const firstIntent = chart.emitted('zoom-intent')?.[0]?.[0] as {
-        start: number
-        end: number
-      }
-      expect(firstIntent.end - firstIntent.start).toBeCloseTo(2.5)
-      expect(chart.emitted('zoom-change')).toBeUndefined()
-
-      await flushPromises()
-      dispatchWheel(overlay.element, 1_000, width, height)
-      await flushPromises()
-      await vi.advanceTimersByTimeAsync(199)
-      expect(chart.emitted('zoom-end')).toBeUndefined()
-
-      await vi.advanceTimersByTimeAsync(1)
-      await flushPromises()
-      const zoomEnd = chart.emitted('zoom-end')?.[0]?.[0] as { start: number; end: number }
-      expect(chart.emitted('zoom-intent')).toHaveLength(2)
-      expect(chart.emitted('zoom-end')).toHaveLength(1)
-      expect(zoomEnd.end - zoomEnd.start).toBeGreaterThan(firstIntent.end - firstIntent.start)
-    } finally {
-      vi.useRealTimers()
-    }
-  })
-
-  it('retains a pending independent wheel gesture by stable series identity', async () => {
-    vi.useFakeTimers()
-    try {
-      const data = ref<WaveformData>(fullSeries(['channel-a', 'channel-b']))
-      const host = mount(
-        defineComponent({
-          setup() {
-            return () =>
-              h(WaveformChart, {
-                data: data.value,
-                displayMode: 'independent',
-                grid: { rowCount: 1, columnCount: 2 },
-                initialXDomain: [0, 100],
-                onZoomIntent: () => {
-                  data.value = seriesWindow(['channel-b', 'channel-a'])
-                },
-              })
-          },
-        }),
-      )
-      resizeObservers.at(-1)?.resize(800, 360)
-      await flushPromises()
-
-      const chart = host.findComponent(WaveformChart)
-      const overlay = chart.findAll('.waveform-chart__overlay--independent')[0]!
-      const { width, height } = configureOverlay(overlay.element)
-      dispatchWheel(overlay.element, -4_000, width, height)
-      await flushPromises()
-      await vi.advanceTimersByTimeAsync(200)
-      await flushPromises()
-
-      const zoomEnd = chart.emitted('zoom-end')?.[0]?.[0] as {
-        trackIndex: number
-        seriesIds: string[]
-      }
-      expect(chart.emitted('zoom-intent')?.[0]?.[0]).toMatchObject({
-        trackIndex: 0,
-        seriesIds: ['channel-a'],
-        gesture: 'wheel',
-      })
-      expect(zoomEnd).toMatchObject({ trackIndex: 1, seriesIds: ['channel-a'], gesture: 'wheel' })
-    } finally {
-      vi.useRealTimers()
-    }
-  })
-
-  it('emits box intent with the selected independent series', async () => {
-    const wrapper = await mountSizedChart(fullSeries(['series-a']), { initialXDomain: [0, 100] })
-    const overlay = wrapper.get('.waveform-chart__overlay--independent')
-    const { width, height } = configureOverlay(overlay.element)
-    const dispatchPointer = (type: string, clientX: number, clientY: number) => {
-      const event = new MouseEvent(type, { button: 0, clientX, clientY, bubbles: true })
-      Object.defineProperty(event, 'pointerId', { value: 11 })
-      overlay.element.dispatchEvent(event)
-    }
-
-    dispatchPointer('pointerdown', width * 0.25, height / 2)
-    dispatchPointer('pointermove', width * 0.75, height / 2)
-    dispatchPointer('pointerup', width * 0.75, height / 2)
-    await flushPromises()
-
-    expect(wrapper.emitted('zoom-intent')?.[0]?.[0]).toMatchObject({
-      trackIndex: 0,
-      seriesIds: ['series-a'],
-      gesture: 'box',
-    })
-  })
-
-  it('cancels pending wheel ends when reset or pagination changes the viewport', async () => {
-    vi.useFakeTimers()
-    try {
-      const reset = await mountSizedChart(fullSeries(['reset']), { initialXDomain: [0, 100] })
-      const resetOverlay = reset.get('.waveform-chart__overlay--independent')
-      const resetBounds = configureOverlay(resetOverlay.element)
-      dispatchWheel(resetOverlay.element, -4_000, resetBounds.width, resetBounds.height)
-      ;(reset.vm as unknown as { resetViewport: () => void }).resetViewport()
-      await vi.advanceTimersByTimeAsync(200)
-      expect(reset.emitted('zoom-end')).toBeUndefined()
-
-      const paged = await mountSizedChart(gridSeries(2), {
-        displayMode: 'independent',
-        grid: { rowCount: 1, columnCount: 1 },
-      })
-      const pageOverlay = paged.get('.waveform-chart__overlay--independent')
-      const pageBounds = configureOverlay(pageOverlay.element)
-      dispatchWheel(pageOverlay.element, -4_000, pageBounds.width, pageBounds.height)
-      await paged.get('.ant-pagination-next button').trigger('click')
-      await flushPromises()
-      await vi.advanceTimersByTimeAsync(200)
-      expect(paged.emitted('zoom-end')).toBeUndefined()
-    } finally {
-      vi.useRealTimers()
-    }
-  })
-})

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

@@ -1,308 +0,0 @@
-import { flushPromises, type VueWrapper } from '@vue/test-utils'
-import { describe, expect, it } from 'vitest'
-
-import { flushAnimationFrames } from '../../test/setup'
-import { mountSizedChart } from '../../test/waveformChart'
-
-const regularPoints = Array.from({ length: 1_200 }, (_, index) => ({ x: index, y: index % 11 }))
-
-function visibleXCount(domain: [number, number], values = regularPoints): number {
-  return new Set(
-    values.filter((point) => point.x >= domain[0] && point.x <= domain[1]).map((point) => point.x),
-  ).size
-}
-
-function prepareOverlay(wrapper: VueWrapper, selector: string) {
-  const overlay = wrapper.get(selector)
-  const width = Number(overlay.attributes('width'))
-  const height = Number(overlay.attributes('height'))
-  Object.defineProperty(overlay.element, 'getBoundingClientRect', {
-    value: () => ({ left: 0, top: 0, width, height }),
-  })
-  return { overlay, width, height }
-}
-
-async function dispatchWheel(
-  overlay: ReturnType<VueWrapper['get']>,
-  width: number,
-  height: number,
-  deltaY: number,
-) {
-  overlay.element.dispatchEvent(
-    new WheelEvent('wheel', {
-      deltaY,
-      clientX: width / 2,
-      clientY: height / 2,
-      bubbles: true,
-      cancelable: true,
-    }),
-  )
-  flushAnimationFrames()
-  await flushPromises()
-}
-
-function dispatchBox(
-  overlay: ReturnType<VueWrapper['get']>,
-  startX: number,
-  endX: number,
-  height: number,
-  pointerId: number,
-) {
-  for (const [type, clientX] of [
-    ['pointerdown', startX],
-    ['pointermove', endX],
-    ['pointerup', endX],
-  ] as const) {
-    const event = new MouseEvent(type, {
-      button: 0,
-      clientX,
-      clientY: height / 2,
-      bubbles: true,
-    })
-    Object.defineProperty(event, 'pointerId', { value: pointerId })
-    overlay.element.dispatchEvent(event)
-  }
-}
-
-describe('WaveformChart point-aware zoom constraints', () => {
-  it('zooms to two distinct X values when the scale limit is disabled', async () => {
-    const wrapper = await mountSizedChart(
-      { kind: 'points', points: regularPoints },
-      { minVisiblePoints: 2, maxZoomScale: null },
-    )
-    const { overlay, width, height } = prepareOverlay(
-      wrapper,
-      '.waveform-chart__overlay--independent',
-    )
-
-    await dispatchWheel(overlay, width, height, -4_000)
-    await dispatchWheel(overlay, width, height, -4_000)
-    const twoPointDomain = wrapper.emitted('zoom-change')?.at(-1)?.[0] as [number, number]
-    expect(visibleXCount(twoPointDomain)).toBe(2)
-
-    const eventCount = wrapper.emitted('zoom-change')?.length ?? 0
-    await dispatchWheel(overlay, width, height, -1_000)
-    expect(wrapper.emitted('zoom-change')?.length ?? 0).toBe(eventCount)
-
-    await dispatchWheel(overlay, width, height, 4_000)
-    const partiallyZoomedOut = wrapper.emitted('zoom-change')?.at(-1)?.[0] as [number, number]
-    expect(partiallyZoomedOut[1] - partiallyZoomedOut[0]).toBeGreaterThan(
-      twoPointDomain[1] - twoPointDomain[0],
-    )
-    await dispatchWheel(overlay, width, height, 4_000)
-    const fullyZoomedOut = wrapper.emitted('zoom-change')?.at(-1)?.[0] as [number, number]
-    expect(fullyZoomedOut).toEqual([0, 1_199])
-  })
-
-  it('keeps two fractional samples when the wheel focus falls between sample positions', async () => {
-    const points = Array.from({ length: 1_000 }, (_, index) => ({
-      x: -5 + (index * 10) / 999,
-      y: index,
-    }))
-    const wrapper = await mountSizedChart(
-      { kind: 'points', points },
-      { minVisiblePoints: 2, initialXDomain: [-5, 5] },
-    )
-    const { overlay, width, height } = prepareOverlay(
-      wrapper,
-      '.waveform-chart__overlay--independent',
-    )
-
-    for (let index = 0; index < 3; index += 1) {
-      overlay.element.dispatchEvent(
-        new WheelEvent('wheel', {
-          deltaY: -4_000,
-          clientX: width * 0.5032,
-          clientY: height / 2,
-          bubbles: true,
-          cancelable: true,
-        }),
-      )
-      flushAnimationFrames()
-      await flushPromises()
-    }
-
-    const domain = wrapper.emitted('zoom-change')?.at(-1)?.[0] as [number, number]
-    expect(visibleXCount(domain, points)).toBe(2)
-  })
-
-  it('uses repeated box zooms to reach exactly two distinct X values', async () => {
-    const wrapper = await mountSizedChart(
-      { kind: 'points', points: regularPoints },
-      { minVisiblePoints: 2 },
-    )
-    const { overlay, width, height } = prepareOverlay(
-      wrapper,
-      '.waveform-chart__overlay--independent',
-    )
-
-    for (let index = 0; index < 3; index += 1) {
-      dispatchBox(overlay, width / 2 - 4, width / 2 + 4, height, index + 1)
-      await flushPromises()
-    }
-
-    const domain = wrapper.emitted('zoom-change')?.at(-1)?.[0] as [number, number]
-    expect(visibleXCount(domain)).toBe(2)
-    const eventCount = wrapper.emitted('zoom-change')?.length ?? 0
-    dispatchBox(overlay, width / 2 - 4, width / 2 + 4, height, 10)
-    await flushPromises()
-    const constrainedDomain = wrapper.emitted('zoom-change')?.at(-1)?.[0] as [number, number]
-    expect(wrapper.emitted('zoom-change')?.length ?? 0).toBe(eventCount)
-    expect(visibleXCount(constrainedDomain)).toBe(2)
-  })
-
-  it('retains the backwards-compatible default maximum zoom scale', async () => {
-    const wrapper = await mountSizedChart({ kind: 'points', points: regularPoints })
-    const { overlay, width, height } = prepareOverlay(
-      wrapper,
-      '.waveform-chart__overlay--independent',
-    )
-
-    await dispatchWheel(overlay, width, height, -4_000)
-    const domain = wrapper.emitted('zoom-change')?.at(-1)?.[0] as [number, number]
-    expect(domain[1] - domain[0]).toBeCloseTo(1_199 / 40)
-  })
-
-  it('honors an explicit maximum zoom scale', async () => {
-    const wrapper = await mountSizedChart(
-      { kind: 'points', points: regularPoints },
-      { maxZoomScale: 20 },
-    )
-    const { overlay, width, height } = prepareOverlay(
-      wrapper,
-      '.waveform-chart__overlay--independent',
-    )
-
-    await dispatchWheel(overlay, width, height, -4_000)
-    const domain = wrapper.emitted('zoom-change')?.at(-1)?.[0] as [number, number]
-    expect(domain[1] - domain[0]).toBeCloseTo(1_199 / 20)
-  })
-
-  it('disables the compatibility scale limit when configured with null', async () => {
-    const wrapper = await mountSizedChart(
-      { kind: 'points', points: regularPoints },
-      { maxZoomScale: null },
-    )
-    const { overlay, width, height } = prepareOverlay(
-      wrapper,
-      '.waveform-chart__overlay--independent',
-    )
-
-    await dispatchWheel(overlay, width, height, -4_000)
-    const domain = wrapper.emitted('zoom-change')?.at(-1)?.[0] as [number, number]
-    expect(domain[1] - domain[0]).toBeLessThan(1_199 / 40)
-  })
-
-  it('falls back to the compatibility limit for an invalid maximum scale', async () => {
-    const wrapper = await mountSizedChart(
-      { kind: 'points', points: regularPoints },
-      { maxZoomScale: 0 },
-    )
-    const { overlay, width, height } = prepareOverlay(
-      wrapper,
-      '.waveform-chart__overlay--independent',
-    )
-
-    await dispatchWheel(overlay, width, height, -4_000)
-    const domain = wrapper.emitted('zoom-change')?.at(-1)?.[0] as [number, number]
-    expect(domain[1] - domain[0]).toBeCloseTo(1_199 / 40)
-  })
-
-  it('uses the strictest configured zoom constraint', async () => {
-    const wrapper = await mountSizedChart(
-      { kind: 'points', points: regularPoints },
-      { minZoomSpan: 50, minVisiblePoints: 2, maxZoomScale: 40 },
-    )
-    const { overlay, width, height } = prepareOverlay(
-      wrapper,
-      '.waveform-chart__overlay--independent',
-    )
-
-    await dispatchWheel(overlay, width, height, -4_000)
-    const domain = wrapper.emitted('zoom-change')?.at(-1)?.[0] as [number, number]
-    expect(domain[1] - domain[0]).toBeCloseTo(50)
-  })
-
-  it('retains two endpoint samples while replacing an independent data window', async () => {
-    const sourcePoints = Array.from({ length: 1_000 }, (_, index) => ({
-      x: -5 + (index * 10) / 999,
-      y: index,
-    }))
-    const wrapper = await mountSizedChart(
-      { kind: 'points', points: sourcePoints },
-      { minVisiblePoints: 2, initialXDomain: [-5, 5] },
-    )
-    const { overlay, width, height } = prepareOverlay(
-      wrapper,
-      '.waveform-chart__overlay--independent',
-    )
-    for (let index = 0; index < 10; index += 1) {
-      const eventCount = wrapper.emitted('zoom-change')?.length ?? 0
-      overlay.element.dispatchEvent(
-        new WheelEvent('wheel', {
-          deltaY: -1_000,
-          clientX: width * 0.5032,
-          clientY: height / 2,
-          bubbles: true,
-          cancelable: true,
-        }),
-      )
-      flushAnimationFrames()
-      await flushPromises()
-      if ((wrapper.emitted('zoom-change')?.length ?? 0) === eventCount) break
-      const domain = wrapper.emitted('zoom-change')?.at(-1)?.[0] as [number, number]
-      const windowPoints = sourcePoints.filter(
-        (point) => point.x >= domain[0] && point.x <= domain[1],
-      )
-      await wrapper.setProps({ data: { kind: 'points', points: windowPoints } })
-      await flushPromises()
-    }
-
-    const finalDomain = wrapper.emitted('zoom-change')?.at(-1)?.[0] as [number, number]
-    const endpointDomain = wrapper
-      .findAll('.waveform-chart__axis-endpoint')
-      .slice(0, 2)
-      .map((endpoint) => Number(endpoint.text()) / 1_000) as [number, number]
-    expect(visibleXCount(finalDomain, sourcePoints)).toBe(2)
-    expect(visibleXCount(endpointDomain, sourcePoints)).toBe(2)
-    const eventCount = wrapper.emitted('zoom-change')?.length ?? 0
-    await dispatchWheel(overlay, width, height, -1_000)
-    expect(wrapper.emitted('zoom-change')?.length ?? 0).toBe(eventCount)
-  })
-
-  it('recomputes irregular point constraints for shared tracks after data replacement', async () => {
-    const createData = (offset: number) => ({
-      kind: 'series' as const,
-      series: [
-        {
-          id: 'first',
-          name: 'First',
-          data: {
-            kind: 'points' as const,
-            points: [0, 1, 4, 20].map((x) => ({ x: x + offset, y: x })),
-          },
-        },
-        {
-          id: 'second',
-          name: 'Second',
-          data: {
-            kind: 'points' as const,
-            points: [0, 3, 9, 20].map((x) => ({ x: x + offset, y: x })),
-          },
-        },
-      ],
-    })
-    const wrapper = await mountSizedChart(createData(0), {
-      displayMode: 'separated',
-      minVisiblePoints: 2,
-    })
-    const { overlay, width, height } = prepareOverlay(wrapper, '.waveform-chart__overlay')
-
-    await dispatchWheel(overlay, width, height, -4_000)
-    await wrapper.setProps({ data: createData(100) })
-    await flushPromises()
-    await dispatchWheel(overlay, width, height, 4_000)
-    const domain = wrapper.emitted('zoom-change')?.at(-1)?.[0] as [number, number]
-    expect(domain).toEqual([100, 120])
-  })
-})

package/src/components/waveformLegendGeometry.test.ts

@@ -1,21 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import {
-  waveformLegendErrorBarPath,
-  waveformLegendLinePath,
-  waveformLineDasharray,
-} from './rendering/seriesStyle'
-describe('legend series geometry', () => {
-  it('keeps line samples centered and clamps error-bar caps to the swatch', () => {
-    expect(waveformLegendLinePath('linear')).toBe('M1 8H25')
-    expect(waveformLegendLinePath('step-start')).toBe('M1 8H25')
-    expect(waveformLegendLinePath('step-middle')).toBe('M1 8H25')
-    expect(waveformLegendLinePath('step-end')).toBe('M1 8H25')
-    expect(waveformLegendLinePath('step-after')).toBe('M1 8H25')
-    expect(waveformLegendLinePath('none')).toBeNull()
-    expect(waveformLegendErrorBarPath(10)).toBe('M8 2H18M13 2V14M8 14H18')
-    expect(waveformLegendErrorBarPath(100)).toBe('M1 2H25M13 2V14M1 14H25')
-    expect(waveformLineDasharray('solid')).toBeUndefined()
-    expect(waveformLineDasharray('dashed')).toBe('8 5')
-    expect(waveformLineDasharray('dash-dot')).toBe('8 5 1.5 5')
-  })
-})