@push.rocks/smartstream 2.0.7 → 3.0.2

package/dist_ts/00_commitinfo_data.js

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

package/dist_ts/index.d.ts

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

package/dist_ts/index.js

@@ -1,5 +1,5 @@
-export * from './smartstream.classes.smartstream.js';
+export * from './smartstream.classes.passthrough.js';
+export * from './smartstream.classes.smartduplex.js';
 export * from './smartstream.classes.streamwrapper.js';
 export * from './smartstream.classes.streamintake.js';
-export * from './smartstream.duplex.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHNDQUFzQyxDQUFDO0FBQ3JELGNBQWMsd0NBQXdDLENBQUM7QUFDdkQsY0FBYyx1Q0FBdUMsQ0FBQztBQUN0RCxjQUFjLHlCQUF5QixDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHNDQUFzQyxDQUFDO0FBQ3JELGNBQWMsc0NBQXNDLENBQUM7QUFDckQsY0FBYyx3Q0FBd0MsQ0FBQztBQUN2RCxjQUFjLHVDQUF1QyxDQUFDIn0=

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

@@ -0,0 +1,32 @@
+/// <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 interface IStreamTools {
+    truncate: () => void;
+    push: (pipeObject: any) => void;
+}
+export interface IWriteAndTransformFunction<T, rT> {
+    (chunkArg: T, toolsArg: IStreamTools): Promise<rT>;
+}
+export interface IStreamEndFunction<rT> {
+    (toolsArg: IStreamTools): Promise<rT>;
+}
+export interface SmartStreamOptions<TInput, TOutput> extends DuplexOptions {
+    readFunction?: () => Promise<void>;
+    writeAndTransformFunction?: IWriteAndTransformFunction<TInput, TOutput>;
+    streamEndFunction?: IStreamEndFunction<TOutput>;
+}
+export declare class SmartDuplex<TInput = any, TOutput = any> extends Duplex {
+    static fromBuffer(buffer: Buffer, options?: DuplexOptions): SmartDuplex;
+    static fromObservable(observable: plugins.smartrx.rxjs.Observable<any>, options?: DuplexOptions): SmartDuplex;
+    static fromReplaySubject(replaySubject: plugins.smartrx.rxjs.ReplaySubject<any>, options?: DuplexOptions): SmartDuplex;
+    private readFunction?;
+    private writeAndTransformFunction?;
+    private streamEndFunction?;
+    private observableSubscription?;
+    constructor(optionsArg?: SmartStreamOptions<TInput, TOutput>);
+    _read(size: number): Promise<void>;
+    _write(chunk: TInput, encoding: string, callback: (error?: Error | null) => void): Promise<void>;
+    _final(callback: (error?: Error | null) => void): Promise<void>;
+}

package/dist_ts/smartstream.classes.smartduplex.js

@@ -0,0 +1,135 @@
+import * as plugins from './smartstream.plugins.js';
+import { Duplex } from 'stream';
+export class SmartDuplex extends Duplex {
+    // STATIC
+    static fromBuffer(buffer, options) {
+        const smartStream = new SmartDuplex(options);
+        process.nextTick(() => {
+            smartStream.push(buffer);
+            smartStream.push(null); // Signal the end of the data
+        });
+        return smartStream;
+    }
+    static fromObservable(observable, options) {
+        const smartStream = new SmartDuplex(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;
+    }
+    static fromReplaySubject(replaySubject, options) {
+        const smartStream = new SmartDuplex(options);
+        let isBackpressured = false;
+        // Subscribe to the ReplaySubject
+        const subscription = replaySubject.subscribe({
+            next: (data) => {
+                const canPush = smartStream.push(data);
+                if (!canPush) {
+                    // If push returns false, pause the subscription because of backpressure
+                    isBackpressured = true;
+                    subscription.unsubscribe();
+                }
+            },
+            error: (err) => {
+                smartStream.emit('error', err);
+            },
+            complete: () => {
+                smartStream.push(null); // End the stream when the ReplaySubject completes
+            },
+        });
+        // Listen for 'drain' event to resume the subscription if it was paused
+        smartStream.on('drain', () => {
+            if (isBackpressured) {
+                isBackpressured = false;
+                // Resubscribe to the ReplaySubject since we previously paused
+                smartStream.observableSubscription = replaySubject.subscribe({
+                    next: (data) => {
+                        if (!smartStream.push(data)) {
+                            smartStream.observableSubscription?.unsubscribe();
+                            isBackpressured = true;
+                        }
+                    },
+                    // No need to repeat error and complete handling here because it's already set up above
+                });
+            }
+        });
+        return smartStream;
+    }
+    constructor(optionsArg) {
+        super(optionsArg);
+        this.readFunction = optionsArg?.readFunction;
+        this.writeAndTransformFunction = optionsArg?.writeAndTransformFunction;
+        this.streamEndFunction = optionsArg?.streamEndFunction;
+    }
+    async _read(size) {
+        if (this.readFunction) {
+            await this.readFunction();
+        }
+    }
+    // Ensure the _write method types the chunk as TInput and encodes TOutput
+    async _write(chunk, encoding, callback) {
+        if (!this.writeAndTransformFunction) {
+            return callback(new Error('No stream function provided'));
+        }
+        const tools = {
+            truncate: () => {
+                this.push(null);
+                callback();
+            },
+            push: (pushArg) => this.push(pushArg),
+        };
+        try {
+            const modifiedChunk = await this.writeAndTransformFunction(chunk, tools);
+            if (modifiedChunk) {
+                if (!this.push(modifiedChunk)) {
+                    // Handle backpressure if necessary
+                }
+            }
+            callback();
+        }
+        catch (err) {
+            callback(err);
+        }
+    }
+    async _final(callback) {
+        if (this.streamEndFunction) {
+            const tools = {
+                truncate: () => callback(),
+                push: (pipeObject) => this.push(pipeObject),
+            };
+            try {
+                const finalChunk = await this.streamEndFunction(tools);
+                if (finalChunk) {
+                    this.push(finalChunk);
+                }
+                callback();
+            }
+            catch (err) {
+                callback(err);
+            }
+        }
+        else {
+            this.push(null),
+                callback();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,21 +1,12 @@
 /// <reference types="node" resolution-mode="require"/>
-/// <reference types="from2" />
 import * as plugins from './smartstream.plugins.js';
-export declare class StreamIntake<T> {
+export declare class StreamIntake<T> extends plugins.stream.Readable {
     private signalEndBoolean;
     private chunkStore;
     pushNextObservable: plugins.smartrx.ObservableIntake<any>;
     private pushedNextDeferred;
-    private readableStream;
-    constructor();
-    /**
-     * returns a new style readble stream
-     */
-    getReadable(): plugins.stream.Readable;
-    /**
-     * returns an oldstyle readble stream
-     */
-    getReadableStream(): plugins.from2.Stream;
+    constructor(options?: plugins.stream.ReadableOptions);
+    _read(size: number): void;
     pushData(chunkData: T): void;
     signalEnd(): void;
 }

package/dist_ts/smartstream.classes.streamintake.js

@@ -1,47 +1,38 @@
 import * as plugins from './smartstream.plugins.js';
-export class StreamIntake {
-    constructor() {
+export class StreamIntake extends plugins.stream.Readable {
+    constructor(options) {
+        super({ ...options, objectMode: true }); // Ensure that we are in object mode.
         this.signalEndBoolean = false;
         this.chunkStore = [];
         this.pushNextObservable = new plugins.smartrx.ObservableIntake();
         this.pushedNextDeferred = plugins.smartpromise.defer();
-        this.readableStream = plugins.from2.obj(async (size, next) => {
-            // console.log('get next');
-            // execute without backpressure
-            while (this.chunkStore.length > 0) {
-                next(null, this.chunkStore.shift());
-            }
-            if (this.signalEndBoolean) {
-                next(null, null);
-            }
-            // lets trigger backpressure handling
-            this.pushNextObservable.push('please push next');
-            await this.pushedNextDeferred.promise;
-            this.pushedNextDeferred = plugins.smartpromise.defer();
-            // execute with backpressure
-            while (this.chunkStore.length > 0) {
-                next(null, this.chunkStore.shift());
-            }
-            if (this.signalEndBoolean) {
-                next(null, null);
-            }
-        });
         this.pushNextObservable.push('please push next');
     }
-    /**
-     * returns a new style readble stream
-     */
-    getReadable() {
-        const readable = new plugins.stream.Readable({
-            objectMode: true,
-        });
-        return readable.wrap(this.readableStream);
-    }
-    /**
-     * returns an oldstyle readble stream
-     */
-    getReadableStream() {
-        return this.readableStream;
+    _read(size) {
+        // console.log('get next');
+        const pushChunk = () => {
+            if (this.chunkStore.length > 0) {
+                // If push returns false, then we should stop reading
+                if (!this.push(this.chunkStore.shift())) {
+                    return;
+                }
+            }
+            if (this.chunkStore.length === 0) {
+                if (this.signalEndBoolean) {
+                    // If we're done, push null to signal the end of the stream
+                    this.push(null);
+                }
+                else {
+                    // Ask for more data and wait
+                    this.pushNextObservable.push('please push next');
+                    this.pushedNextDeferred.promise.then(() => {
+                        this.pushedNextDeferred = plugins.smartpromise.defer(); // Reset the deferred
+                        pushChunk(); // Try pushing the next chunk
+                    });
+                }
+            }
+        };
+        pushChunk();
     }
     pushData(chunkData) {
         this.chunkStore.push(chunkData);
@@ -53,4 +44,4 @@ export class StreamIntake {
         this.pushNextObservable.signalComplete();
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzdHJlYW0uY2xhc3Nlcy5zdHJlYW1pbnRha2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9zbWFydHN0cmVhbS5jbGFzc2VzLnN0cmVhbWludGFrZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLDBCQUEwQixDQUFDO0FBRXBELE1BQU0sT0FBTyxZQUFZO0lBZ0N2QjtRQS9CUSxxQkFBZ0IsR0FBRyxLQUFLLENBQUM7UUFDekIsZUFBVSxHQUFRLEVBQUUsQ0FBQztRQUV0Qix1QkFBa0IsR0FBRyxJQUFJLE9BQU8sQ0FBQyxPQUFPLENBQUMsZ0JBQWdCLEVBQU8sQ0FBQztRQUVoRSx1QkFBa0IsR0FBRyxPQUFPLENBQUMsWUFBWSxDQUFDLEtBQUssRUFBRSxDQUFDO1FBRWxELG1CQUFjLEdBQUcsT0FBTyxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsS0FBSyxFQUFFLElBQUksRUFBRSxJQUFJLEVBQUUsRUFBRTtZQUM5RCwyQkFBMkI7WUFDM0IsK0JBQStCO1lBQy9CLE9BQU8sSUFBSSxDQUFDLFVBQVUsQ0FBQyxNQUFNLEdBQUcsQ0FBQyxFQUFFO2dCQUNqQyxJQUFJLENBQUMsSUFBSSxFQUFFLElBQUksQ0FBQyxVQUFVLENBQUMsS0FBSyxFQUFFLENBQUMsQ0FBQzthQUNyQztZQUNELElBQUksSUFBSSxDQUFDLGdCQUFnQixFQUFFO2dCQUN6QixJQUFJLENBQUMsSUFBSSxFQUFFLElBQUksQ0FBQyxDQUFDO2FBQ2xCO1lBRUQscUNBQXFDO1lBQ3JDLElBQUksQ0FBQyxrQkFBa0IsQ0FBQyxJQUFJLENBQUMsa0JBQWtCLENBQUMsQ0FBQztZQUNqRCxNQUFNLElBQUksQ0FBQyxrQkFBa0IsQ0FBQyxPQUFPLENBQUM7WUFDdEMsSUFBSSxDQUFDLGtCQUFrQixHQUFHLE9BQU8sQ0FBQyxZQUFZLENBQUMsS0FBSyxFQUFFLENBQUM7WUFFdkQsNEJBQTRCO1lBQzVCLE9BQU8sSUFBSSxDQUFDLFVBQVUsQ0FBQyxNQUFNLEdBQUcsQ0FBQyxFQUFFO2dCQUNqQyxJQUFJLENBQUMsSUFBSSxFQUFFLElBQUksQ0FBQyxVQUFVLENBQUMsS0FBSyxFQUFFLENBQUMsQ0FBQzthQUNyQztZQUNELElBQUksSUFBSSxDQUFDLGdCQUFnQixFQUFFO2dCQUN6QixJQUFJLENBQUMsSUFBSSxFQUFFLElBQUksQ0FBQyxDQUFDO2FBQ2xCO1FBQ0gsQ0FBQyxDQUFDLENBQUM7UUFHRCxJQUFJLENBQUMsa0JBQWtCLENBQUMsSUFBSSxDQUFDLGtCQUFrQixDQUFDLENBQUM7SUFDbkQsQ0FBQztJQUVEOztPQUVHO0lBQ0ksV0FBVztRQUNoQixNQUFNLFFBQVEsR0FBRyxJQUFJLE9BQU8sQ0FBQyxNQUFNLENBQUMsUUFBUSxDQUFDO1lBQzNDLFVBQVUsRUFBRSxJQUFJO1NBQ2pCLENBQUMsQ0FBQztRQUNILE9BQU8sUUFBUSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsY0FBYyxDQUFDLENBQUM7SUFDNUMsQ0FBQztJQUVEOztPQUVHO0lBQ0ksaUJBQWlCO1FBQ3RCLE9BQU8sSUFBSSxDQUFDLGNBQWMsQ0FBQztJQUM3QixDQUFDO0lBRU0sUUFBUSxDQUFDLFNBQVk7UUFDMUIsSUFBSSxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLENBQUM7UUFDaEMsSUFBSSxDQUFDLGtCQUFrQixDQUFDLE9BQU8sRUFBRSxDQUFDO0lBQ3BDLENBQUM7SUFFTSxTQUFTO1FBQ2QsSUFBSSxDQUFDLGdCQUFnQixHQUFHLElBQUksQ0FBQztRQUM3QixJQUFJLENBQUMsa0JBQWtCLENBQUMsT0FBTyxFQUFFLENBQUM7UUFDbEMsSUFBSSxDQUFDLGtCQUFrQixDQUFDLGNBQWMsRUFBRSxDQUFDO0lBQzNDLENBQUM7Q0FDRiJ9
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartstream",
-  "version": "2.0.7",
+  "version": "3.0.2",
   "private": false,
   "description": "simplifies access to node streams",
   "main": "dist_ts/index.js",
@@ -8,18 +8,19 @@
   "type": "module",
   "scripts": {
     "test": "(tstest test/)",
-    "build": "(tsbuild)"
+    "build": "(tsbuild)",
+    "buildDocs": "tsdoc"
   },
   "repository": {
     "type": "git",
-    "url": "git+ssh://git@gitlab.com/pushrocks/smartstream.git"
+    "url": "git+https://gitlab.com/push.rocks/smartstream.git"
   },
   "author": "Lossless GmbH",
   "license": "MIT",
   "bugs": {
-    "url": "https://gitlab.com/pushrocks/smartstream/issues"
+    "url": "https://gitlab.com/push.rocks/smartstream/issues"
   },
-  "homepage": "https://gitlab.com/pushrocks/smartstream#README",
+  "homepage": "https://gitlab.com/push.rocks/smartstream#readme",
   "devDependencies": {
     "@git.zone/tsbuild": "^2.1.66",
     "@git.zone/tsrun": "^1.2.44",

package/ts/00_commitinfo_data.ts

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

package/ts/index.ts

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

package/ts/smartstream.classes.passthrough.ts

@@ -0,0 +1,19 @@
+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);
+    }
+  }
+}

package/ts/smartstream.classes.smartduplex.ts

@@ -0,0 +1,177 @@
+import * as plugins from './smartstream.plugins.js';
+import { Duplex, type DuplexOptions } from 'stream';
+
+export interface IStreamTools {
+  truncate: () => void;
+  push: (pipeObject: any) => void;
+}
+
+export interface IWriteAndTransformFunction<T, rT> {
+  (chunkArg: T, toolsArg: IStreamTools): Promise<rT>;
+}
+
+export interface IStreamEndFunction<rT> {
+  (toolsArg: IStreamTools): Promise<rT>;
+}
+
+export interface SmartStreamOptions<TInput, TOutput> extends DuplexOptions {
+  readFunction?: () => Promise<void>;
+  writeAndTransformFunction?: IWriteAndTransformFunction<TInput, TOutput>;
+  streamEndFunction?: IStreamEndFunction<TOutput>;
+  // Add other custom options if necessary
+}
+
+export class SmartDuplex<TInput = any, TOutput = any> extends Duplex {
+  // STATIC
+  static fromBuffer(buffer: Buffer, options?: DuplexOptions): SmartDuplex {
+    const smartStream = new SmartDuplex(options);
+    process.nextTick(() => {
+      smartStream.push(buffer);
+      smartStream.push(null); // Signal the end of the data
+    });
+    return smartStream;
+  }
+
+  static fromObservable(
+    observable: plugins.smartrx.rxjs.Observable<any>,
+    options?: DuplexOptions
+  ): SmartDuplex {
+    const smartStream = new SmartDuplex(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;
+  }
+
+  static fromReplaySubject(
+    replaySubject: plugins.smartrx.rxjs.ReplaySubject<any>,
+    options?: DuplexOptions
+  ): SmartDuplex {
+    const smartStream = new SmartDuplex(options);
+    let isBackpressured = false;
+
+    // Subscribe to the ReplaySubject
+    const subscription = replaySubject.subscribe({
+      next: (data) => {
+        const canPush = smartStream.push(data);
+        if (!canPush) {
+          // If push returns false, pause the subscription because of backpressure
+          isBackpressured = true;
+          subscription.unsubscribe();
+        }
+      },
+      error: (err) => {
+        smartStream.emit('error', err);
+      },
+      complete: () => {
+        smartStream.push(null); // End the stream when the ReplaySubject completes
+      },
+    });
+
+    // Listen for 'drain' event to resume the subscription if it was paused
+    smartStream.on('drain', () => {
+      if (isBackpressured) {
+        isBackpressured = false;
+        // Resubscribe to the ReplaySubject since we previously paused
+        smartStream.observableSubscription = replaySubject.subscribe({
+          next: (data) => {
+            if (!smartStream.push(data)) {
+              smartStream.observableSubscription?.unsubscribe();
+              isBackpressured = true;
+            }
+          },
+          // No need to repeat error and complete handling here because it's already set up above
+        });
+      }
+    });
+
+    return smartStream;
+  }
+
+  // INSTANCE
+  private readFunction?: () => Promise<void>;
+  private writeAndTransformFunction?: IWriteAndTransformFunction<TInput, TOutput>;
+  private streamEndFunction?: IStreamEndFunction<TOutput>;
+  private observableSubscription?: plugins.smartrx.rxjs.Subscription;
+
+  constructor(optionsArg?: SmartStreamOptions<TInput, TOutput>) {
+    super(optionsArg);
+    this.readFunction = optionsArg?.readFunction;
+    this.writeAndTransformFunction = optionsArg?.writeAndTransformFunction;
+    this.streamEndFunction = optionsArg?.streamEndFunction;
+  }
+
+  public async _read(size: number): Promise<void> {
+    if (this.readFunction) {
+      await this.readFunction();
+    }
+  }
+
+  // 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) {
+      return callback(new Error('No stream function provided'));
+    }
+
+    const tools: IStreamTools = {
+      truncate: () => {
+        this.push(null);
+        callback();
+      },
+      push: (pushArg: TOutput) => this.push(pushArg),
+    };
+
+    try {
+      const modifiedChunk = await this.writeAndTransformFunction(chunk, tools);
+      if (modifiedChunk) {
+        if (!this.push(modifiedChunk)) {
+          // Handle backpressure if necessary
+        }
+      }
+      callback();
+    } catch (err) {
+      callback(err);
+    }
+  }
+
+  public async _final(callback: (error?: Error | null) => void) {
+    if (this.streamEndFunction) {
+      const tools: IStreamTools = {
+        truncate: () => callback(),
+        push: (pipeObject) => this.push(pipeObject),
+      };
+
+      try {
+        const finalChunk = await this.streamEndFunction(tools);
+        if (finalChunk) {
+          this.push(finalChunk);
+        }
+        callback();
+      } catch (err) {
+        callback(err);
+      }
+    } else {
+      this.push(null),
+      callback();
+    }
+  }
+}

package/ts/smartstream.classes.streamintake.ts

@@ -1,56 +1,42 @@
 import * as plugins from './smartstream.plugins.js';
 
-export class StreamIntake<T> {
+export class StreamIntake<T> extends plugins.stream.Readable {
   private signalEndBoolean = false;
   private chunkStore: T[] = [];
-
   public pushNextObservable = new plugins.smartrx.ObservableIntake<any>();
-
   private pushedNextDeferred = plugins.smartpromise.defer();
 
-  private readableStream = plugins.from2.obj(async (size, next) => {
-    // console.log('get next');
-    // execute without backpressure
-    while (this.chunkStore.length > 0) {
-      next(null, this.chunkStore.shift());
-    }
-    if (this.signalEndBoolean) {
-      next(null, null);
-    }
-
-    // lets trigger backpressure handling
-    this.pushNextObservable.push('please push next');
-    await this.pushedNextDeferred.promise;
-    this.pushedNextDeferred = plugins.smartpromise.defer();
-
-    // execute with backpressure
-    while (this.chunkStore.length > 0) {
-      next(null, this.chunkStore.shift());
-    }
-    if (this.signalEndBoolean) {
-      next(null, null);
-    }
-  });
-
-  constructor() {
+  constructor(options?: plugins.stream.ReadableOptions) {
+    super({ ...options, objectMode: true }); // Ensure that we are in object mode.
     this.pushNextObservable.push('please push next');
   }
 
-  /**
-   * returns a new style readble stream
-   */
-  public getReadable() {
-    const readable = new plugins.stream.Readable({
-      objectMode: true,
-    });
-    return readable.wrap(this.readableStream);
-  }
-
-  /**
-   * returns an oldstyle readble stream
-   */
-  public getReadableStream() {
-    return this.readableStream;
+  _read(size: number): void {
+    // console.log('get next');
+    const pushChunk = (): void => {
+      if (this.chunkStore.length > 0) {
+        // If push returns false, then we should stop reading
+        if (!this.push(this.chunkStore.shift())) {
+          return;
+        }
+      }
+
+      if (this.chunkStore.length === 0) {
+        if (this.signalEndBoolean) {
+          // If we're done, push null to signal the end of the stream
+          this.push(null);
+        } else {
+          // Ask for more data and wait
+          this.pushNextObservable.push('please push next');
+          this.pushedNextDeferred.promise.then(() => {
+            this.pushedNextDeferred = plugins.smartpromise.defer(); // Reset the deferred
+            pushChunk(); // Try pushing the next chunk
+          });
+        }
+      }
+    };
+
+    pushChunk();
   }
 
   public pushData(chunkData: T) {

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

@@ -1,12 +0,0 @@
-/// <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

@@ -1,48 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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/ts/smartstream.classes.smartstream.ts

@@ -1,55 +0,0 @@
-import * as plugins from './smartstream.plugins.js';
-import { Duplex, type DuplexOptions } from 'stream';
-
-export class SmartStream extends Duplex {
-  private observableSubscription?: plugins.smartrx.rxjs.Subscription;
-
-  constructor(options?: DuplexOptions) {
-    super(options);
-  }
-
-  _read(size: number) {
-    // Implement if you need custom behavior, otherwise leave it empty
-  }
-
-  _write(chunk: any, encoding: string, callback: (error?: Error | null) => void) {
-    // Implement if you need custom behavior
-    callback();
-  }
-
-  static fromBuffer(buffer: Buffer, options?: DuplexOptions): SmartStream {
-    const smartStream = new SmartStream(options);
-    process.nextTick(() => {
-      smartStream.push(buffer);
-      smartStream.push(null); // Signal the end of the data
-    });
-    return smartStream;
-  }
-
-  static fromObservable(observable: plugins.smartrx.rxjs.Observable<any>, options?: DuplexOptions): SmartStream {
-    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;
-  }
-}

package/ts/smartstream.duplex.ts

@@ -1,83 +0,0 @@
-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 let createDuplexStream = <T, rT>(
-  funcArg: IStreamFunction<T, rT>,
-  endFuncArg?: IStreamEndFunction<rT>,
-  optionsArg: IStreamOptions = {
-    objectMode: false,
-    readableObjectMode: true,
-    writableObjectMode: true,
-  }
-) => {
-  return plugins.through2(
-    optionsArg,
-    function (chunk, enc, cb) {
-      let truncated = false;
-      const tools: IStreamTools = {
-        truncate: () => {
-          truncated = true;
-          cb(null, null);
-        },
-        pipeMore: (pipeObject) => {
-          this.push(pipeObject);
-        },
-      };
-      const asyncWrapper = async () => {
-        const resultChunk: rT = await funcArg(chunk, tools);
-        if (!truncated) {
-          cb(null, resultChunk);
-        }
-      };
-      asyncWrapper().catch((err) => {
-        console.log(err);
-      });
-    },
-    function (cb) {
-      const tools: IStreamTools = {
-        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);
-      });
-    }
-  );
-};