@push.rocks/smartstream 3.1.0 → 3.1.1

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@push.rocks/smartstream',
-    version: '3.1.0',
+    version: '3.1.1',
     description: 'A library to simplify the creation and manipulation of Node.js streams, providing utilities for handling transform, duplex, and readable/writable streams effectively in TypeScript.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx5QkFBeUI7SUFDL0IsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLHNMQUFzTDtDQUNwTSxDQUFBIn0=

package/dist_ts_web/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@push.rocks/smartstream',
-    version: '3.1.0',
+    version: '3.1.1',
     description: 'A library to simplify the creation and manipulation of Node.js streams, providing utilities for handling transform, duplex, and readable/writable streams effectively in TypeScript.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHNfd2ViLzAwX2NvbW1pdGluZm9fZGF0YS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLFVBQVUsR0FBRztJQUN4QixJQUFJLEVBQUUseUJBQXlCO0lBQy9CLE9BQU8sRUFBRSxPQUFPO0lBQ2hCLFdBQVcsRUFBRSxzTEFBc0w7Q0FDcE0sQ0FBQSJ9

package/dist_ts_web/classes.webduplexstream.d.ts

@@ -1,11 +1,9 @@
 export interface IStreamToolsRead<TInput, TOutput> {
     done: () => void;
-    write: (writeArg: TInput) => void;
+    write: (writeArg: TInput) => Promise<void>;
 }
 /**
- * the read function is called anytime
- *   -> the WebDuplexStream is being read from
- *      and at the same time if nothing is enqueued
+ * The read function is called when data needs to be read into the stream.
  */
 export interface IStreamReadFunction<TInput, TOutput> {
     (toolsArg: IStreamToolsRead<TInput, TOutput>): Promise<void>;
@@ -15,14 +13,13 @@ export interface IStreamToolsWrite<TInput, TOutput> {
     push: (pushArg: TOutput) => void;
 }
 /**
- * the write function can return something.
- * It is called anytime a chunk is written to the stream.
+ * The write function is called whenever a chunk is written to the stream.
  */
 export interface IStreamWriteFunction<TInput, TOutput> {
     (chunkArg: TInput, toolsArg: IStreamToolsWrite<TInput, TOutput>): Promise<any>;
 }
 export interface IStreamFinalFunction<TInput, TOutput> {
-    (toolsArg: IStreamToolsWrite<TInput, TOutput>): Promise<TOutput>;
+    (toolsArg: IStreamToolsWrite<TInput, TOutput>): Promise<TOutput | void>;
 }
 export interface WebDuplexStreamOptions<TInput, TOutput> {
     readFunction?: IStreamReadFunction<TInput, TOutput>;
@@ -30,8 +27,8 @@ export interface WebDuplexStreamOptions<TInput, TOutput> {
     finalFunction?: IStreamFinalFunction<TInput, TOutput>;
 }
 export declare class WebDuplexStream<TInput = any, TOutput = any> extends TransformStream<TInput, TOutput> {
-    static fromUInt8Array(uint8Array: Uint8Array): WebDuplexStream<Uint8Array, Uint8Array>;
     options: WebDuplexStreamOptions<TInput, TOutput>;
     constructor(optionsArg: WebDuplexStreamOptions<TInput, TOutput>);
-    getCustomReadableStream(): ReadableStream<any>;
+    private _startReading;
+    static fromUInt8Array(uint8Array: Uint8Array): WebDuplexStream<Uint8Array, Uint8Array>;
 }

package/dist_ts_web/classes.webduplexstream.js

@@ -1,21 +1,11 @@
 import * as plugins from './plugins.js';
 export class WebDuplexStream extends TransformStream {
-    static fromUInt8Array(uint8Array) {
-        const stream = new WebDuplexStream({
-            writeFunction: async (chunk, { push }) => {
-                push(chunk); // Directly push the chunk as is
-                return null;
-            }
-        });
-        const writer = stream.writable.getWriter();
-        writer.write(uint8Array).then(() => writer.close());
-        return stream;
-    }
     constructor(optionsArg) {
-        // here we call into the official web stream api
         super({
+            async start(controller) {
+                // Optionally initialize any state here
+            },
             async transform(chunk, controller) {
-                // Transformation logic remains unchanged
                 if (optionsArg?.writeFunction) {
                     const tools = {
                         truncate: () => controller.terminate(),
@@ -23,7 +13,7 @@ export class WebDuplexStream extends TransformStream {
                     };
                     try {
                         const writeReturnChunk = await optionsArg.writeFunction(chunk, tools);
-                        if (writeReturnChunk) { // return chunk is optional
+                        if (writeReturnChunk !== undefined && writeReturnChunk !== null) {
                             controller.enqueue(writeReturnChunk);
                         }
                     }
@@ -32,72 +22,68 @@ export class WebDuplexStream extends TransformStream {
                     }
                 }
                 else {
-                    controller.error(new Error('No write function provided'));
+                    // If no writeFunction is provided, pass the chunk through
+                    controller.enqueue(chunk);
                 }
             },
             async flush(controller) {
-                // Flush logic remains unchanged
                 if (optionsArg?.finalFunction) {
                     const tools = {
                         truncate: () => controller.terminate(),
-                        push: (pipeObject) => controller.enqueue(pipeObject),
+                        push: (pushArg) => controller.enqueue(pushArg),
                     };
-                    optionsArg.finalFunction(tools)
-                        .then(finalChunk => {
+                    try {
+                        const finalChunk = await optionsArg.finalFunction(tools);
                         if (finalChunk) {
                             controller.enqueue(finalChunk);
                         }
-                    })
-                        .catch(err => controller.error(err))
-                        .finally(() => controller.terminate());
+                    }
+                    catch (err) {
+                        controller.error(err);
+                    }
+                    finally {
+                        controller.terminate();
+                    }
                 }
                 else {
                     controller.terminate();
                 }
-            }
+            },
         });
         this.options = optionsArg;
+        // Start producing data if readFunction is provided
+        if (this.options.readFunction) {
+            this._startReading();
+        }
     }
-    // Method to create a custom readable stream that integrates the readFunction
-    // readFunction is executed whenever the stream is being read from and nothing is enqueued
-    getCustomReadableStream() {
-        const readableStream = this.readable;
-        const options = this.options;
-        const customReadable = new ReadableStream({
-            async pull(controller) {
-                const reader = readableStream.getReader();
-                // Check the current state of the original stream
-                const { value, done } = await reader.read();
-                reader.releaseLock();
-                if (done) {
-                    // If the original stream is done, close the custom readable stream
-                    controller.close();
-                }
-                else {
-                    if (value) {
-                        // If there is data in the original stream, enqueue it and do not execute the readFunction
-                        controller.enqueue(value);
-                    }
-                    else if (options.readFunction) {
-                        // If the original stream is empty, execute the readFunction and read again
-                        await options.readFunction({
-                            done: () => controller.close(),
-                            write: (writeArg) => controller.enqueue(writeArg),
-                        });
-                        const newReader = readableStream.getReader();
-                        const { value: newValue, done: newDone } = await newReader.read();
-                        newReader.releaseLock();
-                        if (newDone) {
-                            controller.close();
-                        }
-                        else {
-                            controller.enqueue(newValue);
-                        }
-                    }
-                }
-            }
+    async _startReading() {
+        const writable = this.writable;
+        const writer = writable.getWriter();
+        const tools = {
+            done: () => writer.close(),
+            write: async (writeArg) => await writer.write(writeArg),
+        };
+        try {
+            await this.options.readFunction(tools);
+        }
+        catch (err) {
+            writer.abort(err);
+        }
+        finally {
+            writer.releaseLock();
+        }
+    }
+    // Static method example (adjust as needed)
+    static fromUInt8Array(uint8Array) {
+        const stream = new WebDuplexStream({
+            writeFunction: async (chunk, { push }) => {
+                push(chunk); // Directly push the chunk as is
+                return null;
+            },
         });
-        return customReadable;
+        const writer = stream.writable.getWriter();
+        writer.write(uint8Array).then(() => writer.close());
+        return stream;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartstream",
-  "version": "3.1.0",
+  "version": "3.1.1",
   "private": false,
   "description": "A library to simplify the creation and manipulation of Node.js streams, providing utilities for handling transform, duplex, and readable/writable streams effectively in TypeScript.",
   "type": "module",

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartstream',
-  version: '3.1.0',
+  version: '3.1.1',
   description: 'A library to simplify the creation and manipulation of Node.js streams, providing utilities for handling transform, duplex, and readable/writable streams effectively in TypeScript.'
 }

package/ts_web/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartstream',
-  version: '3.1.0',
+  version: '3.1.1',
   description: 'A library to simplify the creation and manipulation of Node.js streams, providing utilities for handling transform, duplex, and readable/writable streams effectively in TypeScript.'
 }

package/ts_web/classes.webduplexstream.ts

@@ -1,25 +1,22 @@
 import * as plugins from './plugins.js';
 
-
 // ========================================
-// READ
+// Interfaces for Read functionality
 // ========================================
 export interface IStreamToolsRead<TInput, TOutput> {
   done: () => void;
-  write: (writeArg: TInput) => void;
+  write: (writeArg: TInput) => Promise<void>;
 }
 
 /**
- * the read function is called anytime
- *   -> the WebDuplexStream is being read from
- *      and at the same time if nothing is enqueued
+ * The read function is called when data needs to be read into the stream.
  */
 export interface IStreamReadFunction<TInput, TOutput> {
   (toolsArg: IStreamToolsRead<TInput, TOutput>): Promise<void>;
 }
 
 // ========================================
-// WRITE
+// Interfaces for Write functionality
 // ========================================
 export interface IStreamToolsWrite<TInput, TOutput> {
   truncate: () => void;
@@ -27,15 +24,14 @@ export interface IStreamToolsWrite<TInput, TOutput> {
 }
 
 /**
- * the write function can return something.
- * It is called anytime a chunk is written to the stream.
+ * The write function is called whenever a chunk is written to the stream.
  */
 export interface IStreamWriteFunction<TInput, TOutput> {
   (chunkArg: TInput, toolsArg: IStreamToolsWrite<TInput, TOutput>): Promise<any>;
 }
 
 export interface IStreamFinalFunction<TInput, TOutput> {
-  (toolsArg: IStreamToolsWrite<TInput, TOutput>): Promise<TOutput>;
+  (toolsArg: IStreamToolsWrite<TInput, TOutput>): Promise<TOutput | void>;
 }
 
 export interface WebDuplexStreamOptions<TInput, TOutput> {
@@ -45,112 +41,95 @@ export interface WebDuplexStreamOptions<TInput, TOutput> {
 }
 
 export class WebDuplexStream<TInput = any, TOutput = any> extends TransformStream<TInput, TOutput> {
-  static fromUInt8Array(uint8Array: Uint8Array): WebDuplexStream<Uint8Array, Uint8Array> {
-    const stream = new WebDuplexStream<Uint8Array, Uint8Array>({
-      writeFunction: async (chunk, { push }) => {
-        push(chunk); // Directly push the chunk as is
-        return null;
-      }
-    });
-
-    const writer = stream.writable.getWriter();
-    writer.write(uint8Array).then(() => writer.close());
-
-    return stream;
-  }
-  
   // INSTANCE
   options: WebDuplexStreamOptions<TInput, TOutput>;
 
   constructor(optionsArg: WebDuplexStreamOptions<TInput, TOutput>) {
-    // here we call into the official web stream api
     super({
+      async start(controller) {
+        // Optionally initialize any state here
+      },
       async transform(chunk, controller) {
-        // Transformation logic remains unchanged
         if (optionsArg?.writeFunction) {
           const tools: IStreamToolsWrite<TInput, TOutput> = {
             truncate: () => controller.terminate(),
             push: (pushArg: TOutput) => controller.enqueue(pushArg),
           };
-        
+
           try {
             const writeReturnChunk = await optionsArg.writeFunction(chunk, tools);
-            if (writeReturnChunk) { // return chunk is optional
+            if (writeReturnChunk !== undefined && writeReturnChunk !== null) {
               controller.enqueue(writeReturnChunk);
             }
           } catch (err) {
             controller.error(err);
           }
         } else {
-          controller.error(new Error('No write function provided'));
+          // If no writeFunction is provided, pass the chunk through
+          controller.enqueue(chunk as unknown as TOutput);
         }
       },
       async flush(controller) {
-        // Flush logic remains unchanged
         if (optionsArg?.finalFunction) {
           const tools: IStreamToolsWrite<TInput, TOutput> = {
             truncate: () => controller.terminate(),
-            push: (pipeObject) => controller.enqueue(pipeObject),
+            push: (pushArg) => controller.enqueue(pushArg),
           };
-      
-          optionsArg.finalFunction(tools)
-            .then(finalChunk => {
-              if (finalChunk) {
-                controller.enqueue(finalChunk);
-              }
-            })  
-            .catch(err => controller.error(err))
-            .finally(() => controller.terminate());
+
+          try {
+            const finalChunk = await optionsArg.finalFunction(tools);
+            if (finalChunk) {
+              controller.enqueue(finalChunk);
+            }
+          } catch (err) {
+            controller.error(err);
+          } finally {
+            controller.terminate();
+          }
         } else {
           controller.terminate();
         }
-      }
+      },
     });
 
     this.options = optionsArg;
+
+    // Start producing data if readFunction is provided
+    if (this.options.readFunction) {
+      this._startReading();
+    }
   }
 
-  // Method to create a custom readable stream that integrates the readFunction
-  // readFunction is executed whenever the stream is being read from and nothing is enqueued
-  getCustomReadableStream() {
-    const readableStream = this.readable;
-    const options = this.options;
-    const customReadable = new ReadableStream({
-      async pull(controller) {
-        const reader = readableStream.getReader();
-
-        // Check the current state of the original stream
-        const { value, done } = await reader.read();
-        reader.releaseLock();
-
-        if (done) {
-          // If the original stream is done, close the custom readable stream
-          controller.close();
-        } else {
-          if (value) {
-            // If there is data in the original stream, enqueue it and do not execute the readFunction
-            controller.enqueue(value);
-          } else if (options.readFunction) {
-            // If the original stream is empty, execute the readFunction and read again
-            await options.readFunction({
-              done: () => controller.close(),
-              write: (writeArg) => controller.enqueue(writeArg),
-            });
-            
-            const newReader = readableStream.getReader();
-            const { value: newValue, done: newDone } = await newReader.read();
-            newReader.releaseLock();
-
-            if (newDone) {
-              controller.close();
-            } else {
-              controller.enqueue(newValue);
-            }
-          }
-        }
-      }
+  private async _startReading() {
+    const writable = this.writable;
+    const writer = writable.getWriter();
+
+    const tools: IStreamToolsRead<TInput, TOutput> = {
+      done: () => writer.close(),
+      write: async (writeArg) => await writer.write(writeArg),
+    };
+
+    try {
+      await this.options.readFunction(tools);
+    } catch (err) {
+      writer.abort(err);
+    } finally {
+      writer.releaseLock();
+    }
+  }
+
+  // Static method example (adjust as needed)
+  static fromUInt8Array(uint8Array: Uint8Array): WebDuplexStream<Uint8Array, Uint8Array> {
+    const stream = new WebDuplexStream<Uint8Array, Uint8Array>({
+      writeFunction: async (chunk, { push }) => {
+        push(chunk); // Directly push the chunk as is
+        return null;
+      },
     });
 
-    return customReadable;
+    const writer = stream.writable.getWriter();
+    writer.write(uint8Array).then(() => writer.close());
+
+    return stream;
   }
-}
+}