cordova-plugin-unvired-logger 0.0.5 → 0.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "cordova-plugin-unvired-logger",
-    "version": "0.0.5",
+    "version": "0.0.7",
     "description": "A logger plugin for Electron, Android, Browser, and iOS that appends logs to log.txt files organized by user ID.",
     "cordova": {
         "id": "cordova-plugin-unvired-logger",

package/plugin.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<plugin id="cordova-plugin-unvired-logger" version="0.0.5"
+<plugin id="cordova-plugin-unvired-logger" version="0.0.7"
         xmlns="http://apache.org/cordova/ns/plugins/1.0"
         xmlns:android="http://schemas.android.com/apk/res/android">
 
@@ -43,7 +43,7 @@
 
     <platform name="browser">
         <js-module src="src/browser/Logger.js" name="UnviredLogger">
-            <clobbers target="Logger" />
+            <run />
         </js-module>
     </platform>
 </plugin>

package/src/browser/Logger.js

@@ -15,230 +15,179 @@ let defaultLogLevel = LogLevel.Info;
 const getStorageKey = (userId, fileName) => `unvired_logger_${userId}_${fileName}`;
 const getLogLevelKey = (userId) => `unvired_logger_${userId}_level`;
 
-function logDebug(args) {
-    return loggerWithLevel(args);
+module.exports.logDebug = async function (successCallback, errorCallback, args) {
+    loggerWithLevel(successCallback, errorCallback, args);
 }
 
-function logError(args) {
-    return loggerWithLevel(args);
+module.exports.logError = async function (successCallback, errorCallback, args) {
+    loggerWithLevel(successCallback, errorCallback, args);
 }
 
-function logInfo(args) {
-    return loggerWithLevel(args);
+module.exports.logInfo = async function (successCallback, errorCallback, args) {
+    loggerWithLevel(successCallback, errorCallback, args);
 }
 
-function setLogLevel(level) {
-    return new Promise((resolve) => {
-        // If level is an array (from Cordova), extract the first element
-        if (Array.isArray(level)) {
-            defaultLogLevel = level[0];
-        } else {
-            defaultLogLevel = level;
-        }
-        resolve();
-    });
+module.exports.setLogLevel = function(successCallback, errorCallback, level) {
+    // If level is an array (from Cordova), extract the first element
+    if (Array.isArray(level)) {
+        defaultLogLevel = level[0];
+    } else {
+        defaultLogLevel = level;
+    }
+    successCallback("")
 }
 
-function getLogLevel() {
-    return new Promise((resolve) => {
-        resolve(defaultLogLevel);
-    });
+module.exports.getLogLevel = function(successCallback, errorCallback) {
+    successCallback(defaultLogLevel)
 }
 
-function getLogFileURL(args) {
+module.exports.getLogFileURL = function(successCallback, errorCallback, args) {
     // In browser, we return a data URL or storage reference
-    return `browser://${getStorageKey(args[0].userId, LOG_FILE_NAME)}`;
+    successCallback(`browser://${getStorageKey(args[0].userId, LOG_FILE_NAME)}`);
 }
 
-function getLogFileContent(args) {
-    return new Promise((resolve, reject) => {
-        try {
-            const userId = args[0].userId;
-            const storageKey = getStorageKey(userId, LOG_FILE_NAME);
-            const content = localStorage.getItem(storageKey) || '';
-            resolve(content);
-        } catch (err) {
-            reject(new Error(`Failed to read log file: ${err.message}`));
-        }
-    });
+module.exports.getLogFileContent = async function (successCallback, errorCallback, args) {
+    try {
+        const userId = args[0].userId;
+        const storageKey = getStorageKey(userId, LOG_FILE_NAME);
+        const content = localStorage.getItem(storageKey) || '';
+        successCallback(content);
+    } catch (err) {
+        errorCallback(new Error(`Failed to read log file: ${err.message}`));
+    }
 }
 
-function clearLogFile(args) {
-    return new Promise((resolve, reject) => {
-        try {
-            const userId = args[0].userId;
-            const storageKey = getStorageKey(userId, LOG_FILE_NAME);
-            localStorage.removeItem(storageKey);
-            resolve();
-        } catch (err) {
-            reject(new Error(`Failed to clear log file: ${err.message}`));
-        }
-    });
+module.exports.clearLogFile = async function (successCallback, errorCallback, args) {
+    try {
+        const userId = args[0].userId;
+        const storageKey = getStorageKey(userId, LOG_FILE_NAME);
+        localStorage.removeItem(storageKey);
+        successCallback();
+    } catch (err) {
+        errorCallback(new Error(`Failed to clear log file: ${err.message}`));
+    }
 }
 
-function getBackupLogFileURL(args) {
-    return `browser://${getStorageKey(args[0].userId, BACKUP_LOG_FILE_NAME)}`;
+module.exports.getBackupLogFileURL = function (successCallback, errorCallback, args) {
+    successCallback(`browser://${getStorageKey(args[0].userId, BACKUP_LOG_FILE_NAME)}`);
 }
 
-function getBackupLogFileContent(args) {
-    return new Promise((resolve, reject) => {
-        try {
-            const userId = args[0].userId;
-            const storageKey = getStorageKey(userId, BACKUP_LOG_FILE_NAME);
-            const content = localStorage.getItem(storageKey) || '';
-            resolve(content);
-        } catch (err) {
-            reject(new Error(`Failed to read backup log file: ${err.message}`));
-        }
-    });
+module.exports.getBackupLogFileContent = async function(successCallback, errorCallback, args) {
+    try {
+        const userId = args[0].userId;
+        const storageKey = getStorageKey(userId, BACKUP_LOG_FILE_NAME);
+        const content = localStorage.getItem(storageKey) || '';
+        successCallback(content);
+    } catch (err) {
+        errorCallback(new Error(`Failed to read backup log file: ${err.message}`));
+    }
 }
 
-function copyLogToBackup(args) {
-    return new Promise((resolve, reject) => {
-        try {
-            const userId = args[0].userId;
-            const logStorageKey = getStorageKey(userId, LOG_FILE_NAME);
-            const backupStorageKey = getStorageKey(userId, BACKUP_LOG_FILE_NAME);
-            const logContent = localStorage.getItem(logStorageKey) || '';
-            localStorage.setItem(backupStorageKey, logContent);
-            resolve();
-        } catch (err) {
-            reject(new Error(`Failed to copy log file to backup: ${err.message}`));
-        }
-    });
+module.exports.copyLogToBackup = async function(successCallback, errorCallback, args) {
+    try {
+        const userId = args[0].userId;
+        const logStorageKey = getStorageKey(userId, LOG_FILE_NAME);
+        const backupStorageKey = getStorageKey(userId, BACKUP_LOG_FILE_NAME);
+        const logContent = localStorage.getItem(logStorageKey) || '';
+        localStorage.setItem(backupStorageKey, logContent);
+        successCallback();
+    } catch (err) {
+        errorCallback(new Error(`Failed to copy log file to backup: ${err.message}`));
+    }
 }
 
-function loggerWithLevel(args) {
-    return new Promise(async (resolve, reject) => {
-        try {
-            if (!args || !args[0]) {
-                return reject(new Error("Invalid arguments provided"));
-            }
-            
-            const { userId, level, sourceClass, sourceMethod, message } = args[0];
-            
-            if (!userId) return reject(new Error("userId is required"));
-            if (!level) return reject(new Error("level is required"));
-            if (!message) return reject(new Error("message is required"));
-
-            // Normalize log levels for comparison
-            const normalizedDefaultLogLevel = (defaultLogLevel || '').toLowerCase();
-            const normalizedLevel = (level || '').toLowerCase();
-
-            // Log level filtering using normalized values
-            if (
-                (normalizedDefaultLogLevel === LogLevel.Error && (normalizedLevel === LogLevel.Debug || normalizedLevel === LogLevel.Info)) ||
-                (normalizedDefaultLogLevel === LogLevel.Info && normalizedLevel === LogLevel.Debug)
-            ) {
-                return resolve();
-            }
-
-            await checkAndRotateLogFile(args);
-
-            const currentDate = new Date();
-            const formatter = new Intl.DateTimeFormat('en-US', {
-                day: '2-digit', month: '2-digit', year: 'numeric',
-                hour: '2-digit', minute: '2-digit', second: '2-digit'
-            });
-            const localDateString = formatter.format(currentDate);
-
-            const dateUtc = new Date(currentDate.toUTCString());
-            const utcFormatter = new Intl.DateTimeFormat('en-US', {
-                day: '2-digit', month: '2-digit', year: 'numeric',
-                hour: '2-digit', minute: '2-digit', second: '2-digit', timeZone: 'UTC'
-            });
-            const utcDateString = utcFormatter.format(dateUtc);
-
-            let data = `${localDateString} | UTC:${utcDateString} | ${getStringFromLevel(level)} | ${sourceClass} | ${sourceMethod} | ${message}\n`;
-            if (level === LogLevel.Error) {
-                data = `⭕️⭕️⭕️ ${data}`;
-            }
-
-            // Log to console for browser debugging
-            console.log(data);
-
-            // Store in localStorage
-            const storageKey = getStorageKey(userId, LOG_FILE_NAME);
-            const existingContent = localStorage.getItem(storageKey) || '';
-            const newContent = existingContent + data;
-            
-            // Check size limit
-            if (newContent.length > MAX_LOG_SIZE) {
-                // If content is too large, truncate it
-                const truncatedContent = newContent.substring(newContent.length - MAX_LOG_SIZE / 2);
-                localStorage.setItem(storageKey, truncatedContent);
-            } else {
-                localStorage.setItem(storageKey, newContent);
-            }
-
-            resolve(`Logged to browser storage: ${storageKey}`);
-        } catch (err) {
-            reject(new Error(`Logging failed: ${err.message}`));
+module.exports.loggerWithLevel = async function(successCallback, errorCallback, args) {
+    try {
+        if (!args || !args[0]) {
+            return errorCallback(new Error("Invalid arguments provided"));
+        }
+        
+        const { userId, level, sourceClass, sourceMethod, message } = args[0];
+        
+        if (!userId) return reject(new Error("userId is required"));
+        if (!level) return reject(new Error("level is required"));
+        if (!message) return reject(new Error("message is required"));
+
+        // Normalize log levels for comparison
+        const normalizedDefaultLogLevel = (defaultLogLevel || '').toLowerCase();
+        const normalizedLevel = (level || '').toLowerCase();
+
+        // Log level filtering using normalized values
+        if (
+            (normalizedDefaultLogLevel === LogLevel.Error && (normalizedLevel === LogLevel.Debug || normalizedLevel === LogLevel.Info)) ||
+            (normalizedDefaultLogLevel === LogLevel.Info && normalizedLevel === LogLevel.Debug)
+        ) {
+            return successCallback();
+        }
+
+        await checkAndRotateLogFile(args);
+
+        const currentDate = new Date();
+        const formatter = new Intl.DateTimeFormat('en-US', {
+            day: '2-digit', month: '2-digit', year: 'numeric',
+            hour: '2-digit', minute: '2-digit', second: '2-digit'
+        });
+        const localDateString = formatter.format(currentDate);
+
+        const dateUtc = new Date(currentDate.toUTCString());
+        const utcFormatter = new Intl.DateTimeFormat('en-US', {
+            day: '2-digit', month: '2-digit', year: 'numeric',
+            hour: '2-digit', minute: '2-digit', second: '2-digit', timeZone: 'UTC'
+        });
+        const utcDateString = utcFormatter.format(dateUtc);
+
+        let data = `${localDateString} | UTC:${utcDateString} | ${getStringFromLevel(level)} | ${sourceClass} | ${sourceMethod} | ${message}\n`;
+        if (level === LogLevel.Error) {
+            data = `⭕️⭕️⭕️ ${data}`;
         }
-    });
+
+        // Log to console for browser debugging
+        console.log(data);
+
+        // Store in localStorage
+        const storageKey = getStorageKey(userId, LOG_FILE_NAME);
+        const existingContent = localStorage.getItem(storageKey) || '';
+        const newContent = existingContent + data;
+        
+        // Check size limit
+        if (newContent.length > MAX_LOG_SIZE) {
+            // If content is too large, truncate it
+            const truncatedContent = newContent.substring(newContent.length - MAX_LOG_SIZE / 2);
+            localStorage.setItem(storageKey, truncatedContent);
+        } else {
+            localStorage.setItem(storageKey, newContent);
+        }
+
+        successCallback(`Logged to browser storage: ${storageKey}`);
+    } catch (err) {
+        errorCallback(new Error(`Logging failed: ${err.message}`));
+    }
 }
 
-function getStringFromLevel(level) {
+module.exports.getStringFromLevel = async function (successCallback, errorCallback, level) {
     switch (level) {
-        case LogLevel.Info: return 'IMPORTANT';
-        case LogLevel.Error: return 'ERROR';
-        case LogLevel.Debug: return 'DEBUG';
-        default: return '';
+        case LogLevel.Info: successCallback('IMPORTANT');return;
+        case LogLevel.Error: successCallback('ERROR');return;
+        case LogLevel.Debug: successCallback('DEBUG');return;
+        default: successCallback('');return;
     }
 }
 
-function checkAndRotateLogFile(args) {
-    return new Promise(async (resolve, reject) => {
-        try {
-            const userId = args[0].userId;
-            const storageKey = getStorageKey(userId, LOG_FILE_NAME);
-            const content = localStorage.getItem(storageKey) || '';
-            
-            if (content.length > MAX_LOG_SIZE) {
-                const backupStorageKey = getStorageKey(userId, BACKUP_LOG_FILE_NAME);
-                localStorage.setItem(backupStorageKey, content);
-                localStorage.setItem(storageKey, '');
-            }
-            resolve();
-        } catch (err) {
-            reject(new Error(`Failed to rotate log file: ${err.message}`));
+module.exports.checkAndRotateLogFile = async function (successCallback, errorCallback, args) {
+    try {
+        const userId = args[0].userId;
+        const storageKey = getStorageKey(userId, LOG_FILE_NAME);
+        const content = localStorage.getItem(storageKey) || '';
+        
+        if (content.length > MAX_LOG_SIZE) {
+            const backupStorageKey = getStorageKey(userId, BACKUP_LOG_FILE_NAME);
+            localStorage.setItem(backupStorageKey, content);
+            localStorage.setItem(storageKey, '');
         }
-    });
+        successCallback();
+    } catch (err) {
+        errorCallback(new Error(`Failed to rotate log file: ${err.message}`));
+    }
 }
 
-// Export for browser environment
-if (typeof module !== 'undefined' && module.exports) {
-    module.exports = {
-        logDebug,
-        logError,
-        logInfo,
-        setLogLevel,
-        getLogLevel,
-        getLogFileContent,
-        clearLogFile,
-        getBackupLogFileContent,
-        LogLevel,
-        copyLogToBackup,
-        getLogFileURL,
-        getBackupLogFileURL,
-    };
-    require('cordova/exec/proxy').add('UnviredLogger', module.exports);
-} else if (typeof window !== 'undefined') {
-    // Browser environment
-    window.UnviredLogger = {
-        logDebug,
-        logError,
-        logInfo,
-        setLogLevel,
-        getLogLevel,
-        getLogFileContent,
-        clearLogFile,
-        getBackupLogFileContent,
-        LogLevel,
-        copyLogToBackup,
-        getLogFileURL,
-        getBackupLogFileURL,
-    };
-    window.Logger = window.UnviredLogger;
-    require('cordova/exec/proxy').add('UnviredLogger', window.Logger);
-} 
+require('cordova/exec/proxy').add('Logger', module.exports);