@gjsify/web-streams 0.1.0

package/src/index.ts

@@ -0,0 +1,131 @@
+// WHATWG Streams API for GJS
+// Reference: refs/node/lib/internal/webstreams/
+// Copyright (c) Node.js contributors. MIT license.
+// Reimplemented for GJS — pure TypeScript, no native bindings.
+//
+// On Node.js (and any environment with native Web Streams), this module
+// re-exports the native globals for zero overhead.
+// On GJS, it provides a full polyfill and registers globals.
+
+import { WritableStream, WritableStreamDefaultWriter, WritableStreamDefaultController } from './writable-stream.js';
+import { ReadableStream, ReadableStreamDefaultReader, ReadableStreamDefaultController } from './readable-stream.js';
+import { TransformStream, TransformStreamDefaultController } from './transform-stream.js';
+import { ByteLengthQueuingStrategy, CountQueuingStrategy } from './queuing-strategies.js';
+import { TextEncoderStream } from './text-encoder-stream.js';
+import { TextDecoderStream } from './text-decoder-stream.js';
+
+// Validate that a native stream class produces functional instances.
+// GJS may expose stream constructors that return objects missing core methods
+// (e.g. ReadableStream exists but instances lack getReader()).
+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;
+  }
+}
+
+// Use native if available and functional (Node.js 18+), polyfill otherwise
+const _ReadableStream = isNativeStreamUsable(globalThis.ReadableStream, 'getReader')
+  ? globalThis.ReadableStream
+  : ReadableStream;
+const _WritableStream = isNativeStreamUsable(globalThis.WritableStream, 'getWriter')
+  ? globalThis.WritableStream
+  : WritableStream;
+const _TransformStream = isNativeStreamUsable(globalThis.TransformStream, 'readable')
+  ? globalThis.TransformStream
+  : TransformStream;
+const _ByteLengthQueuingStrategy = typeof globalThis.ByteLengthQueuingStrategy === 'function'
+  ? globalThis.ByteLengthQueuingStrategy
+  : ByteLengthQueuingStrategy;
+const _CountQueuingStrategy = typeof globalThis.CountQueuingStrategy === 'function'
+  ? globalThis.CountQueuingStrategy
+  : CountQueuingStrategy;
+const _TextEncoderStream = typeof globalThis.TextEncoderStream === 'function'
+  ? globalThis.TextEncoderStream
+  : TextEncoderStream;
+const _TextDecoderStream = typeof globalThis.TextDecoderStream === 'function'
+  ? globalThis.TextDecoderStream
+  : TextDecoderStream;
+
+// Register globals — replace broken native implementations with polyfill
+if (!isNativeStreamUsable(globalThis.ReadableStream, 'getReader')) {
+  (globalThis as any).ReadableStream = ReadableStream;
+}
+if (!isNativeStreamUsable(globalThis.WritableStream, 'getWriter')) {
+  (globalThis as any).WritableStream = WritableStream;
+}
+if (!isNativeStreamUsable(globalThis.TransformStream, 'readable')) {
+  (globalThis as any).TransformStream = TransformStream;
+}
+if (typeof globalThis.ByteLengthQueuingStrategy === 'undefined') {
+  (globalThis as any).ByteLengthQueuingStrategy = ByteLengthQueuingStrategy;
+}
+if (typeof globalThis.CountQueuingStrategy === 'undefined') {
+  (globalThis as any).CountQueuingStrategy = CountQueuingStrategy;
+}
+if (typeof globalThis.TextEncoderStream === 'undefined') {
+  (globalThis as any).TextEncoderStream = TextEncoderStream;
+}
+if (typeof globalThis.TextDecoderStream === 'undefined') {
+  (globalThis as any).TextDecoderStream = TextDecoderStream;
+}
+
+export {
+  _WritableStream as WritableStream,
+  _ReadableStream as ReadableStream,
+  _TransformStream as TransformStream,
+  _ByteLengthQueuingStrategy as ByteLengthQueuingStrategy,
+  _CountQueuingStrategy as CountQueuingStrategy,
+  _TextEncoderStream as TextEncoderStream,
+  _TextDecoderStream as TextDecoderStream,
+};
+
+// Re-export class types for direct import
+export { WritableStreamDefaultWriter, WritableStreamDefaultController } from './writable-stream.js';
+export { ReadableStreamDefaultReader, ReadableStreamDefaultController } from './readable-stream.js';
+export { TransformStreamDefaultController } from './transform-stream.js';
+
+// Re-export internals needed by other packages
+export {
+  isWritableStream,
+  isWritableStreamLocked,
+  writableStreamAbort,
+  writableStreamClose,
+  writableStreamCloseQueuedOrInFlight,
+  writableStreamDefaultWriterCloseWithErrorPropagation,
+  writableStreamDefaultControllerErrorIfNeeded,
+  createWritableStream,
+} from './writable-stream.js';
+
+export {
+  isReadableStream,
+  isReadableStreamLocked,
+  readableStreamCancel,
+  readableStreamClose,
+  readableStreamError,
+  readableStreamDefaultControllerClose,
+  readableStreamDefaultControllerEnqueue,
+  readableStreamDefaultControllerError,
+  readableStreamDefaultControllerGetDesiredSize,
+  readableStreamDefaultControllerCanCloseOrEnqueue,
+  readableStreamDefaultControllerHasBackpressure,
+  setupReadableStreamDefaultController,
+  createReadableStream,
+} from './readable-stream.js';
+
+export {
+  isTransformStream,
+  isTransformStreamDefaultController,
+} from './transform-stream.js';
+
+export default {
+  WritableStream: _WritableStream,
+  ReadableStream: _ReadableStream,
+  TransformStream: _TransformStream,
+  ByteLengthQueuingStrategy: _ByteLengthQueuingStrategy,
+  CountQueuingStrategy: _CountQueuingStrategy,
+  TextEncoderStream: _TextEncoderStream,
+  TextDecoderStream: _TextDecoderStream,
+};

package/src/queuing-strategies.ts

@@ -0,0 +1,67 @@
+// WHATWG Streams — ByteLengthQueuingStrategy and CountQueuingStrategy
+// Adapted from refs/node/lib/internal/webstreams/queuingstrategies.js
+// Copyright (c) Node.js contributors. MIT license.
+
+const byteSizeFunction = Object.defineProperty(
+  (chunk: any) => chunk.byteLength,
+  'name',
+  { value: 'size' },
+);
+
+const countSizeFunction = Object.defineProperty(
+  () => 1,
+  'name',
+  { value: 'size' },
+);
+
+export class ByteLengthQueuingStrategy {
+  #highWaterMark: number;
+
+  constructor(init: { highWaterMark: number }) {
+    if (init == null || typeof init !== 'object') {
+      throw new TypeError('init must be an object');
+    }
+    if (init.highWaterMark === undefined) {
+      throw new TypeError('init.highWaterMark is required');
+    }
+    this.#highWaterMark = +init.highWaterMark;
+  }
+
+  get highWaterMark(): number {
+    return this.#highWaterMark;
+  }
+
+  get size(): (chunk: any) => number {
+    return byteSizeFunction;
+  }
+
+  get [Symbol.toStringTag]() {
+    return 'ByteLengthQueuingStrategy';
+  }
+}
+
+export class CountQueuingStrategy {
+  #highWaterMark: number;
+
+  constructor(init: { highWaterMark: number }) {
+    if (init == null || typeof init !== 'object') {
+      throw new TypeError('init must be an object');
+    }
+    if (init.highWaterMark === undefined) {
+      throw new TypeError('init.highWaterMark is required');
+    }
+    this.#highWaterMark = +init.highWaterMark;
+  }
+
+  get highWaterMark(): number {
+    return this.#highWaterMark;
+  }
+
+  get size(): (chunk: any) => number {
+    return countSizeFunction;
+  }
+
+  get [Symbol.toStringTag]() {
+    return 'CountQueuingStrategy';
+  }
+}