update tsconfig

npmextra.json

@@ -10,14 +10,31 @@
       "githost": "code.foss.global",
       "gitscope": "push.rocks",
       "gitrepo": "smartfile",
-      "description": "smart ways to work with files in nodejs",
+      "description": "provides a robust suite of tools for managing files in Node.js using TypeScript.",
       "npmPackagename": "@push.rocks/smartfile",
-      "license": "MIT"
+      "license": "MIT",
+      "keywords": [
+        "files management",
+        "TypeScript",
+        "Node.js",
+        "file operations",
+        "file manipulation",
+        "file streaming",
+        "virtual directory",
+        "filesystem utilities",
+        "memory-efficient file handling",
+        "custom file 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."],
+    "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.7",
-  "description": "offers smart ways to work with files in nodejs",
+  "version": "11.0.14",
+  "description": "provides a robust suite of tools for managing files in Node.js using TypeScript.",
   "main": "dist_ts/index.js",
   "typings": "dist_ts/index.d.ts",
   "type": "module",
@@ -16,8 +16,16 @@
     "url": "git+https://gitlab.com/push.rocks/smartfile.git"
   },
   "keywords": [
-    "filesystem",
-    "json"
+    "files management",
+    "TypeScript",
+    "Node.js",
+    "file operations",
+    "file manipulation",
+    "file streaming",
+    "virtual directory",
+    "filesystem utilities",
+    "memory-efficient file handling",
+    "custom file operations"
   ],
   "author": "Lossless GmbH <hello@lossless.com> (https://lossless.com)",
   "license": "MIT",
@@ -26,29 +34,29 @@
   },
   "homepage": "https://gitlab.com/push.rocks/smartfile#readme",
   "dependencies": {
-    "@push.rocks/lik": "^6.0.12",
+    "@push.rocks/lik": "^6.0.14",
     "@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.16",
     "@push.rocks/smartmime": "^1.0.5",
-    "@push.rocks/smartpath": "^5.0.11",
+    "@push.rocks/smartpath": "^5.0.13",
     "@push.rocks/smartpromise": "^4.0.2",
     "@push.rocks/smartrequest": "^2.0.21",
-    "@push.rocks/smartstream": "^3.0.30",
+    "@push.rocks/smartstream": "^3.0.34",
     "@types/fs-extra": "^11.0.4",
     "@types/glob": "^8.1.0",
     "@types/js-yaml": "^4.0.9",
-    "fs-extra": "^11.1.1",
-    "glob": "^10.3.10",
+    "fs-extra": "^11.2.0",
+    "glob": "^10.3.12",
     "js-yaml": "^4.1.0"
   },
   "devDependencies": {
-    "@git.zone/tsbuild": "^2.1.70",
+    "@git.zone/tsbuild": "^2.1.72",
     "@git.zone/tsrun": "^1.2.46",
-    "@git.zone/tstest": "^1.0.84",
-    "@push.rocks/tapbundle": "^5.0.15",
-    "@types/node": "^20.10.0"
+    "@git.zone/tstest": "^1.0.88",
+    "@push.rocks/tapbundle": "^5.0.22",
+    "@types/node": "^20.12.7"
   },
   "files": [
     "ts/**/*",
@@ -65,4 +73,4 @@
   "browserslist": [
     "last 1 chrome versions"
   ]
-}
+}

readme.hints.md

@@ -0,0 +1 @@
+ 

readme.md

@@ -1,10 +1,10 @@
 # @push.rocks/smartfile
 
-> offers smart ways to work with files in nodejs
+> Provides a robust suite of tools for managing files in Node.js using TypeScript.
 
 ## Install
 
-To install `@push.rocks/smartfile`, run the following command in your project directory:
+To integrate `@push.rocks/smartfile` into your project, run:
 
 ```bash
 npm install @push.rocks/smartfile
@@ -12,148 +12,118 @@ npm install @push.rocks/smartfile
 
 ## Usage
 
-The `@push.rocks/smartfile` library offers a comprehensive suite of tools to work with files in Node.js projects, facilitating a variety of file operations such as reading, writing, streaming, and in-memory manipulation. Below, you'll find detailed examples illustrating how to leverage the library's functionality to tackle real-world tasks.
+`@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.
 
-### Working with Filesystem
+### Quick Start
 
-#### Ensuring File and Directory Existence
+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`:
 
 ```typescript
-import { fs } from '@push.rocks/smartfile';
-
-// Ensure a file exists with initial content (Async)
-await fs.ensureFile('./path/to/new/file.txt', 'Initial content');
-
-// Ensure a directory exists (Async)
-await fs.ensureDir('./path/to/new/dir');
+import { SmartFile, StreamFile, VirtualDirectory, fs, memory } from '@push.rocks/smartfile';
 ```
 
-#### Getting File Details
+### Working with `SmartFile`
+
+#### Reading Files
+
+To read from a file and convert it to a `SmartFile` instance:
 
 ```typescript
-import { fs } from '@push.rocks/smartfile';
-
-// Check if a file exists (Async)
-const exists: boolean = await fs.fileExists('./path/to/file.txt');
-
-// Check if a path is a directory
-const isDir: boolean = fs.isDirectory('./path/to/check');
+const myJsonSmartFile: SmartFile = await SmartFile.fromFilePath('./somePath/data.json');
+const jsonData = JSON.parse(myJsonSmartFile.contents.toString());
+console.log(jsonData);  // Assuming the file contains JSON content
 ```
 
-### Reading and Writing Files
+#### Writing Files
 
-#### Basic Reading and Writing
+To write data to a file through a `SmartFile`:
 
 ```typescript
-import { SmartFile, memory } from '@push.rocks/smartfile';
-
-// Read a file to a SmartFile instance (Async)
-const smartFile: SmartFile = await SmartFile.fromFilePath('./path/to/read/file.txt');
-
-// Write SmartFile instance to a new path (Async)
-await smartFile.writeToDir('./path/to/target/dir');
-
-// Write text content to a file (Async)
-await memory.toFs('Hello SmartFile!', './path/to/output/file.txt');
+const filePath: string = './output/outputData.json';
+const content: string = JSON.stringify({ key: 'value' });
+await memory.toFs(content, filePath);
 ```
 
-#### Working with File Contents
+### Streaming Large Files with `StreamFile`
+
+When dealing with large files, you can use `StreamFile` to handle such files efficiently, minimizing memory usage:
 
 ```typescript
-import { SmartFile } from '@push.rocks/smartfile';
-
-// Creating SmartFile instance from text
-const smartFileFromText: SmartFile = await SmartFile.fromString('./path/to/text/file.txt', 'Text content here', 'utf8');
-
-// Reading content from SmartFile instance
-const content: string = smartFileFromText.contents.toString();
-
-// Editing content of SmartFile
-await smartFileFromText.editContentAsString(async (currentContent: string) => `Modified: ${currentContent}`);
+const largeFile: StreamFile = await StreamFile.fromPath('./largeInput/largeFile.mp4');
+await largeFile.writeToDisk('./largeOutput/largeFileCopy.mp4');
 ```
 
-### File Streaming
+### Managing Virtual Directories
+
+Handling multiple files as if they were part of a file system:
 
 ```typescript
-import { StreamFile } from '@push.rocks/smartfile';
-
-// Creating a StreamFile from a file path (Async)
-const streamFile: StreamFile = await StreamFile.fromPath('./path/to/large/file.avi');
-
-// Streaming file content to disk (Async)
-await streamFile.writeToDisk('./path/to/target/file.avi');
+const virtualDir = new VirtualDirectory();
+await virtualDir.addSmartfiles([smartFile1, smartFile2]);
+await virtualDir.saveToDisk('./virtualDirOutput');
 ```
 
-#### Utilizing Stream Files from URLs
+### 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
-import { StreamFile } from '@push.rocks/smartfile';
-
-// Creating a StreamFile from URL (Async)
-const streamFileFromURL: StreamFile = await StreamFile.fromUrl('https://example.com/data.json');
-
-// Accessing StreamFile content as string (Async, for textual data)
-const contentAsString: string = await streamFileFromURL.getContentAsString();
+await fs.copy('./sourceFile.txt', './destinationFile.txt');
 ```
 
-### Handling Virtual Directories
+#### Deleting a Directory
 
 ```typescript
-import { VirtualDirectory, SmartFile } from '@push.rocks/smartfile';
-
-// Creating a virtual directory from existing directory on disk (Async)
-const virtualDirectory: VirtualDirectory = await VirtualDirectory.fromFsDirPath('./path/to/source/dir');
-
-// Adding files to virtual directory
-virtualDirectory.addSmartfiles([await SmartFile.fromFilePath('./path/to/extra/file.txt')]);
-
-// Saving virtual directory to disk (Async)
-await virtualDirectory.saveToDisk('./path/to/destination/dir');
+await fs.remove('./directoryToDelete');
 ```
 
-#### Manipulating File Paths
+#### Listing Files in a Directory
 
 ```typescript
-import { SmartFile } from '@push.rocks/smartfile';
-
-// Read SmartFile and change its relative path
-const smartFile: SmartFile = await SmartFile.fromFilePath('./path/to/original/file.txt');
-smartFile.updateFileName('newFilename.txt'); // Retains original directory but changes file name
+const fileList: string[] = await fs.listFiles('./someDirectory');
+console.log(fileList);
 ```
 
-### Security and Hashing
+### 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
-import { SmartFile } from '@push.rocks/smartfile';
-
-// Creating SmartFile instance and getting hash
-const smartFileForHash: SmartFile = await SmartFile.fromString('./fileForHashing.txt', 'Content for hashing', 'utf8');
-const hash: string = await smartFileForHash.getHash('content'); // 'content', 'path', or 'all'
+const smartFileToEdit: SmartFile = await SmartFile.fromFilePath('./editableFile.txt');
+await smartFileToEdit.editContentAsString((content) => content.replace(/originalText/g, 'newText'));
+await smartFileToEdit.write();
 ```
 
-### Advanced Streaming via `SmartReadStream`
-
-For handling edge cases such as streaming large files that are being written concurrently (e.g., log files), `SmartReadStream` can be employed to monitor files for new data and stream content as it becomes available.
+#### Streaming a File from a URL
 
 ```typescript
-import { fsStream } from '@push.rocks/smartfile';
-
-const smartReadStream = new fsStream.SmartReadStream('./path/to/live/file.log');
-smartReadStream
-  .on('data', (chunk) => {
-    // Process streamed data
-  })
-  .on('error', (err) => {
-    console.error('Stream encountered an error:', err);
-  })
-  .on('end', () => {
-    console.log('No more data available.');
-  });
+const streamedFile: StreamFile = await StreamFile.fromUrl('https://example.com/file.pdf');
+await streamedFile.writeToDisk('./downloadedFiles/file.pdf');
 ```
 
-In conclusion, `@push.rocks/smartfile` equips developers with a highly versatile API for file manipulation, enhancing productivity in handling file operations within Node.js applications. By leveraging the examples provided, users can efficiently integrate file processing tasks into their projects, streamlining workflows and achieving granular control over file and directory management.
+### Working with File Buffers and Streams
 
-For more details and advanced use cases, please refer to the `@push.rocks/smartfile` documentation and explore the source code to unlock the full potential of this powerful library in your Node.js applications.
+`@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();
+```
+
+#### Uploading a File
+
+Stream files or buffers can be integrated with web frameworks to handle file uploads efficiently, utilizing streams to reduce memory footprint.
+
+### Conclusion
+
+With `@push.rocks/smartfile`, managing files in Node.js using TypeScript becomes significantly more straightforward and efficient. Utilizing the provided classes and methods, you can handle a wide range of file operations, from basic read/write tasks to complex operations such as virtual directory management and file streaming, with minimal boilerplate code and maximum efficiency.
 
 ## License and Legal Information
 

ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartfile',
-  version: '11.0.7',
-  description: 'offers smart ways to work with files in nodejs'
+  version: '11.0.14',
+  description: 'provides a robust suite of tools for managing files in Node.js using TypeScript.'
 }

ts/classes.smartfile.ts

@@ -169,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);
   }
 
   /**

ts/fs.ts

@@ -447,8 +447,8 @@ export const waitForFileToBeReady = (filePathArg: string): Promise<void> => {
  * @param fileBaseArg
  */
 export let toFs = async (
-  filePathArg: string,
   fileContentArg: string | Buffer | SmartFile | StreamFile,
+  filePathArg: string,
   optionsArg: {
     respectRelative?: boolean;
   } = {}