@gjsify/web-streams 0.3.21 → 0.4.3

package/src/register/queuing.ts

@@ -1,10 +0,0 @@
-// Registers: ByteLengthQueuingStrategy, CountQueuingStrategy
-
-import { ByteLengthQueuingStrategy, CountQueuingStrategy } from '../index.js';
-
-if (typeof globalThis.ByteLengthQueuingStrategy === 'undefined') {
-  (globalThis as any).ByteLengthQueuingStrategy = ByteLengthQueuingStrategy;
-}
-if (typeof globalThis.CountQueuingStrategy === 'undefined') {
-  (globalThis as any).CountQueuingStrategy = CountQueuingStrategy;
-}

package/src/register/readable.ts

@@ -1,16 +0,0 @@
-// Registers: ReadableStream
-
-import { ReadableStream } from '../index.js';
-
-function isNativeStreamUsable(Ctor: unknown, method: string): boolean {
-  try {
-    if (typeof Ctor !== 'function') return false;
-    return typeof (Ctor as any).prototype[method] === 'function';
-  } catch {
-    return false;
-  }
-}
-
-if (!isNativeStreamUsable(globalThis.ReadableStream, 'getReader')) {
-  (globalThis as any).ReadableStream = ReadableStream;
-}

package/src/register/text-streams.ts

@@ -1,10 +0,0 @@
-// Registers: TextEncoderStream, TextDecoderStream
-
-import { TextEncoderStream, TextDecoderStream } from '../index.js';
-
-if (typeof globalThis.TextEncoderStream === 'undefined') {
-  (globalThis as any).TextEncoderStream = TextEncoderStream;
-}
-if (typeof globalThis.TextDecoderStream === 'undefined') {
-  (globalThis as any).TextDecoderStream = TextDecoderStream;
-}

package/src/register/transform.ts

@@ -1,16 +0,0 @@
-// Registers: TransformStream
-
-import { TransformStream } from '../index.js';
-
-function isNativeStreamUsable(Ctor: unknown, method: string): boolean {
-  try {
-    if (typeof Ctor !== 'function') return false;
-    return typeof (Ctor as any).prototype[method] === 'function';
-  } catch {
-    return false;
-  }
-}
-
-if (!isNativeStreamUsable(globalThis.TransformStream, 'readable')) {
-  (globalThis as any).TransformStream = TransformStream;
-}

package/src/register/writable.ts

@@ -1,16 +0,0 @@
-// Registers: WritableStream
-
-import { WritableStream } from '../index.js';
-
-function isNativeStreamUsable(Ctor: unknown, method: string): boolean {
-  try {
-    if (typeof Ctor !== 'function') return false;
-    return typeof (Ctor as any).prototype[method] === 'function';
-  } catch {
-    return false;
-  }
-}
-
-if (!isNativeStreamUsable(globalThis.WritableStream, 'getWriter')) {
-  (globalThis as any).WritableStream = WritableStream;
-}

package/src/register.ts

@@ -1,8 +0,0 @@
-// Catch-all side-effect module: registers ALL WHATWG Stream globals.
-// Prefer granular imports when only specific streams are needed.
-
-import './register/readable.js';
-import './register/writable.js';
-import './register/transform.js';
-import './register/text-streams.js';
-import './register/queuing.js';

package/src/test.browser.mts

@@ -1,114 +0,0 @@
-import { run, describe, it, expect } from '@gjsify/unit';
-
-run({
-    async StreamsTest() {
-        await describe('ReadableStream', async () => {
-            await it('reads enqueued chunks', async () => {
-                const rs = new ReadableStream({
-                    start(ctrl) { ctrl.enqueue('a'); ctrl.enqueue('b'); ctrl.close(); },
-                });
-                const reader = rs.getReader();
-                expect((await reader.read()).value).toBe('a');
-                expect((await reader.read()).value).toBe('b');
-                expect((await reader.read()).done).toBe(true);
-            });
-
-            await it('supports async iteration', async () => {
-                const rs = new ReadableStream({
-                    start(ctrl) { ctrl.enqueue(1); ctrl.enqueue(2); ctrl.close(); },
-                });
-                const values: number[] = [];
-                for await (const v of rs) values.push(v);
-                expect(values).toStrictEqual([1, 2]);
-            });
-
-            await it('tee() creates two independent streams', async () => {
-                const rs = new ReadableStream({
-                    start(ctrl) { ctrl.enqueue('x'); ctrl.close(); },
-                });
-                const [a, b] = rs.tee();
-                expect((await a.getReader().read()).value).toBe('x');
-                expect((await b.getReader().read()).value).toBe('x');
-            });
-
-            await it('pipeTo() transfers all chunks', async () => {
-                const received: number[] = [];
-                const rs = new ReadableStream({
-                    start(ctrl) { ctrl.enqueue(1); ctrl.enqueue(2); ctrl.close(); },
-                });
-                const ws = new WritableStream({ write(c) { received.push(c); } });
-                await rs.pipeTo(ws);
-                expect(received).toStrictEqual([1, 2]);
-            });
-        });
-
-        await describe('WritableStream', async () => {
-            await it('writes chunks in order', async () => {
-                const written: string[] = [];
-                const ws = new WritableStream({ write(chunk) { written.push(chunk); } });
-                const writer = ws.getWriter();
-                await writer.write('a');
-                await writer.write('b');
-                await writer.close();
-                expect(written).toStrictEqual(['a', 'b']);
-            });
-
-            await it('abort() rejects pending writes', async () => {
-                const ws = new WritableStream();
-                const writer = ws.getWriter();
-                writer.abort(new Error('aborted'));
-                let threw = false;
-                try { await writer.write('x'); } catch (_) { threw = true; }
-                expect(threw).toBe(true);
-            });
-        });
-
-        await describe('TransformStream', async () => {
-            await it('transforms chunks', async () => {
-                const ts = new TransformStream<string, string>({
-                    transform(chunk, ctrl) { ctrl.enqueue(chunk.toUpperCase()); },
-                });
-                const writer = ts.writable.getWriter();
-                writer.write('hello');
-                writer.close();
-                expect(await new Response(ts.readable).text()).toBe('HELLO');
-            });
-
-            await it('passthrough when no transform defined', async () => {
-                const ts = new TransformStream<string, string>();
-                const writer = ts.writable.getWriter();
-                writer.write('pass');
-                writer.close();
-                expect(await new Response(ts.readable).text()).toBe('pass');
-            });
-        });
-
-        await describe('TextEncoderStream / TextDecoderStream', async () => {
-            await it('round-trips UTF-8 text', async () => {
-                const enc = new TextEncoderStream();
-                const dec = new TextDecoderStream();
-                enc.readable.pipeTo(dec.writable);
-                const writer = enc.writable.getWriter();
-                writer.write('héllo wörld');
-                writer.close();
-                expect(await new Response(dec.readable).text()).toBe('héllo wörld');
-            });
-        });
-
-        await describe('ByteLengthQueuingStrategy', async () => {
-            await it('size() returns byteLength', async () => {
-                const s = new ByteLengthQueuingStrategy({ highWaterMark: 1024 });
-                expect(s.highWaterMark).toBe(1024);
-                expect(s.size(new Uint8Array(16))).toBe(16);
-            });
-        });
-
-        await describe('CountQueuingStrategy', async () => {
-            await it('size() always returns 1', async () => {
-                const s = new CountQueuingStrategy({ highWaterMark: 4 });
-                expect(s.highWaterMark).toBe(4);
-                expect(s.size()).toBe(1);
-            });
-        });
-    },
-});

package/src/test.mts

@@ -1,6 +0,0 @@
-
-import { run } from '@gjsify/unit';
-
-import testSuite from './index.spec.js';
-
-run({ testSuite });

package/src/text-decoder-stream.ts

@@ -1,183 +0,0 @@
-// WHATWG TextDecoderStream for GJS
-// Reference: refs/deno/ext/web/08_text_encoding.js (lines 299–412)
-// Copyright (c) 2018-2026 the Deno authors. MIT license.
-// Reimplemented for GJS — pure TypeScript, no native bindings.
-//
-// GJS's TextDecoder does not support the `stream` option, so we manually
-// buffer incomplete multi-byte UTF-8 sequences across chunks.
-
-import { TransformStream } from './transform-stream.js';
-
-/** Check if TextDecoder supports the `stream` option */
-function hasStreamingSupport(): boolean {
-  try {
-    const td = new TextDecoder();
-    td.decode(new Uint8Array([0xC3]), { stream: true });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-const supportsStreaming = hasStreamingSupport();
-
-/**
- * For UTF-8 without streaming TextDecoder support:
- * Determine how many bytes at the end of `buf` form an incomplete
- * multi-byte sequence. Returns 0 if the buffer ends on a complete character.
- */
-function incompleteUtf8Tail(buf: Uint8Array): number {
-  const len = buf.length;
-  if (len === 0) return 0;
-
-  // Check last byte: is it a continuation byte or a start byte?
-  // Start bytes:
-  //   0xxxxxxx (0x00-0x7F) — single byte, complete
-  //   110xxxxx (0xC0-0xDF) — starts 2-byte sequence
-  //   1110xxxx (0xE0-0xEF) — starts 3-byte sequence
-  //   11110xxx (0xF0-0xF7) — starts 4-byte sequence
-  // Continuation: 10xxxxxx (0x80-0xBF)
-
-  // Scan back up to 3 bytes to find the start of the last multi-byte sequence
-  for (let i = 1; i <= Math.min(3, len); i++) {
-    const b = buf[len - i];
-    if ((b & 0x80) === 0) {
-      // ASCII byte — everything before is complete, this byte is complete
-      return 0;
-    }
-    if ((b & 0xC0) !== 0x80) {
-      // This is a start byte
-      let expectedLen: number;
-      if ((b & 0xE0) === 0xC0) expectedLen = 2;
-      else if ((b & 0xF0) === 0xE0) expectedLen = 3;
-      else if ((b & 0xF8) === 0xF0) expectedLen = 4;
-      else return 0; // Invalid start byte, treat as complete
-
-      if (i < expectedLen) {
-        // We have fewer bytes than the sequence needs — incomplete
-        return i;
-      }
-      // Sequence is complete
-      return 0;
-    }
-    // Continuation byte — keep scanning back
-  }
-  // If we scanned back 3 continuation bytes without finding a start byte,
-  // something is wrong; treat as complete to avoid infinite buffering
-  return 0;
-}
-
-/**
- * TextDecoderStream decodes a stream of bytes into strings.
- *
- * Uses TextDecoder with `stream: true` when available (Node.js, browsers).
- * On GJS where `stream` option is not supported, manually buffers incomplete
- * multi-byte UTF-8 sequences across chunks.
- */
-export class TextDecoderStream {
-  #decoder: TextDecoder;
-  #transform: TransformStream;
-
-  constructor(label?: string, options?: TextDecoderOptions) {
-    this.#decoder = new TextDecoder(label, options);
-
-    if (supportsStreaming) {
-      // Native streaming support (Node.js, modern browsers)
-      this.#transform = new TransformStream({
-        transform: (chunk, controller) => {
-          const bytes = toUint8Array(chunk);
-          const decoded = this.#decoder.decode(bytes, { stream: true });
-          if (decoded) {
-            controller.enqueue(decoded);
-          }
-        },
-        flush: (controller) => {
-          const final = this.#decoder.decode();
-          if (final) {
-            controller.enqueue(final);
-          }
-        },
-        cancel: () => {
-          this.#decoder.decode();
-        },
-      });
-    } else {
-      // GJS fallback: manually buffer incomplete UTF-8 sequences
-      let pendingBytes = new Uint8Array(0);
-
-      this.#transform = new TransformStream({
-        transform: (chunk, controller) => {
-          const incoming = toUint8Array(chunk);
-
-          // Merge pending bytes with new data
-          let combined: Uint8Array;
-          if (pendingBytes.length > 0) {
-            combined = new Uint8Array(pendingBytes.length + incoming.length);
-            combined.set(pendingBytes, 0);
-            combined.set(incoming, pendingBytes.length);
-          } else {
-            combined = incoming;
-          }
-
-          // Check for incomplete multi-byte sequence at the end
-          const tail = incompleteUtf8Tail(combined);
-          let decodable: Uint8Array;
-          if (tail > 0) {
-            decodable = combined.slice(0, combined.length - tail);
-            pendingBytes = combined.slice(combined.length - tail);
-          } else {
-            decodable = combined;
-            pendingBytes = new Uint8Array(0);
-          }
-
-          if (decodable.length > 0) {
-            const decoded = this.#decoder.decode(decodable);
-            if (decoded) {
-              controller.enqueue(decoded);
-            }
-          }
-        },
-        flush: (controller) => {
-          if (pendingBytes.length > 0) {
-            // Decode remaining bytes (may produce replacement characters)
-            const decoded = this.#decoder.decode(pendingBytes);
-            if (decoded) {
-              controller.enqueue(decoded);
-            }
-            pendingBytes = new Uint8Array(0);
-          }
-        },
-        cancel: () => {
-          pendingBytes = new Uint8Array(0);
-        },
-      });
-    }
-  }
-
-  get encoding(): string {
-    return this.#decoder.encoding;
-  }
-
-  get fatal(): boolean {
-    return this.#decoder.fatal;
-  }
-
-  get ignoreBOM(): boolean {
-    return this.#decoder.ignoreBOM;
-  }
-
-  get readable(): ReadableStream<string> {
-    return this.#transform.readable;
-  }
-
-  get writable(): WritableStream<BufferSource> {
-    return this.#transform.writable;
-  }
-}
-
-function toUint8Array(chunk: BufferSource): Uint8Array {
-  if (chunk instanceof Uint8Array) return chunk;
-  if (chunk instanceof ArrayBuffer) return new Uint8Array(chunk);
-  if (ArrayBuffer.isView(chunk)) return new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
-  throw new TypeError('chunk must be a BufferSource');
-}

package/src/text-encoder-stream.ts

@@ -1,62 +0,0 @@
-// WHATWG TextEncoderStream for GJS
-// Reference: refs/deno/ext/web/08_text_encoding.js (lines 414–490)
-// Copyright (c) 2018-2026 the Deno authors. MIT license.
-// Reimplemented for GJS — pure TypeScript, no native bindings.
-
-import { TransformStream } from './transform-stream.js';
-
-/**
- * TextEncoderStream encodes a stream of strings into UTF-8 encoded bytes.
- *
- * Handles surrogate pairs split across chunks: if the last code unit of a
- * chunk is a high surrogate (0xD800–0xDBFF), it is held until the next chunk.
- * If the stream ends with a pending high surrogate, U+FFFD replacement bytes
- * are emitted.
- */
-export class TextEncoderStream {
-  #pendingHighSurrogate: string | null = null;
-  #encoder = new TextEncoder();
-  #transform: TransformStream;
-
-  constructor() {
-    this.#transform = new TransformStream({
-      transform: (chunk: string, controller) => {
-        chunk = String(chunk);
-        if (chunk === '') {
-          return;
-        }
-        if (this.#pendingHighSurrogate !== null) {
-          chunk = this.#pendingHighSurrogate + chunk;
-        }
-        const lastCodeUnit = chunk.charCodeAt(chunk.length - 1);
-        if (0xD800 <= lastCodeUnit && lastCodeUnit <= 0xDBFF) {
-          this.#pendingHighSurrogate = chunk.slice(-1);
-          chunk = chunk.slice(0, -1);
-        } else {
-          this.#pendingHighSurrogate = null;
-        }
-        if (chunk) {
-          controller.enqueue(this.#encoder.encode(chunk));
-        }
-      },
-      flush: (controller) => {
-        if (this.#pendingHighSurrogate !== null) {
-          // U+FFFD replacement character in UTF-8
-          controller.enqueue(new Uint8Array([0xEF, 0xBF, 0xBD]));
-        }
-      },
-    });
-  }
-
-  get encoding(): string {
-    return 'utf-8';
-  }
-
-  get readable(): ReadableStream<Uint8Array> {
-    return this.#transform.readable;
-  }
-
-  get writable(): WritableStream<string> {
-    return this.#transform.writable;
-  }
-}