3.0.30

package.json

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

test/test.backpressure.ts

@@ -7,7 +7,6 @@ tap.test('should run backpressure test', async (toolsArg) => {
     const stream1 = new SmartDuplex({
       name: 'stream1',
       objectMode: true,
-      handleBackpressure: true,
       writeFunction: async (chunk, tools) => {
         await new Promise((resolve) => setTimeout(resolve, 10)); // Slow processing
         console.log(`processed chunk ${chunk} in stream 1`);
@@ -17,19 +16,18 @@ tap.test('should run backpressure test', async (toolsArg) => {
     const stream2 = new SmartDuplex({
       name: 'stream2',
       objectMode: true,
-      handleBackpressure: true,
       writeFunction: async (chunk, tools) => {
         await new Promise((resolve) => setTimeout(resolve, 20)); // Slow processing
         console.log(`processed chunk ${chunk} in stream 2`);
-        return chunk;
+        await tools.push(chunk);
+        // return chunk;
       },
     }); // This stream processes data more slowly
     const stream3 = new SmartDuplex({
       objectMode: true,
       name: 'stream3',
-      handleBackpressure: true,
       writeFunction: async (chunk, tools) => {
-        await new Promise((resolve) => setTimeout(resolve, 100)); // Slow processing
+        await new Promise((resolve) => setTimeout(resolve, 200)); // Slow processing
         console.log(`processed chunk ${chunk} in stream 3`);
       },
     });

test/test.smartstream.ts

@@ -5,9 +5,7 @@ import * as fs from 'fs';
 
 tap.test('should create a SmartStream from a Buffer', async () => {
   const bufferData = Buffer.from('This is a test buffer');
-  const smartStream = SmartDuplex.fromBuffer(bufferData, {
-    handleBackpressure: false,
-  });
+  const smartStream = SmartDuplex.fromBuffer(bufferData, {});
   
   let receivedData = Buffer.alloc(0);
   

ts/00_commitinfo_data.ts

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

ts/index.ts

@@ -1,4 +1,3 @@
-export * from './smartstream.classes.passthrough.js';
 export * from './smartstream.classes.smartduplex.js';
 export * from './smartstream.classes.streamwrapper.js';
 export * from './smartstream.classes.streamintake.js';

ts/smartstream.classes.passthrough.ts

@@ -1,21 +0,0 @@
-import * as plugins from './smartstream.plugins.js';
-
-export class PassThrough extends plugins.stream.Duplex {
-  constructor(options?: plugins.stream.DuplexOptions) {
-    super(options);
-  }
-
-  _read(size: number): void {
-    // No-op: Data written will be automatically available for reading.
-  }
-
-  _write(chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void {
-    if (this.push(chunk, encoding)) {
-      callback();
-    } else {
-      this.once('drain', () => {
-        callback();
-      });
-    }
-  }
-}

ts/smartstream.classes.smartduplex.ts

@@ -17,7 +17,6 @@ export interface IStreamFinalFunction<rT> {
 export interface ISmartDuplexOptions<TInput, TOutput> extends DuplexOptions {
   debug?: boolean;
   name?: string;
-  handleBackpressure?: boolean;
   readFunction?: () => Promise<void>;
   writeFunction?: IStreamWriteFunction<TInput, TOutput>;
   finalFunction?: IStreamFinalFunction<TOutput>;
@@ -36,7 +35,7 @@ export class SmartDuplex<TInput = any, TOutput = any> extends Duplex {
   }
 
   // INSTANCE
-  private backpressuredArray = new plugins.lik.BackpressuredArray<TOutput>();
+  private backpressuredArray: plugins.lik.BackpressuredArray<TOutput>;
   public options: ISmartDuplexOptions<TInput, TOutput>;
   private observableSubscription?: plugins.smartrx.rxjs.Subscription;
   private debugLog(messageArg: string) {
@@ -46,8 +45,11 @@ export class SmartDuplex<TInput = any, TOutput = any> extends Duplex {
   }
 
   constructor(optionsArg?: ISmartDuplexOptions<TInput, TOutput>) {
-    super(optionsArg);
+    super(Object.assign({
+      highWaterMark: 1,
+    }, optionsArg));
     this.options = optionsArg;
+    this.backpressuredArray = new plugins.lik.BackpressuredArray<TOutput>(this.options.highWaterMark || 1)
   }
 
   public async _read(size: number): Promise<void> {
@@ -60,11 +62,18 @@ export class SmartDuplex<TInput = any, TOutput = any> extends Duplex {
     let canPushMore = true; 
     while(this.backpressuredArray.data.length > 0 && canPushMore) {
       const nextChunk = this.backpressuredArray.shift();
-      if (nextChunk) {
       canPushMore = this.push(nextChunk);
     }
   }
+
+  public async backpressuredPush (pushArg: TOutput) {
+    const canPushMore = this.backpressuredArray.push(pushArg);
+    if (!canPushMore) {
+      this.debugLog(`${this.options.name}: cannot push more`);
+      await this.backpressuredArray.waitForSpace();
+      this.debugLog(`${this.options.name}: can push more again`);
     }
+  };
 
   private asyncWritePromiseObjectmap = new plugins.lik.ObjectMap<Promise<any>>();
   // Ensure the _write method types the chunk as TInput and encodes TOutput
@@ -81,13 +90,8 @@ export class SmartDuplex<TInput = any, TOutput = any> extends Duplex {
         callback();
       },
       push: async (pushArg: TOutput) => {
-        const canPushMore = this.backpressuredArray.push(pushArg);
-        if (!canPushMore) {
-          this.debugLog(`${this.options.name}: cannot push more`);
-          await this.backpressuredArray.waitForSpace();
-          this.debugLog(`${this.options.name}: can push more again`);
+        await this.backpressuredPush(pushArg);
       }
-      },
     };
 
     try {
@@ -116,22 +120,22 @@ export class SmartDuplex<TInput = any, TOutput = any> extends Duplex {
       const tools: IStreamTools = {
         truncate: () => callback(),
         push: async (pipeObject) => {
-          this.push(pipeObject);
+          this.backpressuredArray.push(pipeObject);
         },
       };
 
       try {
         const finalChunk = await this.options.finalFunction(tools);
         if (finalChunk) {
-          this.push(finalChunk);
+          this.backpressuredArray.push(finalChunk);
         }
       } catch (err) {
-        this.push(null);
+        this.backpressuredArray.push(null);
         callback(err);
         return;
       }
     }
-    this.push(null);
+    this.backpressuredArray.push(null);
     callback();
   }
 }

ts/smartstream.functions.ts

@@ -19,3 +19,12 @@ export function createTransformFunction<TInput, TOutput>(
 
   return smartDuplexStream;
 }
+
+export const createPassThrough = () => {
+  return new SmartDuplex({
+    objectMode: true,
+    writeFunction: async (chunkArg, toolsArg) => {
+      return chunkArg;
+    }
+  })
+}