@gjsify/web-streams 0.1.0

package/src/test.mts

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

package/src/text-decoder-stream.ts

@@ -0,0 +1,183 @@
+// 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

@@ -0,0 +1,62 @@
+// 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;
+  }
+}

package/src/transform-stream.ts

@@ -0,0 +1,410 @@
+// WHATWG Streams — TransformStream
+// Adapted from refs/node/lib/internal/webstreams/transformstream.js
+// Copyright (c) Node.js contributors. MIT license.
+// Modifications: Removed primordials, transfer, inspect, Node.js error codes
+
+import {
+  kState, kType,
+  isBrandCheck,
+  createPromiseCallback,
+  extractHighWaterMark,
+  extractSizeAlgorithm,
+  nonOpFlush,
+  nonOpCancel,
+} from './util.js';
+
+import {
+  createReadableStream,
+  readableStreamDefaultControllerCanCloseOrEnqueue,
+  readableStreamDefaultControllerClose,
+  readableStreamDefaultControllerEnqueue,
+  readableStreamDefaultControllerError,
+  readableStreamDefaultControllerGetDesiredSize,
+  readableStreamDefaultControllerHasBackpressure,
+} from './readable-stream.js';
+
+import {
+  createWritableStream,
+  writableStreamDefaultControllerErrorIfNeeded,
+} from './writable-stream.js';
+
+const kSkipThrow = Symbol('kSkipThrow');
+
+// ---- TransformStream ----
+
+export class TransformStream {
+  [kType] = 'TransformStream';
+  [kState]: any;
+
+  constructor(
+    transformer: any = {},
+    writableStrategy: any = {},
+    readableStrategy: any = {},
+  ) {
+    if (transformer != null && typeof transformer !== 'object') {
+      throw new TypeError('transformer must be an object');
+    }
+    if (writableStrategy != null && typeof writableStrategy !== 'object') {
+      throw new TypeError('writableStrategy must be an object');
+    }
+    if (readableStrategy != null && typeof readableStrategy !== 'object') {
+      throw new TypeError('readableStrategy must be an object');
+    }
+
+    const readableType = transformer?.readableType;
+    const writableType = transformer?.writableType;
+    const start = transformer?.start;
+
+    if (readableType !== undefined) {
+      throw new RangeError(`Invalid readableType: ${readableType}`);
+    }
+    if (writableType !== undefined) {
+      throw new RangeError(`Invalid writableType: ${writableType}`);
+    }
+
+    const readableHighWaterMark = extractHighWaterMark(readableStrategy?.highWaterMark, 0);
+    const readableSize = extractSizeAlgorithm(readableStrategy?.size);
+    const writableHighWaterMark = extractHighWaterMark(writableStrategy?.highWaterMark, 1);
+    const writableSize = extractSizeAlgorithm(writableStrategy?.size);
+
+    const startPromise = Promise.withResolvers<void>();
+
+    initializeTransformStream(
+      this,
+      startPromise,
+      writableHighWaterMark,
+      writableSize,
+      readableHighWaterMark,
+      readableSize,
+    );
+
+    setupTransformStreamDefaultControllerFromTransformer(this, transformer);
+
+    if (start !== undefined) {
+      startPromise.resolve(start.call(transformer, this[kState].controller) as unknown as void);
+    } else {
+      startPromise.resolve();
+    }
+  }
+
+  get readable(): any {
+    if (!isTransformStream(this)) throw new TypeError('Invalid this');
+    return this[kState].readable;
+  }
+
+  get writable(): any {
+    if (!isTransformStream(this)) throw new TypeError('Invalid this');
+    return this[kState].writable;
+  }
+
+  get [Symbol.toStringTag]() {
+    return 'TransformStream';
+  }
+}
+
+// ---- TransformStreamDefaultController ----
+
+export class TransformStreamDefaultController {
+  [kType] = 'TransformStreamDefaultController';
+  [kState]: any;
+
+  constructor(skipThrowSymbol?: symbol) {
+    if (skipThrowSymbol !== kSkipThrow) {
+      throw new TypeError('Illegal constructor');
+    }
+  }
+
+  get desiredSize(): number | null {
+    if (!isTransformStreamDefaultController(this)) throw new TypeError('Invalid this');
+    const { stream } = this[kState];
+    const { readable } = stream[kState];
+    const readableController = readable[kState].controller;
+    return readableStreamDefaultControllerGetDesiredSize(readableController);
+  }
+
+  enqueue(chunk?: any): void {
+    if (!isTransformStreamDefaultController(this)) throw new TypeError('Invalid this');
+    transformStreamDefaultControllerEnqueue(this, chunk);
+  }
+
+  error(reason?: unknown): void {
+    if (!isTransformStreamDefaultController(this)) throw new TypeError('Invalid this');
+    transformStreamDefaultControllerError(this, reason);
+  }
+
+  terminate(): void {
+    if (!isTransformStreamDefaultController(this)) throw new TypeError('Invalid this');
+    transformStreamDefaultControllerTerminate(this);
+  }
+
+  get [Symbol.toStringTag]() {
+    return 'TransformStreamDefaultController';
+  }
+}
+
+// ---- Brand checks ----
+
+export const isTransformStream = isBrandCheck('TransformStream');
+export const isTransformStreamDefaultController = isBrandCheck('TransformStreamDefaultController');
+
+// ---- Internal functions ----
+
+async function defaultTransformAlgorithm(chunk: unknown, controller: any) {
+  transformStreamDefaultControllerEnqueue(controller, chunk);
+}
+
+function initializeTransformStream(
+  stream: any,
+  startPromise: any,
+  writableHighWaterMark: number,
+  writableSizeAlgorithm: (chunk: any) => number,
+  readableHighWaterMark: number,
+  readableSizeAlgorithm: (chunk: any) => number,
+): void {
+  const startAlgorithm = () => startPromise.promise;
+
+  const writable = createWritableStream(
+    startAlgorithm,
+    (chunk: unknown) => transformStreamDefaultSinkWriteAlgorithm(stream, chunk),
+    () => transformStreamDefaultSinkCloseAlgorithm(stream),
+    (reason: unknown) => transformStreamDefaultSinkAbortAlgorithm(stream, reason),
+    writableHighWaterMark,
+    writableSizeAlgorithm,
+  );
+
+  const readable = createReadableStream(
+    startAlgorithm,
+    () => transformStreamDefaultSourcePullAlgorithm(stream),
+    (reason: unknown) => transformStreamDefaultSourceCancelAlgorithm(stream, reason),
+    readableHighWaterMark,
+    readableSizeAlgorithm,
+  );
+
+  stream[kState] = {
+    readable,
+    writable,
+    controller: undefined,
+    backpressure: undefined as boolean | undefined,
+    backpressureChange: {
+      promise: undefined as Promise<void> | undefined,
+      resolve: undefined as ((value: void | PromiseLike<void>) => void) | undefined,
+      reject: undefined as ((reason?: unknown) => void) | undefined,
+    },
+  };
+
+  transformStreamSetBackpressure(stream, true);
+}
+
+function transformStreamError(stream: any, error: unknown): void {
+  const { readable } = stream[kState];
+  readableStreamDefaultControllerError(readable[kState].controller, error);
+  transformStreamErrorWritableAndUnblockWrite(stream, error);
+}
+
+function transformStreamErrorWritableAndUnblockWrite(stream: any, error: unknown): void {
+  const { controller, writable } = stream[kState];
+  transformStreamDefaultControllerClearAlgorithms(controller);
+  writableStreamDefaultControllerErrorIfNeeded(writable[kState].controller, error);
+  transformStreamUnblockWrite(stream);
+}
+
+function transformStreamUnblockWrite(stream: any): void {
+  if (stream[kState].backpressure) {
+    transformStreamSetBackpressure(stream, false);
+  }
+}
+
+function transformStreamSetBackpressure(stream: any, backpressure: boolean): void {
+  if (stream[kState].backpressureChange.promise !== undefined) {
+    stream[kState].backpressureChange.resolve?.();
+  }
+  stream[kState].backpressureChange = Promise.withResolvers<void>();
+  stream[kState].backpressure = backpressure;
+}
+
+function setupTransformStreamDefaultController(
+  stream: any,
+  controller: any,
+  transformAlgorithm: Function,
+  flushAlgorithm: Function,
+  cancelAlgorithm: Function,
+): void {
+  controller[kState] = {
+    stream,
+    transformAlgorithm,
+    flushAlgorithm,
+    cancelAlgorithm,
+    finishPromise: undefined as Promise<void> | undefined,
+  };
+  stream[kState].controller = controller;
+}
+
+function setupTransformStreamDefaultControllerFromTransformer(
+  stream: any,
+  transformer: any,
+): void {
+  const controller = new TransformStreamDefaultController(kSkipThrow);
+  const transform = transformer?.transform;
+  const flush = transformer?.flush;
+  const cancel = transformer?.cancel;
+  const transformAlgorithm = transform
+    ? createPromiseCallback('transformer.transform', transform, transformer)
+    : defaultTransformAlgorithm;
+  const flushAlgorithm = flush
+    ? createPromiseCallback('transformer.flush', flush, transformer)
+    : nonOpFlush;
+  const cancelAlgorithm = cancel
+    ? createPromiseCallback('transformer.cancel', cancel, transformer)
+    : nonOpCancel;
+
+  setupTransformStreamDefaultController(
+    stream, controller, transformAlgorithm, flushAlgorithm, cancelAlgorithm,
+  );
+}
+
+function transformStreamDefaultControllerClearAlgorithms(controller: any): void {
+  controller[kState].transformAlgorithm = undefined;
+  controller[kState].flushAlgorithm = undefined;
+  controller[kState].cancelAlgorithm = undefined;
+}
+
+function transformStreamDefaultControllerEnqueue(controller: any, chunk: any): void {
+  const { stream } = controller[kState];
+  const { readable } = stream[kState];
+  const readableController = readable[kState].controller;
+  if (!readableStreamDefaultControllerCanCloseOrEnqueue(readableController)) {
+    throw new TypeError('Unable to enqueue');
+  }
+  try {
+    readableStreamDefaultControllerEnqueue(readableController, chunk);
+  } catch (error: unknown) {
+    transformStreamErrorWritableAndUnblockWrite(stream, error);
+    throw readable[kState].storedError;
+  }
+  const backpressure = readableStreamDefaultControllerHasBackpressure(readableController);
+  if (backpressure !== stream[kState].backpressure) {
+    transformStreamSetBackpressure(stream, true);
+  }
+}
+
+function transformStreamDefaultControllerError(controller: any, error: unknown): void {
+  transformStreamError(controller[kState].stream, error);
+}
+
+async function transformStreamDefaultControllerPerformTransform(controller: any, chunk: any): Promise<void> {
+  try {
+    const transformAlgorithm = controller[kState].transformAlgorithm;
+    if (transformAlgorithm === undefined) return;
+    return await transformAlgorithm(chunk, controller);
+  } catch (error) {
+    transformStreamError(controller[kState].stream, error);
+    throw error;
+  }
+}
+
+function transformStreamDefaultControllerTerminate(controller: any): void {
+  const { stream } = controller[kState];
+  const { readable } = stream[kState];
+  readableStreamDefaultControllerClose(readable[kState].controller);
+  transformStreamErrorWritableAndUnblockWrite(stream, new TypeError('TransformStream has been terminated'));
+}
+
+function transformStreamDefaultSinkWriteAlgorithm(stream: any, chunk: unknown): Promise<void> {
+  const { controller } = stream[kState];
+  if (stream[kState].backpressure) {
+    const backpressureChange = stream[kState].backpressureChange.promise;
+    return backpressureChange.then(() => {
+      const { writable } = stream[kState];
+      if (writable[kState].state === 'erroring') {
+        throw writable[kState].storedError;
+      }
+      return transformStreamDefaultControllerPerformTransform(controller, chunk);
+    });
+  }
+  return transformStreamDefaultControllerPerformTransform(controller, chunk);
+}
+
+async function transformStreamDefaultSinkAbortAlgorithm(stream: any, reason: unknown): Promise<void> {
+  const { controller, readable } = stream[kState];
+  if (controller[kState].finishPromise !== undefined) {
+    return controller[kState].finishPromise;
+  }
+  const { promise, resolve, reject } = Promise.withResolvers<void>();
+  controller[kState].finishPromise = promise;
+  const cancelPromise = controller[kState].cancelAlgorithm(reason);
+  transformStreamDefaultControllerClearAlgorithms(controller);
+  cancelPromise.then(
+    () => {
+      if (readable[kState].state === 'errored') {
+        reject(readable[kState].storedError);
+      } else {
+        readableStreamDefaultControllerError(readable[kState].controller, reason);
+        resolve();
+      }
+    },
+    (error: unknown) => {
+      readableStreamDefaultControllerError(readable[kState].controller, error);
+      reject(error);
+    },
+  );
+  return controller[kState].finishPromise;
+}
+
+function transformStreamDefaultSinkCloseAlgorithm(stream: any): Promise<void> {
+  const { readable, controller } = stream[kState];
+  if (controller[kState].finishPromise !== undefined) {
+    return controller[kState].finishPromise;
+  }
+  const { promise, resolve, reject } = Promise.withResolvers<void>();
+  controller[kState].finishPromise = promise;
+  const flushPromise = controller[kState].flushAlgorithm(controller);
+  transformStreamDefaultControllerClearAlgorithms(controller);
+  flushPromise.then(
+    () => {
+      if (readable[kState].state === 'errored') {
+        reject(readable[kState].storedError);
+      } else {
+        readableStreamDefaultControllerClose(readable[kState].controller);
+        resolve();
+      }
+    },
+    (error: unknown) => {
+      readableStreamDefaultControllerError(readable[kState].controller, error);
+      reject(error);
+    },
+  );
+  return controller[kState].finishPromise;
+}
+
+function transformStreamDefaultSourcePullAlgorithm(stream: any): Promise<void> {
+  transformStreamSetBackpressure(stream, false);
+  return stream[kState].backpressureChange.promise;
+}
+
+function transformStreamDefaultSourceCancelAlgorithm(stream: any, reason: unknown): Promise<void> {
+  const { controller, writable } = stream[kState];
+  if (controller[kState].finishPromise !== undefined) {
+    return controller[kState].finishPromise;
+  }
+  const { promise, resolve, reject } = Promise.withResolvers<void>();
+  controller[kState].finishPromise = promise;
+  const cancelPromise = controller[kState].cancelAlgorithm(reason);
+  transformStreamDefaultControllerClearAlgorithms(controller);
+  cancelPromise.then(
+    () => {
+      if (writable[kState].state === 'errored') {
+        reject(writable[kState].storedError);
+      } else {
+        writableStreamDefaultControllerErrorIfNeeded(writable[kState].controller, reason);
+        transformStreamUnblockWrite(stream);
+        resolve();
+      }
+    },
+    (error: unknown) => {
+      writableStreamDefaultControllerErrorIfNeeded(writable[kState].controller, error);
+      transformStreamUnblockWrite(stream);
+      reject(error);
+    },
+  );
+  return controller[kState].finishPromise;
+}