@gjsify/stream 0.4.0 → 0.4.4

package/src/index.ts

@@ -1,92 +0,0 @@
-// Reference: Node.js lib/stream.js, lib/internal/streams/*.js
-// Reimplemented for GJS using EventEmitter and microtask scheduling.
-//
-// This file is the public barrel — actual implementations live per-class:
-//   - stream-base.ts        Stream_ (root EventEmitter + pipe glue)
-//   - readable.ts           Readable_ (+ Readable_._autoClose protected hook)
-//   - writable.ts           Writable_ (+ FIFO drain queue)
-//   - duplex.ts             Duplex_   (Readable_ + writable-half re-implementation)
-//   - transform.ts          Transform_
-//   - passthrough.ts        PassThrough_
-//   - utils/pipe.ts         Stream.pipe() helper
-//   - utils/pipeline.ts     pipeline()
-//   - utils/finished.ts     finished(), addAbortSignal(), is{Readable,…}()
-//   - internal/state.ts     module-singleton defaults + validateHighWaterMark
-//   - internal/types.ts     shared interfaces
-//
-// Public class names are makeCallable Proxy wrappers around the underscore-suffixed
-// internal classes (`Stream_`, `Readable_`, …) so legacy CJS consumers can do
-// `Stream.call(this)` (npm `send`, `util.inherits(Sub, Stream)`, our own
-// `@gjsify/crypto` `Hash.copy()`). See `./callable.ts` for the rationale.
-//
-// The historical default export shape — the Stream constructor with all classes
-// + helpers attached as static properties — is preserved for `cjs-compat.cjs`.
-
-import { makeCallable } from './callable.js';
-
-import { Stream_ } from './stream-base.js';
-import { Readable_ } from './readable.js';
-// Side-effect import: wires Stream_.prototype.pipe → pipe() at load time.
-// See ./stream-base.ts (_setPipeImpl) for the late-binding rationale.
-import './utils/pipe.js';
-import { Writable_ } from './writable.js';
-import { Duplex_ } from './duplex.js';
-import { Transform_ } from './transform.js';
-import { PassThrough_ } from './passthrough.js';
-import { pipeline } from './utils/pipeline.js';
-import { finished, addAbortSignal, isReadable, isWritable, isDestroyed, isDisturbed, isErrored } from './utils/finished.js';
-import { getDefaultHighWaterMark, setDefaultHighWaterMark } from './internal/state.js';
-
-// ---- Re-exports of internal helpers ----
-
-export { getDefaultHighWaterMark, setDefaultHighWaterMark };
-export { pipeline, finished, addAbortSignal };
-export { isReadable, isWritable, isDestroyed, isDisturbed, isErrored };
-
-// ---- Type-only re-exports ----
-
-export type { ReadableOptions, WritableOptions, DuplexOptions, TransformOptions, FinishedOptions } from 'node:stream';
-export type { StreamOptions } from './internal/types.js';
-
-// ---- Class wrappers (callable for legacy CJS) ----
-
-export const Stream = makeCallable(Stream_) as typeof Stream_;
-export const Readable = makeCallable(Readable_) as typeof Readable_;
-export const Writable = makeCallable(Writable_) as typeof Writable_;
-export const Duplex = makeCallable(Duplex_) as typeof Duplex_;
-export const Transform = makeCallable(Transform_) as typeof Transform_;
-export const PassThrough = makeCallable(PassThrough_) as typeof PassThrough_;
-
-export type Stream = Stream_;
-export type Readable = Readable_;
-export type Writable = Writable_;
-export type Duplex = Duplex_;
-export type Transform = Transform_;
-export type PassThrough = PassThrough_;
-
-// ---- Default export ----
-//
-// Node returns the Stream constructor with sub-classes + helpers hung off it.
-// `cjs-compat.cjs` resolves `mod.default || mod` to this exact value, so the
-// legacy `util.inherits(Sub, require('stream'))` pattern keeps working.
-
-const _default = Object.assign(Stream, {
-  Stream,
-  Readable,
-  Writable,
-  Duplex,
-  Transform,
-  PassThrough,
-  pipeline,
-  finished,
-  addAbortSignal,
-  isReadable,
-  isWritable,
-  isDestroyed,
-  isDisturbed,
-  isErrored,
-  getDefaultHighWaterMark,
-  setDefaultHighWaterMark,
-});
-
-export default _default;

package/src/inheritance.spec.ts

@@ -1,315 +0,0 @@
-// Stream and util.inherits inheritance tests.
-//
-// Ported from:
-//   refs/node-test/parallel/test-stream-inheritance.js
-//   refs/node-test/parallel/test-util-inherits.js
-// Original: MIT license, Node.js contributors
-// Modifications: adapted to @gjsify/unit, async/await.
-
-import { describe, it, expect } from '@gjsify/unit';
-import { Readable, Writable, Duplex, Transform, PassThrough } from 'node:stream';
-import { inherits } from 'node:util';
-
-export default async () => {
-
-	// -------------------------------------------------------------------------
-	// instanceof hierarchy
-	// -------------------------------------------------------------------------
-	await describe('stream inheritance: instanceof checks', async () => {
-		await it('Readable is instanceof Readable only', async () => {
-			const r = new Readable({ read() {} });
-			expect(r instanceof Readable).toBe(true);
-			expect(r instanceof Writable).toBe(false);
-			expect(r instanceof Duplex).toBe(false);
-			expect(r instanceof Transform).toBe(false);
-		});
-
-		await it('Writable is instanceof Writable only', async () => {
-			const w = new Writable({ write(_c, _e, cb) { cb(); } });
-			expect(w instanceof Readable).toBe(false);
-			expect(w instanceof Writable).toBe(true);
-			expect(w instanceof Duplex).toBe(false);
-			expect(w instanceof Transform).toBe(false);
-		});
-
-		await it('Duplex is instanceof Readable and Writable and Duplex', async () => {
-			const d = new Duplex({ read() {}, write(_c, _e, cb) { cb(); } });
-			expect(d instanceof Readable).toBe(true);
-			expect(d instanceof Writable).toBe(true);
-			expect(d instanceof Duplex).toBe(true);
-			expect(d instanceof Transform).toBe(false);
-		});
-
-		await it('Transform is instanceof Readable, Writable, Duplex, and Transform', async () => {
-			const t = new Transform({ transform(_c, _e, cb) { cb(); } });
-			expect(t instanceof Readable).toBe(true);
-			expect(t instanceof Writable).toBe(true);
-			expect(t instanceof Duplex).toBe(true);
-			expect(t instanceof Transform).toBe(true);
-		});
-
-		await it('null and undefined are not instanceof Writable', async () => {
-			// Cast through unknown — TS rejects `null instanceof X` directly.
-			expect((null as unknown as object) instanceof Writable).toBe(false);
-			expect((undefined as unknown as object) instanceof Writable).toBe(false);
-		});
-
-		await it('PassThrough is instanceof Transform, Duplex, Readable, Writable', async () => {
-			const pt = new PassThrough();
-			expect(pt instanceof PassThrough).toBe(true);
-			expect(pt instanceof Transform).toBe(true);
-			expect(pt instanceof Duplex).toBe(true);
-			expect(pt instanceof Readable).toBe(true);
-			expect(pt instanceof Writable).toBe(true);
-		});
-	});
-
-	// -------------------------------------------------------------------------
-	// Object.setPrototypeOf-based subclass
-	// -------------------------------------------------------------------------
-	await describe('stream inheritance: Object.setPrototypeOf subclassing', async () => {
-		await it('subclass via setPrototypeOf is instanceof parent', async () => {
-			function CustomWritable(this: any) {}
-			Object.setPrototypeOf(CustomWritable, Writable);
-			Object.setPrototypeOf((CustomWritable as any).prototype, Writable.prototype);
-
-			const cw: any = new (CustomWritable as any)();
-			expect(cw instanceof CustomWritable).toBe(true);
-			expect(cw instanceof Writable).toBe(true);
-		});
-
-		await it('ES6 class extending Writable is instanceof Writable', async () => {
-			class MyWritable extends Writable {
-				_write(_c: any, _e: any, cb: () => void) { cb(); }
-			}
-			const mw = new MyWritable();
-			expect(mw instanceof Writable).toBe(true);
-			expect(mw instanceof MyWritable).toBe(true);
-		});
-
-		await it('different Writable subclasses are not cross-instanceof', async () => {
-			function CustomWritable(this: any) {}
-			Object.setPrototypeOf(CustomWritable, Writable);
-			Object.setPrototypeOf((CustomWritable as any).prototype, Writable.prototype);
-
-			class OtherWritable extends Writable {
-				_write(_c: any, _e: any, cb: () => void) { cb(); }
-			}
-
-			expect(new OtherWritable() instanceof (CustomWritable as any)).toBe(false);
-			expect(new (CustomWritable as any)() instanceof OtherWritable).toBe(false);
-		});
-	});
-
-	// -------------------------------------------------------------------------
-	// util.inherits — single and multi-level
-	// -------------------------------------------------------------------------
-	await describe('util.inherits: single-level inheritance', async () => {
-		await it('sets B.super_ to A', async () => {
-			function A(this: any) { this._a = 'a'; }
-			(A.prototype as any).a = function() { return this._a; };
-
-			function B(this: any, value: string) {
-				(A as any).call(this);
-				this._b = value;
-			}
-			inherits(B as any, A as any);
-
-			const desc = Object.getOwnPropertyDescriptor(B, 'super_');
-			expect(desc).toBeDefined();
-			expect((desc as any).value).toBe(A);
-			expect((desc as any).enumerable).toBe(false);
-			expect((desc as any).configurable).toBe(true);
-			expect((desc as any).writable).toBe(true);
-		});
-
-		await it('instance methods from parent are accessible on child', async () => {
-			function A(this: any) { this._a = 'a'; }
-			(A.prototype as any).a = function() { return this._a; };
-
-			function B(this: any, value: string) {
-				(A as any).call(this);
-				this._b = value;
-			}
-			inherits(B as any, A as any);
-			(B.prototype as any).b = function() { return this._b; };
-
-			const b: any = new (B as any)('hello');
-			expect(b.a()).toBe('a');
-			expect(b.b()).toBe('hello');
-			expect(b.constructor).toBe(B);
-		});
-	});
-
-	await describe('util.inherits: two-level inheritance', async () => {
-		await it('C inherits from B inherits from A — all methods accessible', async () => {
-			function A(this: any) { this._a = 'a'; }
-			(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; };
-
-			function C(this: any) { (B as any).call(this); this._c = 'c'; }
-			inherits(C as any, B as any);
-			(C.prototype as any).c = function() { return this._c; };
-			(C.prototype as any).getValue = function() { return this.a() + this.b() + this.c(); };
-
-			expect((C as any).super_).toBe(B);
-
-			const c: any = new (C as any)();
-			expect(c.getValue()).toBe('abc');
-			expect(c.constructor).toBe(C);
-		});
-	});
-
-	await describe('util.inherits: prototype methods set before inherits()', async () => {
-		await it('prototype methods defined before inherits() are preserved', async () => {
-			function A(this: any) { this._a = 'a'; }
-			(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; };
-
-			function D(this: any) { (B as any).call(this); this._d = 'd'; }
-			// Set method BEFORE calling inherits
-			(D.prototype as any).d = function() { return this._d; };
-			inherits(D as any, B as any);
-
-			expect((D as any).super_).toBe(B);
-			const d: any = new (D as any)();
-			expect(d.b()).toBe('b');
-			expect(d.d()).toBe('d');
-			expect(d.constructor).toBe(D);
-		});
-	});
-
-	await describe('util.inherits: invalid arguments', async () => {
-		await it('throws ERR_INVALID_ARG_TYPE when superCtor has no prototype', async () => {
-			function A(this: any) {}
-			let threw = false;
-			let code = '';
-			try {
-				inherits(A as any, {} as any);
-			} catch (e: any) {
-				threw = true;
-				code = e.code;
-			}
-			expect(threw).toBe(true);
-			expect(code).toBe('ERR_INVALID_ARG_TYPE');
-		});
-
-		await it('throws ERR_INVALID_ARG_TYPE when superCtor is null', async () => {
-			function A(this: any) {}
-			let threw = false;
-			let code = '';
-			try {
-				inherits(A as any, null as any);
-			} catch (e: any) {
-				threw = true;
-				code = e.code;
-			}
-			expect(threw).toBe(true);
-			expect(code).toBe('ERR_INVALID_ARG_TYPE');
-		});
-
-		await it('throws ERR_INVALID_ARG_TYPE when ctor is null', async () => {
-			function A(this: any) {}
-			(A.prototype as any).a = function() {};
-			let threw = false;
-			let code = '';
-			try {
-				inherits(null as any, A as any);
-			} catch (e: any) {
-				threw = true;
-				code = e.code;
-			}
-			expect(threw).toBe(true);
-			expect(code).toBe('ERR_INVALID_ARG_TYPE');
-		});
-	});
-
-	// -------------------------------------------------------------------------
-	// util.inherits + stream classes — integration
-	// -------------------------------------------------------------------------
-	await describe('util.inherits + stream: practical subclassing', async () => {
-		await it('function-based Readable subclass via inherits works', async () => {
-			function NumberSource(this: any, numbers: number[]) {
-				Readable.call(this, { objectMode: true });
-				this._numbers = numbers.slice();
-			}
-			inherits(NumberSource as any, Readable as any);
-			(NumberSource.prototype as any)._read = function() {
-				const n = this._numbers.shift();
-				this.push(n !== undefined ? n : null);
-			};
-
-			const collected: number[] = [];
-			const src: any = new (NumberSource as any)([10, 20, 30]);
-			await new Promise<void>((resolve, reject) => {
-				src.on('data', (n: number) => collected.push(n));
-				src.on('end', resolve);
-				src.on('error', reject);
-			});
-			expect(collected).toEqualArray([10, 20, 30]);
-			expect(src instanceof Readable).toBe(true);
-		});
-
-		await it('function-based Writable subclass via inherits works', async () => {
-			function CollectWritable(this: any) {
-				Writable.call(this);
-				this.collected = [];
-			}
-			inherits(CollectWritable as any, Writable as any);
-			(CollectWritable.prototype as any)._write = function(
-				chunk: Buffer,
-				_enc: string,
-				cb: () => void,
-			) {
-				this.collected.push(chunk.toString());
-				cb();
-			};
-
-			const cw: any = new (CollectWritable as any)();
-			await new Promise<void>((resolve, reject) => {
-				cw.on('finish', resolve);
-				cw.on('error', reject);
-				cw.write('hello');
-				cw.write('world');
-				cw.end();
-			});
-			expect(cw.collected).toEqualArray(['hello', 'world']);
-			expect(cw instanceof Writable).toBe(true);
-		});
-
-		await it('function-based Transform subclass via inherits works', async () => {
-			function UpperCase(this: any) {
-				Transform.call(this);
-			}
-			inherits(UpperCase as any, Transform as any);
-			(UpperCase.prototype as any)._transform = function(
-				chunk: Buffer,
-				_enc: string,
-				cb: (err: null, data: Buffer) => void,
-			) {
-				cb(null, Buffer.from(chunk.toString().toUpperCase()));
-			};
-
-			const out: string[] = [];
-			const uc: any = new (UpperCase as any)();
-			await new Promise<void>((resolve, reject) => {
-				uc.on('data', (chunk: Buffer) => out.push(chunk.toString()));
-				uc.on('end', resolve);
-				uc.on('error', reject);
-				uc.write('hello');
-				uc.write('world');
-				uc.end();
-			});
-			expect(out).toEqualArray(['HELLO', 'WORLD']);
-			expect(uc instanceof Transform).toBe(true);
-			expect(uc instanceof Readable).toBe(true);
-			expect(uc instanceof Writable).toBe(true);
-		});
-	});
-};

package/src/internal/state.ts

@@ -1,34 +0,0 @@
-// Module-singleton state for the stream module.
-//
-// Reference: refs/node/lib/internal/streams/state.js
-// Reimplemented for GJS — currently only the default high-water-mark pair.
-// Centralised here so per-class files (Readable, Writable, Duplex) do not
-// duplicate or fight over the values.
-
-let defaultHighWaterMark = 16384;
-let defaultObjectHighWaterMark = 16;
-
-export function getDefaultHighWaterMark(objectMode: boolean): number {
-  return objectMode ? defaultObjectHighWaterMark : defaultHighWaterMark;
-}
-
-export function setDefaultHighWaterMark(objectMode: boolean, value: number): void {
-  if (typeof value !== 'number' || value < 0 || Number.isNaN(value)) {
-    throw new TypeError(`Invalid highWaterMark: ${value}`);
-  }
-  if (objectMode) {
-    defaultObjectHighWaterMark = value;
-  } else {
-    defaultHighWaterMark = value;
-  }
-}
-
-/** Validate a named high-water-mark option and throw ERR_INVALID_ARG_VALUE on NaN/non-number. */
-export function validateHighWaterMark(name: string, value: unknown): void {
-  if (value === undefined) return;
-  if (typeof value !== 'number' || Number.isNaN(value)) {
-    const err = new TypeError(`The value of "${name}" is invalid. Received ${value}`) as Error & { code?: string };
-    err.code = 'ERR_INVALID_ARG_VALUE';
-    throw err;
-  }
-}

package/src/internal/types.ts

@@ -1,31 +0,0 @@
-// Shared types used across the per-class stream modules.
-//
-// Reference: refs/node/lib/stream.js, refs/node/lib/internal/streams/*.js
-// Reimplemented for GJS — kept tiny on purpose; per-class files own their own
-// public option interfaces (re-exported via Node's `node:stream` types).
-
-import type { EventEmitter } from '@gjsify/events';
-
-/** Base options accepted by the Stream constructor (superset used by subclass options). */
-export interface StreamOptions {
-  highWaterMark?: number;
-  objectMode?: boolean;
-  signal?: AbortSignal;
-  captureRejections?: boolean;
-}
-
-/** A stream-like emitter that may have `pause` and `resume` methods (duck-typed). */
-export interface StreamLike extends EventEmitter {
-  pause?(): void;
-  resume?(): void;
-}
-
-/** Internal write-buffer entry shared by Writable and Duplex queues. */
-export interface BufferedWrite {
-  chunk: unknown;
-  encoding: string;
-  callback: (error?: Error | null) => void;
-}
-
-/** Generic node-style error callback. */
-export type ErrCallback = (error?: Error | null) => void;

package/src/passthrough.ts

@@ -1,19 +0,0 @@
-// PassThrough — Transform whose `_transform` is the identity.
-//
-// Reference: refs/node/lib/internal/streams/passthrough.js
-// Reimplemented for GJS.
-
-import type { TransformOptions } from 'node:stream';
-
-import { Transform_ } from './transform.js';
-
-export class PassThrough_ extends Transform_ {
-  constructor(opts?: TransformOptions) {
-    super({
-      ...opts,
-      transform(chunk: unknown, _encoding: string, callback: (error?: Error | null, data?: unknown) => void) {
-        callback(null, chunk);
-      }
-    });
-  }
-}