web-manager 4.0.15 → 4.0.17

package/dist/index.js

@@ -311,6 +311,11 @@ class Manager {
     const { getFirestore } = await import('firebase/firestore');
     const { getMessaging } = await import('firebase/messaging');
 
+    // If we're in devmode, set the firebase config authDomain to the current host
+    // if (this.isDevelopment() && firebaseConfig) {
+    //   firebaseConfig.authDomain = window.location.hostname;
+    // }
+
     // Initialize Firebase
     const app = initializeApp(firebaseConfig);
 

package/dist/modules/notifications.js

@@ -121,7 +121,7 @@ class Notifications {
   // Request permission (without subscribing)
   async requestPermission() {
     try {
-      if (!('Notification' in window)) {
+      if (!this.isSupported()) {
         throw new Error('Notifications not supported');
       }
 
@@ -157,31 +157,6 @@ class Notifications {
     }
   }
 
-  // Listen for token refresh
-  async onTokenRefresh(callback) {
-    try {
-      if (!this.isSupported()) {
-        return () => {};
-      }
-
-      const { onMessage } = await import('firebase/messaging');
-      const messaging = this.manager.firebaseMessaging;
-
-      if (!messaging) {
-        return () => {};
-      }
-
-      return onMessage(messaging, (payload) => {
-        if (payload.data?.refreshToken) {
-          callback(payload.data.token);
-        }
-      });
-    } catch (error) {
-      console.error('Token refresh listener error:', error);
-      return () => {};
-    }
-  }
-
   // Listen for foreground messages
   async onMessage(callback) {
     try {
@@ -199,30 +174,47 @@ class Notifications {
       return onMessage(messaging, (payload) => {
         console.log('Foreground message received:', payload);
 
-        // Show notification if app is in foreground
-        if (payload.notification) {
-          const { title, body, icon, badge, image } = payload.notification;
-          const clickAction = payload.data?.click_action || payload.notification.click_action;
+        // Extract notification data - handle both payload.notification and payload.data formats
+        const notificationData = payload.notification || payload.data || {};
+        const { title, body, icon, badge, image, click_action, url, tag } = notificationData;
 
+        // Determine the click URL (prioritize click_action, then url, then data.url)
+        const clickUrl = click_action || url || payload.data?.click_action || payload.data?.url;
+
+        // Show notification if we have at least a title
+        if (title) {
           const notification = new Notification(title, {
-            body,
-            icon,
-            badge,
-            image,
-            data: payload.data,
-            requireInteraction: false,
+            body: body || '',
+            icon: icon || '/favicon.ico',
+            badge: badge,
+            image: image,
+            tag: tag || 'default',
+            data: { ...payload.data, clickUrl },
+            requireInteraction: true,
+            renotify: true
           });
 
           notification.onclick = (event) => {
             event.preventDefault();
-            if (clickAction) {
-              window.open(clickAction, '_blank');
+
+            // Focus or open the target window
+            if (clickUrl) {
+              // Try to find an existing window/tab with this URL
+              window.focus();
+              window.open(clickUrl, '_blank');
+            } else {
+              // Just focus the current window if no URL
+              window.focus();
             }
+
             notification.close();
           };
         }
 
-        callback(payload);
+        // Call the user's callback with the full payload
+        if (callback) {
+          callback(payload);
+        }
       });
     } catch (error) {
       console.error('Message listener error:', error);
@@ -230,6 +222,35 @@ class Notifications {
     }
   }
 
+  // Sync subscription when auth state changes
+  async syncSubscription() {
+    try {
+      // Check if we have a stored notification token
+      const storage = this.manager.storage();
+      const storedNotification = storage.get('notifications');
+
+      if (!storedNotification?.token) {
+        return false;
+      }
+
+      // Update the subscription in Firestore with current auth state
+      await this._saveSubscription(storedNotification.token);
+
+      // Update local storage with current user ID
+      const user = this.manager.auth().getUser();
+      storage.set('notifications', {
+        ...storedNotification,
+        uid: user?.uid || null,
+        timestamp: new Date().toISOString()
+      });
+
+      return true;
+    } catch (error) {
+      console.error('Sync subscription error:', error);
+      return false;
+    }
+  }
+
   // Save subscription to Firestore
   async _saveSubscription(token) {
     try {
@@ -240,41 +261,97 @@ class Notifications {
         return;
       }
 
-      const { doc, setDoc, serverTimestamp } = await import('firebase/firestore');
+      const { doc, getDoc, setDoc, updateDoc, deleteDoc } = await import('firebase/firestore');
+      const { getContext } = await import('./utilities.js');
 
-      const subscriptionData = {
-        token,
-        platform: 'web',
-        userAgent: navigator.userAgent,
-        tags: ['general'],
-        created: serverTimestamp(),
-        updated: serverTimestamp(),
-      };
+      const now = new Date();
+      const timestamp = now.toISOString();
+      const timestampUNIX = Math.floor(now.getTime() / 1000);
 
-      if (user) {
-        subscriptionData.userId = user.uid;
-        subscriptionData.userEmail = user.email;
-      }
+      // Get context for client information
+      const context = getContext();
+      const clientData = context.client;
+
+      // Reference to the notification document (ID is the token)
+      const notificationRef = doc(firestore, 'notifications', token);
+
+      // Check if document already exists
+      const existingDoc = await getDoc(notificationRef);
+      const existingData = existingDoc.exists() ? existingDoc.data() : null;
 
-      // Save to notifications collection
-      await setDoc(
-        doc(firestore, 'notifications', token),
-        subscriptionData,
-        { merge: true }
-      );
+      // Determine if we need to update
+      const currentUid = user?.uid || null;
+      const existingUid = existingData?.uid || null;
+      const needsUpdate = existingUid !== currentUid;
 
-      // If user is authenticated, also save reference in user document
-      if (user) {
+      if (!existingData) {
+        // New subscription - create the document
+        const subscriptionData = {
+          token,
+          context: {
+            client: clientData
+          },
+          tags: ['general'],
+          created: {
+            timestamp,
+            timestampUNIX
+          },
+          updated: {
+            timestamp,
+            timestampUNIX
+          },
+          uid: currentUid
+        };
+
+        await setDoc(notificationRef, subscriptionData);
+
+      } else if (needsUpdate) {
+        // Existing subscription needs update (userId changed)
+        const updateData = {
+          context: {
+            client: clientData
+          },
+          updated: {
+            timestamp,
+            timestampUNIX
+          },
+          uid: currentUid
+        };
+
+        await updateDoc(notificationRef, updateData);
+      }
+      // If no update needed, do nothing
+
+      // Update user's notification reference if authenticated
+      if (user && (!existingData || needsUpdate)) {
         await setDoc(
           doc(firestore, 'users', user.uid, 'notifications', token),
           {
             token,
-            created: serverTimestamp(),
+            created: existingData?.created || {
+              timestamp,
+              timestampUNIX
+            },
+            updated: {
+              timestamp,
+              timestampUNIX
+            },
             active: true
           },
           { merge: true }
         );
       }
+
+      // Remove old user reference if user changed
+      if (existingUid && existingUid !== currentUid && existingUid !== null) {
+        try {
+          await deleteDoc(doc(firestore, 'users', existingUid, 'notifications', token));
+        } catch (err) {
+          // Ignore errors when cleaning up old references
+          console.log('Could not clean up old user notification reference:', err.message);
+        }
+      }
+
     } catch (error) {
       console.error('Save subscription error:', error);
       // Don't throw - this is not critical for the subscription process

package/dist/modules/utilities.js

@@ -60,22 +60,22 @@ export function showNotification(message, options = {}) {
   // Handle different input types
   let text = message;
   let type = options.type || 'info';
-  
+
   // If message is an Error object, extract message and default to danger
   if (message instanceof Error) {
     text = message.message;
     type = options.type || 'danger';
   }
-  
+
   // Handle string as second parameter for backwards compatibility
   if (typeof options === 'string') {
     options = { type: options };
     type = options.type;
   }
-  
+
   // Extract options
   const timeout = options.timeout !== undefined ? options.timeout : 5000;
-  
+
   const $notification = document.createElement('div');
   $notification.className = `alert alert-${type} alert-dismissible fade show position-fixed top-0 start-50 translate-middle-x mt-5`;
   $notification.style.zIndex = '9999';
@@ -116,28 +116,50 @@ export function getContext() {
     }
   }
 
+  // Get platform
+  function getPlatform() {
+    const platform = (navigator.userAgentData?.platform || navigator.platform || 'unknown').toLowerCase();
+
+    if (/iphone|ipad|ipod/.test(platform)) {
+      return 'ios';
+    } else if (/android/.test(platform)) {
+      return 'android';
+    } else if (/win/.test(platform)) {
+      return 'windows';
+    } else if (/mac/.test(platform)) {
+      return 'macos';
+    } else if (/linux/.test(platform)) {
+      return 'linux';
+    } else if (/cros/.test(platform)) {
+      return 'chromeos';
+    } else {
+      return 'unknown';
+    }
+  }
+
   // Return context information
   return {
     client: {
+      language: navigator.language,
       mobile: isMobile(),
+      platform: getPlatform(),
+      userAgent: navigator.userAgent,
+      url: window.location.href,
     },
     browser: {
-      userAgent: navigator.userAgent,
-      language: navigator.language,
-      platform: navigator.platform,
       vendor: navigator.vendor,
     },
-    screen: {
-      width: window.screen?.width,
-      height: window.screen?.height,
-      availWidth: window.screen?.availWidth,
-      availHeight: window.screen?.availHeight,
-      colorDepth: window.screen?.colorDepth,
-      pixelRatio: window.devicePixelRatio || 1,
-    },
-    viewport: {
-      width: window.innerWidth,
-      height: window.innerHeight,
-    }
+    // screen: {
+    //   width: window.screen?.width,
+    //   height: window.screen?.height,
+    //   availWidth: window.screen?.availWidth,
+    //   availHeight: window.screen?.availHeight,
+    //   colorDepth: window.screen?.colorDepth,
+    //   pixelRatio: window.devicePixelRatio || 1,
+    // },
+    // viewport: {
+    //   width: window.innerWidth,
+    //   height: window.innerHeight,
+    // }
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "web-manager",
-  "version": "4.0.15",
+  "version": "4.0.17",
   "description": "Easily access important variables such as the query string, current domain, and current page in a single object.",
   "main": "dist/index.js",
   "module": "src/index.js",