Class BufferedReadableStream

libraries/stream-extra/src/buffered.ts:9–184

import { tryCancel } from "./try-close.js";

export class BufferedReadableStream implements AsyncExactReadable {
    #buffered: Uint8Array | undefined;
    // PERF: `subarray` is slow
    // don't use it until absolutely necessary
    #bufferedOffset = 0;
    #bufferedLength = 0;

    #position = 0;
    get position() {
        return this.#position;
    }

    protected readonly stream: ReadableStream<Uint8Array>;
    protected readonly reader: ReadableStreamDefaultReader<Uint8Array>;

    constructor(stream: ReadableStream<Uint8Array>) {
        this.stream = stream;
        this.reader = stream.getReader();
    }

    #readBuffered(length: number) {
        if (!this.#buffered) {
            return undefined;
        }

        const value = this.#buffered.subarray(
            this.#bufferedOffset,
            this.#bufferedOffset + length,
        );

        // PERF: Synchronous path for reading from internal buffer
        if (this.#bufferedLength > length) {
            this.#position += length;
            this.#bufferedOffset += length;
            this.#bufferedLength -= length;
            return value;
        }

        this.#position += this.#bufferedLength;
        this.#buffered = undefined;
        this.#bufferedOffset = 0;
        this.#bufferedLength = 0;
        return value;
    }

    async #readSource(length: number): Promise<Uint8Array> {
        const { done, value } = await this.reader.read();
        if (done) {
            throw new ExactReadableEndedError();
        }

        if (value.length > length) {
            this.#buffered = value;
            this.#bufferedOffset = length;
            this.#bufferedLength = value.length - length;
            this.#position += length;
            return value.subarray(0, length);
        }