@yume-chan/stream-extra 0.0.20 → 0.0.22

package/src/consumable.ts

@@ -1,6 +1,10 @@
 import { PromiseResolver } from "@yume-chan/async";
 
-import type { QueuingStrategy, WritableStreamDefaultWriter } from "./stream.js";
+import type {
+    QueuingStrategy,
+    WritableStreamDefaultController,
+    WritableStreamDefaultWriter,
+} from "./stream.js";
 import { ReadableStream, TransformStream, WritableStream } from "./stream.js";
 
 interface Task {
@@ -29,25 +33,25 @@ export class Consumable<T> {
     readonly #task: Task;
     readonly #resolver: PromiseResolver<void>;
 
-    public readonly value: T;
-    public readonly consumed: Promise<void>;
+    readonly value: T;
+    readonly consumed: Promise<void>;
 
-    public constructor(value: T) {
+    constructor(value: T) {
         this.#task = createTask("Consumable");
         this.value = value;
         this.#resolver = new PromiseResolver<void>();
         this.consumed = this.#resolver.promise;
     }
 
-    public consume() {
+    consume() {
         this.#resolver.resolve();
     }
 
-    public error(error: any) {
+    error(error: any) {
         this.#resolver.reject(error);
     }
 
-    public async tryConsume<U>(callback: (value: T) => U) {
+    async tryConsume<U>(callback: (value: T) => U) {
         try {
             // eslint-disable-next-line @typescript-eslint/await-thenable
             const result = await this.#task.run(() => callback(this.value));
@@ -62,7 +66,7 @@ export class Consumable<T> {
 
 async function enqueue<T>(
     controller: { enqueue: (chunk: Consumable<T>) => void },
-    chunk: T
+    chunk: T,
 ) {
     const output = new Consumable(chunk);
     controller.enqueue(output);
@@ -70,7 +74,7 @@ async function enqueue<T>(
 }
 
 export class WrapConsumableStream<T> extends TransformStream<T, Consumable<T>> {
-    public constructor() {
+    constructor() {
         super({
             async transform(chunk, controller) {
                 await enqueue(controller, chunk);
@@ -83,7 +87,7 @@ export class UnwrapConsumableStream<T> extends TransformStream<
     Consumable<T>,
     T
 > {
-    public constructor() {
+    constructor() {
         super({
             transform(chunk, controller) {
                 controller.enqueue(chunk.value);
@@ -101,18 +105,18 @@ export interface ConsumableReadableStreamController<T> {
 
 export interface ConsumableReadableStreamSource<T> {
     start?(
-        controller: ConsumableReadableStreamController<T>
+        controller: ConsumableReadableStreamController<T>,
     ): void | PromiseLike<void>;
     pull?(
-        controller: ConsumableReadableStreamController<T>
+        controller: ConsumableReadableStreamController<T>,
     ): void | PromiseLike<void>;
     cancel?(reason: any): void | PromiseLike<void>;
 }
 
 export class ConsumableReadableStream<T> extends ReadableStream<Consumable<T>> {
-    public constructor(
+    constructor(
         source: ConsumableReadableStreamSource<T>,
-        strategy?: QueuingStrategy<T>
+        strategy?: QueuingStrategy<T>,
     ) {
         let wrappedController:
             | ConsumableReadableStreamController<T>
@@ -155,31 +159,36 @@ export class ConsumableReadableStream<T> extends ReadableStream<Consumable<T>> {
                     await source.cancel?.(reason);
                 },
             },
-            wrappedStrategy
+            wrappedStrategy,
         );
     }
 }
 
 export interface ConsumableWritableStreamSink<T> {
-    start?(): void | PromiseLike<void>;
-    write?(chunk: T): void | PromiseLike<void>;
+    start?(
+        controller: WritableStreamDefaultController,
+    ): void | PromiseLike<void>;
+    write?(
+        chunk: T,
+        controller: WritableStreamDefaultController,
+    ): void | PromiseLike<void>;
     abort?(reason: any): void | PromiseLike<void>;
     close?(): void | PromiseLike<void>;
 }
 
 export class ConsumableWritableStream<T> extends WritableStream<Consumable<T>> {
-    public static async write<T>(
+    static async write<T>(
         writer: WritableStreamDefaultWriter<Consumable<T>>,
-        value: T
+        value: T,
     ) {
         const consumable = new Consumable(value);
         await writer.write(consumable);
         await consumable.consumed;
     }
 
-    public constructor(
+    constructor(
         sink: ConsumableWritableStreamSink<T>,
-        strategy?: QueuingStrategy<T>
+        strategy?: QueuingStrategy<T>,
     ) {
         let wrappedStrategy: QueuingStrategy<Consumable<T>> | undefined;
         if (strategy) {
@@ -196,11 +205,13 @@ export class ConsumableWritableStream<T> extends WritableStream<Consumable<T>> {
 
         super(
             {
-                start() {
-                    return sink.start?.();
+                start(controller) {
+                    return sink.start?.(controller);
                 },
-                async write(chunk) {
-                    await chunk.tryConsume((value) => sink.write?.(value));
+                async write(chunk, controller) {
+                    await chunk.tryConsume(
+                        (value) => sink.write?.(value, controller),
+                    );
                     chunk.consume();
                 },
                 abort(reason) {
@@ -210,21 +221,21 @@ export class ConsumableWritableStream<T> extends WritableStream<Consumable<T>> {
                     return sink.close?.();
                 },
             },
-            wrappedStrategy
+            wrappedStrategy,
         );
     }
 }
 
 export interface ConsumableTransformer<I, O> {
     start?(
-        controller: ConsumableReadableStreamController<O>
+        controller: ConsumableReadableStreamController<O>,
     ): void | PromiseLike<void>;
     transform?(
         chunk: I,
-        controller: ConsumableReadableStreamController<O>
+        controller: ConsumableReadableStreamController<O>,
     ): void | PromiseLike<void>;
     flush?(
-        controller: ConsumableReadableStreamController<O>
+        controller: ConsumableReadableStreamController<O>,
     ): void | PromiseLike<void>;
 }
 
@@ -232,7 +243,7 @@ export class ConsumableTransformStream<I, O> extends TransformStream<
     Consumable<I>,
     Consumable<O>
 > {
-    public constructor(transformer: ConsumableTransformer<I, O>) {
+    constructor(transformer: ConsumableTransformer<I, O>) {
         let wrappedController:
             | ConsumableReadableStreamController<O>
             | undefined;
@@ -254,8 +265,9 @@ export class ConsumableTransformStream<I, O> extends TransformStream<
                 await transformer.start?.(wrappedController);
             },
             async transform(chunk) {
-                await chunk.tryConsume((value) =>
-                    transformer.transform?.(value, wrappedController!)
+                await chunk.tryConsume(
+                    (value) =>
+                        transformer.transform?.(value, wrappedController!),
                 );
                 chunk.consume();
             },
@@ -270,7 +282,7 @@ export class ConsumableInspectStream<T> extends TransformStream<
     Consumable<T>,
     Consumable<T>
 > {
-    public constructor(callback: (value: T) => void) {
+    constructor(callback: (value: T) => void) {
         super({
             transform(chunk, controller) {
                 callback(chunk.value);

package/src/decode-utf8.ts

@@ -3,7 +3,7 @@ import { decodeUtf8 } from "@yume-chan/struct";
 import { TransformStream } from "./stream.js";
 
 export class DecodeUtf8Stream extends TransformStream<Uint8Array, string> {
-    public constructor() {
+    constructor() {
         super({
             transform(chunk, controller) {
                 controller.enqueue(decodeUtf8(chunk));

package/src/distribution.ts

@@ -9,7 +9,7 @@ export class BufferCombiner {
     #offset: number;
     #available: number;
 
-    public constructor(size: number) {
+    constructor(size: number) {
         this.#capacity = size;
         this.#buffer = new Uint8Array(size);
         this.#offset = 0;
@@ -23,7 +23,7 @@ export class BufferCombiner {
      * A generator that yields buffers of specified size.
      * It may yield the same buffer multiple times, consume the data before calling `next`.
      */
-    public *push(data: Uint8Array): Generator<Uint8Array, void, void> {
+    *push(data: Uint8Array): Generator<Uint8Array, void, void> {
         let offset = 0;
         let available = data.byteLength;
 
@@ -31,7 +31,7 @@ export class BufferCombiner {
             if (available >= this.#available) {
                 this.#buffer.set(
                     data.subarray(0, this.#available),
-                    this.#offset
+                    this.#offset,
                 );
                 offset += this.#available;
                 available -= this.#available;
@@ -65,7 +65,7 @@ export class BufferCombiner {
         }
     }
 
-    public flush(): Uint8Array | undefined {
+    flush(): Uint8Array | undefined {
         if (this.#offset === 0) {
             return undefined;
         }
@@ -81,7 +81,7 @@ export class DistributionStream extends ConsumableTransformStream<
     Uint8Array,
     Uint8Array
 > {
-    public constructor(size: number, combine = false) {
+    constructor(size: number, combine = false) {
         const combiner = combine ? new BufferCombiner(size) : undefined;
         super({
             async transform(chunk, controller) {

package/src/duplex.ts

@@ -2,6 +2,7 @@ import { PromiseResolver } from "@yume-chan/async";
 import type { ValueOrPromise } from "@yume-chan/struct";
 
 import type {
+    QueuingStrategy,
     ReadableStream,
     ReadableStreamDefaultController,
     WritableStreamDefaultWriter,
@@ -50,39 +51,45 @@ export class DuplexStreamFactory<R, W> {
     #writers: WritableStreamDefaultWriter<W>[] = [];
 
     #writableClosed = false;
-    public get writableClosed() {
+    get writableClosed() {
         return this.#writableClosed;
     }
 
     #closed = new PromiseResolver<void>();
-    public get closed() {
+    get closed() {
         return this.#closed.promise;
     }
 
     readonly #options: DuplexStreamFactoryOptions;
 
-    public constructor(options?: DuplexStreamFactoryOptions) {
+    constructor(options?: DuplexStreamFactoryOptions) {
         this.#options = options ?? {};
     }
 
-    public wrapReadable(readable: ReadableStream<R>): WrapReadableStream<R> {
-        return new WrapReadableStream<R>({
-            start: (controller) => {
-                this.#readableControllers.push(controller);
-                return readable;
+    wrapReadable(
+        readable: ReadableStream<R>,
+        strategy?: QueuingStrategy<R>,
+    ): WrapReadableStream<R> {
+        return new WrapReadableStream<R>(
+            {
+                start: (controller) => {
+                    this.#readableControllers.push(controller);
+                    return readable;
+                },
+                cancel: async () => {
+                    // cancel means the local peer wants to close the connection.
+                    await this.close();
+                },
+                close: async () => {
+                    // stream end means the remote peer closed the connection first.
+                    await this.dispose();
+                },
             },
-            cancel: async () => {
-                // cancel means the local peer wants to close the connection.
-                await this.close();
-            },
-            close: async () => {
-                // stream end means the remote peer closed the connection first.
-                await this.dispose();
-            },
-        });
+            strategy,
+        );
     }
 
-    public createWritable(stream: WritableStream<W>): WritableStream<W> {
+    createWritable(stream: WritableStream<W>): WritableStream<W> {
         const writer = stream.getWriter();
         this.#writers.push(writer);
 
@@ -104,7 +111,7 @@ export class DuplexStreamFactory<R, W> {
         });
     }
 
-    public async close() {
+    async close() {
         if (this.#writableClosed) {
             return;
         }
@@ -122,7 +129,7 @@ export class DuplexStreamFactory<R, W> {
         }
     }
 
-    public async dispose() {
+    async dispose() {
         this.#writableClosed = true;
         this.#closed.resolve();
 

package/src/index.ts

@@ -1,10 +1,10 @@
 export * from "./buffered-transform.js";
 export * from "./buffered.js";
+export * from "./concat.js";
 export * from "./consumable.js";
 export * from "./decode-utf8.js";
 export * from "./distribution.js";
 export * from "./duplex.js";
-export * from "./gather-string.js";
 export * from "./inspect.js";
 export * from "./pipe-from.js";
 export * from "./push-readable.js";

package/src/pipe-from.ts

@@ -12,7 +12,7 @@ import { WritableStream } from "./stream.js";
  */
 export function pipeFrom<W, T>(
     writable: WritableStream<W>,
-    pair: ReadableWritablePair<W, T>
+    pair: ReadableWritablePair<W, T>,
 ) {
     const writer = pair.writable.getWriter();
     const pipe = pair.readable.pipeTo(writable);

package/src/push-readable.ts

@@ -14,10 +14,12 @@ export interface PushReadableStreamController<T> {
 }
 
 export type PushReadableStreamSource<T> = (
-    controller: PushReadableStreamController<T>
+    controller: PushReadableStreamController<T>,
 ) => void | Promise<void>;
 
 export class PushReadableStream<T> extends ReadableStream<T> {
+    #zeroHighWaterMarkAllowEnqueue = false;
+
     /**
      * Create a new `PushReadableStream` from a source.
      *
@@ -25,33 +27,41 @@ export class PushReadableStream<T> extends ReadableStream<T> {
      * when the `Promise` is resolved, and be errored when the `Promise` is rejected.
      * @param strategy
      */
-    public constructor(
+    constructor(
         source: PushReadableStreamSource<T>,
-        strategy?: QueuingStrategy<T>
+        strategy?: QueuingStrategy<T>,
     ) {
         let waterMarkLow: PromiseResolver<void> | undefined;
         const abortController = new AbortController();
 
         super(
             {
-                start: (controller) => {
+                start: async (controller) => {
+                    await Promise.resolve();
+
                     const result = source({
                         abortSignal: abortController.signal,
-                        async enqueue(chunk) {
+                        enqueue: async (chunk) => {
                             if (abortController.signal.aborted) {
                                 // If the stream is already cancelled,
                                 // throw immediately.
-                                throw (
-                                    abortController.signal.reason ??
-                                    new Error("Aborted")
-                                );
+                                throw abortController.signal.reason;
+                            }
+
+                            if (controller.desiredSize === null) {
+                                // `desiredSize` being `null` means the stream is in error state,
+                                // `controller.enqueue` will throw an error for us.
+                                controller.enqueue(chunk);
+                                return;
+                            }
+
+                            if (this.#zeroHighWaterMarkAllowEnqueue) {
+                                this.#zeroHighWaterMarkAllowEnqueue = false;
+                                controller.enqueue(chunk);
+                                return;
                             }
 
-                            // Only when the stream is errored, `desiredSize` will be `null`.
-                            // But since `null <= 0` is `true`
-                            // (`null <= 0` is evaluated as `!(null > 0)` => `!false` => `true`),
-                            // not handling it will cause a deadlock.
-                            if ((controller.desiredSize ?? 1) <= 0) {
+                            if (controller.desiredSize <= 0) {
                                 waterMarkLow = new PromiseResolver<void>();
                                 await waterMarkLow.promise;
                             }
@@ -79,19 +89,25 @@ export class PushReadableStream<T> extends ReadableStream<T> {
                             },
                             (e) => {
                                 controller.error(e);
-                            }
+                            },
                         );
                     }
                 },
                 pull: () => {
-                    waterMarkLow?.resolve();
+                    if (waterMarkLow) {
+                        waterMarkLow.resolve();
+                        return;
+                    }
+                    if (strategy?.highWaterMark === 0) {
+                        this.#zeroHighWaterMarkAllowEnqueue = true;
+                    }
                 },
                 cancel: (reason) => {
                     abortController.abort(reason);
                     waterMarkLow?.reject(reason);
                 },
             },
-            strategy
+            strategy,
         );
     }
 }

package/src/split-string.ts

@@ -2,7 +2,7 @@ import { TransformStream } from "./stream.js";
 
 function* split(
     input: string,
-    separator: string
+    separator: string,
 ): Generator<string, void, void> {
     let start = 0;
 
@@ -20,7 +20,7 @@ function* split(
 }
 
 export class SplitStringStream extends TransformStream<string, string> {
-    public constructor(separator: string) {
+    constructor(separator: string) {
         super({
             transform(chunk, controller) {
                 for (const part of split(chunk, separator)) {

package/src/stream.ts

@@ -45,20 +45,7 @@ export type TransformStream<I = any, O = any> = TransformStreamPolyfill<I, O>;
 export let TransformStream = TransformStreamPolyfill;
 
 if (GLOBAL.ReadableStream && GLOBAL.WritableStream && GLOBAL.TransformStream) {
-    // Use browser native implementation
     ReadableStream = GLOBAL.ReadableStream;
     WritableStream = GLOBAL.WritableStream;
     TransformStream = GLOBAL.TransformStream;
-} else {
-    // TODO: enable loading Node.js stream implementation when bundler supports Top Level Await
-    // try {
-    //     // Use Node.js native implementation
-    //     const MODULE_NAME = "node:stream/web";
-    //     const StreamWeb = (await import(MODULE_NAME)) as GlobalExtension;
-    //     ReadableStream = StreamWeb.ReadableStream;
-    //     WritableStream = StreamWeb.WritableStream;
-    //     TransformStream = StreamWeb.TransformStream;
-    // } catch {
-    //     // ignore
-    // }
 }

package/src/struct-deserialize.ts

@@ -4,9 +4,9 @@ import type { StructValueType } from "@yume-chan/struct";
 import { BufferedTransformStream } from "./buffered-transform.js";
 
 export class StructDeserializeStream<
-    T extends Struct<any, any, any, any>
+    T extends Struct<any, any, any, any>,
 > extends BufferedTransformStream<StructValueType<T>> {
-    public constructor(struct: T) {
+    constructor(struct: T) {
         super((stream) => {
             return struct.deserialize(stream);
         });

package/src/struct-serialize.ts

@@ -3,7 +3,7 @@ import type Struct from "@yume-chan/struct";
 import { TransformStream } from "./stream.js";
 
 export class StructSerializeStream<
-    T extends Struct<any, any, any, any>
+    T extends Struct<any, any, any, any>,
 > extends TransformStream<T["TInit"], Uint8Array> {
     constructor(struct: T) {
         super({

package/src/wrap-readable.ts

@@ -1,13 +1,14 @@
 import type { ValueOrPromise } from "@yume-chan/struct";
 
 import type {
+    QueuingStrategy,
     ReadableStreamDefaultController,
     ReadableStreamDefaultReader,
 } from "./stream.js";
 import { ReadableStream } from "./stream.js";
 
 export type WrapReadableStreamStart<T> = (
-    controller: ReadableStreamDefaultController<T>
+    controller: ReadableStreamDefaultController<T>,
 ) => ValueOrPromise<ReadableStream<T>>;
 
 export interface ReadableStreamWrapper<T> {
@@ -21,7 +22,7 @@ function getWrappedReadableStream<T>(
         | ReadableStream<T>
         | WrapReadableStreamStart<T>
         | ReadableStreamWrapper<T>,
-    controller: ReadableStreamDefaultController<T>
+    controller: ReadableStreamDefaultController<T>,
 ) {
     if ("start" in wrapper) {
         return wrapper.start(controller);
@@ -42,47 +43,51 @@ function getWrappedReadableStream<T>(
  * 3. Convert native `ReadableStream`s to polyfilled ones so they can `pipe` between.
  */
 export class WrapReadableStream<T> extends ReadableStream<T> {
-    public readable!: ReadableStream<T>;
+    readable!: ReadableStream<T>;
 
     #reader!: ReadableStreamDefaultReader<T>;
 
-    public constructor(
+    constructor(
         wrapper:
             | ReadableStream<T>
             | WrapReadableStreamStart<T>
-            | ReadableStreamWrapper<T>
+            | ReadableStreamWrapper<T>,
+        strategy?: QueuingStrategy<T>,
     ) {
-        super({
-            start: async (controller) => {
-                // `start` is invoked before `ReadableStream`'s constructor finish,
-                // so using `this` synchronously causes
-                // "Must call super constructor in derived class before accessing 'this' or returning from derived constructor".
-                // Queue a microtask to avoid this.
-                await Promise.resolve();
+        super(
+            {
+                start: async (controller) => {
+                    // `start` is invoked before `ReadableStream`'s constructor finish,
+                    // so using `this` synchronously causes
+                    // "Must call super constructor in derived class before accessing 'this' or returning from derived constructor".
+                    // Queue a microtask to avoid this.
+                    await Promise.resolve();
 
-                this.readable = await getWrappedReadableStream(
-                    wrapper,
-                    controller
-                );
-                this.#reader = this.readable.getReader();
-            },
-            cancel: async (reason) => {
-                await this.#reader.cancel(reason);
-                if ("cancel" in wrapper) {
-                    await wrapper.cancel?.(reason);
-                }
-            },
-            pull: async (controller) => {
-                const result = await this.#reader.read();
-                if (result.done) {
-                    controller.close();
-                    if ("close" in wrapper) {
-                        await wrapper.close?.();
+                    this.readable = await getWrappedReadableStream(
+                        wrapper,
+                        controller,
+                    );
+                    this.#reader = this.readable.getReader();
+                },
+                pull: async (controller) => {
+                    const result = await this.#reader.read();
+                    if (result.done) {
+                        controller.close();
+                        if ("close" in wrapper) {
+                            await wrapper.close?.();
+                        }
+                    } else {
+                        controller.enqueue(result.value);
+                    }
+                },
+                cancel: async (reason) => {
+                    await this.#reader.cancel(reason);
+                    if ("cancel" in wrapper) {
+                        await wrapper.cancel?.(reason);
                     }
-                } else {
-                    controller.enqueue(result.value);
-                }
+                },
             },
-        });
+            strategy,
+        );
     }
 }