@unvired/react-native-unvired-sdk 0.0.22 → 0.0.25

package/BuildNo.txt

@@ -1 +1 @@
-R-0.000.0022
+R-0.000.0025

package/dist/database/Database.d.ts

@@ -10,60 +10,9 @@ export declare class Database {
      */
     executeSql(query: string, params?: any[]): Promise<any[]>;
     /**
-     * Create a table
+     * Delete a database
      */
-    createTable(tableName: string, columns: Record<string, string>): Promise<void>;
-    /**
-     * Drop a table
-     */
-    dropTable(tableName: string): Promise<void>;
-    /**
-     * Insert a record
-     */
-    insert(tableName: string, data: Record<string, any>): Promise<number>;
-    /**
-     * Insert multiple records in a transaction
-     */
-    insertBatch(tableName: string, records: Record<string, any>[]): Promise<void>;
-    /**
-     * Update records
-     */
-    update(tableName: string, data: Record<string, any>, where: string, whereParams?: any[]): Promise<number>;
-    /**
-     * Delete records
-     */
-    delete(tableName: string, where: string, whereParams?: any[]): Promise<number>;
-    /**
-     * Select records
-     */
-    select(tableName: string, columns?: string[], where?: string, whereParams?: any[], orderBy?: string, limit?: number): Promise<any[]>;
-    /**
-     * Select a single record
-     */
-    selectOne(tableName: string, columns?: string[], where?: string, whereParams?: any[]): Promise<any | null>;
-    /**
-     * Count records
-     */
-    count(tableName: string, where?: string, whereParams?: any[]): Promise<number>;
-    /**
-     * Check if a table exists
-     */
-    tableExists(tableName: string): Promise<boolean>;
-    /**
-     * Get all table names
-     */
-    getAllTables(): Promise<string[]>;
-    /**
-     * Clear all data from a table
-     */
-    truncate(tableName: string): Promise<void>;
-    /**
-     * Execute multiple SQL statements in a transaction
-     */
-    transaction(queries: Array<{
-        query: string;
-        params?: any[];
-    }>): Promise<void>;
+    deleteDB(): Promise<void>;
 }
 /**
  * Create a new database instance

package/dist/database/Database.js

@@ -17,135 +17,13 @@ export class Database {
         });
     }
     /**
-     * Create a table
+     * Delete a database
      */
-    async createTable(tableName, columns) {
-        const columnDefs = Object.entries(columns)
-            .map(([name, type]) => `${name} ${type}`)
-            .join(', ');
-        const query = `CREATE TABLE IF NOT EXISTS ${tableName} (${columnDefs})`;
-        await this.executeSql(query);
-    }
-    /**
-     * Drop a table
-     */
-    async dropTable(tableName) {
-        const query = `DROP TABLE IF EXISTS ${tableName}`;
-        await this.executeSql(query);
-    }
-    /**
-     * Insert a record
-     */
-    async insert(tableName, data) {
-        var _a;
-        const columns = Object.keys(data).join(', ');
-        const placeholders = Object.keys(data).map(() => '?').join(', ');
-        const values = Object.values(data);
-        const query = `INSERT INTO ${tableName} (${columns}) VALUES (${placeholders})`;
-        const result = await this.executeSql(query, values);
-        // Return the insert ID if available
-        return ((_a = result[0]) === null || _a === void 0 ? void 0 : _a.insertId) || 0;
-    }
-    /**
-     * Insert multiple records in a transaction
-     */
-    async insertBatch(tableName, records) {
-        if (records.length === 0)
-            return;
-        const columns = Object.keys(records[0]).join(', ');
-        const placeholders = Object.keys(records[0]).map(() => '?').join(', ');
-        const query = `INSERT INTO ${tableName} (${columns}) VALUES (${placeholders})`;
-        for (const record of records) {
-            const values = Object.values(record);
-            await this.executeSql(query, values);
-        }
-    }
-    /**
-     * Update records
-     */
-    async update(tableName, data, where, whereParams = []) {
-        var _a;
-        const setClause = Object.keys(data)
-            .map(key => `${key} = ?`)
-            .join(', ');
-        const values = [...Object.values(data), ...whereParams];
-        const query = `UPDATE ${tableName} SET ${setClause} WHERE ${where}`;
-        const result = await this.executeSql(query, values);
-        return ((_a = result[0]) === null || _a === void 0 ? void 0 : _a.rowsAffected) || 0;
-    }
-    /**
-     * Delete records
-     */
-    async delete(tableName, where, whereParams = []) {
-        var _a;
-        const query = `DELETE FROM ${tableName} WHERE ${where}`;
-        const result = await this.executeSql(query, whereParams);
-        return ((_a = result[0]) === null || _a === void 0 ? void 0 : _a.rowsAffected) || 0;
-    }
-    /**
-     * Select records
-     */
-    async select(tableName, columns = ['*'], where, whereParams = [], orderBy, limit) {
-        let query = `SELECT ${columns.join(', ')} FROM ${tableName}`;
-        if (where) {
-            query += ` WHERE ${where}`;
-        }
-        if (orderBy) {
-            query += ` ORDER BY ${orderBy}`;
-        }
-        if (limit) {
-            query += ` LIMIT ${limit}`;
-        }
-        return this.executeSql(query, whereParams);
-    }
-    /**
-     * Select a single record
-     */
-    async selectOne(tableName, columns = ['*'], where, whereParams = []) {
-        const results = await this.select(tableName, columns, where, whereParams, undefined, 1);
-        return results.length > 0 ? results[0] : null;
-    }
-    /**
-     * Count records
-     */
-    async count(tableName, where, whereParams = []) {
-        var _a;
-        let query = `SELECT COUNT(*) as count FROM ${tableName}`;
-        if (where) {
-            query += ` WHERE ${where}`;
-        }
-        const result = await this.executeSql(query, whereParams);
-        return ((_a = result[0]) === null || _a === void 0 ? void 0 : _a.count) || 0;
-    }
-    /**
-     * Check if a table exists
-     */
-    async tableExists(tableName) {
-        const query = `SELECT name FROM sqlite_master WHERE type='table' AND name=?`;
-        const result = await this.executeSql(query, [tableName]);
-        return result.length > 0;
-    }
-    /**
-     * Get all table names
-     */
-    async getAllTables() {
-        const query = `SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'`;
-        const result = await this.executeSql(query);
-        return result.map(row => row.name);
-    }
-    /**
-     * Clear all data from a table
-     */
-    async truncate(tableName) {
-        await this.executeSql(`DELETE FROM ${tableName}`);
-    }
-    /**
-     * Execute multiple SQL statements in a transaction
-     */
-    async transaction(queries) {
-        for (const { query, params } of queries) {
-            await this.executeSql(query, params || []);
-        }
+    async deleteDB() {
+        return new Promise((resolve, reject) => {
+            const adapter = DatabaseManager.getDatabaseAdapter();
+            adapter.deleteUserData({ dbName: this.dbName }, () => resolve(), (error) => reject(new Error(String(error))));
+        });
     }
 }
 /**

package/dist/database/services/DatabaseNative.js

@@ -9,10 +9,9 @@ export class DatabaseNative {
         if (this.databases.has(dbKey)) {
             return this.databases.get(dbKey);
         }
-        // @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.
+        if (!name) {
+            throw new Error("Database name is required");
+        }
         const db = open({ name });
         this.databases.set(dbKey, db);
         return db;
@@ -29,43 +28,105 @@ export class DatabaseNative {
                 }
             },
             execute: async (options, successCallback, errorCallback) => {
-                var _a;
                 try {
                     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);
+                    // FIX: Await the result properly
+                    const res = await db.execute(options.query, options.params);
+                    let resultToReturn = [];
+                    // Cast to any to avoid TS error "Property '_array' does not exist on type 'never'"
+                    const rawRes = res;
+                    if (rawRes) {
+                        if (rawRes.rows) {
+                            const rawRows = rawRes.rows;
+                            if (Array.isArray(rawRows)) {
+                                resultToReturn = rawRows;
+                            }
+                            else if (rawRows._array && Array.isArray(rawRows._array)) {
+                                resultToReturn = rawRows._array;
+                            }
+                            else if (typeof rawRows.length === 'number') {
+                                // JSI iterator
+                                for (let i = 0; i < rawRows.length; i++) {
+                                    // Use item() if available, otherwise index access
+                                    const r = rawRows.item ? rawRows.item(i) : rawRows[i];
+                                    resultToReturn.push(r);
+                                }
+                            }
+                        }
+                        else if (Array.isArray(rawRes)) {
+                            resultToReturn = rawRes;
+                        }
+                        // Attach insertId if present (though interface usually expects strict array, 
+                        // JS runtime allows attaching props to array)
+                        if (rawRes.insertId !== undefined) {
+                            resultToReturn.insertId = rawRes.insertId;
+                            resultToReturn.rowsAffected = rawRes.rowsAffected;
+                        }
+                    }
+                    successCallback(resultToReturn);
                 }
                 catch (error) {
                     errorCallback(error instanceof Error ? error.message : String(error));
                 }
             },
             executeStatementOnPath: async (dbPath, sqlQuery, callback) => {
-                var _a, _b;
+                var _a;
                 try {
                     const dbName = ((_a = dbPath.split("/").pop()) === null || _a === void 0 ? void 0 : _a.replace(".db", "")) || "default";
                     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);
+                    const res = await db.execute(sqlQuery);
+                    let resultToReturn = [];
+                    const rawRes = res;
+                    if (rawRes && rawRes.rows) {
+                        const rawRows = rawRes.rows;
+                        if (typeof rawRows.length === 'number') {
+                            for (let i = 0; i < rawRows.length; i++) {
+                                const r = rawRows.item ? rawRows.item(i) : rawRows[i];
+                                resultToReturn.push(r);
+                            }
+                        }
+                        else if (Array.isArray(rawRows)) {
+                            resultToReturn = rawRows;
+                        }
+                        else if (rawRows._array) {
+                            resultToReturn = rawRows._array;
+                        }
+                    }
+                    // Attach insertId if present
+                    if (rawRes && rawRes.insertId !== undefined) {
+                        resultToReturn.insertId = rawRes.insertId;
+                        resultToReturn.rowsAffected = rawRes.rowsAffected;
+                    }
+                    callback(resultToReturn);
                 }
                 catch (error) {
                     callback([]);
                 }
             },
             selectFromPath: async (dbPath, sqlQuery, callback) => {
-                var _a, _b;
+                var _a;
                 try {
                     const dbName = ((_a = dbPath.split("/").pop()) === null || _a === void 0 ? void 0 : _a.replace(".db", "")) || "default";
                     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);
+                    const res = await db.execute(sqlQuery);
+                    let resultToReturn = [];
+                    const rawRes = res;
+                    if (rawRes && rawRes.rows) {
+                        const rawRows = rawRes.rows;
+                        if (typeof rawRows.length === 'number') {
+                            for (let i = 0; i < rawRows.length; i++) {
+                                const r = rawRows.item ? rawRows.item(i) : rawRows[i];
+                                resultToReturn.push(r);
+                            }
+                        }
+                        else if (Array.isArray(rawRows)) {
+                            resultToReturn = rawRows;
+                        }
+                        else if (rawRows._array) {
+                            resultToReturn = rawRows._array;
+                        }
+                    }
+                    callback(resultToReturn);
                 }
                 catch (error) {
                     callback([]);
@@ -106,7 +167,7 @@ export class DatabaseNative {
                         ? "DELETE FROM user_data WHERE user_id = ?"
                         : "DELETE FROM user_data";
                     const params = options.userId ? [options.userId] : [];
-                    db.execute(query, params);
+                    await db.execute(query, params);
                     callback();
                 }
                 catch (error) {

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.22",
+  "version": "0.0.25",
   "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/ReactNativePlatformAdapter.ts

@@ -1,4 +1,9 @@
-import { DeviceInfo, DatabaseManager, LocalStorage, logger, LogLevel, PushNotification, FileSystem } from '@unvired/react-native-unvired-sdk';
+import { DeviceInfo } from '../src/device-info';
+import { DatabaseManager } from '../src/database';
+import { LocalStorage } from '../src/local-storage';
+import { logger, LogLevel } from '../src/logger';
+import { PushNotification } from '../src/push-notification';
+import { FileSystem } from '../src/file-system';
 import { PlatformInterface, IDeviceInfo, IFileEntry, IDatabaseAdapter, IPushNotificationAdapter, ILoggerAdapter, IStorageAdapter } from './PlatformInterface';
 
 export class ReactNativePlatformAdapter implements PlatformInterface {
@@ -74,7 +79,8 @@ export class ReactNativePlatformAdapter implements PlatformInterface {
                     await pushNotification.requestPermission(options);
                 },
                 getToken: async () => {
-                    return await pushNotification.getToken();
+                    const token = await pushNotification.getToken();
+                    return token || '';
                 },
                 onTokenRefresh: (callback) => {
                     pushNotification.onTokenRefresh(callback);

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);
-        }
-    }
-}