@yume-chan/stream-extra 0.0.19 → 0.0.21

package/src/distribution.ts

@@ -4,16 +4,16 @@ import { ConsumableTransformStream } from "./consumable.js";
  * Splits or combines buffers to specified size.
  */
 export class BufferCombiner {
-    private _capacity: number;
-    private readonly _buffer: Uint8Array;
-    private _offset: number;
-    private _available: number;
+    #capacity: number;
+    readonly #buffer: Uint8Array;
+    #offset: number;
+    #available: number;
 
-    public constructor(size: number) {
-        this._capacity = size;
-        this._buffer = new Uint8Array(size);
-        this._offset = 0;
-        this._available = size;
+    constructor(size: number) {
+        this.#capacity = size;
+        this.#buffer = new Uint8Array(size);
+        this.#offset = 0;
+        this.#available = size;
     }
 
     /**
@@ -23,56 +23,56 @@ 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;
 
-        if (this._offset !== 0) {
-            if (available >= this._available) {
-                this._buffer.set(
-                    data.subarray(0, this._available),
-                    this._offset
+        if (this.#offset !== 0) {
+            if (available >= this.#available) {
+                this.#buffer.set(
+                    data.subarray(0, this.#available),
+                    this.#offset,
                 );
-                offset += this._available;
-                available -= this._available;
+                offset += this.#available;
+                available -= this.#available;
 
-                yield this._buffer;
-                this._offset = 0;
-                this._available = this._capacity;
+                yield this.#buffer;
+                this.#offset = 0;
+                this.#available = this.#capacity;
 
                 if (available === 0) {
                     return;
                 }
             } else {
-                this._buffer.set(data, this._offset);
-                this._offset += available;
-                this._available -= available;
+                this.#buffer.set(data, this.#offset);
+                this.#offset += available;
+                this.#available -= available;
                 return;
             }
         }
 
-        while (available >= this._capacity) {
-            const end = offset + this._capacity;
+        while (available >= this.#capacity) {
+            const end = offset + this.#capacity;
             yield data.subarray(offset, end);
             offset = end;
-            available -= this._capacity;
+            available -= this.#capacity;
         }
 
         if (available > 0) {
-            this._buffer.set(data.subarray(offset), this._offset);
-            this._offset += available;
-            this._available -= available;
+            this.#buffer.set(data.subarray(offset), this.#offset);
+            this.#offset += available;
+            this.#available -= available;
         }
     }
 
-    public flush(): Uint8Array | undefined {
-        if (this._offset === 0) {
+    flush(): Uint8Array | undefined {
+        if (this.#offset === 0) {
             return undefined;
         }
 
-        const output = this._buffer.subarray(0, this._offset);
-        this._offset = 0;
-        this._available = this._capacity;
+        const output = this.#buffer.subarray(0, this.#offset);
+        this.#offset = 0;
+        this.#available = this.#capacity;
         return output;
     }
 }
@@ -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

@@ -46,29 +46,29 @@ export interface DuplexStreamFactoryOptions {
  * when any of them is closed, all other streams will be closed as well.
  */
 export class DuplexStreamFactory<R, W> {
-    private readableControllers: ReadableStreamDefaultController<R>[] = [];
-    private writers: WritableStreamDefaultWriter<W>[] = [];
+    #readableControllers: ReadableStreamDefaultController<R>[] = [];
+    #writers: WritableStreamDefaultWriter<W>[] = [];
 
-    private _writableClosed = false;
-    public get writableClosed() {
-        return this._writableClosed;
+    #writableClosed = false;
+    get writableClosed() {
+        return this.#writableClosed;
     }
 
-    private _closed = new PromiseResolver<void>();
-    public get closed() {
-        return this._closed.promise;
+    #closed = new PromiseResolver<void>();
+    get closed() {
+        return this.#closed.promise;
     }
 
-    private options: DuplexStreamFactoryOptions;
+    readonly #options: DuplexStreamFactoryOptions;
 
-    public constructor(options?: DuplexStreamFactoryOptions) {
-        this.options = options ?? {};
+    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);
+                this.#readableControllers.push(controller);
                 return readable;
             },
             cancel: async () => {
@@ -82,9 +82,9 @@ 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);
+        this.#writers.push(writer);
 
         // `WritableStream` has no way to tell if the remote peer has closed the connection.
         // So it only triggers `close`.
@@ -97,34 +97,36 @@ export class DuplexStreamFactory<R, W> {
                 await this.close();
             },
             close: async () => {
+                // NOOP: the writer is already closed
                 await writer.close().catch(NOOP);
                 await this.close();
             },
         });
     }
 
-    public async close() {
-        if (this._writableClosed) {
+    async close() {
+        if (this.#writableClosed) {
             return;
         }
-        this._writableClosed = true;
+        this.#writableClosed = true;
 
         // Call `close` first, so it can still write data to `WritableStream`s.
-        if ((await this.options.close?.()) !== false) {
+        if ((await this.#options.close?.()) !== false) {
             // `close` can return `false` to disable automatic `dispose`.
             await this.dispose();
         }
 
-        for (const writer of this.writers) {
-            await writer.close().catch(NOOP);
+        for (const writer of this.#writers) {
+            // NOOP: the writer is already closed
+            writer.close().catch(NOOP);
         }
     }
 
-    public async dispose() {
-        this._writableClosed = true;
-        this._closed.resolve();
+    async dispose() {
+        this.#writableClosed = true;
+        this.#closed.resolve();
 
-        for (const controller of this.readableControllers) {
+        for (const controller of this.#readableControllers) {
             try {
                 controller.close();
             } catch {
@@ -132,6 +134,6 @@ export class DuplexStreamFactory<R, W> {
             }
         }
 
-        await this.options.dispose?.();
+        await this.#options.dispose?.();
     }
 }

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,24 +25,24 @@ 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 canceled = new AbortController();
+        const abortController = new AbortController();
 
         super(
             {
                 start: (controller) => {
                     const result = source({
-                        abortSignal: canceled.signal,
+                        abortSignal: abortController.signal,
                         async enqueue(chunk) {
-                            if (canceled.signal.aborted) {
+                            if (abortController.signal.aborted) {
                                 // If the stream is already cancelled,
                                 // throw immediately.
                                 throw (
-                                    canceled.signal.reason ??
+                                    abortController.signal.reason ??
                                     new Error("Aborted")
                                 );
                             }
@@ -71,11 +71,15 @@ export class PushReadableStream<T> extends ReadableStream<T> {
                     if (result && "then" in result) {
                         result.then(
                             () => {
-                                controller.close();
+                                try {
+                                    controller.close();
+                                } catch (e) {
+                                    // controller already closed
+                                }
                             },
                             (e) => {
                                 controller.error(e);
-                            }
+                            },
                         );
                     }
                 },
@@ -83,11 +87,11 @@ export class PushReadableStream<T> extends ReadableStream<T> {
                     waterMarkLow?.resolve();
                 },
                 cancel: (reason) => {
-                    canceled.abort(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

@@ -7,7 +7,7 @@ import type {
 import { ReadableStream } from "./stream.js";
 
 export type WrapReadableStreamStart<T> = (
-    controller: ReadableStreamDefaultController<T>
+    controller: ReadableStreamDefaultController<T>,
 ) => ValueOrPromise<ReadableStream<T>>;
 
 export interface ReadableStreamWrapper<T> {
@@ -21,7 +21,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,15 +42,15 @@ 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>;
 
-    private reader!: ReadableStreamDefaultReader<T>;
+    #reader!: ReadableStreamDefaultReader<T>;
 
-    public constructor(
+    constructor(
         wrapper:
             | ReadableStream<T>
             | WrapReadableStreamStart<T>
-            | ReadableStreamWrapper<T>
+            | ReadableStreamWrapper<T>,
     ) {
         super({
             start: async (controller) => {
@@ -62,18 +62,18 @@ export class WrapReadableStream<T> extends ReadableStream<T> {
 
                 this.readable = await getWrappedReadableStream(
                     wrapper,
-                    controller
+                    controller,
                 );
-                this.reader = this.readable.getReader();
+                this.#reader = this.readable.getReader();
             },
             cancel: async (reason) => {
-                await this.reader.cancel(reason);
+                await this.#reader.cancel(reason);
                 if ("cancel" in wrapper) {
                     await wrapper.cancel?.(reason);
                 }
             },
             pull: async (controller) => {
-                const result = await this.reader.read();
+                const result = await this.#reader.read();
                 if (result.done) {
                     controller.close();
                     if ("close" in wrapper) {

package/src/wrap-writable.ts

@@ -16,7 +16,7 @@ async function getWrappedWritableStream<T>(
     wrapper:
         | WritableStream<T>
         | WrapWritableStreamStart<T>
-        | WritableStreamWrapper<T>
+        | WritableStreamWrapper<T>,
 ) {
     if ("start" in wrapper) {
         return await wrapper.start();
@@ -30,15 +30,15 @@ async function getWrappedWritableStream<T>(
 }
 
 export class WrapWritableStream<T> extends WritableStream<T> {
-    public writable!: WritableStream<T>;
+    writable!: WritableStream<T>;
 
-    private writer!: WritableStreamDefaultWriter<T>;
+    #writer!: WritableStreamDefaultWriter<T>;
 
-    public constructor(
+    constructor(
         wrapper:
             | WritableStream<T>
             | WrapWritableStreamStart<T>
-            | WritableStreamWrapper<T>
+            | WritableStreamWrapper<T>,
     ) {
         super({
             start: async () => {
@@ -49,13 +49,13 @@ export class WrapWritableStream<T> extends WritableStream<T> {
                 await Promise.resolve();
 
                 this.writable = await getWrappedWritableStream(wrapper);
-                this.writer = this.writable.getWriter();
+                this.#writer = this.writable.getWriter();
             },
             write: async (chunk) => {
-                await this.writer.write(chunk);
+                await this.#writer.write(chunk);
             },
             abort: async (reason) => {
-                await this.writer.abort(reason);
+                await this.#writer.abort(reason);
                 if ("close" in wrapper) {
                     await wrapper.close?.();
                 }
@@ -65,7 +65,7 @@ export class WrapWritableStream<T> extends WritableStream<T> {
                 // 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();
+                await this.#writer.close();
                 if ("close" in wrapper) {
                     await wrapper.close?.();
                 }
@@ -73,7 +73,7 @@ export class WrapWritableStream<T> extends WritableStream<T> {
         });
     }
 
-    public bePipedThroughFrom<U>(transformer: TransformStream<U, T>) {
+    bePipedThroughFrom<U>(transformer: TransformStream<U, T>) {
         let promise: Promise<void>;
         return new WrapWritableStream<U>({
             start: () => {

package/tsconfig.build.json

@@ -1,3 +1,8 @@
 {
-    "extends": "./node_modules/@yume-chan/tsconfig/tsconfig.base.json"
+    "extends": "./node_modules/@yume-chan/tsconfig/tsconfig.base.json",
+    "references": [
+        {
+            "path": "../struct/tsconfig.build.json"
+        }
+    ]
 }