Fix Safari SecurityError when Block All Cookies is enabled

shared/AppInsightsCommon/src/StorageHelperFuncs.ts

@@ -5,6 +5,7 @@ import {
     IDiagnosticLogger, _eInternalMessageId, _throwInternal, dumpObj, eLoggingSeverity, getExceptionName, getGlobal, getGlobalInst,
     isNullOrUndefined, objForEachKey
 } from "@microsoft/applicationinsights-core-js";
+import { objGetOwnPropertyDescriptor } from "@nevware21/ts-utils";
 import { StorageType } from "./Enums";
 
 let _canUseLocalStorage: boolean = undefined;
@@ -23,31 +24,88 @@ function _getLocalStorageObject(): Storage {
     return null;
 }
 
+/**
+ * Safely checks if storage object (localStorage or sessionStorage) is available and accessible
+ * This helps prevent SecurityError in some browsers (e.g., Safari) when cookies are blocked
+ * @param storageType - Type of storage
+ * @returns {boolean} Returns whether storage object is safely accessible
+ */
+function _canSafelyAccessStorage(storageType: StorageType): boolean {
+    const storageTypeName = storageType === StorageType.LocalStorage ? "localStorage" : "sessionStorage";
+    let result = true;
+
+    try {
+        // First, check if window exists and get the global object once
+        const gbl: any = getGlobal();
+        if (isNullOrUndefined(gbl)) {
+            result = false;
+        } else {
+            // Try to indirectly check if the property exists and is accessible
+            // This avoids direct property access that might throw in Safari with "Block All Cookies" enabled
+
+            // Some browsers throw when accessing the property descriptors with getOwnPropertyDescriptor
+            // Others throw when directly accessing the storage objects
+            // This approach tries both methods safely
+            try {
+                // Method 1: Try using property descriptor - safer in Safari with cookies blocked
+                const descriptor = objGetOwnPropertyDescriptor(gbl, storageTypeName);
+                if (!descriptor || !descriptor.get) {
+                    result = false;
+                }
+            } catch (e) {
+                // If the above fails, attempt a direct access inside a try-catch
+                try {
+                    const storage = gbl[storageTypeName];
+                    if (!storage) {
+                        result = false;
+                    }
+                } catch (e) {
+                    // If both approaches fail, storage cannot be safely accessed
+                    result = false;
+                }
+            }
+        }
+    } catch (e) {
+        result = false;
+    }
+
+    return result;
+}
+
 /**
  * Tests storage object (localStorage or sessionStorage) to verify that it is usable
  * More details here: https://mathiasbynens.be/notes/localstorage-pattern
  * @param storageType - Type of storage
  * @returns {Storage} Returns storage object verified that it is usable
  */
 function _getVerifiedStorageObject(storageType: StorageType): Storage {
+    let result = null;
+
     try {
-        if (isNullOrUndefined(getGlobal())) {
-            return null;
-        }
-        let uid = (new Date).toString();
-        let storage: Storage = getGlobalInst(storageType === StorageType.LocalStorage ? "localStorage" : "sessionStorage");
-        let name:string = _storagePrefix + uid;
-        storage.setItem(name, uid);
-        let fail = storage.getItem(name) !== uid;
-        storage.removeItem(name);
-        if (!fail) {
-            return storage;
+        // First check if we can safely access the storage object
+        if (_canSafelyAccessStorage(storageType)) {
+            const storageTypeName = storageType === StorageType.LocalStorage ? "localStorage" : "sessionStorage";
+
+            // Now we can safely try to use the storage
+            try {
+                let uid = (new Date).toString();
+                let storage: Storage = getGlobalInst(storageTypeName);
+                let name:string = _storagePrefix + uid;
+                storage.setItem(name, uid);
+                let fail = storage.getItem(name) !== uid;
+                storage.removeItem(name);
+                if (!fail) {
+                    result = storage;
+                }
+            } catch (exception) {
+                // Storage exists but can't be used (quota exceeded, etc.)
+            }
         }
     } catch (exception) {
-        // eslint-disable-next-line no-empty
+        // Catch any unexpected errors
     }
 
-    return null;
+    return result;
 }
 
 /**