@gjsify/web-streams 0.1.0

package/lib/types/index.d.ts

@@ -0,0 +1,77 @@
+import { ReadableStream } from './readable-stream.js';
+import { TransformStream } from './transform-stream.js';
+import { TextEncoderStream } from './text-encoder-stream.js';
+declare const _ReadableStream: typeof ReadableStream | {
+    new (underlyingSource: UnderlyingByteSource, strategy?: {
+        highWaterMark?: number;
+    }): globalThis.ReadableStream<Uint8Array<ArrayBuffer>>;
+    new <R = any>(underlyingSource: UnderlyingDefaultSource<R>, strategy?: QueuingStrategy<R>): globalThis.ReadableStream<R>;
+    new <R = any>(underlyingSource?: UnderlyingSource<R>, strategy?: QueuingStrategy<R>): globalThis.ReadableStream<R>;
+    prototype: globalThis.ReadableStream;
+};
+declare const _WritableStream: {
+    new <W = any>(underlyingSink?: UnderlyingSink<W>, strategy?: QueuingStrategy<W>): globalThis.WritableStream<W>;
+    prototype: globalThis.WritableStream;
+};
+declare const _TransformStream: typeof TransformStream | {
+    new <I = any, O = any>(transformer?: Transformer<I, O>, writableStrategy?: QueuingStrategy<I>, readableStrategy?: QueuingStrategy<O>): globalThis.TransformStream<I, O>;
+    prototype: globalThis.TransformStream;
+};
+declare const _ByteLengthQueuingStrategy: {
+    new (init: QueuingStrategyInit): globalThis.ByteLengthQueuingStrategy;
+    prototype: globalThis.ByteLengthQueuingStrategy;
+};
+declare const _CountQueuingStrategy: {
+    new (init: QueuingStrategyInit): globalThis.CountQueuingStrategy;
+    prototype: globalThis.CountQueuingStrategy;
+};
+declare const _TextEncoderStream: typeof TextEncoderStream | {
+    new (): globalThis.TextEncoderStream;
+    prototype: globalThis.TextEncoderStream;
+};
+declare const _TextDecoderStream: {
+    new (label?: string, options?: TextDecoderOptions): globalThis.TextDecoderStream;
+    prototype: globalThis.TextDecoderStream;
+};
+export { _WritableStream as WritableStream, _ReadableStream as ReadableStream, _TransformStream as TransformStream, _ByteLengthQueuingStrategy as ByteLengthQueuingStrategy, _CountQueuingStrategy as CountQueuingStrategy, _TextEncoderStream as TextEncoderStream, _TextDecoderStream as TextDecoderStream, };
+export { WritableStreamDefaultWriter, WritableStreamDefaultController } from './writable-stream.js';
+export { ReadableStreamDefaultReader, ReadableStreamDefaultController } from './readable-stream.js';
+export { TransformStreamDefaultController } from './transform-stream.js';
+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';
+declare const _default: {
+    WritableStream: {
+        new <W = any>(underlyingSink?: UnderlyingSink<W>, strategy?: QueuingStrategy<W>): globalThis.WritableStream<W>;
+        prototype: globalThis.WritableStream;
+    };
+    ReadableStream: typeof ReadableStream | {
+        new (underlyingSource: UnderlyingByteSource, strategy?: {
+            highWaterMark?: number;
+        }): globalThis.ReadableStream<Uint8Array<ArrayBuffer>>;
+        new <R = any>(underlyingSource: UnderlyingDefaultSource<R>, strategy?: QueuingStrategy<R>): globalThis.ReadableStream<R>;
+        new <R = any>(underlyingSource?: UnderlyingSource<R>, strategy?: QueuingStrategy<R>): globalThis.ReadableStream<R>;
+        prototype: globalThis.ReadableStream;
+    };
+    TransformStream: typeof TransformStream | {
+        new <I = any, O = any>(transformer?: Transformer<I, O>, writableStrategy?: QueuingStrategy<I>, readableStrategy?: QueuingStrategy<O>): globalThis.TransformStream<I, O>;
+        prototype: globalThis.TransformStream;
+    };
+    ByteLengthQueuingStrategy: {
+        new (init: QueuingStrategyInit): globalThis.ByteLengthQueuingStrategy;
+        prototype: globalThis.ByteLengthQueuingStrategy;
+    };
+    CountQueuingStrategy: {
+        new (init: QueuingStrategyInit): globalThis.CountQueuingStrategy;
+        prototype: globalThis.CountQueuingStrategy;
+    };
+    TextEncoderStream: typeof TextEncoderStream | {
+        new (): globalThis.TextEncoderStream;
+        prototype: globalThis.TextEncoderStream;
+    };
+    TextDecoderStream: {
+        new (label?: string, options?: TextDecoderOptions): globalThis.TextDecoderStream;
+        prototype: globalThis.TextDecoderStream;
+    };
+};
+export default _default;

package/lib/types/queuing-strategies.d.ts

@@ -0,0 +1,18 @@
+export declare class ByteLengthQueuingStrategy {
+    #private;
+    constructor(init: {
+        highWaterMark: number;
+    });
+    get highWaterMark(): number;
+    get size(): (chunk: any) => number;
+    get [Symbol.toStringTag](): string;
+}
+export declare class CountQueuingStrategy {
+    #private;
+    constructor(init: {
+        highWaterMark: number;
+    });
+    get highWaterMark(): number;
+    get size(): (chunk: any) => number;
+    get [Symbol.toStringTag](): string;
+}

package/lib/types/readable-stream.d.ts

@@ -0,0 +1,61 @@
+import { kState, kType } from './util.js';
+declare const kCancel: unique symbol;
+declare const kPull: unique symbol;
+declare const kRelease: unique symbol;
+declare class ReadableStream {
+    [kType]: string;
+    [kState]: any;
+    constructor(source?: any, strategy?: any);
+    get locked(): boolean;
+    static from(iterable: unknown): ReadableStream;
+    cancel(reason?: unknown): Promise<void>;
+    getReader(options?: any): ReadableStreamDefaultReader;
+    pipeThrough(transform: any, options?: any): ReadableStream;
+    pipeTo(destination: any, options?: any): Promise<void>;
+    tee(): [ReadableStream, ReadableStream];
+    values(options?: any): AsyncIterableIterator<any>;
+    [Symbol.asyncIterator](): AsyncIterableIterator<any>;
+    get [Symbol.toStringTag](): string;
+}
+declare class ReadableStreamDefaultReader {
+    [kType]: string;
+    [kState]: any;
+    constructor(stream: ReadableStream);
+    read(): Promise<{
+        value: any;
+        done: boolean;
+    }>;
+    releaseLock(): void;
+    get closed(): Promise<void>;
+    cancel(reason?: unknown): Promise<void>;
+    get [Symbol.toStringTag](): string;
+}
+declare class ReadableStreamDefaultController {
+    [kType]: string;
+    [kState]: any;
+    constructor(skipThrowSymbol?: symbol);
+    get desiredSize(): number | null;
+    close(): void;
+    enqueue(chunk?: any): void;
+    error(error?: unknown): void;
+    [kCancel](reason: unknown): Promise<void>;
+    [kPull](readRequest: any): void;
+    [kRelease](): void;
+    get [Symbol.toStringTag](): string;
+}
+declare const isReadableStream: (value: unknown) => boolean;
+declare const isReadableStreamDefaultController: (value: unknown) => boolean;
+declare const isReadableStreamDefaultReader: (value: unknown) => boolean;
+declare function isReadableStreamLocked(stream: any): boolean;
+declare function readableStreamCancel(stream: any, reason: unknown): Promise<void>;
+declare function readableStreamClose(stream: any): void;
+declare function readableStreamError(stream: any, error: unknown): void;
+declare function readableStreamDefaultControllerClose(controller: any): void;
+declare function readableStreamDefaultControllerEnqueue(controller: any, chunk: any): void;
+declare function readableStreamDefaultControllerCanCloseOrEnqueue(controller: any): boolean;
+declare function readableStreamDefaultControllerGetDesiredSize(controller: any): number | null;
+declare function readableStreamDefaultControllerHasBackpressure(controller: any): boolean;
+declare function readableStreamDefaultControllerError(controller: any, error: unknown): void;
+declare function setupReadableStreamDefaultController(stream: any, controller: any, startAlgorithm: Function, pullAlgorithm: Function, cancelAlgorithm: Function, highWaterMark: number, sizeAlgorithm: (chunk: any) => number): void;
+declare function createReadableStream(start: Function, pull: Function, cancel: Function, highWaterMark?: number, size?: (chunk: any) => number): ReadableStream;
+export { ReadableStream, ReadableStreamDefaultReader, ReadableStreamDefaultController, isReadableStream, isReadableStreamLocked, isReadableStreamDefaultReader, isReadableStreamDefaultController, readableStreamCancel, readableStreamClose, readableStreamError, readableStreamDefaultControllerClose, readableStreamDefaultControllerEnqueue, readableStreamDefaultControllerError, readableStreamDefaultControllerGetDesiredSize, readableStreamDefaultControllerCanCloseOrEnqueue, readableStreamDefaultControllerHasBackpressure, setupReadableStreamDefaultController, createReadableStream, };

package/lib/types/text-decoder-stream.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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 declare class TextDecoderStream {
+    #private;
+    constructor(label?: string, options?: TextDecoderOptions);
+    get encoding(): string;
+    get fatal(): boolean;
+    get ignoreBOM(): boolean;
+    get readable(): ReadableStream<string>;
+    get writable(): WritableStream<BufferSource>;
+}

package/lib/types/text-encoder-stream.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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 declare class TextEncoderStream {
+    #private;
+    constructor();
+    get encoding(): string;
+    get readable(): ReadableStream<Uint8Array>;
+    get writable(): WritableStream<string>;
+}

package/lib/types/transform-stream.d.ts

@@ -0,0 +1,21 @@
+import { kState, kType } from './util.js';
+export declare class TransformStream {
+    [kType]: string;
+    [kState]: any;
+    constructor(transformer?: any, writableStrategy?: any, readableStrategy?: any);
+    get readable(): any;
+    get writable(): any;
+    get [Symbol.toStringTag](): string;
+}
+export declare class TransformStreamDefaultController {
+    [kType]: string;
+    [kState]: any;
+    constructor(skipThrowSymbol?: symbol);
+    get desiredSize(): number | null;
+    enqueue(chunk?: any): void;
+    error(reason?: unknown): void;
+    terminate(): void;
+    get [Symbol.toStringTag](): string;
+}
+export declare const isTransformStream: (value: unknown) => boolean;
+export declare const isTransformStreamDefaultController: (value: unknown) => boolean;

package/lib/types/util.d.ts

@@ -0,0 +1,40 @@
+export declare const kState: unique symbol;
+export declare const kType: unique symbol;
+export declare function isBrandCheck(brand: string): (value: unknown) => boolean;
+export declare function dequeueValue(controller: any): any;
+export declare function resetQueue(controller: any): void;
+export declare function peekQueueValue(controller: any): any;
+export declare function enqueueValueWithSize(controller: any, value: any, size: number): void;
+export declare function extractHighWaterMark(value: number | undefined, defaultHWM: number): number;
+export declare function extractSizeAlgorithm(size: ((chunk: any) => number) | undefined): (chunk: any) => number;
+export declare function cloneAsUint8Array(view: ArrayBufferView): Uint8Array;
+export declare function ArrayBufferViewGetBuffer(view: ArrayBufferView): ArrayBuffer;
+export declare function ArrayBufferViewGetByteLength(view: ArrayBufferView): number;
+export declare function ArrayBufferViewGetByteOffset(view: ArrayBufferView): number;
+export declare function setPromiseHandled(promise: Promise<unknown>): void;
+export declare function createPromiseCallback(name: string, fn: Function, thisArg: unknown): (...args: unknown[]) => Promise<any>;
+export declare function nonOpFlush(): Promise<void>;
+export declare function nonOpStart(): void;
+export declare function nonOpPull(): Promise<void>;
+export declare function nonOpCancel(): Promise<void>;
+export declare function nonOpWrite(): Promise<void>;
+export declare const AsyncIterator: {
+    __proto__: any;
+    next: (() => Promise<IteratorResult<unknown>>) | undefined;
+    return: ((value?: unknown) => Promise<IteratorResult<unknown>>) | undefined;
+};
+export declare function createAsyncFromSyncIterator(syncIteratorRecord: {
+    iterator: Iterator<unknown>;
+    nextMethod: Function;
+    done: boolean;
+}): {
+    iterator: AsyncGenerator<unknown, any, any>;
+    nextMethod: (...[value]: [] | [any]) => Promise<IteratorResult<unknown, any>>;
+    done: boolean;
+};
+export declare function getIterator(obj: Record<string | symbol, unknown>, kind?: 'sync' | 'async', method?: Function): any;
+export declare function iteratorNext(iteratorRecord: {
+    iterator: unknown;
+    nextMethod: Function;
+    done: boolean;
+}, value?: unknown): any;

package/lib/types/writable-stream.d.ts

@@ -0,0 +1,49 @@
+import { kState, kType } from './util.js';
+declare const kAbort: unique symbol;
+declare const kError: unique symbol;
+export declare class WritableStream {
+    [kType]: string;
+    [kState]: any;
+    constructor(sink?: any, strategy?: any);
+    get locked(): boolean;
+    abort(reason?: unknown): Promise<void>;
+    close(): Promise<void>;
+    getWriter(): WritableStreamDefaultWriter;
+    get [Symbol.toStringTag](): string;
+}
+export declare class WritableStreamDefaultWriter {
+    [kType]: string;
+    [kState]: any;
+    constructor(stream: WritableStream);
+    get closed(): Promise<void>;
+    get desiredSize(): number | null;
+    get ready(): Promise<void>;
+    abort(reason?: unknown): Promise<void>;
+    close(): Promise<void>;
+    releaseLock(): void;
+    write(chunk?: any): Promise<void>;
+    get [Symbol.toStringTag](): string;
+}
+export declare class WritableStreamDefaultController {
+    [kType]: string;
+    [kState]: any;
+    constructor(skipThrowSymbol?: symbol);
+    [kAbort](reason: unknown): any;
+    [kError](): void;
+    get signal(): AbortSignal;
+    error(error?: unknown): void;
+    get [Symbol.toStringTag](): string;
+}
+export declare const isWritableStream: (value: unknown) => boolean;
+export declare const isWritableStreamDefaultWriter: (value: unknown) => boolean;
+export declare const isWritableStreamDefaultController: (value: unknown) => boolean;
+export declare function isWritableStreamLocked(stream: any): boolean;
+export declare function writableStreamAbort(stream: any, reason?: unknown): Promise<void>;
+export declare function writableStreamClose(stream: any): Promise<void>;
+export declare function writableStreamCloseQueuedOrInFlight(stream: any): boolean;
+export declare function writableStreamDefaultWriterWrite(writer: any, chunk: any): Promise<void>;
+export declare function writableStreamDefaultWriterRelease(writer: any): void;
+export declare function writableStreamDefaultWriterCloseWithErrorPropagation(writer: any): Promise<void>;
+export declare function writableStreamDefaultControllerErrorIfNeeded(controller: any, error: unknown): void;
+export declare function createWritableStream(start: Function, write: Function, close: Function, abort: Function, highWaterMark?: number, size?: (chunk: any) => number): WritableStream;
+export {};

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@gjsify/web-streams",
+  "version": "0.1.0",
+  "description": "WHATWG Streams API (ReadableStream, WritableStream, TransformStream) for GJS",
+  "type": "module",
+  "module": "lib/esm/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/esm/index.js"
+    }
+  },
+  "scripts": {
+    "clear": "rm -rf lib tsconfig.tsbuildinfo tsconfig.types.tsbuildinfo test.gjs.mjs test.node.mjs || exit 0",
+    "check": "tsc --noEmit",
+    "build": "yarn build:gjsify && yarn build:types",
+    "build:gjsify": "gjsify build --library 'src/**/*.{ts,js}' --exclude 'src/**/*.spec.{mts,ts}' 'src/test.{mts,ts}'",
+    "build:types": "tsc",
+    "build:test": "yarn build:test:gjs && yarn build:test:node",
+    "build:test:gjs": "gjsify build src/test.mts --app gjs --outfile test.gjs.mjs",
+    "build:test:node": "gjsify build src/test.mts --app node --outfile test.node.mjs",
+    "test": "yarn build:gjsify && yarn build:test && yarn test:node && yarn test:gjs",
+    "test:gjs": "gjs -m test.gjs.mjs",
+    "test:node": "node test.node.mjs"
+  },
+  "keywords": [
+    "gjs",
+    "web",
+    "streams",
+    "readable",
+    "writable",
+    "transform"
+  ],
+  "dependencies": {
+    "@gjsify/utils": "^0.1.0"
+  },
+  "devDependencies": {
+    "@gjsify/cli": "^0.1.0",
+    "@gjsify/unit": "^0.1.0",
+    "@types/node": "^25.5.0",
+    "typescript": "^6.0.2"
+  }
+}