waveform-analysis 0.1.47 → 0.1.50

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 },
+    ])
+  })
 })

package/src/core/data.ts

@@ -4,8 +4,10 @@ import type {
   WaveformPoint,
   WaveformLineStyle,
   NormalizedWaveformSeries,
+  WaveformTypedValues,
 } from '../types'
 import { ERROR_BAR_DEFAULTS } from '../components/core/constants'
+import { createWaveformPointSource, type WaveformPointSource } from './waveformPointSource'
 
 const DEFAULT_ERROR_BAR_WIDTH = ERROR_BAR_DEFAULTS.WIDTH
 const DEFAULT_ERROR_BAR_CAP_WIDTH = ERROR_BAR_DEFAULTS.CAP_WIDTH
@@ -31,6 +33,95 @@ function normalizeWaveformPoint(point: WaveformPoint): WaveformPoint {
   }
 }
 
+function isWaveformTypedValues(value: unknown): value is WaveformTypedValues {
+  return value instanceof Float32Array || value instanceof Float64Array
+}
+
+function normalizeSampleValues(
+  values: ArrayLike<number>,
+  sampleRate: number,
+  startTime: number | undefined,
+): WaveformPoint[] {
+  if (!Number.isFinite(sampleRate) || sampleRate <= 0) return []
+
+  const normalizedStartTime = Number.isFinite(startTime) ? (startTime ?? 0) : 0
+  const points: WaveformPoint[] = []
+  for (let index = 0; index < values.length; index += 1) {
+    const value = values[index]
+    if (!Number.isFinite(value)) continue
+    points.push({ x: normalizedStartTime + index / sampleRate, y: value })
+  }
+  return points
+}
+
+function normalizeTypedSamples(data: {
+  values: unknown
+  sampleRate: number
+  startTime?: number
+}): WaveformPoint[] {
+  if (
+    !isWaveformTypedValues(data.values) ||
+    !Number.isFinite(data.sampleRate) ||
+    data.sampleRate <= 0 ||
+    (data.startTime !== undefined && !Number.isFinite(data.startTime))
+  ) {
+    return []
+  }
+  return normalizeSampleValues(data.values, data.sampleRate, data.startTime)
+}
+
+function typedPointValuesHaveMatchingLengths(data: {
+  x: unknown
+  y: unknown
+  error?: unknown
+  lowerError?: unknown
+  upperError?: unknown
+}): data is {
+  x: Float64Array
+  y: WaveformTypedValues
+  error?: WaveformTypedValues
+  lowerError?: WaveformTypedValues
+  upperError?: WaveformTypedValues
+} {
+  if (!(data.x instanceof Float64Array) || !isWaveformTypedValues(data.y)) return false
+  const length = data.x.length
+  const values = [data.error, data.lowerError, data.upperError]
+  return (
+    values.every(
+      (value) => value === undefined || (isWaveformTypedValues(value) && value.length === length),
+    ) && data.y.length === length
+  )
+}
+
+function normalizeTypedPoints(data: {
+  x: Float64Array
+  y: WaveformTypedValues
+  error?: WaveformTypedValues
+  lowerError?: WaveformTypedValues
+  upperError?: WaveformTypedValues
+}): WaveformPoint[] {
+  const points: WaveformPoint[] = []
+  let previousX = Number.NEGATIVE_INFINITY
+  let sorted = true
+  for (let index = 0; index < data.x.length; index += 1) {
+    const x = data.x[index]
+    const y = data.y[index]
+    if (!Number.isFinite(x) || !Number.isFinite(y)) continue
+    const normalized = normalizeWaveformPoint({
+      x,
+      y,
+      error: data.error?.[index],
+      lowerError: data.lowerError?.[index],
+      upperError: data.upperError?.[index],
+    })
+    if (normalized.x < previousX) sorted = false
+    previousX = normalized.x
+    points.push(normalized)
+  }
+  if (!sorted) points.sort((left, right) => left.x - right.x)
+  return points
+}
+
 export function resolveWaveformPointErrors(point: WaveformPoint): {
   lower: number
   upper: number
@@ -44,24 +135,21 @@ export function resolveWaveformPointErrors(point: WaveformPoint): {
 
 /**
  * 规范化单波形数据
- * @param data 输入数据（samples 或 points 格式）
+ * @param data 输入数据（对象数组或 TypedArray 格式）
  * @returns 规范化后的点数组
  */
 export function normalizeWaveformData(data: SingleWaveformData): WaveformPoint[] {
   if (data.kind === 'samples') {
-    if (!Number.isFinite(data.sampleRate) || data.sampleRate <= 0) return []
-
-    const startTime = Number.isFinite(data.startTime) ? (data.startTime ?? 0) : 0
-    const points: WaveformPoint[] = []
-    for (let index = 0; index < data.values.length; index += 1) {
-      const value = data.values[index]
-      if (!Number.isFinite(value)) continue
-      points.push({ x: startTime + index / data.sampleRate, y: value })
-    }
+    return normalizeSampleValues(data.values, data.sampleRate, data.startTime)
+  }
 
-    return points
+  if (data.kind === 'typed-samples') {
+    return normalizeTypedSamples(data)
   }
 
+  if (data.kind === 'typed-points')
+    return typedPointValuesHaveMatchingLengths(data) ? normalizeTypedPoints(data) : []
+
   const points: WaveformPoint[] = []
   let previousX = Number.NEGATIVE_INFINITY
   let sorted = true
@@ -77,78 +165,92 @@ export function normalizeWaveformData(data: SingleWaveformData): WaveformPoint[]
   return points
 }
 
-/**
- * 规范化波形系列数据
- * @param data 输入数据（单波形或多通道）
- * @returns 规范化后的系列数组
- */
-export function normalizeWaveformSeries(data: WaveformData): NormalizedWaveformSeries[] {
+export interface NormalizedWaveformSourceSeries extends Omit<NormalizedWaveformSeries, 'points'> {
+  source: WaveformPointSource
+}
+
+function normalizedSeriesOptions(
+  id: string,
+  series: {
+    shotNo?: string
+    trackId?: string
+    name: string
+    unit?: string
+    color?: string
+    lineType?: NormalizedWaveformSeries['lineType']
+    lineStyle?: WaveformLineStyle
+    pointType?: NormalizedWaveformSeries['pointType']
+    errorBar?: { visible?: boolean; color?: string; width?: number; capWidth?: number }
+  },
+) {
+  const requestedLineType = series.lineType ?? 'linear'
+  const lineStyle = normalizeLineStyle(series.lineStyle)
+  const requestedPointType = series.pointType ?? 'none'
+  const errorBarVisible = series.errorBar?.visible === true
+  const lineType =
+    requestedLineType === 'none' && requestedPointType === 'none' && !errorBarVisible
+      ? 'linear'
+      : requestedLineType
+  const width = Number(series.errorBar?.width)
+  const capWidth = Number(series.errorBar?.capWidth)
+  return {
+    id,
+    shotNo: series.shotNo?.trim() || undefined,
+    trackId: series.trackId?.trim() || undefined,
+    name: series.name,
+    unit: series.unit,
+    color: series.color,
+    lineType,
+    lineStyle,
+    pointType: requestedPointType,
+    errorBar: {
+      visible: errorBarVisible,
+      color: series.errorBar?.color,
+      width: Number.isFinite(width) && width > 0 ? width : DEFAULT_ERROR_BAR_WIDTH,
+      capWidth: Number.isFinite(capWidth) && capWidth > 0 ? capWidth : DEFAULT_ERROR_BAR_CAP_WIDTH,
+    },
+  }
+}
+
+/** Internal normalized series which preserves compact TypedArray storage for chart rendering. */
+export function normalizeWaveformSeriesSources(
+  data: WaveformData,
+): NormalizedWaveformSourceSeries[] {
   if (data.kind !== 'series') {
-    const points = normalizeWaveformData(data)
-    return points.length > 0
+    const source = createWaveformPointSource(data, normalizeWaveformData)
+    return source.length
       ? [
           {
-            id: 'series-0',
-            name: '',
-            lineType: 'linear',
-            lineStyle: 'solid',
-            pointType: 'none',
-            errorBar: {
-              visible: false,
-              width: DEFAULT_ERROR_BAR_WIDTH,
-              capWidth: DEFAULT_ERROR_BAR_CAP_WIDTH,
-            },
-            points,
+            ...normalizedSeriesOptions('series-0', { name: '' }),
+            source,
           },
         ]
       : []
   }
 
   const usedIds = new Set<string>()
+  return data.series.flatMap((series, index) => {
+    const id = series.id?.trim() || `series-${index}`
+    let uniqueId = id
+    let suffix = 1
+    while (usedIds.has(uniqueId)) {
+      uniqueId = `${id}-${suffix}`
+      suffix += 1
+    }
+    usedIds.add(uniqueId)
+    const source = createWaveformPointSource(series.data, normalizeWaveformData)
+    return source.length ? [{ ...normalizedSeriesOptions(uniqueId, series), source }] : []
+  })
+}
 
-  return data.series
-    .map((series, index) => {
-      const id = series.id?.trim() || `series-${index}`
-
-      // 确保 ID 唯一，如果重复则添加后缀
-      let uniqueId = id
-      let suffix = 1
-      while (usedIds.has(uniqueId)) {
-        uniqueId = `${id}-${suffix}`
-        suffix++
-      }
-      usedIds.add(uniqueId)
-
-      const requestedLineType = series.lineType ?? 'linear'
-      const lineStyle = normalizeLineStyle((series as { lineStyle?: unknown }).lineStyle)
-      const requestedPointType = series.pointType ?? 'none'
-      const errorBarVisible = series.errorBar?.visible === true
-      const lineType =
-        requestedLineType === 'none' && requestedPointType === 'none' && !errorBarVisible
-          ? 'linear'
-          : requestedLineType
-      const width = Number(series.errorBar?.width)
-      const capWidth = Number(series.errorBar?.capWidth)
-
-      return {
-        id: uniqueId,
-        shotNo: series.shotNo?.trim() || undefined,
-        trackId: series.trackId?.trim() || undefined,
-        name: series.name,
-        unit: series.unit,
-        color: series.color,
-        lineType,
-        lineStyle,
-        pointType: requestedPointType,
-        errorBar: {
-          visible: errorBarVisible,
-          color: series.errorBar?.color,
-          width: Number.isFinite(width) && width > 0 ? width : DEFAULT_ERROR_BAR_WIDTH,
-          capWidth:
-            Number.isFinite(capWidth) && capWidth > 0 ? capWidth : DEFAULT_ERROR_BAR_CAP_WIDTH,
-        },
-        points: normalizeWaveformData(series.data),
-      }
-    })
-    .filter((series) => series.points.length > 0)
+/**
+ * 规范化波形系列数据
+ * @param data 输入数据（单波形或多通道）
+ * @returns 规范化后的系列数组
+ */
+export function normalizeWaveformSeries(data: WaveformData): NormalizedWaveformSeries[] {
+  return normalizeWaveformSeriesSources(data).map(({ source, ...series }) => ({
+    ...series,
+    points: source.pointsInRange(),
+  }))
 }

package/src/core/index.ts

@@ -10,4 +10,15 @@ export {
   selectDecorationPoints,
   selectRenderablePoints,
   type ResolvedWaveformRenderingOptions,
+  type ResolvedWaveformSamplingOptions,
 } from './rendering'
+export {
+  calculateWasmRange,
+  findWasmVisibleRange,
+  initializeWasmSampling,
+  sampleWaveformWasm,
+  type WasmRangeMetrics,
+  type WasmSamplingRequest,
+  type WasmSamplingResult,
+  type WasmSamplingStrategy,
+} from './wasmSampling'

package/src/core/rendering.test.ts

@@ -1,7 +1,8 @@
 import { describe, expect, it } from 'vitest'
 
-import type { WaveformPoint } from '../types'
+import type { WaveformPoint, WaveformRenderingOptions } from '../types'
 import {
+  DEFAULT_WAVEFORM_RENDERING_OPTIONS,
   hasMinimumVisibleXValues,
   resolveWaveformRenderingOptions,
   selectDecorationPoints,
@@ -49,25 +50,80 @@ describe('waveform rendering selection', () => {
         pointMinSpacing: -1,
         errorBarMinSpacing: Number.POSITIVE_INFINITY,
       }),
-    ).toEqual({
-      downsample: true,
-      downsampleThreshold: 2_000,
-      maxPointsPerPixel: 4,
-      pointMinSpacing: 10,
-      errorBarMinSpacing: 12,
-    })
+    ).toEqual(DEFAULT_WAVEFORM_RENDERING_OPTIONS)
   })
 
   it('accepts custom decoration spacing and uses zero to disable it', () => {
     expect(resolveWaveformRenderingOptions({ pointMinSpacing: 6, errorBarMinSpacing: 0 })).toEqual({
-      downsample: true,
-      downsampleThreshold: 2_000,
-      maxPointsPerPixel: 4,
+      ...DEFAULT_WAVEFORM_RENDERING_OPTIONS,
       pointMinSpacing: 6,
       errorBarMinSpacing: 0,
     })
   })
 
+  it('normalizes sampling options with strict runtime validation', () => {
+    const options: WaveformRenderingOptions = {
+      sampling: {
+        mode: 'wasm',
+        autoThreshold: 1_001.9,
+        autoHysteresis: 20.8,
+        strategy: 'minmax',
+        maxPointsPerPixel: 2.5,
+        rawPointLimit: 50_000.2,
+        wasmFailureFallback: 'javascript',
+      },
+    }
+
+    expect(resolveWaveformRenderingOptions(options)).toMatchObject({
+      downsample: true,
+      maxPointsPerPixel: 2.5,
+      sampling: {
+        mode: 'wasm',
+        autoThreshold: 1_001,
+        autoHysteresis: 20,
+        strategy: 'minmax',
+        maxPointsPerPixel: 2.5,
+        rawPointLimit: 50_000,
+        wasmFailureFallback: 'javascript',
+      },
+    })
+
+    expect(
+      resolveWaveformRenderingOptions({
+        sampling: {
+          mode: 'invalid',
+          autoThreshold: 0,
+          autoHysteresis: -1,
+          strategy: 'invalid',
+          maxPointsPerPixel: Number.POSITIVE_INFINITY,
+          rawPointLimit: 0,
+          wasmFailureFallback: 'fallback',
+        },
+      } as unknown as WaveformRenderingOptions),
+    ).toMatchObject({ sampling: DEFAULT_WAVEFORM_RENDERING_OPTIONS.sampling })
+  })
+
+  it('maps legacy downsample flags and gives explicit sampling mode precedence', () => {
+    expect(resolveWaveformRenderingOptions({ downsample: false }).sampling.mode).toBe('raw')
+    expect(resolveWaveformRenderingOptions({ downsample: true }).sampling.mode).toBe('auto')
+    expect(
+      resolveWaveformRenderingOptions({ downsample: false, sampling: { mode: 'wasm' } }),
+    ).toMatchObject({ downsample: true, sampling: { mode: 'wasm' } })
+  })
+
+  it('prefers nested sampling density over the legacy rendering field', () => {
+    const legacy = resolveWaveformRenderingOptions({ maxPointsPerPixel: 2 })
+    const nested = resolveWaveformRenderingOptions({
+      maxPointsPerPixel: 2,
+      sampling: { maxPointsPerPixel: 3 },
+    })
+
+    expect(legacy.maxPointsPerPixel).toBe(2)
+    expect(legacy.sampling.maxPointsPerPixel).toBe(2)
+    expect(nested.maxPointsPerPixel).toBe(3)
+    expect(nested.sampling.maxPointsPerPixel).toBe(3)
+  })
+
   it('selects evenly distributed source points for dense decorations', () => {
     const selected = selectDecorationPoints(points, [0, 9_999], 100, 10, true)
 
@@ -135,7 +191,10 @@ describe('waveform rendering selection', () => {
       densePoints,
       [99_999, 0],
       500,
-      resolveWaveformRenderingOptions({ downsampleThreshold: 100 }),
+      resolveWaveformRenderingOptions({
+        downsampleThreshold: 100,
+        sampling: { autoThreshold: 200_000 },
+      }),
       {
         lineVisible: true,
         pointVisible: true,
@@ -152,6 +211,22 @@ describe('waveform rendering selection', () => {
     expect(selected.errorBarRenderPoints.every((point) => (point.error ?? 0) > 0)).toBe(true)
   })
 
+  it('uses a width-bounded placeholder while large-series Worker sampling is pending', () => {
+    const rendering = resolveWaveformRenderingOptions({
+      sampling: { mode: 'auto', autoThreshold: 1_000, maxPointsPerPixel: 2 },
+    })
+    const selected = selectSeriesRenderPoints(points, [0, 9_999], 100, rendering, {
+      lineVisible: true,
+      pointVisible: false,
+      errorBarVisible: false,
+      hasErrorPoints: false,
+    })
+
+    expect(selected.linePoints).toHaveLength(200)
+    expect(selected.linePoints[0]).toBe(points[0])
+    expect(selected.linePoints.at(-1)).toBe(points.at(-1))
+  })
+
   it('counts unique visible x values across series and reversed domains', () => {
     const first = {
       points: [