web-manager 3.2.74 → 4.0.0

package/dist/modules/firestore.js

@@ -0,0 +1,242 @@
+class Firestore {
+  constructor(manager) {
+    this.manager = manager;
+    this._db = null;
+    this._initialized = false;
+    this._initPromise = null;
+  }
+
+  async _ensureInitialized() {
+    if (this._initialized) {
+      return this._db;
+    }
+
+    if (!this._initPromise) {
+      this._initPromise = this._initializeFirestore();
+    }
+
+    return this._initPromise;
+  }
+
+  async _initializeFirestore() {
+    try {
+      // Check if Firebase app is initialized
+      if (!this.manager._firebaseApp) {
+        throw new Error('Firebase app not initialized. Please initialize Firebase first.');
+      }
+
+      // Dynamically import Firestore
+      const { getFirestore, doc: firestoreDoc, collection: firestoreCollection, getDoc, setDoc, updateDoc, deleteDoc, getDocs, query, where, orderBy, limit, startAt, endAt } = await import('firebase/firestore');
+      
+      // Store references for later use
+      this._firestoreMethods = {
+        getFirestore,
+        doc: firestoreDoc,
+        collection: firestoreCollection,
+        getDoc,
+        setDoc,
+        updateDoc,
+        deleteDoc,
+        getDocs,
+        query,
+        where,
+        orderBy,
+        limit,
+        startAt,
+        endAt
+      };
+
+      // Initialize Firestore
+      this._db = getFirestore(this.manager._firebaseApp);
+      this._initialized = true;
+
+      return this._db;
+    } catch (error) {
+      console.error('Failed to initialize Firestore:', error);
+      throw error;
+    }
+  }
+
+  // Main doc() method - supports both 'path/to/doc' and ('collection', 'docId')
+  doc(...args) {
+    const self = this;
+    let docPath;
+
+    // Handle different argument patterns
+    if (args.length === 1 && typeof args[0] === 'string') {
+      // Single path string: doc('users/userId')
+      docPath = args[0];
+    } else if (args.length === 2 && typeof args[0] === 'string' && typeof args[1] === 'string') {
+      // Collection and doc ID: doc('users', 'userId')
+      docPath = `${args[0]}/${args[1]}`;
+    } else {
+      throw new Error('Invalid arguments for doc(). Use doc("path/to/doc") or doc("collection", "docId")');
+    }
+
+    return {
+      async get() {
+        await self._ensureInitialized();
+        const docRef = self._firestoreMethods.doc(self._db, docPath);
+        const docSnap = await self._firestoreMethods.getDoc(docRef);
+        
+        return {
+          exists: () => docSnap.exists(),
+          data: () => docSnap.data(),
+          id: docSnap.id,
+          ref: docRef
+        };
+      },
+
+      async set(data, options = {}) {
+        await self._ensureInitialized();
+        const docRef = self._firestoreMethods.doc(self._db, docPath);
+        return await self._firestoreMethods.setDoc(docRef, data, options);
+      },
+
+      async update(data) {
+        await self._ensureInitialized();
+        const docRef = self._firestoreMethods.doc(self._db, docPath);
+        return await self._firestoreMethods.updateDoc(docRef, data);
+      },
+
+      async delete() {
+        await self._ensureInitialized();
+        const docRef = self._firestoreMethods.doc(self._db, docPath);
+        return await self._firestoreMethods.deleteDoc(docRef);
+      }
+    };
+  }
+
+  // Collection method for queries
+  collection(collectionPath) {
+    const self = this;
+    
+    return {
+      async get() {
+        await self._ensureInitialized();
+        const collRef = self._firestoreMethods.collection(self._db, collectionPath);
+        const querySnapshot = await self._firestoreMethods.getDocs(collRef);
+        
+        return {
+          docs: querySnapshot.docs.map(doc => ({
+            id: doc.id,
+            data: () => doc.data(),
+            exists: () => doc.exists(),
+            ref: doc.ref
+          })),
+          size: querySnapshot.size,
+          empty: querySnapshot.empty,
+          forEach: (callback) => querySnapshot.forEach(callback)
+        };
+      },
+
+      where(field, operator, value) {
+        return self._buildQuery(collectionPath, [{ type: 'where', field, operator, value }]);
+      },
+
+      orderBy(field, direction = 'asc') {
+        return self._buildQuery(collectionPath, [{ type: 'orderBy', field, direction }]);
+      },
+
+      limit(count) {
+        return self._buildQuery(collectionPath, [{ type: 'limit', count }]);
+      },
+
+      doc(docId) {
+        if (docId) {
+          return self.doc(`${collectionPath}/${docId}`);
+        }
+        // Auto-generate ID if not provided
+        return self.doc(`${collectionPath}/${self._generateId()}`);
+      }
+    };
+  }
+
+  // Build chainable query
+  _buildQuery(collectionPath, constraints = []) {
+    const self = this;
+
+    const queryBuilder = {
+      where(field, operator, value) {
+        constraints.push({ type: 'where', field, operator, value });
+        return queryBuilder;
+      },
+
+      orderBy(field, direction = 'asc') {
+        constraints.push({ type: 'orderBy', field, direction });
+        return queryBuilder;
+      },
+
+      limit(count) {
+        constraints.push({ type: 'limit', count });
+        return queryBuilder;
+      },
+
+      startAt(...values) {
+        constraints.push({ type: 'startAt', values });
+        return queryBuilder;
+      },
+
+      endAt(...values) {
+        constraints.push({ type: 'endAt', values });
+        return queryBuilder;
+      },
+
+      async get() {
+        await self._ensureInitialized();
+        const collRef = self._firestoreMethods.collection(self._db, collectionPath);
+        
+        // Build query constraints
+        const queryConstraints = [];
+        for (const constraint of constraints) {
+          switch (constraint.type) {
+            case 'where':
+              queryConstraints.push(self._firestoreMethods.where(constraint.field, constraint.operator, constraint.value));
+              break;
+            case 'orderBy':
+              queryConstraints.push(self._firestoreMethods.orderBy(constraint.field, constraint.direction));
+              break;
+            case 'limit':
+              queryConstraints.push(self._firestoreMethods.limit(constraint.count));
+              break;
+            case 'startAt':
+              queryConstraints.push(self._firestoreMethods.startAt(...constraint.values));
+              break;
+            case 'endAt':
+              queryConstraints.push(self._firestoreMethods.endAt(...constraint.values));
+              break;
+          }
+        }
+
+        const q = self._firestoreMethods.query(collRef, ...queryConstraints);
+        const querySnapshot = await self._firestoreMethods.getDocs(q);
+        
+        return {
+          docs: querySnapshot.docs.map(doc => ({
+            id: doc.id,
+            data: () => doc.data(),
+            exists: () => doc.exists(),
+            ref: doc.ref
+          })),
+          size: querySnapshot.size,
+          empty: querySnapshot.empty,
+          forEach: (callback) => querySnapshot.forEach(callback)
+        };
+      }
+    };
+
+    return queryBuilder;
+  }
+
+  // Helper to generate document IDs (similar to Firebase auto-generated IDs)
+  _generateId() {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    let id = '';
+    for (let i = 0; i < 20; i++) {
+      id += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return id;
+  }
+}
+
+export default Firestore;

package/dist/modules/notifications.js

@@ -0,0 +1,285 @@
+class Notifications {
+  constructor(manager) {
+    this.manager = manager;
+    this._requestInProgress = false;
+  }
+
+  // Check if notifications are supported
+  isSupported() {
+    return 'Notification' in window && 
+           'serviceWorker' in navigator && 
+           this.manager.firebaseMessaging !== undefined;
+  }
+
+  // Check if user is subscribed to notifications
+  async isSubscribed() {
+    try {
+      if (!this.isSupported()) {
+        return false;
+      }
+
+      return Notification.permission === 'granted';
+    } catch (error) {
+      console.error('Check subscription error:', error);
+      return false;
+    }
+  }
+
+  // Subscribe to push notifications
+  async subscribe(options = {}) {
+    try {
+      if (!this.isSupported()) {
+        throw new Error('Push notifications are not supported');
+      }
+
+      if (this._requestInProgress) {
+        throw new Error('Subscription request already in progress');
+      }
+
+      this._requestInProgress = true;
+
+      // Get Firebase messaging
+      const messaging = this.manager.firebaseMessaging;
+      if (!messaging) {
+        throw new Error('Firebase Messaging not initialized');
+      }
+
+      // Get service worker registration
+      const swRegistration = this.manager.state.serviceWorker;
+      if (!swRegistration) {
+        throw new Error('Service Worker not registered');
+      }
+
+      // Request notification permission if not already granted
+      if (Notification.permission === 'default') {
+        const permission = await Notification.requestPermission();
+        if (permission !== 'granted') {
+          throw new Error('Notification permission denied');
+        }
+      } else if (Notification.permission === 'denied') {
+        throw new Error('Notification permission denied');
+      }
+
+      // Get FCM token
+      const { getToken } = await import('firebase/messaging');
+      const token = await getToken(messaging, {
+        serviceWorkerRegistration: swRegistration,
+        vapidKey: options.vapidKey
+      });
+
+      if (!token) {
+        throw new Error('Failed to get FCM token');
+      }
+
+      // Save subscription info
+      await this._saveSubscription(token);
+
+      // Track in local storage
+      const storage = this.manager.storage();
+      storage.set('notifications', {
+        subscribed: true,
+        token: token,
+        subscribedAt: new Date().toISOString(),
+        uid: this.manager.auth().getUser()?.uid || null
+      });
+
+      this._requestInProgress = false;
+      return { subscribed: true, token };
+
+    } catch (error) {
+      this._requestInProgress = false;
+      console.error('Subscribe error:', error);
+      throw error;
+    }
+  }
+
+  // Unsubscribe from push notifications
+  async unsubscribe() {
+    try {
+      if (!this.isSupported()) {
+        return false;
+      }
+
+      const { deleteToken } = await import('firebase/messaging');
+      const messaging = this.manager.firebaseMessaging;
+      
+      if (messaging) {
+        await deleteToken(messaging);
+      }
+
+      // Clear local storage
+      const storage = this.manager.storage();
+      storage.remove('notifications');
+
+      return true;
+    } catch (error) {
+      console.error('Unsubscribe error:', error);
+      throw error;
+    }
+  }
+
+  // Request permission (without subscribing)
+  async requestPermission() {
+    try {
+      if (!('Notification' in window)) {
+        throw new Error('Notifications not supported');
+      }
+
+      const permission = await Notification.requestPermission();
+      return permission === 'granted';
+    } catch (error) {
+      console.error('Request permission error:', error);
+      return false;
+    }
+  }
+
+  // Get current FCM token
+  async getToken() {
+    try {
+      if (!this.isSupported()) {
+        return null;
+      }
+
+      const messaging = this.manager.firebaseMessaging;
+      if (!messaging) {
+        return null;
+      }
+
+      const { getToken } = await import('firebase/messaging');
+      const swRegistration = this.manager.state.serviceWorker;
+      
+      return await getToken(messaging, {
+        serviceWorkerRegistration: swRegistration
+      });
+    } catch (error) {
+      console.error('Get token error:', error);
+      return null;
+    }
+  }
+
+  // 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 {
+      if (!this.isSupported()) {
+        return () => {};
+      }
+
+      const { onMessage } = await import('firebase/messaging');
+      const messaging = this.manager.firebaseMessaging;
+      
+      if (!messaging) {
+        return () => {};
+      }
+
+      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;
+          
+          const notification = new Notification(title, {
+            body,
+            icon,
+            badge,
+            image,
+            data: payload.data,
+            requireInteraction: false,
+          });
+
+          notification.onclick = (event) => {
+            event.preventDefault();
+            if (clickAction) {
+              window.open(clickAction, '_blank');
+            }
+            notification.close();
+          };
+        }
+
+        callback(payload);
+      });
+    } catch (error) {
+      console.error('Message listener error:', error);
+      return () => {};
+    }
+  }
+
+  // Save subscription to Firestore
+  async _saveSubscription(token) {
+    try {
+      const firestore = this.manager.firebaseFirestore;
+      const user = this.manager.auth().getUser();
+      
+      if (!firestore || !token) {
+        return;
+      }
+
+      const { doc, setDoc, serverTimestamp } = await import('firebase/firestore');
+      
+      const subscriptionData = {
+        token,
+        platform: 'web',
+        userAgent: navigator.userAgent,
+        tags: ['general'],
+        created: serverTimestamp(),
+        updated: serverTimestamp(),
+      };
+
+      if (user) {
+        subscriptionData.userId = user.uid;
+        subscriptionData.userEmail = user.email;
+      }
+
+      // Save to notifications collection
+      await setDoc(
+        doc(firestore, 'notifications', token),
+        subscriptionData,
+        { merge: true }
+      );
+
+      // If user is authenticated, also save reference in user document
+      if (user) {
+        await setDoc(
+          doc(firestore, 'users', user.uid, 'notifications', token),
+          {
+            token,
+            created: serverTimestamp(),
+            active: true
+          },
+          { merge: true }
+        );
+      }
+    } catch (error) {
+      console.error('Save subscription error:', error);
+      // Don't throw - this is not critical for the subscription process
+    }
+  }
+}
+
+export default Notifications;

package/dist/modules/sentry.js

@@ -0,0 +1,166 @@
+class SentryModule {
+  constructor(manager) {
+    this.manager = manager;
+    this.initialized = false;
+    this.Sentry = null;
+    this.config = null;
+  }
+
+  /**
+   * Initialize Sentry error tracking
+   * @param {Object} config - Sentry configuration object
+   * @returns {Promise} Resolves when initialization is complete
+   */
+  init(config = {}) {
+    return new Promise((resolve, reject) => {
+      // Dynamically import Sentry to reduce initial bundle size
+      import('@sentry/browser')
+        .then((SentryModule) => {
+          // Store reference and expose globally
+          this.Sentry = SentryModule;
+          window.Sentry = SentryModule;
+
+          // Build configuration with our defaults
+          this.config = this._buildConfig(config);
+
+          // Initialize Sentry
+          this.Sentry.init(this.config);
+          this.initialized = true;
+
+          resolve({ initialized: true });
+        })
+        .catch((error) => {
+          console.error('[Sentry] Failed to initialize:', error);
+          reject(error);
+        });
+    });
+  }
+
+  /**
+   * Build Sentry configuration with defaults and integrations
+   * @private
+   */
+  _buildConfig(userConfig) {
+    const config = { ...userConfig };
+    const manager = this.manager;
+
+    // Set release version and environment
+    config.release = `${manager.config.brand.id}@${manager.config.buildTime}`;
+    config.environment = manager.config.environment || 'production';
+    config.integrations = config.integrations || [];
+
+    // Add browser tracing integration if not already present
+    if (!config.integrations.some(i => i.name === 'BrowserTracing')) {
+      config.integrations.push(this.Sentry.browserTracingIntegration());
+    }
+
+    // Add replay integration if sample rates are configured
+    const hasReplays = (config.replaysSessionSampleRate > 0) ||
+                      (config.replaysOnErrorSampleRate > 0);
+
+    if (hasReplays && !config.integrations.some(i => i.name === 'Replay')) {
+      config.integrations.push(this.Sentry.replayIntegration({
+        maskAllText: false,
+        blockAllMedia: false,
+      }));
+    }
+
+    // Configure beforeSend to enrich events with user data and session info
+    config.beforeSend = (event, hint) => {
+      const startTime = this.manager.config.page.startTime || Date.now();
+      const hoursSinceStart = (Date.now() - startTime) / (1000 * 3600);
+      const storage = this.manager.storage();
+
+      // Add custom tags
+      event.tags = {
+        ...event.tags,
+        'process.type': 'browser',
+        'usage.session.hours': hoursSinceStart.toFixed(2),
+      };
+
+      // Add user info from storage
+      event.user = {
+        ...event.user,
+        email: storage.get('user.auth.email', ''),
+        uid: storage.get('user.auth.uid', ''),
+      };
+
+      // Log error to console for debugging
+      console.error('[Sentry] Caught error:', {
+        message: event.message || (event.exception?.values?.[0]?.value) || 'Unknown error',
+        level: event.level,
+        tags: event.tags,
+        user: event.user,
+        hint
+      });
+
+      // Block sending in development mode
+      if (this.manager.isDevelopment()) {
+        console.log('[Sentry] Development mode - not sending to Sentry');
+        return null;
+      }
+
+      return event;
+    };
+
+    return config;
+  }
+
+  /**
+   * Capture an exception and send to Sentry
+   * Safe to call even if Sentry is not initialized
+   * @param {Error} error - The error to capture
+   * @param {Object} captureContext - Additional context for the error
+   * @returns {string|null} Event ID if successful, null otherwise
+   */
+  captureException(error, captureContext) {
+    // Log the error
+    console.error('[Sentry] Capturing exception:', error);
+
+    // Safe to call - won't throw if not initialized
+    if (!this.initialized) {
+      console.log('[Sentry] Not initialized, skipping capture');
+      return null;
+    }
+
+    // Call Sentry to capture the exception
+    try {
+      return this.Sentry.captureException(error, captureContext);
+    } catch (captureError) {
+      console.error('[Sentry] Failed to capture exception:', captureError);
+      return null;
+    }
+  }
+
+  // /**
+  //  * Capture a message and send to Sentry
+  //  * Safe to call even if Sentry is not initialized
+  //  * @param {string} message - The message to capture
+  //  * @param {string} level - Severity level (debug, info, warning, error, fatal)
+  //  * @param {Object} captureContext - Additional context for the message
+  //  * @returns {string|null} Event ID if successful, null otherwise
+  //  */
+  // captureMessage(message, level = 'info', captureContext) {
+  //   if (!message) {
+  //     console.warn('[Sentry] captureMessage called with no message');
+  //     return null;
+  //   }
+
+  //   console.log(`[Sentry] Capturing message (${level}):`, message);
+
+  //   // Safe to call - won't throw if not initialized
+  //   if (!this.initialized || !this.Sentry) {
+  //     console.log('[Sentry] Not initialized, skipping capture');
+  //     return null;
+  //   }
+
+  //   try {
+  //     return this.Sentry.captureMessage(message, level, captureContext);
+  //   } catch (captureError) {
+  //     console.error('[Sentry] Failed to capture message:', captureError);
+  //     return null;
+  //   }
+  // }
+}
+
+export default SentryModule;