@posiwise/common-services 0.2.13 → 0.2.14

package/fesm2022/posiwise-common-services.mjs

@@ -1195,7 +1195,13 @@ class AuthService {
             return this.userService.getUserInfo();
         }));
         sequence$.subscribe(resp => {
-            localStorage.setItem('name', resp.first_name);
+            // Store user information in localStorage for chat widgets and other services
+            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.router.navigate(['home']);
             if ($('.cc-dismiss').length > 0) {
                 $('.cc-dismiss')[0].click();
@@ -2920,97 +2926,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 +3109,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 +3203,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 {