waveform-analysis 0.1.47 → 0.1.50

package/src/components/annotation/markup.ts

@@ -1,6 +1,9 @@
-import { bisector } from 'd3'
-
 import type { WaveformAnnotation, WaveformAnnotationStyle, WaveformLineType } from '../../types'
+import {
+  isWaveformPointSource,
+  pointSourceFromPoints,
+  type WaveformPointSource,
+} from '../../core/waveformPointSource'
 import type { AnnotationHit, AnnotationSeriesCandidate, AnnotationTrackLayout } from './types'
 
 export const DEFAULT_ANNOTATION_STYLE = {
@@ -23,16 +26,26 @@ export const ANNOTATION_TEXT_GLYPH_HEIGHT = 14
 export const ANNOTATION_TEXT_FONT = '12px Arial, sans-serif'
 export const ANNOTATION_CONNECTOR_LENGTH = 32
 
-const pointBisector = bisector((point: { x: number }) => point.x)
+type PointCollection = Array<{ x: number; y: number }> | WaveformPointSource
+
+function sourceFor(points: PointCollection) {
+  return isWaveformPointSource(points) ? points : pointSourceFromPoints(points)
+}
 
 function findNearestPointOnScreen(
   track: AnnotationTrackLayout,
   pointerX: number,
   pointerY: number,
 ): { point: { x: number; y: number }; screenX: number; screenY: number; distance: number } | null {
-  let nearest: { point: { x: number; y: number }; screenX: number; screenY: number; distance: number } | null =
-    null
-  for (const point of track.series.points) {
+  let nearest: {
+    point: { x: number; y: number }
+    screenX: number
+    screenY: number
+    distance: number
+  } | null = null
+  const source = track.series.source ?? pointSourceFromPoints(track.series.points)
+  for (let index = 0; index < source.length; index += 1) {
+    const point = source.pointAt(index)!
     if (!Number.isFinite(point.x) || !Number.isFinite(point.y)) continue
     const screenX = track.xScale(point.x)
     const screenY = track.top + track.yScale(point.y)
@@ -45,33 +58,35 @@ function findNearestPointOnScreen(
 }
 
 export function findNearestPointByX(
-  points: Array<{ x: number; y: number }>,
+  points: PointCollection,
   xValue: number,
 ): { x: number; y: number } | null {
-  if (!points.length || !Number.isFinite(xValue)) return null
-  const centerIndex = pointBisector.center(points, xValue)
-  const center = points[Math.min(centerIndex, points.length - 1)]
-  const left = points[Math.max(0, centerIndex - 1)]
-  return Math.abs(xValue - left.x) < Math.abs(center.x - xValue) ? left : center
+  const source = sourceFor(points)
+  if (!source.length || !Number.isFinite(xValue)) return null
+  const rightIndex = source.visibleRange([xValue, xValue]).start
+  const right = source.pointAt(Math.min(rightIndex, source.length - 1))!
+  const left = source.pointAt(Math.max(0, rightIndex - 1))!
+  return Math.abs(xValue - left.x) < Math.abs(right.x - xValue) ? left : right
 }
 
 export function interpolateAnnotationPoint(
-  points: Array<{ x: number; y: number }>,
+  points: PointCollection,
   xValue: number,
   lineType: WaveformLineType = 'linear',
 ): { x: number; y: number } | null {
-  if (!points.length || !Number.isFinite(xValue)) return null
-  const first = points[0]
-  const last = points[points.length - 1]
+  const source = sourceFor(points)
+  if (!source.length || !Number.isFinite(xValue)) return null
+  const first = source.pointAt(0)!
+  const last = source.pointAt(source.length - 1)!
   if (xValue < first.x || xValue > last.x) return null
-  if (points.length === 1) return xValue === first.x ? { ...first } : null
+  if (source.length === 1) return xValue === first.x ? { ...first } : null
 
-  const rightIndex = pointBisector.left(points, xValue)
-  const right = points[Math.min(rightIndex, points.length - 1)]
+  const rightIndex = source.visibleRange([xValue, xValue]).start
+  const right = source.pointAt(Math.min(rightIndex, source.length - 1))!
   if (right.x === xValue || rightIndex === 0) return { x: xValue, y: right.y }
   if (lineType === 'none') return null
 
-  const left = points[rightIndex - 1]
+  const left = source.pointAt(rightIndex - 1)!
   if (lineType === 'step-start') return { x: xValue, y: right.y }
   if (lineType === 'step-middle') {
     return { x: xValue, y: xValue < (left.x + right.x) / 2 ? left.y : right.y }
@@ -108,7 +123,7 @@ export function findAnnotationSeriesCandidates(
         ]
       }
       const interpolatedPoint = interpolateAnnotationPoint(
-        track.series.points,
+        track.series.source ?? pointSourceFromPoints(track.series.points),
         xValue,
         track.series.lineType,
       )
@@ -116,7 +131,10 @@ export function findAnnotationSeriesCandidates(
 
       // Always snap to nearest actual sample point for the anchor
       // This ensures annotations align with visible data points
-      const nearestPoint = findNearestPointByX(track.series.points, xValue)
+      const nearestPoint = findNearestPointByX(
+        track.series.source ?? pointSourceFromPoints(track.series.points),
+        xValue,
+      )
       if (!nearestPoint) return []
 
       // Use interpolated point for distance calculation to get accurate series selection
@@ -213,15 +231,16 @@ export function findNearestAnnotationPoint(
 
   tracks.forEach((track) => {
     const localY = pointerY - track.top
-    if (localY < 0 || localY > track.height || track.series.points.length === 0) return
+    const source = track.series.source ?? pointSourceFromPoints(track.series.points)
+    if (localY < 0 || localY > track.height || source.length === 0) return
 
     const xValue = track.xScale.invert(pointerX)
-    const centerIndex = pointBisector.center(track.series.points, xValue)
+    const centerIndex = source.visibleRange([xValue, xValue]).start
     const firstIndex = Math.max(0, centerIndex - 2)
-    const lastIndex = Math.min(track.series.points.length - 1, centerIndex + 2)
+    const lastIndex = Math.min(source.length - 1, centerIndex + 2)
 
     for (let candidateIndex = firstIndex; candidateIndex <= lastIndex; candidateIndex += 1) {
-      const point = track.series.points[candidateIndex]
+      const point = source.pointAt(candidateIndex)!
       const screenX = track.xScale(point.x)
       const screenY = track.yScale(point.y) + track.top
       const distance = Math.hypot(screenX - pointerX, screenY - pointerY)

package/src/components/annotation/types.ts

@@ -1,6 +1,7 @@
 import type { ScaleLinear } from 'd3'
 
 import type { WaveformAnnotation, WaveformLineType, WaveformPoint } from '../../types'
+import type { WaveformPointSource } from '../../core/waveformPointSource'
 
 export interface AnnotationTrackLayout {
   index: number
@@ -11,6 +12,7 @@ export interface AnnotationTrackLayout {
     unit?: string
     lineType?: WaveformLineType
     points: WaveformPoint[]
+    source?: WaveformPointSource
   }
   left?: number
   top: number

package/src/components/annotation/useWaveformChartAnnotations.ts

@@ -9,7 +9,6 @@ import {
   ANNOTATION_AMBIGUITY_DISTANCE,
   ANNOTATION_HIT_RADIUS,
   findAnnotationSeriesCandidates,
-  findNearestPointByX,
 } from './markup'
 import type {
   AnnotationEditorAnchor,
@@ -150,15 +149,15 @@ export function useWaveformChartAnnotations(context: AnnotationContext) {
       item.seriesList.some((series) => series.id === seriesId),
     )
     const series = track?.seriesList.find((item) => item.id === seriesId)
-    const validPoints = series?.points.filter(
-      (item) => Number.isFinite(item.x) && Number.isFinite(item.y),
-    )
-    const point = validPoints && draft ? findNearestPointByX(validPoints, draft.annotation.x) : null
-    if (!draft || !candidate || !track || !validPoints?.length) {
+    const source = series?.source
+    const first = source?.pointAt(0)
+    const last = source?.pointAt((source?.length ?? 0) - 1)
+    const point = draft ? source?.nearestPoint(draft.annotation.x) : undefined
+    if (!draft || !candidate || !track || !first || !last || !point) {
       timeError.value = '当前波形没有有效数据'
       return
     }
-    if (draft.annotation.x < validPoints[0].x || draft.annotation.x > validPoints.at(-1)!.x) {
+    if (draft.annotation.x < first.x || draft.annotation.x > last.x) {
       timeError.value = '时间超出当前波形范围'
       return
     }
@@ -183,20 +182,18 @@ export function useWaveformChartAnnotations(context: AnnotationContext) {
       item.seriesList.some((series) => series.id === draft.annotation.seriesId),
     )
     const series = track?.seriesList.find((item) => item.id === draft.annotation.seriesId)
-    const validPoints = series?.points.filter(
-      (point) => Number.isFinite(point.x) && Number.isFinite(point.y),
-    )
-    if (!validPoints?.length) {
+    const source = series?.source
+    const first = source?.pointAt(0)
+    const last = source?.pointAt((source?.length ?? 0) - 1)
+    if (!source || !first || !last) {
       timeError.value = '当前波形没有有效数据'
       return
     }
-    const firstX = validPoints[0].x
-    const lastX = validPoints[validPoints.length - 1].x
-    if (rawTime < firstX || rawTime > lastX) {
+    if (rawTime < first.x || rawTime > last.x) {
       timeError.value = '时间超出当前波形范围'
       return
     }
-    const point = findNearestPointByX(validPoints, rawTime)!
+    const point = source.nearestPoint(rawTime)!
     timeError.value = ''
     draft.annotation = { ...draft.annotation, x: point.x, y: point.y }
   }

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

@@ -0,0 +1,51 @@
+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)
+  })
+})

package/src/components/core/latestTaskScheduler.ts

@@ -0,0 +1,75 @@
+export interface LatestTaskSchedulerMetrics {
+  scheduled: number
+  coalesced: number
+  maxPending: number
+}
+
+export function resolveAutoSelectedMode(
+  visiblePointCount: number,
+  threshold: number,
+  hysteresis: number,
+  previousSelectedMode?: 'raw' | 'sampled',
+): 'raw' | 'sampled' {
+  if (!previousSelectedMode) return visiblePointCount <= threshold ? 'raw' : 'sampled'
+  return previousSelectedMode === 'raw'
+    ? visiblePointCount <= threshold + hysteresis
+      ? 'raw'
+      : 'sampled'
+    : visiblePointCount <= Math.max(0, threshold - hysteresis)
+      ? 'raw'
+      : 'sampled'
+}
+
+interface ScheduledTask {
+  generation: number
+  run: (generation: number) => Promise<void>
+}
+
+/** Runs at most one task at a time and retains only the newest pending task. */
+export function createLatestTaskScheduler() {
+  let generation = 0
+  let running = false
+  let pending: ScheduledTask | undefined
+  let disposed = false
+  const metrics: LatestTaskSchedulerMetrics = { scheduled: 0, coalesced: 0, maxPending: 0 }
+
+  const drain = async () => {
+    if (running || disposed) return
+    running = true
+    try {
+      while (pending && !disposed) {
+        const task = pending
+        pending = undefined
+        await task.run(task.generation)
+      }
+    } finally {
+      running = false
+    }
+  }
+
+  return {
+    schedule(run: ScheduledTask['run']) {
+      if (disposed) return 0
+      generation += 1
+      metrics.scheduled += 1
+      if (pending) metrics.coalesced += 1
+      pending = { generation, run }
+      metrics.maxPending = Math.max(metrics.maxPending, 1)
+      void drain()
+      return generation
+    },
+    isCurrent(candidate: number) {
+      return !disposed && candidate === generation
+    },
+    cancelPending() {
+      generation += 1
+      pending = undefined
+    },
+    dispose() {
+      disposed = true
+      generation += 1
+      pending = undefined
+    },
+    metrics,
+  }
+}

package/src/components/core/layout.ts

@@ -133,9 +133,13 @@ export function axisTextMetrics(
   }
 }
 
-export function measureYAxisGroupClearance(group: YAxisSeriesGroup, tickCount?: number): number {
+export function measureYAxisGroupClearance(
+  group: YAxisSeriesGroup,
+  tickCount?: number,
+  nice = true,
+): number {
   return (
-    axisTextMetrics(group.domain, true, undefined, group.seriesList[0]?.unit, tickCount)
+    axisTextMetrics(group.domain, nice, undefined, group.seriesList[0]?.unit, tickCount)
       .tickTextWidth +
     Y_AXIS_TICK_PADDING +
     Y_AXIS_LABEL_GAP +
@@ -144,9 +148,13 @@ export function measureYAxisGroupClearance(group: YAxisSeriesGroup, tickCount?:
   )
 }
 
-function measureYAxisGroupTickClearance(group: YAxisSeriesGroup, tickCount?: number): number {
+function measureYAxisGroupTickClearance(
+  group: YAxisSeriesGroup,
+  tickCount?: number,
+  nice = true,
+): number {
   return (
-    axisTextMetrics(group.domain, true, undefined, group.seriesList[0]?.unit, tickCount)
+    axisTextMetrics(group.domain, nice, undefined, group.seriesList[0]?.unit, tickCount)
       .tickTextWidth +
     Y_AXIS_TICK_PADDING +
     Y_AXIS_OUTER_PADDING
@@ -159,13 +167,14 @@ export function measureTrackYAxisClearance(
   yDomain?: WaveformYDomain,
   yDomains?: Record<string, WaveformYDomain>,
   tickCount?: number,
+  nice = true,
 ): { left: number; right: number } {
   return resolveYAxisSeriesGroups(track, overlayMode, yDomain, yDomains).reduce(
     (clearance, group) => {
       clearance[group.side] +=
         overlayMode === 'multi-axis' || track.visibleSeries.length === 1
-          ? measureYAxisGroupClearance(group, tickCount)
-          : measureYAxisGroupTickClearance(group, tickCount)
+          ? measureYAxisGroupClearance(group, tickCount, nice)
+          : measureYAxisGroupTickClearance(group, tickCount, nice)
       return clearance
     },
     { left: 0, right: 0 },

package/src/components/core/trackLayoutBuilder.ts

@@ -55,7 +55,10 @@ export interface BuildTrackLayoutsOptions {
   timeUnit: 's' | 'ms'
   xAxisLabelFormatter?: WaveformXAxisLabelFormatter
   yAxisSplitNumber?: number
+  yAxisNice?: boolean
   rendering: ResolvedWaveformRenderingOptions
+  /** Latest sampling result for SVG lines only; source series remain complete for interaction. */
+  linePointOverrides?: Readonly<Record<string, WaveformPoint[]>>
   hideSecondaryLabels: boolean
   yAxisLabelX: number
   showCompactEmptyTracks: boolean
@@ -119,7 +122,7 @@ export function buildTrackLayouts(options: BuildTrackLayoutsOptions): TrackLayou
       const tickCount = resolveYAxisTickCount(cell.plotHeight, options.yAxisSplitNumber)
       const niceCount = Math.max(1, tickCount - 1)
       const scale = scaleLinear(group.domain, [cell.plotHeight, 0])
-      scale.nice(niceCount)
+      if (options.yAxisNice !== false) scale.nice(niceCount)
       const [axisStart, axisEnd] = scale.domain()
       const majorTicks = Array.from(
         { length: tickCount },
@@ -158,7 +161,9 @@ export function buildTrackLayouts(options: BuildTrackLayoutsOptions): TrackLayou
         seriesList: group.seriesList,
       }
     })
-    const yScale = yAxes[0]?.scale ?? scaleLinear(displayTrack.yDomain, [cell.plotHeight, 0]).nice()
+    const fallbackYScale = scaleLinear(displayTrack.yDomain, [cell.plotHeight, 0])
+    if (options.yAxisNice !== false) fallbackYScale.nice()
+    const yScale = yAxes[0]?.scale ?? fallbackYScale
     const xMajorTicks = xScale.ticks(Math.max(2, Math.floor(cell.width / 100)))
     const yMajorTicks = yAxes[0]?.majorTicks ?? []
     const yAxisTickValues = yAxes[0]?.tickValues ?? []
@@ -197,6 +202,7 @@ export function buildTrackLayouts(options: BuildTrackLayoutsOptions): TrackLayou
         options.rendering,
         {
           lineVisible: !isEmpty && trackSeries.lineType !== 'none',
+          linePointOverride: options.linePointOverrides?.[trackSeries.id],
           pointVisible: trackSeries.pointType !== 'none',
           errorBarVisible: trackSeries.errorBar.visible,
           hasErrorPoints: trackSeries.hasErrorPoints,

package/src/components/core/types.ts

@@ -6,6 +6,7 @@ import type {
   WaveformPoint,
   WaveformPointType,
 } from '../../types'
+import type { WaveformPointSource } from '../../core/waveformPointSource'
 import type { NormalizedWaveformGridLineOptions } from './grid'
 
 /**
@@ -23,6 +24,7 @@ export interface DisplaySeries {
   pointType: WaveformPointType
   errorBar: ResolvedWaveformErrorBarOptions
   points: WaveformPoint[]
+  source?: WaveformPointSource
   xDomain: [number, number]
   yDomain: [number, number]
   hasErrorPoints: boolean

package/src/components/core/useWaveformChartController.ts

@@ -26,6 +26,7 @@ import { useWaveformChartLifecycle } from './useWaveformChartLifecycle'
 import { usePreparedWaveformSeries } from './useWaveformData'
 import { useWaveformLayout } from './useWaveformLayout'
 import { useWaveformPresentation } from './useWaveformPresentation'
+import { useWaveformRenderSampling } from './useWaveformRenderSampling'
 import type {
   ResolvedWaveformChartProps,
   ViewportSelectionState,
@@ -68,6 +69,7 @@ export function useWaveformChartController(
   const clipPathId = useWaveformInstanceId('waveform-clip')
   const internalHiddenSeriesIds = ref(new Set(props.defaultHiddenSeriesIds))
   const annotationInteraction = useWaveformAnnotationInteraction()
+  const linePointOverrides = shallowRef<Record<string, import('../../types').WaveformPoint[]>>({})
   const editorSeriesOptions = ref<AnnotationSeriesCandidate[]>([])
   const hoverThrottle = useAnimationFrameThrottle()
 
@@ -126,10 +128,12 @@ export function useWaveformChartController(
     sharedYDomains,
     independentYDomains,
     annotationInteraction: markRaw(annotationInteraction),
+    linePointOverrides,
   })
   const {
     chartSeries,
     chartTracks,
+    renderingOptions,
     trackLayouts,
     gridOptions,
     pageCount,
@@ -146,6 +150,16 @@ export function useWaveformChartController(
     resolveSeriesYScale,
   } = layout
 
+  useWaveformRenderSampling({
+    props,
+    emit,
+    instanceId: clipPathId,
+    preparedSeries,
+    sourceTrackLayouts: trackLayouts,
+    renderingOptions,
+    linePointOverrides,
+  })
+
   watchEffect(() => {
     paginationBandHeight.value =
       gridOptions.value.showPagination && pageCount.value > 1 && chartWidth.value <= 520 ? 40 : 0

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

@@ -0,0 +1,95 @@
+import { describe, expect, it } from 'vitest'
+
+import { prepareWaveformSeries } from './useWaveformData'
+
+describe('prepareWaveformSeries compact inputs', () => {
+  it('keeps dense typed samples as numeric columns until individual points are requested', () => {
+    const values = Float32Array.from({ length: 100_001 }, (_, index) => index / 10)
+    const snapshot = values.slice()
+    const [series] = prepareWaveformSeries({
+      kind: 'typed-samples',
+      values,
+      sampleRate: 1_000,
+      startTime: 2,
+    })
+
+    expect(series?.source.isCompact).toBe(true)
+    expect(series?.points).toHaveLength(values.length)
+    expect(series?.xDomain[0]).toBeLessThanOrEqual(2)
+    expect(series?.xDomain[1]).toBeGreaterThanOrEqual(102)
+    expect(series?.source.pointAt(50_000)).toEqual({ x: 52, y: 5_000 })
+    expect(values).toEqual(snapshot)
+
+    const workerDataset = series?.source.toWorkerDataset()
+    expect(workerDataset).toMatchObject({
+      kind: 'samples',
+      sampleRate: 1_000,
+      startTime: 2,
+    })
+    if (workerDataset?.kind === 'samples') {
+      expect(workerDataset).not.toHaveProperty('sourceIndexes')
+      expect(workerDataset.values.buffer).not.toBe(values.buffer)
+      expect(workerDataset.values).toEqual(values)
+    }
+  })
+
+  it('preserves invalid-sample time gaps without allocating an X column', () => {
+    const [series] = prepareWaveformSeries({
+      kind: 'typed-samples',
+      values: new Float64Array([1, Number.NaN, 3]),
+      sampleRate: 2,
+      startTime: 10,
+    })
+
+    expect(series?.source.pointsInRange()).toEqual([
+      { x: 10, y: 1 },
+      { x: 11, y: 3 },
+    ])
+    expect(series?.source.toWorkerDataset()).toMatchObject({
+      kind: 'samples',
+      values: new Float64Array([1, 3]),
+      sourceIndexes: new Uint32Array([0, 2]),
+    })
+  })
+
+  it('filters and stably orders compact typed points without materializing source point objects', () => {
+    const [series] = prepareWaveformSeries({
+      kind: 'typed-points',
+      x: new Float64Array([2, 1, 1, Number.NaN]),
+      y: new Float32Array([20, 10, 11, 12]),
+      error: new Float32Array([1, -1, Number.NaN, 4]),
+    })
+
+    expect(series?.source.isCompact).toBe(true)
+    expect(series?.source.pointsInRange()).toEqual([
+      { x: 1, y: 10 },
+      { x: 1, y: 11 },
+      { x: 2, y: 20, error: 1 },
+    ])
+    expect(series?.source.visibleRange([1, 1])).toEqual({ start: 0, end: 2 })
+    expect(series?.source.nearestPoint(-10)).toEqual({ x: 1, y: 10 })
+    expect(series?.source.nearestPoint(10)).toEqual({ x: 2, y: 20, error: 1 })
+  })
+
+  it('retains normal array access, iteration, slicing, mapping, and enumeration semantics', () => {
+    const [series] = prepareWaveformSeries({
+      kind: 'typed-samples',
+      values: new Float32Array([2, 4, 6]),
+      sampleRate: 2,
+    })
+
+    expect(series?.points[1]).toEqual({ x: 0.5, y: 4 })
+    expect(series?.points.at(-1)).toEqual({ x: 1, y: 6 })
+    expect([...(series?.points ?? [])]).toEqual([
+      { x: 0, y: 2 },
+      { x: 0.5, y: 4 },
+      { x: 1, y: 6 },
+    ])
+    expect(series?.points.slice(1)).toEqual([
+      { x: 0.5, y: 4 },
+      { x: 1, y: 6 },
+    ])
+    expect(series?.points.map((point) => point.y)).toEqual([2, 4, 6])
+    expect(Object.keys(series?.points ?? [])).toEqual(['0', '1', '2'])
+  })
+})

package/src/components/core/useWaveformData.ts

@@ -1,6 +1,7 @@
 import { shallowRef, watch } from 'vue'
 
-import { normalizeWaveformSeries, resolveWaveformPointErrors } from '../../core'
+import { normalizeWaveformSeriesSources } from '../../core/data'
+import { lazyPointArray, type WaveformPointSource } from '../../core/waveformPointSource'
 import type {
   ResolvedWaveformErrorBarOptions,
   WaveformData,
@@ -22,43 +23,33 @@ export interface PreparedWaveformSeries {
   pointType: WaveformPointType
   errorBar: ResolvedWaveformErrorBarOptions
   points: WaveformPoint[]
+  source: WaveformPointSource
   xDomain: [number, number]
   yDomain: [number, number]
   hasErrorPoints: boolean
 }
 
-function pointMetrics(
-  points: WaveformPoint[],
-  includeErrors = false,
-): { xDomain: [number, number]; yDomain: [number, number]; hasErrorPoints: boolean } {
-  let xMinimum = Number.POSITIVE_INFINITY
-  let xMaximum = Number.NEGATIVE_INFINITY
-  let yMinimum = Number.POSITIVE_INFINITY
-  let yMaximum = Number.NEGATIVE_INFINITY
-  let hasErrorPoints = false
-  for (const point of points) {
-    if (point.x < xMinimum) xMinimum = point.x
-    if (point.x > xMaximum) xMaximum = point.x
-    if (point.y < yMinimum) yMinimum = point.y
-    if (point.y > yMaximum) yMaximum = point.y
-    if (includeErrors) {
-      const errors = resolveWaveformPointErrors(point)
-      if (errors.lower !== 0 || errors.upper !== 0) hasErrorPoints = true
-      yMinimum = Math.min(yMinimum, point.y - errors.lower)
-      yMaximum = Math.max(yMaximum, point.y + errors.upper)
-    }
-  }
-  return {
-    xDomain: paddedDomain(Number.isFinite(xMinimum) ? [xMinimum, xMaximum] : []),
-    yDomain: paddedDomain(Number.isFinite(yMinimum) ? [yMinimum, yMaximum] : []),
-    hasErrorPoints,
-  }
-}
-
 export function prepareWaveformSeries(data: WaveformData): PreparedWaveformSeries[] {
-  return normalizeWaveformSeries(data).map((series) => {
-    const metrics = pointMetrics(series.points, series.errorBar.visible)
-    return { ...series, ...metrics }
+  return normalizeWaveformSeriesSources(data).map(({ source, ...series }) => {
+    const sourceMetrics = source.metrics(series.errorBar.visible)
+    return {
+      ...series,
+      source,
+      // Existing chart code remains array-oriented; compact sources materialize individual points
+      // only when an index is read.
+      points: lazyPointArray(source),
+      xDomain: paddedDomain(
+        Number.isFinite(sourceMetrics.xMinimum)
+          ? [sourceMetrics.xMinimum, sourceMetrics.xMaximum]
+          : [],
+      ),
+      yDomain: paddedDomain(
+        Number.isFinite(sourceMetrics.yMinimum)
+          ? [sourceMetrics.yMinimum, sourceMetrics.yMaximum]
+          : [],
+      ),
+      hasErrorPoints: sourceMetrics.hasErrorPoints,
+    }
   })
 }