@unvired/react-native-unvired-sdk 0.0.44 → 0.0.46

package/dist/local-storage/services/StorageNative.js

@@ -1,36 +1,75 @@
-import { createMMKV } from 'react-native-mmkv';
-const storage = createMMKV();
+let storage = null;
+try {
+    const MMKVModule = require('react-native-mmkv');
+    if (typeof MMKVModule.createMMKV === 'function') {
+        storage = MMKVModule.createMMKV();
+    }
+    else if (MMKVModule.MMKV) {
+        storage = new MMKVModule.MMKV();
+    }
+}
+catch (e) {
+    storage = null;
+}
+// In-memory fallback map when MMKV is not installed (e.g. standard Expo Go or testing environments)
+const memoryStore = new Map();
 export class StorageNative {
+    static isMMKVAvailable() {
+        return !!storage;
+    }
     getItem(key) {
-        const val = storage.getString(key);
-        return val !== undefined ? val : null;
+        if (storage && typeof storage.getString === 'function') {
+            const val = storage.getString(key);
+            return val !== undefined ? val : null;
+        }
+        return memoryStore.has(key) ? memoryStore.get(key) : null;
     }
     setItem(key, value) {
-        storage.set(key, value);
+        if (storage && typeof storage.set === 'function') {
+            storage.set(key, value);
+        }
+        else {
+            memoryStore.set(key, value);
+        }
     }
     removeItem(key) {
-        storage.remove(key);
+        if (storage && typeof storage.remove === 'function') {
+            storage.remove(key);
+        }
+        else if (storage && typeof storage.delete === 'function') {
+            storage.delete(key);
+        }
+        else {
+            memoryStore.delete(key);
+        }
     }
     clear() {
-        storage.clearAll();
+        if (storage && typeof storage.clearAll === 'function') {
+            storage.clearAll();
+        }
+        else {
+            memoryStore.clear();
+        }
     }
     getAllKeys() {
-        return storage.getAllKeys();
+        if (storage && typeof storage.getAllKeys === 'function') {
+            return storage.getAllKeys();
+        }
+        return Array.from(memoryStore.keys());
     }
     multiGet(keys) {
         return keys.map(key => {
-            const val = storage.getString(key);
-            return [key, val !== undefined ? val : null];
+            return [key, this.getItem(key)];
         });
     }
     multiSet(keyValuePairs) {
         keyValuePairs.forEach(([key, value]) => {
-            storage.set(key, value);
+            this.setItem(key, value);
         });
     }
     multiRemove(keys) {
         keys.forEach(key => {
-            storage.remove(key);
+            this.removeItem(key);
         });
     }
 }

package/dist/logger/BaseLogger.js

@@ -43,6 +43,10 @@ export class BaseLogger {
     async log(level, className, methodName, message) {
         if (!this.shouldLog(level))
             return;
+        // Suppress transient circular dependency error during DatabaseManager module evaluation
+        if (className === 'DatabaseManager' && methodName === 'initializeDatabase' && message && message.includes("reading 'instance'")) {
+            return;
+        }
         const line = this.format(className, methodName, message, level);
         // console always
         switch (level) {

package/dist/main.d.ts

@@ -1,11 +1,11 @@
 export { Logger, logger } from './logger';
 export type { LogLevel, ILogger, ILoggerImplementation } from './logger';
 export { LocalStorage } from './local-storage';
-export { DatabaseManager, Database, createDatabase } from './database';
+export { DatabaseManager, Database, createDatabase, DatabaseExpo, DatabaseNative, DatabaseWeb } from './database';
 export type { IDatabaseAdapter, DatabaseOptions, ExecuteOptions, SaveWebDBOptions, ExportWebDBOptions, DeleteUserDataOptions, SuccessCallback, ErrorCallback, ResultCallback, SQLResultSet, SQLTransaction, SQLiteDatabase } from './database';
 export { DeviceInfo } from './device-info';
 export type { IDeviceInfo } from './device-info';
-export { FileSystem } from './file-system';
-export type { IFileEntry } from './file-system';
+export { FileSystem, FileSystemExpo, FileSystemNative, FileSystemWeb } from './file-system';
+export type { IFileEntry, IDirectoryReader, IFileSystem, FileSystemEncoding } from './file-system';
 export { PushNotification } from './push-notification';
 export type { IPushNotificationAdapter } from './push-notification';

package/dist/main.js

@@ -21,7 +21,7 @@ export { LocalStorage } from './local-storage';
 // ============================================
 // Database Module
 // ============================================
-export { DatabaseManager, Database, createDatabase } from './database';
+export { DatabaseManager, Database, createDatabase, DatabaseExpo, DatabaseNative, DatabaseWeb } from './database';
 // ============================================
 // Device Info Module
 // ============================================
@@ -29,7 +29,7 @@ export { DeviceInfo } from './device-info';
 // ============================================
 // File System Module
 // ============================================
-export { FileSystem } from './file-system';
+export { FileSystem, FileSystemExpo, FileSystemNative, FileSystemWeb } from './file-system';
 // ============================================
 // Push Notification Module
 // ============================================

package/dist/push-notification/services/PushNotificationNative.js

@@ -1,11 +1,33 @@
+// PushNotificationNative.ts
+import { Platform } from "react-native";
 let messaging = null;
 try {
     const firebaseMessaging = require("@react-native-firebase/messaging");
-    messaging = firebaseMessaging.default;
+    messaging = firebaseMessaging.default || firebaseMessaging;
 }
 catch (error) {
     // Optional if @react-native-firebase/messaging is not installed
 }
+let ExpoNotifications = null;
+try {
+    ExpoNotifications = require("expo-notifications");
+}
+catch (error) {
+    // Optional if expo-notifications is not installed
+}
+// Auto-configure foreground notification display behavior in Expo
+if (ExpoNotifications && typeof ExpoNotifications.setNotificationHandler === "function") {
+    try {
+        ExpoNotifications.setNotificationHandler({
+            handleNotification: async () => ({
+                shouldShowAlert: true,
+                shouldPlaySound: true,
+                shouldSetBadge: false,
+            }),
+        });
+    }
+    catch (e) { }
+}
 export class PushNotificationNative {
     constructor() {
         this.tokenRefreshCallback = null;
@@ -13,99 +35,191 @@ export class PushNotificationNative {
         this.backgroundMessageCallback = null;
     }
     async requestPermission(options = {}) {
-        if (!messaging) {
-            console.warn("Firebase messaging is not installed");
-            return;
-        }
-        try {
-            const authStatus = await messaging().requestPermission();
-            const enabled = authStatus === messaging.AuthorizationStatus.AUTHORIZED ||
-                authStatus === messaging.AuthorizationStatus.PROVISIONAL;
-            if (enabled) {
-                console.log("Push notification permission granted:", authStatus);
+        if (messaging) {
+            try {
+                const authStatus = await messaging().requestPermission();
+                const enabled = authStatus === messaging.AuthorizationStatus.AUTHORIZED ||
+                    authStatus === messaging.AuthorizationStatus.PROVISIONAL;
+                if (enabled) {
+                    console.log("[PushNotificationNative] Firebase push permission granted:", authStatus);
+                }
+                else {
+                    console.log("[PushNotificationNative] Firebase push permission denied");
+                }
+                return;
             }
-            else {
-                console.log("Push notification permission denied");
+            catch (error) {
+                console.error("[PushNotificationNative] Error requesting Firebase push permission:", error);
+                throw error;
             }
         }
-        catch (error) {
-            console.error("Error requesting push notification permission:", error);
-            throw error;
+        if (ExpoNotifications && typeof ExpoNotifications.requestPermissionsAsync === "function") {
+            try {
+                const result = await ExpoNotifications.requestPermissionsAsync();
+                console.log("[PushNotificationNative] Expo push permission status:", result.status);
+                // On Android 8.0+ (API 26+), configure the default notification channel
+                if (Platform.OS === "android" && typeof ExpoNotifications.setNotificationChannelAsync === "function") {
+                    try {
+                        await ExpoNotifications.setNotificationChannelAsync("default", {
+                            name: "Default",
+                            importance: 5, // AndroidImportance.MAX
+                            vibrationPattern: [0, 250, 250, 250],
+                            lightColor: "#FF231F7C",
+                        });
+                    }
+                    catch (channelErr) {
+                        console.warn("[PushNotificationNative] Could not create Expo notification channel:", channelErr);
+                    }
+                }
+                return;
+            }
+            catch (error) {
+                console.error("[PushNotificationNative] Error requesting Expo push permission:", error);
+                throw error;
+            }
         }
+        console.warn("[PushNotificationNative] Neither Firebase messaging nor Expo notifications is installed");
     }
     async getToken() {
-        if (!messaging) {
-            return "native-mock-token";
-        }
-        try {
-            const token = await messaging().getToken();
-            return token;
+        if (messaging) {
+            try {
+                // Register device with APNs on iOS if needed
+                if (Platform.OS === "ios" && typeof messaging().registerDeviceForRemoteMessages === "function") {
+                    await messaging().registerDeviceForRemoteMessages();
+                }
+                const token = await messaging().getToken();
+                return token;
+            }
+            catch (error) {
+                console.error("[PushNotificationNative] Error getting FCM token:", error);
+                throw error;
+            }
         }
-        catch (error) {
-            console.error("Error getting FCM token:", error);
-            throw error;
+        if (ExpoNotifications) {
+            try {
+                // Primary for Enterprise servers (Unvired backend expects native APNs/FCM device token):
+                if (typeof ExpoNotifications.getDevicePushTokenAsync === "function") {
+                    const deviceToken = await ExpoNotifications.getDevicePushTokenAsync();
+                    return deviceToken.data || String(deviceToken);
+                }
+                else if (typeof ExpoNotifications.getExpoPushTokenAsync === "function") {
+                    const expoToken = await ExpoNotifications.getExpoPushTokenAsync();
+                    return expoToken.data || String(expoToken);
+                }
+            }
+            catch (error) {
+                console.warn("[PushNotificationNative] Error getting device push token, trying Expo push token fallback:", error);
+                try {
+                    if (typeof ExpoNotifications.getExpoPushTokenAsync === "function") {
+                        const expoToken = await ExpoNotifications.getExpoPushTokenAsync();
+                        return expoToken.data || String(expoToken);
+                    }
+                }
+                catch (expoErr) {
+                    console.warn("[PushNotificationNative] Error getting Expo push token:", expoErr);
+                }
+            }
         }
+        return "native-mock-token";
     }
     onTokenRefresh(callback) {
-        if (!messaging)
-            return;
         this.tokenRefreshCallback = callback;
-        messaging().onTokenRefresh((token) => {
-            if (this.tokenRefreshCallback) {
-                this.tokenRefreshCallback(token);
-            }
-        });
+        if (messaging) {
+            messaging().onTokenRefresh((token) => {
+                if (this.tokenRefreshCallback) {
+                    this.tokenRefreshCallback(token);
+                }
+            });
+            return;
+        }
+        if (ExpoNotifications && typeof ExpoNotifications.addPushTokenListener === "function") {
+            ExpoNotifications.addPushTokenListener((tokenObj) => {
+                if (this.tokenRefreshCallback) {
+                    const token = (tokenObj === null || tokenObj === void 0 ? void 0 : tokenObj.data) || String(tokenObj);
+                    this.tokenRefreshCallback(token);
+                }
+            });
+        }
     }
     onMessage(callback) {
-        if (!messaging)
-            return;
         this.messageCallback = callback;
-        messaging().onMessage(async (remoteMessage) => {
-            if (this.messageCallback) {
-                this.messageCallback(remoteMessage);
-            }
-        });
+        if (messaging) {
+            messaging().onMessage(async (remoteMessage) => {
+                if (this.messageCallback) {
+                    this.messageCallback(remoteMessage);
+                }
+            });
+            return;
+        }
+        if (ExpoNotifications && typeof ExpoNotifications.addNotificationReceivedListener === "function") {
+            ExpoNotifications.addNotificationReceivedListener((notification) => {
+                if (this.messageCallback) {
+                    this.messageCallback(notification);
+                }
+            });
+        }
     }
     onBackgroundMessage(callback) {
-        if (!messaging)
-            return;
         this.backgroundMessageCallback = callback;
-        messaging().setBackgroundMessageHandler(async (remoteMessage) => {
-            if (this.backgroundMessageCallback) {
-                this.backgroundMessageCallback(remoteMessage);
-            }
-        });
+        if (messaging) {
+            messaging().setBackgroundMessageHandler(async (remoteMessage) => {
+                if (this.backgroundMessageCallback) {
+                    this.backgroundMessageCallback(remoteMessage);
+                }
+            });
+            return;
+        }
+        if (ExpoNotifications && typeof ExpoNotifications.addNotificationResponseReceivedListener === "function") {
+            ExpoNotifications.addNotificationResponseReceivedListener((response) => {
+                if (this.backgroundMessageCallback) {
+                    this.backgroundMessageCallback(response);
+                }
+            });
+        }
     }
     async isSupported() {
-        if (!messaging)
-            return false;
-        try {
-            return await messaging().isDeviceRegisteredForRemoteMessages();
+        if (messaging) {
+            try {
+                return await messaging().isDeviceRegisteredForRemoteMessages();
+            }
+            catch (error) {
+                return false;
+            }
         }
-        catch (error) {
-            return false;
+        if (ExpoNotifications) {
+            return true;
         }
+        return false;
     }
     async deleteToken() {
-        if (!messaging)
-            return;
-        try {
-            await messaging().deleteToken();
-        }
-        catch (error) {
-            console.error("Error deleting FCM token:", error);
-            throw error;
+        if (messaging) {
+            try {
+                await messaging().deleteToken();
+            }
+            catch (error) {
+                console.error("[PushNotificationNative] Error deleting FCM token:", error);
+                throw error;
+            }
         }
     }
     async getInitialNotification() {
-        if (!messaging)
-            return null;
-        try {
-            return await messaging().getInitialNotification();
+        if (messaging) {
+            try {
+                return await messaging().getInitialNotification();
+            }
+            catch (error) {
+                return null;
+            }
         }
-        catch (error) {
-            return null;
+        if (ExpoNotifications && typeof ExpoNotifications.getLastNotificationResponseAsync === "function") {
+            try {
+                return await ExpoNotifications.getLastNotificationResponseAsync();
+            }
+            catch (error) {
+                return null;
+            }
         }
+        return null;
     }
     async subscribeToTopic(topic) {
         if (!messaging)
@@ -114,7 +228,7 @@ export class PushNotificationNative {
             await messaging().subscribeToTopic(topic);
         }
         catch (error) {
-            console.error("Error subscribing to topic:", error);
+            console.error("[PushNotificationNative] Error subscribing to topic:", error);
         }
     }
     async unsubscribeFromTopic(topic) {
@@ -124,7 +238,7 @@ export class PushNotificationNative {
             await messaging().unsubscribeFromTopic(topic);
         }
         catch (error) {
-            console.error("Error unsubscribing from topic:", error);
+            console.error("[PushNotificationNative] Error unsubscribing from topic:", error);
         }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unvired/react-native-unvired-sdk",
-  "version": "0.0.44",
+  "version": "0.0.46",
   "description": "Unvired SDK for React Native with logging, database, notifications, and file system support",
   "main": "dist/main.js",
   "types": "dist/main.d.ts",
@@ -14,6 +14,11 @@
   "peerDependencies": {
     "@op-engineering/op-sqlite": "^15.2.5",
     "@react-native-firebase/messaging": "^21.8.1",
+    "expo-application": "*",
+    "expo-device": "*",
+    "expo-file-system": "*",
+    "expo-notifications": "*",
+    "expo-sqlite": "*",
     "react": ">=18",
     "react-native": ">=0.73",
     "react-native-device-info": "^15.0.1",
@@ -22,6 +27,21 @@
     "react-native-zip-archive": "^7.0.2"
   },
   "peerDependenciesMeta": {
+    "expo-sqlite": {
+      "optional": true
+    },
+    "expo-file-system": {
+      "optional": true
+    },
+    "expo-device": {
+      "optional": true
+    },
+    "expo-application": {
+      "optional": true
+    },
+    "expo-notifications": {
+      "optional": true
+    },
     "@react-native-firebase/messaging": {
       "optional": true
     },