3.0.11

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartstream",
-  "version": "3.0.6",
+  "version": "3.0.11",
   "private": false,
   "description": "simplifies access to node streams",
   "main": "dist_ts/index.js",

ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartstream',
-  version: '3.0.6',
+  version: '3.0.11',
   description: 'simplifies access to node streams'
 }

ts/smartstream.classes.passthrough.ts

@@ -13,7 +13,9 @@ export class PassThrough extends plugins.stream.Duplex {
     if (this.push(chunk, encoding)) {
       callback();
     } else {
-      this.once('drain', callback);
+      this.once('drain', () => {
+        callback();
+      });
     }
   }
 }

ts/smartstream.classes.smartduplex.ts

@@ -109,15 +109,15 @@ export class SmartDuplex<TInput = any, TOutput = any> extends Duplex {
 
   // INSTANCE
   private readFunction?: () => Promise<void>;
-  private writeAndTransformFunction?: IWriteAndTransformFunction<TInput, TOutput>;
+  private writeFunction?: IWriteAndTransformFunction<TInput, TOutput>;
-  private streamEndFunction?: IStreamEndFunction<TOutput>;
+  private finalFunction?: IStreamEndFunction<TOutput>;
   private observableSubscription?: plugins.smartrx.rxjs.Subscription;
 
   constructor(optionsArg?: SmartStreamOptions<TInput, TOutput>) {
     super(optionsArg);
     this.readFunction = optionsArg?.readFunction;
-    this.writeAndTransformFunction = optionsArg?.writeAndTransformFunction;
+    this.writeFunction = optionsArg?.writeAndTransformFunction;
-    this.streamEndFunction = optionsArg?.finalFunction;
+    this.finalFunction = optionsArg?.finalFunction;
   }
 
   public async _read(size: number): Promise<void> {
@@ -128,7 +128,7 @@ export class SmartDuplex<TInput = any, TOutput = any> extends Duplex {
 
   // Ensure the _write method types the chunk as TInput and encodes TOutput
   public async _write(chunk: TInput, encoding: string, callback: (error?: Error | null) => void) {
-    if (!this.writeAndTransformFunction) {
+    if (!this.writeFunction) {
       return callback(new Error('No stream function provided'));
     }
 
@@ -141,7 +141,7 @@ export class SmartDuplex<TInput = any, TOutput = any> extends Duplex {
     };
 
     try {
-      const modifiedChunk = await this.writeAndTransformFunction(chunk, tools);
+      const modifiedChunk = await this.writeFunction(chunk, tools);
       if (modifiedChunk) {
         if (!this.push(modifiedChunk)) {
           // Handle backpressure if necessary
@@ -154,24 +154,24 @@ export class SmartDuplex<TInput = any, TOutput = any> extends Duplex {
   }
 
   public async _final(callback: (error?: Error | null) => void) {
-    if (this.streamEndFunction) {
+    if (this.finalFunction) {
       const tools: IStreamTools = {
         truncate: () => callback(),
         push: (pipeObject) => this.push(pipeObject),
       };
 
       try {
-        const finalChunk = await this.streamEndFunction(tools);
+        const finalChunk = await this.finalFunction(tools);
         if (finalChunk) {
           this.push(finalChunk);
         }
-        callback();
       } catch (err) {
         callback(err);
       }
     } else {
-      this.push(null),
+      // nothing here
-      callback();
     }
+    this.push(null);
+    callback();
   }
 }