@unvired/react-native-unvired-sdk 0.0.26 → 0.0.28

package/BuildNo.txt

@@ -1 +1 @@
-R-0.000.0026
+R-0.000.0028

package/dist/database/services/DatabaseNative.js

@@ -31,7 +31,7 @@ export class DatabaseNative {
                 try {
                     const db = this.getDatabase(options.dbName);
                     // FIX: Await the result properly
-                    const res = await db.execute(options.query, options.params);
+                    const res = await db.execute(options.query, options.params || []);
                     let resultToReturn = [];
                     // Cast to any to avoid TS error "Property '_array' does not exist on type 'never'"
                     const rawRes = res;

package/dist/device-info/BaseDeviceInfo.js

@@ -24,6 +24,10 @@ export class BaseDeviceInfo {
                 isMobile: Platform.OS === 'ios' || Platform.OS === 'android',
                 manufacturer: DeviceInfo.getManufacturerSync(),
                 uuid: DeviceInfo.getUniqueIdSync(),
+                deviceId: DeviceInfo.getUniqueIdSync(),
+                deviceName: DeviceInfo.getDeviceNameSync(),
+                brand: DeviceInfo.getBrand(),
+                deviceType: DeviceInfo.getDeviceType(),
             };
             this.cachedDeviceInfo = deviceInfo;
             return deviceInfo;
@@ -36,6 +40,10 @@ export class BaseDeviceInfo {
                 model: 'Unknown',
                 version: Platform.Version.toString(),
                 isMobile: Platform.OS === 'ios' || Platform.OS === 'android',
+                deviceId: 'N/A',
+                deviceName: 'N/A',
+                brand: 'N/A',
+                deviceType: 'N/A',
             };
             this.cachedDeviceInfo = fallback;
             return fallback;

package/dist/device-info/DeviceInfo.types.d.ts

@@ -8,4 +8,8 @@ export interface IDeviceInfo {
     isMobile: boolean;
     manufacturer?: string;
     uuid?: string;
+    deviceId?: string;
+    deviceName?: string;
+    brand?: string;
+    deviceType?: string;
 }

package/dist/local-storage/localStorage.d.ts

@@ -9,41 +9,41 @@ export declare class LocalStorage {
      * @param key - The key to retrieve
      * @returns The parsed value or null if not found
      */
-    static getItem<T = any>(key: string): Promise<T | null>;
+    static getItem<T = any>(key: string): T | null;
     /**
      * Set an item in storage
      * @param key - The key to store the value under
      * @param value - The value to store (will be JSON stringified)
      */
-    static setItem(key: string, value: any): Promise<void>;
+    static setItem(key: string, value: any): void;
     /**
      * Remove an item from storage
      * @param key - The key to remove
      */
-    static removeItem(key: string): Promise<void>;
+    static removeItem(key: string): void;
     /**
      * Clear all items from storage
      */
-    static clear(): Promise<void>;
+    static clear(): void;
     /**
      * Get all keys from storage
      * @returns Array of all keys
      */
-    static getAllKeys(): Promise<readonly string[]>;
+    static getAllKeys(): readonly string[];
     /**
      * Get multiple items from storage
      * @param keys - Array of keys to retrieve
      * @returns Array of [key, value] pairs
      */
-    static multiGet(keys: string[]): Promise<Array<[string, any]>>;
+    static multiGet(keys: string[]): Array<[string, any]>;
     /**
      * Set multiple items in storage
      * @param keyValuePairs - Array of [key, value] pairs to store
      */
-    static multiSet(keyValuePairs: Array<[string, any]>): Promise<void>;
+    static multiSet(keyValuePairs: Array<[string, any]>): void;
     /**
      * Remove multiple items from storage
      * @param keys - Array of keys to remove
      */
-    static multiRemove(keys: string[]): Promise<void>;
+    static multiRemove(keys: string[]): void;
 }

package/dist/local-storage/localStorage.js

@@ -14,9 +14,9 @@ export class LocalStorage {
      * @param key - The key to retrieve
      * @returns The parsed value or null if not found
      */
-    static async getItem(key) {
+    static getItem(key) {
         try {
-            const value = await storageImpl.getItem(key);
+            const value = storageImpl.getItem(key);
             return value ? JSON.parse(value) : null;
         }
         catch (error) {
@@ -29,10 +29,10 @@ export class LocalStorage {
      * @param key - The key to store the value under
      * @param value - The value to store (will be JSON stringified)
      */
-    static async setItem(key, value) {
+    static setItem(key, value) {
         try {
             const jsonValue = JSON.stringify(value);
-            await storageImpl.setItem(key, jsonValue);
+            storageImpl.setItem(key, jsonValue);
         }
         catch (error) {
             console.error(`Error setting item with key "${key}":`, error);
@@ -43,9 +43,9 @@ export class LocalStorage {
      * Remove an item from storage
      * @param key - The key to remove
      */
-    static async removeItem(key) {
+    static removeItem(key) {
         try {
-            await storageImpl.removeItem(key);
+            storageImpl.removeItem(key);
         }
         catch (error) {
             console.error(`Error removing item with key "${key}":`, error);
@@ -55,9 +55,9 @@ export class LocalStorage {
     /**
      * Clear all items from storage
      */
-    static async clear() {
+    static clear() {
         try {
-            await storageImpl.clear();
+            storageImpl.clear();
         }
         catch (error) {
             console.error('Error clearing storage:', error);
@@ -68,9 +68,9 @@ export class LocalStorage {
      * Get all keys from storage
      * @returns Array of all keys
      */
-    static async getAllKeys() {
+    static getAllKeys() {
         try {
-            return await storageImpl.getAllKeys();
+            return storageImpl.getAllKeys();
         }
         catch (error) {
             console.error('Error getting all keys:', error);
@@ -82,9 +82,9 @@ export class LocalStorage {
      * @param keys - Array of keys to retrieve
      * @returns Array of [key, value] pairs
      */
-    static async multiGet(keys) {
+    static multiGet(keys) {
         try {
-            const results = await storageImpl.multiGet(keys);
+            const results = storageImpl.multiGet(keys);
             return results.map(([key, value]) => [
                 key,
                 value ? JSON.parse(value) : null
@@ -99,13 +99,13 @@ export class LocalStorage {
      * Set multiple items in storage
      * @param keyValuePairs - Array of [key, value] pairs to store
      */
-    static async multiSet(keyValuePairs) {
+    static multiSet(keyValuePairs) {
         try {
             const jsonPairs = keyValuePairs.map(([key, value]) => [
                 key,
                 JSON.stringify(value)
             ]);
-            await storageImpl.multiSet(jsonPairs);
+            storageImpl.multiSet(jsonPairs);
         }
         catch (error) {
             console.error('Error setting multiple items:', error);
@@ -116,9 +116,9 @@ export class LocalStorage {
      * Remove multiple items from storage
      * @param keys - Array of keys to remove
      */
-    static async multiRemove(keys) {
+    static multiRemove(keys) {
         try {
-            await storageImpl.multiRemove(keys);
+            storageImpl.multiRemove(keys);
         }
         catch (error) {
             console.error('Error removing multiple items:', error);

package/dist/local-storage/services/StorageNative.d.ts

@@ -1,10 +1,10 @@
 export declare class StorageNative {
-    getItem(key: string): Promise<string | null>;
-    setItem(key: string, value: string): Promise<void>;
-    removeItem(key: string): Promise<void>;
-    clear(): Promise<void>;
-    getAllKeys(): Promise<readonly string[]>;
-    multiGet(keys: string[]): Promise<readonly [string, string | null][]>;
-    multiSet(keyValuePairs: Array<[string, string]>): Promise<void>;
-    multiRemove(keys: string[]): Promise<void>;
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+    clear(): void;
+    getAllKeys(): readonly string[];
+    multiGet(keys: string[]): readonly [string, string | null][];
+    multiSet(keyValuePairs: Array<[string, string]>): void;
+    multiRemove(keys: string[]): void;
 }

package/dist/local-storage/services/StorageNative.js

@@ -1,27 +1,36 @@
-import AsyncStorage from '@react-native-async-storage/async-storage';
+import { createMMKV } from 'react-native-mmkv';
+const storage = createMMKV();
 export class StorageNative {
-    async getItem(key) {
-        return await AsyncStorage.getItem(key);
+    getItem(key) {
+        const val = storage.getString(key);
+        return val !== undefined ? val : null;
     }
-    async setItem(key, value) {
-        await AsyncStorage.setItem(key, value);
+    setItem(key, value) {
+        storage.set(key, value);
     }
-    async removeItem(key) {
-        await AsyncStorage.removeItem(key);
+    removeItem(key) {
+        storage.remove(key);
     }
-    async clear() {
-        await AsyncStorage.clear();
+    clear() {
+        storage.clearAll();
     }
-    async getAllKeys() {
-        return await AsyncStorage.getAllKeys();
+    getAllKeys() {
+        return storage.getAllKeys();
     }
-    async multiGet(keys) {
-        return await AsyncStorage.multiGet(keys);
+    multiGet(keys) {
+        return keys.map(key => {
+            const val = storage.getString(key);
+            return [key, val !== undefined ? val : null];
+        });
     }
-    async multiSet(keyValuePairs) {
-        await AsyncStorage.multiSet(keyValuePairs);
+    multiSet(keyValuePairs) {
+        keyValuePairs.forEach(([key, value]) => {
+            storage.set(key, value);
+        });
     }
-    async multiRemove(keys) {
-        await AsyncStorage.multiRemove(keys);
+    multiRemove(keys) {
+        keys.forEach(key => {
+            storage.remove(key);
+        });
     }
 }

package/dist/local-storage/services/StorageWeb.d.ts

@@ -1,10 +1,10 @@
 export declare class StorageWeb {
-    getItem(key: string): Promise<string | null>;
-    setItem(key: string, value: string): Promise<void>;
-    removeItem(key: string): Promise<void>;
-    clear(): Promise<void>;
-    getAllKeys(): Promise<readonly string[]>;
-    multiGet(keys: string[]): Promise<readonly [string, string | null][]>;
-    multiSet(keyValuePairs: Array<[string, string]>): Promise<void>;
-    multiRemove(keys: string[]): Promise<void>;
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+    clear(): void;
+    getAllKeys(): readonly string[];
+    multiGet(keys: string[]): readonly [string, string | null][];
+    multiSet(keyValuePairs: Array<[string, string]>): void;
+    multiRemove(keys: string[]): void;
 }

package/dist/local-storage/services/StorageWeb.js

@@ -1,26 +1,26 @@
 export class StorageWeb {
-    async getItem(key) {
+    getItem(key) {
         return localStorage.getItem(key);
     }
-    async setItem(key, value) {
+    setItem(key, value) {
         localStorage.setItem(key, value);
     }
-    async removeItem(key) {
+    removeItem(key) {
         localStorage.removeItem(key);
     }
-    async clear() {
+    clear() {
         localStorage.clear();
     }
-    async getAllKeys() {
+    getAllKeys() {
         return Object.keys(localStorage);
     }
-    async multiGet(keys) {
+    multiGet(keys) {
         return keys.map(key => [key, localStorage.getItem(key)]);
     }
-    async multiSet(keyValuePairs) {
+    multiSet(keyValuePairs) {
         keyValuePairs.forEach(([key, value]) => localStorage.setItem(key, value));
     }
-    async multiRemove(keys) {
+    multiRemove(keys) {
         keys.forEach(key => localStorage.removeItem(key));
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unvired/react-native-unvired-sdk",
-  "version": "0.0.26",
+  "version": "0.0.28",
   "description": "Unvired SDK for React Native with logging, database, notifications, and file system support",
   "main": "dist/main.js",
   "types": "dist/main.d.ts",
@@ -13,7 +13,7 @@
   },
   "peerDependencies": {
     "@op-engineering/op-sqlite": "^15.2.5",
-    "@react-native-async-storage/async-storage": "^2.2.0",
+    "react-native-mmkv": "*",
     "@react-native-firebase/messaging": "^21.8.1",
     "react": ">=18",
     "react-native": ">=0.73",
@@ -34,6 +34,9 @@
     "@react-native-async-storage/async-storage": {
       "optional": true
     },
+    "react-native-mmkv": {
+      "optional": true
+    },
     "react-native-device-info": {
       "optional": true
     },
@@ -47,6 +50,7 @@
   "devDependencies": {
     "@op-engineering/op-sqlite": "^15.2.5",
     "@react-native-async-storage/async-storage": "^2.2.0",
+    "react-native-mmkv": "^4.3.2",
     "@react-native-firebase/messaging": "^21.8.1",
     "@types/pako": "^2.0.4",
     "@types/react": ">=18",
@@ -66,4 +70,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}

package/test-app/filepath.ts

@@ -0,0 +1,107 @@
+import UnviredWrapper from '@unvired/react-native-wrapper-sdk';
+
+const wrapper = new UnviredWrapper();
+const fileServiceRaw = wrapper.file();
+
+// Helper to convert ArrayBuffer to string (Native JS - No Buffer Dependency)
+function arrayBufferToString(buffer: ArrayBuffer): string {
+    // Handling small to medium files. For very large files, chunking is needed to avoid stack overflow.
+    return String.fromCharCode.apply(null, new Uint8Array(buffer) as any);
+}
+
+class SDKFileService {
+
+    // Delegate standard methods
+    getDocumentDirectoryPath() {
+        return fileServiceRaw.getDocumentDirectory();
+    }
+
+    async createFile(fileName: string, content: string): Promise<string> {
+        const dir = fileServiceRaw.getDocumentDirectory();
+
+        // Ensure dir ends with slash
+        const path = (dir.endsWith('/') ? dir : dir + '/') + fileName;
+
+        // FIX: React Native Blob implementation has issues with direct ArrayBuffer views in some versions.
+        // Passing string directly to writeExternalFile allows the underlying Blob([content]) to work 
+        // because Blob([string]) is supported.
+        const data = content;
+
+        console.log(`[SDKFileService] Creating file ${fileName} at ${path}`);
+        await fileServiceRaw.writeExternalFile(dir, fileName, data as any);
+        return path;
+    }
+
+    async readFile(fileName: string): Promise<string> {
+        let path = fileName;
+        // If not absolute path, prepend doc dir
+        if (!fileName.startsWith('/') && !fileName.startsWith('file://')) {
+            const dir = fileServiceRaw.getDocumentDirectory();
+            path = (dir.endsWith('/') ? dir : dir + '/') + fileName;
+        }
+
+        // Cleaning file:// prefix if present
+        if (path.startsWith('file://')) {
+            path = path.replace('file://', '');
+        }
+
+        console.log(`[SDKFileService] Reading file: ${path}`);
+        const data = await fileServiceRaw.readExternalFile(path);
+        return arrayBufferToString(data);
+    }
+
+    async deleteFile(fileName: string): Promise<void> {
+        let path = fileName;
+        if (!fileName.startsWith('/') && !fileName.startsWith('file://')) {
+            const dir = fileServiceRaw.getDocumentDirectory();
+            path = (dir.endsWith('/') ? dir : dir + '/') + fileName;
+        }
+
+        // Cleaning file:// prefix if present
+        if (path.startsWith('file://')) {
+            path = path.replace('file://', '');
+        }
+
+        console.log(`[SDKFileService] Deleting file: ${path}`);
+        await fileServiceRaw.deleteExternalFile(path);
+    }
+
+    async listFiles(): Promise<any[]> {
+        const dir = fileServiceRaw.getDocumentDirectory();
+        console.log(`[SDKFileService] Listing files in: ${dir}`);
+
+        // Use resolveLocalFileSystemURL to get DirectoryEntry
+        let dirEntry;
+        try {
+            dirEntry = await fileServiceRaw.resolveLocalFileSystemURL(dir);
+        } catch (e) {
+            console.error('[SDKFileService] Failed to resolve directory:', e);
+            return [];
+        }
+
+        return new Promise((resolve, reject) => {
+            try {
+                const reader = dirEntry.createReader();
+                reader.readEntries((entries: any[]) => {
+                    console.log(`[SDKFileService] Found ${entries.length} entries`);
+                    const mapped = entries.map(e => ({
+                        uri: e.nativeURL || e.fullPath,
+                        name: e.name,
+                        isDirectory: e.isDirectory,
+                        size: 0,
+                        modificationTime: Date.now() / 1000
+                    }));
+                    resolve(mapped);
+                }, (err: any) => {
+                    console.error('[SDKFileService] Failed to list files (readEntries):', err);
+                    resolve([]); // Don't crash UI
+                });
+            } catch (e) {
+                console.error('[SDKFileService] Exception in listFiles:', e);
+                resolve([]);
+            }
+        });
+    }
+}
+
+export default new SDKFileService();

package/ts-core/ReactNativePlatformAdapter.ts

@@ -38,7 +38,11 @@ export class ReactNativePlatformAdapter implements PlatformInterface {
                 DatabaseManager.getDatabaseAdapter().create({ name: options.userId }, successCallback, errorCallback);
             },
             execute: (options: any, successCallback, errorCallback) => {
-                DatabaseManager.getDatabaseAdapter().execute(options, successCallback, errorCallback);
+                DatabaseManager.getDatabaseAdapter().execute({
+                    dbName: options.userId,
+                    query: options.query,
+                    params: options.params
+                }, successCallback, errorCallback);
             },
             executeStatementOnPath: (dbPath, sqlQuery, callback) => {
                 DatabaseManager.getDatabaseAdapter().executeStatementOnPath(dbPath, sqlQuery, callback);

package/wrapper/fileService.ts

@@ -0,0 +1,313 @@
+import { PlatformManager } from '@unvired/unvired-ts-core-sdk';
+
+export interface IDirectoryReader {
+    readEntries(successCallback: (entries: IFileEntry[]) => void, errorCallback: (error: any) => void): void;
+}
+
+export interface IFileEntry {
+    fullPath: string;
+    nativeURL: string;
+    isDirectory?: boolean;
+    remove(callback: () => void, errorCallback: (error: any) => void): void;
+    removeRecursively(callback: () => void, errorCallback: (error: any) => void): void;
+    createReader(): IDirectoryReader;
+    getDirectory?(path: string, options: { create: boolean }, callback: (entry: IFileEntry) => void, errorCallback: (error: any) => void): void;
+    getFile?(path: string, options: { create: boolean }, callback: (entry: IFileEntry) => void, errorCallback: (error: any) => void): void;
+    file?(callback: (file: File) => void, errorCallback: (error: any) => void): void;
+    createWriter?(callback: (writer: any) => void, errorCallback: (error: any) => void): void;
+}
+
+export class FileService {
+
+    getDocumentDirectory(): string {
+        // @ts-ignore
+        return PlatformManager.getInstance().getPlatformAdapter().getDocumentDirectory();
+    }
+
+    resolveLocalFileSystemURL(url: string): Promise<IFileEntry> {
+        // @ts-ignore
+        return PlatformManager.getInstance().getPlatformAdapter().resolveLocalFileSystemURL(url);
+    }
+
+    async getFolderBasedOnUserId(userId: string): Promise<string> {
+        // @ts-ignore
+        return await PlatformManager.getInstance().getPlatformAdapter().getFolderBasedOnUserId(userId);
+    }
+
+    async deleteUserFolder(userId: string): Promise<void> {
+        // @ts-ignore
+        await PlatformManager.getInstance().getPlatformAdapter().deleteUserFolder(userId);
+    }
+
+    /**
+     * Reads an external file as ArrayBuffer using IFileEntry API
+     * @param filePath Absolute path to the file
+     */
+    async readExternalFile(filePath: string): Promise<ArrayBuffer> {
+        // Get the file entry
+        const fileEntry = await this.resolveLocalFileSystemURL(filePath);
+
+        return new Promise((resolve, reject) => {
+            // Use the file() method to read the file
+            if (!fileEntry.file) {
+                reject(new Error('file() method not available on entry'));
+                return;
+            }
+
+            fileEntry.file(
+                async (fileMetadata: any) => {
+                    try {
+                        // Read the file using react-native-fs
+                        const RNFS = await import('react-native-fs');
+                        const content = await RNFS.readFile(fileMetadata.path, 'utf8');
+
+                        // Convert string to ArrayBuffer
+                        const encoder = new TextEncoder();
+                        resolve(encoder.encode(content).buffer);
+                    } catch (error) {
+                        reject(error);
+                    }
+                },
+                (error: any) => {
+                    reject(error);
+                }
+            );
+        });
+    }
+
+    /**
+     * Writes data to an external file using IFileEntry API
+     * @param filePath Parent directory path
+     * @param fileName File name
+     * @param data Data to write (ArrayBuffer or string)
+     */
+    async writeExternalFile(filePath: string, fileName: string, data: ArrayBuffer | string): Promise<void> {
+        // Convert data to string if it's ArrayBuffer
+        let content: string;
+        if (data instanceof ArrayBuffer) {
+            const decoder = new TextDecoder();
+            content = decoder.decode(data);
+        } else {
+            content = data;
+        }
+
+        // Get the directory entry
+        const dirEntry = await this.resolveLocalFileSystemURL(filePath);
+
+        return new Promise((resolve, reject) => {
+            // Get or create the file
+            if (!dirEntry.getFile) {
+                reject(new Error('getFile() method not available on directory entry'));
+                return;
+            }
+
+            dirEntry.getFile(
+                fileName,
+                { create: true },
+                (fileEntry: IFileEntry) => {
+                    // Create a writer
+                    if (!fileEntry.createWriter) {
+                        reject(new Error('createWriter() method not available on file entry'));
+                        return;
+                    }
+
+                    fileEntry.createWriter(
+                        (writer: any) => {
+                            writer.onwriteend = () => {
+                                resolve();
+                            };
+                            writer.onerror = (error: any) => {
+                                reject(error);
+                            };
+
+                            // Write the content
+                            writer.write(content);
+                        },
+                        (error: any) => {
+                            reject(error);
+                        }
+                    );
+                },
+                (error: any) => {
+                    reject(error);
+                }
+            );
+        });
+    }
+
+    /**
+     * Deletes an external file using IFileEntry API
+     * @param filePath Absolute path to the file
+     */
+    async deleteExternalFile(filePath: string): Promise<void> {
+        const fileEntry = await this.resolveLocalFileSystemURL(filePath);
+
+        return new Promise((resolve, reject) => {
+            fileEntry.remove(
+                () => resolve(),
+                (error: any) => reject(error)
+            );
+        });
+    }
+
+    /**
+     * Checks if a file exists using IFileEntry API
+     * @param filePath Absolute path to the file
+     */
+    async fileExists(filePath: string): Promise<boolean> {
+        try {
+            await this.resolveLocalFileSystemURL(filePath);
+            return true;
+        } catch (error) {
+            return false;
+        }
+    }
+
+    /**
+     * Creates a directory
+     * @param dirPath Parent directory path
+     * @param dirName Directory name to create
+     */
+    async createDirectory(dirPath: string, dirName: string): Promise<IFileEntry> {
+        const parentEntry = await this.resolveLocalFileSystemURL(dirPath);
+
+        return new Promise((resolve, reject) => {
+            if (!parentEntry.getDirectory) {
+                reject(new Error('getDirectory() method not available on entry'));
+                return;
+            }
+
+            parentEntry.getDirectory(
+                dirName,
+                { create: true },
+                (dirEntry: IFileEntry) => resolve(dirEntry),
+                (error: any) => reject(error)
+            );
+        });
+    }
+
+    /**
+     * Lists files and directories in a directory
+     * @param dirPath Directory path to list
+     */
+    async listDirectory(dirPath: string): Promise<IFileEntry[]> {
+        const dirEntry = await this.resolveLocalFileSystemURL(dirPath);
+
+        return new Promise((resolve, reject) => {
+            const reader = dirEntry.createReader();
+            reader.readEntries(
+                (entries: IFileEntry[]) => resolve(entries),
+                (error: any) => reject(error)
+            );
+        });
+    }
+
+    /**
+     * Deletes a directory and all its contents
+     * @param dirPath Directory path to delete
+     */
+    async deleteDirectory(dirPath: string): Promise<void> {
+        const dirEntry = await this.resolveLocalFileSystemURL(dirPath);
+
+        return new Promise((resolve, reject) => {
+            dirEntry.removeRecursively(
+                () => resolve(),
+                (error: any) => reject(error)
+            );
+        });
+    }
+
+    /**
+     * Copies a file
+     * @param sourcePath Source file path
+     * @param destDir Destination directory path
+     * @param newName New file name (optional, keeps original name if not provided)
+     */
+    async copyFile(sourcePath: string, destDir: string, newName?: string): Promise<void> {
+        // Read source file
+        const content = await this.readExternalFile(sourcePath);
+
+        // Get source file name if newName not provided
+        const fileName = newName || sourcePath.split('/').pop() || 'file';
+
+        // Write to destination
+        await this.writeExternalFile(destDir, fileName, content);
+    }
+
+    /**
+     * Moves/renames a file
+     * @param sourcePath Source file path
+     * @param destDir Destination directory path
+     * @param newName New file name (optional, keeps original name if not provided)
+     */
+    async moveFile(sourcePath: string, destDir: string, newName?: string): Promise<void> {
+        // Copy file to destination
+        await this.copyFile(sourcePath, destDir, newName);
+
+        // Delete source file
+        await this.deleteExternalFile(sourcePath);
+    }
+
+    /**
+     * Gets file information (size, modification date, etc.)
+     * @param filePath File path
+     */
+    async getFileInfo(filePath: string): Promise<any> {
+        const fileEntry = await this.resolveLocalFileSystemURL(filePath);
+
+        return new Promise((resolve, reject) => {
+            if (!fileEntry.file) {
+                reject(new Error('file() method not available on entry'));
+                return;
+            }
+
+            fileEntry.file(
+                (fileMetadata: any) => resolve(fileMetadata),
+                (error: any) => reject(error)
+            );
+        });
+    }
+
+    /**
+     * Appends data to an existing file
+     * @param filePath File path
+     * @param data Data to append
+     */
+    async appendToFile(filePath: string, data: ArrayBuffer | string): Promise<void> {
+        // Convert data to string if it's ArrayBuffer
+        let content: string;
+        if (data instanceof ArrayBuffer) {
+            const decoder = new TextDecoder();
+            content = decoder.decode(data);
+        } else {
+            content = data;
+        }
+
+        const fileEntry = await this.resolveLocalFileSystemURL(filePath);
+
+        return new Promise((resolve, reject) => {
+            if (!fileEntry.createWriter) {
+                reject(new Error('createWriter() method not available on file entry'));
+                return;
+            }
+
+            fileEntry.createWriter(
+                (writer: any) => {
+                    writer.onwriteend = () => {
+                        resolve();
+                    };
+                    writer.onerror = (error: any) => {
+                        reject(error);
+                    };
+
+                    // Append the content
+                    writer.append(content);
+                },
+                (error: any) => {
+                    reject(error);
+                }
+            );
+        });
+    }
+
+}