@posiwise/common-services 0.2.13 → 0.2.15

package/fesm2022/posiwise-common-services.mjs

@@ -984,10 +984,12 @@ class AuthService {
         this.integrationsApi = integrationsApi;
         this.document = document;
         this.platformSubject = new BehaviorSubject('');
+        this.userDataSubject = new BehaviorSubject({});
         this.twitterEndpoint = '/twitter';
         this.header_key = 'browser';
         this.platform = '';
         this.platform$ = this.platformSubject.asObservable();
+        this.userData$ = this.userDataSubject.asObservable();
         // Set Header Key
         this.setHeaderKey();
     }
@@ -1108,11 +1110,12 @@ class AuthService {
                 phonegap: true
             };
         }
-        // Send DELETE request with token intact, then clear tokens after response
-        // Use tap to clear tokens without changing the response stream
         return this.http.delete('session', options).pipe(tap$1(() => {
-            // Clear tokens AFTER logout succeeds
             this.secureTokenStorage.clearTokens().subscribe();
+            // Reset Crisp session on logout so next visitor is anonymous again
+            if (window && window.$crisp && typeof window.$crisp.push === 'function') {
+                window.$crisp.push(['do', 'session:reset']);
+            }
         }));
     }
     /**
@@ -1130,6 +1133,23 @@ class AuthService {
     getToken$() {
         return this.secureTokenStorage.getToken$();
     }
+    /**
+     * Get user data (email, name, userId) after login
+     * Similar to getToken$() but returns user information
+     * @returns Observable with user data: { email?: string; name?: string; userId?: string }
+     */
+    getUserData$() {
+        console.log(this.userData$);
+        return this.userData$;
+    }
+    /**
+     * Set user data in the BehaviorSubject
+     * Called after user logs in to update user information across the app
+     * @param userData User data object with email, name, and userId
+     */
+    setUserData(userData) {
+        this.userDataSubject.next(userData);
+    }
     getNewsletterSubscription(token) {
         return this.http.get(`${NEWSLETTER_CONFIRMATION_PATH}?token=${token}`);
     }
@@ -1195,7 +1215,33 @@ class AuthService {
             return this.userService.getUserInfo();
         }));
         sequence$.subscribe(resp => {
-            localStorage.setItem('name', resp.first_name);
+            const firstName = resp.first_name ?? '';
+            const email = resp.email ?? '';
+            const userId = resp.id?.toString() ?? '';
+            localStorage.setItem('name', firstName);
+            localStorage.setItem('userEmail', email);
+            localStorage.setItem('userId', userId);
+            this.setUserData({
+                name: firstName,
+                email: email,
+                userId: userId
+            });
+            // Identify logged-in user in Crisp if widget is already loaded
+            if (window && window.$crisp && typeof window.$crisp.push === 'function') {
+                if (email) {
+                    window.$crisp.push(['set', 'user:email', email]);
+                }
+                if (firstName) {
+                    window.$crisp.push(['set', 'user:nickname', firstName]);
+                }
+                if (userId) {
+                    window.$crisp.push([
+                        'set',
+                        'session:data',
+                        [['user_id', [userId]]]
+                    ]);
+                }
+            }
             this.router.navigate(['home']);
             if ($('.cc-dismiss').length > 0) {
                 $('.cc-dismiss')[0].click();
@@ -2920,97 +2966,7 @@ class SentryErrorHandler {
                 // NOTE: We intentionally do not enable Performance Tracing here.
                 // The previous integration (`BrowserTracing` + `routingInstrumentation`) was part of
                 // the legacy `@sentry/angular-ivy` API and isn't available in `@sentry/angular` v10.
-                beforeSend(event, hint) {
-                    const initialExceptionValuesLength = Array.isArray(event?.exception?.values)
-                        ? event.exception.values.length
-                        : undefined;
-                    const safeIncludes = (val, needle) => typeof val === 'string' && val.includes(needle);
-                    // Check if the event is of type CloseEvent and ignore it
-                    if (event?.exception?.values) {
-                        event.exception.values = event.exception.values.filter(value => {
-                            // Update the condition based on the actual structure of the event
-                            return !(value.type === 'CloseEvent' ||
-                                safeIncludes(value.value, 'CloseEvent'));
-                        });
-                    }
-                    if (event?.exception?.values) {
-                        event.exception.values = event.exception.values.filter(value => {
-                            // Check for the specific error message and ignore it
-                            return !(value.type === 'Error' &&
-                                safeIncludes(value.value, 'ResizeObserver loop completed'));
-                        });
-                    }
-                    // originates from vendor.js file
-                    if (event?.exception?.values) {
-                        const isJsonParsingError = event.exception.values.some(value => {
-                            return (value.type === 'SyntaxError' &&
-                                value?.value?.includes("expected ':' after property name in"));
-                        });
-                        if (isJsonParsingError) {
-                            return null;
-                        }
-                    }
-                    // Check if the event is a ChunkLoadError and ignore it (it could be because of poor network)
-                    if (event?.exception?.values) {
-                        event.exception.values = event.exception.values.filter(value => {
-                            return !(value.type === 'ChunkLoadError' ||
-                                safeIncludes(value.value, 'ChunkLoadError: Loading chunk'));
-                        });
-                    }
-                    // Check if the event is a script loading error and ignore it
-                    if (event?.exception?.values) {
-                        event.exception.values = event.exception.values.filter(value => {
-                            return !(value.type === 'Error' &&
-                                safeIncludes(value.value, 'Could not load "util"'));
-                        });
-                    }
-                    // Check if the event is a timeout error and ignore it
-                    if (event?.exception?.values) {
-                        event.exception.values = event.exception.values.filter(value => {
-                            return !(value.type === 'Error' &&
-                                safeIncludes(value.value, 'Error loading plotly.js library from'));
-                        });
-                    }
-                    // Check if the event is related to cross-origin frame access
-                    if (event?.exception?.values) {
-                        const isCrossOriginFrameError = event.exception.values.some(value => {
-                            return (value.type === 'SecurityError' &&
-                                value?.value?.includes("Failed to read a named property 'navigator' from 'Window': Blocked a frame with origin"));
-                        });
-                        if (isCrossOriginFrameError) {
-                            // Exclude cross-origin frame errors from being reported to Sentry
-                            return null;
-                        }
-                    }
-                    // Check if it's a non-error exception
-                    const isNonErrorException = event?.exception?.values?.[0]?.value?.startsWith('Non-Error exception captured') ??
-                        hint?.originalException?.message?.startsWith('Non-Error exception captured');
-                    if (isNonErrorException) {
-                        // We want to ignore those kinds of errors
-                        return null;
-                    }
-                    // Filter out Edge browser (145.0.0+) synthetic isTrusted events
-                    // These events spam Sentry as "unlabeled events"
-                    const isEdge = /Edg\//.test(navigator.userAgent);
-                    if (isEdge && hint?.originalException) {
-                        const originalException = hint.originalException;
-                        if (originalException &&
-                            typeof originalException === 'object' &&
-                            originalException['isTrusted'] === true) {
-                            // Block Edge synthetic browser events from being sent to Sentry
-                            return null;
-                        }
-                    }
-                    // If we started with exception values but filtered them all out, drop the event.
-                    // Otherwise Sentry will group it as an "unlabeled event" and spam the issue stream.
-                    if (typeof initialExceptionValuesLength === 'number' &&
-                        initialExceptionValuesLength > 0 &&
-                        Array.isArray(event?.exception?.values) &&
-                        event.exception.values.length === 0) {
-                        return null;
-                    }
-                    return event;
-                },
+                beforeSend: (event, hint) => SentryErrorHandler.beforeSendFilter(event, hint),
                 denyUrls: [/drift.*\.js/i, /analytics.*\.js/i, /polyfills.*\.js/i, /vendor.*\.js/i],
                 environment,
                 // We ignore Server Errors. We have to define here since Angular
@@ -3193,15 +3149,41 @@ class SentryErrorHandler {
             return 'string_error';
         }
         if (error && typeof error === 'object') {
+            return this.classifyObjectError(error);
+        }
+        return 'unknown';
+    }
+    /**
+     * Classifies object-type errors
+     */
+    classifyObjectError(error) {
+        if (typeof error === 'object' && error !== null) {
             if ('isTrusted' in error) {
                 return 'browser_event';
             }
             if ('type' in error) {
-                return `event_${error.type}`.toLowerCase();
+                return this.classifyErrorByType(error);
             }
-            return 'object_error';
         }
-        return 'unknown';
+        return 'object_error';
+    }
+    /**
+     * Determines error type classification based on the 'type' property
+     */
+    classifyErrorByType(error) {
+        const typedError = error;
+        const rawType = typedError['type'];
+        let errorType;
+        if (typeof rawType === 'string') {
+            errorType = rawType;
+        }
+        else if (rawType != null) {
+            errorType = JSON.stringify(rawType);
+        }
+        else {
+            errorType = 'unknown';
+        }
+        return `event_${errorType}`.toLowerCase();
     }
     isEdgeSyntheticEvent(error) {
         // Check if running in Edge browser
@@ -3261,6 +3243,102 @@ class SentryErrorHandler {
         const enhancedError = new Error(enhancedErrorMessage);
         captureException(enhancedError);
     }
+    /**
+     * Filters Sentry events before sending — extracted from beforeSend config
+     * to reduce cognitive complexity (S3776).
+     *
+     * Drops or filters exception values for known noisy/irrelevant error types:
+     * CloseEvent, ResizeObserver, JSON parsing, ChunkLoadError, script loading,
+     * plotly timeout, cross-origin frame, non-error exceptions, and Edge synthetic events.
+     */
+    static beforeSendFilter(event, hint) {
+        const initialExceptionValuesLength = Array.isArray(event?.exception?.values)
+            ? event.exception.values.length
+            : undefined;
+        // Apply all exception-value filters in a single pass
+        if (event?.exception?.values) {
+            event.exception.values = SentryErrorHandler.filterExceptionValues(event.exception.values);
+        }
+        // Check for early-return (drop) conditions
+        const dropReason = SentryErrorHandler.shouldDropEvent(event, hint);
+        if (dropReason) {
+            return null;
+        }
+        // If we started with exception values but filtered them all out, drop the event.
+        if (typeof initialExceptionValuesLength === 'number' &&
+            initialExceptionValuesLength > 0 &&
+            Array.isArray(event?.exception?.values) &&
+            event.exception.values.length === 0) {
+            return null;
+        }
+        return event;
+    }
+    /**
+     * Filters out known noisy exception values in a single pass.
+     */
+    static filterExceptionValues(values) {
+        const safeIncludes = (val, needle) => typeof val === 'string' && val.includes(needle);
+        return values.filter(value => {
+            // CloseEvent
+            if (value.type === 'CloseEvent' || safeIncludes(value.value, 'CloseEvent')) {
+                return false;
+            }
+            // ResizeObserver loop completed
+            if (value.type === 'Error' &&
+                safeIncludes(value.value, 'ResizeObserver loop completed')) {
+                return false;
+            }
+            // ChunkLoadError
+            if (value.type === 'ChunkLoadError' ||
+                safeIncludes(value.value, 'ChunkLoadError: Loading chunk')) {
+                return false;
+            }
+            // Script loading error
+            if (value.type === 'Error' && safeIncludes(value.value, 'Could not load "util"')) {
+                return false;
+            }
+            // Plotly timeout error
+            if (value.type === 'Error' &&
+                safeIncludes(value.value, 'Error loading plotly.js library from')) {
+                return false;
+            }
+            return true;
+        });
+    }
+    /**
+     * Determines whether the entire event should be dropped (return truthy to drop).
+     */
+    static shouldDropEvent(event, hint) {
+        // JSON parsing error from vendor.js
+        const hasJsonParsingError = event?.exception?.values?.some(value => value.type === 'SyntaxError' &&
+            value?.value?.includes("expected ':' after property name in"));
+        if (hasJsonParsingError) {
+            return true;
+        }
+        // Cross-origin frame access error
+        const hasCrossOriginError = event?.exception?.values?.some(value => value.type === 'SecurityError' &&
+            value?.value?.includes("Failed to read a named property 'navigator' from 'Window': Blocked a frame with origin"));
+        if (hasCrossOriginError) {
+            return true;
+        }
+        // Non-error exception
+        const isNonErrorException = event?.exception?.values?.[0]?.value?.startsWith('Non-Error exception captured') ??
+            hint?.originalException?.message?.startsWith('Non-Error exception captured');
+        if (isNonErrorException) {
+            return true;
+        }
+        // Edge browser synthetic isTrusted events
+        const isEdge = /Edg\//.test(navigator.userAgent);
+        if (isEdge && hint?.originalException) {
+            const originalException = hint.originalException;
+            if (originalException &&
+                typeof originalException === 'object' &&
+                originalException['isTrusted'] === true) {
+                return true;
+            }
+        }
+        return false;
+    }
     logToConsole(error) {
         // Attempt to print in the console
         try {