@yume-chan/stream-extra 0.0.24 → 1.0.0

package/src/buffered.ts

@@ -1,15 +1,15 @@
+import type { MaybePromiseLike } from "@yume-chan/async";
 import type { AsyncExactReadable } from "@yume-chan/struct";
-import { ExactReadableEndedError } from "@yume-chan/struct";
+import { bipedal, ExactReadableEndedError } from "@yume-chan/struct";
 
 import { PushReadableStream } from "./push-readable.js";
 import type { ReadableStream, ReadableStreamDefaultReader } from "./stream.js";
-
-const NOOP = () => {
-    // no-op
-};
+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;
 
@@ -26,99 +26,124 @@ export class BufferedReadableStream implements AsyncExactReadable {
         this.reader = stream.getReader();
     }
 
-    async #readSource() {
+    #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);
+        }
+
+        this.#position += value.length;
         return value;
     }
 
-    async #readAsync(length: number, initial?: Uint8Array) {
-        let result: Uint8Array;
-        let index: number;
+    iterateExactly(
+        length: number,
+    ): Iterator<MaybePromiseLike<Uint8Array>, void, void> {
+        let state = this.#buffered ? 0 : 1;
+        return {
+            next: () => {
+                switch (state) {
+                    case 0: {
+                        const value = this.#readBuffered(length)!;
+                        if (value.length === length) {
+                            state = 2;
+                        } else {
+                            length -= value.length;
+                            state = 1;
+                        }
+                        return { done: false, value };
+                    }
+                    case 1:
+                        state = 3;
+                        return {
+                            done: false,
+                            value: this.#readSource(length).then((value) => {
+                                if (value.length === length) {
+                                    state = 2;
+                                } else {
+                                    length -= value.length;
+                                    state = 1;
+                                }
+                                return value;
+                            }),
+                        };
+                    case 2:
+                        return { done: true, value: undefined };
+                    case 3:
+                        throw new Error(
+                            "Can't call `next` before previous Promise resolves",
+                        );
+                    default:
+                        throw new Error("unreachable");
+                }
+            },
+        };
+    }
 
+    readExactly = bipedal(function* (
+        this: BufferedReadableStream,
+        then,
+        length: number,
+    ) {
+        let result: Uint8Array | undefined;
+        let index = 0;
+
+        const initial = this.#readBuffered(length);
         if (initial) {
+            if (initial.length === length) {
+                return initial;
+            }
+
             result = new Uint8Array(length);
-            result.set(initial);
-            index = initial.length;
+            result.set(initial, index);
+            index += initial.length;
             length -= initial.length;
         } else {
-            const array = await this.#readSource();
-            if (array.length === length) {
-                this.#position += length;
-                return array;
-            }
-
-            if (array.length > length) {
-                this.#buffered = array;
-                this.#bufferedOffset = length;
-                this.#bufferedLength = array.length - length;
-                this.#position += length;
-                return array.subarray(0, length);
-            }
-
             result = new Uint8Array(length);
-            result.set(array);
-            index = array.length;
-            length -= array.length;
-            this.#position += array.length;
         }
 
         while (length > 0) {
-            const array = await this.#readSource();
-            if (array.length === length) {
-                result.set(array, index);
-                this.#position += length;
-                return result;
-            }
-
-            if (array.length > length) {
-                this.#buffered = array;
-                this.#bufferedOffset = length;
-                this.#bufferedLength = array.length - length;
-                result.set(array.subarray(0, length), index);
-                this.#position += length;
-                return result;
-            }
-
-            result.set(array, index);
-            index += array.length;
-            length -= array.length;
-            this.#position += array.length;
+            const value = yield* then(this.#readSource(length));
+            result.set(value, index);
+            index += value.length;
+            length -= value.length;
         }
 
         return result;
-    }
-
-    /**
-     *
-     * @param length
-     * @returns
-     */
-    readExactly(length: number): Uint8Array | Promise<Uint8Array> {
-        // PERF: Add a synchronous path for reading from internal buffer
-        if (this.#buffered) {
-            const array = this.#buffered;
-            const offset = this.#bufferedOffset;
-            if (this.#bufferedLength > length) {
-                // PERF: `subarray` is slow
-                // don't use it until absolutely necessary
-                this.#bufferedOffset += length;
-                this.#bufferedLength -= length;
-                this.#position += length;
-                return array.subarray(offset, offset + length);
-            }
-
-            this.#buffered = undefined;
-            this.#bufferedLength = 0;
-            this.#bufferedOffset = 0;
-            this.#position += array.length - offset;
-            return this.#readAsync(length, array.subarray(offset));
-        }
-
-        return this.#readAsync(length);
-    }
+    });
 
     /**
      * Return a readable stream with unconsumed data (if any) and
@@ -133,8 +158,7 @@ export class BufferedReadableStream implements AsyncExactReadable {
                 await controller.enqueue(buffered);
 
                 controller.abortSignal.addEventListener("abort", () => {
-                    // NOOP: the reader might already be released
-                    this.reader.cancel().catch(NOOP);
+                    void tryCancel(this.reader);
                 });
 
                 // Manually pipe the stream
@@ -142,9 +166,9 @@ export class BufferedReadableStream implements AsyncExactReadable {
                     const { done, value } = await this.reader.read();
                     if (done) {
                         return;
-                    } else {
-                        await controller.enqueue(value);
                     }
+
+                    await controller.enqueue(value);
                 }
             });
         } else {

package/src/concat.ts

@@ -1,5 +1,5 @@
 import { PromiseResolver } from "@yume-chan/async";
-import { EMPTY_UINT8_ARRAY } from "@yume-chan/struct";
+import { EmptyUint8Array } from "@yume-chan/struct";
 
 import type { ReadableStreamDefaultController } from "./stream.js";
 import { ReadableStream, WritableStream } from "./stream.js";
@@ -101,7 +101,7 @@ export class ConcatBufferStream {
             let offset = 0;
             switch (this.#segments.length) {
                 case 0:
-                    result = EMPTY_UINT8_ARRAY;
+                    result = EmptyUint8Array;
                     break;
                 case 1:
                     result = this.#segments[0]!;

package/src/consumable.ts

@@ -1,4 +1,4 @@
-import { PromiseResolver } from "@yume-chan/async";
+import { PromiseResolver, isPromiseLike } from "@yume-chan/async";
 
 import type {
     QueuingStrategy,
@@ -12,11 +12,123 @@ import {
 import type { Task } from "./task.js";
 import { createTask } from "./task.js";
 
-function isPromiseLike(value: unknown): value is PromiseLike<unknown> {
-    return typeof value === "object" && value !== null && "then" in value;
+// Workaround https://github.com/evanw/esbuild/issues/3923
+class WritableStream<in T> extends NativeWritableStream<Consumable<T>> {
+    static async write<T>(
+        writer: WritableStreamDefaultWriter<Consumable<T>>,
+        value: T,
+    ) {
+        const consumable = new Consumable(value);
+        await writer.write(consumable);
+        await consumable.consumed;
+    }
+
+    constructor(
+        sink: Consumable.WritableStreamSink<T>,
+        strategy?: QueuingStrategy<T>,
+    ) {
+        let wrappedStrategy: QueuingStrategy<Consumable<T>> | undefined;
+        if (strategy) {
+            wrappedStrategy = {};
+            if ("highWaterMark" in strategy) {
+                wrappedStrategy.highWaterMark = strategy.highWaterMark;
+            }
+            if ("size" in strategy) {
+                wrappedStrategy.size = (chunk) => {
+                    return strategy.size!(
+                        chunk instanceof Consumable ? chunk.value : chunk,
+                    );
+                };
+            }
+        }
+
+        super(
+            {
+                start(controller) {
+                    return sink.start?.(controller);
+                },
+                async write(chunk, controller) {
+                    await chunk.tryConsume((chunk) =>
+                        sink.write?.(chunk, controller),
+                    );
+                },
+                abort(reason) {
+                    return sink.abort?.(reason);
+                },
+                close() {
+                    return sink.close?.();
+                },
+            },
+            wrappedStrategy,
+        );
+    }
+}
+
+class ReadableStream<T> extends NativeReadableStream<Consumable<T>> {
+    static async enqueue<T>(
+        controller: { enqueue: (chunk: Consumable<T>) => void },
+        chunk: T,
+    ) {
+        const output = new Consumable(chunk);
+        controller.enqueue(output);
+        await output.consumed;
+    }
+
+    constructor(
+        source: Consumable.ReadableStreamSource<T>,
+        strategy?: QueuingStrategy<T>,
+    ) {
+        let wrappedController:
+            | Consumable.ReadableStreamController<T>
+            | undefined;
+
+        let wrappedStrategy: QueuingStrategy<Consumable<T>> | undefined;
+        if (strategy) {
+            wrappedStrategy = {};
+            if ("highWaterMark" in strategy) {
+                wrappedStrategy.highWaterMark = strategy.highWaterMark;
+            }
+            if ("size" in strategy) {
+                wrappedStrategy.size = (chunk) => {
+                    return strategy.size!(chunk.value);
+                };
+            }
+        }
+
+        super(
+            {
+                async start(controller) {
+                    wrappedController = {
+                        async enqueue(chunk) {
+                            await ReadableStream.enqueue(controller, chunk);
+                        },
+                        close() {
+                            controller.close();
+                        },
+                        error(reason) {
+                            controller.error(reason);
+                        },
+                    };
+
+                    await source.start?.(wrappedController);
+                },
+                async pull() {
+                    await source.pull?.(wrappedController!);
+                },
+                async cancel(reason) {
+                    await source.cancel?.(reason);
+                },
+            },
+            wrappedStrategy,
+        );
+    }
 }
 
 export class Consumable<T> {
+    static readonly WritableStream = WritableStream;
+
+    static readonly ReadableStream = ReadableStream;
+
     readonly #task: Task;
     readonly #resolver: PromiseResolver<void>;
 
@@ -76,58 +188,7 @@ export namespace Consumable {
         close?(): void | PromiseLike<void>;
     }
 
-    export class WritableStream<in T> extends NativeWritableStream<
-        Consumable<T>
-    > {
-        static async write<T>(
-            writer: WritableStreamDefaultWriter<Consumable<T>>,
-            value: T,
-        ) {
-            const consumable = new Consumable(value);
-            await writer.write(consumable);
-            await consumable.consumed;
-        }
-
-        constructor(
-            sink: WritableStreamSink<T>,
-            strategy?: QueuingStrategy<T>,
-        ) {
-            let wrappedStrategy: QueuingStrategy<Consumable<T>> | undefined;
-            if (strategy) {
-                wrappedStrategy = {};
-                if ("highWaterMark" in strategy) {
-                    wrappedStrategy.highWaterMark = strategy.highWaterMark;
-                }
-                if ("size" in strategy) {
-                    wrappedStrategy.size = (chunk) => {
-                        return strategy.size!(
-                            chunk instanceof Consumable ? chunk.value : chunk,
-                        );
-                    };
-                }
-            }
-
-            super(
-                {
-                    start(controller) {
-                        return sink.start?.(controller);
-                    },
-                    async write(chunk, controller) {
-                        await chunk.tryConsume((chunk) =>
-                            sink.write?.(chunk, controller),
-                        );
-                    },
-                    abort(reason) {
-                        return sink.abort?.(reason);
-                    },
-                    close() {
-                        return sink.close?.();
-                    },
-                },
-                wrappedStrategy,
-            );
-        }
-    }
+    export type WritableStream<in T> = typeof Consumable.WritableStream<T>;
 
     export interface ReadableStreamController<T> {
         enqueue(chunk: T): Promise<void>;
@@ -145,61 +206,5 @@ export namespace Consumable {
         cancel?(reason: unknown): void | PromiseLike<void>;
     }
 
-    export class ReadableStream<T> extends NativeReadableStream<Consumable<T>> {
-        static async enqueue<T>(
-            controller: { enqueue: (chunk: Consumable<T>) => void },
-            chunk: T,
-        ) {
-            const output = new Consumable(chunk);
-            controller.enqueue(output);
-            await output.consumed;
-        }
-
-        constructor(
-            source: ReadableStreamSource<T>,
-            strategy?: QueuingStrategy<T>,
-        ) {
-            let wrappedController: ReadableStreamController<T> | undefined;
-
-            let wrappedStrategy: QueuingStrategy<Consumable<T>> | undefined;
-            if (strategy) {
-                wrappedStrategy = {};
-                if ("highWaterMark" in strategy) {
-                    wrappedStrategy.highWaterMark = strategy.highWaterMark;
-                }
-                if ("size" in strategy) {
-                    wrappedStrategy.size = (chunk) => {
-                        return strategy.size!(chunk.value);
-                    };
-                }
-            }
-
-            super(
-                {
-                    async start(controller) {
-                        wrappedController = {
-                            async enqueue(chunk) {
-                                await ReadableStream.enqueue(controller, chunk);
-                            },
-                            close() {
-                                controller.close();
-                            },
-                            error(reason) {
-                                controller.error(reason);
-                            },
-                        };
-
-                        await source.start?.(wrappedController);
-                    },
-                    async pull() {
-                        await source.pull?.(wrappedController!);
-                    },
-                    async cancel(reason) {
-                        await source.cancel?.(reason);
-                    },
-                },
-                wrappedStrategy,
-            );
-        }
-    }
+    export type ReadableStream<T> = typeof Consumable.ReadableStream<T>;
 }

package/src/duplex.ts

@@ -1,5 +1,5 @@
+import type { MaybePromiseLike } from "@yume-chan/async";
 import { PromiseResolver } from "@yume-chan/async";
-import type { ValueOrPromise } from "@yume-chan/struct";
 
 import type {
     QueuingStrategy,
@@ -8,6 +8,7 @@ import type {
     WritableStreamDefaultWriter,
 } from "./stream.js";
 import { WritableStream } from "./stream.js";
+import { tryClose } from "./try-close.js";
 import { WrapReadableStream } from "./wrap-readable.js";
 
 const NOOP = () => {
@@ -27,7 +28,7 @@ export interface DuplexStreamFactoryOptions {
      * `DuplexStreamFactory#dispose` yourself, you can return `false`
      * (or a `Promise` that resolves to `false`) to disable the automatic call.
      */
-    close?: (() => ValueOrPromise<boolean | void>) | undefined;
+    close?: (() => MaybePromiseLike<boolean | void>) | undefined;
 
     /**
      * Callback when any `ReadableStream` is closed (the other peer doesn't produce any more data),
@@ -134,11 +135,7 @@ export class DuplexStreamFactory<R, W> {
         this.#closed.resolve();
 
         for (const controller of this.#readableControllers) {
-            try {
-                controller.close();
-            } catch {
-                // ignore
-            }
+            tryClose(controller);
         }
 
         await this.#options.dispose?.();

package/src/index.ts

@@ -14,5 +14,6 @@ export * from "./stream.js";
 export * from "./struct-deserialize.js";
 export * from "./struct-serialize.js";
 export * from "./task.js";
+export * from "./try-close.js";
 export * from "./wrap-readable.js";
 export * from "./wrap-writable.js";

package/src/maybe-consumable-ns.ts

@@ -0,0 +1,75 @@
+import { Consumable } from "./consumable.js";
+import type { MaybeConsumable } from "./maybe-consumable.js";
+import type {
+    QueuingStrategy,
+    WritableStreamDefaultController,
+} from "./stream.js";
+import { WritableStream as NativeWritableStream } from "./stream.js";
+
+export function getValue<T>(value: MaybeConsumable<T>): T {
+    return value instanceof Consumable ? value.value : value;
+}
+
+export function tryConsume<T, R>(
+    value: T,
+    callback: (value: T extends Consumable<infer U> ? U : T) => R,
+): R {
+    if (value instanceof Consumable) {
+        return value.tryConsume(callback);
+    } else {
+        return callback(value as never);
+    }
+}
+
+export interface WritableStreamSink<in T> {
+    start?(
+        controller: WritableStreamDefaultController,
+    ): void | PromiseLike<void>;
+    write?(
+        chunk: T,
+        controller: WritableStreamDefaultController,
+    ): void | PromiseLike<void>;
+    abort?(reason: unknown): void | PromiseLike<void>;
+    close?(): void | PromiseLike<void>;
+}
+
+export class WritableStream<in T> extends NativeWritableStream<
+    MaybeConsumable<T>
+> {
+    constructor(sink: WritableStreamSink<T>, strategy?: QueuingStrategy<T>) {
+        let wrappedStrategy: QueuingStrategy<MaybeConsumable<T>> | undefined;
+        if (strategy) {
+            wrappedStrategy = {};
+            if ("highWaterMark" in strategy) {
+                wrappedStrategy.highWaterMark = strategy.highWaterMark;
+            }
+            if ("size" in strategy) {
+                wrappedStrategy.size = (chunk) => {
+                    return strategy.size!(
+                        chunk instanceof Consumable ? chunk.value : chunk,
+                    );
+                };
+            }
+        }
+
+        super(
+            {
+                start(controller) {
+                    return sink.start?.(controller);
+                },
+                async write(chunk, controller) {
+                    await tryConsume(chunk, (chunk) =>
+                        sink.write?.(chunk as T, controller),
+                    );
+                },
+                abort(reason) {
+                    return sink.abort?.(reason);
+                },
+                close() {
+                    return sink.close?.();
+                },
+            },
+            wrappedStrategy,
+        );
+    }
+}