Function createDataStore

src/data/createDataStore.ts:91–331

(device: GPUDevice)

}

export function createDataStore(device: GPUDevice): DataStore {
  const series = new Map<number, SeriesEntry>();
  let disposed = false;

  // Type guard (avoid relying on Array.isArray narrowing for readonly tuples in strict TS configs).
  const isTupleDataPoint = (p: DataPoint): p is DataPointTuple => Array.isArray(p);

  const packDataPointsWithXOffset = (points: ReadonlyArray<DataPoint>, xOffset: number): Float32Array => {
    if (!points || points.length === 0) return new Float32Array(0);

    const buffer = new ArrayBuffer(points.length * 2 * 4);
    const f32 = new Float32Array(buffer);

    // Hot path: keep logic minimal (validation happens elsewhere in option resolution).
    for (let i = 0; i < points.length; i++) {
      const p = points[i]!;
      const x = isTupleDataPoint(p) ? p[0] : p.x;
      const y = isTupleDataPoint(p) ? p[1] : p.y;

      // Subtracting before the Float32 cast preserves sub-ULP deltas for large x magnitudes.
      f32[i * 2 + 0] = x - xOffset;
      f32[i * 2 + 1] = y;
    }

    return f32;
  };

  const assertNotDisposed = (): void => {
    if (disposed) {
      throw new Error('DataStore is disposed.');
    }
  };

  const getSeriesEntry = (index: number): SeriesEntry => {
    assertNotDisposed();
    const entry = series.get(index);
    if (!entry) {
      throw new Error(`Series ${index} has no data. Call setSeries(${index}, data) first.`);
    }
    return entry;
  };

  const setSeries = (index: number, data: ReadonlyArray<DataPoint>, options?: Readonly<{ xOffset?: number }>): void => {
    assertNotDisposed();

    const xOffset = options?.xOffset ?? 0;
    const packed = xOffset === 0 ? packDataPoints(data) : packDataPointsWithXOffset(data, xOffset);
    const pointCount = data.length;
    const hash32 = hashFloat32ArrayBits(packed);

    const requiredBytes = roundUpToMultipleOf4(packed.byteLength);
    const targetBytes = Math.max(MIN_BUFFER_BYTES, requiredBytes);

    const existing = series.get(index);
    const unchanged = existing && existing.pointCount === pointCount && existing.hash32 === hash32;
    if (unchanged) return;

    let buffer = existing?.buffer ?? null;