@yume-chan/stream-extra 0.0.24 → 2.0.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,
+        );
+    }
+}

package/src/maybe-consumable.ts

@@ -1,101 +1,5 @@
-import { Consumable } from "./consumable.js";
-import type {
-    QueuingStrategy,
-    WritableStreamDefaultController,
-} from "./stream.js";
-import {
-    WritableStream as NativeWritableStream,
-    TransformStream,
-} from "./stream.js";
+import type { Consumable } from "./consumable.js";
 
 export type MaybeConsumable<T> = T | Consumable<T>;
 
-export namespace MaybeConsumable {
-    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 class UnwrapStream<T> extends TransformStream<
-        MaybeConsumable<T>,
-        T
-    > {
-        constructor() {
-            super({
-                transform(chunk, controller) {
-                    MaybeConsumable.tryConsume(chunk, (chunk) => {
-                        controller.enqueue(chunk as T);
-                    });
-                },
-            });
-        }
-    }
-
-    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 MaybeConsumable.tryConsume(chunk, (chunk) =>
-                            sink.write?.(chunk as T, controller),
-                        );
-                    },
-                    abort(reason) {
-                        return sink.abort?.(reason);
-                    },
-                    close() {
-                        return sink.close?.();
-                    },
-                },
-                wrappedStrategy,
-            );
-        }
-    }
-}
+export * as MaybeConsumable from "./maybe-consumable-ns.js";