ktfile 1.1.9 → 1.2.0

package/README.md

@@ -24,20 +24,20 @@ npm install ktfile
 ### Basic Usage
 
 ```javascript
-import { fileSync, fileAsync, File } from 'ktfile';
+import { fileSync, fileAsync, File } from 'ktfile'
 
 // Synchronous API
-const file = fileSync('/path/to/file.txt');
-file.write('Hello, world!');
-console.log(file.read()); // "Hello, world!"
+const file = fileSync('/path/to/file.txt')
+file.write('Hello, world!')
+console.log(file.read()) // "Hello, world!"
 
 // Asynchronous API
-const asyncFile = fileAsync('/path/to/file.txt');
-await asyncFile.write('Hello, async world!');
-console.log(await asyncFile.read()); // "Hello, async world!"
+const asyncFile = fileAsync('/path/to/file.txt')
+await asyncFile.write('Hello, async world!')
+console.log(await asyncFile.read()) // "Hello, async world!"
 
 // Alternative syntax
-const file2 = new File('/another/path');
+const file2 = new File('/another/path')
 ```
 
 ### Node.js Setup
@@ -45,10 +45,10 @@ const file2 = new File('/another/path');
 The library automatically initializes with Node.js `fs` module when available. For custom environments:
 
 ```javascript
-import { initFS } from 'ktfile';
-import fs from 'fs';
+import { initFS } from 'ktfile'
+import fs from 'fs'
 
-initFS(fs);
+initFS(fs)
 ```
 
 ## API Reference
@@ -86,89 +86,89 @@ initFS(fs);
 ##### Path Operations
 ```javascript
 // Join paths
-const newPath = file.to('subdirectory', 'file.txt');
+const newPath = file.to('subdirectory', 'file.txt')
 
 // Check if path contains another path
-const contains = parentDir.contains(childFile);
+const contains = parentDir.contains(childFile)
 ```
 
 ##### File Creation and Deletion
 ```javascript
 // Create file
-file.createFile();
+file.createFile()
 
 // Create temporary file
-const tempFile = FileSync.createTempFile(directory, 'prefix', '.tmp');
+const tempFile = FileSync.createTempFile(directory, 'prefix', '.tmp')
 
 // Delete file or directory
-file.delete(recursive = false, force = false);
+file.delete(recursive = false, force = false)
 
 // Schedule deletion on exit
-file.deleteOnExit(recursive = false);
+file.deleteOnExit(recursive = false)
 
 // Clear directory contents
-directory.clear(recursive = true);
+directory.clear(recursive = true)
 ```
 
 ##### Directory Operations
 ```javascript
 // Create directory
-directory.mkdir(recursive = false);
+directory.mkdir(recursive = false)
 
 // Create directory tree
-directory.mkdirs();
+directory.mkdirs()
 
 // List files in directory
-const files = directory.listFiles();
-const filenames = directory.listFilenames();
+const files = directory.listFiles()
+const filenames = directory.listFilenames()
 
 // Walk directory tree
 for (const file of directory.walk()) {
-    console.log(file.name);
+    console.log(file.name)
 }
 ```
 
 ##### File Operations
 ```javascript
 // Copy file
-file.copyTo(destination, overwrite = false, recursive = false);
+file.copyTo(destination, overwrite = false, recursive = false)
 
 // Move/rename file
-file.renameTo(newLocation, overwrite = false, recursive = false);
+file.renameTo(newLocation, overwrite = false, recursive = false)
 ```
 
 ##### Reading Files
 ```javascript
 // Read as string
-const content = file.read('utf8');
+const content = file.read('utf8')
 
 // Read as Buffer
-const buffer = file.read();
+const buffer = file.read()
 
 // Read lines as array
-const lines = file.readLines('utf8');
+const lines = file.readLines('utf8')
 
 // Read JSON
-const data = file.readJSON();
+const data = file.readJSON()
 
 // Read symbolic link target
-const target = symlink.readlink();
+const target = symlink.readlink()
 ```
 
 ##### Writing Files
 ```javascript
 // Write string or Buffer
-file.write('content', 'utf8');
-file.write(buffer);
+file.write('content', 'utf8')
+file.write(buffer)
 
 // Write with custom encoder
-file.write(data, { write: () => data });
+file.write(data, { write: () => data })
 
 // Write JSON
-file.writeJSON({ key: 'value' });
+file.writeJSON({ key: 'value' })
 
 // Append to file
-file.append('more content', 'utf8');
+file.append('more content', 'utf8')
 ```
 
 ### FileAsync Class
@@ -194,94 +194,94 @@ All methods that return metadata or perform operations are asynchronous and retu
 ##### Permission Methods
 ```javascript
 // Check permissions
-const canRead = await file.canRead();
-const canWrite = await file.canWrite();
-const canExecute = await file.canExecute();
+const canRead = await file.canRead()
+const canWrite = await file.canWrite()
+const canExecute = await file.canExecute()
 
 // Set permissions
-await file.setReadable(true);
-await file.setWritable(false);
-await file.setExecutable(true);
+await file.setReadable(true)
+await file.setWritable(false)
+await file.setExecutable(true)
 ```
 
 ##### Metadata Methods
 ```javascript
 // Get timestamps
-const created = await file.creationTime();
-const modified = await file.lastModified();
-const accessed = await file.lastAccess();
+const created = await file.creationTime()
+const modified = await file.lastModified()
+const accessed = await file.lastAccess()
 
 // Set timestamps
-await file.setCreationTime(new Date());
-await file.setLastModified(new Date());
+await file.setCreationTime(new Date())
+await file.setLastModified(new Date())
 
 // File information
-const exists = await file.exists();
-const isDir = await file.isDirectory();
-const isFile = await file.isFile();
-const isEmpty = await file.isEmpty();
-const isLink = await file.isSymbolicLink();
+const exists = await file.exists()
+const isDir = await file.isDirectory()
+const isFile = await file.isFile()
+const isEmpty = await file.isEmpty()
+const isLink = await file.isSymbolicLink()
 
 // File sizes
-const bytes = await file.size();
-const kb = await file.sizeKB();
-const mb = await file.sizeMB();
-const gb = await file.sizeGB();
+const bytes = await file.size()
+const kb = await file.sizeKB()
+const mb = await file.sizeMB()
+const gb = await file.sizeGB()
 ```
 
 ##### File Operations
 ```javascript
 // Create and delete
-await file.createFile();
-await file.delete(recursive, force);
-await directory.clear(recursive);
+await file.createFile()
+await file.delete(recursive, force)
+await directory.clear(recursive)
 
 // Copy and move
-await file.copyTo(destination, overwrite, recursive);
-await file.renameTo(newLocation, overwrite, recursive);
+await file.copyTo(destination, overwrite, recursive)
+await file.renameTo(newLocation, overwrite, recursive)
 ```
 
 ##### Directory Operations
 ```javascript
 // Create directories
-await directory.mkdir(recursive);
-await directory.mkdirs();
+await directory.mkdir(recursive)
+await directory.mkdirs()
 
 // List contents
-const files = await directory.listFiles();
-const filenames = await directory.listFilenames();
+const files = await directory.listFiles()
+const filenames = await directory.listFilenames()
 
 // Walk directory tree (AsyncGenerator)
 for await (const file of directory.walk()) {
-    console.log(file.name);
+    console.log(file.name)
 }
 ```
 
 ##### Reading Files
 ```javascript
 // Read file contents
-const content = await file.read('utf8');
-const buffer = await file.read();
-const lines = await file.readLines('utf8');
-const data = await file.readJSON();
+const content = await file.read('utf8')
+const buffer = await file.read()
+const lines = await file.readLines('utf8')
+const data = await file.readJSON()
 
 // Read symbolic link
-const target = await symlink.readlink();
+const target = await symlink.readlink()
 ```
 
 ##### Writing Files
 ```javascript
 // Write content
-await file.write('content', 'utf8');
-await file.write(buffer);
-await file.writeJSON({ key: 'value' });
-await file.append('more content', 'utf8');
+await file.write('content', 'utf8')
+await file.write(buffer)
+await file.writeJSON({ key: 'value' })
+await file.append('more content', 'utf8')
 ```
 
 ##### Static Methods
 ```javascript
 // Create temporary file
-const tempFile = FileAsync.createTempFile(directory, 'prefix', '.tmp');
+const tempFile = FileAsync.createTempFile(directory, 'prefix', '.tmp')
 ```
 
 ## Examples
@@ -289,30 +289,30 @@ const tempFile = FileAsync.createTempFile(directory, 'prefix', '.tmp');
 ### Working with Directories
 
 ```javascript
-import { fileSync } from 'ktfile';
+import { fileSync } from 'ktfile'
 
-const projectDir = fileSync('./my-project');
+const projectDir = fileSync('./my-project')
 
 // Create project structure
-projectDir.mkdirs();
-projectDir.to('src').mkdir();
-projectDir.to('tests').mkdir();
-projectDir.to('docs').mkdir();
+projectDir.mkdirs()
+projectDir.to('src').mkdir()
+projectDir.to('tests').mkdir()
+projectDir.to('docs').mkdir()
 
 // Create files
-const packageJson = projectDir.to('package.json');
+const packageJson = projectDir.to('package.json')
 packageJson.writeJSON({
     name: 'my-project',
     version: '1.0.0'
-});
+})
 
-const readme = projectDir.to('README.md');
-readme.write('# My Project\n\nDescription here...');
+const readme = projectDir.to('README.md')
+readme.write('# My Project\n\nDescription here...')
 
 // List all files
 for (const file of projectDir.walk()) {
     if (file.isFile) {
-        console.log(`File: ${file.name} (${file.sizeKB} KB)`);
+        console.log(`File: ${file.name} (${file.sizeKB} KB)`)
     }
 }
 ```
@@ -320,68 +320,68 @@ for (const file of projectDir.walk()) {
 ### File Manipulation
 
 ```javascript
-import { fileSync } from 'ktfile';
+import { fileSync } from 'ktfile'
 
-const sourceFile = fileSync('./data.json');
-const backupFile = fileSync('./backup/data-backup.json');
+const sourceFile = fileSync('./data.json')
+const backupFile = fileSync('./backup/data-backup.json')
 
 // Create backup directory
-backupFile.parent?.mkdirs();
+backupFile.parent?.mkdirs()
 
 // Copy file
-sourceFile.copyTo(backupFile, true);
+sourceFile.copyTo(backupFile, true)
 
 // Read and modify JSON
-const data = sourceFile.readJSON();
-data.lastBackup = new Date().toISOString();
-sourceFile.writeJSON(data);
+const data = sourceFile.readJSON()
+data.lastBackup = new Date().toISOString()
+sourceFile.writeJSON(data)
 
-console.log(`Backup created: ${backupFile.size} bytes`);
+console.log(`Backup created: ${backupFile.size} bytes`)
 ```
 
 ### Async Operations
 
 ```javascript
-import { fileAsync } from 'ktfile';
+import { fileAsync } from 'ktfile'
 
 async function processFiles() {
-    const directory = fileAsync('./uploads');
-    const files = await directory.listFiles();
+    const directory = fileAsync('./uploads')
+    const files = await directory.listFiles()
     
     for (const file of files || []) {
         if (file.extension === '.txt') {
-            const content = await file.read('utf8');
-            const processed = content.toUpperCase();
+            const content = await file.read('utf8')
+            const processed = content.toUpperCase()
             
-            const outputFile = file.parent?.to('processed', file.name);
-            await outputFile?.parent?.mkdirs();
-            await outputFile?.write(processed);
+            const outputFile = file.parent?.to('processed', file.name)
+            await outputFile?.parent?.mkdirs()
+            await outputFile?.write(processed)
             
-            console.log(`Processed: ${file.name}`);
+            console.log(`Processed: ${file.name}`)
         }
     }
 }
 
-processFiles().catch(console.error);
+processFiles().catch(console.error)
 ```
 
 ### Temporary Files
 
 ```javascript
-import { FileSync, fileSync } from 'ktfile';
+import { FileSync, fileSync } from 'ktfile'
 
-const tempDir = fileSync('./temp');
-tempDir.mkdirs();
+const tempDir = fileSync('./temp')
+tempDir.mkdirs()
 
 // Create temporary file
-const tempFile = FileSync.createTempFile(tempDir, 'data-', '.json');
-tempFile.writeJSON({ processing: true, timestamp: Date.now() });
+const tempFile = FileSync.createTempFile(tempDir, 'data-', '.json')
+tempFile.writeJSON({ processing: true, timestamp: Date.now() })
 
 // Use the temporary file
-console.log(`Temp file created: ${tempFile.name}`);
+console.log(`Temp file created: ${tempFile.name}`)
 
 // Clean up on exit
-tempFile.deleteOnExit();
+tempFile.deleteOnExit()
 ```
 
 ## Error Handling
@@ -389,18 +389,18 @@ tempFile.deleteOnExit();
 Methods return `null` when operations fail, allowing for graceful error handling:
 
 ```javascript
-const file = fileSync('./nonexistent.txt');
+const file = fileSync('./nonexistent.txt')
 
-const content = file.read();
+const content = file.read()
 if (content === null) {
-    console.log('File does not exist or cannot be read');
+    console.log('File does not exist or cannot be read')
 } else {
-    console.log('File content:', content);
+    console.log('File content:', content)
 }
 
 // Check existence before operations
 if (file.exists) {
-    file.delete();
+    file.delete()
 }
 ```
 
@@ -409,13 +409,13 @@ if (file.exists) {
 KTFile handles platform differences automatically:
 
 ```javascript
-const file = fileSync('./path/to/file.txt');
+const file = fileSync('./path/to/file.txt')
 
 // Uses correct separator for platform
-console.log(file.separator); // '/' on Unix, '\' on Windows
+console.log(file.separator) // '/' on Unix, '\' on Windows
 
 // Paths are normalized automatically
-const nested = file.parent?.to('..', 'sibling', 'file.txt');
+const nested = file.parent?.to('..', 'sibling', 'file.txt')
 ```
 
 ## License

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ktfile",
-  "version": "1.1.9",
+  "version": "1.2.0",
   "description": "A powerful, cross-platform file system library for JavaScript/TypeScript that provides both synchronous and asynchronous APIs with a clean, object-oriented interface.",
   "main": "index.min.js",
   "types": "types/ktfile.d.ts",