@unvired/react-native-unvired-sdk 0.0.12 → 0.0.13

package/dist/push-notification/BasePushNotification.js

@@ -0,0 +1,180 @@
+// BasePushNotification.ts
+// Base push notification implementation
+let messaging;
+let FirebaseMessagingTypes;
+try {
+    const firebaseMessaging = require('@react-native-firebase/messaging');
+    messaging = firebaseMessaging.default;
+    FirebaseMessagingTypes = firebaseMessaging.FirebaseMessagingTypes;
+}
+catch (error) {
+    console.warn('Firebase messaging not installed. Push notifications will not work.');
+}
+/**
+ * Base Push Notification Class
+ * Handles push notifications using Firebase Cloud Messaging
+ */
+export class BasePushNotification {
+    constructor() {
+        this.tokenRefreshCallback = null;
+        this.messageCallback = null;
+        this.backgroundMessageCallback = null;
+    }
+    /**
+     * Request push notification permission
+     */
+    async requestPermission(options = {}) {
+        if (!messaging) {
+            throw new Error('Firebase messaging is not installed');
+        }
+        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);
+            }
+            else {
+                console.log('Push notification permission denied');
+            }
+        }
+        catch (error) {
+            console.error('Error requesting push notification permission:', error);
+            throw error;
+        }
+    }
+    /**
+     * Get FCM token
+     */
+    async getToken() {
+        if (!messaging) {
+            throw new Error('Firebase messaging is not installed');
+        }
+        try {
+            const token = await messaging().getToken();
+            console.log('FCM Token:', token);
+            return token;
+        }
+        catch (error) {
+            console.error('Error getting FCM token:', error);
+            throw error;
+        }
+    }
+    /**
+     * Listen for token refresh
+     */
+    onTokenRefresh(callback) {
+        if (!messaging)
+            return;
+        this.tokenRefreshCallback = callback;
+        messaging().onTokenRefresh((token) => {
+            console.log('FCM Token refreshed:', token);
+            if (this.tokenRefreshCallback) {
+                this.tokenRefreshCallback(token);
+            }
+        });
+    }
+    /**
+     * Listen for foreground messages
+     */
+    onMessage(callback) {
+        if (!messaging)
+            return;
+        this.messageCallback = callback;
+        messaging().onMessage(async (remoteMessage) => {
+            console.log('Foreground message received:', remoteMessage);
+            if (this.messageCallback) {
+                this.messageCallback(remoteMessage);
+            }
+        });
+    }
+    /**
+     * Listen for background messages
+     */
+    onBackgroundMessage(callback) {
+        if (!messaging)
+            return;
+        this.backgroundMessageCallback = callback;
+        messaging().setBackgroundMessageHandler(async (remoteMessage) => {
+            console.log('Background message received:', remoteMessage);
+            if (this.backgroundMessageCallback) {
+                this.backgroundMessageCallback(remoteMessage);
+            }
+        });
+    }
+    /**
+     * Check if device supports push notifications
+     */
+    static async isSupported() {
+        if (!messaging)
+            return false;
+        try {
+            return await messaging().isDeviceRegisteredForRemoteMessages();
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Delete FCM token
+     */
+    async deleteToken() {
+        if (!messaging) {
+            throw new Error('Firebase messaging is not installed');
+        }
+        try {
+            await messaging().deleteToken();
+            console.log('FCM token deleted');
+        }
+        catch (error) {
+            console.error('Error deleting FCM token:', error);
+            throw error;
+        }
+    }
+    /**
+     * Get initial notification (app opened from notification)
+     */
+    async getInitialNotification() {
+        if (!messaging)
+            return null;
+        try {
+            return await messaging().getInitialNotification();
+        }
+        catch (error) {
+            console.error('Error getting initial notification:', error);
+            return null;
+        }
+    }
+    /**
+     * Subscribe to topic
+     */
+    async subscribeToTopic(topic) {
+        if (!messaging) {
+            throw new Error('Firebase messaging is not installed');
+        }
+        try {
+            await messaging().subscribeToTopic(topic);
+            console.log(`Subscribed to topic: ${topic}`);
+        }
+        catch (error) {
+            console.error('Error subscribing to topic:', error);
+            throw error;
+        }
+    }
+    /**
+     * Unsubscribe from topic
+     */
+    async unsubscribeFromTopic(topic) {
+        if (!messaging) {
+            throw new Error('Firebase messaging is not installed');
+        }
+        try {
+            await messaging().unsubscribeFromTopic(topic);
+            console.log(`Unsubscribed from topic: ${topic}`);
+        }
+        catch (error) {
+            console.error('Error unsubscribing from topic:', error);
+            throw error;
+        }
+    }
+}

package/dist/push-notification/PushNotification.d.ts

@@ -0,0 +1,9 @@
+import { BasePushNotification } from './BasePushNotification';
+/**
+ * PushNotification class
+ * Extends BasePushNotification
+ */
+export declare class PushNotification extends BasePushNotification {
+}
+export type { IPushNotificationAdapter } from './PushNotification.types';
+export default PushNotification;

package/dist/push-notification/PushNotification.js

@@ -0,0 +1,11 @@
+// PushNotification.ts
+// Main push notification export
+import { BasePushNotification } from './BasePushNotification';
+/**
+ * PushNotification class
+ * Extends BasePushNotification
+ */
+export class PushNotification extends BasePushNotification {
+}
+// Default export
+export default PushNotification;

package/dist/push-notification/PushNotification.types.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Push notification adapter interface
+ */
+export interface IPushNotificationAdapter {
+    requestPermission(options?: {
+        forceShow?: boolean;
+    }): Promise<void>;
+    getToken(): Promise<string>;
+    onTokenRefresh(callback: (token: string) => void): void;
+    onMessage(callback: (message: any) => void): void;
+    onBackgroundMessage(callback: (message: any) => void): void;
+}

package/dist/push-notification/PushNotification.types.js

@@ -0,0 +1,3 @@
+// PushNotification.types.ts
+// Type definitions for push notification module
+export {};

package/dist/push-notification/index.d.ts

@@ -0,0 +1,3 @@
+export { PushNotification } from './PushNotification';
+export type { IPushNotificationAdapter } from './PushNotification.types';
+export { default } from './PushNotification';

package/dist/push-notification/index.js

@@ -0,0 +1,3 @@
+// Push Notification module exports
+export { PushNotification } from './PushNotification';
+export { default } from './PushNotification';

package/example/USAGE_EXAMPLE.ts

@@ -0,0 +1,167 @@
+import { PlatformInterface, IDeviceInfo, IFileEntry, IDatabaseAdapter, IPushNotificationAdapter, ILoggerAdapter, DatabaseType } from './PlatformInterface';
+import { logger, LogLevel } from '@unvired/react-native-unvired-sdk';
+export class ReactNativePlatformAdapter implements PlatformInterface {
+
+    getDeviceInfo(): IDeviceInfo {
+        // TODO: Implement device info retrieval
+        return {
+            platform: 'unknown',
+            model: '',
+            version: '',
+            isMobile: true
+        };
+    }
+
+    getPlatform(): string {
+        // TODO: Implement platform retrieval
+        return "";
+    }
+
+    getFrontendType(): string {
+        // TODO: Implement frontend type retrieval
+        // Refer CordovaPlatformAdapter.ts for reference to return values
+        return "";
+    }
+
+    getDocumentDirectory(): string {
+        // TODO: Implement document directory retrieval
+        return "";
+    }
+
+    resolveLocalFileSystemURL(url: string): Promise<IFileEntry> {
+        // TODO: Implement local file system URL resolution
+        return Promise.resolve({} as IFileEntry);
+    }
+
+    async getFolderBasedOnUserId(userId: string): Promise<string> {
+        // TODO: Implement folder retrieval based on user ID
+        return "";
+    }
+
+    async deleteUserFolder(userId: string): Promise<void> {
+        // TODO: Implement user folder deletion
+    }
+
+    getDatabaseAdapter(): IDatabaseAdapter {
+        // TODO: Implement database adapter
+        return {
+            create: (options, successCallback, errorCallback) => {
+                // TODO: Implement database creation
+            },
+            execute: (options, successCallback, errorCallback) => {
+                // TODO: Implement SQL execution
+            },
+            executeStatementOnPath: (dbPath, sqlQuery, callback) => {
+                // TODO: Implement SQL execution on specific path
+                callback([]);
+            },
+            selectFromPath: (dbPath, sqlQuery, callback) => {
+                // TODO: Implement SELECT query
+                callback([]);
+            },
+            createDatabase: (dbPath, callback) => {
+                // TODO: Implement database creation
+                callback();
+            },
+            getDBFilePath: (options, callback) => {
+                // TODO: Implement database file path retrieval
+                callback("");
+            },
+            saveWebDB: (options, callback, errorCallback) => {
+                // TODO: Implement web database save
+                callback({});
+            },
+            exportWebDB: (options, callback, errorCallback) => {
+                // TODO: Implement web database export
+                callback({});
+            },
+            deleteUserData: (options, callback, errorCallback) => {
+                // TODO: Implement user data deletion
+                callback();
+            }
+        };
+    }
+
+    getPushNotificationAdapter(): IPushNotificationAdapter | null {
+        try {
+            return {
+                requestPermission: async (options = { forceShow: false }) => {
+                    //TODO: Implement push notification permission request
+                },
+                getToken: async () => {
+                    //TODO: Implement push notification token retrieval
+                    return "";
+                },
+                onTokenRefresh: (callback) => {
+                    //TODO: Implement push notification token refresh
+                },
+                onMessage: (callback) => {
+                    //TODO: Implement push notification message handling
+                },
+                onBackgroundMessage: (callback) => {
+                    //TODO: Implement push notification background message handling
+                }
+            };
+        } catch (error) {
+            return null;
+        }
+    }
+
+    getLoggerAdapter(): ILoggerAdapter {
+        return {
+            logDebug: (sourceClass, method, message) => {
+                console.log(`[DEBUG] ${sourceClass}.${method}: ${message}`);
+                logger.logDebug(sourceClass, method, message);
+                // TODO: Implement log file writing
+            },
+            logError: (sourceClass, method, message) => {
+                console.error(`[ERROR] ${sourceClass}.${method}: ${message}`);
+                logger.logError(sourceClass, method, message);
+                // TODO: Implement log file writing
+            },
+            logInfo: (sourceClass, method, message) => {
+                console.info(`[INFO] ${sourceClass}.${method}: ${message}`);
+                logger.logInfo(sourceClass, method, message);
+                // TODO: Implement log file writing
+            },
+            setLogLevel: (logLevel: LogLevel) => {
+                // TODO: Implement log level setting
+                console.log(`Setting log level to: ${logLevel}`);
+                logger.setLogLevel(logLevel);
+            },
+            getLogFileURL: async () => {
+                // TODO: Implement log file URL retrieval
+                return logger.getLogFileURL();
+            },
+            getLogFileContent: async () => {
+                // TODO: Implement log file content retrieval
+                return logger.getLogFileContent();
+            },
+            getBackupLogFileContent: async () => {
+                // TODO: Implement backup log file content retrieval
+                return logger.getBackupLogFileContent();
+            },
+            clearLogFile: async () => {
+                // TODO: Implement log file clearing
+                logger.clearLogFile();
+            }
+        };
+    }
+
+    getStorageAdapter() {
+        return {
+            getItem: (key: string) => {
+                return null;
+            },
+            setItem: (key: string, value: string) => {
+                // Dummy implementation
+            },
+            removeItem: (key: string) => {
+                // Dummy implementation
+            },
+            clear: () => {
+                // Dummy implementation
+            }
+        };
+    }
+}

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@unvired/react-native-unvired-sdk",
-  "version": "0.0.12",
+  "version": "0.0.13",
   "description": "Unvired SDK for React Native with logging, database, notifications, and file system support",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "main": "dist/main.js",
+  "types": "dist/main.d.ts",
   "scripts": {
     "build": "tsc --project tsconfig.json",
     "prepare": "npm run build",
@@ -25,20 +25,29 @@
   "license": "UNLICENSED",
   "peerDependencies": {
     "@dr.pogodin/react-native-fs": "^2.36.2",
+    "@react-native-firebase/messaging": "^21.8.1",
     "react": ">=16.8.0",
     "react-native": ">=0.60.0",
+    "react-native-device-info": "^14.1.1",
+    "react-native-sqlite-storage": "^6.0.1",
     "react-native-zip-archive": "^7.0.2"
   },
-  "peerDependenciesMeta": {},
+  "peerDependenciesMeta": {
+    "@react-native-firebase/messaging": {
+      "optional": true
+    }
+  },
   "devDependencies": {
     "@types/react": "^18.0.0",
     "@types/react-native": "^0.72.0",
+    "@types/react-native-sqlite-storage": "^6.0.5",
     "eslint": "^8.0.0",
     "jest": "^29.0.0",
     "prettier": "^3.0.0",
     "typescript": "^5.0.0"
   },
   "dependencies": {
+    "@react-native-async-storage/async-storage": "^2.2.0",
     "@types/pako": "^2.0.4",
     "pako": "^2.1.0"
   },
@@ -50,4 +59,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}

package/dist/index.d.ts

@@ -1,3 +0,0 @@
-export { Logger, logger } from './logger/Logger';
-export type { LogLevel, ILogger, ILoggerImplementation, } from './logger/Logger';
-export { default } from './logger/Logger';

package/dist/index.js

@@ -1,4 +0,0 @@
-// Export main logger class and instance
-export { Logger, logger } from './logger/Logger';
-// Default export (logger instance)
-export { default } from './logger/Logger';