@posiwise/common-services 0.1.91 → 0.1.93

package/fesm2022/posiwise-common-services.mjs

@@ -36,6 +36,16 @@ class ScriptLoaderService {
         this.document = document;
         this._scripts = {};
     }
+    getCspNonce() {
+        // Prefer explicit global set by server-side renderer
+        const w = globalThis;
+        if (w?.__cspNonce)
+            return w.__cspNonce;
+        // Fallback: try to read nonce from any existing script tag
+        const anyScript = this.document.querySelector('script[nonce]');
+        const n = anyScript?.nonce || anyScript?.getAttribute('nonce') || undefined;
+        return n || undefined;
+    }
     load(tag, ...scripts) {
         scripts.forEach((src) => {
             if (!this._scripts[src]) {
@@ -73,6 +83,9 @@ class ScriptLoaderService {
                 const scriptTag = document.createElement('script');
                 scriptTag.type = 'text/javascript';
                 scriptTag.src = this._scripts[src].src;
+                const nonce = this.getCspNonce();
+                if (nonce)
+                    scriptTag.nonce = nonce;
                 scriptTag.onload = () => {
                     this._scripts[src].loaded = true;
                     resolve({ src, loaded: true });
@@ -2806,6 +2819,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.18", ngImpo
 
 class SentryErrorHandler {
     static { this.sentryInitialized = false; }
+    static { this.unhandledRejectionListenerAttached = false; }
     constructor(appConfigService) {
         this.appConfigService = appConfigService;
     }
@@ -2820,16 +2834,15 @@ class SentryErrorHandler {
             if (env?.integrations?.sentry_config) {
                 init({ ...config, ...env.integrations.sentry_config });
                 SentryErrorHandler.sentryInitialized = true;
-                // Add a global listener for unhandled promise rejections
-                window.addEventListener('unhandledrejection', (event) => {
-                    this.handlePromiseRejection(event);
-                });
+                // Add a global listener for unhandled promise rejections (once)
+                if (!SentryErrorHandler.unhandledRejectionListenerAttached) {
+                    window.addEventListener('unhandledrejection', (event) => {
+                        this.handlePromiseRejection(event);
+                    });
+                    SentryErrorHandler.unhandledRejectionListenerAttached = true;
+                }
             }
         });
-        // Add a global listener for unhandled promise rejections
-        window.addEventListener('unhandledrejection', (event) => {
-            this.handlePromiseRejection(event);
-        });
     }
     async getSentryConfigAsync() {
         return new Promise(resolve => {
@@ -2842,18 +2855,23 @@ class SentryErrorHandler {
                 // 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' || value.value.includes('CloseEvent'));
+                            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' &&
-                                value.value.includes('ResizeObserver loop completed'));
+                                safeIncludes(value.value, 'ResizeObserver loop completed'));
                         });
                     }
                     // originates from vendor.js file
@@ -2870,21 +2888,21 @@ class SentryErrorHandler {
                     if (event?.exception?.values) {
                         event.exception.values = event.exception.values.filter(value => {
                             return !(value.type === 'ChunkLoadError' ||
-                                value.value.includes('ChunkLoadError: Loading chunk'));
+                                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' &&
-                                value.value.includes('Could not load "util"'));
+                                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' &&
-                                value.value.includes('Error loading plotly.js library from'));
+                                safeIncludes(value.value, 'Error loading plotly.js library from'));
                         });
                     }
                     // Check if the event is related to cross-origin frame access
@@ -2898,16 +2916,6 @@ class SentryErrorHandler {
                             return null;
                         }
                     }
-                    // Check if the event has an exception and values array
-                    if (event?.exception?.values) {
-                        // Filter out events generated by TryCatch and GlobalHandlers
-                        event.exception.values = event.exception.values.filter(value => {
-                            const mechanism = value.mechanism;
-                            return !(mechanism &&
-                                (mechanism.type === 'TryCatch' ||
-                                    mechanism.type === 'GlobalHandlers'));
-                        });
-                    }
                     // 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');
@@ -2915,6 +2923,14 @@ class SentryErrorHandler {
                         // We want to ignore those kinds of errors
                         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;
                 },
                 denyUrls: [/drift.*\.js/i, /analytics.*\.js/i, /polyfills.*\.js/i, /vendor.*\.js/i],