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

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

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

@@ -1,61 +0,0 @@
-import { IFileEntry } from './FileSystem.types';
-/**
- * Base File System Class
- * Handles file system operations for React Native
- * - iOS/Android/Windows: Uses @dr.pogodin/react-native-fs
- * - Web: Limited functionality (not supported)
- */
-export declare class BaseFileSystem {
-    /**
-     * Get document directory path
-     */
-    static getDocumentDirectory(): string;
-    /**
-     * Resolve local file system URL
-     */
-    static resolveLocalFileSystemURL(url: string): Promise<IFileEntry>;
-    /**
-     * Get folder based on user ID
-     */
-    static getFolderBasedOnUserId(userId: string): Promise<string>;
-    /**
-     * Delete user folder
-     */
-    static deleteUserFolder(userId: string): Promise<void>;
-    /**
-     * Create directory
-     */
-    static createDirectory(path: string): Promise<void>;
-    /**
-     * Read file content
-     */
-    static readFile(path: string, encoding?: string): Promise<string>;
-    /**
-     * Write file content
-     */
-    static writeFile(path: string, content: string, encoding?: string): Promise<void>;
-    /**
-     * Delete file
-     */
-    static deleteFile(path: string): Promise<void>;
-    /**
-     * Check if file exists
-     */
-    static exists(path: string): Promise<boolean>;
-    /**
-     * Get file info
-     */
-    static stat(path: string): Promise<any>;
-    /**
-     * List directory contents
-     */
-    static readDir(path: string): Promise<any[]>;
-    /**
-     * Copy file
-     */
-    static copyFile(source: string, destination: string): Promise<void>;
-    /**
-     * Move file
-     */
-    static moveFile(source: string, destination: string): Promise<void>;
-}

package/dist/file-system/BaseFileSystem.js

@@ -1,164 +0,0 @@
-// BaseFileSystem.ts
-// Base file system implementation
-import { Platform } from 'react-native';
-import { FileSystemNative } from './services/FileSystemNative';
-import { FileSystemWeb } from './services/FileSystemWeb';
-// Select file system implementation based on platform
-const fsImpl = Platform.OS === 'web' ? new FileSystemWeb() : new FileSystemNative();
-/**
- * Base File System Class
- * Handles file system operations for React Native
- * - iOS/Android/Windows: Uses @dr.pogodin/react-native-fs
- * - Web: Limited functionality (not supported)
- */
-export class BaseFileSystem {
-    /**
-     * Get document directory path
-     */
-    static getDocumentDirectory() {
-        return fsImpl.getDocumentDirectory();
-    }
-    /**
-     * Resolve local file system URL
-     */
-    static async resolveLocalFileSystemURL(url) {
-        try {
-            return await fsImpl.resolveLocalFileSystemURL(url);
-        }
-        catch (error) {
-            console.error('Error resolving file system URL:', error);
-            throw error;
-        }
-    }
-    /**
-     * Get folder based on user ID
-     */
-    static async getFolderBasedOnUserId(userId) {
-        try {
-            return await fsImpl.getFolderBasedOnUserId(userId);
-        }
-        catch (error) {
-            console.error('Error getting user folder:', error);
-            throw error;
-        }
-    }
-    /**
-     * Delete user folder
-     */
-    static async deleteUserFolder(userId) {
-        try {
-            await fsImpl.deleteUserFolder(userId);
-        }
-        catch (error) {
-            console.error('Error deleting user folder:', error);
-            throw error;
-        }
-    }
-    /**
-     * Create directory
-     */
-    static async createDirectory(path) {
-        try {
-            await fsImpl.createDirectory(path);
-        }
-        catch (error) {
-            console.error('Error creating directory:', error);
-            throw error;
-        }
-    }
-    /**
-     * Read file content
-     */
-    static async readFile(path, encoding = 'utf8') {
-        try {
-            return await fsImpl.readFile(path, encoding);
-        }
-        catch (error) {
-            console.error('Error reading file:', error);
-            throw error;
-        }
-    }
-    /**
-     * Write file content
-     */
-    static async writeFile(path, content, encoding = 'utf8') {
-        try {
-            await fsImpl.writeFile(path, content, encoding);
-        }
-        catch (error) {
-            console.error('Error writing file:', error);
-            throw error;
-        }
-    }
-    /**
-     * Delete file
-     */
-    static async deleteFile(path) {
-        try {
-            await fsImpl.deleteFile(path);
-        }
-        catch (error) {
-            console.error('Error deleting file:', error);
-            throw error;
-        }
-    }
-    /**
-     * Check if file exists
-     */
-    static async exists(path) {
-        try {
-            return await fsImpl.exists(path);
-        }
-        catch (error) {
-            return false;
-        }
-    }
-    /**
-     * Get file info
-     */
-    static async stat(path) {
-        try {
-            return await fsImpl.stat(path);
-        }
-        catch (error) {
-            console.error('Error getting file stats:', error);
-            throw error;
-        }
-    }
-    /**
-     * List directory contents
-     */
-    static async readDir(path) {
-        try {
-            return await fsImpl.readDir(path);
-        }
-        catch (error) {
-            console.error('Error reading directory:', error);
-            throw error;
-        }
-    }
-    /**
-     * Copy file
-     */
-    static async copyFile(source, destination) {
-        try {
-            await fsImpl.copyFile(source, destination);
-        }
-        catch (error) {
-            console.error('Error copying file:', error);
-            throw error;
-        }
-    }
-    /**
-     * Move file
-     */
-    static async moveFile(source, destination) {
-        try {
-            await fsImpl.moveFile(source, destination);
-        }
-        catch (error) {
-            console.error('Error moving file:', error);
-            throw error;
-        }
-    }
-}