@gjsify/stream 0.1.6 → 0.1.8

package/lib/esm/callable.js

@@ -0,0 +1,4 @@
+import { makeCallable } from "@gjsify/utils";
+export {
+  makeCallable
+};

package/lib/esm/index.js

@@ -15,50 +15,81 @@ function setDefaultHighWaterMark(objectMode, value) {
     defaultHighWaterMark = value;
   }
 }
-class Stream extends EventEmitter {
+function validateHighWaterMark(name, value) {
+  if (value === void 0) return;
+  if (typeof value !== "number" || Number.isNaN(value)) {
+    const err = new TypeError(`The value of "${name}" is invalid. Received ${value}`);
+    err.code = "ERR_INVALID_ARG_VALUE";
+    throw err;
+  }
+}
+class Stream_ extends EventEmitter {
   constructor(opts) {
     super(opts);
   }
   pipe(destination, options) {
     const source = this;
     const doEnd = options?.end !== false;
+    let drainListenerAdded = false;
+    const ondrain = () => {
+      drainListenerAdded = false;
+      destination.removeListener("drain", ondrain);
+      if (typeof source.resume === "function") {
+        source.resume();
+      }
+    };
     const ondata = (chunk) => {
       if (destination.writable) {
         if (destination.write(chunk) === false && typeof source.pause === "function") {
           source.pause();
+          if (!drainListenerAdded) {
+            drainListenerAdded = true;
+            destination.on("drain", ondrain);
+          }
         }
       }
     };
     source.on("data", ondata);
-    const ondrain = () => {
-      if (typeof source.resume === "function") {
-        source.resume();
-      }
-    };
-    destination.on("drain", ondrain);
+    let didEnd = false;
     const onend = () => {
+      if (didEnd) return;
+      didEnd = true;
+      if (doEnd) destination.end();
+    };
+    const onclose = () => {
+      if (didEnd) return;
+      didEnd = true;
       if (doEnd) {
-        destination.end();
+        if (!(source instanceof Readable) && typeof destination.destroy === "function") {
+          destination.destroy();
+        }
       }
     };
     if (doEnd) {
       source.on("end", onend);
+      source.on("close", onclose);
     }
     const cleanup = () => {
       source.removeListener("data", ondata);
-      destination.removeListener("drain", ondrain);
+      if (drainListenerAdded) destination.removeListener("drain", ondrain);
       source.removeListener("end", onend);
+      source.removeListener("close", onclose);
+      source.removeListener("end", cleanup);
+      source.removeListener("close", cleanup);
+      destination.removeListener("close", cleanup);
     };
+    source.on("end", cleanup);
     source.on("close", cleanup);
     destination.on("close", cleanup);
     if (source instanceof Readable) {
-      source._pipeDests.push({ dest: destination, ondata, ondrain, onend, cleanup, doEnd });
+      source._pipeDests.push({ dest: destination, cleanup });
+      source._readableState.pipes.push(destination);
     }
     destination.emit("pipe", source);
     return destination;
   }
 }
-class Readable extends Stream {
+class Readable_ extends Stream_ {
   readable = true;
   readableFlowing = null;
   readableLength = 0;
@@ -71,7 +102,7 @@ class Readable extends Stream {
   /** @internal Tracked pipe destinations for unpipe. */
   _pipeDests = [];
   _buffer = [];
-  _readableState = { ended: false, endEmitted: false, reading: false, constructed: true };
+  _readableState = { ended: false, endEmitted: false, reading: false, constructed: true, highWaterMark: 0, objectMode: false, pipes: [] };
   _readablePending = false;
   _readImpl;
   _destroyImpl;
@@ -81,6 +112,8 @@ class Readable extends Stream {
     this.readableHighWaterMark = opts?.highWaterMark ?? getDefaultHighWaterMark(opts?.objectMode ?? false);
     this.readableEncoding = opts?.encoding ?? null;
     this.readableObjectMode = opts?.objectMode ?? false;
+    this._readableState.highWaterMark = this.readableHighWaterMark;
+    this._readableState.objectMode = this.readableObjectMode;
     if (opts?.read) this._readImpl = opts.read;
     if (opts?.destroy) this._destroyImpl = opts.destroy;
     if (opts?.construct) this._constructImpl = opts.construct;
@@ -194,6 +227,17 @@ class Readable extends Stream {
       this._scheduleReadable();
       return false;
     }
+    if (!this.readableObjectMode) {
+      const isValid = typeof chunk === "string" || ArrayBuffer.isView(chunk);
+      if (!isValid) {
+        const err = Object.assign(
+          new TypeError(`Invalid non-string/buffer chunk type: ${typeof chunk}`),
+          { code: "ERR_INVALID_ARG_TYPE" }
+        );
+        nextTick(() => this.emit("error", err));
+        return false;
+      }
+    }
     this._buffer.push(chunk);
     this.readableLength += this.readableObjectMode ? 1 : chunk.length ?? 1;
     if (this.readableFlowing && !this._flowing) {
@@ -299,6 +343,7 @@ class Readable extends Stream {
         state.dest.emit("unpipe", this);
       }
       this._pipeDests = [];
+      this._readableState.pipes = [];
       this.readableFlowing = false;
     } else {
       const idx = this._pipeDests.findIndex((s) => s.dest === destination);
@@ -306,6 +351,8 @@ class Readable extends Stream {
         const state = this._pipeDests[idx];
         state.cleanup();
         this._pipeDests.splice(idx, 1);
+        const pipeIdx = this._readableState.pipes.indexOf(destination);
+        if (pipeIdx !== -1) this._readableState.pipes.splice(pipeIdx, 1);
         destination.emit("unpipe", this);
         if (this._pipeDests.length === 0) {
           this.readableFlowing = false;
@@ -314,6 +361,13 @@ class Readable extends Stream {
     }
     return this;
   }
+  _destroy(error, callback) {
+    if (this._destroyImpl) {
+      this._destroyImpl.call(this, error, callback);
+    } else {
+      callback(error ?? void 0);
+    }
+  }
   destroy(error) {
     if (this.destroyed) return this;
     this.destroyed = true;
@@ -323,7 +377,9 @@ class Readable extends Stream {
       if (err) nextTick(() => this.emit("error", err));
       nextTick(() => this.emit("close"));
     };
-    if (this._destroyImpl) {
+    if (Object.prototype.hasOwnProperty.call(this, "_destroy")) {
+      this._destroy(error ?? null, cb);
+    } else if (this._destroyImpl) {
       this._destroyImpl.call(this, error ?? null, cb);
     } else {
       cb(error);
@@ -412,7 +468,19 @@ class Readable extends Stream {
     return readable;
   }
 }
-class Writable extends Stream {
+class Writable_ extends Stream_ {
+  // Allow `duplex instanceof Writable` to return true even though Duplex inherits
+  // from Readable_ only. Mirrors Node.js: standard prototype-chain check first,
+  // then duck-type fallback — but only when checking against Writable itself, not
+  // against a user subclass. Because `Writable` is exported as a makeCallable Proxy,
+  // `this === Writable_` fails for `obj instanceof Writable`; however the Proxy's
+  // default `get` trap forwards `.prototype` straight to the target, so the
+  // prototype reference check below correctly recognises both.
+  static [Symbol.hasInstance](obj) {
+    if (typeof this.prototype !== "undefined" && Object.prototype.isPrototypeOf.call(this.prototype, obj)) return true;
+    if (this.prototype !== Writable_.prototype) return false;
+    return obj !== null && obj !== void 0 && typeof obj.writableHighWaterMark === "number";
+  }
   writable = true;
   writableHighWaterMark;
   writableLength = 0;
@@ -509,7 +577,7 @@ class Writable extends Stream {
       } else {
         nextTick(() => {
           callback();
-          if (this.writableNeedDrain && this.writableLength < this.writableHighWaterMark) {
+          if (this.writableNeedDrain && this.writableLength <= this.writableHighWaterMark) {
             this.writableNeedDrain = false;
             this.emit("drain");
           }
@@ -645,7 +713,7 @@ class Writable extends Stream {
           this.emit("error", err);
         } else {
           for (const b of buffered) b.callback();
-          if (this.writableNeedDrain && this.writableLength < this.writableHighWaterMark) {
+          if (this.writableNeedDrain && this.writableLength <= this.writableHighWaterMark) {
             this.writableNeedDrain = false;
             this.emit("drain");
           }
@@ -680,7 +748,7 @@ class Writable extends Stream {
     return this;
   }
 }
-class Duplex extends Readable {
+class Duplex_ extends Readable_ {
   writable = true;
   writableHighWaterMark;
   writableLength = 0;
@@ -691,6 +759,8 @@ class Duplex extends Readable {
   writableNeedDrain = false;
   allowHalfOpen;
   _decodeStrings;
+  // Exposed writable-side state (mirrors Node.js _writableState for split HWM tests)
+  _writableState = { highWaterMark: 0, objectMode: false };
   _duplexCorkedBuffer = [];
   _writeImpl;
   _finalImpl;
@@ -699,8 +769,24 @@ class Duplex extends Readable {
   _pendingEndCb = null;
   constructor(opts) {
     super(opts);
-    this.writableHighWaterMark = opts?.writableHighWaterMark ?? opts?.highWaterMark ?? getDefaultHighWaterMark(opts?.writableObjectMode ?? opts?.objectMode ?? false);
+    validateHighWaterMark("writableHighWaterMark", opts?.writableHighWaterMark);
+    validateHighWaterMark("readableHighWaterMark", opts?.readableHighWaterMark);
     this.writableObjectMode = opts?.writableObjectMode ?? opts?.objectMode ?? false;
+    this.writableHighWaterMark = opts?.highWaterMark ?? opts?.writableHighWaterMark ?? getDefaultHighWaterMark(this.writableObjectMode);
+    this._writableState.highWaterMark = this.writableHighWaterMark;
+    this._writableState.objectMode = this.writableObjectMode;
+    if (opts?.highWaterMark === void 0 && opts?.readableHighWaterMark !== void 0) {
+      this.readableHighWaterMark = opts.readableHighWaterMark;
+      this._readableState.highWaterMark = opts.readableHighWaterMark;
+    }
+    if (opts?.readableObjectMode !== void 0) {
+      this.readableObjectMode = opts.readableObjectMode;
+      this._readableState.objectMode = opts.readableObjectMode;
+      if (opts?.readableHighWaterMark === void 0 && opts?.highWaterMark === void 0) {
+        this.readableHighWaterMark = getDefaultHighWaterMark(opts.readableObjectMode);
+        this._readableState.highWaterMark = this.readableHighWaterMark;
+      }
+    }
     this.allowHalfOpen = opts?.allowHalfOpen !== false;
     this._decodeStrings = opts?.decodeStrings !== false;
     if (opts?.write) this._writeImpl = opts.write;
@@ -785,7 +871,7 @@ class Duplex extends Readable {
       } else {
         nextTick(() => {
           cb();
-          if (this.writableNeedDrain && this.writableLength < this.writableHighWaterMark) {
+          if (this.writableNeedDrain && this.writableLength <= this.writableHighWaterMark) {
             this.writableNeedDrain = false;
             this.emit("drain");
           }
@@ -815,11 +901,13 @@ class Duplex extends Readable {
     const doFinal = () => {
       this._final((err) => {
         this.writableFinished = true;
-        nextTick(() => {
-          if (err) this.emit("error", err);
-          this.emit("finish");
-          nextTick(() => this.emit("close"));
-          if (callback) callback();
+        this._doPrefinishHooks(() => {
+          nextTick(() => {
+            if (err) this.emit("error", err);
+            this.emit("finish");
+            nextTick(() => this.emit("close"));
+            if (callback) callback();
+          });
         });
       });
     };
@@ -830,6 +918,10 @@ class Duplex extends Readable {
     }
     return this;
   }
+  /** Hook for subclasses to run logic between _final and 'finish'. Default: no-op. */
+  _doPrefinishHooks(cb) {
+    cb();
+  }
   cork() {
     this.writableCorked++;
   }
@@ -849,7 +941,7 @@ class Duplex extends Readable {
             }
           });
         }
-        if (this.writableNeedDrain && this.writableLength < this.writableHighWaterMark) {
+        if (this.writableNeedDrain && this.writableLength <= this.writableHighWaterMark) {
           this.writableNeedDrain = false;
           nextTick(() => this.emit("drain"));
         }
@@ -861,44 +953,50 @@ class Duplex extends Readable {
     return this;
   }
 }
-class Transform extends Duplex {
-  _transformImpl;
-  _flushImpl;
+class Transform_ extends Duplex_ {
   constructor(opts) {
-    super({
-      ...opts,
-      write: void 0
-      // Override write to use transform
-    });
-    if (opts?.transform) this._transformImpl = opts.transform;
-    if (opts?.flush) this._flushImpl = opts.flush;
+    super({ ...opts, write: void 0, final: void 0 });
+    if (opts?.transform) this._transform = opts.transform;
+    if (opts?.flush) this._flush = opts.flush;
+    if (opts?.final) this._final = opts.final;
   }
-  _transform(chunk, encoding, callback) {
-    if (this._transformImpl) {
-      this._transformImpl.call(this, chunk, encoding, callback);
-    } else {
-      callback(null, chunk);
-    }
+  _transform(_chunk, _encoding, _callback) {
+    const err = Object.assign(
+      new Error("The _transform() method is not implemented"),
+      { code: "ERR_METHOD_NOT_IMPLEMENTED" }
+    );
+    throw err;
   }
   _flush(callback) {
-    if (this._flushImpl) {
-      this._flushImpl.call(this, callback);
-    } else {
-      callback();
-    }
+    callback();
   }
   _write(chunk, encoding, callback) {
-    this._transform(chunk, encoding, (err, data) => {
-      if (err) {
-        callback(err);
-        return;
-      }
-      if (data !== void 0 && data !== null) {
-        this.push(data);
-      }
-      callback();
-    });
+    let called = false;
+    try {
+      this._transform(chunk, encoding, (err, data) => {
+        if (called) {
+          const e = Object.assign(new Error("Callback called multiple times"), { code: "ERR_MULTIPLE_CALLBACK" });
+          nextTick(() => this.emit("error", e));
+          return;
+        }
+        called = true;
+        if (err) {
+          callback(err);
+          return;
+        }
+        if (data !== void 0 && data !== null) {
+          this.push(data);
+        }
+        callback();
+      });
+    } catch (err) {
+      if (err?.code === "ERR_METHOD_NOT_IMPLEMENTED") throw err;
+      callback(err);
+    }
   }
+  // Transform's built-in _final: calls _flush then pushes null.
+  // This is the default; when the user provides opts.final it is overridden on
+  // the instance and _doPrefinishHooks ensures _flush is still called after it.
   _final(callback) {
     this._flush((err, data) => {
       if (err) {
@@ -912,8 +1010,18 @@ class Transform extends Duplex {
       callback();
     });
   }
+  // When a user-provided _final overrides the prototype method, we still need
+  // to call the built-in flush+push-null logic (mirroring Node.js's prefinish).
+  _doPrefinishHooks(cb) {
+    const protoFinal = Transform_.prototype._final;
+    if (this._final !== protoFinal) {
+      protoFinal.call(this, cb);
+    } else {
+      cb();
+    }
+  }
 }
-class PassThrough extends Transform {
+class PassThrough_ extends Transform_ {
   constructor(opts) {
     super({
       ...opts,
@@ -1058,6 +1166,13 @@ function isErrored(stream) {
   if (s.destroyed === true && typeof s.writable === "boolean" && s.writable === false) return true;
   return false;
 }
+import { makeCallable } from "./callable.js";
+const Stream = makeCallable(Stream_);
+const Readable = makeCallable(Readable_);
+const Writable = makeCallable(Writable_);
+const Duplex = makeCallable(Duplex_);
+const Transform = makeCallable(Transform_);
+const PassThrough = makeCallable(PassThrough_);
 const _default = Object.assign(Stream, {
   Stream,
   Readable,

package/lib/types/callable.d.ts

@@ -0,0 +1 @@
+export { makeCallable } from '@gjsify/utils';

package/lib/types/callable.spec.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

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

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/edge-cases.spec.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/index.d.ts

@@ -13,19 +13,15 @@ export type { ReadableOptions, WritableOptions, DuplexOptions, TransformOptions,
 /** 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 {
+declare class Stream_ extends EventEmitter {
     constructor(opts?: StreamOptions);
     pipe<T extends Writable>(destination: T, options?: {
         end?: boolean;
     }): T;
 }
-export declare class Readable extends Stream {
+declare class Readable_ extends Stream_ {
     readable: boolean;
     readableFlowing: boolean | null;
     readableLength: number;
@@ -38,7 +34,15 @@ export declare class Readable extends Stream {
     /** @internal Tracked pipe destinations for unpipe. */
     _pipeDests: PipeState[];
     private _buffer;
-    private _readableState;
+    _readableState: {
+        ended: boolean;
+        endEmitted: boolean;
+        reading: boolean;
+        constructed: boolean;
+        highWaterMark: number;
+        objectMode: boolean;
+        pipes: any[];
+    };
     private _readablePending;
     private _readImpl;
     private _destroyImpl;
@@ -63,11 +67,13 @@ export declare class Readable extends Stream {
     private _flow;
     isPaused(): boolean;
     unpipe(destination?: Writable): this;
+    _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
     destroy(error?: Error): this;
     [Symbol.asyncIterator](): AsyncIterableIterator<unknown>;
     static from(iterable: Iterable<unknown> | AsyncIterable<unknown>, opts?: ReadableOptions): Readable;
 }
-export declare class Writable extends Stream {
+declare class Writable_ extends Stream_ {
+    static [Symbol.hasInstance](obj: any): boolean;
     writable: boolean;
     writableHighWaterMark: number;
     writableLength: number;
@@ -108,7 +114,7 @@ export declare class Writable extends Stream {
     setDefaultEncoding(encoding: string): this;
     destroy(error?: Error): this;
 }
-export declare class Duplex extends Readable {
+declare class Duplex_ extends Readable_ {
     writable: boolean;
     writableHighWaterMark: number;
     writableLength: number;
@@ -119,6 +125,10 @@ export declare class Duplex extends Readable {
     writableNeedDrain: boolean;
     allowHalfOpen: boolean;
     private _decodeStrings;
+    _writableState: {
+        highWaterMark: number;
+        objectMode: boolean;
+    };
     private _duplexCorkedBuffer;
     private _writeImpl;
     private _finalImpl;
@@ -131,20 +141,21 @@ export declare class Duplex extends Readable {
     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;
+    /** Hook for subclasses to run logic between _final and 'finish'. Default: no-op. */
+    protected _doPrefinishHooks(cb: () => void): void;
     cork(): void;
     uncork(): void;
     setDefaultEncoding(encoding: string): this;
 }
-export declare class Transform extends Duplex {
-    private _transformImpl;
-    private _flushImpl;
+declare class Transform_ extends Duplex_ {
     constructor(opts?: TransformOptions);
-    _transform(chunk: any, encoding: string, callback: (error?: Error | null, data?: any) => void): void;
+    _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;
+    protected _doPrefinishHooks(cb: () => void): void;
 }
-export declare class PassThrough extends Transform {
+declare class PassThrough_ extends Transform_ {
     constructor(opts?: TransformOptions);
 }
 type PipelineCallback = (err: Error | null) => void;
@@ -161,13 +172,25 @@ 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;
+export declare const Stream: typeof Stream_;
+export declare const Readable: typeof Readable_;
+export declare const Writable: typeof Writable_;
+export declare const Duplex: typeof Duplex_;
+export declare const Transform: typeof Transform_;
+export declare const PassThrough: 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_;
+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;

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

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/inheritance.spec.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/pipe.spec.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

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

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/transform.spec.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gjsify/stream",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Node.js stream module for Gjs",
   "type": "module",
   "module": "lib/esm/index.js",
@@ -43,14 +43,14 @@
     "stream"
   ],
   "devDependencies": {
-    "@gjsify/cli": "^0.1.6",
-    "@gjsify/unit": "^0.1.6",
+    "@gjsify/cli": "^0.1.8",
+    "@gjsify/unit": "^0.1.8",
     "@types/node": "^25.5.2",
     "typescript": "^6.0.2"
   },
   "dependencies": {
-    "@gjsify/events": "^0.1.6",
-    "@gjsify/utils": "^0.1.6",
-    "@gjsify/web-streams": "^0.1.6"
+    "@gjsify/events": "^0.1.8",
+    "@gjsify/utils": "^0.1.8",
+    "@gjsify/web-streams": "^0.1.8"
   }
 }