@push.rocks/smartstream 3.0.37 → 3.0.39

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@push.rocks/smartstream',
-    version: '3.0.37',
+    version: '3.0.39',
     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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx5QkFBeUI7SUFDL0IsT0FBTyxFQUFFLFFBQVE7SUFDakIsV0FBVyxFQUFFLHNMQUFzTDtDQUNwTSxDQUFBIn0=

package/dist_ts/smartstream.plugins.d.ts

@@ -4,5 +4,5 @@ export { stream };
 import * as lik from '@push.rocks/lik';
 import * as smartpromise from '@push.rocks/smartpromise';
 import * as smartrx from '@push.rocks/smartrx';
-import * as webstream from '@push.rocks/webstream';
+import * as webstream from '../dist_ts_web/index.js';
 export { lik, smartpromise, smartrx, webstream };

package/dist_ts/smartstream.plugins.js

@@ -5,6 +5,6 @@ export { stream };
 import * as lik from '@push.rocks/lik';
 import * as smartpromise from '@push.rocks/smartpromise';
 import * as smartrx from '@push.rocks/smartrx';
-import * as webstream from '@push.rocks/webstream';
+import * as webstream from '../dist_ts_web/index.js';
 export { lik, smartpromise, smartrx, webstream };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzdHJlYW0ucGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0c3RyZWFtLnBsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYztBQUNkLE9BQU8sS0FBSyxNQUFNLE1BQU0sUUFBUSxDQUFDO0FBRWpDLE9BQU8sRUFBRSxNQUFNLEVBQUUsQ0FBQztBQUVsQixrQkFBa0I7QUFDbEIsT0FBTyxLQUFLLEdBQUcsTUFBTSxpQkFBaUIsQ0FBQztBQUN2QyxPQUFPLEtBQUssWUFBWSxNQUFNLDBCQUEwQixDQUFDO0FBQ3pELE9BQU8sS0FBSyxPQUFPLE1BQU0scUJBQXFCLENBQUM7QUFDL0MsT0FBTyxLQUFLLFNBQVMsTUFBTSx1QkFBdUIsQ0FBQztBQUVuRCxPQUFPLEVBQUUsR0FBRyxFQUFFLFlBQVksRUFBRSxPQUFPLEVBQUUsU0FBUyxFQUFFLENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRzdHJlYW0ucGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0c3RyZWFtLnBsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYztBQUNkLE9BQU8sS0FBSyxNQUFNLE1BQU0sUUFBUSxDQUFDO0FBRWpDLE9BQU8sRUFBRSxNQUFNLEVBQUUsQ0FBQztBQUVsQixrQkFBa0I7QUFDbEIsT0FBTyxLQUFLLEdBQUcsTUFBTSxpQkFBaUIsQ0FBQztBQUN2QyxPQUFPLEtBQUssWUFBWSxNQUFNLDBCQUEwQixDQUFDO0FBQ3pELE9BQU8sS0FBSyxPQUFPLE1BQU0scUJBQXFCLENBQUM7QUFDL0MsT0FBTyxLQUFLLFNBQVMsTUFBTSx5QkFBeUIsQ0FBQztBQUVyRCxPQUFPLEVBQUUsR0FBRyxFQUFFLFlBQVksRUFBRSxPQUFPLEVBQUUsU0FBUyxFQUFFLENBQUMifQ==

package/dist_ts_web/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_web/00_commitinfo_data.js

@@ -0,0 +1,9 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export const commitinfo = {
+    name: '@push.rocks/smartstream',
+    version: '3.0.39',
+    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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHNfd2ViLzAwX2NvbW1pdGluZm9fZGF0YS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLFVBQVUsR0FBRztJQUN4QixJQUFJLEVBQUUseUJBQXlCO0lBQy9CLE9BQU8sRUFBRSxRQUFRO0lBQ2pCLFdBQVcsRUFBRSxzTEFBc0w7Q0FDcE0sQ0FBQSJ9

package/dist_ts_web/classes.webduplexstream.d.ts

@@ -0,0 +1,37 @@
+export interface IStreamToolsRead<TInput, TOutput> {
+    done: () => void;
+    write: (writeArg: TInput) => void;
+}
+/**
+ * the read function is called anytime
+ *   -> the WebDuplexStream is being read from
+ *      and at the same time if nothing is enqueued
+ */
+export interface IStreamReadFunction<TInput, TOutput> {
+    (toolsArg: IStreamToolsRead<TInput, TOutput>): Promise<void>;
+}
+export interface IStreamToolsWrite<TInput, TOutput> {
+    truncate: () => void;
+    push: (pushArg: TOutput) => void;
+}
+/**
+ * the write function can return something.
+ * It is called anytime 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>;
+}
+export interface WebDuplexStreamOptions<TInput, TOutput> {
+    readFunction?: IStreamReadFunction<TInput, TOutput>;
+    writeFunction?: IStreamWriteFunction<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>;
+}

package/dist_ts_web/classes.webduplexstream.js

@@ -0,0 +1,102 @@
+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) {
+        super({
+            async transform(chunk, controller) {
+                // Transformation logic remains unchanged
+                if (optionsArg?.writeFunction) {
+                    const tools = {
+                        truncate: () => controller.terminate(),
+                        push: (pushArg) => controller.enqueue(pushArg),
+                    };
+                    optionsArg.writeFunction(chunk, tools)
+                        .then(writeReturnChunk => {
+                        // the write return chunk is optional
+                        // just in case the write function returns something other than void.
+                        if (writeReturnChunk) {
+                            controller.enqueue(writeReturnChunk);
+                        }
+                    })
+                        .catch(err => controller.error(err));
+                }
+                else {
+                    controller.error(new Error('No write function provided'));
+                }
+            },
+            async flush(controller) {
+                // Flush logic remains unchanged
+                if (optionsArg?.finalFunction) {
+                    const tools = {
+                        truncate: () => controller.terminate(),
+                        push: (pipeObject) => controller.enqueue(pipeObject),
+                    };
+                    optionsArg.finalFunction(tools)
+                        .then(finalChunk => {
+                        if (finalChunk) {
+                            controller.enqueue(finalChunk);
+                        }
+                    })
+                        .catch(err => controller.error(err))
+                        .finally(() => controller.terminate());
+                }
+                else {
+                    controller.terminate();
+                }
+            }
+        });
+        this.options = optionsArg;
+    }
+    // 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);
+                        }
+                    }
+                }
+            }
+        });
+        return customReadable;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_web/convert.d.ts

@@ -0,0 +1,18 @@
+export interface IDuplexStream {
+    read(): any;
+    write(chunk: any, callback?: (error?: Error | null) => void): boolean;
+    on(event: string, listener: (...args: any[]) => void): this;
+    once(event: string, listener: (...args: any[]) => void): this;
+    end(callback?: () => void): void;
+    destroy(error?: Error): void;
+}
+export interface IReadableStreamOptions {
+    highWaterMark?: number;
+}
+export interface IWritableStreamOptions {
+    highWaterMark?: number;
+}
+export declare function convertDuplexToWebStream(duplex: IDuplexStream): {
+    readable: ReadableStream;
+    writable: WritableStream;
+};

package/dist_ts_web/convert.js

@@ -0,0 +1,45 @@
+export function convertDuplexToWebStream(duplex) {
+    const readable = new ReadableStream({
+        start(controller) {
+            duplex.on('readable', () => {
+                let chunk;
+                while (null !== (chunk = duplex.read())) {
+                    controller.enqueue(chunk);
+                }
+            });
+            duplex.on('end', () => {
+                controller.close();
+            });
+        },
+        cancel(reason) {
+            duplex.destroy(new Error(reason));
+        }
+    });
+    const writable = new WritableStream({
+        write(chunk) {
+            return new Promise((resolve, reject) => {
+                const isBackpressured = !duplex.write(chunk, (error) => {
+                    if (error) {
+                        reject(error);
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+                if (isBackpressured) {
+                    duplex.once('drain', resolve);
+                }
+            });
+        },
+        close() {
+            return new Promise((resolve, reject) => {
+                duplex.end(resolve);
+            });
+        },
+        abort(reason) {
+            duplex.destroy(new Error(reason));
+        }
+    });
+    return { readable, writable };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udmVydC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzX3dlYi9jb252ZXJ0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQWlCQSxNQUFNLFVBQVUsd0JBQXdCLENBQUMsTUFBcUI7SUFDNUQsTUFBTSxRQUFRLEdBQUcsSUFBSSxjQUFjLENBQUM7UUFDbEMsS0FBSyxDQUFDLFVBQVU7WUFDZCxNQUFNLENBQUMsRUFBRSxDQUFDLFVBQVUsRUFBRSxHQUFHLEVBQUU7Z0JBQ3pCLElBQUksS0FBSyxDQUFDO2dCQUNWLE9BQU8sSUFBSSxLQUFLLENBQUMsS0FBSyxHQUFHLE1BQU0sQ0FBQyxJQUFJLEVBQUUsQ0FBQyxFQUFFLENBQUM7b0JBQ3hDLFVBQVUsQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLENBQUM7Z0JBQzVCLENBQUM7WUFDSCxDQUFDLENBQUMsQ0FBQztZQUVILE1BQU0sQ0FBQyxFQUFFLENBQUMsS0FBSyxFQUFFLEdBQUcsRUFBRTtnQkFDcEIsVUFBVSxDQUFDLEtBQUssRUFBRSxDQUFDO1lBQ3JCLENBQUMsQ0FBQyxDQUFDO1FBQ0wsQ0FBQztRQUNELE1BQU0sQ0FBQyxNQUFNO1lBQ1gsTUFBTSxDQUFDLE9BQU8sQ0FBQyxJQUFJLEtBQUssQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDO1FBQ3BDLENBQUM7S0FDRixDQUFDLENBQUM7SUFFSCxNQUFNLFFBQVEsR0FBRyxJQUFJLGNBQWMsQ0FBQztRQUNsQyxLQUFLLENBQUMsS0FBSztZQUNULE9BQU8sSUFBSSxPQUFPLENBQU8sQ0FBQyxPQUFPLEVBQUUsTUFBTSxFQUFFLEVBQUU7Z0JBQzNDLE1BQU0sZUFBZSxHQUFHLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxLQUFLLEVBQUUsQ0FBQyxLQUFLLEVBQUUsRUFBRTtvQkFDckQsSUFBSSxLQUFLLEVBQUUsQ0FBQzt3QkFDVixNQUFNLENBQUMsS0FBSyxDQUFDLENBQUM7b0JBQ2hCLENBQUM7eUJBQU0sQ0FBQzt3QkFDTixPQUFPLEVBQUUsQ0FBQztvQkFDWixDQUFDO2dCQUNILENBQUMsQ0FBQyxDQUFDO2dCQUVILElBQUksZUFBZSxFQUFFLENBQUM7b0JBQ3BCLE1BQU0sQ0FBQyxJQUFJLENBQUMsT0FBTyxFQUFFLE9BQU8sQ0FBQyxDQUFDO2dCQUNoQyxDQUFDO1lBQ0gsQ0FBQyxDQUFDLENBQUM7UUFDTCxDQUFDO1FBQ0QsS0FBSztZQUNILE9BQU8sSUFBSSxPQUFPLENBQU8sQ0FBQyxPQUFPLEVBQUUsTUFBTSxFQUFFLEVBQUU7Z0JBQzNDLE1BQU0sQ0FBQyxHQUFHLENBQUMsT0FBTyxDQUFDLENBQUM7WUFDdEIsQ0FBQyxDQUFDLENBQUM7UUFDTCxDQUFDO1FBQ0QsS0FBSyxDQUFDLE1BQU07WUFDVixNQUFNLENBQUMsT0FBTyxDQUFDLElBQUksS0FBSyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUM7UUFDcEMsQ0FBQztLQUNGLENBQUMsQ0FBQztJQUVILE9BQU8sRUFBRSxRQUFRLEVBQUUsUUFBUSxFQUFFLENBQUM7QUFDaEMsQ0FBQyJ9

package/dist_ts_web/index.d.ts

@@ -0,0 +1,3 @@
+import './plugins.js';
+export * from './classes.webduplexstream.js';
+export { convertDuplexToWebStream, } from './convert.js';

package/dist_ts_web/index.js

@@ -0,0 +1,4 @@
+import './plugins.js';
+export * from './classes.webduplexstream.js';
+export { convertDuplexToWebStream, } from './convert.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90c193ZWIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxjQUFjLENBQUM7QUFDdEIsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxPQUFPLEVBQ0wsd0JBQXdCLEdBQ3pCLE1BQU0sY0FBYyxDQUFDIn0=

package/dist_ts_web/plugins.d.ts

@@ -0,0 +1,2 @@
+import * as smartenv from '@push.rocks/smartenv';
+export { smartenv, };

package/dist_ts_web/plugins.js

@@ -0,0 +1,11 @@
+// @push.rocks scope
+import * as smartenv from '@push.rocks/smartenv';
+export { smartenv, };
+// lets setup dependencies
+const smartenvInstance = new smartenv.Smartenv();
+await smartenvInstance.getSafeNodeModule('stream/web', async (moduleArg) => {
+    globalThis.ReadableStream = moduleArg.ReadableStream;
+    globalThis.WritableStream = moduleArg.WritableStream;
+    globalThis.TransformStream = moduleArg.TransformStream;
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzX3dlYi9wbHVnaW5zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLG9CQUFvQjtBQUNwQixPQUFPLEtBQUssUUFBUSxNQUFNLHNCQUFzQixDQUFDO0FBRWpELE9BQU8sRUFDTCxRQUFRLEdBQ1QsQ0FBQTtBQUVELDBCQUEwQjtBQUMxQixNQUFNLGdCQUFnQixHQUFHLElBQUksUUFBUSxDQUFDLFFBQVEsRUFBRSxDQUFDO0FBRWpELE1BQU0sZ0JBQWdCLENBQUMsaUJBQWlCLENBQThCLFlBQVksRUFBRSxLQUFLLEVBQUUsU0FBUyxFQUFFLEVBQUU7SUFDdEcsVUFBVSxDQUFDLGNBQWMsR0FBRyxTQUFTLENBQUMsY0FBYyxDQUFDO0lBQ3JELFVBQVUsQ0FBQyxjQUFjLEdBQUcsU0FBUyxDQUFDLGNBQWMsQ0FBQztJQUNyRCxVQUFVLENBQUMsZUFBZSxHQUFHLFNBQVMsQ0FBQyxlQUFlLENBQUM7QUFDekQsQ0FBQyxDQUFDLENBQUEifQ==

package/package.json

@@ -1,34 +1,36 @@
 {
   "name": "@push.rocks/smartstream",
-  "version": "3.0.37",
+  "version": "3.0.39",
   "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.",
-  "main": "dist_ts/index.js",
-  "typings": "dist_ts/index.d.ts",
   "type": "module",
+  "exports": {
+    ".": "./dist_ts/index.js",
+    "./web": "./dist_ts_web/index.js"
+  },
   "repository": {
     "type": "git",
-    "url": "git+https://gitlab.com/push.rocks/smartstream.git"
+    "url": "https://code.foss.global/push.rocks/smartstream.git"
   },
   "author": "Lossless GmbH",
   "license": "MIT",
   "bugs": {
     "url": "https://gitlab.com/push.rocks/smartstream/issues"
   },
-  "homepage": "https://gitlab.com/push.rocks/smartstream#readme",
+  "homepage": "https://code.foss.global/push.rocks/smartstream",
   "devDependencies": {
-    "@git.zone/tsbuild": "^2.1.72",
+    "@git.zone/tsbuild": "^2.1.80",
     "@git.zone/tsrun": "^1.2.44",
-    "@git.zone/tstest": "^1.0.88",
-    "@push.rocks/smartfile": "^11.0.4",
-    "@push.rocks/tapbundle": "^5.0.17",
-    "@types/node": "^20.11.28"
+    "@git.zone/tstest": "^1.0.90",
+    "@push.rocks/smartfile": "^11.0.15",
+    "@push.rocks/tapbundle": "^5.0.23",
+    "@types/node": "^20.12.12"
   },
   "dependencies": {
-    "@push.rocks/lik": "^6.0.14",
+    "@push.rocks/lik": "^6.0.15",
+    "@push.rocks/smartenv": "^5.0.12",
     "@push.rocks/smartpromise": "^4.0.3",
-    "@push.rocks/smartrx": "^3.0.7",
-    "@push.rocks/webstream": "^1.0.8"
+    "@push.rocks/smartrx": "^3.0.7"
   },
   "browserslist": [
     "last 1 chrome versions"
@@ -66,7 +68,6 @@
   ],
   "scripts": {
     "test": "(tstest test/)",
-    "build": "(tsbuild)",
-    "buildDocs": "tsdoc"
+    "build": "(tsbuild tsfolders --web --allowimplicitany)"
   }
 }

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartstream',
-  version: '3.0.37',
+  version: '3.0.39',
   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/smartstream.plugins.ts

@@ -7,7 +7,7 @@ export { stream };
 import * as lik from '@push.rocks/lik';
 import * as smartpromise from '@push.rocks/smartpromise';
 import * as smartrx from '@push.rocks/smartrx';
-import * as webstream from '@push.rocks/webstream';
+import * as webstream from '../dist_ts_web/index.js';
 
 export { lik, smartpromise, smartrx, webstream };
 

package/ts_web/00_commitinfo_data.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@push.rocks/smartstream',
+  version: '3.0.39',
+  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

@@ -0,0 +1,156 @@
+import * as plugins from './plugins.js';
+
+
+// ========================================
+// READ
+// ========================================
+export interface IStreamToolsRead<TInput, TOutput> {
+  done: () => void;
+  write: (writeArg: TInput) => void;
+}
+
+/**
+ * the read function is called anytime
+ *   -> the WebDuplexStream is being read from
+ *      and at the same time if nothing is enqueued
+ */
+export interface IStreamReadFunction<TInput, TOutput> {
+  (toolsArg: IStreamToolsRead<TInput, TOutput>): Promise<void>;
+}
+
+// ========================================
+// WRITE
+// ========================================
+export interface IStreamToolsWrite<TInput, TOutput> {
+  truncate: () => void;
+  push: (pushArg: TOutput) => void;
+}
+
+/**
+ * the write function can return something.
+ * It is called anytime 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>;
+}
+
+export interface WebDuplexStreamOptions<TInput, TOutput> {
+  readFunction?: IStreamReadFunction<TInput, TOutput>;
+  writeFunction?: IStreamWriteFunction<TInput, TOutput>;
+  finalFunction?: IStreamFinalFunction<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>) {
+    super({
+      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),
+          };
+        
+          optionsArg.writeFunction(chunk, tools)
+            .then(writeReturnChunk => {
+              // the write return chunk is optional
+              // just in case the write function returns something other than void.
+              if (writeReturnChunk) {
+                controller.enqueue(writeReturnChunk);
+              }
+            })
+            .catch(err => controller.error(err));
+        } else {
+          controller.error(new Error('No write function provided'));
+        }
+      },
+      async flush(controller) {
+        // Flush logic remains unchanged
+        if (optionsArg?.finalFunction) {
+          const tools: IStreamToolsWrite<TInput, TOutput> = {
+            truncate: () => controller.terminate(),
+            push: (pipeObject) => controller.enqueue(pipeObject),
+          };
+      
+          optionsArg.finalFunction(tools)
+            .then(finalChunk => {
+              if (finalChunk) {
+                controller.enqueue(finalChunk);
+              }
+            })  
+            .catch(err => controller.error(err))
+            .finally(() => controller.terminate());
+        } else {
+          controller.terminate();
+        }
+      }
+    });
+
+    this.options = optionsArg;
+  }
+
+  // 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);
+            }
+          }
+        }
+      }
+    });
+
+    return customReadable;
+  }
+}

package/ts_web/convert.ts

@@ -0,0 +1,64 @@
+export interface IDuplexStream {
+  read(): any;
+  write(chunk: any, callback?: (error?: Error | null) => void): boolean;
+  on(event: string, listener: (...args: any[]) => void): this;
+  once(event: string, listener: (...args: any[]) => void): this;
+  end(callback?: () => void): void;
+  destroy(error?: Error): void;
+}
+
+export interface IReadableStreamOptions {
+  highWaterMark?: number;
+}
+
+export interface IWritableStreamOptions {
+  highWaterMark?: number;
+}
+
+export function convertDuplexToWebStream(duplex: IDuplexStream): { readable: ReadableStream, writable: WritableStream } {
+  const readable = new ReadableStream({
+    start(controller) {
+      duplex.on('readable', () => {
+        let chunk;
+        while (null !== (chunk = duplex.read())) {
+          controller.enqueue(chunk);
+        }
+      });
+
+      duplex.on('end', () => {
+        controller.close();
+      });
+    },
+    cancel(reason) {
+      duplex.destroy(new Error(reason));
+    }
+  });
+
+  const writable = new WritableStream({
+    write(chunk) {
+      return new Promise<void>((resolve, reject) => {
+        const isBackpressured = !duplex.write(chunk, (error) => {
+          if (error) {
+            reject(error);
+          } else {
+            resolve();
+          }
+        });
+
+        if (isBackpressured) {
+          duplex.once('drain', resolve);
+        }
+      });
+    },
+    close() {
+      return new Promise<void>((resolve, reject) => {
+        duplex.end(resolve);
+      });
+    },
+    abort(reason) {
+      duplex.destroy(new Error(reason));
+    }
+  });
+
+  return { readable, writable };
+}

package/ts_web/index.ts

@@ -0,0 +1,5 @@
+import './plugins.js';
+export * from './classes.webduplexstream.js';
+export {
+  convertDuplexToWebStream,
+} from './convert.js';

package/ts_web/plugins.ts

@@ -0,0 +1,15 @@
+// @push.rocks scope
+import * as smartenv from '@push.rocks/smartenv';
+
+export {
+  smartenv,
+}
+
+// lets setup dependencies
+const smartenvInstance = new smartenv.Smartenv();
+
+await smartenvInstance.getSafeNodeModule<typeof import('stream/web')>('stream/web', async (moduleArg) => {
+  globalThis.ReadableStream = moduleArg.ReadableStream;
+  globalThis.WritableStream = moduleArg.WritableStream;
+  globalThis.TransformStream = moduleArg.TransformStream;
+})

package/assets/denoentry.ts

@@ -1 +0,0 @@
-console.log('Hello from deno');