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

package/BuildNo.txt

@@ -1 +1 @@
-R-0.000.0023
+R-0.000.0026

package/dist/device-info/BaseDeviceInfo.d.ts

@@ -6,16 +6,10 @@ import { IDeviceInfo } from './DeviceInfo.types';
 export declare class BaseDeviceInfo {
     private static cachedDeviceInfo;
     /**
-     * Get comprehensive device information (async)
-     * Call this once during app initialization to populate cache
+     * Get comprehensive device information synchronously
+     * Uses synchronous methods from react-native-device-info
      */
-    static getDeviceInfo(): Promise<IDeviceInfo>;
-    /**
-     * Get device information synchronously (returns cached data)
-     * Returns loading state if not yet initialized
-     * Call getDeviceInfo() first to populate cache
-     */
-    static getDeviceInfoSync(): IDeviceInfo;
+    static getDeviceInfo(): IDeviceInfo;
     /**
      * Get platform name
      */

package/dist/device-info/BaseDeviceInfo.js

@@ -8,27 +8,29 @@ import DeviceInfo from 'react-native-device-info';
  */
 export class BaseDeviceInfo {
     /**
-     * Get comprehensive device information (async)
-     * Call this once during app initialization to populate cache
+     * Get comprehensive device information synchronously
+     * Uses synchronous methods from react-native-device-info
      */
-    static async getDeviceInfo() {
+    static getDeviceInfo() {
         if (this.cachedDeviceInfo) {
             return this.cachedDeviceInfo;
         }
         try {
+            // Use synchronous methods from react-native-device-info
             const deviceInfo = {
                 platform: Platform.OS,
-                model: await DeviceInfo.getModel(),
+                model: DeviceInfo.getModel(),
                 version: Platform.Version.toString(),
                 isMobile: Platform.OS === 'ios' || Platform.OS === 'android',
-                manufacturer: await DeviceInfo.getManufacturer(),
-                uuid: await DeviceInfo.getUniqueId(),
+                manufacturer: DeviceInfo.getManufacturerSync(),
+                uuid: DeviceInfo.getUniqueIdSync(),
             };
             this.cachedDeviceInfo = deviceInfo;
             return deviceInfo;
         }
         catch (error) {
             console.error('Error getting device info:', error);
+            // Return fallback with synchronous Platform data
             const fallback = {
                 platform: Platform.OS,
                 model: 'Unknown',
@@ -39,23 +41,6 @@ export class BaseDeviceInfo {
             return fallback;
         }
     }
-    /**
-     * Get device information synchronously (returns cached data)
-     * Returns loading state if not yet initialized
-     * Call getDeviceInfo() first to populate cache
-     */
-    static getDeviceInfoSync() {
-        if (this.cachedDeviceInfo) {
-            return this.cachedDeviceInfo;
-        }
-        // Return immediate fallback while async initialization happens
-        return {
-            platform: Platform.OS,
-            model: 'Loading...',
-            version: Platform.Version.toString(),
-            isMobile: Platform.OS === 'ios' || Platform.OS === 'android',
-        };
-    }
     /**
      * Get platform name
      */

package/dist/file-system/FileSystem.d.ts

@@ -1,4 +1,44 @@
-import { IFileEntry, FileSystemEncoding } from './FileSystem.types';
+/**
+ * File entry interface
+ */
+export interface IDirectoryReader {
+    readEntries(successCallback: (entries: IFileEntry[]) => void, errorCallback: (error: any) => void): void;
+}
+export interface IFileEntry {
+    isFile: boolean;
+    isDirectory: boolean;
+    name: string;
+    fullPath: string;
+    filesystem?: any;
+    nativeURL: string;
+    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: any) => void, errorCallback: (error: any) => void): void;
+    createWriter?(callback: (writer: any) => void, errorCallback: (error: any) => void): void;
+}
+export type FileSystemEncoding = 'utf8' | 'ascii' | 'base64';
+export interface IFileSystem {
+    getDocumentDirectory(): string;
+    resolveLocalFileSystemURL(url: string): Promise<IFileEntry>;
+    getFolderBasedOnUserId(userId: string): Promise<string>;
+    deleteUserFolder(userId: string): Promise<void>;
+    createDirectory(path: string): Promise<void>;
+    readFile(path: string, encoding?: FileSystemEncoding): Promise<string>;
+    writeFile(path: string, content: string, encoding?: FileSystemEncoding): Promise<void>;
+    deleteFile(path: string): Promise<void>;
+    exists(path: string): Promise<boolean>;
+    stat(path: string): Promise<any>;
+    readDir(path: string): Promise<any[]>;
+    copyFile(source: string, destination: string): Promise<void>;
+    moveFile(source: string, destination: string): Promise<void>;
+}
 /**
  * FileSystem class
  * Handles file system operations for React Native
@@ -59,5 +99,4 @@ export declare class FileSystem {
      */
     static moveFile(source: string, destination: string): Promise<void>;
 }
-export type { IFileEntry } from './FileSystem.types';
 export default FileSystem;

package/dist/file-system/index.d.ts

@@ -1,3 +1,3 @@
 export { FileSystem } from './FileSystem';
-export type { IFileEntry, IDirectoryReader } from './FileSystem.types';
+export type { IFileEntry, IDirectoryReader } from './FileSystem';
 export { default } from './FileSystem';

package/dist/file-system/services/FileSystemNative.d.ts

@@ -1,5 +1,5 @@
 import * as RNFS from 'react-native-fs';
-import { IFileEntry, IFileSystem, FileSystemEncoding } from '../FileSystem.types';
+import type { IFileEntry, IFileSystem, FileSystemEncoding } from '../FileSystem';
 export declare class FileSystemNative implements IFileSystem {
     getDocumentDirectory(): string;
     resolveLocalFileSystemURL(url: string): Promise<IFileEntry>;

package/dist/file-system/services/FileSystemNative.js

@@ -1,5 +1,182 @@
 import * as RNFS from 'react-native-fs';
-import { RNFileEntry } from '../RNFileEntry';
+/**
+ * DirectoryReader implementation for React Native
+ * Wraps RNFS.readDir to match the Cordova DirectoryReader interface
+ */
+class RNDirectoryReader {
+    constructor(dirPath) {
+        this.dirPath = dirPath;
+    }
+    readEntries(callback, errorCallback) {
+        RNFS.readDir(this.dirPath)
+            .then(items => {
+            const entries = items.map(item => new RNFileEntry(item.path, item.isDirectory()));
+            callback(entries);
+        })
+            .catch(errorCallback);
+    }
+}
+/**
+ * FileEntry implementation for React Native
+ * Wraps react-native-fs to match the Cordova FileEntry interface
+ */
+class RNFileEntry {
+    constructor(path, isDirectory = false) {
+        this.fullPath = path;
+        this.nativeURL = `file://${path}`;
+        this.isDirectory = isDirectory;
+        this.isFile = !isDirectory;
+        this.name = path.split('/').pop() || '';
+        this.filesystem = null;
+    }
+    /**
+     * Remove a file or empty directory
+     */
+    remove(callback, errorCallback) {
+        RNFS.unlink(this.fullPath)
+            .then(() => callback())
+            .catch(errorCallback);
+    }
+    /**
+     * Remove a directory and all its contents recursively
+     */
+    removeRecursively(callback, errorCallback) {
+        // RNFS.unlink works recursively for directories
+        RNFS.unlink(this.fullPath)
+            .then(() => callback())
+            .catch(errorCallback);
+    }
+    /**
+     * Create a directory reader for reading directory contents
+     */
+    createReader() {
+        return new RNDirectoryReader(this.fullPath);
+    }
+    /**
+     * Get or create a subdirectory
+     */
+    getDirectory(path, options, callback, errorCallback) {
+        const dirPath = `${this.fullPath}/${path}`;
+        RNFS.exists(dirPath)
+            .then(exists => {
+            if (exists) {
+                return RNFS.stat(dirPath).then(stats => {
+                    if (stats.isDirectory()) {
+                        callback(new RNFileEntry(dirPath, true));
+                    }
+                    else {
+                        errorCallback(new Error('Path exists but is not a directory'));
+                    }
+                });
+            }
+            else if (options.create) {
+                return RNFS.mkdir(dirPath).then(() => {
+                    callback(new RNFileEntry(dirPath, true));
+                });
+            }
+            else {
+                errorCallback(new Error('Directory does not exist'));
+            }
+        })
+            .catch(errorCallback);
+    }
+    /**
+     * Get or create a file
+     */
+    getFile(path, options, callback, errorCallback) {
+        const filePath = `${this.fullPath}/${path}`;
+        RNFS.exists(filePath)
+            .then(exists => {
+            if (exists) {
+                return RNFS.stat(filePath).then(stats => {
+                    if (!stats.isDirectory()) {
+                        callback(new RNFileEntry(filePath, false));
+                    }
+                    else {
+                        errorCallback(new Error('Path exists but is a directory'));
+                    }
+                });
+            }
+            else if (options.create) {
+                // Create empty file
+                return RNFS.writeFile(filePath, '', 'utf8').then(() => {
+                    callback(new RNFileEntry(filePath, false));
+                });
+            }
+            else {
+                errorCallback(new Error('File does not exist'));
+            }
+        })
+            .catch(errorCallback);
+    }
+    /**
+     * Get file metadata
+     */
+    file(callback, errorCallback) {
+        RNFS.stat(this.fullPath)
+            .then(stats => {
+            // Create a File-like object with metadata
+            const fileObject = {
+                name: this.fullPath.split('/').pop() || '',
+                size: stats.size,
+                type: '', // RNFS doesn't provide MIME type directly
+                lastModified: new Date(stats.mtime).getTime(),
+                lastModifiedDate: new Date(stats.mtime),
+                path: this.fullPath,
+            };
+            callback(fileObject);
+        })
+            .catch(errorCallback);
+    }
+    /**
+     * Create a file writer for writing to the file
+     */
+    createWriter(callback, errorCallback) {
+        // Create a FileWriter-like object
+        const writer = {
+            filePath: this.fullPath,
+            write: (data) => {
+                return RNFS.writeFile(this.fullPath, data, 'utf8')
+                    .then(() => { if (writer.onwriteend)
+                    writer.onwriteend(); })
+                    .catch((err) => { if (writer.onerror)
+                    writer.onerror(err); });
+            },
+            append: (data) => {
+                return RNFS.appendFile(this.fullPath, data, 'utf8')
+                    .then(() => { if (writer.onwriteend)
+                    writer.onwriteend(); })
+                    .catch((err) => { if (writer.onerror)
+                    writer.onerror(err); });
+            },
+            truncate: (size) => {
+                // Read file, truncate content, and write back
+                return RNFS.readFile(this.fullPath, 'utf8')
+                    .then(content => {
+                    const truncated = content.substring(0, size);
+                    return RNFS.writeFile(this.fullPath, truncated, 'utf8')
+                        .then(() => { if (writer.onwriteend)
+                        writer.onwriteend(); });
+                })
+                    .catch((err) => { if (writer.onerror)
+                    writer.onerror(err); });
+            },
+            seek: (offset) => {
+                // Not directly supported in RNFS
+                // This would need to be implemented with read/write operations
+                return Promise.resolve();
+            },
+            onwriteend: null,
+            onerror: null
+        };
+        try {
+            callback(writer);
+        }
+        catch (error) {
+            errorCallback(error);
+        }
+    }
+}
 export class FileSystemNative {
     getDocumentDirectory() {
         return RNFS.DocumentDirectoryPath;

package/dist/file-system/services/FileSystemWeb.d.ts

@@ -1,4 +1,4 @@
-import { IFileEntry, IFileSystem, FileSystemEncoding } from '../FileSystem.types';
+import type { IFileEntry, IFileSystem, FileSystemEncoding } from '../FileSystem';
 export declare class FileSystemWeb implements IFileSystem {
     getDocumentDirectory(): string;
     resolveLocalFileSystemURL(url: string): Promise<IFileEntry>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unvired/react-native-unvired-sdk",
-  "version": "0.0.23",
+  "version": "0.0.26",
   "description": "Unvired SDK for React Native with logging, database, notifications, and file system support",
   "main": "dist/main.js",
   "types": "dist/main.d.ts",

package/ts-core/PlatformInterface.ts

@@ -85,7 +85,7 @@ export interface ILocalStorageAdapter {
  */
 export interface PlatformInterface {
     // Device Information
-    getDeviceInfo(): Promise<IDeviceInfo>;
+    getDeviceInfo(): IDeviceInfo;
     getPlatform(): string;
     getFrontendType(): string;
     getDocumentDirectory(): string;

package/ts-core/ReactNativePlatformAdapter.ts

@@ -3,8 +3,8 @@ import { PlatformInterface, IDeviceInfo, IFileEntry, IDatabaseAdapter, IPushNoti
 
 export class ReactNativePlatformAdapter implements PlatformInterface {
 
-    async getDeviceInfo(): Promise<IDeviceInfo> {
-        return await DeviceInfo.getDeviceInfo();
+    getDeviceInfo(): IDeviceInfo {
+        return DeviceInfo.getDeviceInfo();
     }
 
     getPlatform(): string {

package/dist/file-system/FileSystem.types.d.ts

@@ -1,41 +0,0 @@
-/**
- * File entry interface
- */
-export interface IDirectoryReader {
-    readEntries(successCallback: (entries: IFileEntry[]) => void, errorCallback: (error: any) => void): void;
-}
-export interface IFileEntry {
-    isFile: boolean;
-    isDirectory: boolean;
-    name: string;
-    fullPath: string;
-    filesystem?: any;
-    nativeURL: string;
-    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: any) => void, errorCallback: (error: any) => void): void;
-    createWriter?(callback: (writer: any) => void, errorCallback: (error: any) => void): void;
-}
-export type FileSystemEncoding = 'utf8' | 'ascii' | 'base64';
-export interface IFileSystem {
-    getDocumentDirectory(): string;
-    resolveLocalFileSystemURL(url: string): Promise<IFileEntry>;
-    getFolderBasedOnUserId(userId: string): Promise<string>;
-    deleteUserFolder(userId: string): Promise<void>;
-    createDirectory(path: string): Promise<void>;
-    readFile(path: string, encoding?: FileSystemEncoding): Promise<string>;
-    writeFile(path: string, content: string, encoding?: FileSystemEncoding): Promise<void>;
-    deleteFile(path: string): Promise<void>;
-    exists(path: string): Promise<boolean>;
-    stat(path: string): Promise<any>;
-    readDir(path: string): Promise<any[]>;
-    copyFile(source: string, destination: string): Promise<void>;
-    moveFile(source: string, destination: string): Promise<void>;
-}

package/dist/file-system/FileSystem.types.js

@@ -1,3 +0,0 @@
-// FileSystem.types.ts
-// Type definitions for file system module
-export {};

package/dist/file-system/RNFileEntry.d.ts

@@ -1,55 +0,0 @@
-import { IFileEntry, IDirectoryReader } from './FileSystem.types';
-/**
- * DirectoryReader implementation for React Native
- * Wraps RNFS.readDir to match the Cordova DirectoryReader interface
- */
-export declare class RNDirectoryReader implements IDirectoryReader {
-    private dirPath;
-    constructor(dirPath: string);
-    readEntries(callback: (entries: IFileEntry[]) => void, errorCallback: (error: any) => void): void;
-}
-/**
- * FileEntry implementation for React Native
- * Wraps react-native-fs to match the Cordova FileEntry interface
- */
-export declare class RNFileEntry implements IFileEntry {
-    isFile: boolean;
-    isDirectory: boolean;
-    name: string;
-    fullPath: string;
-    nativeURL: string;
-    filesystem: any;
-    constructor(path: string, isDirectory?: boolean);
-    /**
-     * Remove a file or empty directory
-     */
-    remove(callback: () => void, errorCallback: (error: any) => void): void;
-    /**
-     * Remove a directory and all its contents recursively
-     */
-    removeRecursively(callback: () => void, errorCallback: (error: any) => void): void;
-    /**
-     * Create a directory reader for reading directory contents
-     */
-    createReader(): IDirectoryReader;
-    /**
-     * Get or create a subdirectory
-     */
-    getDirectory(path: string, options: {
-        create: boolean;
-    }, callback: (entry: IFileEntry) => void, errorCallback: (error: any) => void): void;
-    /**
-     * Get or create a file
-     */
-    getFile(path: string, options: {
-        create: boolean;
-    }, callback: (entry: IFileEntry) => void, errorCallback: (error: any) => void): void;
-    /**
-     * Get file metadata
-     */
-    file(callback: (file: any) => void, errorCallback: (error: any) => void): void;
-    /**
-     * Create a file writer for writing to the file
-     */
-    createWriter(callback: (writer: any) => void, errorCallback: (error: any) => void): void;
-}

package/dist/file-system/RNFileEntry.js

@@ -1,179 +0,0 @@
-import * as RNFS from 'react-native-fs';
-/**
- * DirectoryReader implementation for React Native
- * Wraps RNFS.readDir to match the Cordova DirectoryReader interface
- */
-export class RNDirectoryReader {
-    constructor(dirPath) {
-        this.dirPath = dirPath;
-    }
-    readEntries(callback, errorCallback) {
-        RNFS.readDir(this.dirPath)
-            .then(items => {
-            const entries = items.map(item => new RNFileEntry(item.path, item.isDirectory()));
-            callback(entries);
-        })
-            .catch(errorCallback);
-    }
-}
-/**
- * FileEntry implementation for React Native
- * Wraps react-native-fs to match the Cordova FileEntry interface
- */
-export class RNFileEntry {
-    constructor(path, isDirectory = false) {
-        this.fullPath = path;
-        this.nativeURL = `file://${path}`;
-        this.isDirectory = isDirectory;
-        this.isFile = !isDirectory;
-        this.name = path.split('/').pop() || '';
-        this.filesystem = null;
-    }
-    /**
-     * Remove a file or empty directory
-     */
-    remove(callback, errorCallback) {
-        RNFS.unlink(this.fullPath)
-            .then(() => callback())
-            .catch(errorCallback);
-    }
-    /**
-     * Remove a directory and all its contents recursively
-     */
-    removeRecursively(callback, errorCallback) {
-        // RNFS.unlink works recursively for directories
-        RNFS.unlink(this.fullPath)
-            .then(() => callback())
-            .catch(errorCallback);
-    }
-    /**
-     * Create a directory reader for reading directory contents
-     */
-    createReader() {
-        return new RNDirectoryReader(this.fullPath);
-    }
-    /**
-     * Get or create a subdirectory
-     */
-    getDirectory(path, options, callback, errorCallback) {
-        const dirPath = `${this.fullPath}/${path}`;
-        RNFS.exists(dirPath)
-            .then(exists => {
-            if (exists) {
-                return RNFS.stat(dirPath).then(stats => {
-                    if (stats.isDirectory()) {
-                        callback(new RNFileEntry(dirPath, true));
-                    }
-                    else {
-                        errorCallback(new Error('Path exists but is not a directory'));
-                    }
-                });
-            }
-            else if (options.create) {
-                return RNFS.mkdir(dirPath).then(() => {
-                    callback(new RNFileEntry(dirPath, true));
-                });
-            }
-            else {
-                errorCallback(new Error('Directory does not exist'));
-            }
-        })
-            .catch(errorCallback);
-    }
-    /**
-     * Get or create a file
-     */
-    getFile(path, options, callback, errorCallback) {
-        const filePath = `${this.fullPath}/${path}`;
-        RNFS.exists(filePath)
-            .then(exists => {
-            if (exists) {
-                return RNFS.stat(filePath).then(stats => {
-                    if (!stats.isDirectory()) {
-                        callback(new RNFileEntry(filePath, false));
-                    }
-                    else {
-                        errorCallback(new Error('Path exists but is a directory'));
-                    }
-                });
-            }
-            else if (options.create) {
-                // Create empty file
-                return RNFS.writeFile(filePath, '', 'utf8').then(() => {
-                    callback(new RNFileEntry(filePath, false));
-                });
-            }
-            else {
-                errorCallback(new Error('File does not exist'));
-            }
-        })
-            .catch(errorCallback);
-    }
-    /**
-     * Get file metadata
-     */
-    file(callback, errorCallback) {
-        RNFS.stat(this.fullPath)
-            .then(stats => {
-            // Create a File-like object with metadata
-            const fileObject = {
-                name: this.fullPath.split('/').pop() || '',
-                size: stats.size,
-                type: '', // RNFS doesn't provide MIME type directly
-                lastModified: new Date(stats.mtime).getTime(),
-                lastModifiedDate: new Date(stats.mtime),
-                path: this.fullPath,
-            };
-            callback(fileObject);
-        })
-            .catch(errorCallback);
-    }
-    /**
-     * Create a file writer for writing to the file
-     */
-    createWriter(callback, errorCallback) {
-        // Create a FileWriter-like object
-        const writer = {
-            filePath: this.fullPath,
-            write: (data) => {
-                return RNFS.writeFile(this.fullPath, data, 'utf8')
-                    .then(() => { if (writer.onwriteend)
-                    writer.onwriteend(); })
-                    .catch((err) => { if (writer.onerror)
-                    writer.onerror(err); });
-            },
-            append: (data) => {
-                return RNFS.appendFile(this.fullPath, data, 'utf8')
-                    .then(() => { if (writer.onwriteend)
-                    writer.onwriteend(); })
-                    .catch((err) => { if (writer.onerror)
-                    writer.onerror(err); });
-            },
-            truncate: (size) => {
-                // Read file, truncate content, and write back
-                return RNFS.readFile(this.fullPath, 'utf8')
-                    .then(content => {
-                    const truncated = content.substring(0, size);
-                    return RNFS.writeFile(this.fullPath, truncated, 'utf8')
-                        .then(() => { if (writer.onwriteend)
-                        writer.onwriteend(); });
-                })
-                    .catch((err) => { if (writer.onerror)
-                    writer.onerror(err); });
-            },
-            seek: (offset) => {
-                // Not directly supported in RNFS
-                // This would need to be implemented with read/write operations
-                return Promise.resolve();
-            },
-            onwriteend: null,
-            onerror: null
-        };
-        try {
-            callback(writer);
-        }
-        catch (error) {
-            errorCallback(error);
-        }
-    }
-}

package/ts-core/ReactNativeFileEntry.ts

@@ -1,208 +0,0 @@
-import RNFS from 'react-native-fs';
-export interface IDirectoryReader {
-    readEntries(callback: (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;
-}
-/**
- * DirectoryReader implementation for React Native
- * Wraps RNFS.readDir to match the Cordova DirectoryReader interface
- */
-export class ReactNativeDirectoryReader implements IDirectoryReader {
-    private dirPath: string;
-
-    constructor(dirPath: string) {
-        this.dirPath = dirPath;
-    }
-
-    readEntries(
-        callback: (entries: IFileEntry[]) => void,
-        errorCallback: (error: any) => void
-    ): void {
-        RNFS.readDir(this.dirPath)
-            .then(items => {
-                const entries = items.map(item =>
-                    new ReactNativeFileEntry(item.path, item.isDirectory())
-                );
-                callback(entries);
-            })
-            .catch(errorCallback);
-    }
-}
-
-/**
- * FileEntry implementation for React Native
- * Wraps react-native-fs to match the Cordova FileEntry interface
- */
-export class ReactNativeFileEntry implements IFileEntry {
-    fullPath: string;
-    nativeURL: string;
-    isDirectory?: boolean;
-
-    constructor(path: string, isDirectory: boolean = false) {
-        this.fullPath = path;
-        this.nativeURL = `file://${path}`;
-        this.isDirectory = isDirectory;
-    }
-
-    /**
-     * Remove a file or empty directory
-     */
-    remove(callback: () => void, errorCallback: (error: any) => void): void {
-        RNFS.unlink(this.fullPath)
-            .then(() => callback())
-            .catch(errorCallback);
-    }
-
-    /**
-     * Remove a directory and all its contents recursively
-     */
-    removeRecursively(callback: () => void, errorCallback: (error: any) => void): void {
-        // RNFS.unlink works recursively for directories
-        RNFS.unlink(this.fullPath)
-            .then(() => callback())
-            .catch(errorCallback);
-    }
-
-    /**
-     * Create a directory reader for reading directory contents
-     */
-    createReader(): IDirectoryReader {
-        return new ReactNativeDirectoryReader(this.fullPath);
-    }
-
-    /**
-     * Get or create a subdirectory
-     */
-    getDirectory(
-        path: string,
-        options: { create: boolean },
-        callback: (entry: IFileEntry) => void,
-        errorCallback: (error: any) => void
-    ): void {
-        const dirPath = `${this.fullPath}/${path}`;
-
-        RNFS.exists(dirPath)
-            .then(exists => {
-                if (exists) {
-                    return RNFS.stat(dirPath).then(stats => {
-                        if (stats.isDirectory()) {
-                            callback(new ReactNativeFileEntry(dirPath, true));
-                        } else {
-                            errorCallback(new Error('Path exists but is not a directory'));
-                        }
-                    });
-                } else if (options.create) {
-                    return RNFS.mkdir(dirPath).then(() => {
-                        callback(new ReactNativeFileEntry(dirPath, true));
-                    });
-                } else {
-                    errorCallback(new Error('Directory does not exist'));
-                }
-            })
-            .catch(errorCallback);
-    }
-
-    /**
-     * Get or create a file
-     */
-    getFile(
-        path: string,
-        options: { create: boolean },
-        callback: (entry: IFileEntry) => void,
-        errorCallback: (error: any) => void
-    ): void {
-        const filePath = `${this.fullPath}/${path}`;
-
-        RNFS.exists(filePath)
-            .then(exists => {
-                if (exists) {
-                    return RNFS.stat(filePath).then(stats => {
-                        if (!stats.isDirectory()) {
-                            callback(new ReactNativeFileEntry(filePath, false));
-                        } else {
-                            errorCallback(new Error('Path exists but is a directory'));
-                        }
-                    });
-                } else if (options.create) {
-                    // Create empty file
-                    return RNFS.writeFile(filePath, '', 'utf8').then(() => {
-                        callback(new ReactNativeFileEntry(filePath, false));
-                    });
-                } else {
-                    errorCallback(new Error('File does not exist'));
-                }
-            })
-            .catch(errorCallback);
-    }
-
-    /**
-     * Get file metadata
-     */
-    file(callback: (file: File) => void, errorCallback: (error: any) => void): void {
-        RNFS.stat(this.fullPath)
-            .then(stats => {
-                // Create a File-like object with metadata
-                const fileObject: any = {
-                    name: this.fullPath.split('/').pop() || '',
-                    size: stats.size,
-                    type: '', // RNFS doesn't provide MIME type directly
-                    lastModified: new Date(stats.mtime).getTime(),
-                    lastModifiedDate: new Date(stats.mtime),
-                    path: this.fullPath,
-                };
-                callback(fileObject as File);
-            })
-            .catch(errorCallback);
-    }
-
-    /**
-     * Create a file writer for writing to the file
-     */
-    createWriter(callback: (writer: any) => void, errorCallback: (error: any) => void): void {
-        // Create a FileWriter-like object
-        const writer = {
-            filePath: this.fullPath,
-
-            write: (data: string) => {
-                return RNFS.writeFile(this.fullPath, data, 'utf8');
-            },
-
-            append: (data: string) => {
-                return RNFS.appendFile(this.fullPath, data, 'utf8');
-            },
-
-            truncate: (size: number) => {
-                // Read file, truncate content, and write back
-                return RNFS.readFile(this.fullPath, 'utf8')
-                    .then(content => {
-                        const truncated = content.substring(0, size);
-                        return RNFS.writeFile(this.fullPath, truncated, 'utf8');
-                    });
-            },
-
-            seek: (offset: number) => {
-                // Not directly supported in RNFS
-                // This would need to be implemented with read/write operations
-                return Promise.resolve();
-            }
-        };
-
-        try {
-            callback(writer);
-        } catch (error) {
-            errorCallback(error);
-        }
-    }
-}