Function setSeries

src/data/createDataStore.ts:133–196

(index: number, data: ReadonlyArray<DataPoint>, options?: Readonly<{ xOffset?: number }>)

  };

  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;
    let capacityBytes = existing?.capacityBytes ?? 0;

    if (!buffer || targetBytes > capacityBytes) {
      const maxBufferSize = device.limits.maxBufferSize;
      if (targetBytes > maxBufferSize) {
        throw new Error(
          `DataStore.setSeries(${index}): required buffer size ${targetBytes} exceeds device.limits.maxBufferSize (${maxBufferSize}).`
        );
      }

      if (buffer) {
        try {
          buffer.destroy();
        } catch {
          // Ignore destroy errors; we are replacing the buffer anyway.
        }
      }

      const grownCapacityBytes = computeGrownCapacityBytes(capacityBytes, targetBytes);
      if (grownCapacityBytes > maxBufferSize) {
        // If geometric growth would exceed the limit, fall back to the exact required size.
        // (Still no shrink: if current capacity was already larger, we'd keep it above.)
        // NOTE: targetBytes is already checked against maxBufferSize above.
        capacityBytes = targetBytes;
      } else {
        capacityBytes = grownCapacityBytes;
      }

      buffer = device.createBuffer({
        size: capacityBytes,
        usage: GPUBufferUsage.VERTEX | GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
      });
    }

    // Avoid 0-byte writes (empty series). The buffer is still valid for binding.
    if (packed.byteLength > 0) {
      device.queue.writeBuffer(buffer, 0, packed.buffer);
    }

    series.set(index, {
      buffer,
      capacityBytes,