@gjsify/stream 0.4.0 → 0.4.4

package/package.json

@@ -1,56 +1,60 @@
 {
-  "name": "@gjsify/stream",
-  "version": "0.4.0",
-  "description": "Node.js stream module for Gjs",
-  "type": "module",
-  "module": "lib/esm/index.js",
-  "types": "lib/types/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./lib/types/index.d.ts",
-      "require": "./cjs-compat.cjs",
-      "default": "./lib/esm/index.js"
+    "name": "@gjsify/stream",
+    "version": "0.4.4",
+    "description": "Node.js stream module for Gjs",
+    "type": "module",
+    "module": "lib/esm/index.js",
+    "types": "lib/types/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./lib/types/index.d.ts",
+            "require": "./cjs-compat.cjs",
+            "default": "./lib/esm/index.js"
+        },
+        "./consumers": {
+            "types": "./lib/types/consumers/index.d.ts",
+            "default": "./lib/esm/consumers/index.js"
+        },
+        "./promises": {
+            "types": "./lib/types/promises/index.d.ts",
+            "default": "./lib/esm/promises/index.js"
+        },
+        "./web": {
+            "types": "./lib/types/web/index.d.ts",
+            "default": "./lib/esm/web/index.js"
+        }
     },
-    "./consumers": {
-      "types": "./lib/types/consumers/index.d.ts",
-      "default": "./lib/esm/consumers/index.js"
+    "files": [
+        "lib",
+        "cjs-compat.cjs"
+    ],
+    "scripts": {
+        "clear": "rm -rf lib tsconfig.tsbuildinfo tsconfig.types.tsbuildinfo test.gjs.mjs test.node.mjs || exit 0",
+        "check": "tsc --noEmit",
+        "build": "gjsify run build:gjsify && gjsify run build:types",
+        "build:gjsify": "gjsify build --library 'src/**/*.{ts,js}' --exclude 'src/**/*.spec.{mts,ts}' 'src/test.{mts,ts}'",
+        "build:types": "tsc",
+        "build:test": "gjsify run build:test:gjs && gjsify run 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": "gjsify run build:gjsify && gjsify run build:test && gjsify run test:node && gjsify run test:gjs",
+        "test:gjs": "gjsify run test.gjs.mjs",
+        "test:node": "node test.node.mjs"
     },
-    "./promises": {
-      "types": "./lib/types/promises/index.d.ts",
-      "default": "./lib/esm/promises/index.js"
+    "keywords": [
+        "gjs",
+        "node",
+        "stream"
+    ],
+    "devDependencies": {
+        "@gjsify/cli": "^0.4.4",
+        "@gjsify/unit": "^0.4.4",
+        "@types/node": "^25.6.2",
+        "typescript": "^6.0.3"
     },
-    "./web": {
-      "types": "./lib/types/web/index.d.ts",
-      "default": "./lib/esm/web/index.js"
+    "dependencies": {
+        "@gjsify/events": "^0.4.4",
+        "@gjsify/utils": "^0.4.4",
+        "@gjsify/web-streams": "^0.4.4"
     }
-  },
-  "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": "gjsify run test.gjs.mjs",
-    "test:node": "node test.node.mjs"
-  },
-  "keywords": [
-    "gjs",
-    "node",
-    "stream"
-  ],
-  "devDependencies": {
-    "@gjsify/cli": "^0.4.0",
-    "@gjsify/unit": "^0.4.0",
-    "@types/node": "^25.6.2",
-    "typescript": "^6.0.3"
-  },
-  "dependencies": {
-    "@gjsify/events": "^0.4.0",
-    "@gjsify/utils": "^0.4.0",
-    "@gjsify/web-streams": "^0.4.0"
-  }
-}
+}

package/src/callable.spec.ts

@@ -1,196 +0,0 @@
-// Legacy `.call(this)` + `util.inherits(Sub, Parent)` compatibility tests.
-//
-// Ported from refs/node-test/parallel/test-util-inherits.js
-// Original: MIT license, Node.js contributors
-// Modifications: adapted to @gjsify/unit and extended to cover all six stream
-// classes that are wrapped by `makeCallable` in `./callable.ts`.
-//
-// Regression coverage for the npm `send` (express.static) bug and for our own
-// `@gjsify/crypto` `Hash.copy()` path which both do `Stream.call(this)` /
-// `Transform.call(copy)` on pre-ES2015 CJS-style constructors.
-
-import { describe, it, expect } from '@gjsify/unit';
-import { Stream, Readable, Writable, Duplex, Transform, PassThrough } from 'node:stream';
-import { inherits } from 'node:util';
-
-export default async () => {
-	await describe('makeCallable: new invocation still works', async () => {
-		await it('new Stream() returns a valid instance', async () => {
-			const s = new Stream();
-			expect(typeof (s as any).pipe).toBe('function');
-			expect(s instanceof Stream).toBe(true);
-		});
-
-		await it('new Readable() initialises readable state', async () => {
-			const r = new Readable({ read() {} });
-			expect(r.readable).toBe(true);
-			expect(r instanceof Readable).toBe(true);
-			expect(r instanceof Stream).toBe(true);
-		});
-
-		await it('new Transform() initialises both readable + writable state', async () => {
-			const t = new Transform({ transform(chunk, _enc, cb) { cb(null, chunk); } });
-			expect(t.readable).toBe(true);
-			expect(t.writable).toBe(true);
-			expect(t instanceof Transform).toBe(true);
-			expect(t instanceof Duplex).toBe(true);
-			expect(t instanceof Readable).toBe(true);
-		});
-
-		await it('Stream.prototype is accessible via the wrapper', async () => {
-			expect(typeof (Stream as any).prototype).toBe('object');
-			expect(typeof (Stream as any).prototype.pipe).toBe('function');
-		});
-	});
-
-	await describe('makeCallable: no-new invocation (legacy stream constructors)', async () => {
-		// Regression: Node's stream constructors guard against missing-new
-		// with `if (!(this instanceof Cls)) return new Cls(...)`. Consumers
-		// like `merge2` (used by `fast-glob`) call `Stream.PassThrough(opts)`
-		// without `new` and rely on the result being a real instance. The
-		// makeCallable apply trap must auto-construct in that case rather
-		// than try to mutate `undefined`/`globalThis`.
-		await it('PassThrough(opts) without new returns an instance', async () => {
-			const pt: any = (PassThrough as any)({});
-			expect(pt instanceof PassThrough).toBe(true);
-			expect(pt instanceof Transform).toBe(true);
-			expect(typeof pt.pipe).toBe('function');
-		});
-
-		await it('Readable({read}) without new returns an instance', async () => {
-			const r: any = (Readable as any)({ read() {} });
-			expect(r instanceof Readable).toBe(true);
-			expect(r.readable).toBe(true);
-		});
-
-		await it('Writable({write}) without new returns an instance', async () => {
-			const w: any = (Writable as any)({ write(_c: any, _e: any, cb: any) { cb(); } });
-			expect(w instanceof Writable).toBe(true);
-			expect(w.writable).toBe(true);
-		});
-
-		await it('PassThrough() pipes data through a no-new instance', async () => {
-			const pt: any = (PassThrough as any)();
-			const chunks: Buffer[] = [];
-			await new Promise<void>((resolve, reject) => {
-				pt.on('data', (c: Buffer) => chunks.push(c));
-				pt.on('end', resolve);
-				pt.on('error', reject);
-				pt.end(Buffer.from('hello'));
-			});
-			expect(Buffer.concat(chunks).toString()).toBe('hello');
-		});
-	});
-
-	await describe('makeCallable: legacy Stream.call(this) + util.inherits', async () => {
-		await it('Stream.call(plainObject) assigns EventEmitter bookkeeping', async () => {
-			// Plain object promoted to a Stream via .call()
-			const plain: any = Object.create(Stream.prototype);
-			(Stream as any).call(plain);
-			// EventEmitter state is now present
-			plain.on('ping', function(this: any, msg: string) { this.received = msg; });
-			plain.emit('ping', 'hi');
-			expect(plain.received).toBe('hi');
-		});
-
-		await it('legacy subclass pattern (function + inherits + .call) works', async () => {
-			function SubStream(this: any) {
-				(Stream as any).call(this);
-				this.foo = 42;
-			}
-			inherits(SubStream as any, Stream as any);
-			(SubStream.prototype as any).greet = function() { return 'hello'; };
-
-			const s: any = new (SubStream as any)();
-			expect(s.foo).toBe(42);
-			expect(s.greet()).toBe('hello');
-			// Inherited from Stream.prototype
-			expect(typeof s.pipe).toBe('function');
-			expect(s instanceof Stream).toBe(true);
-		});
-
-		await it('multi-level inherits (A.call -> B.call -> C) works', async () => {
-			function A(this: any) {
-				(Stream as any).call(this);
-				this._a = 'a';
-			}
-			inherits(A as any, Stream as any);
-			(A.prototype as any).a = function() { return this._a; };
-
-			function B(this: any) {
-				(A as any).call(this);
-				this._b = 'b';
-			}
-			inherits(B as any, A as any);
-			(B.prototype as any).b = function() { return this._b; };
-
-			const b: any = new (B as any)();
-			expect(b.a()).toBe('a');
-			expect(b.b()).toBe('b');
-			expect(b instanceof A).toBe(true);
-			expect(b instanceof Stream).toBe(true);
-		});
-	});
-
-	await describe('makeCallable: Readable / Writable / Transform .call(this)', async () => {
-		await it('Readable.call(plain) sets up readable state', async () => {
-			const r: any = Object.create(Readable.prototype);
-			(Readable as any).call(r, { read() {} });
-			expect(r.readable).toBe(true);
-			expect(typeof r.readableHighWaterMark).toBe('number');
-			// pipe is inherited from Stream.prototype through Readable.prototype
-			expect(typeof r.pipe).toBe('function');
-		});
-
-		await it('Writable.call(plain) sets up writable state', async () => {
-			const w: any = Object.create(Writable.prototype);
-			(Writable as any).call(w, { write(_c: any, _e: any, cb: any) { cb(); } });
-			expect(w.writable).toBe(true);
-			expect(typeof w.writableHighWaterMark).toBe('number');
-		});
-
-		await it('Transform.call(plain) sets up both readable and writable state', async () => {
-			// This is the exact pattern used by @gjsify/crypto Hash.copy():
-			//   const copy = Object.create(Hash.prototype);
-			//   Transform.call(copy);
-			const copy: any = Object.create(Transform.prototype);
-			(Transform as any).call(copy);
-			expect(copy.readable).toBe(true);
-			expect(copy.writable).toBe(true);
-			// The Transform should be usable after .call() initialization —
-			// field initializers from all ancestors ran on copy.
-			expect(typeof copy.readableHighWaterMark).toBe('number');
-			expect(typeof copy.writableHighWaterMark).toBe('number');
-		});
-
-		await it('PassThrough.call(plain) inherits the full chain', async () => {
-			const pt: any = Object.create(PassThrough.prototype);
-			(PassThrough as any).call(pt);
-			expect(pt.readable).toBe(true);
-			expect(pt.writable).toBe(true);
-		});
-	});
-
-	await describe('makeCallable: integration with util.inherits', async () => {
-		await it('inherits(Sub, Readable) + Readable.call(this) yields a working Readable subclass', async () => {
-			function SimpleSrc(this: any, items: number[]) {
-				(Readable as any).call(this, { objectMode: true });
-				this._items = items;
-			}
-			inherits(SimpleSrc as any, Readable as any);
-			(SimpleSrc.prototype as any)._read = function() {
-				const item = this._items.shift();
-				this.push(item !== undefined ? item : null);
-			};
-
-			const src: any = new (SimpleSrc as any)([1, 2, 3]);
-			const out: number[] = [];
-			await new Promise<void>((resolve, reject) => {
-				src.on('data', (chunk: number) => out.push(chunk));
-				src.on('end', resolve);
-				src.on('error', reject);
-			});
-			expect(out).toEqualArray([1, 2, 3]);
-		});
-	});
-};

package/src/callable.ts

@@ -1,3 +0,0 @@
-// Re-exported from @gjsify/utils — second consumer (events) triggered promotion.
-// See packages/gjs/utils/src/callable.ts for implementation and comments.
-export { makeCallable } from '@gjsify/utils';

package/src/consumers/index.spec.ts

@@ -1,107 +0,0 @@
-// 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) as { key: string };
-        expect(result.key).toBe('value');
-      });
-
-      await it('should parse JSON array', async () => {
-        const stream = Readable.from(['[1,2,3]']);
-        const result = await json(stream) as number[];
-        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,39 +0,0 @@
-// 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 };