waveform-analysis 0.1.62 → 0.1.64

package/src/components/core/fixedYDomainLayout.test.ts

@@ -1,204 +0,0 @@
-import { zoomIdentity } from 'd3'
-import { describe, expect, it } from 'vitest'
-
-import { DEFAULT_WAVEFORM_RENDERING_OPTIONS } from '../../core'
-import type { DisplaySeries, DisplayTrack } from './types'
-import { buildTrackLayouts, resolveYAxisSeriesGroups } from './layout'
-
-function series(id: string, minimum: number, maximum: number): DisplaySeries {
-  return {
-    id,
-    name: id,
-    color: '#1677ff',
-    lineType: 'linear',
-    lineStyle: 'solid',
-    pointType: 'none',
-    errorBar: { visible: false, width: 1.5, capWidth: 8 },
-    points: [
-      { x: 0, y: minimum },
-      { x: 1, y: maximum },
-    ],
-    xDomain: [0, 1],
-    yDomain: [minimum, maximum],
-    hasErrorPoints: false,
-  }
-}
-
-function track(seriesList: DisplaySeries[]): DisplayTrack {
-  return {
-    id: 'track',
-    series: seriesList,
-    visibleSeries: seriesList,
-    xDomain: [0, 1],
-    yDomain: [0, 100],
-  }
-}
-
-describe('fixed Y-domain layout', () => {
-  it('expands a global fixed domain to nice equal intervals', () => {
-    const sourceTrack = track([series('a', 0, 100)])
-    const result = buildTrackLayouts({
-      cells: [
-        {
-          slotIndex: 0,
-          row: 0,
-          column: 0,
-          left: 0,
-          top: 0,
-          width: 120,
-          height: 100,
-          plotHeight: 100,
-          cellHeight: 130,
-          xAxisBand: 30,
-          series: sourceTrack,
-        },
-      ],
-      grid: {
-        rowCount: 1,
-        columnCount: 1,
-        showPagination: false,
-        fillIncompleteLastRow: false,
-        trackLines: {},
-      },
-      displayMode: 'independent',
-      overlayMode: 'single-axis',
-      independentTransforms: [zoomIdentity],
-      sharedZoomDomain: [0, 1],
-      fixedYDomain: [3, 97],
-      timeUnit: 'ms',
-      rendering: DEFAULT_WAVEFORM_RENDERING_OPTIONS,
-      hideSecondaryLabels: false,
-      yAxisLabelX: -50,
-      showCompactEmptyTracks: false,
-    })[0]
-
-    expect(result?.yScale.domain()).toEqual([0, 100])
-    expect(result?.yAxes[0]?.tickValues).toContain(0)
-    expect(result?.yAxes[0]?.tickValues).toContain(100)
-    expect(result?.seriesPaths[0]?.yScale.domain()).toEqual([0, 100])
-  })
-
-  it('uses the configured split number for fixed domains', () => {
-    const result = buildTrackLayouts({
-      cells: [
-        {
-          slotIndex: 0,
-          row: 0,
-          column: 0,
-          left: 0,
-          top: 0,
-          width: 120,
-          height: 100,
-          plotHeight: 100,
-          cellHeight: 130,
-          xAxisBand: 30,
-          series: track([series('a', 0, 100)]),
-        },
-      ],
-      grid: {
-        rowCount: 1,
-        columnCount: 1,
-        showPagination: false,
-        fillIncompleteLastRow: false,
-        trackLines: {},
-      },
-      displayMode: 'independent',
-      overlayMode: 'single-axis',
-      independentTransforms: [zoomIdentity],
-      sharedZoomDomain: [0, 1],
-      fixedYDomain: [3, 97],
-      yAxisSplitNumber: 5,
-      timeUnit: 'ms',
-      rendering: DEFAULT_WAVEFORM_RENDERING_OPTIONS,
-      hideSecondaryLabels: false,
-      yAxisLabelX: -50,
-      showCompactEmptyTracks: false,
-    })[0]
-
-    expect(result?.yAxes[0]?.majorTicks).toEqual([0, 25, 50, 75, 100])
-  })
-
-  it('defaults to five ticks and supports a two-tick axis', () => {
-    const build = (splitNumber?: number) =>
-      buildTrackLayouts({
-        cells: [
-          {
-            slotIndex: 0,
-            row: 0,
-            column: 0,
-            left: 0,
-            top: 0,
-            width: 120,
-            height: 100,
-            plotHeight: 100,
-            cellHeight: 130,
-            xAxisBand: 30,
-            series: track([series('a', 3, 97)]),
-          },
-        ],
-        grid: {
-          rowCount: 1,
-          columnCount: 1,
-          showPagination: false,
-          fillIncompleteLastRow: false,
-          trackLines: {},
-        },
-        displayMode: 'independent',
-        overlayMode: 'single-axis',
-        independentTransforms: [zoomIdentity],
-        sharedZoomDomain: [0, 1],
-        fixedYDomain: [3, 97],
-        yAxisSplitNumber: splitNumber,
-        timeUnit: 'ms',
-        rendering: DEFAULT_WAVEFORM_RENDERING_OPTIONS,
-        hideSecondaryLabels: false,
-        yAxisLabelX: -50,
-        showCompactEmptyTracks: false,
-      })[0]?.yAxes[0]?.majorTicks
-
-    expect(build()).toHaveLength(5)
-    expect(build(2)).toEqual([0, 100])
-  })
-
-  it('resolves track, series, and global fixed-domain precedence', () => {
-    const sourceTrack = track([series('a', 0, 10), series('b', 20, 30)])
-
-    expect(
-      resolveYAxisSeriesGroups(sourceTrack, 'single-axis', [-5, 5], {
-        a: [-10, 10],
-        track: [300, 100],
-      })[0]?.domain,
-    ).toEqual([100, 300])
-
-    expect(
-      resolveYAxisSeriesGroups(sourceTrack, 'single-axis', [-5, 5], {
-        a: [-10, 10],
-      })[0]?.domain,
-    ).toEqual([-10, 10])
-  })
-
-  it('keeps per-series fixed domains on separate axes and merges axis overflow', () => {
-    const sourceTrack = track([
-      series('a', 0, 1),
-      series('b', 10, 11),
-      series('c', 20, 21),
-      series('d', 30, 31),
-      series('e', 40, 41),
-    ])
-    const groups = resolveYAxisSeriesGroups(sourceTrack, 'multi-axis', undefined, {
-      a: [-1, 1],
-      b: [-2, 2],
-      c: [-3, 3],
-      d: [-4, 4],
-      e: [-5, 5],
-    })
-
-    expect(groups.map((group) => group.domain)).toEqual([
-      [-1, 1],
-      [-2, 2],
-      [-3, 3],
-      [-5, 5],
-    ])
-    expect(groups.every((group) => group.fixed)).toBe(true)
-  })
-})

package/src/components/core/grid.test.ts

@@ -1,197 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import {
-  getBottomRowCellIndexes,
-  getPageCount,
-  normalizeGridOptions,
-  paginateSeries,
-  resolveGridCellGeometry,
-  X_AXIS_BAND,
-} from './grid'
-
-describe('waveform grid helpers', () => {
-  it('normalizes grid counts and uses a two by one default', () => {
-    expect(normalizeGridOptions()).toEqual({
-      rowCount: 2,
-      columnCount: 1,
-      showPagination: true,
-      fillIncompleteLastRow: false,
-      trackOrder: [],
-      hideEmptyTracks: false,
-      trackLines: {},
-    })
-    expect(normalizeGridOptions({ rowCount: 0, columnCount: 99 })).toEqual({
-      rowCount: 1,
-      columnCount: 10,
-      showPagination: true,
-      fillIncompleteLastRow: false,
-      trackOrder: [],
-      hideEmptyTracks: false,
-      trackLines: {},
-    })
-    expect(normalizeGridOptions({ hideEmptyTracks: true }).hideEmptyTracks).toBe(true)
-  })
-
-  it('normalizes track order by trimming, dropping blanks, and removing duplicates', () => {
-    expect(
-      normalizeGridOptions({ trackOrder: [' voltage ', '', 'current', 'voltage', '  '] }),
-    ).toMatchObject({ trackOrder: ['voltage', 'current'] })
-  })
-
-  it('normalizes per-track grid line visibility with visible defaults', () => {
-    expect(
-      normalizeGridOptions({
-        trackLines: {
-          voltage: { horizontal: false },
-          current: { vertical: false },
-        },
-      }).trackLines,
-    ).toEqual({
-      voltage: { horizontal: false, vertical: true },
-      current: { horizontal: true, vertical: false },
-    })
-  })
-
-  it('preserves optional per-direction grid colors and ignores blank values', () => {
-    expect(
-      normalizeGridOptions({
-        trackLines: {
-          voltage: {
-            horizontalColor: '#ef4444',
-            verticalColor: '  #2563eb  ',
-          },
-          current: { horizontalColor: '  ' },
-        },
-      }).trackLines,
-    ).toEqual({
-      voltage: {
-        horizontal: true,
-        vertical: true,
-        horizontalColor: '#ef4444',
-        verticalColor: '  #2563eb  ',
-      },
-      current: {
-        horizontal: true,
-        vertical: true,
-      },
-    })
-  })
-
-  it('falls back to visible grid lines for invalid runtime values', () => {
-    const options = {
-      trackLines: {
-        voltage: { horizontal: 'invalid', vertical: null },
-      },
-    } as unknown as Parameters<typeof normalizeGridOptions>[0]
-
-    expect(normalizeGridOptions(options).trackLines.voltage).toEqual({
-      horizontal: true,
-      vertical: true,
-    })
-  })
-
-  it('paginates row-major slots and keeps at least one page for empty data', () => {
-    const options = normalizeGridOptions({ rowCount: 2, columnCount: 2 })
-    expect(getPageCount([1, 2, 3, 4, 5].length, options)).toBe(2)
-    expect(paginateSeries([1, 2, 3, 4, 5], 2, options)).toEqual([5])
-    expect(getPageCount(0, options)).toBe(1)
-  })
-
-  it('resolves mode-specific gaps and bottom cells', () => {
-    const options = normalizeGridOptions({ rowCount: 2, columnCount: 2 })
-    const separated = resolveGridCellGeometry(400, 200, options, 'separated', [
-      true,
-      true,
-      true,
-      true,
-    ])
-    const compact = resolveGridCellGeometry(400, 200, options, 'compact', [true, true, true, true])
-    const independent = resolveGridCellGeometry(400, 200, options, 'independent', [
-      true,
-      true,
-      false,
-      false,
-    ])
-    expect(separated[1].left).toBeGreaterThan(separated[0].left + separated[0].width)
-    expect(separated[2].top).toBe(separated[0].plotHeight + 16)
-    expect(separated[2].xAxisBand).toBe(X_AXIS_BAND)
-    expect(compact[2].top).toBe(compact[0].top + compact[0].plotHeight)
-    expect(compact[2].xAxisBand).toBe(X_AXIS_BAND)
-    expect(independent[2].top).toBe(
-      independent[0].top + independent[0].plotHeight + X_AXIS_BAND + 14,
-    )
-    expect(independent[0].cellHeight).toBe(independent[0].plotHeight + X_AXIS_BAND)
-    expect(
-      getBottomRowCellIndexes(
-        separated.map((cell, index) => ({ ...cell, hasSeries: index !== 3 })),
-        2,
-      ),
-    ).toEqual(new Set([2, 1]))
-  })
-
-  it('accepts an independent horizontal gap without changing vertical spacing', () => {
-    const options = normalizeGridOptions({ rowCount: 2, columnCount: 2 })
-    const cells = resolveGridCellGeometry(
-      400,
-      200,
-      options,
-      'independent',
-      [true, true, true, true],
-      64,
-    )
-
-    expect(cells[0].width).toBe(168)
-    expect(cells[1].left).toBe(232)
-    expect(cells[2].top).toBe(cells[0].plotHeight + X_AXIS_BAND + 14)
-  })
-
-  it('fills incomplete final rows without changing page capacity', () => {
-    const oneColumn = resolveGridCellGeometry(
-      400,
-      400,
-      normalizeGridOptions({ rowCount: 4, columnCount: 1, fillIncompleteLastRow: true }),
-      'separated',
-      [true, true, true],
-    )
-    expect(oneColumn).toHaveLength(3)
-    expect(oneColumn.map((cell) => cell.width)).toEqual([400, 400, 400])
-    expect(oneColumn.at(-1)?.isLastRow).toBe(true)
-
-    const twoColumns = resolveGridCellGeometry(
-      400,
-      300,
-      normalizeGridOptions({ rowCount: 2, columnCount: 2, fillIncompleteLastRow: true }),
-      'separated',
-      [true, true, true],
-    )
-    expect(twoColumns).toHaveLength(3)
-    expect(twoColumns[2]).toMatchObject({ row: 1, column: 0, left: 0, width: 400 })
-
-    const threeColumns = resolveGridCellGeometry(
-      400,
-      300,
-      normalizeGridOptions({ rowCount: 2, columnCount: 3, fillIncompleteLastRow: true }),
-      'separated',
-      [true, true, true, true, true],
-    )
-    expect(threeColumns).toHaveLength(5)
-    expect(threeColumns.slice(3).map((cell) => cell.width)).toEqual([192, 192])
-    expect(threeColumns.slice(3).map((cell) => cell.left)).toEqual([0, 208])
-  })
-
-  it('keeps full pages and the disabled option byte-for-byte compatible', () => {
-    const base = normalizeGridOptions({ rowCount: 2, columnCount: 2 })
-    const filled = normalizeGridOptions({
-      rowCount: 2,
-      columnCount: 2,
-      fillIncompleteLastRow: true,
-    })
-    const fullSlots = [true, true, true, true]
-    expect(resolveGridCellGeometry(400, 300, filled, 'independent', fullSlots)).toEqual(
-      resolveGridCellGeometry(400, 300, base, 'independent', fullSlots),
-    )
-    expect(resolveGridCellGeometry(400, 300, base, 'independent', [true, true, true])).toHaveLength(
-      4,
-    )
-  })
-})

package/src/components/core/latestTaskScheduler.test.ts

@@ -1,51 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-
-import { createLatestTaskScheduler } from './latestTaskScheduler'
-
-function deferred() {
-  let resolve!: () => void
-  const promise = new Promise<void>((done) => {
-    resolve = done
-  })
-  return { promise, resolve }
-}
-
-describe('createLatestTaskScheduler', () => {
-  it('runs one task at a time and coalesces pending work to the latest task', async () => {
-    const scheduler = createLatestTaskScheduler()
-    const first = deferred()
-    const calls: number[] = []
-
-    scheduler.schedule(async (generation) => {
-      calls.push(generation)
-      await first.promise
-    })
-    scheduler.schedule(async (generation) => {
-      calls.push(generation)
-    })
-    const latest = scheduler.schedule(async (generation) => {
-      calls.push(generation)
-    })
-
-    expect(calls).toEqual([1])
-    expect(scheduler.isCurrent(1)).toBe(false)
-    expect(scheduler.isCurrent(latest)).toBe(true)
-    first.resolve()
-    await vi.waitFor(() => expect(calls).toEqual([1, 3]))
-    expect(scheduler.metrics).toEqual({ scheduled: 3, coalesced: 1, maxPending: 1 })
-  })
-
-  it('invalidates running work and discards pending work on cancellation or disposal', async () => {
-    const scheduler = createLatestTaskScheduler()
-    const first = deferred()
-    const firstGeneration = scheduler.schedule(async () => first.promise)
-    scheduler.schedule(async () => undefined)
-
-    scheduler.cancelPending()
-    expect(scheduler.isCurrent(firstGeneration)).toBe(false)
-    first.resolve()
-    await first.promise
-    scheduler.dispose()
-    expect(scheduler.schedule(async () => undefined)).toBe(0)
-  })
-})