@unvired/react-native-unvired-sdk 0.0.15 → 0.0.16

package/BuildNo.txt

@@ -1 +1 @@
-R-0.000.0015
+R-0.000.0016

package/dist/database/DatabaseManager.d.ts

@@ -1,7 +1,7 @@
 import { IDatabaseAdapter } from './types';
 /**
  * DatabaseManager - Manages database operations across platforms
- * - iOS/Android/Windows: Uses react-native-sqlite-storage
+ * - iOS/Android/Windows: Uses @op-engineering/op-sqlite
  * - Web: Uses WebSQL
  */
 export declare class DatabaseManager {

package/dist/database/DatabaseManager.js

@@ -5,7 +5,7 @@ import { DatabaseWeb } from './services/DatabaseWeb';
 const dbImpl = Platform.OS === 'web' ? new DatabaseWeb() : new DatabaseNative();
 /**
  * DatabaseManager - Manages database operations across platforms
- * - iOS/Android/Windows: Uses react-native-sqlite-storage
+ * - iOS/Android/Windows: Uses @op-engineering/op-sqlite
  * - Web: Uses WebSQL
  */
 export class DatabaseManager {

package/dist/database/services/DatabaseNative.d.ts

@@ -3,6 +3,5 @@ export declare class DatabaseNative {
     private databases;
     private defaultLocation;
     private getDatabase;
-    private resultSetToArray;
     getAdapter(): IDatabaseAdapter;
 }

package/dist/database/services/DatabaseNative.js

@@ -1,33 +1,27 @@
-import SQLite from "react-native-sqlite-storage";
-SQLite.enablePromise(true);
-SQLite.DEBUG(false);
+import { open } from '@op-engineering/op-sqlite';
 export class DatabaseNative {
     constructor() {
         this.databases = new Map();
         this.defaultLocation = "default";
     }
-    async getDatabase(name, location) {
+    getDatabase(name, location) {
         const dbKey = `${name}_${location || this.defaultLocation}`;
         if (this.databases.has(dbKey)) {
             return this.databases.get(dbKey);
         }
-        const dbLocation = (location || this.defaultLocation);
-        const db = await SQLite.openDatabase({ name, location: dbLocation });
+        // @op-engineering/op-sqlite open function
+        // We treat location as mainly advisory since op-sqlite defaults to valid paths.
+        // If strict paths are needed, we would need to construct absolute path using FS.
+        // For now, we rely on the name.
+        const db = open({ name });
         this.databases.set(dbKey, db);
         return db;
     }
-    resultSetToArray(resultSet) {
-        const results = [];
-        for (let i = 0; i < resultSet.rows.length; i++) {
-            results.push(resultSet.rows.item(i));
-        }
-        return results;
-    }
     getAdapter() {
         return {
             create: async (options, successCallback, errorCallback) => {
                 try {
-                    await this.getDatabase(options.name, options.location);
+                    this.getDatabase(options.name, options.location);
                     successCallback({ success: true, database: options.name });
                 }
                 catch (error) {
@@ -35,61 +29,43 @@ export class DatabaseNative {
                 }
             },
             execute: async (options, successCallback, errorCallback) => {
+                var _a;
                 try {
-                    const db = await this.getDatabase(options.dbName);
-                    const results = await new Promise((resolve, reject) => {
-                        db.transaction((tx) => {
-                            tx.executeSql(options.query, options.params || [], (_, resultSet) => {
-                                resolve(this.resultSetToArray(resultSet));
-                            }, (_, error) => {
-                                reject(error);
-                                return false;
-                            });
-                        });
-                    });
-                    successCallback(results);
+                    const db = this.getDatabase(options.dbName);
+                    const res = db.execute(options.query, options.params);
+                    // op-sqlite v15+ returns rows as an array natively in most configurations
+                    // Check for _array for backward compatibility with some bridges or older habits
+                    // @ts-ignore
+                    const rows = ((_a = res.rows) === null || _a === void 0 ? void 0 : _a._array) || res.rows || [];
+                    successCallback(rows);
                 }
                 catch (error) {
                     errorCallback(error instanceof Error ? error.message : String(error));
                 }
             },
             executeStatementOnPath: async (dbPath, sqlQuery, callback) => {
-                var _a;
+                var _a, _b;
                 try {
                     const dbName = ((_a = dbPath.split("/").pop()) === null || _a === void 0 ? void 0 : _a.replace(".db", "")) || "default";
-                    const db = await this.getDatabase(dbName);
-                    const results = await new Promise((resolve) => {
-                        db.transaction((tx) => {
-                            tx.executeSql(sqlQuery, [], (_, resultSet) => {
-                                resolve(this.resultSetToArray(resultSet));
-                            }, () => {
-                                resolve([]);
-                                return false;
-                            });
-                        });
-                    });
-                    callback(results);
+                    const db = this.getDatabase(dbName);
+                    const res = db.execute(sqlQuery);
+                    // @ts-ignore
+                    const rows = ((_b = res.rows) === null || _b === void 0 ? void 0 : _b._array) || res.rows || [];
+                    callback(rows);
                 }
                 catch (error) {
                     callback([]);
                 }
             },
             selectFromPath: async (dbPath, sqlQuery, callback) => {
-                var _a;
+                var _a, _b;
                 try {
                     const dbName = ((_a = dbPath.split("/").pop()) === null || _a === void 0 ? void 0 : _a.replace(".db", "")) || "default";
-                    const db = await this.getDatabase(dbName);
-                    const results = await new Promise((resolve) => {
-                        db.readTransaction((tx) => {
-                            tx.executeSql(sqlQuery, [], (_, resultSet) => {
-                                resolve(this.resultSetToArray(resultSet));
-                            }, () => {
-                                resolve([]);
-                                return false;
-                            });
-                        });
-                    });
-                    callback(results);
+                    const db = this.getDatabase(dbName);
+                    const res = db.execute(sqlQuery);
+                    // @ts-ignore
+                    const rows = ((_b = res.rows) === null || _b === void 0 ? void 0 : _b._array) || res.rows || [];
+                    callback(rows);
                 }
                 catch (error) {
                     callback([]);
@@ -99,7 +75,7 @@ export class DatabaseNative {
                 var _a;
                 try {
                     const dbName = ((_a = dbPath.split("/").pop()) === null || _a === void 0 ? void 0 : _a.replace(".db", "")) || "default";
-                    await this.getDatabase(dbName);
+                    this.getDatabase(dbName);
                     callback();
                 }
                 catch (error) {
@@ -125,19 +101,12 @@ export class DatabaseNative {
             },
             deleteUserData: async (options, callback, errorCallback) => {
                 try {
-                    const db = await this.getDatabase(options.dbName);
-                    await new Promise((resolve, reject) => {
-                        db.transaction((tx) => {
-                            const query = options.userId
-                                ? "DELETE FROM user_data WHERE user_id = ?"
-                                : "DELETE FROM user_data";
-                            const params = options.userId ? [options.userId] : [];
-                            tx.executeSql(query, params, () => resolve(), (_, error) => {
-                                reject(error);
-                                return false;
-                            });
-                        });
-                    });
+                    const db = this.getDatabase(options.dbName);
+                    const query = options.userId
+                        ? "DELETE FROM user_data WHERE user_id = ?"
+                        : "DELETE FROM user_data";
+                    const params = options.userId ? [options.userId] : [];
+                    db.execute(query, params);
                     callback();
                 }
                 catch (error) {

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

@@ -2,7 +2,7 @@ import { IFileEntry, FileSystemEncoding } from './FileSystem.types';
 /**
  * FileSystem class
  * Handles file system operations for React Native
- * - iOS/Android/Windows: Uses @dr.pogodin/react-native-fs
+ * - iOS/Android/Windows: Uses react-native-fs
  * - Web: Limited functionality (not supported)
  */
 export declare class FileSystem {

package/dist/file-system/FileSystem.js

@@ -6,7 +6,7 @@ const fsImpl = Platform.OS === 'web' ? new FileSystemWeb() : new FileSystemNativ
 /**
  * FileSystem class
  * Handles file system operations for React Native
- * - iOS/Android/Windows: Uses @dr.pogodin/react-native-fs
+ * - iOS/Android/Windows: Uses react-native-fs
  * - Web: Limited functionality (not supported)
  */
 export class FileSystem {

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

@@ -1,4 +1,17 @@
 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;
@@ -6,21 +19,37 @@ export declare class RNFileEntry implements IFileEntry {
     fullPath: string;
     nativeURL: string;
     filesystem: any;
-    constructor(isFile: boolean, isDirectory: boolean, name: string, fullPath: string, nativeURL: string, filesystem?: any);
-    remove(successCallback: () => void, errorCallback: (error: any) => void): void;
-    removeRecursively(successCallback: () => void, errorCallback: (error: any) => void): void;
+    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;
-    }, successCallback: (entry: IFileEntry) => void, errorCallback: (error: any) => void): void;
+    }, callback: (entry: IFileEntry) => void, errorCallback: (error: any) => void): void;
+    /**
+     * Get or create a file
+     */
     getFile(path: string, options: {
         create: boolean;
-    }, successCallback: (entry: IFileEntry) => void, errorCallback: (error: any) => void): void;
+    }, 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;
 }
-export declare class RNDirectoryReader implements IDirectoryReader {
-    private localPath;
-    constructor(localPath: string);
-    readEntries(successCallback: (entries: IFileEntry[]) => void, errorCallback: (error: any) => void): void;
-}

package/dist/file-system/RNFileEntry.js

@@ -1,114 +1,179 @@
-import * as RNFS from '@dr.pogodin/react-native-fs';
+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(isFile, isDirectory, name, fullPath, nativeURL, filesystem = null) {
-        this.isFile = isFile;
+    constructor(path, isDirectory = false) {
+        this.fullPath = path;
+        this.nativeURL = `file://${path}`;
         this.isDirectory = isDirectory;
-        this.name = name;
-        this.fullPath = fullPath;
-        this.nativeURL = nativeURL;
-        this.filesystem = filesystem;
+        this.isFile = !isDirectory;
+        this.name = path.split('/').pop() || '';
+        this.filesystem = null;
     }
-    remove(successCallback, errorCallback) {
+    /**
+     * Remove a file or empty directory
+     */
+    remove(callback, errorCallback) {
         RNFS.unlink(this.fullPath)
-            .then(() => successCallback())
-            .catch((err) => errorCallback(err));
+            .then(() => callback())
+            .catch(errorCallback);
     }
-    removeRecursively(successCallback, errorCallback) {
-        this.remove(successCallback, 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);
     }
-    getDirectory(path, options, successCallback, errorCallback) {
-        const newPath = this.fullPath + (this.fullPath.endsWith('/') ? '' : '/') + path;
-        const newNativeURL = "file://" + newPath;
-        if (options.create) {
-            RNFS.mkdir(newPath).then(() => {
-                successCallback(new RNFileEntry(false, true, path, newPath, newNativeURL));
-            }).catch(errorCallback);
-        }
-        else {
-            RNFS.stat(newPath).then(stat => {
-                if (stat.isDirectory()) {
-                    successCallback(new RNFileEntry(false, true, path, newPath, newNativeURL));
-                }
-                else {
-                    errorCallback("Not a directory");
-                }
-            }).catch(errorCallback);
-        }
+    /**
+     * 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);
     }
-    getFile(path, options, successCallback, errorCallback) {
-        const newPath = this.fullPath + (this.fullPath.endsWith('/') ? '' : '/') + path;
-        const newNativeURL = "file://" + newPath;
-        if (options.create) {
-            RNFS.exists(newPath).then(exists => {
-                if (exists) {
-                    successCallback(new RNFileEntry(true, false, path, newPath, newNativeURL));
-                }
-                else {
-                    RNFS.writeFile(newPath, '', 'utf8').then(() => {
-                        successCallback(new RNFileEntry(true, false, path, newPath, newNativeURL));
-                    }).catch(errorCallback);
-                }
-            }).catch(errorCallback);
-        }
-        else {
-            RNFS.stat(newPath).then(stat => {
-                if (stat.isFile()) {
-                    successCallback(new RNFileEntry(true, false, path, newPath, newNativeURL));
-                }
-                else {
-                    errorCallback("Not a file");
-                }
-            }).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(stat => {
-            const file = {
-                name: stat.name,
-                localURL: "file://" + stat.path,
-                type: "",
-                lastModified: stat.mtime ? new Date(stat.mtime).getTime() : 0,
-                lastModifiedDate: stat.mtime,
-                size: stat.size,
-                start: 0,
-                end: stat.size,
-                slice: () => { }
+        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(file);
-        }).catch(errorCallback);
+            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) => {
-                RNFS.writeFile(this.fullPath, data, 'utf8')
+                return RNFS.writeFile(this.fullPath, data, 'utf8')
                     .then(() => { if (writer.onwriteend)
                     writer.onwriteend(); })
                     .catch((err) => { if (writer.onerror)
                     writer.onerror(err); });
             },
-            seek: () => { },
-            truncate: () => { },
+            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
         };
-        callback(writer);
-    }
-}
-export class RNDirectoryReader {
-    constructor(localPath) {
-        this.localPath = localPath;
-    }
-    readEntries(successCallback, errorCallback) {
-        RNFS.readDir(this.localPath)
-            .then((result) => {
-            const entries = result.map(fileStat => {
-                return new RNFileEntry(fileStat.isFile(), fileStat.isDirectory(), fileStat.name || fileStat.path.split('/').pop() || '', fileStat.path, "file://" + fileStat.path);
-            });
-            successCallback(entries);
-        })
-            .catch((err) => errorCallback(err));
+        try {
+            callback(writer);
+        }
+        catch (error) {
+            errorCallback(error);
+        }
     }
 }

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

@@ -1,4 +1,4 @@
-import * as RNFS from '@dr.pogodin/react-native-fs';
+import * as RNFS from 'react-native-fs';
 import { IFileEntry, IFileSystem, FileSystemEncoding } from '../FileSystem.types';
 export declare class FileSystemNative implements IFileSystem {
     getDocumentDirectory(): string;
@@ -10,8 +10,8 @@ export declare class FileSystemNative implements IFileSystem {
     writeFile(path: string, content: string, encoding?: FileSystemEncoding): Promise<void>;
     deleteFile(path: string): Promise<void>;
     exists(path: string): Promise<boolean>;
-    stat(path: string): Promise<RNFS.StatResultT>;
-    readDir(path: string): Promise<RNFS.ReadDirResItemT[]>;
+    stat(path: string): Promise<RNFS.StatResult>;
+    readDir(path: string): Promise<RNFS.ReadDirItem[]>;
     copyFile(source: string, destination: string): Promise<void>;
     moveFile(source: string, destination: string): Promise<void>;
 }

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

@@ -1,35 +1,52 @@
-import * as RNFS from '@dr.pogodin/react-native-fs';
+import * as RNFS from 'react-native-fs';
 import { RNFileEntry } from '../RNFileEntry';
 export class FileSystemNative {
     getDocumentDirectory() {
         return RNFS.DocumentDirectoryPath;
     }
     async resolveLocalFileSystemURL(url) {
-        let normalizedPath = url;
-        if (normalizedPath.startsWith('file://')) {
-            normalizedPath = normalizedPath.substring(7);
-        }
-        const exists = await RNFS.exists(normalizedPath);
-        if (!exists) {
-            throw new Error(`File or directory does not exist: ${normalizedPath}`);
-        }
-        const stat = await RNFS.stat(normalizedPath);
-        const fileName = stat.name || normalizedPath.split('/').pop() || 'unknown';
-        return new RNFileEntry(stat.isFile(), stat.isDirectory(), fileName, stat.path, `file://${stat.path}`);
+        return new Promise((resolve, reject) => {
+            // Remove file:// prefix if present
+            const path = url.replace('file://', '');
+            RNFS.exists(path)
+                .then(exists => {
+                if (!exists) {
+                    reject(new Error(`Path does not exist: ${path}`));
+                    return;
+                }
+                return RNFS.stat(path).then(stats => {
+                    resolve(new RNFileEntry(path, stats.isDirectory()));
+                });
+            })
+                .catch(reject);
+        });
     }
     async getFolderBasedOnUserId(userId) {
-        const userFolder = `${RNFS.DocumentDirectoryPath}/users/${userId}`;
-        const exists = await RNFS.exists(userFolder);
-        if (!exists) {
-            await RNFS.mkdir(userFolder, { NSURLIsExcludedFromBackupKey: true });
+        const userPath = `${RNFS.DocumentDirectoryPath}/${userId}`;
+        try {
+            const exists = await RNFS.exists(userPath);
+            if (!exists) {
+                // Create the directory if it doesn't exist
+                await RNFS.mkdir(userPath);
+            }
+            // Return the native URL format
+            return `file://${userPath}`;
+        }
+        catch (error) {
+            throw new Error(`Failed to get/create folder for user ${userId}: ${error}`);
         }
-        return userFolder;
     }
     async deleteUserFolder(userId) {
-        const userFolder = `${RNFS.DocumentDirectoryPath}/users/${userId}`;
-        const exists = await RNFS.exists(userFolder);
-        if (exists) {
-            await RNFS.unlink(userFolder);
+        const userPath = `${RNFS.DocumentDirectoryPath}/${userId}`;
+        try {
+            const exists = await RNFS.exists(userPath);
+            if (exists) {
+                // RNFS.unlink removes directories recursively
+                await RNFS.unlink(userPath);
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to delete folder for user ${userId}: ${error}`);
         }
     }
     async createDirectory(path) {

package/dist/logger/services/LoggerNative.js

@@ -4,14 +4,14 @@ import { Platform } from 'react-native';
 let RNFS = null;
 let zip = null;
 try {
-    RNFS = require('@dr.pogodin/react-native-fs');
+    RNFS = require('react-native-fs');
     if (!RNFS || !RNFS.DocumentDirectoryPath) {
-        console.error('❌ @dr.pogodin/react-native-fs is not properly linked. Please run: cd ios && pod install (iOS) or rebuild your Android app.');
+        console.error('❌ react-native-fs is not properly linked. Please run: cd ios && pod install (iOS) or rebuild your Android app.');
         RNFS = null;
     }
 }
 catch (e) {
-    console.error('❌ @dr.pogodin/react-native-fs module not found. Please install: npm install @dr.pogodin/react-native-fs');
+    console.error('❌ react-native-fs module not found. Please install: npm install react-native-fs');
 }
 try {
     const zipModule = require('react-native-zip-archive');

package/dist/logger/services/LoggerWindows.js

@@ -2,14 +2,14 @@ import * as pako from 'pako';
 // Import with null safety
 let RNFS = null;
 try {
-    RNFS = require('@dr.pogodin/react-native-fs');
+    RNFS = require('react-native-fs');
     if (!RNFS || !RNFS.DocumentDirectoryPath) {
-        console.error('❌ @dr.pogodin/react-native-fs is not properly linked.');
+        console.error('❌ react-native-fs is not properly linked.');
         RNFS = null;
     }
 }
 catch (e) {
-    console.error('❌ @dr.pogodin/react-native-fs module not found.');
+    console.error('❌ react-native-fs module not found.');
 }
 export class LoggerWindows {
     constructor() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unvired/react-native-unvired-sdk",
-  "version": "0.0.15",
+  "version": "0.0.16",
   "description": "Unvired SDK for React Native with logging, database, notifications, and file system support",
   "main": "dist/main.js",
   "types": "dist/main.d.ts",
@@ -24,13 +24,14 @@
   "author": "Unvired",
   "license": "UNLICENSED",
   "peerDependencies": {
-    "@dr.pogodin/react-native-fs": "^2.36.2",
+    "react-native-fs": "^2.20.0",
     "@react-native-firebase/messaging": "^21.8.1",
-    "react": ">=16.8.0",
-    "react-native": ">=0.60.0",
-    "react-native-device-info": "^14.1.1",
-    "react-native-sqlite-storage": "^6.0.1",
-    "react-native-zip-archive": "^7.0.2"
+    "react": "19.2.0",
+    "react-native": "0.83.1",
+    "react-native-device-info": "^15.0.1",
+    "@op-engineering/op-sqlite": "^15.2.5",
+    "react-native-zip-archive": "^7.0.2",
+    "@react-native-async-storage/async-storage": "^2.2.0"
   },
   "peerDependenciesMeta": {
     "@react-native-firebase/messaging": {
@@ -38,17 +39,24 @@
     }
   },
   "devDependencies": {
-    "@types/react": "^18.0.0",
-    "@types/react-native": "^0.72.0",
-    "@types/react-native-sqlite-storage": "^6.0.5",
+    "@types/react": "^19.0.0",
+    "@types/react-native": "^0.73.0",
     "@types/sql.js": "^1.4.9",
     "eslint": "^8.0.0",
     "jest": "^29.0.0",
     "prettier": "^3.0.0",
-    "typescript": "^5.0.0"
+    "typescript": "^5.0.0",
+    "react-native-fs": "^2.20.0",
+    "@op-engineering/op-sqlite": "^15.2.5",
+    "react-native-zip-archive": "^7.0.2",
+    "@react-native-async-storage/async-storage": "^2.2.0",
+    "react-native-device-info": "^15.0.1",
+    "@react-native-firebase/messaging": "^21.8.1"
+  },
+  "engines": {
+    "node": ">=22.0.0"
   },
   "dependencies": {
-    "@react-native-async-storage/async-storage": "^2.2.0",
     "@types/pako": "^2.0.4",
     "pako": "^2.1.0",
     "sql.js": "^1.10.3"

package/ts-core/PlatformInterface.ts

@@ -0,0 +1,109 @@
+/**
+ * Platform Adapter Interface
+ * 
+ * This interface abstracts platform-specific functionality so that the core SDK
+ * can work with both Cordova and React Native platforms.
+ */
+
+export enum DatabaseType {
+    FrameworkDb = 'FrameworkDb',
+    AppDb = 'AppDb'
+}
+
+export interface IDeviceInfo {
+    platform: string;
+    model: string;
+    version: string;
+    isMobile: boolean;
+}
+
+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 interface IDirectoryReader {
+    readEntries(callback: (entries: IFileEntry[]) => void, errorCallback: (error: any) => void): void;
+}
+
+export interface IDatabaseAdapter {
+    create(options: { userId: string }, successCallback: (result: any) => void, errorCallback: (error: any) => void): void;
+    execute(options: any, successCallback: (result: any) => void, errorCallback: (error: any) => void): void;
+    executeStatementOnPath(dbPath: string, sqlQuery: string, callback: (result: any) => void): void;
+    selectFromPath(dbPath: string, sqlQuery: string, callback: (result: any) => void): void;
+    createDatabase(dbPath: string, callback: () => void): void;
+    getDBFilePath(options: { dbType: string }, callback: (path: string) => void): void;
+    saveWebDB(options: { userId: string }, callback: (result: any) => void, errorCallback: (error: any) => void): void;
+    exportWebDB(options: { userId: string }, callback: (result: any) => void, errorCallback: (error: any) => void): void;
+    deleteUserData(options: { userId: string }, callback: () => void, errorCallback: (error: any) => void): void;
+}
+
+export interface IPushNotificationAdapter {
+    requestPermission(options?: { forceShow: boolean }): Promise<void>;
+    getToken(): Promise<string>;
+    onTokenRefresh(callback: (token: string) => void): void;
+    onMessage(callback: (payload: any) => void): void;
+    onBackgroundMessage(callback: (payload: any) => void): void;
+}
+
+export interface ILoggerAdapter {
+    logDebug(sourceClass: string, method: string, message: string): void;
+    logError(sourceClass: string, method: string, message: string): void;
+    logInfo(sourceClass: string, method: string, message: string): void;
+    setLogLevel(logLevel: string): void;
+    getLogFileURL(): Promise<string>;
+    getLogFileContent(): Promise<string>;
+    getBackupLogFileContent(): Promise<string>;
+    clearLogFile(): void;
+}
+
+export interface IStorageAdapter {
+    getItem(key: string): void;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+    clear(): void;
+}
+
+
+
+export interface ILocalStorageAdapter {
+    getItem(key: string): void;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+    clear(): void;
+}
+/**
+ * Main Platform Adapter Interface
+ */
+export interface PlatformInterface {
+    // Device Information
+    getDeviceInfo(): Promise<IDeviceInfo>;
+    getPlatform(): string;
+    getFrontendType(): string;
+    getDocumentDirectory(): string;
+
+    // File System Operations
+    resolveLocalFileSystemURL(url: string): Promise<IFileEntry>;
+    getFolderBasedOnUserId(userId: string): Promise<string>;
+    deleteUserFolder(userId: string): Promise<void>;
+
+    // Database Operations
+    getDatabaseAdapter(): IDatabaseAdapter;
+
+    // Push Notifications
+    getPushNotificationAdapter(): IPushNotificationAdapter | null;
+
+    // Logging
+    getLoggerAdapter(): ILoggerAdapter;
+
+    // Storage
+    getStorageAdapter(): IStorageAdapter;
+}

package/ts-core/ReactNativeFileEntry.ts

@@ -0,0 +1,208 @@
+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);
+        }
+    }
+}

package/{example/USAGE_EXAMPLE.ts → ts-core/ReactNativePlatformAdapter.ts}

@@ -1,5 +1,7 @@
 import { PlatformInterface, IDeviceInfo, IFileEntry, IDatabaseAdapter, IPushNotificationAdapter, ILoggerAdapter, DatabaseType } from './PlatformInterface';
-import { logger, LogLevel } from '@unvired/react-native-unvired-sdk';
+import { logger, LogLevel } from '../src/logger';
+import { RNFileEntry } from '../src/file-system/RNFileEntry';
+import { FileSystem } from '../src/file-system/FileSystem';
 export class ReactNativePlatformAdapter implements PlatformInterface {
 
     getDeviceInfo(): IDeviceInfo {
@@ -24,22 +26,20 @@ export class ReactNativePlatformAdapter implements PlatformInterface {
     }
 
     getDocumentDirectory(): string {
-        // TODO: Implement document directory retrieval
-        return "";
+        // Return the document directory path for React Native
+        return FileSystem.getDocumentDirectory();
     }
 
     resolveLocalFileSystemURL(url: string): Promise<IFileEntry> {
-        // TODO: Implement local file system URL resolution
-        return Promise.resolve({} as IFileEntry);
+        return FileSystem.resolveLocalFileSystemURL(url);
     }
 
     async getFolderBasedOnUserId(userId: string): Promise<string> {
-        // TODO: Implement folder retrieval based on user ID
-        return "";
+        return FileSystem.getFolderBasedOnUserId(userId);
     }
 
     async deleteUserFolder(userId: string): Promise<void> {
-        // TODO: Implement user folder deletion
+        return FileSystem.deleteUserFolder(userId);
     }
 
     getDatabaseAdapter(): IDatabaseAdapter {
@@ -139,7 +139,8 @@ export class ReactNativePlatformAdapter implements PlatformInterface {
             },
             getBackupLogFileContent: async () => {
                 // TODO: Implement backup log file content retrieval
-                return logger.getBackupLogFileContent();
+                const content = await logger.getBackupLogFileContent();
+                return content || '';
             },
             clearLogFile: async () => {
                 // TODO: Implement log file clearing