update tsconfig

npmextra.json

@@ -17,15 +17,13 @@
         "files management",
         "TypeScript",
         "Node.js",
-        "read files",
-        "write files",
-        "copy files",
+        "file operations",
+        "file manipulation",
         "file streaming",
-        "directories manipulation",
-        "virtual file system",
+        "virtual directory",
         "filesystem utilities",
-        "ESM syntax",
-        "memory-efficient streaming"
+        "memory-efficient file handling",
+        "custom file operations"
       ]
     }
   },

package.json

@@ -1,7 +1,7 @@
 {
   "name": "@push.rocks/smartfile",
   "private": false,
-  "version": "11.0.9",
+  "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",
@@ -19,15 +19,13 @@
     "files management",
     "TypeScript",
     "Node.js",
-    "read files",
-    "write files",
-    "copy files",
+    "file operations",
+    "file manipulation",
     "file streaming",
-    "directories manipulation",
-    "virtual file system",
+    "virtual directory",
     "filesystem utilities",
-    "ESM syntax",
-    "memory-efficient streaming"
+    "memory-efficient file handling",
+    "custom file operations"
   ],
   "author": "Lossless GmbH <hello@lossless.com> (https://lossless.com)",
   "license": "MIT",
@@ -36,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/**/*",
@@ -75,4 +73,4 @@
   "browserslist": [
     "last 1 chrome versions"
   ]
-}
+}

readme.hints.md

@@ -0,0 +1 @@
+ 

readme.md

@@ -1,6 +1,6 @@
 # @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
 
@@ -12,87 +12,118 @@ npm install @push.rocks/smartfile
 
 ## Usage
 
-`@push.rocks/smartfile` provides a robust suite of tools for managing files in Node.js projects using modern TypeScript and ESM syntax. It simplifies numerous file operations such as reading, writing, copying, and streaming files, as well as working with directories and virtual file systems.
+`@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.
 
-### **Key Features and Classes**
+### Quick Start
 
-- **`SmartFile`**: Facilitates reading from and writing to individual files, managing metadata.
-- **`StreamFile`**: Optimizes memory usage by enabling efficient file streaming.
-- **`VirtualDirectory`**: Allows manipulation of a group of files or directories as a virtual file system.
-
-### **Getting Started with ESM and TypeScript**
-
-First, ensure your project supports ESM syntax and TypeScript. Then, begin by importing the desired features from `@push.rocks/smartfile`:
+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 { SmartFile, StreamFile, VirtualDirectory, memory, fs as smartFs } from '@push.rocks/smartfile';
+import { SmartFile, StreamFile, VirtualDirectory, fs, memory } from '@push.rocks/smartfile';
 ```
 
-### **Reading and Writing Files**
+### Working with `SmartFile`
 
 #### Reading Files
 
-Reading a JSON file:
+To read from a file and convert it to a `SmartFile` instance:
 
 ```typescript
-const myJsonFile: SmartFile = await SmartFile.fromFilePath('./data.json');
-const jsonData = JSON.parse(myJsonFile.contents.toString());
-console.log(jsonData);
+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
 ```
 
 #### Writing Files
 
-Writing content to a file:
+To write data to a file through a `SmartFile`:
 
 ```typescript
-const filePath: string = './output.txt';
-const content: string = 'Hello, SmartFile!';
+const filePath: string = './output/outputData.json';
+const content: string = JSON.stringify({ key: 'value' });
 await memory.toFs(content, filePath);
-console.log('File saved successfully.');
 ```
 
-### **Streaming Large Files**
+### Streaming Large Files with `StreamFile`
 
-For large files, `StreamFile` provides a memory-efficient streaming solution:
+When dealing with large files, you can use `StreamFile` to handle such files efficiently, minimizing memory usage:
 
 ```typescript
-import { createReadStream } from 'fs';
-
-const sourceStream = createReadStream('./large-video.mp4');
-const myStreamFile = await StreamFile.fromStream(sourceStream, 'large-video.mp4');
-await myStreamFile.writeToDir('./storage');
-console.log('Large file streamed to disk successfully.');
+const largeFile: StreamFile = await StreamFile.fromPath('./largeInput/largeFile.mp4');
+await largeFile.writeToDisk('./largeOutput/largeFileCopy.mp4');
 ```
 
-### **Working with Virtual Directories**
+### Managing Virtual Directories
 
-`VirtualDirectory` abstracts a collection of files allowing operations to be performed as if they were on disk:
+Handling multiple files as if they were part of a file system:
 
 ```typescript
 const virtualDir = new VirtualDirectory();
-virtualDir.addSmartfiles([smartFile1, smartFile2]); // Assuming these are SmartFile instances
-await virtualDir.saveToDisk('./virtual-output');
-console.log('Virtual directory saved to disk.');
+await virtualDir.addSmartfiles([smartFile1, smartFile2]);
+await virtualDir.saveToDisk('./virtualDirOutput');
 ```
 
-### **Advanced File Operations**
+### File System Operations
 
-`@push.rocks/smartfile` simplifies complex file operations, including:
+`@push.rocks/smartfile` provides a suite of utilities for common file system operations such as copying, deleting, and listing files or directories.
 
-- Copying directories and files
-- Removing files or directories
-- Listing files and directories with filters
-- Reading file content directly into JavaScript objects
+#### Copying a File
 
-### **Web File Handling**
+```typescript
+await fs.copy('./sourceFile.txt', './destinationFile.txt');
+```
 
-Handling files from HTTP requests:
+#### Deleting a Directory
 
-`@push.rocks/smartfile` offers utilities to work with files from web sources, making it simpler to manage downloads and uploads.
+```typescript
+await fs.remove('./directoryToDelete');
+```
 
-### **Comprehensive File Management**
+#### Listing Files in a Directory
 
-Whether you're dealing with local files, directories, or files over the internet, `@push.rocks/smartfile` provides a comprehensive set of tools to streamline your workflow and reduce the complexity of file management in your Node.js projects.
+```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((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();
+```
+
+#### 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.9',
+  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;
   } = {}