@push.rocks/smartstream 2.0.3

package/dist_ts/00_commitinfo_data.d.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export declare const commitinfo: {
+    name: string;
+    version: string;
+    description: string;
+};

package/dist_ts/00_commitinfo_data.js

@@ -0,0 +1,9 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export const commitinfo = {
+    name: '@pushrocks/smartstream',
+    version: '2.0.3',
+    description: 'simplifies access to node streams'
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx3QkFBd0I7SUFDOUIsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLG1DQUFtQztDQUNqRCxDQUFBIn0=

package/dist_ts/index.d.ts

@@ -0,0 +1,3 @@
+export * from './smartstream.classes.streamwrapper.js';
+export * from './smartstream.classes.streamintake.js';
+export * from './smartstream.duplex.js';

package/dist_ts/index.js

@@ -0,0 +1,4 @@
+export * from './smartstream.classes.streamwrapper.js';
+export * from './smartstream.classes.streamintake.js';
+export * from './smartstream.duplex.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHdDQUF3QyxDQUFDO0FBQ3ZELGNBQWMsdUNBQXVDLENBQUM7QUFDdEQsY0FBYyx5QkFBeUIsQ0FBQyJ9

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

@@ -0,0 +1,21 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import * as plugins from './smartstream.plugins.js';
+export declare class StreamIntake<T> {
+    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(): NodeJS.ReadableStream;
+    pushData(chunkData: T): void;
+    signalEnd(): void;
+}

package/dist_ts/smartstream.classes.streamintake.js

@@ -0,0 +1,56 @@
+import * as plugins from './smartstream.plugins.js';
+export class StreamIntake {
+    constructor() {
+        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;
+    }
+    pushData(chunkData) {
+        this.chunkStore.push(chunkData);
+        this.pushedNextDeferred.resolve();
+    }
+    signalEnd() {
+        this.signalEndBoolean = true;
+        this.pushedNextDeferred.resolve();
+        this.pushNextObservable.signalComplete();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,37 @@
+import * as plugins from './smartstream.plugins.js';
+export interface IErrorFunction {
+    (err: Error): any;
+}
+export interface ICustomEventFunction {
+    (): any;
+}
+export interface ICustomEventObject {
+    eventName: string;
+    eventFunction: ICustomEventFunction;
+}
+/**
+ * class Smartstream handles
+ */
+export declare class StreamWrapper {
+    private streamArray;
+    private customEventObjectArray;
+    private streamStartedDeferred;
+    /**
+     * constructor
+     */
+    constructor(streamArrayArg: any[]);
+    /**
+     * make something with the stream itself
+     */
+    streamStarted(): Promise<any>;
+    /**
+     * attach listener to custom event
+     */
+    onCustomEvent(eventNameArg: string, eventFunctionArg: ICustomEventFunction): void;
+    /**
+     * run the stream
+     * @returns Promise
+     */
+    run(): Promise<void>;
+}
+export declare let cleanPipe: () => plugins.stream.Transform;

package/dist_ts/smartstream.classes.streamwrapper.js

@@ -0,0 +1,81 @@
+import * as plugins from './smartstream.plugins.js';
+// interfaces
+import 'stream';
+/**
+ * class Smartstream handles
+ */
+export class StreamWrapper {
+    /**
+     * constructor
+     */
+    constructor(streamArrayArg) {
+        this.streamArray = [];
+        this.customEventObjectArray = [];
+        this.streamStartedDeferred = plugins.smartpromise.defer();
+        this.streamArray = streamArrayArg;
+    }
+    /**
+     * make something with the stream itself
+     */
+    streamStarted() {
+        return this.streamStartedDeferred.promise;
+    }
+    /**
+     * attach listener to custom event
+     */
+    onCustomEvent(eventNameArg, eventFunctionArg) {
+        this.customEventObjectArray.push({
+            eventName: eventNameArg,
+            eventFunction: eventFunctionArg,
+        });
+    }
+    /**
+     * run the stream
+     * @returns Promise
+     */
+    run() {
+        const done = plugins.smartpromise.defer();
+        // clone Array
+        const streamExecutionArray = [];
+        for (const streamItem of this.streamArray) {
+            streamExecutionArray.push(streamItem);
+        }
+        // combine the stream
+        let finalStream = null;
+        let firstIteration = true;
+        for (const stream of streamExecutionArray) {
+            if (firstIteration === true) {
+                finalStream = stream;
+            }
+            stream.on('error', (err) => {
+                done.reject(err);
+            });
+            for (const customEventObject of this.customEventObjectArray) {
+                stream.on(customEventObject.eventName, customEventObject.eventFunction);
+            }
+            if (!firstIteration) {
+                finalStream = finalStream.pipe(stream);
+            }
+            firstIteration = false;
+        }
+        this.streamStartedDeferred.resolve();
+        finalStream.on('end', () => {
+            done.resolve();
+        });
+        finalStream.on('close', () => {
+            done.resolve();
+        });
+        finalStream.on('finish', () => {
+            done.resolve();
+        });
+        return done.promise;
+    }
+}
+export let cleanPipe = () => {
+    return plugins.through2.obj((file, enc, cb) => {
+        cb();
+    }, (cb) => {
+        cb();
+    });
+};
+//# 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/dist_ts/smartstream.plugins.d.ts

@@ -0,0 +1,8 @@
+import * as stream from 'stream';
+export { stream };
+import * as smartpromise from '@pushrocks/smartpromise';
+import * as smartrx from '@pushrocks/smartrx';
+export { smartpromise, smartrx };
+import from2 from 'from2';
+import through2 from 'through2';
+export { from2, through2 };

package/dist_ts/smartstream.plugins.js

@@ -0,0 +1,12 @@
+// node native
+import * as stream from 'stream';
+export { stream };
+// pushrocks scope
+import * as smartpromise from '@pushrocks/smartpromise';
+import * as smartrx from '@pushrocks/smartrx';
+export { smartpromise, smartrx };
+// thirdparty
+import from2 from 'from2';
+import through2 from 'through2';
+export { from2, through2 };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzdHJlYW0ucGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0c3RyZWFtLnBsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYztBQUNkLE9BQU8sS0FBSyxNQUFNLE1BQU0sUUFBUSxDQUFDO0FBRWpDLE9BQU8sRUFBRSxNQUFNLEVBQUUsQ0FBQztBQUVsQixrQkFBa0I7QUFDbEIsT0FBTyxLQUFLLFlBQVksTUFBTSx5QkFBeUIsQ0FBQztBQUN4RCxPQUFPLEtBQUssT0FBTyxNQUFNLG9CQUFvQixDQUFDO0FBRTlDLE9BQU8sRUFBRSxZQUFZLEVBQUUsT0FBTyxFQUFFLENBQUM7QUFFakMsYUFBYTtBQUNiLE9BQU8sS0FBSyxNQUFNLE9BQU8sQ0FBQztBQUMxQixPQUFPLFFBQVEsTUFBTSxVQUFVLENBQUM7QUFFaEMsT0FBTyxFQUFFLEtBQUssRUFBRSxRQUFRLEVBQUUsQ0FBQyJ9

package/npmextra.json

@@ -0,0 +1,17 @@
+{
+  "npmci": {
+    "npmGlobalTools": [],
+    "npmAccessLevel": "public"
+  },
+  "gitzone": {
+    "projectType": "npm",
+    "module": {
+      "githost": "gitlab.com",
+      "gitscope": "pushrocks",
+      "gitrepo": "smartstream",
+      "description": "simplifies access to node streams",
+      "npmPackagename": "@pushrocks/smartstream",
+      "license": "MIT"
+    }
+  }
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@push.rocks/smartstream",
+  "version": "2.0.3",
+  "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)"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@gitlab.com/pushrocks/smartstream.git"
+  },
+  "author": "Lossless GmbH",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://gitlab.com/pushrocks/smartstream/issues"
+  },
+  "homepage": "https://gitlab.com/pushrocks/smartstream#README",
+  "devDependencies": {
+    "@gitzone/tsbuild": "^2.1.63",
+    "@gitzone/tstest": "^1.0.71",
+    "@pushrocks/smartfile": "^10.0.0",
+    "@pushrocks/tapbundle": "^5.0.3",
+    "tslint": "^6.1.3",
+    "tslint-config-prettier": "^1.18.0"
+  },
+  "dependencies": {
+    "@pushrocks/smartpromise": "^3.1.7",
+    "@pushrocks/smartrx": "^2.0.25",
+    "@types/from2": "^2.3.1",
+    "@types/through2": "^2.0.36",
+    "from2": "^2.3.0",
+    "through2": "^4.0.2"
+  },
+  "browserslist": [
+    "last 1 chrome versions"
+  ],
+  "files": [
+    "ts/**/*",
+    "ts_web/**/*",
+    "dist/**/*",
+    "dist_*/**/*",
+    "dist_ts/**/*",
+    "dist_ts_web/**/*",
+    "assets/**/*",
+    "cli.js",
+    "npmextra.json",
+    "readme.md"
+  ]
+}

package/readme.md

@@ -0,0 +1,54 @@
+# @pushrocks/smartstream
+simplifies access to node streams
+
+## Availabililty and Links
+* [npmjs.org (npm package)](https://www.npmjs.com/package/@pushrocks/smartstream)
+* [gitlab.com (source)](https://gitlab.com/pushrocks/smartstream)
+* [github.com (source mirror)](https://github.com/pushrocks/smartstream)
+* [docs (typedoc)](https://pushrocks.gitlab.io/smartstream/)
+
+## Status for master
+
+Status Category | Status Badge
+-- | --
+GitLab Pipelines | [![pipeline status](https://gitlab.com/pushrocks/smartstream/badges/master/pipeline.svg)](https://lossless.cloud)
+GitLab Pipline Test Coverage | [![coverage report](https://gitlab.com/pushrocks/smartstream/badges/master/coverage.svg)](https://lossless.cloud)
+npm | [![npm downloads per month](https://badgen.net/npm/dy/@pushrocks/smartstream)](https://lossless.cloud)
+Snyk | [![Known Vulnerabilities](https://badgen.net/snyk/pushrocks/smartstream)](https://lossless.cloud)
+TypeScript Support | [![TypeScript](https://badgen.net/badge/TypeScript/>=%203.x/blue?icon=typescript)](https://lossless.cloud)
+node Support | [![node](https://img.shields.io/badge/node->=%2010.x.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
+Code Style | [![Code Style](https://badgen.net/badge/style/prettier/purple)](https://lossless.cloud)
+PackagePhobia (total standalone install weight) | [![PackagePhobia](https://badgen.net/packagephobia/install/@pushrocks/smartstream)](https://lossless.cloud)
+PackagePhobia (package size on registry) | [![PackagePhobia](https://badgen.net/packagephobia/publish/@pushrocks/smartstream)](https://lossless.cloud)
+BundlePhobia (total size when bundled) | [![BundlePhobia](https://badgen.net/bundlephobia/minzip/@pushrocks/smartstream)](https://lossless.cloud)
+Platform support | [![Supports Windows 10](https://badgen.net/badge/supports%20Windows%2010/yes/green?icon=windows)](https://lossless.cloud) [![Supports Mac OS X](https://badgen.net/badge/supports%20Mac%20OS%20X/yes/green?icon=apple)](https://lossless.cloud)
+
+## Usage
+
+Use TypeScript for best in class instellisense.
+
+```typescript
+import { Smartstream } from 'smartstream'
+import * as gUglify from 'gulp-uglify'
+
+let mySmartstream = new Smartstream([
+    gulp.src(['./file1.js','./file2.js']),
+    gUglify(),
+    gulp.dest('./some/output/path')
+])
+
+mySmartstream.onError((err) => { /* handle error */ }) // handles all errors in stream
+myStream.onCustomEvent('myeventname', (args...) => { /* Do something */ }) // emit an custom event anywhere in your stream
+mySmartstream.run().then(() => {/* do something when stream is finished */})
+```
+
+## Contribution
+
+We are always happy for code contributions. If you are not the code contributing type that is ok. Still, maintaining Open Source repositories takes considerable time and thought. If you like the quality of what we do and our modules are useful to you we would appreciate a little monthly contribution: You can [contribute one time](https://lossless.link/contribute-onetime) or [contribute monthly](https://lossless.link/contribute). :)
+
+For further information read the linked docs at the top of this readme.
+
+> MIT licensed | **©** [Lossless GmbH](https://lossless.gmbh)
+| By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy)
+
+[![repo-footer](https://lossless.gitlab.io/publicrelations/repofooter.svg)](https://maintainedby.lossless.com)

package/ts/00_commitinfo_data.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@pushrocks/smartstream',
+  version: '2.0.3',
+  description: 'simplifies access to node streams'
+}

package/ts/index.ts

@@ -0,0 +1,3 @@
+export * from './smartstream.classes.streamwrapper.js';
+export * from './smartstream.classes.streamintake.js';
+export * from './smartstream.duplex.js';

package/ts/smartstream.classes.streamintake.ts

@@ -0,0 +1,66 @@
+import * as plugins from './smartstream.plugins.js';
+
+export class StreamIntake<T> {
+  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() {
+    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;
+  }
+
+  public pushData(chunkData: T) {
+    this.chunkStore.push(chunkData);
+    this.pushedNextDeferred.resolve();
+  }
+
+  public signalEnd() {
+    this.signalEndBoolean = true;
+    this.pushedNextDeferred.resolve();
+    this.pushNextObservable.signalComplete();
+  }
+}

package/ts/smartstream.classes.streamwrapper.ts

@@ -0,0 +1,107 @@
+import * as plugins from './smartstream.plugins.js';
+
+// interfaces
+import { Transform } from 'stream';
+
+export interface IErrorFunction {
+  (err: Error): any;
+}
+
+export interface ICustomEventFunction {
+  (): any;
+}
+
+export interface ICustomEventObject {
+  eventName: string;
+  eventFunction: ICustomEventFunction;
+}
+
+/**
+ * class Smartstream handles
+ */
+export class StreamWrapper {
+  private streamArray: Array<plugins.stream.Duplex> = [];
+  private customEventObjectArray: ICustomEventObject[] = [];
+  private streamStartedDeferred = plugins.smartpromise.defer();
+
+  /**
+   * constructor
+   */
+  constructor(streamArrayArg: any[]) {
+    this.streamArray = streamArrayArg;
+  }
+
+  /**
+   * make something with the stream itself
+   */
+  streamStarted(): Promise<any> {
+    return this.streamStartedDeferred.promise;
+  }
+
+  /**
+   * attach listener to custom event
+   */
+  onCustomEvent(eventNameArg: string, eventFunctionArg: ICustomEventFunction) {
+    this.customEventObjectArray.push({
+      eventName: eventNameArg,
+      eventFunction: eventFunctionArg,
+    });
+  }
+
+  /**
+   * run the stream
+   * @returns Promise
+   */
+  run(): Promise<void> {
+    const done = plugins.smartpromise.defer<void>();
+
+    // clone Array
+    const streamExecutionArray: Array<plugins.stream.Duplex> = [];
+    for (const streamItem of this.streamArray) {
+      streamExecutionArray.push(streamItem);
+    }
+
+    // combine the stream
+    let finalStream = null;
+    let firstIteration: boolean = true;
+    for (const stream of streamExecutionArray) {
+      if (firstIteration === true) {
+        finalStream = stream;
+      }
+      stream.on('error', (err) => {
+        done.reject(err);
+      });
+      for (const customEventObject of this.customEventObjectArray) {
+        stream.on(customEventObject.eventName, customEventObject.eventFunction);
+      }
+      if (!firstIteration) {
+        finalStream = finalStream.pipe(stream);
+      }
+      firstIteration = false;
+    }
+
+    this.streamStartedDeferred.resolve();
+
+    finalStream.on('end', () => {
+      done.resolve();
+    });
+    finalStream.on('close', () => {
+      done.resolve();
+    });
+    finalStream.on('finish', () => {
+      done.resolve();
+    });
+    return done.promise;
+  }
+}
+
+export let cleanPipe = () => {
+  return plugins.through2.obj(
+    (file, enc, cb) => {
+      cb();
+    },
+    (cb) => {
+      cb();
+    }
+  );
+};

package/ts/smartstream.duplex.ts

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

package/ts/smartstream.plugins.ts

@@ -0,0 +1,16 @@
+// node native
+import * as stream from 'stream';
+
+export { stream };
+
+// pushrocks scope
+import * as smartpromise from '@pushrocks/smartpromise';
+import * as smartrx from '@pushrocks/smartrx';
+
+export { smartpromise, smartrx };
+
+// thirdparty
+import from2 from 'from2';
+import through2 from 'through2';
+
+export { from2, through2 };