@push.rocks/smartstream 3.0.31 → 3.0.33

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@push.rocks/smartstream',
-    version: '3.0.31',
+    version: '3.0.33',
     description: 'simplifies access to node streams'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx5QkFBeUI7SUFDL0IsT0FBTyxFQUFFLFFBQVE7SUFDakIsV0FBVyxFQUFFLG1DQUFtQztDQUNqRCxDQUFBIn0=

package/dist_ts/smartstream.classes.passthrough.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import * as plugins from './smartstream.plugins.js';
+export declare class PassThrough extends plugins.stream.Duplex {
+    constructor(options?: plugins.stream.DuplexOptions);
+    _read(size: number): void;
+    _write(chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
+}

package/dist_ts/smartstream.classes.passthrough.js

@@ -0,0 +1,18 @@
+import * as plugins from './smartstream.plugins.js';
+export class PassThrough extends plugins.stream.Duplex {
+    constructor(options) {
+        super(options);
+    }
+    _read(size) {
+        // No-op: Data written will be automatically available for reading.
+    }
+    _write(chunk, encoding, callback) {
+        if (this.push(chunk, encoding)) {
+            callback();
+        }
+        else {
+            this.once('drain', callback);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzdHJlYW0uY2xhc3Nlcy5wYXNzdGhyb3VnaC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0c3RyZWFtLmNsYXNzZXMucGFzc3Rocm91Z2gudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSwwQkFBMEIsQ0FBQztBQUVwRCxNQUFNLE9BQU8sV0FBWSxTQUFRLE9BQU8sQ0FBQyxNQUFNLENBQUMsTUFBTTtJQUNwRCxZQUFZLE9BQXNDO1FBQ2hELEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUNqQixDQUFDO0lBRUQsS0FBSyxDQUFDLElBQVk7UUFDaEIsbUVBQW1FO0lBQ3JFLENBQUM7SUFFRCxNQUFNLENBQUMsS0FBVSxFQUFFLFFBQXdCLEVBQUUsUUFBd0M7UUFDbkYsSUFBSSxJQUFJLENBQUMsSUFBSSxDQUFDLEtBQUssRUFBRSxRQUFRLENBQUMsRUFBRTtZQUM5QixRQUFRLEVBQUUsQ0FBQztTQUNaO2FBQU07WUFDTCxJQUFJLENBQUMsSUFBSSxDQUFDLE9BQU8sRUFBRSxRQUFRLENBQUMsQ0FBQztTQUM5QjtJQUNILENBQUM7Q0FDRiJ9

package/dist_ts/smartstream.classes.smartduplex.d.ts

@@ -31,7 +31,7 @@ export interface ISmartDuplexOptions<TInput, TOutput> extends DuplexOptions {
      */
     writeFunction?: IStreamWriteFunction<TInput, TOutput>;
     /**
-     * a final function that is being sent to the end of the stream
+     * a final function that is run at the end of the stream
      */
     finalFunction?: IStreamFinalFunction<TOutput>;
 }

package/dist_ts/smartstream.classes.smartstream.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import * as plugins from './smartstream.plugins.js';
+import { Duplex, type DuplexOptions } from 'stream';
+export declare class SmartStream extends Duplex {
+    private observableSubscription?;
+    constructor(options?: DuplexOptions);
+    _read(size: number): void;
+    _write(chunk: any, encoding: string, callback: (error?: Error | null) => void): void;
+    static fromBuffer(buffer: Buffer, options?: DuplexOptions): SmartStream;
+    static fromObservable(observable: plugins.smartrx.rxjs.Observable<any>, options?: DuplexOptions): SmartStream;
+}

package/dist_ts/smartstream.classes.smartstream.js

@@ -0,0 +1,48 @@
+import * as plugins from './smartstream.plugins.js';
+import { Duplex } from 'stream';
+export class SmartStream extends Duplex {
+    constructor(options) {
+        super(options);
+    }
+    _read(size) {
+        // Implement if you need custom behavior, otherwise leave it empty
+    }
+    _write(chunk, encoding, callback) {
+        // Implement if you need custom behavior
+        callback();
+    }
+    static fromBuffer(buffer, options) {
+        const smartStream = new SmartStream(options);
+        process.nextTick(() => {
+            smartStream.push(buffer);
+            smartStream.push(null); // Signal the end of the data
+        });
+        return smartStream;
+    }
+    static fromObservable(observable, options) {
+        const smartStream = new SmartStream(options);
+        smartStream.observableSubscription = observable.subscribe({
+            next: (data) => {
+                if (!smartStream.push(data)) {
+                    // Pause the observable if the stream buffer is full
+                    smartStream.observableSubscription?.unsubscribe();
+                    smartStream.once('drain', () => {
+                        // Resume the observable when the stream buffer is drained
+                        smartStream.observableSubscription?.unsubscribe();
+                        smartStream.observableSubscription = observable.subscribe(data => {
+                            smartStream.push(data);
+                        });
+                    });
+                }
+            },
+            error: (err) => {
+                smartStream.emit('error', err);
+            },
+            complete: () => {
+                smartStream.push(null); // Signal the end of the data
+            }
+        });
+        return smartStream;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/smartstream.duplex.d.ts

@@ -0,0 +1,23 @@
+import * as plugins from './smartstream.plugins.js';
+export interface ITruncateFunc {
+    (): void;
+}
+export interface IPipeMoreFunc {
+    (pipeObject: any): void;
+}
+export interface IStreamTools {
+    truncate: ITruncateFunc;
+    pipeMore: IPipeMoreFunc;
+}
+export interface IStreamFunction<T, rT> {
+    (chunkArg: T, toolsArg: IStreamTools): Promise<rT>;
+}
+export interface IStreamEndFunction<rT> {
+    (toolsArg: IStreamTools): Promise<rT>;
+}
+export interface IStreamOptions {
+    objectMode?: boolean;
+    readableObjectMode?: boolean;
+    writableObjectMode?: boolean;
+}
+export declare let createDuplexStream: <T, rT>(funcArg: IStreamFunction<T, rT>, endFuncArg?: IStreamEndFunction<rT>, optionsArg?: IStreamOptions) => plugins.stream.Transform;

package/dist_ts/smartstream.duplex.js

@@ -0,0 +1,48 @@
+import * as plugins from './smartstream.plugins.js';
+export let createDuplexStream = (funcArg, endFuncArg, optionsArg = {
+    objectMode: false,
+    readableObjectMode: true,
+    writableObjectMode: true,
+}) => {
+    return plugins.through2(optionsArg, function (chunk, enc, cb) {
+        let truncated = false;
+        const tools = {
+            truncate: () => {
+                truncated = true;
+                cb(null, null);
+            },
+            pipeMore: (pipeObject) => {
+                this.push(pipeObject);
+            },
+        };
+        const asyncWrapper = async () => {
+            const resultChunk = await funcArg(chunk, tools);
+            if (!truncated) {
+                cb(null, resultChunk);
+            }
+        };
+        asyncWrapper().catch((err) => {
+            console.log(err);
+        });
+    }, function (cb) {
+        const tools = {
+            truncate: () => {
+                cb();
+            },
+            pipeMore: (pushArg) => {
+                this.push(pushArg);
+            },
+        };
+        const asyncWrapper = async () => {
+            if (endFuncArg) {
+                const result = await endFuncArg(tools);
+                this.push(result);
+            }
+            cb();
+        };
+        asyncWrapper().catch((err) => {
+            console.log(err);
+        });
+    });
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzdHJlYW0uZHVwbGV4LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvc21hcnRzdHJlYW0uZHVwbGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sMEJBQTBCLENBQUM7QUE2QnBELE1BQU0sQ0FBQyxJQUFJLGtCQUFrQixHQUFHLENBQzlCLE9BQStCLEVBQy9CLFVBQW1DLEVBQ25DLGFBQTZCO0lBQzNCLFVBQVUsRUFBRSxLQUFLO0lBQ2pCLGtCQUFrQixFQUFFLElBQUk7SUFDeEIsa0JBQWtCLEVBQUUsSUFBSTtDQUN6QixFQUNELEVBQUU7SUFDRixPQUFPLE9BQU8sQ0FBQyxRQUFRLENBQ3JCLFVBQVUsRUFDVixVQUFVLEtBQUssRUFBRSxHQUFHLEVBQUUsRUFBRTtRQUN0QixJQUFJLFNBQVMsR0FBRyxLQUFLLENBQUM7UUFDdEIsTUFBTSxLQUFLLEdBQWlCO1lBQzFCLFFBQVEsRUFBRSxHQUFHLEVBQUU7Z0JBQ2IsU0FBUyxHQUFHLElBQUksQ0FBQztnQkFDakIsRUFBRSxDQUFDLElBQUksRUFBRSxJQUFJLENBQUMsQ0FBQztZQUNqQixDQUFDO1lBQ0QsUUFBUSxFQUFFLENBQUMsVUFBVSxFQUFFLEVBQUU7Z0JBQ3ZCLElBQUksQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLENBQUM7WUFDeEIsQ0FBQztTQUNGLENBQUM7UUFDRixNQUFNLFlBQVksR0FBRyxLQUFLLElBQUksRUFBRTtZQUM5QixNQUFNLFdBQVcsR0FBTyxNQUFNLE9BQU8sQ0FBQyxLQUFLLEVBQUUsS0FBSyxDQUFDLENBQUM7WUFDcEQsSUFBSSxDQUFDLFNBQVMsRUFBRTtnQkFDZCxFQUFFLENBQUMsSUFBSSxFQUFFLFdBQVcsQ0FBQyxDQUFDO2FBQ3ZCO1FBQ0gsQ0FBQyxDQUFDO1FBQ0YsWUFBWSxFQUFFLENBQUMsS0FBSyxDQUFDLENBQUMsR0FBRyxFQUFFLEVBQUU7WUFDM0IsT0FBTyxDQUFDLEdBQUcsQ0FBQyxHQUFHLENBQUMsQ0FBQztRQUNuQixDQUFDLENBQUMsQ0FBQztJQUNMLENBQUMsRUFDRCxVQUFVLEVBQUU7UUFDVixNQUFNLEtBQUssR0FBaUI7WUFDMUIsUUFBUSxFQUFFLEdBQUcsRUFBRTtnQkFDYixFQUFFLEVBQUUsQ0FBQztZQUNQLENBQUM7WUFDRCxRQUFRLEVBQUUsQ0FBQyxPQUFPLEVBQUUsRUFBRTtnQkFDcEIsSUFBSSxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsQ0FBQztZQUNyQixDQUFDO1NBQ0YsQ0FBQztRQUNGLE1BQU0sWUFBWSxHQUFHLEtBQUssSUFBSSxFQUFFO1lBQzlCLElBQUksVUFBVSxFQUFFO2dCQUNkLE1BQU0sTUFBTSxHQUFHLE1BQU0sVUFBVSxDQUFDLEtBQUssQ0FBQyxDQUFDO2dCQUN2QyxJQUFJLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDO2FBQ25CO1lBQ0QsRUFBRSxFQUFFLENBQUM7UUFDUCxDQUFDLENBQUM7UUFDRixZQUFZLEVBQUUsQ0FBQyxLQUFLLENBQUMsQ0FBQyxHQUFHLEVBQUUsRUFBRTtZQUMzQixPQUFPLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxDQUFDO1FBQ25CLENBQUMsQ0FBQyxDQUFDO0lBQ0wsQ0FBQyxDQUNGLENBQUM7QUFDSixDQUFDLENBQUMifQ==

package/package.json

@@ -1,16 +1,11 @@
 {
   "name": "@push.rocks/smartstream",
-  "version": "3.0.31",
+  "version": "3.0.33",
   "private": false,
   "description": "simplifies access to node streams",
   "main": "dist_ts/index.js",
   "typings": "dist_ts/index.d.ts",
   "type": "module",
-  "scripts": {
-    "test": "(tstest test/)",
-    "build": "(tsbuild)",
-    "buildDocs": "tsdoc"
-  },
   "repository": {
     "type": "git",
     "url": "git+https://gitlab.com/push.rocks/smartstream.git"
@@ -48,5 +43,10 @@
     "cli.js",
     "npmextra.json",
     "readme.md"
-  ]
-}
+  ],
+  "scripts": {
+    "test": "(tstest test/)",
+    "build": "(tsbuild)",
+    "buildDocs": "tsdoc"
+  }
+}

package/ts/00_commitinfo_data.ts

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

package/ts/smartstream.classes.smartduplex.ts

@@ -34,11 +34,11 @@ export interface ISmartDuplexOptions<TInput, TOutput> extends DuplexOptions {
    * it can push or return chunks (but does not have to) to be written to the readable side of the stream
    */
   writeFunction?: IStreamWriteFunction<TInput, TOutput>;
+  
   /**
-   * a final function that is being sent to the end of the stream 
+   * a final function that is run at the end of the stream 
    */
   finalFunction?: IStreamFinalFunction<TOutput>;
-  // Add other custom options if necessary
 }
 
 export class SmartDuplex<TInput = any, TOutput = any> extends Duplex {