11.1.0

changelog.md

@@ -0,0 +1,293 @@
+# Changelog
+
+## 2025-01-07 - 11.1.0 - feat(SmartFile)
+Add rename functionality to SmartFile class
+
+- Implemented a new method to rename a file within the SmartFile class.
+- The rename method updates the file path and optionally writes the renamed file to the disk.
+
+## 2024-12-15 - 11.0.23 - fix(fs)
+Handle errors in toObjectSync method
+
+- Added error handling in toObjectSync function to capture and provide more informative error messages.
+
+## 2024-06-23 - 11.0.22 - fix(core)
+Update dependencies and changelog
+
+- Updated @push.rocks/smartstream to ^3.0.44
+- Updated glob to ^10.4.2
+- Updated @types/node to ^20.14.8
+
+## 2024-06-23 - 11.0.21 - fix(dependencies)
+Update dependencies to latest versions
+
+- Updated @push.rocks/smartpromise to ^4.0.4
+- Updated @push.rocks/smartstream to ^3.0.44
+- Updated glob to ^10.4.2
+- Updated @types/node to ^20.14.8
+
+## 2024-06-07 - 11.0.20 - Changelog
+11.0.20
+
+## 2024-06-07 - 11.0.19 - fix(core): update
+11.0.19
+
+- fix(core): update
+
+## 2024-06-07 - 11.0.18 - fix(core): update
+11.0.18
+
+- fix(core): update
+
+## 2024-06-06 - 11.0.17 - fix(core): update
+11.0.17
+
+- fix(core): update
+
+## 2024-06-06 - 11.0.16 - fix(core): update
+11.0.16
+
+- fix(core): update
+
+## 2024-05-29 - 11.0.16 - update description
+11.0.16
+
+- update description
+
+## 2024-05-17 - 11.0.15 - fix(core): update
+11.0.15
+
+- fix(core): update
+
+## 2024-04-14 - 11.0.14 - update tsconfig
+11.0.14
+
+- update tsconfig
+
+## 2024-04-12 - 11.0.13 - fix(core): update
+11.0.13
+
+- fix(core): update
+
+## 2024-04-12 - 11.0.12 - fix(core): update
+11.0.12
+
+- fix(core): update
+
+## 2024-04-12 - 11.0.11 - fix(core): update
+11.0.11
+
+- fix(core): update
+
+## 2024-04-03 - 11.0.10 - fix(core): update
+11.0.10
+
+- fix(core): update
+
+## 2024-04-03 - 11.0.9 - fix(core): update
+11.0.9
+
+- fix(core): update
+
+## 2024-04-02 - 11.0.8 - fix(core): update
+11.0.8
+
+- fix(core): update
+
+## 2024-04-02 - 11.0.7 - fix(core): update
+11.0.7
+
+- fix(core): update
+
+## 2024-04-02 - 11.0.6 - fix(core): update
+11.0.6
+
+- fix(core): update
+
+## 2024-04-01 - 11.0.5 - update npmextra.json
+11.0.5
+
+- update npmextra.json: githost
+
+## 2024-04-01 - 11.0.4 - fix(core): update
+11.0.4
+
+- fix(core): update
+
+## 2023-11-24 - 11.0.3 - fix(core): update
+11.0.3
+
+- fix(core): update
+
+## 2023-11-07 - 11.0.2 - fix(core): update
+11.0.2
+
+- fix(core): update
+
+## 2023-11-07 - 11.0.1 - fix(core): update
+11.0.1
+
+- fix(core): update
+
+## 2023-11-06 - 11.0.0 - fix(core): update
+11.0.0
+
+- fix(core): update
+
+## 2023-11-06 - 10.0.40 - BREAKING CHANGE(core): update
+10.0.40
+
+- BREAKING CHANGE(core): update
+
+## 2023-11-04 - 10.0.39 - fix(core): update
+10.0.39
+
+- fix(core): update
+
+## 2023-11-04 - 10.0.38 - fix(core): update
+10.0.38
+
+- fix(core): update
+
+## 2023-11-04 - 10.0.37 - fix(core): update
+10.0.37
+
+- fix(core): update
+
+## 2023-11-03 - 10.0.36 - fix(core): update
+10.0.36
+
+- fix(core): update
+
+## 2023-11-03 - 10.0.35 - fix(core): update
+10.0.35
+
+- fix(core): update
+
+## 2023-11-03 - 10.0.34 - fix(core): update
+10.0.34
+
+- fix(core): update
+
+## 2023-11-03 - 10.0.33 - fix(core): update
+10.0.33
+
+- fix(core): update
+
+## 2023-10-12 - 10.0.32 - fix(core): update
+10.0.32
+
+- fix(core): update
+
+## 2023-09-22 - 10.0.31 - fix(core): update
+10.0.31
+
+- fix(core): update
+
+## 2023-08-31 - 10.0.30 - fix(core): update
+10.0.30
+
+- fix(core): update
+
+## 2023-08-23 - 10.0.29 - fix(core): update
+10.0.29
+
+- fix(core): update
+
+## 2023-07-12 - 10.0.28 - fix(core): update
+10.0.28
+
+- fix(core): update
+
+## 2023-07-10 - 10.0.27 - fix(core): update
+10.0.27
+
+- fix(core): update
+
+## 2023-07-10 - 10.0.26 - fix(core): update
+10.0.26
+
+- fix(core): update
+
+## 2023-07-08 - 10.0.25 - fix(core): update
+10.0.25
+
+- fix(core): update
+
+## 2023-06-25 - 10.0.24 to 10.0.14 - Series of Fixes
+10.0.24 to 10.0.14
+
+- Series of fixes in the core module
+
+## 2023-01-09 - 10.0.13 to 10.0.6 - Series of Fixes
+10.0.13 to 10.0.6
+
+- Series of fixes in the core module
+
+## 2022-09-05 - 10.0.5 to 10.0.3 - Series of Fixes
+10.0.5 to 10.0.3
+
+- Series of fixes in the core module
+
+## 2022-06-07 - 10.0.2 to 10.0.1 - Series of Fixes
+10.0.2 to 10.0.1
+
+- Series of fixes in the core module
+
+## 2022-06-07 - 9.0.7 - BREAKING CHANGE(core): switch to esm
+9.0.7
+
+- BREAKING CHANGE(core): switch to esm
+
+## 2022-03-11 - 9.0.6 to 9.0.2 - Series of Fixes
+9.0.6 to 9.0.2
+
+- Series of fixes in the core module
+
+## 2021-12-01 - 9.0.1 - fix(core): update
+9.0.1
+
+- fix(core): update
+
+## 2021-12-01 - 9.0.0 - fix(absolute pathing)
+9.0.0
+
+- add functions for easily getting absolute paths
+
+## 2021-11-30 - 8.0.11 - BREAKING CHANGE(relative pathing)
+8.0.11
+
+- improved relative pathing
+
+## 2020-08-10 - 8.0.10 to 7.0.12 - Series of Fixes and Updates
+8.0.10 to 7.0.12
+
+- Series of fixes in the core module
+- BREAKING CHANGE(Smartfile class): switch to a Buffer-only approach
+
+## 2019-02-17 - 7.0.0 - fix(core): update dependencies
+7.0.0
+
+- fix(core): update dependencies
+
+## 2019-01-27 - 6.0.12 - BREAKING CHANGE(smartfile.fs.fileExists)
+6.0.12
+
+- now returns a Promise<boolean>
+
+## 2018-08-19 - 6.0.11 to 6.0.6 - Series of Fixes
+6.0.11 to 6.0.6
+
+- Series of fixes in core and dependencies
+
+## 2018-07-03 - 6.0.5 to 5.0.0 - Series of Fixes
+6.0.5 to 5.0.0
+
+- Series of fixes in core and dependencies
+
+## 2018-02-16 - 4.2.28 - BREAKING CHANGE(scope)
+4.2.28
+
+- switch to pushrocks scope
+
+

npmextra.json

@@ -7,12 +7,42 @@
   "gitzone": {
     "projectType": "npm",
     "module": {
-      "githost": "gitlab.com",
+      "githost": "code.foss.global",
       "gitscope": "push.rocks",
       "gitrepo": "smartfile",
-      "description": "smart ways to work with files in nodejs",
+      "description": "Provides comprehensive tools for efficient file management in Node.js using TypeScript, including handling streams, virtual directories, and various file operations.",
       "npmPackagename": "@push.rocks/smartfile",
-      "license": "MIT"
+      "license": "MIT",
+      "keywords": [
+        "file management",
+        "TypeScript",
+        "Node.js",
+        "file operations",
+        "file manipulation",
+        "file streaming",
+        "virtual directory",
+        "filesystem utilities",
+        "memory-efficient file handling",
+        "custom file operations",
+        "write files",
+        "read files",
+        "copy files",
+        "delete files",
+        "list directories",
+        "handle large files",
+        "virtual filesystems",
+        "buffer operations"
+      ]
     }
+  },
+  "tsdoc": {
+    "classes": [
+      "SmartFile",
+      "StreamFile"
+    ],
+    "descriptions": [
+      "the purpose of the StreamFile class is to provide a hybrid interface between streaming files and simple handling when writing and reading those files multiple times."
+    ],
+    "legal": "\n## License and Legal Information\n\nThis repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository. \n\n**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.\n\n### Trademarks\n\nThis project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH and are not included within the scope of the MIT license granted herein. Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines, and any usage must be approved in writing by Task Venture Capital GmbH.\n\n### Company Information\n\nTask Venture Capital GmbH  \nRegistered at District court Bremen HRB 35230 HB, Germany\n\nFor any legal inquiries or if you require further information, please contact us via email at hello@task.vc.\n\nBy using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.\n"
   }
 }

package.json

@@ -1,8 +1,8 @@
 {
   "name": "@push.rocks/smartfile",
   "private": false,
-  "version": "11.0.2",
+  "version": "11.1.0",
-  "description": "offers smart ways to work with files in nodejs",
+  "description": "Provides comprehensive tools for efficient file management in Node.js using TypeScript, including handling streams, virtual directories, and various file operations.",
   "main": "dist_ts/index.js",
   "typings": "dist_ts/index.d.ts",
   "type": "module",
@@ -13,42 +13,58 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://gitlab.com/push.rocks/smartfile.git"
+    "url": "https://code.foss.global/push.rocks/smartfile.git"
   },
   "keywords": [
-    "filesystem",
+    "file management",
-    "json"
+    "TypeScript",
+    "Node.js",
+    "file operations",
+    "file manipulation",
+    "file streaming",
+    "virtual directory",
+    "filesystem utilities",
+    "memory-efficient file handling",
+    "custom file operations",
+    "write files",
+    "read files",
+    "copy files",
+    "delete files",
+    "list directories",
+    "handle large files",
+    "virtual filesystems",
+    "buffer operations"
   ],
   "author": "Lossless GmbH <hello@lossless.com> (https://lossless.com)",
   "license": "MIT",
   "bugs": {
     "url": "https://gitlab.com/push.rocks/smartfile/issues"
   },
-  "homepage": "https://gitlab.com/push.rocks/smartfile#readme",
+  "homepage": "https://code.foss.global/push.rocks/smartfile",
   "dependencies": {
-    "@push.rocks/lik": "^6.0.5",
+    "@push.rocks/lik": "^6.1.0",
     "@push.rocks/smartdelay": "^3.0.5",
     "@push.rocks/smartfile-interfaces": "^1.0.7",
     "@push.rocks/smarthash": "^3.0.4",
-    "@push.rocks/smartjson": "^5.0.10",
+    "@push.rocks/smartjson": "^5.0.20",
-    "@push.rocks/smartmime": "^1.0.5",
+    "@push.rocks/smartmime": "^2.0.4",
-    "@push.rocks/smartpath": "^5.0.11",
+    "@push.rocks/smartpath": "^5.0.18",
-    "@push.rocks/smartpromise": "^4.0.2",
+    "@push.rocks/smartpromise": "^4.0.4",
-    "@push.rocks/smartrequest": "^2.0.20",
+    "@push.rocks/smartrequest": "^2.0.23",
-    "@push.rocks/smartstream": "^3.0.7",
+    "@push.rocks/smartstream": "^3.2.5",
-    "@types/fs-extra": "^11.0.3",
+    "@types/fs-extra": "^11.0.4",
     "@types/glob": "^8.1.0",
-    "@types/js-yaml": "^4.0.8",
+    "@types/js-yaml": "^4.0.9",
-    "fs-extra": "^11.1.1",
+    "fs-extra": "^11.2.0",
-    "glob": "^10.3.10",
+    "glob": "^11.0.0",
     "js-yaml": "^4.1.0"
   },
   "devDependencies": {
-    "@git.zone/tsbuild": "^2.1.70",
+    "@git.zone/tsbuild": "^2.2.0",
-    "@git.zone/tsrun": "^1.2.46",
+    "@git.zone/tsrun": "^1.3.3",
-    "@git.zone/tstest": "^1.0.81",
+    "@git.zone/tstest": "^1.0.90",
-    "@push.rocks/tapbundle": "^5.0.15",
+    "@push.rocks/tapbundle": "^5.5.3",
-    "@types/node": "^20.8.10"
+    "@types/node": "^22.10.2"
   },
   "files": [
     "ts/**/*",

readme.hints.md

@@ -0,0 +1 @@
+ 

readme.md

@@ -1,49 +1,241 @@
 # @push.rocks/smartfile
-smart ways to work with files in nodejs
 
-## Availabililty and Links
+> Provides a robust suite of tools for managing files in Node.js using TypeScript.
-* [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
+## Install
 
-Status Category | Status Badge
+To integrate `@push.rocks/smartfile` into your project, run:
--- | --
+
-GitLab Pipelines | [![pipeline status](https://gitlab.com/push.rocks/smartfile/badges/master/pipeline.svg)](https://lossless.cloud)
+```bash
-GitLab Pipline Test Coverage | [![coverage report](https://gitlab.com/push.rocks/smartfile/badges/master/coverage.svg)](https://lossless.cloud)
+npm install @push.rocks/smartfile
-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/@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
 
-smartfile is an approach of being one tool to handle files in diverse environments.
+`@push.rocks/smartfile` offers extensive file management utilities, enabling seamless file processing with TypeScript in a Node.js environment. Below are detailed examples showcasing various features of the module.
 
-### Smartfile Sections
+### Quick Start
 
-smartfile thinks in sections:
+First, ensure you're working in an environment that supports ECMAScript modules (ESM) and TypeScript. Here’s how you’d generally import and use `@push.rocks/smartfile`:
 
-| section     | description                                                                  |
+```typescript
-| ----------- | ---------------------------------------------------------------------------- |
+import { SmartFile, StreamFile, VirtualDirectory, fs, memory, interpreter } from '@push.rocks/smartfile';
-| fs          | (object) gets data from fs to somewhere                                      |
+```
-| memory      | gets data from memory to somewhere                                           |
-| remote      | gets data from remote locations to somewhere                                 |
-| interpreter | (object) handles yaml and json                                               |
-| smartfile   | (class) a virtual representation of a file, alternative to vinyl file format |
 
-## Contribution
+### Working with `SmartFile`
 
-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). :)
+#### Reading Files
 
-For further information read the linked docs at the top of this readme.
+To read from a file and convert it to a `SmartFile` instance:
 
-## Legal
+```typescript
-> MIT licensed | **©** [Task Venture Capital GmbH](https://task.vc)
+const myJsonSmartFile: SmartFile = await SmartFile.fromFilePath('./somePath/data.json');
-| By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy)
+const jsonData = JSON.parse(myJsonSmartFile.contents.toString());
+console.log(jsonData);  // Assuming the file contains JSON content
+```
+
+#### Writing Files
+
+To write data to a file through a `SmartFile`:
+
+```typescript
+const filePath: string = './output/outputData.json';
+const content: string = JSON.stringify({ key: 'value' });
+await memory.toFs(content, filePath);
+```
+
+### Streaming Large Files with `StreamFile`
+
+When dealing with large files, you can use `StreamFile` to handle such files efficiently, minimizing memory usage:
+
+```typescript
+const largeFile: StreamFile = await StreamFile.fromPath('./largeInput/largeFile.mp4');
+await largeFile.writeToDisk('./largeOutput/largeFileCopy.mp4');
+```
+
+### Working with Virtual Directories
+
+Handling multiple files as if they were part of a file system:
+
+```typescript
+const virtualDir = await VirtualDirectory.fromFsDirPath('./data/inputDir');
+await virtualDir.saveToDisk('./data/outputDir');
+```
+
+### File System Operations
+
+`@push.rocks/smartfile` provides a suite of utilities for common file system operations such as copying, deleting, and listing files or directories.
+
+#### Copying a File
+
+```typescript
+await fs.copy('./sourceFile.txt', './destinationFile.txt');
+```
+
+#### Deleting a Directory
+
+```typescript
+await fs.remove('./directoryToDelete');
+```
+
+#### Listing Files in a Directory
+
+```typescript
+const fileList: string[] = await fs.listFiles('./someDirectory');
+console.log(fileList);
+```
+
+### Advanced File Management
+
+For specialized file operations, such as editing the contents of a file or streaming files from URLs, `@push.rocks/smartfile` includes advanced management features.
+
+#### Editing a File’s Contents
+
+```typescript
+const smartFileToEdit: SmartFile = await SmartFile.fromFilePath('./editableFile.txt');
+await smartFileToEdit.editContentAsString(async (content) => content.replace(/originalText/g, 'newText'));
+await smartFileToEdit.write();
+```
+
+#### Streaming a File from a URL
+
+```typescript
+const streamedFile: StreamFile = await StreamFile.fromUrl('https://example.com/file.pdf');
+await streamedFile.writeToDisk('./downloadedFiles/file.pdf');
+```
+
+### Working with File Buffers and Streams
+
+`@push.rocks/smartfile` allows you to easily work with files using Buffers and Streams, facilitating operations like file transformations, uploads, and downloads.
+
+#### Creating a SmartFile from a Buffer
+
+```typescript
+const buffer: Buffer = Buffer.from('Sample data');
+const bufferSmartFile: SmartFile = await SmartFile.fromBuffer('./bufferFile.txt', buffer);
+await bufferSmartFile.write();
+```
+
+### Using `VirtualDirectory` for Complex File Management
+
+`VirtualDirectory` simplifies the management of multiple files that are otherwise scattered across different directories or created at runtime. 
+
+#### Creating a `VirtualDirectory`
+
+To create a `VirtualDirectory` from an existing file directory:
+
+```typescript
+const virtualDirectory = await VirtualDirectory.fromFsDirPath('./someDirectory');
+```
+
+#### Adding More Files
+
+You can add more `SmartFile` instances to your `VirtualDirectory`:
+
+```typescript
+const additionalFiles = [
+  await SmartFile.fromFilePath('./anotherDirectory/file1.txt'),
+  await SmartFile.fromFilePath('./anotherDirectory/file2.txt')
+];
+virtualDirectory.addSmartfiles(additionalFiles);
+```
+
+#### Saving `VirtualDirectory` to Disk
+
+Save your entire `VirtualDirectory` to disk:
+
+```typescript
+await virtualDirectory.saveToDisk('./outputDirectory');
+```
+
+### Utilizing StreamFile for Efficient File Handling
+
+Using `StreamFile` can be especially beneficial for large files or when performing streaming operations.
+
+#### Streaming from a URL
+
+`StreamFile` provides capabilities to stream files directly from URLs, making it easier to work with remote content.
+
+```typescript
+const urlStreamFile: StreamFile = await StreamFile.fromUrl('https://example.com/largefile.zip');
+await urlStreamFile.writeToDisk('./downloadedFiles/largefile.zip');
+```
+
+### Combining Buffer and Stream Approaches
+
+Create `StreamFile` from a buffer for efficient, multi-use streams.
+
+```typescript
+const buffer = Buffer.from('Streaming buffer content');
+const bufferStreamFile = StreamFile.fromBuffer(buffer, 'bufferBasedStream.txt');
+await bufferStreamFile.writeToDisk('./streams/bufferBasedStream.txt');
+```
+
+### Read and Write Operations with StreamFile
+
+Perform read and write operations efficiently using `StreamFile`.
+
+```typescript
+const fileStream = await StreamFile.fromPath('./inputData/largeFile.data');
+await fileStream.writeToDisk('./outputData/largeFileCopy.data');
+```
+
+Check for completeness of your read and write operations, ensuring the integrity of file content.
+
+```typescript
+const readBuffer = await fileStream.getContentAsBuffer();
+console.log(readBuffer.toString());
+```
+
+### Ensuring File Readiness for Streaming
+
+Ensure a file is ready for streaming or create a custom readable stream incorporating data transformation.
+
+```typescript
+const smartReadStream = new SmartReadStream('./incomingData/sample.data');
+smartReadStream.on('data', (chunk) => {
+  console.log('New Data Chunk:', chunk.toString());
+});
+```
+
+### File Transformation with SmartReadStream
+
+Perform transformations on the stream of data while reading:
+
+```typescript
+smartReadStream.on('data', (chunk) => {
+  // Perform some transformation
+  const transformedChunk = chunk.toString().toUpperCase();
+  console.log('Transformed Data Chunk:', transformedChunk);
+});
+```
+
+### Streaming with SmartReadStream
+
+Stream data from a `SmartReadStream` to a file efficiently managing large datasets.
+
+```typescript
+const transformedWriteStream = fs.createWriteStream('./processedData/transformed.data');
+smartReadStream.pipe(transformedWriteStream);
+```
+
+`@push.rocks/smartfile` significantly simplifies the handling of complex file operations in Node.js projects, making these tasks straightforward while maintaining efficiency and ease of use. Explore and leverage these features to enhance your project's file management capabilities.
+
+## License and Legal Information
+
+This repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository. 
+
+**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.
+
+### Trademarks
+
+This project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH and are not included within the scope of the MIT license granted herein. Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines, and any usage must be approved in writing by Task Venture Capital GmbH.
+
+### Company Information
+
+Task Venture Capital GmbH  
+Registered at District court Bremen HRB 35230 HB, Germany
+
+For any legal inquiries or if you require further information, please contact us via email at hello@task.vc.
+
+By using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.

ts/00_commitinfo_data.ts

@@ -1,8 +1,8 @@
 /**
- * autocreated commitinfo by @pushrocks/commitinfo
+ * autocreated commitinfo by @push.rocks/commitinfo
  */
 export const commitinfo = {
   name: '@push.rocks/smartfile',
-  version: '11.0.2',
+  version: '11.1.0',
-  description: 'offers smart ways to work with files in nodejs'
+  description: 'Provides comprehensive tools for efficient file management in Node.js using TypeScript, including handling streams, virtual directories, and various file operations.'
 }

ts/classes.smartfile.ts

@@ -1,4 +1,4 @@
-import * as plugins from './smartfile.plugins.js';
+import * as plugins from './plugins.js';
 import * as fs from './fs.js';
 import * as memory from './memory.js';
 
@@ -91,6 +91,12 @@ export class SmartFile extends plugins.smartjson.Smartjson {
     });
   }
 
+  public static async fromUrl(urlArg: string) {
+    const response = await plugins.smartrequest.getBinary(urlArg);
+    const smartfile = await SmartFile.fromBuffer(urlArg, response.body);
+    return smartfile;
+  }
+
   // ========
   // INSTANCE
   // ========
@@ -163,7 +169,9 @@ export class SmartFile extends plugins.smartjson.Smartjson {
    * - no argument write to exactly where the file was picked up
    */
   public async write() {
-    await memory.toFs(this.contentBuffer, plugins.path.join(this.base, this.path));
+    let writePath = plugins.smartpath.transform.makeAbsolute(this.path, this.base);
+    console.log(`writing to ${writePath}`);
+    await memory.toFs(this.contentBuffer, writePath);
   }
 
   /**
@@ -204,6 +212,43 @@ export class SmartFile extends plugins.smartjson.Smartjson {
     await fs.remove(plugins.path.join(this.base, this.path));
   }
 
+  /**
+   * Renames the file to the specified new name.
+   * - Updates the `path` property with the new name.
+   * - Writes the file to the new location if it exists on disk.
+   * @param newName The new name of the file (including extension if applicable).
+   * @param writeToDisk (optional) If true, also renames the file on the disk.
+   * @returns The updated file path after renaming.
+   */
+  public async rename(newName: string, writeToDisk: boolean = false): Promise<string> {
+    // Validate the new name
+    if (!newName || typeof newName !== 'string') {
+      throw new Error('Invalid new name provided.');
+    }
+
+    // Extract the directory path
+    const oldFilePath = this.path;
+    const dirPath = plugins.path.dirname(this.path);
+
+    // Create the new file path
+    const newFilePath = plugins.path.join(dirPath, newName);
+
+    // Update the `path` property
+    this.path = newFilePath;
+
+    // Optionally write the renamed file to disk
+    if (writeToDisk) {
+      const oldAbsolutePath = plugins.smartpath.transform.makeAbsolute(oldFilePath, this.base);
+      const newAbsolutePath = plugins.smartpath.transform.makeAbsolute(newFilePath, this.base);
+
+      // Rename the file on disk
+      await plugins.fsExtra.rename(oldAbsolutePath, newAbsolutePath);
+    }
+
+    // Return the new path
+    return this.path;
+  }
+
   // -----------------------------------------------
   // vinyl compatibility
   // -----------------------------------------------
@@ -298,4 +343,11 @@ export class SmartFile extends plugins.smartjson.Smartjson {
     stream.push(null); // Push null to signify the end of the stream (EOF)
     return stream;
   }
+
+  /**
+   * Returns the size of the file in bytes
+   */
+  public async getSize(): Promise<number> {
+    return this.contentBuffer.length;
+  }
 }

ts/classes.streamfile.ts

@@ -1,4 +1,4 @@
-import * as plugins from './smartfile.plugins.js';
+import * as plugins from './plugins.js';
 import * as smartfileFs from './fs.js';
 import * as smartfileFsStream from './fsstream.js';
 import { Readable } from 'stream';
@@ -10,26 +10,16 @@ type TStreamSource = (streamFile: StreamFile) => Promise<Readable>;
  * 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 streamSource: TStreamSource = async (streamFileArg) => smartfileFsStream.createReadStream(filePath);
     const streamFile = new StreamFile(streamSource, filePath);
     streamFile.multiUse = true;
+    streamFile.byteLengthComputeFunction = async () => {
+      const stats = await smartfileFs.stat(filePath);
+      return stats.size;
+    }
     return streamFile;
   }
 
@@ -37,6 +27,10 @@ export class StreamFile {
     const streamSource: TStreamSource = async (streamFileArg) => plugins.smartrequest.getStream(url); // Replace with actual plugin method
     const streamFile = new StreamFile(streamSource);
     streamFile.multiUse = true;
+    streamFile.byteLengthComputeFunction = async () => {
+      const response = await plugins.smartrequest.getBinary(url); // TODO: switch to future .getBinaryByteLength()
+      return response.body.length;
+    }
     return streamFile;
   }
 
@@ -49,6 +43,7 @@ export class StreamFile {
     };
     const streamFile = new StreamFile(streamSource, relativeFilePath);
     streamFile.multiUse = true;
+    streamFile.byteLengthComputeFunction = async () => buffer.length;
     return streamFile;
   }
 
@@ -91,6 +86,22 @@ export class StreamFile {
     return streamFile;
   }
 
+
+  // INSTANCE
+  relativeFilePath?: string;
+  private streamSource: TStreamSource;
+
+  // enable stream based multi use
+  private cachedStreamBuffer?: Buffer;
+  public multiUse: boolean;
+  public used: boolean = false;
+  public byteLengthComputeFunction: () => Promise<number>;
+
+  private constructor(streamSource: TStreamSource, relativeFilePath?: string) {
+    this.streamSource = streamSource;
+    this.relativeFilePath = relativeFilePath;
+  }
+
   // METHODS
 
   private checkMultiUse() {
@@ -149,4 +160,15 @@ export class StreamFile {
     const contentBuffer = await this.getContentAsBuffer();
     return contentBuffer.toString(formatArg);
   }
+
+  /**
+   * Returns the size of the file content in bytes.
+   */
+  public async getSize(): Promise<number> {
+    if (this.byteLengthComputeFunction) {
+      return this.byteLengthComputeFunction();
+    } else {
+      return null;
+    }
+  }
 }

ts/classes.virtualdirectory.ts

@@ -1,5 +1,5 @@
 import { SmartFile } from './classes.smartfile.js';
-import * as plugins from './smartfile.plugins.js';
+import * as plugins from './plugins.js';
 import * as fs from './fs.js';
 
 

ts/fs.ts

@@ -1,9 +1,10 @@
-import * as plugins from './smartfile.plugins.js';
+import * as plugins from './plugins.js';
 import * as interpreter from './interpreter.js';
 
 import { SmartFile } from './classes.smartfile.js';
 
 import * as memory from './memory.js';
+import type { StreamFile } from './classes.streamfile.js';
 /*===============================================================
 ============================ Checks =============================
 ===============================================================*/
@@ -189,7 +190,8 @@ export const removeManySync = (filePathArrayArg: string[]): void => {
 ===============================================================*/
 
 /**
- *
+ * reads a file content to an object
+ * good for JSON, YAML, TOML, etc.
  * @param filePathArg
  * @param fileTypeArg
  * @returns {any}
@@ -198,14 +200,19 @@ export const toObjectSync = (filePathArg, fileTypeArg?) => {
   const fileString = plugins.fsExtra.readFileSync(filePathArg, 'utf8');
   let fileType;
   fileTypeArg ? (fileType = fileTypeArg) : (fileType = interpreter.filetype(filePathArg));
-  return interpreter.objectFile(fileString, fileType);
+  try {
+    return interpreter.objectFile(fileString, fileType);
+  } catch (err) {
+    err.message = `Failed to read file at ${filePathArg}` + err.message;
+    throw err;
+  };
 };
 
 /**
  * reads a file content to a String
  */
 export const toStringSync = (filePath: string): string => {
-  const encoding = plugins.smartmime.getEncoding(filePath);
+  const encoding = plugins.smartmime.getEncodingForPathSync(filePath);
   let fileString: string | Buffer = plugins.fsExtra.readFileSync(filePath, encoding);
   if (Buffer.isBuffer(fileString)) {
     fileString = fileString.toString('binary');
@@ -392,49 +399,98 @@ export const listFileTree = async (
  * Watches for file stability before resolving the promise.
  */
 export const waitForFileToBeReady = (filePathArg: string): Promise<void> => {
-  return new Promise((resolve, reject) => {
+  return new Promise(async (resolve, reject) => {
-    let lastSize = -1;
+    let lastFileSize = -1;
-    let stableCheckTimeout: NodeJS.Timeout | null = null;
+    let fileIsStable = false;
 
-    const clearStableCheckTimeout = () => {
+    const checkFileStability = async () => {
-      if (stableCheckTimeout) {
+      let currentFileSize: number;
-        clearTimeout(stableCheckTimeout);
+      const deferred = plugins.smartpromise.defer();
-        stableCheckTimeout = null;
+      plugins.fs.stat(filePathArg, (err, stats) => {
+        if (err) {
+          fileIsStable = true;
+          watcher.close();
+          reject(err);
+          return;
+        }
+        currentFileSize = stats.size;
+        deferred.resolve();
+      });
+      await deferred.promise;
+      if (currentFileSize === lastFileSize) {
+        fileIsStable = true;
+        await plugins.smartdelay.delayFor(100);
+        resolve();
       }
+      lastFileSize = currentFileSize;
     };
 
     const watcher = plugins.fs.watch(filePathArg, (eventType, filename) => {
       if (eventType === 'change') {
-        plugins.fs.stat(filePathArg, (err, stats) => {
+        checkFileStability();
-          if (err) {
-            watcher.close();
-            clearStableCheckTimeout();
-            reject(err);
-            return;
-          }
-          if (stats.size === lastSize) {
-            clearStableCheckTimeout();
-            stableCheckTimeout = setTimeout(() => {
-              watcher.close();
-              resolve();
-            }, 5000); // stability duration
-          } else {
-            lastSize = stats.size;
-          }
-        });
       }
     });
 
     watcher.on('error', (error) => {
-      clearStableCheckTimeout();
       watcher.close();
       reject(error);
     });
+
+    while (!fileIsStable) {
+      await checkFileStability();
+      if (!fileIsStable) {
+        await plugins.smartdelay.delayFor(5000);
+      }
+    }
+    watcher.close();
   });
 };
 
+/**
+ * writes string or Smartfile to disk.
+ * @param fileArg
+ * @param fileNameArg
+ * @param fileBaseArg
+ */
+export let toFs = async (
+  fileContentArg: string | Buffer | SmartFile | StreamFile,
+  filePathArg: string,
+  optionsArg: {
+    respectRelative?: boolean;
+  } = {}
+) => {
+  const done = plugins.smartpromise.defer();
 
+  // check args
+  if (!fileContentArg || !filePathArg) {
+    throw new Error('expected valid arguments');
+  }
 
+  // prepare actual write action
+  let fileContent: string | Buffer;
+  let fileEncoding: 'utf8' | 'binary' = 'utf8';
+  let filePath: string = filePathArg;
 
+  // handle Smartfile
+  if (fileContentArg instanceof SmartFile) {
+    fileContent = fileContentArg.contentBuffer;
+    // handle options
+    if (optionsArg.respectRelative) {
+      filePath = plugins.path.join(filePath, fileContentArg.path);
+    }
+  } else if (Buffer.isBuffer(fileContentArg)) {
+    fileContent = fileContentArg;
+    fileEncoding = 'binary';
+  } else if (typeof fileContentArg === 'string') {
+    fileContent = fileContentArg;
+  } else {
+    throw new Error('fileContent is neither string nor Smartfile');
+  }
+  await ensureDir(plugins.path.parse(filePath).dir);
+  plugins.fsExtra.writeFile(filePath, fileContent, { encoding: fileEncoding }, done.resolve);
+  return await done.promise;
+};
 
-
+export const stat = async (filePathArg: string) => {
+  return plugins.fsPromises.stat(filePathArg);
+}

ts/fsstream.ts

@@ -1,7 +1,7 @@
 /*
 This file contains logic for streaming things from and to the filesystem
 */
-import * as plugins from './smartfile.plugins.js';
+import * as plugins from './plugins.js';
 
 export const createReadStream = (pathArg: string) => {
   return plugins.fs.createReadStream(pathArg);
@@ -97,7 +97,7 @@ export const waitForFileToBeReadyForStreaming = (filePathArg: string): Promise<v
   });
 };
 
-class SmartReadStream extends plugins.stream.Readable {
+export class SmartReadStream extends plugins.stream.Readable {
   private watcher: plugins.fs.FSWatcher | null = null;
   private lastReadSize: number = 0;
   private endTimeout: NodeJS.Timeout | null = null;

ts/index.ts

@@ -1,4 +1,4 @@
-import * as plugins from './smartfile.plugins.js';
+import * as plugins from './plugins.js';
 import * as fsMod from './fs.js';
 import * as fsStreamMod from './fsstream.js';
 import * as interpreterMod from './interpreter.js';

ts/interpreter.ts

@@ -1,4 +1,4 @@
-import * as plugins from './smartfile.plugins.js';
+import * as plugins from './plugins.js';
 
 export let filetype = (pathArg: string): string => {
   const extName = plugins.path.extname(pathArg);

ts/memory.ts

@@ -1,4 +1,4 @@
-import * as plugins from './smartfile.plugins.js';
+import * as plugins from './plugins.js';
 import { SmartFile } from './classes.smartfile.js';
 import * as smartfileFs from './fs.js';
 import * as interpreter from './interpreter.js';

ts/plugins.ts

@@ -1,9 +1,10 @@
 // node native scope
 import * as fs from 'fs';
+import * as fsPromises from 'fs/promises';
 import * as path from 'path';
 import * as stream from 'stream';
 
-export { fs, path, stream };
+export { fs, fsPromises, path, stream };
 
 // @pushrocks scope
 import * as lik from '@push.rocks/lik';

tsconfig.json

@@ -3,9 +3,12 @@
     "experimentalDecorators": true,
     "useDefineForClassFields": false,
     "target": "ES2022",
-    "module": "ES2022",
+    "module": "NodeNext",
-    "moduleResolution": "nodenext",
+    "moduleResolution": "NodeNext",
     "esModuleInterop": true,
-    "verbatimModuleSyntax": true,
+    "verbatimModuleSyntax": true
-  }
+  },
+  "exclude": [
+    "dist_*/**/*.d.ts"
+  ]
 }