@gjsify/stream 0.0.4 → 0.1.0

package/lib/esm/promises/index.js

@@ -1,6 +1,30 @@
-export * from "@gjsify/deno_std/node/stream/promises";
-import promises from "@gjsify/deno_std/node/stream/promises";
-var promises_default = promises;
+import { pipeline as _pipeline, finished as _finished } from "../index.js";
+function pipeline(...streams) {
+  return new Promise((resolve, reject) => {
+    _pipeline(...streams, (err) => {
+      if (err) reject(err);
+      else resolve();
+    });
+  });
+}
+function finished(stream, opts) {
+  return new Promise((resolve, reject) => {
+    if (opts && typeof opts !== "function") {
+      _finished(stream, opts, (err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    } else {
+      _finished(stream, (err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    }
+  });
+}
+var promises_default = { pipeline, finished };
 export {
-  promises_default as default
+  promises_default as default,
+  finished,
+  pipeline
 };

package/lib/esm/web/index.js

@@ -1,6 +1,37 @@
-export * from "@gjsify/deno_std/node/stream/web";
-import web from "@gjsify/deno_std/node/stream/web";
-var web_default = web;
+import {
+  ReadableStream,
+  WritableStream,
+  TransformStream,
+  ByteLengthQueuingStrategy,
+  CountQueuingStrategy,
+  TextEncoderStream,
+  TextDecoderStream
+} from "@gjsify/web-streams";
+import {
+  ReadableStream as ReadableStream2,
+  WritableStream as WritableStream2,
+  TransformStream as TransformStream2,
+  ByteLengthQueuingStrategy as ByteLengthQueuingStrategy2,
+  CountQueuingStrategy as CountQueuingStrategy2,
+  TextEncoderStream as TextEncoderStream2,
+  TextDecoderStream as TextDecoderStream2
+} from "@gjsify/web-streams";
+var web_default = {
+  ReadableStream: ReadableStream2,
+  WritableStream: WritableStream2,
+  TransformStream: TransformStream2,
+  ByteLengthQueuingStrategy: ByteLengthQueuingStrategy2,
+  CountQueuingStrategy: CountQueuingStrategy2,
+  TextEncoderStream: TextEncoderStream2,
+  TextDecoderStream: TextDecoderStream2
+};
 export {
+  ByteLengthQueuingStrategy,
+  CountQueuingStrategy,
+  ReadableStream,
+  TextDecoderStream,
+  TextEncoderStream,
+  TransformStream,
+  WritableStream,
   web_default as default
 };

package/lib/types/consumers/index.d.ts

@@ -1,3 +1,13 @@
-export * from '@gjsify/deno_std/node/stream/consumers';
-import consumers from '@gjsify/deno_std/node/stream/consumers';
-export default consumers;
+export declare function arrayBuffer(stream: ReadableStream | AsyncIterable<any>): Promise<ArrayBuffer>;
+export declare function blob(stream: ReadableStream | AsyncIterable<any>): Promise<Blob>;
+export declare function buffer(stream: ReadableStream | AsyncIterable<any>): Promise<any>;
+export declare function text(stream: ReadableStream | AsyncIterable<any>): Promise<string>;
+export declare function json(stream: ReadableStream | AsyncIterable<any>): Promise<any>;
+declare const _default: {
+    arrayBuffer: typeof arrayBuffer;
+    blob: typeof blob;
+    buffer: typeof buffer;
+    text: typeof text;
+    json: typeof json;
+};
+export default _default;

package/lib/types/index.d.ts

@@ -1,6 +1,182 @@
-/// <reference types="node" />
-export * from '@gjsify/deno_std/node/stream';
-import stream from '@gjsify/deno_std/node/stream';
-import type { ReadableOptions } from 'stream';
-export type { ReadableOptions };
-export default stream;
+import { EventEmitter } from '@gjsify/events';
+import type { ReadableOptions, WritableOptions, DuplexOptions, TransformOptions, FinishedOptions } from 'node:stream';
+export declare function getDefaultHighWaterMark(objectMode: boolean): number;
+export declare function setDefaultHighWaterMark(objectMode: boolean, value: number): void;
+/** Base options accepted by the Stream constructor (superset used by subclass options). */
+export interface StreamOptions {
+    highWaterMark?: number;
+    objectMode?: boolean;
+    signal?: AbortSignal;
+    captureRejections?: boolean;
+}
+export type { ReadableOptions, WritableOptions, DuplexOptions, TransformOptions, FinishedOptions };
+/** Tracked pipe destination for unpipe support. */
+interface PipeState {
+    dest: Writable;
+    ondata: (chunk: unknown) => void;
+    ondrain: () => void;
+    onend: () => void;
+    cleanup: () => void;
+    doEnd: boolean;
+}
+export declare class Stream extends EventEmitter {
+    constructor(opts?: StreamOptions);
+    pipe<T extends Writable>(destination: T, options?: {
+        end?: boolean;
+    }): T;
+}
+export declare class Readable extends Stream {
+    readable: boolean;
+    readableFlowing: boolean | null;
+    readableLength: number;
+    readableHighWaterMark: number;
+    readableEncoding: string | null;
+    readableObjectMode: boolean;
+    readableEnded: boolean;
+    readableAborted: boolean;
+    destroyed: boolean;
+    /** @internal Tracked pipe destinations for unpipe. */
+    _pipeDests: PipeState[];
+    private _buffer;
+    private _readableState;
+    private _readablePending;
+    private _readImpl;
+    private _destroyImpl;
+    private _constructImpl;
+    constructor(opts?: ReadableOptions);
+    _construct(callback: (error?: Error | null) => void): void;
+    _read(_size: number): void;
+    read(size?: number): any;
+    /** @internal Extract exactly `size` bytes from the internal buffer. */
+    private _readBytes;
+    push(chunk: any, encoding?: string): boolean;
+    /** Emit 'end' followed by 'close' (matches Node.js autoDestroy behavior). */
+    private _emitEnd;
+    /** Schedule a single 'readable' event per microtask cycle (deduplicates multiple pushes). */
+    private _scheduleReadable;
+    on(event: string | symbol, listener: (...args: any[]) => void): this;
+    unshift(chunk: any): void;
+    setEncoding(encoding: string): this;
+    pause(): this;
+    resume(): this;
+    private _flowing;
+    private _flow;
+    isPaused(): boolean;
+    unpipe(destination?: Writable): this;
+    destroy(error?: Error): this;
+    [Symbol.asyncIterator](): AsyncIterableIterator<unknown>;
+    static from(iterable: Iterable<unknown> | AsyncIterable<unknown>, opts?: ReadableOptions): Readable;
+}
+export declare class Writable extends Stream {
+    writable: boolean;
+    writableHighWaterMark: number;
+    writableLength: number;
+    writableObjectMode: boolean;
+    writableEnded: boolean;
+    writableFinished: boolean;
+    writableCorked: number;
+    writableNeedDrain: boolean;
+    destroyed: boolean;
+    private _writableState;
+    private _corkedBuffer;
+    private _writeBuffer;
+    private _pendingConstruct;
+    private _ending;
+    private _endCallback?;
+    private _pendingEnd;
+    private _writeImpl;
+    private _writev;
+    private _finalImpl;
+    private _destroyImpl;
+    private _constructImpl;
+    private _decodeStrings;
+    private _defaultEncoding;
+    constructor(opts?: WritableOptions);
+    _construct(callback: (error?: Error | null) => void): void;
+    _write(chunk: any, encoding: string, callback: (error?: Error | null) => void): void;
+    _final(callback: (error?: Error | null) => void): void;
+    private _maybeFlush;
+    private _doWrite;
+    private _drainWriteBuffer;
+    private _maybeFinish;
+    write(chunk: any, encoding?: string | ((error?: Error | null) => void), callback?: (error?: Error | null) => void): boolean;
+    private _doEnd;
+    end(chunk?: any, encoding?: string | (() => void), callback?: () => void): this;
+    cork(): void;
+    uncork(): void;
+    private _flushCorkedBuffer;
+    setDefaultEncoding(encoding: string): this;
+    destroy(error?: Error): this;
+}
+export declare class Duplex extends Readable {
+    writable: boolean;
+    writableHighWaterMark: number;
+    writableLength: number;
+    writableObjectMode: boolean;
+    writableEnded: boolean;
+    writableFinished: boolean;
+    writableCorked: number;
+    writableNeedDrain: boolean;
+    allowHalfOpen: boolean;
+    private _decodeStrings;
+    private _duplexCorkedBuffer;
+    private _writeImpl;
+    private _finalImpl;
+    private _defaultEncoding;
+    private _pendingWrites;
+    private _pendingEndCb;
+    constructor(opts?: DuplexOptions);
+    _write(chunk: any, encoding: string, callback: (error?: Error | null) => void): void;
+    _final(callback: (error?: Error | null) => void): void;
+    destroy(error?: Error): this;
+    write(chunk: any, encoding?: string | ((error?: Error | null) => void), callback?: (error?: Error | null) => void): boolean;
+    end(chunk?: any, encoding?: string | (() => void), callback?: () => void): this;
+    cork(): void;
+    uncork(): void;
+    setDefaultEncoding(encoding: string): this;
+}
+export declare class Transform extends Duplex {
+    private _transformImpl;
+    private _flushImpl;
+    constructor(opts?: TransformOptions);
+    _transform(chunk: any, encoding: string, callback: (error?: Error | null, data?: any) => void): void;
+    _flush(callback: (error?: Error | null, data?: any) => void): void;
+    _write(chunk: any, encoding: string, callback: (error?: Error | null) => void): void;
+    _final(callback: (error?: Error | null) => void): void;
+}
+export declare class PassThrough extends Transform {
+    constructor(opts?: TransformOptions);
+}
+type PipelineCallback = (err: Error | null) => void;
+/** A stream that can be destroyed (duck-typed for pipeline). */
+interface DestroyableStream extends Stream {
+    destroy?(error?: Error): void;
+}
+export declare function pipeline(...args: [...streams: DestroyableStream[], callback: PipelineCallback] | DestroyableStream[]): DestroyableStream;
+export declare function finished(stream: Stream | Readable | Writable, callback: (err?: Error | null) => void): () => void;
+export declare function finished(stream: Stream | Readable | Writable, opts: FinishedOptions, callback: (err?: Error | null) => void): () => void;
+export declare function addAbortSignal(signal: AbortSignal, stream: Stream): typeof stream;
+export declare function isReadable(stream: unknown): boolean;
+export declare function isWritable(stream: unknown): boolean;
+export declare function isDestroyed(stream: unknown): boolean;
+export declare function isDisturbed(stream: unknown): boolean;
+export declare function isErrored(stream: unknown): boolean;
+declare const _default: typeof Stream & {
+    Stream: typeof Stream;
+    Readable: typeof Readable;
+    Writable: typeof Writable;
+    Duplex: typeof Duplex;
+    Transform: typeof Transform;
+    PassThrough: typeof PassThrough;
+    pipeline: typeof pipeline;
+    finished: typeof finished;
+    addAbortSignal: typeof addAbortSignal;
+    isReadable: typeof isReadable;
+    isWritable: typeof isWritable;
+    isDestroyed: typeof isDestroyed;
+    isDisturbed: typeof isDisturbed;
+    isErrored: typeof isErrored;
+    getDefaultHighWaterMark: typeof getDefaultHighWaterMark;
+    setDefaultHighWaterMark: typeof setDefaultHighWaterMark;
+};
+export default _default;

package/lib/types/promises/index.d.ts

@@ -1,3 +1,8 @@
-export * from '@gjsify/deno_std/node/stream/promises';
-import promises from '@gjsify/deno_std/node/stream/promises';
-export default promises;
+import type { Stream, Readable, Writable } from '../index.js';
+export declare function pipeline(...streams: any[]): Promise<void>;
+export declare function finished(stream: Stream | Readable | Writable, opts?: any): Promise<void>;
+declare const _default: {
+    pipeline: typeof pipeline;
+    finished: typeof finished;
+};
+export default _default;

package/lib/types/web/index.d.ts

@@ -1,3 +1,3 @@
-export * from '@gjsify/deno_std/node/stream/web';
-import web from '@gjsify/deno_std/node/stream/web';
-export default web;
+export { ReadableStream, WritableStream, TransformStream, ByteLengthQueuingStrategy, CountQueuingStrategy, TextEncoderStream, TextDecoderStream, } from '@gjsify/web-streams';
+declare const _default: Record<string, any>;
+export default _default;

package/package.json

@@ -1,63 +1,39 @@
 {
   "name": "@gjsify/stream",
-  "version": "0.0.4",
+  "version": "0.1.0",
   "description": "Node.js stream module for Gjs",
   "type": "module",
-  "main": "lib/cjs/index.js",
   "module": "lib/esm/index.js",
-  "types": "lib/types/index.d.js",
+  "types": "lib/types/index.d.ts",
   "exports": {
     ".": {
-      "import": {
-        "types": "./lib/types/index.d.ts",
-        "default": "./lib/esm/index.js"
-      },
-      "require": {
-        "types": "./lib/types/index.d.ts",
-        "default": "./lib/cjs/index.js"
-      }
+      "types": "./lib/types/index.d.ts",
+      "require": "./cjs-compat.cjs",
+      "default": "./lib/esm/index.js"
     },
     "./consumers": {
-      "import": {
-        "types": "./lib/types/consumers/index.d.ts",
-        "default": "./lib/esm/consumers/index.js"
-      },
-      "require": {
-        "types": "./lib/types/consumers/index.d.ts",
-        "default": "./lib/cjs/consumers/index.js"
-      }
+      "types": "./lib/types/consumers/index.d.ts",
+      "default": "./lib/esm/consumers/index.js"
     },
     "./promises": {
-      "import": {
-        "types": "./lib/types/promises/index.d.ts",
-        "default": "./lib/esm/promises/index.js"
-      },
-      "require": {
-        "types": "./lib/types/promises/index.d.ts",
-        "default": "./lib/cjs/promises/index.js"
-      }
+      "types": "./lib/types/promises/index.d.ts",
+      "default": "./lib/esm/promises/index.js"
     },
     "./web": {
-      "import": {
-        "types": "./lib/types/web/index.d.ts",
-        "default": "./lib/esm/web/index.js"
-      },
-      "require": {
-        "types": "./lib/types/web/index.d.ts",
-        "default": "./lib/cjs/web/index.js"
-      }
+      "types": "./lib/types/web/index.d.ts",
+      "default": "./lib/esm/web/index.js"
     }
   },
   "scripts": {
-    "clear": "rm -rf lib tsconfig.tsbuildinfo tsconfig.types.tsbuildinfo || exit 0",
-    "print:name": "echo '@gjsify/stream'",
-    "build": "yarn print:name && yarn build:gjsify && yarn build:types",
+    "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 --project tsconfig.types.json || exit 0",
+    "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 print:name && yarn build:gjsify && yarn build:test && yarn test:node && yarn test:gjs",
+    "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"
   },
@@ -67,12 +43,14 @@
     "stream"
   ],
   "devDependencies": {
-    "@gjsify/cli": "^0.0.4",
-    "@gjsify/unit": "^0.0.4",
-    "@types/node": "^20.10.5",
-    "typescript": "^5.3.3"
+    "@gjsify/cli": "^0.1.0",
+    "@gjsify/unit": "^0.1.0",
+    "@types/node": "^25.5.0",
+    "typescript": "^6.0.2"
   },
   "dependencies": {
-    "@gjsify/deno_std": "^0.0.4"
+    "@gjsify/events": "^0.1.0",
+    "@gjsify/utils": "^0.1.0",
+    "@gjsify/web-streams": "^0.1.0"
   }
 }

package/src/consumers/index.spec.ts

@@ -0,0 +1,107 @@
+// Tests for stream/consumers module
+// Reference: Node.js lib/stream/consumers.js
+
+import { describe, it, expect } from '@gjsify/unit';
+import { Readable } from 'node:stream';
+import { text, json, buffer, arrayBuffer, blob } from 'node:stream/consumers';
+
+export default async () => {
+  await describe('stream/consumers', async () => {
+
+    // ==================== text() ====================
+    await describe('text', async () => {
+      await it('should consume stream as text', async () => {
+        const stream = Readable.from(['Hello', ' ', 'World']);
+        const result = await text(stream);
+        expect(result).toBe('Hello World');
+      });
+
+      await it('should handle empty stream', async () => {
+        const stream = Readable.from([]);
+        const result = await text(stream);
+        expect(result).toBe('');
+      });
+
+      await it('should handle single chunk', async () => {
+        const stream = Readable.from(['single']);
+        const result = await text(stream);
+        expect(result).toBe('single');
+      });
+    });
+
+    // ==================== json() ====================
+    await describe('json', async () => {
+      await it('should consume stream as JSON', async () => {
+        const stream = Readable.from(['{"key":', '"value"}']);
+        const result = await json(stream);
+        expect(result.key).toBe('value');
+      });
+
+      await it('should parse JSON array', async () => {
+        const stream = Readable.from(['[1,2,3]']);
+        const result = await json(stream);
+        expect(Array.isArray(result)).toBe(true);
+        expect(result.length).toBe(3);
+        expect(result[0]).toBe(1);
+      });
+
+      await it('should parse JSON number', async () => {
+        const stream = Readable.from(['42']);
+        const result = await json(stream);
+        expect(result).toBe(42);
+      });
+    });
+
+    // ==================== buffer() ====================
+    await describe('buffer', async () => {
+      await it('should consume stream as Uint8Array', async () => {
+        const stream = Readable.from(['Hello']);
+        const result = await buffer(stream);
+        expect(result instanceof Uint8Array).toBe(true);
+        expect(result.length).toBeGreaterThan(0);
+      });
+
+      await it('should handle empty stream', async () => {
+        const stream = Readable.from([]);
+        const result = await buffer(stream);
+        expect(result instanceof Uint8Array).toBe(true);
+        expect(result.length).toBe(0);
+      });
+    });
+
+    // ==================== arrayBuffer() ====================
+    await describe('arrayBuffer', async () => {
+      await it('should consume stream as ArrayBuffer', async () => {
+        const stream = Readable.from(['Hello']);
+        const result = await arrayBuffer(stream);
+        expect(result instanceof ArrayBuffer).toBe(true);
+        expect(result.byteLength).toBeGreaterThan(0);
+      });
+
+      await it('should handle multiple chunks', async () => {
+        const stream = Readable.from(['AB', 'CD']);
+        const result = await arrayBuffer(stream);
+        const view = new Uint8Array(result);
+        const str = new TextDecoder().decode(view);
+        expect(str).toBe('ABCD');
+      });
+    });
+
+    // ==================== blob() ====================
+    await describe('blob', async () => {
+      await it('should consume stream as Blob', async () => {
+        const stream = Readable.from(['Hello Blob']);
+        const result = await blob(stream);
+        expect(result instanceof Blob).toBe(true);
+        expect(result.size).toBeGreaterThan(0);
+      });
+
+      await it('should have correct content', async () => {
+        const stream = Readable.from(['test']);
+        const result = await blob(stream);
+        const t = await result.text();
+        expect(t).toBe('test');
+      });
+    });
+  });
+};

package/src/consumers/index.ts

@@ -1,3 +1,39 @@
-export * from '@gjsify/deno_std/node/stream/consumers';
-import consumers from '@gjsify/deno_std/node/stream/consumers';
-export default consumers;
+// stream/consumers — Utility functions for consuming readable streams
+
+export async function arrayBuffer(stream: ReadableStream | AsyncIterable<any>): Promise<ArrayBuffer> {
+  const chunks: Uint8Array[] = [];
+  for await (const chunk of stream as AsyncIterable<any>) {
+    chunks.push(chunk instanceof Uint8Array ? chunk : new TextEncoder().encode(String(chunk)));
+  }
+  const totalLength = chunks.reduce((acc, c) => acc + c.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return result.buffer;
+}
+
+export async function blob(stream: ReadableStream | AsyncIterable<any>): Promise<Blob> {
+  const buf = await arrayBuffer(stream);
+  return new Blob([buf]);
+}
+
+export async function buffer(stream: ReadableStream | AsyncIterable<any>): Promise<any> {
+  const buf = await arrayBuffer(stream);
+  // Return as Uint8Array (Buffer-compatible)
+  return new Uint8Array(buf);
+}
+
+export async function text(stream: ReadableStream | AsyncIterable<any>): Promise<string> {
+  const buf = await arrayBuffer(stream);
+  return new TextDecoder().decode(buf);
+}
+
+export async function json(stream: ReadableStream | AsyncIterable<any>): Promise<any> {
+  const str = await text(stream);
+  return JSON.parse(str);
+}
+
+export default { arrayBuffer, blob, buffer, text, json };