11.0.0

.gitea/workflows/default_nottags.yaml

@@ -7,14 +7,13 @@ on:
 
 env:
   IMAGE: registry.gitlab.com/hosttoday/ht-docker-node:npmci
+  NPMCI_COMPUTED_REPOURL: https://${{gitea.repository_owner}}:${{secrets.GITEA_TOKEN}}@gitea.lossless.digital/${{gitea.repository}}.git
   NPMCI_TOKEN_NPM: ${{secrets.NPMCI_TOKEN_NPM}}
   NPMCI_TOKEN_NPM2: ${{secrets.NPMCI_TOKEN_NPM2}}
   NPMCI_GIT_GITHUBTOKEN: ${{secrets.NPMCI_GIT_GITHUBTOKEN}}
   NPMCI_URL_CLOUDLY: ${{secrets.NPMCI_URL_CLOUDLY}}
 
-
 jobs:
-
   security:
     runs-on: ubuntu-latest
     continue-on-error: true
@@ -22,27 +21,27 @@ jobs:
       image: ${{ env.IMAGE }}
 
     steps:
-    - uses: actions/checkout@v3
+      - uses: actions/checkout@v3
 
-    - name: Install pnpm and npmci
-      run: |
-        pnpm install -g pnpm
-        pnpm install -g @shipzone/npmci
+      - name: Install pnpm and npmci
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
 
-    - name: Run npm prepare
-      run: npmci npm prepare
+      - name: Run npm prepare
+        run: npmci npm prepare
 
-    - name: Audit production dependencies
-      run: |
-        npmci command npm config set registry https://registry.npmjs.org
-        npmci command pnpm audit --audit-level=high --prod
-      continue-on-error: true
+      - name: Audit production dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --prod
+        continue-on-error: true
 
-    - name: Audit development dependencies
-      run: |
-        npmci command npm config set registry https://registry.npmjs.org
-        npmci command pnpm audit --audit-level=high --dev
-      continue-on-error: true
+      - name: Audit development dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --dev
+        continue-on-error: true
 
   test:
     if: ${{ always() }}
@@ -52,16 +51,16 @@ jobs:
       image: ${{ env.IMAGE }}
 
     steps:
-    - uses: actions/checkout@v3
+      - uses: actions/checkout@v3
 
-    - name: Test stable
-      run: |
-        npmci node install stable
-        npmci npm install
-        npmci npm test
+      - name: Test stable
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm test
 
-    - name: Test build
-      run: |
-        npmci node install stable
-        npmci npm install
-        npmci npm build
+      - name: Test build
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm build

.gitea/workflows/default_tags.yaml

@@ -7,14 +7,13 @@ on:
 
 env:
   IMAGE: registry.gitlab.com/hosttoday/ht-docker-node:npmci
+  NPMCI_COMPUTED_REPOURL: https://${{gitea.repository_owner}}:${{secrets.GITEA_TOKEN}}@gitea.lossless.digital/${{gitea.repository}}.git
   NPMCI_TOKEN_NPM: ${{secrets.NPMCI_TOKEN_NPM}}
   NPMCI_TOKEN_NPM2: ${{secrets.NPMCI_TOKEN_NPM2}}
   NPMCI_GIT_GITHUBTOKEN: ${{secrets.NPMCI_GIT_GITHUBTOKEN}}
   NPMCI_URL_CLOUDLY: ${{secrets.NPMCI_URL_CLOUDLY}}
 
-
 jobs:
-
   security:
     runs-on: ubuntu-latest
     continue-on-error: true
@@ -22,27 +21,25 @@ jobs:
       image: ${{ env.IMAGE }}
 
     steps:
-    - uses: actions/checkout@v3
+      - uses: actions/checkout@v3
 
-    - name: Install pnpm and npmci
-      run: |
-        pnpm install -g pnpm
-        pnpm install -g @shipzone/npmci
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+          npmci npm prepare
 
-    - name: Run npm prepare
-      run: npmci npm prepare
+      - name: Audit production dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --prod
+        continue-on-error: true
 
-    - name: Audit production dependencies
-      run: |
-        npmci command npm config set registry https://registry.npmjs.org
-        npmci command pnpm audit --audit-level=high --prod
-      continue-on-error: true
-
-    - name: Audit development dependencies
-      run: |
-        npmci command npm config set registry https://registry.npmjs.org
-        npmci command pnpm audit --audit-level=high --dev
-      continue-on-error: true
+      - name: Audit development dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --dev
+        continue-on-error: true
 
   test:
     if: ${{ always() }}
@@ -52,19 +49,25 @@ jobs:
       image: ${{ env.IMAGE }}
 
     steps:
-    - uses: actions/checkout@v3
+      - uses: actions/checkout@v3
 
-    - name: Test stable
-      run: |
-        npmci node install stable
-        npmci npm install
-        npmci npm test
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+          npmci npm prepare
 
-    - name: Test build
-      run: |
-        npmci node install stable
-        npmci npm install
-        npmci npm build
+      - name: Test stable
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm test
+
+      - name: Test build
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm build
 
   release:
     needs: test
@@ -74,12 +77,18 @@ jobs:
       image: ${{ env.IMAGE }}
 
     steps:
-    - uses: actions/checkout@v3
+      - uses: actions/checkout@v3
 
-    - name: Release
-      run: |
-        npmci node install stable
-        npmci npm publish
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+          npmci npm prepare
+
+      - name: Release
+        run: |
+          npmci node install stable
+          npmci npm publish
 
   metadata:
     needs: test
@@ -90,21 +99,26 @@ jobs:
     continue-on-error: true
 
     steps:
-    - uses: actions/checkout@v3
+      - uses: actions/checkout@v3
 
-    - name: Code quality
-      run: |
-        npmci command npm install -g typescript
-        npmci npm prepare
-        npmci npm install
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+          npmci npm prepare
 
-    - name: Trigger
-      run: npmci trigger
+      - name: Code quality
+        run: |
+          npmci command npm install -g typescript
+          npmci npm install
 
-    - name: Build docs
-      run: |
-        npmci node install stable
-        npmci npm install
-        pnpm install -g @gitzone/tsdoc
-        npmci command tsdoc
-      continue-on-error: true
+      - name: Trigger
+        run: npmci trigger
+
+      - name: Build docs and upload artifacts
+        run: |
+          npmci node install stable
+          npmci npm install
+          pnpm install -g @git.zone/tsdoc
+          npmci command tsdoc
+        continue-on-error: true

package.json

@@ -1,7 +1,7 @@
 {
   "name": "@push.rocks/smartfile",
   "private": false,
-  "version": "10.0.31",
+  "version": "11.0.0",
   "description": "offers smart ways to work with files in nodejs",
   "main": "dist_ts/index.js",
   "typings": "dist_ts/index.d.ts",
@@ -13,7 +13,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://gitlab.com/pushrocks/smartfile.git"
+    "url": "git+https://gitlab.com/push.rocks/smartfile.git"
   },
   "keywords": [
     "filesystem",
@@ -22,33 +22,33 @@
   "author": "Lossless GmbH <hello@lossless.com> (https://lossless.com)",
   "license": "MIT",
   "bugs": {
-    "url": "https://gitlab.com/pushrocks/smartfile/issues"
+    "url": "https://gitlab.com/push.rocks/smartfile/issues"
   },
-  "homepage": "https://gitlab.com/pushrocks/smartfile",
+  "homepage": "https://gitlab.com/push.rocks/smartfile#readme",
   "dependencies": {
     "@push.rocks/lik": "^6.0.5",
     "@push.rocks/smartdelay": "^3.0.5",
     "@push.rocks/smartfile-interfaces": "^1.0.7",
-    "@push.rocks/smarthash": "^3.0.2",
+    "@push.rocks/smarthash": "^3.0.4",
     "@push.rocks/smartjson": "^5.0.10",
     "@push.rocks/smartmime": "^1.0.5",
     "@push.rocks/smartpath": "^5.0.11",
     "@push.rocks/smartpromise": "^4.0.2",
-    "@push.rocks/smartrequest": "^2.0.18",
-    "@push.rocks/smartstream": "^2.0.4",
-    "@types/fs-extra": "^11.0.1",
+    "@push.rocks/smartrequest": "^2.0.20",
+    "@push.rocks/smartstream": "^3.0.7",
+    "@types/fs-extra": "^11.0.3",
     "@types/glob": "^8.1.0",
-    "@types/js-yaml": "^4.0.5",
+    "@types/js-yaml": "^4.0.8",
     "fs-extra": "^11.1.1",
-    "glob": "^10.3.4",
+    "glob": "^10.3.10",
     "js-yaml": "^4.1.0"
   },
   "devDependencies": {
     "@git.zone/tsbuild": "^2.1.70",
     "@git.zone/tsrun": "^1.2.46",
-    "@git.zone/tstest": "^1.0.80",
+    "@git.zone/tstest": "^1.0.81",
     "@push.rocks/tapbundle": "^5.0.15",
-    "@types/node": "^20.5.7"
+    "@types/node": "^20.8.10"
   },
   "files": [
     "ts/**/*",

readme.md

@@ -1,26 +1,26 @@
-# @pushrocks/smartfile
+# @push.rocks/smartfile
 smart ways to work with files in nodejs
 
 ## Availabililty and Links
-* [npmjs.org (npm package)](https://www.npmjs.com/package/@pushrocks/smartfile)
-* [gitlab.com (source)](https://gitlab.com/pushrocks/smartfile)
-* [github.com (source mirror)](https://github.com/pushrocks/smartfile)
-* [docs (typedoc)](https://pushrocks.gitlab.io/smartfile/)
+* [npmjs.org (npm package)](https://www.npmjs.com/package/@push.rocks/smartfile)
+* [gitlab.com (source)](https://gitlab.com/push.rocks/smartfile)
+* [github.com (source mirror)](https://github.com/push.rocks/smartfile)
+* [docs (typedoc)](https://push.rocks.gitlab.io/smartfile/)
 
 ## Status for master
 
 Status Category | Status Badge
 -- | --
-GitLab Pipelines | [![pipeline status](https://gitlab.com/pushrocks/smartfile/badges/master/pipeline.svg)](https://lossless.cloud)
-GitLab Pipline Test Coverage | [![coverage report](https://gitlab.com/pushrocks/smartfile/badges/master/coverage.svg)](https://lossless.cloud)
-npm | [![npm downloads per month](https://badgen.net/npm/dy/@pushrocks/smartfile)](https://lossless.cloud)
-Snyk | [![Known Vulnerabilities](https://badgen.net/snyk/pushrocks/smartfile)](https://lossless.cloud)
+GitLab Pipelines | [![pipeline status](https://gitlab.com/push.rocks/smartfile/badges/master/pipeline.svg)](https://lossless.cloud)
+GitLab Pipline Test Coverage | [![coverage report](https://gitlab.com/push.rocks/smartfile/badges/master/coverage.svg)](https://lossless.cloud)
+npm | [![npm downloads per month](https://badgen.net/npm/dy/@push.rocks/smartfile)](https://lossless.cloud)
+Snyk | [![Known Vulnerabilities](https://badgen.net/snyk/push.rocks/smartfile)](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/smartfile)](https://lossless.cloud)
-PackagePhobia (package size on registry) | [![PackagePhobia](https://badgen.net/packagephobia/publish/@pushrocks/smartfile)](https://lossless.cloud)
-BundlePhobia (total size when bundled) | [![BundlePhobia](https://badgen.net/bundlephobia/minzip/@pushrocks/smartfile)](https://lossless.cloud)
+PackagePhobia (total standalone install weight) | [![PackagePhobia](https://badgen.net/packagephobia/install/@push.rocks/smartfile)](https://lossless.cloud)
+PackagePhobia (package size on registry) | [![PackagePhobia](https://badgen.net/packagephobia/publish/@push.rocks/smartfile)](https://lossless.cloud)
+BundlePhobia (total size when bundled) | [![BundlePhobia](https://badgen.net/bundlephobia/minzip/@push.rocks/smartfile)](https://lossless.cloud)
 
 ## Usage
 

test/test.streamfile.ts

@@ -0,0 +1,67 @@
+import * as path from 'path';
+import { expect, tap } from '@push.rocks/tapbundle';
+import * as smartfile from '../ts/index.js'; // adjust the import path as needed
+
+// Test assets path
+const testAssetsPath = './test/testassets/';
+
+// ---------------------------
+// StreamFile tests
+// ---------------------------
+
+tap.test('StreamFile.fromPath should create a StreamFile from a file path', async () => {
+  const streamFile = await smartfile.StreamFile.fromPath(path.join(testAssetsPath, 'mytest.json'));
+  expect(streamFile).toBeInstanceOf(smartfile.StreamFile);
+  const contentBuffer = await streamFile.getContentAsBuffer();
+  expect(contentBuffer).toBeInstanceOf(Buffer);
+});
+
+tap.test('StreamFile.fromUrl should create a StreamFile from a URL', async () => {
+  const streamFile = await smartfile.StreamFile.fromUrl('http://example.com/somefile.json');
+  expect(streamFile).toBeInstanceOf(smartfile.StreamFile);
+});
+
+tap.test('StreamFile.fromBuffer should create a StreamFile from a Buffer', async () => {
+  const buffer = Buffer.from('Some content');
+  const streamFile = smartfile.StreamFile.fromBuffer(buffer, 'bufferfile.txt');
+  expect(streamFile).toBeInstanceOf(smartfile.StreamFile);
+});
+
+tap.test('StreamFile should write the stream to disk', async () => {
+  const streamFile = await smartfile.StreamFile.fromPath(path.join(testAssetsPath, 'mytest.json'));
+  await streamFile.writeToDisk(path.join(testAssetsPath, 'temp', 'mytest.json'));
+  // Verify the file was written
+  expect(
+    // We'll use the fileExists method from your smartfile library
+    // Replace with the actual method you use to check file existence
+    await smartfile.fs.fileExists(path.join(testAssetsPath, 'temp', 'mytest.json'))
+  ).toBeTrue();
+});
+
+tap.test('StreamFile should write to a directory', async () => {
+  const streamFile = await smartfile.StreamFile.fromPath(path.join(testAssetsPath, 'mytest.json'));
+  await streamFile.writeToDir(path.join(testAssetsPath, 'temp'));
+  // Verify the file was written
+  expect(
+    await smartfile.fs.fileExists(path.join(testAssetsPath, 'temp', 'mytest.json'))
+  ).toBeTrue();
+});
+
+tap.test('StreamFile should return content as a buffer', async () => {
+  const streamFile = await smartfile.StreamFile.fromPath(path.join(testAssetsPath, 'mytest.json'));
+  const contentBuffer = await streamFile.getContentAsBuffer();
+  expect(contentBuffer).toBeInstanceOf(Buffer);
+  // Further checks on the content can be added here if necessary
+});
+
+tap.test('StreamFile should return content as a string', async () => {
+  const streamFile = await smartfile.StreamFile.fromPath(path.join(testAssetsPath, 'mytest.json'));
+  const contentString = await streamFile.getContentAsString();
+  expect(typeof contentString).toBeTypeofString();
+  // Verify the content matches what's expected
+  // This assumes the file contains a JSON object with a key 'key1' with value 'this works'
+  expect(JSON.parse(contentString).key1).toEqual('this works');
+});
+
+// Start the test sequence
+tap.start();

test/test.ts

@@ -64,7 +64,7 @@ tap.test('.fs.fileTreeToObject -> should read a file tree into an Object', async
     path.resolve('./test/testassets/'),
     '**/*.txt'
   );
-  expect(fileArrayArg[0]).toBeInstanceOf(smartfile.Smartfile);
+  expect(fileArrayArg[0]).toBeInstanceOf(smartfile.SmartFile);
   expect(fileArrayArg[0].contents.toString()).toEqual(fileArrayArg[0].contentBuffer.toString());
 });
 
@@ -175,7 +175,7 @@ tap.test('.Smartfile -> should produce vinyl compatible files', async () => {
     './test/testassets/testfolder/**/*'
   );
   const localSmartfile = smartfileArray[0];
-  expect(localSmartfile).toBeInstanceOf(smartfile.Smartfile);
+  expect(localSmartfile).toBeInstanceOf(smartfile.SmartFile);
   expect(localSmartfile.contents).toBeInstanceOf(Buffer);
   // tslint:disable-next-line:no-unused-expression
   expect(localSmartfile.isBuffer()).toBeTrue();
@@ -202,9 +202,9 @@ tap.test('should output a smartfile array to disk', async () => {
 tap.test('should create, store and retrieve valid smartfiles', async () => {
   const fileString = 'hi there';
   const filePath = './test/testassets/utf8.txt';
-  const smartfileInstance = await smartfile.Smartfile.fromString(filePath, fileString, 'utf8');
+  const smartfileInstance = await smartfile.SmartFile.fromString(filePath, fileString, 'utf8');
   smartfileInstance.write();
-  const smartfileInstance2 = await smartfile.Smartfile.fromFilePath(filePath);
+  const smartfileInstance2 = await smartfile.SmartFile.fromFilePath(filePath);
   const retrievedString = smartfileInstance.contents.toString();
   expect(retrievedString).toEqual(fileString);
 });
@@ -212,7 +212,7 @@ tap.test('should create, store and retrieve valid smartfiles', async () => {
 tap.test('should get a hash', async () => {
   const fileString = 'hi there';
   const filePath = './test/testassets/utf8.txt';
-  const smartfileInstance = await smartfile.Smartfile.fromString(filePath, fileString, 'utf8');
+  const smartfileInstance = await smartfile.SmartFile.fromString(filePath, fileString, 'utf8');
   const hash = await smartfileInstance.getHash();
   console.log(hash);
 });

test/testassets/temp/mytest.json

@@ -0,0 +1,8 @@
+{
+  "key1": "this works",
+  "key2": "this works too",
+  "key3": {
+    "nestedkey1": "hello"
+  }
+}
+

test/testassets/temp/test/testassets/mytest.json

@@ -0,0 +1,8 @@
+{
+  "key1": "this works",
+  "key2": "this works too",
+  "key3": {
+    "nestedkey1": "hello"
+  }
+}
+

ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartfile',
-  version: '10.0.31',
+  version: '11.0.0',
   description: 'offers smart ways to work with files in nodejs'
 }

ts/classes.smartfile.ts

@@ -1,6 +1,6 @@
 import * as plugins from './smartfile.plugins.js';
-import * as fs from './smartfile.fs.js';
-import * as memory from './smartfile.memory.js';
+import * as fs from './fs.js';
+import * as memory from './memory.js';
 
 export interface ISmartfileConstructorOptions {
   path: string;
@@ -9,10 +9,9 @@ export interface ISmartfileConstructorOptions {
 }
 
 /**
- * class Smartfile
- * -> is vinyl file compatible
+ * an vinyl file compatible in memory file class
  */
-export class Smartfile extends plugins.smartjson.Smartjson {
+export class SmartFile extends plugins.smartjson.Smartjson {
   // ======
   // STATIC
   // ======
@@ -24,7 +23,7 @@ export class Smartfile extends plugins.smartjson.Smartjson {
   public static async fromFilePath(filePath: string, baseArg: string = process.cwd()) {
     filePath = plugins.path.resolve(filePath);
     const fileBuffer = fs.toBufferSync(filePath);
-    const smartfile = new Smartfile({
+    const smartfile = new SmartFile({
       contentBuffer: fileBuffer,
       base: baseArg,
       path: plugins.path.relative(baseArg, filePath),
@@ -37,7 +36,7 @@ export class Smartfile extends plugins.smartjson.Smartjson {
     contentBufferArg: Buffer,
     baseArg: string = process.cwd()
   ) {
-    const smartfile = new Smartfile({
+    const smartfile = new SmartFile({
       contentBuffer: contentBufferArg,
       base: baseArg,
       path: plugins.path.relative(baseArg, filePath),
@@ -52,7 +51,7 @@ export class Smartfile extends plugins.smartjson.Smartjson {
     encodingArg: 'utf8' | 'binary',
     baseArg = process.cwd()
   ) {
-    const smartfile = new Smartfile({
+    const smartfile = new SmartFile({
       contentBuffer: Buffer.from(contentStringArg, encodingArg),
       base: baseArg,
       path: plugins.path.relative(baseArg, filePath),
@@ -62,7 +61,34 @@ export class Smartfile extends plugins.smartjson.Smartjson {
   }
 
   public static async fromFoldedJson(foldedJsonArg: string) {
-    return new Smartfile(plugins.smartjson.parse(foldedJsonArg));
+    return new SmartFile(plugins.smartjson.parse(foldedJsonArg));
+  }
+
+  /**
+   * creates a Smartfile from a ReadableStream
+   * @param stream a readable stream that provides file content
+   * @param filePath the file path to associate with the content
+   * @param baseArg the base path to use for the file
+   */
+  public static async fromStream(
+    stream: plugins.stream.Readable,
+    filePath: string,
+    baseArg: string = process.cwd()
+  ): Promise<SmartFile> {
+    return new Promise<SmartFile>((resolve, reject) => {
+      const chunks: Buffer[] = [];
+      stream.on('data', (chunk) => chunks.push(Buffer.from(chunk)));
+      stream.on('error', (error) => reject(error));
+      stream.on('end', () => {
+        const contentBuffer = Buffer.concat(chunks);
+        const smartfile = new SmartFile({
+          contentBuffer: contentBuffer,
+          base: baseArg,
+          path: plugins.path.relative(baseArg, filePath),
+        });
+        resolve(smartfile);
+      });
+    });
   }
 
   // ========
@@ -128,7 +154,7 @@ export class Smartfile extends plugins.smartjson.Smartjson {
    * @param contentString
    */
   public setContentsFromString(contentString: string, encodingArg: 'utf8' | 'binary' = 'utf8') {
-    this.contents = new Buffer(contentString, encodingArg);
+    this.contents = Buffer.from(contentString, encodingArg);
   }
 
   /**
@@ -262,4 +288,14 @@ export class Smartfile extends plugins.smartjson.Smartjson {
     const newFileString = await editFuncArg(this.contentBuffer.toString());
     this.contentBuffer = Buffer.from(newFileString);
   }
+
+  /**
+   * Returns a ReadableStream from the file's content buffer
+   */
+  public getStream(): plugins.stream.Readable {
+    const stream = new plugins.stream.Readable();
+    stream.push(this.contentBuffer); // Push the content buffer to the stream
+    stream.push(null); // Push null to signify the end of the stream (EOF)
+    return stream;
+  }
 }

ts/classes.streamfile.ts

@@ -0,0 +1,152 @@
+import * as plugins from './smartfile.plugins.js';
+import * as smartfileFs from './fs.js';
+import * as smartfileFsStream from './fsstream.js';
+import { Readable } from 'stream';
+
+type TStreamSource = (streamFile: StreamFile) => Promise<Readable>;
+
+/**
+ * The StreamFile class represents a file as a stream.
+ * It allows creating streams from a file path, a URL, or a buffer.
+ */
+export class StreamFile {
+  // INSTANCE
+  relativeFilePath?: string;
+  private streamSource: TStreamSource;
+
+  // enable stream based multi use
+  private cachedStreamBuffer?: Buffer;
+  public multiUse: boolean;
+  public used: boolean = false;
+
+  private constructor(streamSource: TStreamSource, relativeFilePath?: string) {
+    this.streamSource = streamSource;
+    this.relativeFilePath = relativeFilePath;
+  }
+
+  // STATIC
+
+  public static async fromPath(filePath: string): Promise<StreamFile> {
+    const streamSource: TStreamSource = async (stremFileArg) => smartfileFsStream.createReadStream(filePath);
+    const streamFile = new StreamFile(streamSource, filePath);
+    streamFile.multiUse = true;
+    return streamFile;
+  }
+
+  public static async fromUrl(url: string): Promise<StreamFile> {
+    const streamSource: TStreamSource = async (streamFileArg) => plugins.smartrequest.getStream(url); // Replace with actual plugin method
+    const streamFile = new StreamFile(streamSource);
+    streamFile.multiUse = true;
+    return streamFile;
+  }
+
+  public static fromBuffer(buffer: Buffer, relativeFilePath?: string): StreamFile {
+    const streamSource: TStreamSource = async (streamFileArg) => {
+      const stream = new Readable();
+      stream.push(buffer);
+      stream.push(null); // End of stream
+      return stream;
+    };
+    const streamFile = new StreamFile(streamSource, relativeFilePath);
+    streamFile.multiUse = true;
+    return streamFile;
+  }
+
+  /**
+   * Creates a StreamFile from an existing Readable stream with an option for multiple uses.
+   * @param stream A Node.js Readable stream.
+   * @param relativeFilePath Optional file path for the stream.
+   * @param multiUse If true, the stream can be read multiple times, caching its content.
+   * @returns A StreamFile instance.
+   */
+  public static fromStream(stream: Readable, relativeFilePath?: string, multiUse: boolean = false): StreamFile {
+    const streamSource: TStreamSource = (streamFileArg) => {
+      if (streamFileArg.multiUse) {
+        // If multi-use is enabled and we have cached content, create a new readable stream from the buffer
+        const bufferedStream = new Readable();
+        bufferedStream.push(streamFileArg.cachedStreamBuffer);
+        bufferedStream.push(null); // No more data to push
+        return Promise.resolve(bufferedStream);
+      } else {
+        return Promise.resolve(stream);
+      }
+    };
+
+    const streamFile = new StreamFile(streamSource, relativeFilePath);
+    streamFile.multiUse = multiUse;
+
+    // If multi-use is enabled, cache the stream when it's first read
+    if (multiUse) {
+      const chunks: Buffer[] = [];
+      stream.on('data', (chunk) => chunks.push(Buffer.from(chunk)));
+      stream.on('end', () => {
+        streamFile.cachedStreamBuffer = Buffer.concat(chunks);
+      });
+      // It's important to handle errors that may occur during streaming
+      stream.on('error', (err) => {
+        console.error('Error while caching stream:', err);
+      });
+    }
+
+    return streamFile;
+  }
+
+  // METHODS
+
+  private checkMultiUse() {
+    if (!this.multiUse && this.used) {
+      throw new Error('This stream can only be used once.');
+    }
+    this.used = true;
+  }
+
+  /**
+   * Creates a new readable stream from the source.
+   */
+  public async createReadStream(): Promise<Readable> {
+    return this.streamSource(this);
+  }
+
+  /**
+   * Writes the stream to the disk at the specified path.
+   * @param filePathArg The file path where the stream should be written.
+   */
+  public async writeToDisk(filePathArg: string): Promise<void> {
+    this.checkMultiUse();
+    const readStream = await this.createReadStream();
+    const writeStream = smartfileFsStream.createWriteStream(filePathArg);
+
+    return new Promise((resolve, reject) => {
+      readStream.pipe(writeStream);
+      readStream.on('error', reject);
+      writeStream.on('error', reject);
+      writeStream.on('finish', resolve);
+    });
+  }
+
+  public async writeToDir(dirPathArg: string) {
+    this.checkMultiUse();
+    const filePath = plugins.path.join(dirPathArg, this.relativeFilePath);
+    await smartfileFs.ensureDir(plugins.path.parse(filePath).dir);
+    return this.writeToDisk(filePath);
+  }
+
+  public async getContentAsBuffer() {
+    this.checkMultiUse();
+    const done = plugins.smartpromise.defer<Buffer>();
+    const readStream = await this.createReadStream();
+    const chunks: Buffer[] = [];
+    readStream.on('data', (chunk) => chunks.push(Buffer.from(chunk)));
+    readStream.on('error', done.reject);
+    readStream.on('end', () => {
+      const contentBuffer = Buffer.concat(chunks);
+      done.resolve(contentBuffer);
+    });
+    return done.promise;
+  }
+
+  public async getContentAsString(formatArg: 'utf8' | 'binary' = 'utf8') {
+    const contentBuffer = await this.getContentAsBuffer();
+    return contentBuffer.toString(formatArg);
+  }
+}

ts/classes.virtualdirectory.ts

@@ -1,11 +1,21 @@
-import { Smartfile } from './smartfile.classes.smartfile.js';
+import { SmartFile } from './classes.smartfile.js';
 import * as plugins from './smartfile.plugins.js';
-import * as fs from './smartfile.fs.js';
+import * as fs from './fs.js';
+
+
+export interface IVirtualDirectoryConstructorOptions {
+  mode: ''
+}
 
 /**
  * a virtual directory exposes a fs api
  */
 export class VirtualDirectory {
+
+  consstructor(options = {}) {
+
+  }
+
   // STATIC
   public static async fromFsDirPath(pathArg: string): Promise<VirtualDirectory> {
     const newVirtualDir = new VirtualDirectory();
@@ -18,17 +28,17 @@ export class VirtualDirectory {
   ): Promise<VirtualDirectory> {
     const newVirtualDir = new VirtualDirectory();
     for (const fileArg of virtualDirTransferableObjectArg.files) {
-      newVirtualDir.addSmartfiles([Smartfile.enfoldFromJson(fileArg) as Smartfile]);
+      newVirtualDir.addSmartfiles([SmartFile.enfoldFromJson(fileArg) as SmartFile]);
     }
     return newVirtualDir;
   }
 
   // INSTANCE
-  public smartfileArray: Smartfile[] = [];
+  public smartfileArray: SmartFile[] = [];
 
   constructor() {}
 
-  public addSmartfiles(smartfileArrayArg: Smartfile[]) {
+  public addSmartfiles(smartfileArrayArg: SmartFile[]) {
     this.smartfileArray = this.smartfileArray.concat(smartfileArrayArg);
   }
 

ts/fs.ts

@@ -1,9 +1,9 @@
 import * as plugins from './smartfile.plugins.js';
-import * as interpreter from './smartfile.interpreter.js';
+import * as interpreter from './interpreter.js';
 
-import { Smartfile } from './smartfile.classes.smartfile.js';
+import { SmartFile } from './classes.smartfile.js';
 
-import * as memory from './smartfile.memory.js';
+import * as memory from './memory.js';
 /*===============================================================
 ============================ Checks =============================
 ===============================================================*/
@@ -221,6 +221,18 @@ export const toBufferSync = (filePath: string): Buffer => {
   return plugins.fsExtra.readFileSync(filePath);
 };
 
+/**
+ * Creates a Readable Stream from a file path.
+ * @param filePath The path to the file.
+ * @returns {fs.ReadStream}
+ */
+export const toReadStream = (filePath: string): plugins.fs.ReadStream => {
+  if (!fileExistsSync(filePath)) {
+    throw new Error(`File does not exist at path: ${filePath}`);
+  }
+  return plugins.fsExtra.createReadStream(filePath);
+};
+
 export const fileTreeToHash = async (dirPathArg: string, miniMatchFilter: string) => {
   const fileTreeObject = await fileTreeToObject(dirPathArg, miniMatchFilter);
   let combinedString = '';
@@ -246,7 +258,7 @@ export const fileTreeToObject = async (dirPathArg: string, miniMatchFilter: stri
   }
 
   const fileTree = await listFileTree(dirPath, miniMatchFilter);
-  const smartfileArray: Smartfile[] = [];
+  const smartfileArray: SmartFile[] = [];
   for (const filePath of fileTree) {
     const readPath = ((): string => {
       if (!plugins.path.isAbsolute(filePath)) {
@@ -259,7 +271,7 @@ export const fileTreeToObject = async (dirPathArg: string, miniMatchFilter: stri
 
     // push a read file as Smartfile
     smartfileArray.push(
-      new Smartfile({
+      new SmartFile({
         contentBuffer: fileBuffer,
         base: dirPath,
         path: filePath,

ts/index.ts

@@ -1,11 +1,12 @@
 import * as plugins from './smartfile.plugins.js';
-import * as fsMod from './smartfile.fs.js';
-import * as fsStreamMod from './smartfile.fsstream.js';
-import * as interpreterMod from './smartfile.interpreter.js';
-import * as memoryMod from './smartfile.memory.js';
+import * as fsMod from './fs.js';
+import * as fsStreamMod from './fsstream.js';
+import * as interpreterMod from './interpreter.js';
+import * as memoryMod from './memory.js';
 
-export * from './smartfile.classes.smartfile.js';
-export * from './smartfile.classes.virtualdirectory.js';
+export * from './classes.smartfile.js';
+export * from './classes.streamfile.js';
+export * from './classes.virtualdirectory.js';
 
 export const fs = fsMod;
 export const fsStream = fsStreamMod;

ts/memory.ts

@@ -1,7 +1,8 @@
 import * as plugins from './smartfile.plugins.js';
-import { Smartfile } from './smartfile.classes.smartfile.js';
-import * as smartfileFs from './smartfile.fs.js';
-import * as interpreter from './smartfile.interpreter.js';
+import { SmartFile } from './classes.smartfile.js';
+import * as smartfileFs from './fs.js';
+import * as interpreter from './interpreter.js';
+import type { StreamFile } from './classes.streamfile.js';
 
 /**
  * converts file to Object
@@ -24,7 +25,7 @@ export interface IToFsOptions {
  * @param fileBaseArg
  */
 export let toFs = async (
-  fileContentArg: string | Buffer | Smartfile,
+  fileContentArg: string | Buffer | SmartFile | StreamFile,
   filePathArg: string,
   optionsArg: IToFsOptions = {}
 ) => {
@@ -41,7 +42,7 @@ export let toFs = async (
   let filePath: string = filePathArg;
 
   // handle Smartfile
-  if (fileContentArg instanceof Smartfile) {
+  if (fileContentArg instanceof SmartFile) {
     fileContent = fileContentArg.contentBuffer;
     // handle options
     if (optionsArg.respectRelative) {
@@ -83,7 +84,7 @@ export const toFsSync = (fileArg: string, filePathArg: string) => {
   plugins.fsExtra.writeFileSync(filePath, fileString, { encoding: 'utf8' });
 };
 
-export let smartfileArrayToFs = async (smartfileArrayArg: Smartfile[], dirArg: string) => {
+export let smartfileArrayToFs = async (smartfileArrayArg: SmartFile[], dirArg: string) => {
   await smartfileFs.ensureDir(dirArg);
   for (const smartfile of smartfileArrayArg) {
     await toFs(smartfile, dirArg, {