@unvired/react-native-unvired-sdk 0.0.33 → 0.0.35

package/BuildNo.txt

@@ -1 +1 @@
-R-0.000.0033
+R-0.000.0035

package/dist/database/DatabaseManager.d.ts

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

package/dist/database/DatabaseManager.js

@@ -1,10 +1,8 @@
 import { DatabaseNative } from "./services/DatabaseNative";
-// Select database implementation based on platform
 const dbImpl = new DatabaseNative();
 /**
- * DatabaseManager - Manages database operations across platforms
+ * DatabaseManager - Manages native database operations
  * - iOS/Android/Windows: Uses @op-engineering/op-sqlite
- * - Web: Uses WebSQL
  */
 export class DatabaseManager {
     /**

package/dist/database/DatabaseManager.web.d.ts

@@ -0,0 +1,11 @@
+import { IDatabaseAdapter } from "./types";
+/**
+ * DatabaseManager - Manages web database operations
+ * - Web: Uses Browser/WebSQL/IndexedDB/UnviredDB via sql.js
+ */
+export declare class DatabaseManager {
+    /**
+     * Get the database adapter implementation
+     */
+    static getDatabaseAdapter(): IDatabaseAdapter;
+}

package/dist/database/DatabaseManager.web.js

@@ -0,0 +1,14 @@
+import { DatabaseWeb } from "./services/DatabaseWeb";
+const dbImpl = new DatabaseWeb();
+/**
+ * DatabaseManager - Manages web database operations
+ * - Web: Uses Browser/WebSQL/IndexedDB/UnviredDB via sql.js
+ */
+export class DatabaseManager {
+    /**
+     * Get the database adapter implementation
+     */
+    static getDatabaseAdapter() {
+        return dbImpl.getAdapter();
+    }
+}

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

@@ -0,0 +1,12 @@
+import { IDatabaseAdapter } from "../types";
+/**
+ * DatabaseWeb - SQLite WebAssembly adapter for React Native Web using sql.js
+ * Persists SQLite databases to localStorage
+ */
+export declare class DatabaseWeb {
+    private databases;
+    private defaultLocation;
+    private getDatabase;
+    private persistDatabase;
+    getAdapter(): IDatabaseAdapter;
+}

package/dist/database/services/DatabaseWeb.js

@@ -0,0 +1,246 @@
+let SQL = null;
+let initPromise = null;
+function getSqlJs() {
+    if (!initPromise) {
+        let initSqlJs;
+        try {
+            initSqlJs = require("sql.js");
+            if (initSqlJs && initSqlJs.default) {
+                initSqlJs = initSqlJs.default;
+            }
+        }
+        catch {
+            initSqlJs = globalThis.initSqlJs;
+        }
+        initPromise = initSqlJs({
+            locateFile: (file) => `https://sql.js.org/dist/${file}`,
+        }).then((sql) => {
+            SQL = sql;
+            return sql;
+        });
+    }
+    return initPromise || Promise.reject(new Error("sql.js not initialized"));
+}
+/**
+ * DatabaseWeb - SQLite WebAssembly adapter for React Native Web using sql.js
+ * Persists SQLite databases to localStorage
+ */
+export class DatabaseWeb {
+    constructor() {
+        this.databases = new Map();
+        this.defaultLocation = "default";
+    }
+    async getDatabase(name, location) {
+        const dbKey = `${name}_${location || this.defaultLocation}`;
+        if (this.databases.has(dbKey)) {
+            return this.databases.get(dbKey);
+        }
+        if (!name) {
+            throw new Error("Database name is required");
+        }
+        const sql = await getSqlJs();
+        let db;
+        if (typeof localStorage !== "undefined") {
+            try {
+                const savedData = localStorage.getItem(`__sqlite_${name}`);
+                if (savedData) {
+                    const u8 = new Uint8Array(JSON.parse(savedData));
+                    db = new sql.Database(u8);
+                    this.databases.set(dbKey, db);
+                    return db;
+                }
+            }
+            catch (e) {
+                console.warn("[DatabaseWeb] Failed to load database from localStorage:", e);
+            }
+        }
+        db = new sql.Database();
+        this.databases.set(dbKey, db);
+        return db;
+    }
+    persistDatabase(name, location) {
+        const dbKey = `${name}_${location || this.defaultLocation}`;
+        const db = this.databases.get(dbKey);
+        if (db && typeof localStorage !== "undefined") {
+            try {
+                const data = db.export();
+                localStorage.setItem(`__sqlite_${name}`, JSON.stringify(Array.from(data)));
+            }
+            catch (e) {
+                console.warn("[DatabaseWeb] Failed to persist database to localStorage:", e);
+            }
+        }
+    }
+    getAdapter() {
+        return {
+            create: async (options, successCallback, errorCallback) => {
+                try {
+                    const dbName = (options.name || options.userId || "default");
+                    await this.getDatabase(dbName, options.location);
+                    successCallback({ success: true, database: dbName });
+                }
+                catch (error) {
+                    errorCallback(error instanceof Error ? error.message : String(error));
+                }
+            },
+            execute: async (options, successCallback, errorCallback) => {
+                try {
+                    const dbName = (options.dbName || options.userId || "default");
+                    const params = options.params || options.args || [];
+                    const db = await this.getDatabase(dbName);
+                    const trimmedQuery = options.query.trim();
+                    const isSelect = /^SELECT\b/i.test(trimmedQuery);
+                    let resultToReturn = [];
+                    if (isSelect) {
+                        const stmt = db.prepare(options.query);
+                        if (params && params.length > 0) {
+                            stmt.bind(params);
+                        }
+                        while (stmt.step()) {
+                            resultToReturn.push(stmt.getAsObject());
+                        }
+                        stmt.free();
+                    }
+                    else {
+                        const stmt = db.prepare(options.query);
+                        if (params && params.length > 0) {
+                            stmt.bind(params);
+                        }
+                        stmt.step();
+                        stmt.free();
+                        let insertId = 0;
+                        let rowsAffected = 0;
+                        try {
+                            const res = db.exec("SELECT last_insert_rowid() as id, changes() as changes;");
+                            if (res.length > 0 && res[0].values && res[0].values.length > 0) {
+                                insertId = res[0].values[0][0];
+                                rowsAffected = res[0].values[0][1];
+                            }
+                        }
+                        catch (e) { }
+                        resultToReturn.insertId = insertId;
+                        resultToReturn.rowsAffected = rowsAffected;
+                        this.persistDatabase(dbName);
+                    }
+                    successCallback(resultToReturn);
+                }
+                catch (error) {
+                    errorCallback(error instanceof Error ? error.message : String(error));
+                }
+            },
+            executeStatementOnPath: async (dbPath, sqlQuery, callback) => {
+                var _a;
+                try {
+                    const dbName = ((_a = dbPath.split("/").pop()) === null || _a === void 0 ? void 0 : _a.replace(".db", "")) || "default";
+                    const db = await this.getDatabase(dbName);
+                    const stmt = db.prepare(sqlQuery);
+                    const resultToReturn = [];
+                    while (stmt.step()) {
+                        resultToReturn.push(stmt.getAsObject());
+                    }
+                    stmt.free();
+                    let insertId = 0;
+                    let rowsAffected = 0;
+                    try {
+                        const res = db.exec("SELECT last_insert_rowid() as id, changes() as changes;");
+                        if (res.length > 0 && res[0].values && res[0].values.length > 0) {
+                            insertId = res[0].values[0][0];
+                            rowsAffected = res[0].values[0][1];
+                        }
+                    }
+                    catch (e) { }
+                    resultToReturn.insertId = insertId;
+                    resultToReturn.rowsAffected = rowsAffected;
+                    this.persistDatabase(dbName);
+                    callback(resultToReturn);
+                }
+                catch (error) {
+                    callback([]);
+                }
+            },
+            selectFromPath: async (dbPath, sqlQuery, callback) => {
+                var _a;
+                try {
+                    const dbName = ((_a = dbPath.split("/").pop()) === null || _a === void 0 ? void 0 : _a.replace(".db", "")) || "default";
+                    const db = await this.getDatabase(dbName);
+                    const stmt = db.prepare(sqlQuery);
+                    const resultToReturn = [];
+                    while (stmt.step()) {
+                        resultToReturn.push(stmt.getAsObject());
+                    }
+                    stmt.free();
+                    callback(resultToReturn);
+                }
+                catch (error) {
+                    callback([]);
+                }
+            },
+            createDatabase: async (dbPath, callback) => {
+                var _a;
+                try {
+                    const dbName = ((_a = dbPath.split("/").pop()) === null || _a === void 0 ? void 0 : _a.replace(".db", "")) || "default";
+                    await this.getDatabase(dbName);
+                    callback();
+                }
+                catch (error) {
+                    callback();
+                }
+            },
+            getDBFilePath: async (options, callback) => {
+                callback(`${options.name || options.userId || "default"}.db`);
+            },
+            saveWebDB: async (options, callback, errorCallback) => {
+                try {
+                    const dbName = options.dbName || options.userId || "default";
+                    const db = await this.getDatabase(dbName);
+                    const data = db.export();
+                    if (typeof localStorage !== "undefined") {
+                        localStorage.setItem(`__sqlite_${dbName}`, JSON.stringify(Array.from(data)));
+                    }
+                    callback({ success: true });
+                }
+                catch (error) {
+                    errorCallback(error instanceof Error ? error.message : String(error));
+                }
+            },
+            exportWebDB: async (options, callback, errorCallback) => {
+                try {
+                    const dbName = options.dbName || options.userId || "default";
+                    const db = await this.getDatabase(dbName);
+                    const data = db.export();
+                    callback({ success: true, data: Array.from(data) });
+                }
+                catch (error) {
+                    errorCallback(error instanceof Error ? error.message : String(error));
+                }
+            },
+            deleteUserData: async (options, callback, errorCallback) => {
+                try {
+                    const dbName = options.dbName || options.userId;
+                    if (dbName) {
+                        const dbKey = `${dbName}_${this.defaultLocation}`;
+                        if (this.databases.has(dbKey)) {
+                            const db = this.databases.get(dbKey);
+                            try {
+                                db === null || db === void 0 ? void 0 : db.close();
+                            }
+                            catch (e) { }
+                            this.databases.delete(dbKey);
+                        }
+                        if (typeof localStorage !== "undefined") {
+                            localStorage.removeItem(`__sqlite_${dbName}`);
+                            localStorage.removeItem(`__unvired_db_${dbName}`);
+                        }
+                    }
+                    callback();
+                }
+                catch (error) {
+                    errorCallback(error instanceof Error ? error.message : String(error));
+                }
+            },
+            getEncryptionKey: (options, successCallback, errorCallback) => {
+                successCallback("");
+            },
+        };
+    }
+}

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

@@ -1,13 +1,12 @@
-import { IDeviceInfo } from './DeviceInfo.types';
+import { IDeviceInfo } from "./DeviceInfo.types";
 /**
  * Base Device Information Class
- * Handles device information retrieval for React Native
+ * Handles device information retrieval across Native & Web
  */
 export declare class BaseDeviceInfo {
     private static cachedDeviceInfo;
     /**
      * Get comprehensive device information synchronously
-     * Uses synchronous methods from react-native-device-info
      */
     static getDeviceInfo(): IDeviceInfo;
     /**

package/dist/device-info/BaseDeviceInfo.js

@@ -1,109 +1,54 @@
 // BaseDeviceInfo.ts
 // Base device information implementation
-import { Platform } from 'react-native';
-import DeviceInfo from 'react-native-device-info';
+import { Platform } from "react-native";
+import { DeviceInfoNative } from "./services/DeviceInfoNative";
+import { DeviceInfoWeb } from "./services/DeviceInfoWeb";
+const deviceInfoImpl = Platform.OS === "web" ? new DeviceInfoWeb() : new DeviceInfoNative();
 /**
  * Base Device Information Class
- * Handles device information retrieval for React Native
+ * Handles device information retrieval across Native & Web
  */
 export class BaseDeviceInfo {
     /**
      * Get comprehensive device information synchronously
-     * Uses synchronous methods from react-native-device-info
      */
     static getDeviceInfo() {
         if (this.cachedDeviceInfo) {
             return this.cachedDeviceInfo;
         }
-        try {
-            // Use synchronous methods from react-native-device-info
-            const deviceInfo = {
-                platform: Platform.OS,
-                model: DeviceInfo.getModel(),
-                version: Platform.Version.toString(),
-                isMobile: Platform.OS === 'ios' || Platform.OS === 'android',
-                manufacturer: DeviceInfo.getManufacturerSync(),
-                uuid: DeviceInfo.getUniqueIdSync(),
-                deviceId: DeviceInfo.getUniqueIdSync(),
-                deviceName: DeviceInfo.getDeviceNameSync(),
-                brand: DeviceInfo.getBrand(),
-                deviceType: DeviceInfo.getDeviceType(),
-            };
-            this.cachedDeviceInfo = deviceInfo;
-            return deviceInfo;
-        }
-        catch (error) {
-            console.error('Error getting device info:', error);
-            // Return fallback with synchronous Platform data
-            const fallback = {
-                platform: Platform.OS,
-                model: 'Unknown',
-                version: Platform.Version.toString(),
-                isMobile: Platform.OS === 'ios' || Platform.OS === 'android',
-                deviceId: 'N/A',
-                deviceName: 'N/A',
-                brand: 'N/A',
-                deviceType: 'N/A',
-            };
-            this.cachedDeviceInfo = fallback;
-            return fallback;
-        }
+        const info = deviceInfoImpl.getDeviceInfo();
+        this.cachedDeviceInfo = info;
+        return info;
     }
     /**
      * Get platform name
      */
     static getPlatform() {
-        return Platform.OS;
+        return deviceInfoImpl.getPlatform();
     }
     /**
      * Get frontend type
      */
     static getFrontendType() {
-        if (Platform.OS === 'ios') {
-            return 'APPLE_PHONE';
-        }
-        else if (Platform.OS === 'android') {
-            return 'ANDROID_PHONE';
-        }
-        else if (Platform.OS === 'windows') {
-            return 'WINDOWS_PHONE';
-        }
-        else {
-            return 'UNKNOWN';
-        }
+        return deviceInfoImpl.getFrontendType();
     }
     /**
      * Check if device is a tablet
      */
     static async isTablet() {
-        try {
-            return await DeviceInfo.isTablet();
-        }
-        catch (error) {
-            return false;
-        }
+        return await deviceInfoImpl.isTablet();
     }
     /**
      * Get app version
      */
     static async getAppVersion() {
-        try {
-            return await DeviceInfo.getVersion();
-        }
-        catch (error) {
-            return '1.0.0';
-        }
+        return await deviceInfoImpl.getAppVersion();
     }
     /**
      * Get build number
      */
     static async getBuildNumber() {
-        try {
-            return await DeviceInfo.getBuildNumber();
-        }
-        catch (error) {
-            return '1';
-        }
+        return await deviceInfoImpl.getBuildNumber();
     }
 }
 BaseDeviceInfo.cachedDeviceInfo = null;

package/dist/device-info/DeviceInfo.types.d.ts

@@ -13,3 +13,14 @@ export interface IDeviceInfo {
     brand?: string;
     deviceType?: string;
 }
+/**
+ * Device info implementation interface
+ */
+export interface IDeviceInfoImplementation {
+    getDeviceInfo(): IDeviceInfo;
+    getPlatform(): string;
+    getFrontendType(): string;
+    isTablet(): Promise<boolean>;
+    getAppVersion(): Promise<string>;
+    getBuildNumber(): Promise<string>;
+}

package/dist/device-info/services/DeviceInfoNative.d.ts

@@ -0,0 +1,9 @@
+import { IDeviceInfo, IDeviceInfoImplementation } from "../DeviceInfo.types";
+export declare class DeviceInfoNative implements IDeviceInfoImplementation {
+    getDeviceInfo(): IDeviceInfo;
+    getPlatform(): string;
+    getFrontendType(): string;
+    isTablet(): Promise<boolean>;
+    getAppVersion(): Promise<string>;
+    getBuildNumber(): Promise<string>;
+}

package/dist/device-info/services/DeviceInfoNative.js

@@ -0,0 +1,83 @@
+// DeviceInfoNative.ts
+import { Platform } from "react-native";
+let RNDeviceInfo = null;
+try {
+    RNDeviceInfo = require("react-native-device-info").default || require("react-native-device-info");
+}
+catch (e) {
+    RNDeviceInfo = null;
+}
+export class DeviceInfoNative {
+    getDeviceInfo() {
+        try {
+            if (RNDeviceInfo) {
+                return {
+                    platform: Platform.OS,
+                    model: RNDeviceInfo.getModel ? RNDeviceInfo.getModel() : "Unknown",
+                    version: Platform.Version ? Platform.Version.toString() : "1.0",
+                    isMobile: Platform.OS === "ios" || Platform.OS === "android",
+                    manufacturer: RNDeviceInfo.getManufacturerSync ? RNDeviceInfo.getManufacturerSync() : "Unknown",
+                    uuid: RNDeviceInfo.getUniqueIdSync ? RNDeviceInfo.getUniqueIdSync() : "default-uuid",
+                    deviceId: RNDeviceInfo.getUniqueIdSync ? RNDeviceInfo.getUniqueIdSync() : "default-id",
+                    deviceName: RNDeviceInfo.getDeviceNameSync ? RNDeviceInfo.getDeviceNameSync() : "Device",
+                    brand: RNDeviceInfo.getBrand ? RNDeviceInfo.getBrand() : "Unknown",
+                    deviceType: RNDeviceInfo.getDeviceType ? RNDeviceInfo.getDeviceType() : "Handset",
+                };
+            }
+        }
+        catch (error) {
+            console.warn("Error getting native device info:", error);
+        }
+        return {
+            platform: Platform.OS,
+            model: "Unknown",
+            version: Platform.Version ? Platform.Version.toString() : "1.0",
+            isMobile: Platform.OS === "ios" || Platform.OS === "android",
+            deviceId: "N/A",
+            deviceName: "N/A",
+            brand: "N/A",
+            deviceType: "N/A",
+        };
+    }
+    getPlatform() {
+        return Platform.OS;
+    }
+    getFrontendType() {
+        if (Platform.OS === "ios") {
+            return "APPLE_PHONE";
+        }
+        else if (Platform.OS === "android") {
+            return "ANDROID_PHONE";
+        }
+        else if (Platform.OS === "windows") {
+            return "WINDOWS_PHONE";
+        }
+        else {
+            return "UNKNOWN";
+        }
+    }
+    async isTablet() {
+        try {
+            return RNDeviceInfo && RNDeviceInfo.isTablet ? await RNDeviceInfo.isTablet() : false;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    async getAppVersion() {
+        try {
+            return RNDeviceInfo && RNDeviceInfo.getVersion ? await RNDeviceInfo.getVersion() : "1.0.0";
+        }
+        catch (error) {
+            return "1.0.0";
+        }
+    }
+    async getBuildNumber() {
+        try {
+            return RNDeviceInfo && RNDeviceInfo.getBuildNumber ? await RNDeviceInfo.getBuildNumber() : "1";
+        }
+        catch (error) {
+            return "1";
+        }
+    }
+}

package/dist/device-info/services/DeviceInfoWeb.d.ts

@@ -0,0 +1,12 @@
+import { IDeviceInfo, IDeviceInfoImplementation } from "../DeviceInfo.types";
+/**
+ * DeviceInfoWeb - Browser-native implementation using Navigator & LocalStorage
+ */
+export declare class DeviceInfoWeb implements IDeviceInfoImplementation {
+    getDeviceInfo(): IDeviceInfo;
+    getPlatform(): string;
+    getFrontendType(): string;
+    isTablet(): Promise<boolean>;
+    getAppVersion(): Promise<string>;
+    getBuildNumber(): Promise<string>;
+}

package/dist/device-info/services/DeviceInfoWeb.js

@@ -0,0 +1,54 @@
+function getWebDeviceId() {
+    if (typeof localStorage !== "undefined") {
+        try {
+            let id = localStorage.getItem("__unvired_device_id");
+            if (!id) {
+                id = "web-" + Math.random().toString(36).substring(2, 15) + "-" + Date.now().toString(36);
+                localStorage.setItem("__unvired_device_id", id);
+            }
+            return id;
+        }
+        catch (e) { }
+    }
+    return "web-device-default";
+}
+/**
+ * DeviceInfoWeb - Browser-native implementation using Navigator & LocalStorage
+ */
+export class DeviceInfoWeb {
+    getDeviceInfo() {
+        const nav = typeof navigator !== "undefined" ? navigator : null;
+        const ua = (nav === null || nav === void 0 ? void 0 : nav.userAgent) || "Browser";
+        const isMobile = /Mobi|Android|iPhone|iPad|iPod/i.test(ua);
+        const isTablet = /iPad|Tablet/i.test(ua);
+        const deviceId = getWebDeviceId();
+        return {
+            platform: "web",
+            model: (nav === null || nav === void 0 ? void 0 : nav.userAgent) || "Web Browser",
+            version: (nav === null || nav === void 0 ? void 0 : nav.appVersion) || "1.0.0",
+            isMobile,
+            manufacturer: (nav === null || nav === void 0 ? void 0 : nav.vendor) || "Browser Vendor",
+            uuid: deviceId,
+            deviceId: deviceId,
+            deviceName: (nav === null || nav === void 0 ? void 0 : nav.appName) || "Web Client",
+            brand: (nav === null || nav === void 0 ? void 0 : nav.vendor) || "Web",
+            deviceType: isTablet ? "Tablet" : isMobile ? "Handset" : "Desktop",
+        };
+    }
+    getPlatform() {
+        return "web";
+    }
+    getFrontendType() {
+        return "BROWSER";
+    }
+    async isTablet() {
+        const ua = typeof navigator !== "undefined" ? navigator.userAgent : "";
+        return /iPad|Tablet/i.test(ua);
+    }
+    async getAppVersion() {
+        return "1.0.0";
+    }
+    async getBuildNumber() {
+        return "1";
+    }
+}

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

@@ -1,5 +1,9 @@
-import type { IFileEntry, IFileSystem, FileSystemEncoding } from '../FileSystem';
+import type { IFileEntry, IFileSystem, FileSystemEncoding } from "../FileSystem";
+/**
+ * FileSystemWeb - Virtual browser-backed file system with localStorage persistence
+ */
 export declare class FileSystemWeb implements IFileSystem {
+    private baseDir;
     getDocumentDirectory(): string;
     resolveLocalFileSystemURL(url: string): Promise<IFileEntry>;
     getFolderBasedOnUserId(userId: string): Promise<string>;