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

package/dist/logger/services/LoggerWindows.js

@@ -0,0 +1,225 @@
+import * as pako from 'pako';
+// Import with null safety
+let RNFS = null;
+try {
+    RNFS = require('@dr.pogodin/react-native-fs');
+    if (!RNFS || !RNFS.DocumentDirectoryPath) {
+        console.error('❌ @dr.pogodin/react-native-fs is not properly linked.');
+        RNFS = null;
+    }
+}
+catch (e) {
+    console.error('❌ @dr.pogodin/react-native-fs module not found.');
+}
+export class LoggerWindows {
+    constructor() {
+        this.isRotating = false; // Rotation lock to prevent concurrent rotations
+        this.isAvailable = false;
+        this.writeQueue = [];
+        this.isWriting = false;
+        const dir = 'unvired_logs';
+        const file = 'applog.txt'; // main log file
+        if (!RNFS) {
+            console.warn('⚠️ LoggerWindows: RNFS not available, logging to file system disabled');
+            this.logDir = '';
+            this.logFile = '';
+            this.backupZip = '';
+            return;
+        }
+        this.isAvailable = true;
+        // Windows specifically uses DocumentDirectoryPath (AppData/Local/Packages/.../LocalState)
+        this.logDir = `${RNFS.DocumentDirectoryPath}/${dir}`;
+        this.logFile = `${this.logDir}/${file}`;
+        this.backupZip = `${this.logDir}/backuplog.zip`;
+    }
+    async init() {
+        if (!this.isAvailable || !this.logDir || !RNFS)
+            return;
+        try {
+            if (!(await RNFS.exists(this.logDir)))
+                await RNFS.mkdir(this.logDir);
+            if (!(await RNFS.exists(this.logFile)))
+                await RNFS.writeFile(this.logFile, '', 'utf8');
+        }
+        catch (e) {
+            console.error('❌ LoggerWindows init error:', e);
+        }
+    }
+    async writeLine(line, maxSize) {
+        if (!this.isAvailable || !RNFS)
+            return;
+        // Push to queue
+        this.writeQueue.push(line);
+        // Trigger processing if not already running
+        this.processWriteQueue(maxSize);
+    }
+    async processWriteQueue(maxSize) {
+        if (this.isWriting)
+            return;
+        this.isWriting = true;
+        try {
+            await this.ensureDir();
+            while (this.writeQueue.length > 0) {
+                // Peek at the chunk of lines to write? 
+                // Writing one by one is safe but slow. 
+                // Let's write one by one for safety first.
+                const line = this.writeQueue.shift();
+                if (!line)
+                    continue;
+                try {
+                    await RNFS.appendFile(this.logFile, line + '\n', 'utf8');
+                    // Check rotation (only occasionally to avoid stat spam?)
+                    // We can check every N writes or if queue is empty
+                    if (!this.isRotating && this.writeQueue.length === 0) {
+                        try {
+                            const stat = await RNFS.stat(this.logFile);
+                            if (Number(stat.size) >= maxSize) {
+                                this.rotateLog();
+                            }
+                        }
+                        catch (statErr) {
+                            // ignore
+                        }
+                    }
+                }
+                catch (filesErr) {
+                    // If file is locked, we might want to put line back?
+                    // or just retry? 
+                    // For now, retry once then drop to avoid infinite loop
+                    console.warn('⚠️ Write failed, retrying once:', filesErr.message);
+                    try {
+                        await new Promise(r => setTimeout(r, 50)); // small delay
+                        await RNFS.appendFile(this.logFile, line + '\n', 'utf8');
+                    }
+                    catch (retryErr) {
+                        console.error('❌ Failed to write log line after retry:', retryErr);
+                    }
+                }
+            }
+        }
+        catch (e) {
+            console.error('❌ LoggerWindows queue error:', e);
+        }
+        finally {
+            this.isWriting = false;
+            // If logs came in while we were finishing, trigger again
+            if (this.writeQueue.length > 0) {
+                this.processWriteQueue(maxSize);
+            }
+        }
+    }
+    async ensureDir() {
+        if (!this.isAvailable || !this.logDir || !RNFS)
+            return;
+        try {
+            if (!(await RNFS.exists(this.logDir)))
+                await RNFS.mkdir(this.logDir);
+        }
+        catch (e) {
+            // Ignore if dir already exists race condition
+        }
+    }
+    async rotateLog() {
+        if (!this.isAvailable || !RNFS) {
+            return;
+        }
+        // Prevent concurrent rotations
+        if (this.isRotating) {
+            console.log('⏭️ Rotation already in progress, skipping...');
+            return;
+        }
+        this.isRotating = true;
+        try {
+            console.log('🔄 Starting log rotation (using pako gzip)...');
+            // Check if log file exists
+            if (!(await RNFS.exists(this.logFile))) {
+                return;
+            }
+            // Step 1: Read current log content
+            // Reading whole file into memory might be heavy for huge files, 
+            // but for mobile logs generally acceptable (e.g. 5-10MB limit)
+            const content = await RNFS.readFile(this.logFile, 'utf8');
+            // Step 2: Compress content using Pako (gzip)
+            const binaryData = pako.gzip(content);
+            // Step 3: Convert binary to base64 for writing using Buffer (more robust)
+            // React Native environment usually has Buffer polyfill, or we use a chunked approach
+            const base64 = Buffer.from(binaryData).toString('base64');
+            // Step 4: Write to backup file (overwriting old one)
+            // We rename extensions to .gz to be accurate, or keep .zip if requirement is strict 
+            // (but technically it IS a gzip stream, not a PKZip archive)
+            // User asked for base64 return, so storing it purely is fine.
+            await RNFS.writeFile(this.backupZip, base64, 'base64');
+            console.log('✅ Backup created successfully');
+            // Step 5: Clear current log
+            await RNFS.writeFile(this.logFile, '', 'utf8');
+            console.log('✔ Log rotation completed successfully');
+        }
+        catch (e) {
+            console.error('❌ Logger rotation error:', e);
+            // Recovery: ensure log file exists
+            try {
+                if (!(await RNFS.exists(this.logFile))) {
+                    await RNFS.writeFile(this.logFile, '', 'utf8');
+                }
+            }
+            catch { }
+        }
+        finally {
+            this.isRotating = false;
+        }
+    }
+    // ------------------------
+    // Public accessors
+    // ------------------------
+    async getLogFileURL() {
+        if (!this.isAvailable)
+            return '';
+        return this.logFile;
+    }
+    async getLogFileContent() {
+        if (!this.isAvailable || !RNFS)
+            return '';
+        try {
+            if (await RNFS.exists(this.logFile)) {
+                return await RNFS.readFile(this.logFile, 'utf8');
+            }
+            return '';
+        }
+        catch (e) {
+            return '';
+        }
+    }
+    async getBackupLogFileContent() {
+        if (!this.isAvailable || !RNFS)
+            return null;
+        try {
+            // Do NOT force rotation. Only return existing backup if present.
+            // await this.rotateLog();
+            if (await RNFS.exists(this.backupZip)) {
+                // It's already written as base64 in rotateLog step via writeFile('base64'), 
+                // but readFile('base64') reads the file content and returns base64. 
+                // Wait, writeFile(path, data, 'base64') expects data to BE base64.
+                // readFile(path, 'base64') reads binary and RETURNS base64.
+                // Yes, so we can just read it back.
+                return await RNFS.readFile(this.backupZip, 'base64');
+            }
+            return null;
+        }
+        catch (e) {
+            console.error('❌ LoggerWindows getBackupLogFileContent error:', e);
+            return null;
+        }
+    }
+    async clear() {
+        if (!this.isAvailable || !RNFS)
+            return;
+        try {
+            await RNFS.writeFile(this.logFile, '', 'utf8');
+            if (await RNFS.exists(this.backupZip))
+                await RNFS.unlink(this.backupZip);
+        }
+        catch (e) {
+            // silent
+        }
+    }
+}

package/dist/main.d.ts

@@ -0,0 +1,13 @@
+export { Logger, logger } from './logger';
+export type { LogLevel, ILogger, ILoggerImplementation } from './logger';
+export { LocalStorage } from './local-storage';
+export { DatabaseManager, Database, createDatabase } 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 { PushNotification } from './push-notification';
+export type { IPushNotificationAdapter } from './push-notification';
+export { ReactNativePlatformAdapter, getPlatformAdapter, resetPlatformAdapter, DatabaseType } from './PlatformAdapter';
+export type { IPlatformAdapter, ILoggerAdapter, IStorageAdapter } from './PlatformAdapter';

package/dist/main.js

@@ -0,0 +1,28 @@
+// ============================================
+// Logger Module
+// ============================================
+export { Logger, logger } from './logger';
+// ============================================
+// Local Storage Module
+// ============================================
+export { LocalStorage } from './local-storage';
+// ============================================
+// Database Module
+// ============================================
+export { DatabaseManager, Database, createDatabase } from './database';
+// ============================================
+// Device Info Module
+// ============================================
+export { DeviceInfo } from './device-info';
+// ============================================
+// File System Module
+// ============================================
+export { FileSystem } from './file-system';
+// ============================================
+// Push Notification Module
+// ============================================
+export { PushNotification } from './push-notification';
+// ============================================
+// Platform Adapter
+// ============================================
+export { ReactNativePlatformAdapter, getPlatformAdapter, resetPlatformAdapter, DatabaseType } from './PlatformAdapter';

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

@@ -0,0 +1,52 @@
+import { IPushNotificationAdapter } from './PushNotification.types';
+/**
+ * Base Push Notification Class
+ * Handles push notifications using Firebase Cloud Messaging
+ */
+export declare class BasePushNotification implements IPushNotificationAdapter {
+    private tokenRefreshCallback;
+    private messageCallback;
+    private backgroundMessageCallback;
+    /**
+     * Request push notification permission
+     */
+    requestPermission(options?: {
+        forceShow?: boolean;
+    }): Promise<void>;
+    /**
+     * Get FCM token
+     */
+    getToken(): Promise<string>;
+    /**
+     * Listen for token refresh
+     */
+    onTokenRefresh(callback: (token: string) => void): void;
+    /**
+     * Listen for foreground messages
+     */
+    onMessage(callback: (message: any) => void): void;
+    /**
+     * Listen for background messages
+     */
+    onBackgroundMessage(callback: (message: any) => void): void;
+    /**
+     * Check if device supports push notifications
+     */
+    static isSupported(): Promise<boolean>;
+    /**
+     * Delete FCM token
+     */
+    deleteToken(): Promise<void>;
+    /**
+     * Get initial notification (app opened from notification)
+     */
+    getInitialNotification(): Promise<any | null>;
+    /**
+     * Subscribe to topic
+     */
+    subscribeToTopic(topic: string): Promise<void>;
+    /**
+     * Unsubscribe from topic
+     */
+    unsubscribeFromTopic(topic: string): Promise<void>;
+}

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';