@yume-chan/stream-extra 0.0.17

package/esm/wrap-readable.js

@@ -0,0 +1,57 @@
+import { ReadableStream } from "./stream.js";
+function getWrappedReadableStream(wrapper, controller) {
+    if ('start' in wrapper) {
+        return wrapper.start(controller);
+    }
+    else if (typeof wrapper === 'function') {
+        return wrapper(controller);
+    }
+    else {
+        // Can't use `wrapper instanceof ReadableStream`
+        // Because we want to be compatible with any ReadableStream-like objects
+        return wrapper;
+    }
+}
+/**
+ * This class has multiple usages:
+ *
+ * 1. Get notified when the stream is cancelled or closed.
+ * 2. Synchronously create a `ReadableStream` by asynchronously return another `ReadableStream`.
+ * 3. Convert native `ReadableStream`s to polyfilled ones so they can `pipe` between.
+ */
+export class WrapReadableStream extends ReadableStream {
+    readable;
+    reader;
+    constructor(wrapper) {
+        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?.();
+                    }
+                }
+                else {
+                    controller.enqueue(result.value);
+                }
+            }
+        });
+    }
+}
+//# sourceMappingURL=wrap-readable.js.map

package/esm/wrap-readable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrap-readable.js","sourceRoot":"","sources":["../src/wrap-readable.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAgE,MAAM,aAAa,CAAC;AAU3G,SAAS,wBAAwB,CAC7B,OAAkF,EAClF,UAA8C;IAE9C,IAAI,OAAO,IAAI,OAAO,EAAE;QACpB,OAAO,OAAO,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;KACpC;SAAM,IAAI,OAAO,OAAO,KAAK,UAAU,EAAE;QACtC,OAAO,OAAO,CAAC,UAAU,CAAC,CAAC;KAC9B;SAAM;QACH,gDAAgD;QAChD,wEAAwE;QACxE,OAAO,OAAO,CAAC;KAClB;AACL,CAAC;AAED;;;;;;GAMG;AACH,MAAM,OAAO,kBAAsB,SAAQ,cAAiB;IACjD,QAAQ,CAAqB;IAE5B,MAAM,CAAkC;IAEhD,YAAmB,OAAkF;QACjG,KAAK,CAAC;YACF,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,EAAE;gBACxB,mEAAmE;gBACnE,uCAAuC;gBACvC,gHAAgH;gBAChH,mCAAmC;gBACnC,MAAM,OAAO,CAAC,OAAO,EAAE,CAAC;gBAExB,IAAI,CAAC,QAAQ,GAAG,MAAM,wBAAwB,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;gBACpE,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,CAAC;YAC5C,CAAC;YACD,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE;gBACrB,MAAM,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;gBACjC,IAAI,QAAQ,IAAI,OAAO,EAAE;oBACrB,MAAM,OAAO,CAAC,MAAM,EAAE,CAAC,MAAM,CAAC,CAAC;iBAClC;YACL,CAAC;YACD,IAAI,EAAE,KAAK,EAAE,UAAU,EAAE,EAAE;gBACvB,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;gBACxC,IAAI,MAAM,CAAC,IAAI,EAAE;oBACb,UAAU,CAAC,KAAK,EAAE,CAAC;oBACnB,IAAI,OAAO,IAAI,OAAO,EAAE;wBACpB,MAAM,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC;qBAC3B;iBACJ;qBAAM;oBACH,UAAU,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;iBACpC;YACL,CAAC;SACJ,CAAC,CAAC;IACP,CAAC;CACJ"}

package/esm/wrap-writable.d.ts

@@ -0,0 +1,13 @@
+import type { ValueOrPromise } from "@yume-chan/struct";
+import { WritableStream } from "./stream.js";
+export declare type WrapWritableStreamStart<T> = () => ValueOrPromise<WritableStream<T>>;
+export interface WritableStreamWrapper<T> {
+    start: WrapWritableStreamStart<T>;
+    close?(): Promise<void>;
+}
+export declare class WrapWritableStream<T> extends WritableStream<T> {
+    writable: WritableStream<T>;
+    private writer;
+    constructor(wrapper: WritableStream<T> | WrapWritableStreamStart<T> | WritableStreamWrapper<T>);
+}
+//# sourceMappingURL=wrap-writable.d.ts.map

package/esm/wrap-writable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrap-writable.d.ts","sourceRoot":"","sources":["../src/wrap-writable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,EAAE,cAAc,EAA+B,MAAM,aAAa,CAAC;AAE1E,oBAAY,uBAAuB,CAAC,CAAC,IAAI,MAAM,cAAc,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC;AAEjF,MAAM,WAAW,qBAAqB,CAAC,CAAC;IACpC,KAAK,EAAE,uBAAuB,CAAC,CAAC,CAAC,CAAC;IAClC,KAAK,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3B;AAgBD,qBAAa,kBAAkB,CAAC,CAAC,CAAE,SAAQ,cAAc,CAAC,CAAC,CAAC;IACjD,QAAQ,EAAG,cAAc,CAAC,CAAC,CAAC,CAAC;IAEpC,OAAO,CAAC,MAAM,CAAkC;gBAE7B,OAAO,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,uBAAuB,CAAC,CAAC,CAAC,GAAG,qBAAqB,CAAC,CAAC,CAAC;CAmCxG"}

package/esm/wrap-writable.js

@@ -0,0 +1,53 @@
+import { WritableStream } from "./stream.js";
+async function getWrappedWritableStream(wrapper) {
+    if ('start' in wrapper) {
+        return await wrapper.start();
+    }
+    else if (typeof wrapper === 'function') {
+        return await wrapper();
+    }
+    else {
+        // Can't use `wrapper instanceof WritableStream`
+        // Because we want to be compatible with any WritableStream-like objects
+        return wrapper;
+    }
+}
+export class WrapWritableStream extends WritableStream {
+    writable;
+    writer;
+    constructor(wrapper) {
+        super({
+            start: async () => {
+                // `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.writable = await getWrappedWritableStream(wrapper);
+                this.writer = this.writable.getWriter();
+            },
+            write: async (chunk) => {
+                // Maintain back pressure
+                await this.writer.ready;
+                await this.writer.write(chunk);
+            },
+            abort: async (reason) => {
+                await this.writer.abort(reason);
+                if ('close' in wrapper) {
+                    await wrapper.close?.();
+                }
+            },
+            close: async () => {
+                // Close the inner stream first.
+                // 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();
+                if ('close' in wrapper) {
+                    await wrapper.close?.();
+                }
+            },
+        });
+    }
+}
+//# sourceMappingURL=wrap-writable.js.map

package/esm/wrap-writable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrap-writable.js","sourceRoot":"","sources":["../src/wrap-writable.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAA+B,MAAM,aAAa,CAAC;AAS1E,KAAK,UAAU,wBAAwB,CACnC,OAAkF;IAElF,IAAI,OAAO,IAAI,OAAO,EAAE;QACpB,OAAO,MAAM,OAAO,CAAC,KAAK,EAAE,CAAC;KAChC;SAAM,IAAI,OAAO,OAAO,KAAK,UAAU,EAAE;QACtC,OAAO,MAAM,OAAO,EAAE,CAAC;KAC1B;SAAM;QACH,gDAAgD;QAChD,wEAAwE;QACxE,OAAO,OAAO,CAAC;KAClB;AACL,CAAC;AAED,MAAM,OAAO,kBAAsB,SAAQ,cAAiB;IACjD,QAAQ,CAAqB;IAE5B,MAAM,CAAkC;IAEhD,YAAmB,OAAkF;QACjG,KAAK,CAAC;YACF,KAAK,EAAE,KAAK,IAAI,EAAE;gBACd,mEAAmE;gBACnE,uCAAuC;gBACvC,gHAAgH;gBAChH,mCAAmC;gBACnC,MAAM,OAAO,CAAC,OAAO,EAAE,CAAC;gBAExB,IAAI,CAAC,QAAQ,GAAG,MAAM,wBAAwB,CAAC,OAAO,CAAC,CAAC;gBACxD,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,CAAC;YAC5C,CAAC;YACD,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE;gBACnB,yBAAyB;gBACzB,MAAM,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC;gBACxB,MAAM,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACnC,CAAC;YACD,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE;gBACpB,MAAM,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;gBAChC,IAAI,OAAO,IAAI,OAAO,EAAE;oBACpB,MAAM,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC;iBAC3B;YACL,CAAC;YACD,KAAK,EAAE,KAAK,IAAI,EAAE;gBACd,gCAAgC;gBAChC,0EAA0E;gBAC1E,yEAAyE;gBACzE,uCAAuC;gBACvC,MAAM,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;gBAC1B,IAAI,OAAO,IAAI,OAAO,EAAE;oBACpB,MAAM,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC;iBAC3B;YACL,CAAC;SACJ,CAAC,CAAC;IACP,CAAC;CACJ"}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@yume-chan/stream-extra",
+  "version": "0.0.17",
+  "description": "Extensions to Web Streams API",
+  "keywords": [
+    "stream",
+    "web-streams-api"
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "Simon Chan",
+    "email": "cnsimonchan@live.com",
+    "url": "https://chensi.moe/blog"
+  },
+  "homepage": "https://github.com/yume-chan/ya-webadb/tree/main/packages/stream-extra#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yume-chan/ya-webadb.git",
+    "directory": "packages/stream-extra"
+  },
+  "bugs": {
+    "url": "https://github.com/yume-chan/ya-webadb/issues"
+  },
+  "type": "module",
+  "main": "esm/index.js",
+  "types": "esm/index.d.ts",
+  "dependencies": {
+    "@yume-chan/async": "^2.2.0",
+    "@yume-chan/struct": "^0.0.17",
+    "tslib": "^2.4.0",
+    "web-streams-polyfill": "^4.0.0-beta.3"
+  },
+  "devDependencies": {
+    "@jest/globals": "^28.1.2",
+    "@yume-chan/ts-package-builder": "^1.0.0",
+    "cross-env": "^7.0.3",
+    "jest": "^28.1.2",
+    "ts-jest": "^28.0.5",
+    "typescript": "^4.7.4"
+  },
+  "scripts": {
+    "build": "tsc -b tsconfig.build.json",
+    "build:watch": "tsc -b tsconfig.build.json",
+    "test": "cross-env NODE_OPTIONS=--experimental-vm-modules jest --coverage"
+  }
+}

package/src/buffered-transform.ts

@@ -0,0 +1,58 @@
+import type { ValueOrPromise } from '@yume-chan/struct';
+import { BufferedReadableStream, BufferedReadableStreamEndedError } from './buffered.js';
+import { PushReadableStream, PushReadableStreamController } from './push-readable.js';
+import { ReadableStream, ReadableWritablePair, WritableStream } from './stream.js';
+
+// TODO: BufferedTransformStream: find better implementation
+export class BufferedTransformStream<T> implements ReadableWritablePair<T, Uint8Array> {
+    private _readable: ReadableStream<T>;
+    public get readable() { return this._readable; }
+
+    private _writable: WritableStream<Uint8Array>;
+    public get writable() { return this._writable; }
+
+    constructor(transform: (stream: BufferedReadableStream) => ValueOrPromise<T>) {
+        // Convert incoming chunks to a `BufferedReadableStream`
+        let sourceStreamController!: PushReadableStreamController<Uint8Array>;
+
+        const buffered = new BufferedReadableStream(new PushReadableStream<Uint8Array>(
+            controller =>
+                sourceStreamController = controller,
+        ));
+
+        this._readable = new ReadableStream<T>({
+            async pull(controller) {
+                try {
+                    const value = await transform(buffered);
+                    controller.enqueue(value);
+                } catch (e) {
+                    // TODO: BufferedTransformStream: The semantic of stream ending is not clear
+                    // If the `transform` started but did not finish, it should really be an error?
+                    // But we can't detect that, unless there is a `peek` method on buffered stream.
+                    if (e instanceof BufferedReadableStreamEndedError) {
+                        controller.close();
+                        return;
+                    }
+                    throw e;
+                }
+            },
+            cancel: (reason) => {
+                // Propagate cancel to the source stream
+                // So future writes will be rejected
+                buffered.cancel(reason);
+            }
+        });
+
+        this._writable = new WritableStream({
+            async write(chunk) {
+                await sourceStreamController.enqueue(chunk);
+            },
+            abort() {
+                sourceStreamController.close();
+            },
+            close() {
+                sourceStreamController.close();
+            },
+        });
+    }
+}

package/src/buffered.ts

@@ -0,0 +1,148 @@
+import { PushReadableStream } from "./push-readable.js";
+import type { ReadableStream, ReadableStreamDefaultReader } from "./stream.js";
+
+export class BufferedReadableStreamEndedError extends Error {
+    public constructor() {
+        super('Stream ended');
+
+        // Fix Error's prototype chain when compiling to ES5
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+
+export class BufferedReadableStream {
+    private buffered: Uint8Array | undefined;
+    private bufferedOffset = 0;
+    private bufferedLength = 0;
+
+    protected readonly stream: ReadableStream<Uint8Array>;
+
+    protected readonly reader: ReadableStreamDefaultReader<Uint8Array>;
+
+    public constructor(stream: ReadableStream<Uint8Array>) {
+        this.stream = stream;
+        this.reader = stream.getReader();
+    }
+
+    private async readSource() {
+        const { done, value } = await this.reader.read();
+        if (done) {
+            throw new BufferedReadableStreamEndedError();
+        }
+        return value;
+    }
+
+    private async readAsync(length: number, initial?: Uint8Array) {
+        let result: Uint8Array;
+        let index: number;
+
+        if (initial) {
+            result = new Uint8Array(length);
+            result.set(initial);
+            index = initial.byteLength;
+            length -= initial.byteLength;
+        } else {
+            const array = await this.readSource();
+            if (array.byteLength === length) {
+                return array;
+            }
+
+            if (array.byteLength > length) {
+                this.buffered = array;
+                this.bufferedOffset = length;
+                this.bufferedLength = array.byteLength - length;
+                return array.subarray(0, length);
+            }
+
+            result = new Uint8Array(length);
+            result.set(array);
+            index = array.byteLength;
+            length -= array.byteLength;
+        }
+
+        while (length > 0) {
+            const array = await this.readSource();
+            if (array.byteLength === length) {
+                result.set(array, index);
+                return result;
+            }
+
+            if (array.byteLength > length) {
+                this.buffered = array;
+                this.bufferedOffset = length;
+                this.bufferedLength = array.byteLength - length;
+                result.set(array.subarray(0, length), index);
+                return result;
+            }
+
+            result.set(array, index);
+            index += array.byteLength;
+            length -= array.byteLength;
+        }
+
+        return result;
+    }
+
+    /**
+     *
+     * @param length
+     * @returns
+     */
+    public read(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;
+                return array.subarray(offset, offset + length);
+            }
+
+            this.buffered = undefined;
+            return this.readAsync(length, array.subarray(offset));
+        }
+
+        return this.readAsync(length);
+    }
+
+    /**
+     * Return a readable stream with unconsumed data (if any) and
+     * all data from the wrapped stream.
+     * @returns A `ReadableStream`
+     */
+    public release(): ReadableStream<Uint8Array> {
+        if (this.buffered) {
+            return new PushReadableStream<Uint8Array>(async controller => {
+                // Put the remaining data back to the stream
+                await controller.enqueue(this.buffered!);
+
+                // Manually pipe the stream
+                while (true) {
+                    try {
+                        const { done, value } = await this.reader.read();
+                        if (done) {
+                            controller.close();
+                            break;
+                        } else {
+                            await controller.enqueue(value);
+                        }
+                    } catch (e) {
+                        controller.error(e);
+                        break;
+                    }
+                }
+            });
+        } else {
+            // Simply release the reader and return the stream
+            this.reader.releaseLock();
+            return this.stream;
+        }
+    }
+
+    public cancel(reason?: any) {
+        return this.reader.cancel(reason);
+    }
+}

package/src/chunk.ts

@@ -0,0 +1,15 @@
+import { TransformStream } from "./stream.js";
+
+export class ChunkStream extends TransformStream<Uint8Array, Uint8Array>{
+    public constructor(size: number) {
+        super({
+            transform(chunk, controller) {
+                for (let start = 0; start < chunk.byteLength;) {
+                    const end = start + size;
+                    controller.enqueue(chunk.subarray(start, end));
+                    start = end;
+                }
+            }
+        });
+    }
+}

package/src/decode-utf8.ts

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

package/src/duplex.ts

@@ -0,0 +1,120 @@
+import { PromiseResolver } from "@yume-chan/async";
+import type { ValueOrPromise } from "@yume-chan/struct";
+import { WritableStream, type ReadableStream, type ReadableStreamDefaultController, type WritableStreamDefaultWriter } from "./stream.js";
+import { WrapReadableStream } from "./wrap-readable.js";
+
+export interface DuplexStreamFactoryOptions {
+    /**
+     * Callback when any `ReadableStream` is cancelled (the user doesn't need any more data),
+     * or `WritableStream` is ended (the user won't produce any more data),
+     * or `DuplexStreamFactory#close` is called.
+     *
+     * Usually you want to let the other peer know that the duplex stream should be clsoed.
+     *
+     * `dispose` will automatically be called after `close` completes,
+     * but if you want to wait another peer for a close confirmation and call
+     * `DuplexStreamFactory#dispose` yourself, you can return `false`
+     * (or a `Promise` that resolves to `false`) to disable the automatic call.
+     */
+    close?: (() => ValueOrPromise<boolean | void>) | undefined;
+
+    /**
+     * Callback when any `ReadableStream` is closed (the other peer doesn't produce any more data),
+     * or `WritableStream` is aborted (the other peer can't receive any more data),
+     * or `DuplexStreamFactory#abort` is called.
+     *
+     * Usually indicates the other peer has closed the duplex stream. You can clean up
+     * any resources you have allocated now.
+     */
+    dispose?: (() => void | Promise<void>) | undefined;
+}
+
+/**
+ * A factory for creating a duplex stream.
+ *
+ * It can create multiple `ReadableStream`s and `WritableStream`s,
+ * 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>[] = [];
+
+    private _writableClosed = false;
+    public get writableClosed() { return this._writableClosed; }
+
+    private _closed = new PromiseResolver<void>();
+    public get closed() { return this._closed.promise; }
+
+    private options: DuplexStreamFactoryOptions;
+
+    public 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;
+            },
+            cancel: async () => {
+                // cancel means the local peer closes the connection first.
+                await this.close();
+            },
+            close: async () => {
+                // stream end means the remote peer closed the connection first.
+                await this.dispose();
+            },
+        });
+    }
+
+    public createWritable(stream: WritableStream<W>): WritableStream<W> {
+        const writer = stream.getWriter();
+        this.writers.push(writer);
+
+        // `WritableStream` has no way to tell if the remote peer has closed the connection.
+        // So it only triggers `close`.
+        return new WritableStream<W>({
+            write: async (chunk) => {
+                await writer.ready;
+                await writer.write(chunk);
+            },
+            abort: async (reason) => {
+                await writer.abort(reason);
+                await this.close();
+            },
+            close: async () => {
+                try { await writer.close(); } catch { }
+                await this.close();
+            },
+        });
+    }
+
+    public async close() {
+        if (this._writableClosed) {
+            return;
+        }
+        this._writableClosed = true;
+
+        // Call `close` first, so it can still write data to `WritableStream`s.
+        if (await this.options.close?.() !== false) {
+            // `close` can return `false` to disable automatic `dispose`.
+            await this.dispose();
+        }
+
+        for (const writer of this.writers) {
+            try { await writer.close(); } catch { }
+        }
+    }
+
+    public async dispose() {
+        this._writableClosed = true;
+        this._closed.resolve();
+
+        for (const controller of this.readableControllers) {
+            try { controller.close(); } catch { }
+        }
+
+        await this.options.dispose?.();
+    }
+}

package/src/gather-string.ts

@@ -0,0 +1,15 @@
+import { WritableStream } from "./stream.js";
+
+export class GatherStringStream extends WritableStream<string>{
+    // PERF: rope (concat strings) is faster than `[].join('')`
+    private _result = '';
+    public get result() { return this._result; }
+
+    public constructor() {
+        super({
+            write: (chunk) => {
+                this._result += chunk;
+            },
+        });
+    }
+}

package/src/index.ts

@@ -0,0 +1,15 @@
+export * from './buffered-transform.js';
+export * from './buffered.js';
+export * from './chunk.js';
+export * from './decode-utf8.js';
+export * from './duplex.js';
+export * from './gather-string.js';
+export * from './inspect.js';
+export * from './pipe-from.js';
+export * from './push-readable.js';
+export * from './split-string.js';
+export * from './stream.js';
+export * from './struct-deserialize.js';
+export * from './struct-serialize.js';
+export * from './wrap-readable.js';
+export * from './wrap-writable.js';

package/src/inspect.ts

@@ -0,0 +1,12 @@
+import { TransformStream } from "./stream.js";
+
+export class InspectStream<T> extends TransformStream<T, T> {
+    constructor(callback: (value: T) => void) {
+        super({
+            transform(chunk, controller) {
+                callback(chunk);
+                controller.enqueue(chunk);
+            }
+        });
+    }
+}