@yume-chan/stream-extra 0.0.20 → 0.0.21

package/src/buffered.ts

@@ -14,19 +14,19 @@ export class BufferedReadableStream implements AsyncExactReadable {
     #bufferedLength = 0;
 
     #position = 0;
-    public get position() {
+    get position() {
         return this.#position;
     }
 
     protected readonly stream: ReadableStream<Uint8Array>;
     protected readonly reader: ReadableStreamDefaultReader<Uint8Array>;
 
-    public constructor(stream: ReadableStream<Uint8Array>) {
+    constructor(stream: ReadableStream<Uint8Array>) {
         this.stream = stream;
         this.reader = stream.getReader();
     }
 
-    private async readSource() {
+    async #readSource() {
         const { done, value } = await this.reader.read();
         if (done) {
             throw new ExactReadableEndedError();
@@ -35,7 +35,7 @@ export class BufferedReadableStream implements AsyncExactReadable {
         return value;
     }
 
-    private async readAsync(length: number, initial?: Uint8Array) {
+    async #readAsync(length: number, initial?: Uint8Array) {
         let result: Uint8Array;
         let index: number;
 
@@ -45,7 +45,7 @@ export class BufferedReadableStream implements AsyncExactReadable {
             index = initial.byteLength;
             length -= initial.byteLength;
         } else {
-            const array = await this.readSource();
+            const array = await this.#readSource();
             if (array.byteLength === length) {
                 return array;
             }
@@ -64,7 +64,7 @@ export class BufferedReadableStream implements AsyncExactReadable {
         }
 
         while (length > 0) {
-            const array = await this.readSource();
+            const array = await this.#readSource();
             if (array.byteLength === length) {
                 result.set(array, index);
                 return result;
@@ -91,7 +91,7 @@ export class BufferedReadableStream implements AsyncExactReadable {
      * @param length
      * @returns
      */
-    public readExactly(length: number): Uint8Array | Promise<Uint8Array> {
+    readExactly(length: number): Uint8Array | Promise<Uint8Array> {
         // PERF: Add a synchronous path for reading from internal buffer
         if (this.#buffered) {
             const array = this.#buffered;
@@ -107,10 +107,10 @@ export class BufferedReadableStream implements AsyncExactReadable {
             this.#buffered = undefined;
             this.#bufferedLength = 0;
             this.#bufferedOffset = 0;
-            return this.readAsync(length, array.subarray(offset));
+            return this.#readAsync(length, array.subarray(offset));
         }
 
-        return this.readAsync(length);
+        return this.#readAsync(length);
     }
 
     /**
@@ -118,7 +118,7 @@ export class BufferedReadableStream implements AsyncExactReadable {
      * all data from the wrapped stream.
      * @returns A `ReadableStream`
      */
-    public release(): ReadableStream<Uint8Array> {
+    release(): ReadableStream<Uint8Array> {
         if (this.#bufferedLength > 0) {
             return new PushReadableStream<Uint8Array>(async (controller) => {
                 // Put the remaining data back to the stream
@@ -147,7 +147,7 @@ export class BufferedReadableStream implements AsyncExactReadable {
         }
     }
 
-    public cancel(reason?: unknown) {
+    cancel(reason?: unknown) {
         return this.reader.cancel(reason);
     }
 }

package/src/concat.ts

@@ -0,0 +1,160 @@
+import { PromiseResolver } from "@yume-chan/async";
+
+import type { ReadableStreamDefaultController } from "./stream.js";
+import { ReadableStream, WritableStream } from "./stream.js";
+
+export interface ConcatStringReadableStream
+    extends ReadableStream<string>,
+        Promise<string> {}
+
+// `TransformStream` only calls its `source.flush` method when its `readable` is being read.
+// If the user want to use the `Promise` interface, the `flush` method will never be called,
+// so the `PromiseResolver` will never be resolved.
+// Thus we need to implement our own `TransformStream` using a `WritableStream` and a `ReadableStream`.
+
+/**
+ * A `TransformStream` that concatenates strings.
+ *
+ * Its `readable` is also a `Promise<string>`, so it's possible to `await` it to get the result.
+ *
+ * ```ts
+ * const result: string = await readable.pipeThrough(new ConcatStringStream());
+ * ```
+ */
+export class ConcatStringStream {
+    // PERF: rope (concat strings) is faster than `[].join('')`
+    #result = "";
+
+    #resolver = new PromiseResolver<string>();
+
+    #writable = new WritableStream<string>({
+        write: (chunk) => {
+            this.#result += chunk;
+        },
+        close: () => {
+            this.#resolver.resolve(this.#result);
+            this.#readableController.enqueue(this.#result);
+            this.#readableController.close();
+        },
+        abort: (reason) => {
+            this.#resolver.reject(reason);
+            this.#readableController.error(reason);
+        },
+    });
+    get writable(): WritableStream<string> {
+        return this.#writable;
+    }
+
+    #readableController!: ReadableStreamDefaultController<string>;
+    #readable = new ReadableStream<string>({
+        start: (controller) => {
+            this.#readableController = controller;
+        },
+    }) as ConcatStringReadableStream;
+    get readable(): ConcatStringReadableStream {
+        return this.#readable;
+    }
+
+    constructor() {
+        void Object.defineProperties(this.#readable, {
+            then: {
+                get: () =>
+                    this.#resolver.promise.then.bind(this.#resolver.promise),
+            },
+            catch: {
+                get: () =>
+                    this.#resolver.promise.catch.bind(this.#resolver.promise),
+            },
+            finally: {
+                get: () =>
+                    this.#resolver.promise.finally.bind(this.#resolver.promise),
+            },
+        });
+    }
+}
+
+export interface ConcatBufferReadableStream
+    extends ReadableStream<Uint8Array>,
+        Promise<Uint8Array> {}
+
+/**
+ * A `TransformStream` that concatenates `Uint8Array`s.
+ *
+ * If you want to decode the result as string,
+ * prefer `.pipeThrough(new DecodeUtf8Stream()).pipeThrough(new ConcatStringStream())`,
+ * than `.pipeThough(new ConcatBufferStream()).pipeThrough(new DecodeUtf8Stream())`,
+ * because concatenating strings is faster than concatenating `Uint8Array`s.
+ */
+export class ConcatBufferStream {
+    #segments: Uint8Array[] = [];
+
+    #resolver = new PromiseResolver<Uint8Array>();
+
+    #writable = new WritableStream<Uint8Array>({
+        write: (chunk) => {
+            this.#segments.push(chunk);
+        },
+        close: () => {
+            let result: Uint8Array;
+            let offset = 0;
+            switch (this.#segments.length) {
+                case 0:
+                    result = new Uint8Array(0);
+                    break;
+                case 1:
+                    result = this.#segments[0]!;
+                    break;
+                default:
+                    result = new Uint8Array(
+                        this.#segments.reduce(
+                            (prev, item) => prev + item.length,
+                            0,
+                        ),
+                    );
+                    for (const segment of this.#segments) {
+                        result.set(segment, offset);
+                        offset += segment.length;
+                    }
+                    break;
+            }
+
+            this.#resolver.resolve(result);
+            this.#readableController.enqueue(result);
+            this.#readableController.close();
+        },
+        abort: (reason) => {
+            this.#resolver.reject(reason);
+            this.#readableController.error(reason);
+        },
+    });
+    get writable(): WritableStream<Uint8Array> {
+        return this.#writable;
+    }
+
+    #readableController!: ReadableStreamDefaultController<Uint8Array>;
+    #readable = new ReadableStream<Uint8Array>({
+        start: (controller) => {
+            this.#readableController = controller;
+        },
+    }) as ConcatBufferReadableStream;
+    get readable(): ConcatBufferReadableStream {
+        return this.#readable;
+    }
+
+    constructor() {
+        void Object.defineProperties(this.#readable, {
+            then: {
+                get: () =>
+                    this.#resolver.promise.then.bind(this.#resolver.promise),
+            },
+            catch: {
+                get: () =>
+                    this.#resolver.promise.catch.bind(this.#resolver.promise),
+            },
+            finally: {
+                get: () =>
+                    this.#resolver.promise.finally.bind(this.#resolver.promise),
+            },
+        });
+    }
+}

package/src/consumable.ts

@@ -29,25 +29,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 +62,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 +70,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 +83,7 @@ export class UnwrapConsumableStream<T> extends TransformStream<
     Consumable<T>,
     T
 > {
-    public constructor() {
+    constructor() {
         super({
             transform(chunk, controller) {
                 controller.enqueue(chunk.value);
@@ -101,18 +101,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,7 +155,7 @@ export class ConsumableReadableStream<T> extends ReadableStream<Consumable<T>> {
                     await source.cancel?.(reason);
                 },
             },
-            wrappedStrategy
+            wrappedStrategy,
         );
     }
 }
@@ -168,18 +168,18 @@ export interface ConsumableWritableStreamSink<T> {
 }
 
 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) {
@@ -210,21 +210,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 +232,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 +254,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 +271,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

@@ -50,22 +50,22 @@ 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> {
+    wrapReadable(readable: ReadableStream<R>): WrapReadableStream<R> {
         return new WrapReadableStream<R>({
             start: (controller) => {
                 this.#readableControllers.push(controller);
@@ -82,7 +82,7 @@ export class DuplexStreamFactory<R, W> {
         });
     }
 
-    public createWritable(stream: WritableStream<W>): WritableStream<W> {
+    createWritable(stream: WritableStream<W>): WritableStream<W> {
         const writer = stream.getWriter();
         this.#writers.push(writer);
 
@@ -104,7 +104,7 @@ export class DuplexStreamFactory<R, W> {
         });
     }
 
-    public async close() {
+    async close() {
         if (this.#writableClosed) {
             return;
         }
@@ -122,7 +122,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,7 +14,7 @@ export interface PushReadableStreamController<T> {
 }
 
 export type PushReadableStreamSource<T> = (
-    controller: PushReadableStreamController<T>
+    controller: PushReadableStreamController<T>,
 ) => void | Promise<void>;
 
 export class PushReadableStream<T> extends ReadableStream<T> {
@@ -25,9 +25,9 @@ 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();
@@ -79,7 +79,7 @@ export class PushReadableStream<T> extends ReadableStream<T> {
                             },
                             (e) => {
                                 controller.error(e);
-                            }
+                            },
                         );
                     }
                 },
@@ -91,7 +91,7 @@ export class PushReadableStream<T> extends ReadableStream<T> {
                     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({