@yume-chan/stream-extra 0.0.18 → 0.0.19

package/esm/wrap-writable.d.ts

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

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

@@ -1 +1 @@
-{"version":3,"file":"wrap-writable.d.ts","sourceRoot":"","sources":["../src/wrap-writable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAExD,OAAO,EAAE,cAAc,EAAoC,MAAM,aAAa,CAAC;AAE/E,MAAM,MAAM,uBAAuB,CAAC,CAAC,IAAI,MAAM,cAAc,CACzD,cAAc,CAAC,CAAC,CAAC,CACpB,CAAC;AAEF,MAAM,WAAW,qBAAqB,CAAC,CAAC;IACpC,KAAK,EAAE,uBAAuB,CAAC,CAAC,CAAC,CAAC;IAClC,KAAK,CAAC,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAClC;AAmBD,qBAAa,kBAAkB,CAAC,CAAC,CAAE,SAAQ,cAAc,CAAC,CAAC,CAAC;IACjD,QAAQ,EAAG,cAAc,CAAC,CAAC,CAAC,CAAC;IAEpC,OAAO,CAAC,MAAM,CAAkC;gBAG5C,OAAO,EACD,cAAc,CAAC,CAAC,CAAC,GACjB,uBAAuB,CAAC,CAAC,CAAC,GAC1B,qBAAqB,CAAC,CAAC,CAAC;CAoCrC"}
+{"version":3,"file":"wrap-writable.d.ts","sourceRoot":"","sources":["../src/wrap-writable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAExD,OAAO,KAAK,EAAE,eAAe,EAA+B,MAAM,aAAa,CAAC;AAChF,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAE7C,MAAM,MAAM,uBAAuB,CAAC,CAAC,IAAI,MAAM,cAAc,CACzD,cAAc,CAAC,CAAC,CAAC,CACpB,CAAC;AAEF,MAAM,WAAW,qBAAqB,CAAC,CAAC;IACpC,KAAK,EAAE,uBAAuB,CAAC,CAAC,CAAC,CAAC;IAClC,KAAK,CAAC,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAClC;AAmBD,qBAAa,kBAAkB,CAAC,CAAC,CAAE,SAAQ,cAAc,CAAC,CAAC,CAAC;IACjD,QAAQ,EAAG,cAAc,CAAC,CAAC,CAAC,CAAC;IAEpC,OAAO,CAAC,MAAM,CAAkC;gBAG5C,OAAO,EACD,cAAc,CAAC,CAAC,CAAC,GACjB,uBAAuB,CAAC,CAAC,CAAC,GAC1B,qBAAqB,CAAC,CAAC,CAAC;IAmC3B,kBAAkB,CAAC,CAAC,EAAE,WAAW,EAAE,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC;CAYlE"}

package/esm/wrap-writable.js

@@ -1,53 +1,63 @@
-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?.();
-                }
-            },
-        });
-    }
-}
+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) => {
+                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?.();
+                }
+            },
+        });
+    }
+    bePipedThroughFrom(transformer) {
+        let promise;
+        return new WrapWritableStream({
+            start: () => {
+                promise = transformer.readable.pipeTo(this);
+                return transformer.writable;
+            },
+            async close() {
+                await promise;
+            },
+        });
+    }
+}
 //# sourceMappingURL=wrap-writable.js.map

package/esm/wrap-writable.js.map

@@ -1 +1 @@
-{"version":3,"file":"wrap-writable.js","sourceRoot":"","sources":["../src/wrap-writable.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAoC,MAAM,aAAa,CAAC;AAW/E,KAAK,UAAU,wBAAwB,CACnC,OAG8B;IAE9B,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,YACI,OAG8B;QAE9B,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"}
+{"version":3,"file":"wrap-writable.js","sourceRoot":"","sources":["../src/wrap-writable.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAW7C,KAAK,UAAU,wBAAwB,CACnC,OAG8B;IAE9B,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,YACI,OAG8B;QAE9B,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,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;IAEM,kBAAkB,CAAI,WAAkC;QAC3D,IAAI,OAAsB,CAAC;QAC3B,OAAO,IAAI,kBAAkB,CAAI;YAC7B,KAAK,EAAE,GAAG,EAAE;gBACR,OAAO,GAAG,WAAW,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;gBAC5C,OAAO,WAAW,CAAC,QAAQ,CAAC;YAChC,CAAC;YACD,KAAK,CAAC,KAAK;gBACP,MAAM,OAAO,CAAC;YAClB,CAAC;SACJ,CAAC,CAAC;IACP,CAAC;CACJ"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yume-chan/stream-extra",
-  "version": "0.0.18",
+  "version": "0.0.19",
   "description": "Extensions to Web Streams API",
   "keywords": [
     "stream",
@@ -26,17 +26,18 @@
   "types": "esm/index.d.ts",
   "dependencies": {
     "@yume-chan/async": "^2.2.0",
-    "@yume-chan/struct": "^0.0.18",
+    "@yume-chan/struct": "^0.0.19",
     "tslib": "^2.4.1",
     "web-streams-polyfill": "^4.0.0-beta.3"
   },
   "devDependencies": {
-    "@jest/globals": "^29.3.1",
+    "@jest/globals": "^29.5.0",
     "@yume-chan/eslint-config": "^1.0.0",
     "@yume-chan/tsconfig": "^1.0.0",
     "cross-env": "^7.0.3",
-    "eslint": "^8.31.0",
-    "jest": "^29.3.1",
+    "eslint": "^8.36.0",
+    "jest": "^29.5.0",
+    "prettier": "^2.8.4",
     "ts-jest": "^29.0.4",
     "typescript": "^4.9.4"
   },
@@ -44,6 +45,6 @@
     "build": "tsc -b tsconfig.build.json",
     "build:watch": "tsc -b tsconfig.build.json",
     "test": "cross-env NODE_OPTIONS=--experimental-vm-modules jest --coverage",
-    "lint": "eslint src/**/*.ts --fix"
+    "lint": "eslint src/**/*.ts --fix && prettier src/**/*.ts --write --tab-width 4"
   }
 }

package/src/buffered-transform.ts

@@ -1,18 +1,13 @@
-import { type ValueOrPromise } from "@yume-chan/struct";
+import type { ValueOrPromise } from "@yume-chan/struct";
 
 import {
     BufferedReadableStream,
     BufferedReadableStreamEndedError,
 } from "./buffered.js";
-import {
-    PushReadableStream,
-    type PushReadableStreamController,
-} from "./push-readable.js";
-import {
-    ReadableStream,
-    WritableStream,
-    type ReadableWritablePair,
-} from "./stream.js";
+import type { PushReadableStreamController } from "./push-readable.js";
+import { PushReadableStream } from "./push-readable.js";
+import type { ReadableWritablePair } from "./stream.js";
+import { ReadableStream, WritableStream } from "./stream.js";
 
 // TODO: BufferedTransformStream: find better implementation
 export class BufferedTransformStream<T>

package/src/buffered.ts

@@ -1,8 +1,5 @@
 import { PushReadableStream } from "./push-readable.js";
-import {
-    type ReadableStream,
-    type ReadableStreamDefaultReader,
-} from "./stream.js";
+import type { ReadableStream, ReadableStreamDefaultReader } from "./stream.js";
 
 export class BufferedReadableStreamEndedError extends Error {
     public constructor() {
@@ -18,8 +15,12 @@ export class BufferedReadableStream {
     private bufferedOffset = 0;
     private bufferedLength = 0;
 
-    protected readonly stream: ReadableStream<Uint8Array>;
+    private _position = 0;
+    public get position() {
+        return this._position;
+    }
 
+    protected readonly stream: ReadableStream<Uint8Array>;
     protected readonly reader: ReadableStreamDefaultReader<Uint8Array>;
 
     public constructor(stream: ReadableStream<Uint8Array>) {
@@ -32,6 +33,7 @@ export class BufferedReadableStream {
         if (done) {
             throw new BufferedReadableStreamEndedError();
         }
+        this._position += value.byteLength;
         return value;
     }
 

package/src/consumable.ts

@@ -0,0 +1,281 @@
+import { PromiseResolver } from "@yume-chan/async";
+
+import type { QueuingStrategy, WritableStreamDefaultWriter } from "./stream.js";
+import { ReadableStream, TransformStream, WritableStream } from "./stream.js";
+
+interface Task {
+    run<T>(callback: () => T): T;
+}
+
+interface Console {
+    createTask(name: string): Task;
+}
+
+interface GlobalEx {
+    console: Console;
+}
+
+// `createTask` allows browser DevTools to track the call stack across async boundaries.
+const { console } = globalThis as unknown as GlobalEx;
+const createTask: Console["createTask"] =
+    console.createTask?.bind(console) ??
+    (() => ({
+        run(callback) {
+            return callback();
+        },
+    }));
+
+export class Consumable<T> {
+    private readonly task: Task;
+    private readonly resolver: PromiseResolver<void>;
+
+    public readonly value: T;
+    public readonly consumed: Promise<void>;
+
+    public constructor(value: T) {
+        this.task = createTask("Consumable");
+        this.value = value;
+        this.resolver = new PromiseResolver<void>();
+        this.consumed = this.resolver.promise;
+    }
+
+    public consume() {
+        this.resolver.resolve();
+    }
+
+    public error(error: any) {
+        this.resolver.reject(error);
+    }
+
+    public 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));
+            this.consume();
+            return result;
+        } catch (e) {
+            this.resolver.reject(e);
+            throw e;
+        }
+    }
+}
+
+async function enqueue<T>(
+    controller: { enqueue: (chunk: Consumable<T>) => void },
+    chunk: T
+) {
+    const output = new Consumable(chunk);
+    controller.enqueue(output);
+    await output.consumed;
+}
+
+export class WrapConsumableStream<T> extends TransformStream<T, Consumable<T>> {
+    public constructor() {
+        super({
+            async transform(chunk, controller) {
+                await enqueue(controller, chunk);
+            },
+        });
+    }
+}
+
+export class UnwrapConsumableStream<T> extends TransformStream<
+    Consumable<T>,
+    T
+> {
+    public constructor() {
+        super({
+            transform(chunk, controller) {
+                controller.enqueue(chunk.value);
+                chunk.consume();
+            },
+        });
+    }
+}
+
+export interface ConsumableReadableStreamController<T> {
+    enqueue(chunk: T): Promise<void>;
+    close(): void;
+    error(reason: any): void;
+}
+
+export interface ConsumableReadableStreamSource<T> {
+    start?(
+        controller: ConsumableReadableStreamController<T>
+    ): void | PromiseLike<void>;
+    pull?(
+        controller: ConsumableReadableStreamController<T>
+    ): void | PromiseLike<void>;
+    cancel?(reason: any): void | PromiseLike<void>;
+}
+
+export class ConsumableReadableStream<T> extends ReadableStream<Consumable<T>> {
+    public constructor(
+        source: ConsumableReadableStreamSource<T>,
+        strategy?: QueuingStrategy<T>
+    ) {
+        let wrappedController:
+            | ConsumableReadableStreamController<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 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 interface ConsumableWritableStreamSink<T> {
+    start?(): void | PromiseLike<void>;
+    write?(chunk: T): 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>(
+        writer: WritableStreamDefaultWriter<Consumable<T>>,
+        value: T
+    ) {
+        const consumable = new Consumable(value);
+        await writer.write(consumable);
+        await consumable.consumed;
+    }
+
+    public constructor(
+        sink: ConsumableWritableStreamSink<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.value);
+                };
+            }
+        }
+
+        super(
+            {
+                start() {
+                    return sink.start?.();
+                },
+                async write(chunk) {
+                    await chunk.tryConsume((value) => sink.write?.(value));
+                    chunk.consume();
+                },
+                abort(reason) {
+                    return sink.abort?.(reason);
+                },
+                close() {
+                    return sink.close?.();
+                },
+            },
+            wrappedStrategy
+        );
+    }
+}
+
+export interface ConsumableTransformer<I, O> {
+    start?(
+        controller: ConsumableReadableStreamController<O>
+    ): void | PromiseLike<void>;
+    transform?(
+        chunk: I,
+        controller: ConsumableReadableStreamController<O>
+    ): void | PromiseLike<void>;
+    flush?(
+        controller: ConsumableReadableStreamController<O>
+    ): void | PromiseLike<void>;
+}
+
+export class ConsumableTransformStream<I, O> extends TransformStream<
+    Consumable<I>,
+    Consumable<O>
+> {
+    public constructor(transformer: ConsumableTransformer<I, O>) {
+        let wrappedController:
+            | ConsumableReadableStreamController<O>
+            | undefined;
+
+        super({
+            async start(controller) {
+                wrappedController = {
+                    async enqueue(chunk) {
+                        await enqueue(controller, chunk);
+                    },
+                    close() {
+                        controller.terminate();
+                    },
+                    error(reason) {
+                        controller.error(reason);
+                    },
+                };
+
+                await transformer.start?.(wrappedController);
+            },
+            async transform(chunk) {
+                await chunk.tryConsume((value) =>
+                    transformer.transform?.(value, wrappedController!)
+                );
+                chunk.consume();
+            },
+            async flush() {
+                await transformer.flush?.(wrappedController!);
+            },
+        });
+    }
+}
+
+export class ConsumableInspectStream<T> extends TransformStream<
+    Consumable<T>,
+    Consumable<T>
+> {
+    public constructor(callback: (value: T) => void) {
+        super({
+            transform(chunk, controller) {
+                callback(chunk.value);
+                controller.enqueue(chunk);
+            },
+        });
+    }
+}

package/src/distribution.ts

@@ -0,0 +1,113 @@
+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;
+
+    public constructor(size: number) {
+        this._capacity = size;
+        this._buffer = new Uint8Array(size);
+        this._offset = 0;
+        this._available = size;
+    }
+
+    /**
+     * Pushes data to the combiner.
+     * @param data The input data to be split or combined.
+     * @returns
+     * 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> {
+        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
+                );
+                offset += this._available;
+                available -= this._available;
+
+                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;
+                return;
+            }
+        }
+
+        while (available >= this._capacity) {
+            const end = offset + this._capacity;
+            yield data.subarray(offset, end);
+            offset = end;
+            available -= this._capacity;
+        }
+
+        if (available > 0) {
+            this._buffer.set(data.subarray(offset), this._offset);
+            this._offset += available;
+            this._available -= available;
+        }
+    }
+
+    public flush(): Uint8Array | undefined {
+        if (this._offset === 0) {
+            return undefined;
+        }
+
+        const output = this._buffer.subarray(0, this._offset);
+        this._offset = 0;
+        this._available = this._capacity;
+        return output;
+    }
+}
+
+export class DistributionStream extends ConsumableTransformStream<
+    Uint8Array,
+    Uint8Array
+> {
+    public constructor(size: number, combine = false) {
+        const combiner = combine ? new BufferCombiner(size) : undefined;
+        super({
+            async transform(chunk, controller) {
+                if (combiner) {
+                    for (const buffer of combiner.push(chunk)) {
+                        await controller.enqueue(buffer);
+                    }
+                } else {
+                    let offset = 0;
+                    let available = chunk.byteLength;
+                    while (available > 0) {
+                        const end = offset + size;
+                        await controller.enqueue(chunk.subarray(offset, end));
+                        offset = end;
+                        available -= size;
+                    }
+                }
+            },
+            async flush(controller) {
+                if (combiner) {
+                    const data = combiner.flush();
+                    if (data) {
+                        await controller.enqueue(data);
+                    }
+                }
+            },
+        });
+    }
+}