Class WrapWritableStream

libraries/stream-extra/src/wrap-writable.ts:32–85

}

export class WrapWritableStream<T> extends WritableStream<T> {
    writable!: WritableStream<T>;

    #writer!: WritableStreamDefaultWriter<T>;

    constructor(
        start:
            | WritableStream<T>
            | WrapWritableStreamStart<T>
            | WritableStreamWrapper<T>,
    ) {
        super({
            start: async () => {
                const writable = await getWrappedWritableStream(start);
                // `start` is called in `super()`, so can't use `this` synchronously.
                // but it's fine after the first `await`
                this.writable = writable;
                this.#writer = this.writable.getWriter();
            },
            write: async (chunk) => {
                await this.#writer.write(chunk);
            },
            abort: async (reason) => {
                await this.#writer.abort(reason);
                if (start !== this.writable && "close" in start) {
                    await start.close?.();
                }
            },
            close: async () => {
                // Close the inner stream first.
                // Usually the inner stream is a logical sub-stream over the outer stream,
                // closing the outer stream first will make the inner stream incapable of
                // sending data in its `close` handler.
                await this.#writer.close();
                if (start !== this.writable && "close" in start) {
                    await start.close?.();
                }
            },
        });
    }

    bePipedThroughFrom<U>(transformer: TransformStream<U, T>) {
        let promise: Promise<void>;
        return new WrapWritableStream<U>({
            start: () => {
                promise = transformer.readable.pipeTo(this);
                return transformer.writable;
            },
            async close() {
                await promise;
            },
        });
    }
}