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

package/dist/file-system/RNFileEntry.js

@@ -0,0 +1,179 @@
+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/dist/file-system/index.d.ts

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

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

@@ -1,17 +1,17 @@
-import * as RNFS from '@dr.pogodin/react-native-fs';
-import { IFileEntry } from '../FileSystem.types';
-export declare class FileSystemNative {
+import * as RNFS from 'react-native-fs';
+import { IFileEntry, IFileSystem, FileSystemEncoding } from '../FileSystem.types';
+export declare class FileSystemNative implements 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?: RNFS.EncodingT): Promise<string>;
-    writeFile(path: string, content: string, encoding?: RNFS.EncodingT): 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<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,40 +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 {
-            isFile: stat.isFile(),
-            isDirectory: stat.isDirectory(),
-            name: fileName,
-            fullPath: stat.path,
-            nativeURL: `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/file-system/services/FileSystemWeb.d.ts

@@ -1,12 +1,12 @@
-import { IFileEntry } from '../FileSystem.types';
-export declare class FileSystemWeb {
+import { IFileEntry, IFileSystem, FileSystemEncoding } from '../FileSystem.types';
+export declare class FileSystemWeb implements 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?: string): Promise<string>;
-    writeFile(path: string, content: string, encoding?: 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>;

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.14",
+  "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;
+}