@yume-chan/stream-extra 0.0.22 → 0.0.24

package/src/distribution.ts

@@ -1,4 +1,6 @@
-import { ConsumableTransformStream } from "./consumable.js";
+import { Consumable } from "./consumable.js";
+import { MaybeConsumable } from "./maybe-consumable.js";
+import { TransformStream } from "./stream.js";
 
 /**
  * Splits or combines buffers to specified size.
@@ -25,7 +27,7 @@ export class BufferCombiner {
      */
     *push(data: Uint8Array): Generator<Uint8Array, void, void> {
         let offset = 0;
-        let available = data.byteLength;
+        let available = data.length;
 
         if (this.#offset !== 0) {
             if (available >= this.#available) {
@@ -77,34 +79,42 @@ export class BufferCombiner {
     }
 }
 
-export class DistributionStream extends ConsumableTransformStream<
-    Uint8Array,
-    Uint8Array
+export class DistributionStream extends TransformStream<
+    MaybeConsumable<Uint8Array>,
+    MaybeConsumable<Uint8Array>
 > {
     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;
+                await MaybeConsumable.tryConsume(chunk, async (chunk) => {
+                    if (combiner) {
+                        for (const buffer of combiner.push(chunk)) {
+                            await Consumable.ReadableStream.enqueue(
+                                controller,
+                                buffer,
+                            );
+                        }
+                    } else {
+                        let offset = 0;
+                        let available = chunk.length;
+                        while (available > 0) {
+                            const end = offset + size;
+                            await Consumable.ReadableStream.enqueue(
+                                controller,
+                                chunk.subarray(offset, end),
+                            );
+                            offset = end;
+                            available -= size;
+                        }
                     }
-                }
+                });
             },
-            async flush(controller) {
+            flush(controller) {
                 if (combiner) {
                     const data = combiner.flush();
                     if (data) {
-                        await controller.enqueue(data);
+                        controller.enqueue(data);
                     }
                 }
             },

package/src/encoding.ts

@@ -0,0 +1,39 @@
+import type { TransformStream } from "./stream.js";
+
+export interface TextDecoderOptions {
+    fatal?: boolean;
+    ignoreBOM?: boolean;
+}
+
+declare class TextDecoderStreamType extends TransformStream<
+    ArrayBufferView | ArrayBuffer,
+    string
+> {
+    constructor(label?: string, options?: TextDecoderOptions);
+
+    readonly encoding: string;
+    readonly fatal: boolean;
+    readonly ignoreBOM: boolean;
+}
+
+declare class TextEncoderStreamType extends TransformStream<
+    string,
+    Uint8Array
+> {
+    constructor();
+
+    readonly encoding: string;
+}
+
+interface GlobalExtension {
+    TextDecoderStream: typeof TextDecoderStreamType;
+    TextEncoderStream: typeof TextEncoderStreamType;
+}
+
+const Global = globalThis as unknown as GlobalExtension;
+
+export const TextDecoderStream = Global.TextDecoderStream;
+export type TextDecoderStream = TextDecoderStreamType;
+
+export const TextEncoderStream = Global.TextEncoderStream;
+export type TextEncoderStream = TextEncoderStreamType;

package/src/index.ts

@@ -2,15 +2,17 @@ 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 "./encoding.js";
 export * from "./inspect.js";
+export * from "./maybe-consumable.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 "./task.js";
 export * from "./wrap-readable.js";
 export * from "./wrap-writable.js";

package/src/maybe-consumable.ts

@@ -0,0 +1,101 @@
+import { Consumable } from "./consumable.js";
+import type {
+    QueuingStrategy,
+    WritableStreamDefaultController,
+} from "./stream.js";
+import {
+    WritableStream as NativeWritableStream,
+    TransformStream,
+} from "./stream.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,
+            );
+        }
+    }
+}

package/src/stream.ts

@@ -1,10 +1,11 @@
-import type { AbortSignal } from "web-streams-polyfill";
-import {
-    ReadableStream as ReadableStreamPolyfill,
-    TransformStream as TransformStreamPolyfill,
-    WritableStream as WritableStreamPolyfill,
-} from "web-streams-polyfill";
-export * from "web-streams-polyfill";
+import type {
+    AbortSignal,
+    ReadableStream as ReadableStreamType,
+    TransformStream as TransformStreamType,
+    WritableStream as WritableStreamType,
+} from "./types.js";
+
+export * from "./types.js";
 
 /** A controller object that allows you to abort one or more DOM requests as and when desired. */
 export interface AbortController {
@@ -16,7 +17,7 @@ export interface AbortController {
     /**
      * Invoking this method will set this object's AbortSignal's aborted flag and signal to any observers that the associated activity is to be aborted.
      */
-    abort(reason?: any): void;
+    abort(reason?: unknown): void;
 }
 
 interface AbortControllerConstructor {
@@ -26,26 +27,20 @@ interface AbortControllerConstructor {
 
 interface GlobalExtension {
     AbortController: AbortControllerConstructor;
-    ReadableStream: typeof ReadableStreamPolyfill;
-    WritableStream: typeof WritableStreamPolyfill;
-    TransformStream: typeof TransformStreamPolyfill;
+    ReadableStream: typeof ReadableStreamType;
+    WritableStream: typeof WritableStreamType;
+    TransformStream: typeof TransformStreamType;
 }
 
-const GLOBAL = globalThis as unknown as GlobalExtension;
-
-export const AbortController = GLOBAL.AbortController;
+const Global = globalThis as unknown as GlobalExtension;
 
-export type ReadableStream<R = any> = ReadableStreamPolyfill<R>;
-export let ReadableStream = ReadableStreamPolyfill;
+export const AbortController = Global.AbortController;
 
-export type WritableStream<W = any> = WritableStreamPolyfill<W>;
-export let WritableStream = WritableStreamPolyfill;
+export type ReadableStream<out T> = ReadableStreamType<T>;
+export const ReadableStream = Global.ReadableStream;
 
-export type TransformStream<I = any, O = any> = TransformStreamPolyfill<I, O>;
-export let TransformStream = TransformStreamPolyfill;
+export type WritableStream<in T> = WritableStreamType<T>;
+export const WritableStream = Global.WritableStream;
 
-if (GLOBAL.ReadableStream && GLOBAL.WritableStream && GLOBAL.TransformStream) {
-    ReadableStream = GLOBAL.ReadableStream;
-    WritableStream = GLOBAL.WritableStream;
-    TransformStream = GLOBAL.TransformStream;
-}
+export type TransformStream<I, O> = TransformStreamType<I, O>;
+export const TransformStream = Global.TransformStream;

package/src/struct-deserialize.ts

@@ -4,11 +4,11 @@ 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<object, PropertyKey, object, unknown>,
 > extends BufferedTransformStream<StructValueType<T>> {
     constructor(struct: T) {
         super((stream) => {
-            return struct.deserialize(stream);
+            return struct.deserialize(stream) as never;
         });
     }
 }

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<object, PropertyKey, object, unknown>,
 > extends TransformStream<T["TInit"], Uint8Array> {
     constructor(struct: T) {
         super({

package/src/task.ts

@@ -0,0 +1,21 @@
+export interface Task {
+    run<T>(callback: () => T): T;
+}
+
+interface Console {
+    createTask(name: string): Task;
+}
+
+interface GlobalExtension {
+    console?: Console;
+}
+
+// `createTask` allows browser DevTools to track the call stack across async boundaries.
+const { console } = globalThis as unknown as GlobalExtension;
+export const createTask: (name: string) => Task =
+    console?.createTask?.bind(console) ??
+    (() => ({
+        run(callback) {
+            return callback();
+        },
+    }));