@gjsify/web-streams 0.1.0

package/README.md

@@ -0,0 +1,30 @@
+# @gjsify/web-streams
+
+GJS implementation of the Web Streams API (ReadableStream, WritableStream, TransformStream).
+
+Part of the [gjsify](https://github.com/gjsify/gjsify) project — Node.js and Web APIs for GJS (GNOME JavaScript).
+
+## Installation
+
+```bash
+npm install @gjsify/web-streams
+# or
+yarn add @gjsify/web-streams
+```
+
+## Usage
+
+```typescript
+import { ReadableStream, WritableStream, TransformStream } from '@gjsify/web-streams';
+
+const readable = new ReadableStream({
+  start(controller) {
+    controller.enqueue('hello');
+    controller.close();
+  }
+});
+```
+
+## License
+
+MIT

package/lib/esm/index.js

@@ -0,0 +1,121 @@
+import { WritableStream } from "./writable-stream.js";
+import { ReadableStream } from "./readable-stream.js";
+import { TransformStream } 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";
+function isNativeStreamUsable(Ctor, method) {
+  try {
+    if (typeof Ctor !== "function") return false;
+    return typeof Ctor.prototype[method] === "function";
+  } catch {
+    return false;
+  }
+}
+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;
+if (!isNativeStreamUsable(globalThis.ReadableStream, "getReader")) {
+  globalThis.ReadableStream = ReadableStream;
+}
+if (!isNativeStreamUsable(globalThis.WritableStream, "getWriter")) {
+  globalThis.WritableStream = WritableStream;
+}
+if (!isNativeStreamUsable(globalThis.TransformStream, "readable")) {
+  globalThis.TransformStream = TransformStream;
+}
+if (typeof globalThis.ByteLengthQueuingStrategy === "undefined") {
+  globalThis.ByteLengthQueuingStrategy = ByteLengthQueuingStrategy;
+}
+if (typeof globalThis.CountQueuingStrategy === "undefined") {
+  globalThis.CountQueuingStrategy = CountQueuingStrategy;
+}
+if (typeof globalThis.TextEncoderStream === "undefined") {
+  globalThis.TextEncoderStream = TextEncoderStream;
+}
+if (typeof globalThis.TextDecoderStream === "undefined") {
+  globalThis.TextDecoderStream = TextDecoderStream;
+}
+import { WritableStreamDefaultWriter as WritableStreamDefaultWriter2, WritableStreamDefaultController as WritableStreamDefaultController2 } from "./writable-stream.js";
+import { ReadableStreamDefaultReader as ReadableStreamDefaultReader2, ReadableStreamDefaultController as ReadableStreamDefaultController2 } from "./readable-stream.js";
+import { TransformStreamDefaultController as TransformStreamDefaultController2 } from "./transform-stream.js";
+import {
+  isWritableStream,
+  isWritableStreamLocked,
+  writableStreamAbort,
+  writableStreamClose,
+  writableStreamCloseQueuedOrInFlight,
+  writableStreamDefaultWriterCloseWithErrorPropagation,
+  writableStreamDefaultControllerErrorIfNeeded,
+  createWritableStream
+} from "./writable-stream.js";
+import {
+  isReadableStream,
+  isReadableStreamLocked,
+  readableStreamCancel,
+  readableStreamClose,
+  readableStreamError,
+  readableStreamDefaultControllerClose,
+  readableStreamDefaultControllerEnqueue,
+  readableStreamDefaultControllerError,
+  readableStreamDefaultControllerGetDesiredSize,
+  readableStreamDefaultControllerCanCloseOrEnqueue,
+  readableStreamDefaultControllerHasBackpressure,
+  setupReadableStreamDefaultController,
+  createReadableStream
+} from "./readable-stream.js";
+import {
+  isTransformStream,
+  isTransformStreamDefaultController
+} from "./transform-stream.js";
+var index_default = {
+  WritableStream: _WritableStream,
+  ReadableStream: _ReadableStream,
+  TransformStream: _TransformStream,
+  ByteLengthQueuingStrategy: _ByteLengthQueuingStrategy,
+  CountQueuingStrategy: _CountQueuingStrategy,
+  TextEncoderStream: _TextEncoderStream,
+  TextDecoderStream: _TextDecoderStream
+};
+export {
+  _ByteLengthQueuingStrategy as ByteLengthQueuingStrategy,
+  _CountQueuingStrategy as CountQueuingStrategy,
+  _ReadableStream as ReadableStream,
+  ReadableStreamDefaultController2 as ReadableStreamDefaultController,
+  ReadableStreamDefaultReader2 as ReadableStreamDefaultReader,
+  _TextDecoderStream as TextDecoderStream,
+  _TextEncoderStream as TextEncoderStream,
+  _TransformStream as TransformStream,
+  TransformStreamDefaultController2 as TransformStreamDefaultController,
+  _WritableStream as WritableStream,
+  WritableStreamDefaultController2 as WritableStreamDefaultController,
+  WritableStreamDefaultWriter2 as WritableStreamDefaultWriter,
+  createReadableStream,
+  createWritableStream,
+  index_default as default,
+  isReadableStream,
+  isReadableStreamLocked,
+  isTransformStream,
+  isTransformStreamDefaultController,
+  isWritableStream,
+  isWritableStreamLocked,
+  readableStreamCancel,
+  readableStreamClose,
+  readableStreamDefaultControllerCanCloseOrEnqueue,
+  readableStreamDefaultControllerClose,
+  readableStreamDefaultControllerEnqueue,
+  readableStreamDefaultControllerError,
+  readableStreamDefaultControllerGetDesiredSize,
+  readableStreamDefaultControllerHasBackpressure,
+  readableStreamError,
+  setupReadableStreamDefaultController,
+  writableStreamAbort,
+  writableStreamClose,
+  writableStreamCloseQueuedOrInFlight,
+  writableStreamDefaultControllerErrorIfNeeded,
+  writableStreamDefaultWriterCloseWithErrorPropagation
+};

package/lib/esm/queuing-strategies.js

@@ -0,0 +1,56 @@
+const byteSizeFunction = Object.defineProperty(
+  (chunk) => chunk.byteLength,
+  "name",
+  { value: "size" }
+);
+const countSizeFunction = Object.defineProperty(
+  () => 1,
+  "name",
+  { value: "size" }
+);
+class ByteLengthQueuingStrategy {
+  #highWaterMark;
+  constructor(init) {
+    if (init == null || typeof init !== "object") {
+      throw new TypeError("init must be an object");
+    }
+    if (init.highWaterMark === void 0) {
+      throw new TypeError("init.highWaterMark is required");
+    }
+    this.#highWaterMark = +init.highWaterMark;
+  }
+  get highWaterMark() {
+    return this.#highWaterMark;
+  }
+  get size() {
+    return byteSizeFunction;
+  }
+  get [Symbol.toStringTag]() {
+    return "ByteLengthQueuingStrategy";
+  }
+}
+class CountQueuingStrategy {
+  #highWaterMark;
+  constructor(init) {
+    if (init == null || typeof init !== "object") {
+      throw new TypeError("init must be an object");
+    }
+    if (init.highWaterMark === void 0) {
+      throw new TypeError("init.highWaterMark is required");
+    }
+    this.#highWaterMark = +init.highWaterMark;
+  }
+  get highWaterMark() {
+    return this.#highWaterMark;
+  }
+  get size() {
+    return countSizeFunction;
+  }
+  get [Symbol.toStringTag]() {
+    return "CountQueuingStrategy";
+  }
+}
+export {
+  ByteLengthQueuingStrategy,
+  CountQueuingStrategy
+};