react-native-nitro-cookies 1.0.2 → 1.0.4

package/NitroCookies.podspec

@@ -20,6 +20,14 @@ Pod::Spec.new do |s|
     "cpp/**/*.{hpp,cpp}",
   ]
 
+  s.pod_target_xcconfig = {
+    "HEADER_SEARCH_PATHS" => [
+      "${PODS_ROOT}/RCT-Folly",
+    ],
+    "GCC_PREPROCESSOR_DEFINITIONS" => "$(inherited) FOLLY_NO_CONFIG FOLLY_CFG_NO_COROUTINES",
+    "OTHER_CPLUSPLUSFLAGS" => "-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1",
+  }
+
   s.dependency 'React-jsi'
   s.dependency 'React-callinvoker'
 

package/ios/NitroCookies.swift

@@ -187,6 +187,45 @@ public class HybridNitroCookies: HybridNitroCookiesSpec {
         return url
     }
 
+    // MARK: - WebKit Main-Thread Helpers
+
+    /**
+     * Run a WKHTTPCookieStore operation on the main thread and return a result.
+     *
+     * All WKHTTPCookieStore interactions must happen on the main thread to avoid
+     * EXC_BREAKPOINT crashes in WebKit's non-thread-safe internal data structures.
+     */
+    @available(iOS 11.0, *)
+    private func withWebKitStore<T>(
+        _ operation: @escaping (WKHTTPCookieStore, @escaping (T) -> Void) -> Void
+    ) async -> T {
+        await withCheckedContinuation { continuation in
+            DispatchQueue.main.async {
+                let store = WKWebsiteDataStore.default().httpCookieStore
+                operation(store) { result in
+                    continuation.resume(returning: result)
+                }
+            }
+        }
+    }
+
+    /**
+     * Run a void WKHTTPCookieStore operation on the main thread.
+     */
+    @available(iOS 11.0, *)
+    private func withWebKitStoreVoid(
+        _ operation: @escaping (WKHTTPCookieStore, @escaping () -> Void) -> Void
+    ) async {
+        await withCheckedContinuation { (continuation: CheckedContinuation<Void, Never>) in
+            DispatchQueue.main.async {
+                let store = WKWebsiteDataStore.default().httpCookieStore
+                operation(store) {
+                    continuation.resume(returning: ())
+                }
+            }
+        }
+    }
+
     // MARK: - Synchronous Cookie Operations
 
     /**
@@ -211,16 +250,7 @@ public class HybridNitroCookies: HybridNitroCookiesSpec {
         let url = try validateURL(urlString)
         try validateDomain(cookie: cookie, url: url)
 
-        // Apply defaults
-        var cookieWithDefaults = cookie
-        if cookieWithDefaults.path == nil {
-            cookieWithDefaults.path = "/"
-        }
-        if cookieWithDefaults.domain == nil {
-            cookieWithDefaults.domain = url.host
-        }
-
-        let httpCookie = try makeHTTPCookie(from: cookieWithDefaults, url: url)
+        let httpCookie = try makeHTTPCookie(from: cookie, url: url)
         HTTPCookieStorage.shared.setCookie(httpCookie)
         return true
     }
@@ -271,32 +301,13 @@ public class HybridNitroCookies: HybridNitroCookiesSpec {
             let url = try self.validateURL(urlString)
             try self.validateDomain(cookie: cookie, url: url)
 
-            // Apply defaults
-            var cookieWithDefaults = cookie
-            if cookieWithDefaults.path == nil {
-                cookieWithDefaults.path = "/"
-            }
-            if cookieWithDefaults.domain == nil {
-                cookieWithDefaults.domain = url.host
-            }
-
-            let httpCookie = try self.makeHTTPCookie(from: cookieWithDefaults, url: url)
+            let httpCookie = try self.makeHTTPCookie(from: cookie, url: url)
 
             if useWebKit == true {
                 // Use WKHTTPCookieStore
                 if #available(iOS 11.0, *) {
-                    // Accessing WKWebsiteDataStore.default() inside MainActor.run is necessary for iOS 11-12 compatibility,
-                    // since it is not marked @MainActor in those versions.
-                    // For iOS 13+, WKWebsiteDataStore.default() is already @MainActor, so wrapping in MainActor.run is redundant.
-                    // This workaround is safe for iOS 13+ and does not introduce any performance penalty or behavioral change,
-                    // as MainActor.run is a no-op when already on the main actor. This ensures compatibility across all supported iOS versions.
-                    let store = await MainActor.run {
-                        WKWebsiteDataStore.default().httpCookieStore
-                    }
-                    await withCheckedContinuation { continuation in
-                        store.setCookie(httpCookie) {
-                            continuation.resume(returning: ())
-                        }
+                    await self.withWebKitStoreVoid { store, done in
+                        store.setCookie(httpCookie) { done() }
                     }
                     return true
                 } else {
@@ -321,13 +332,8 @@ public class HybridNitroCookies: HybridNitroCookiesSpec {
 
             if useWebKit == true {
                 if #available(iOS 11.0, *) {
-                    let store = await MainActor.run {
-                        WKWebsiteDataStore.default().httpCookieStore
-                    }
-                    let httpCookies = await withCheckedContinuation { continuation in
-                        store.getAllCookies { cookies in
-                            continuation.resume(returning: cookies)
-                        }
+                    let httpCookies: [HTTPCookie] = await self.withWebKitStore { store, done in
+                        store.getAllCookies { cookies in done(cookies) }
                     }
                     let filteredCookies = httpCookies.filter { cookie in
                         self.isMatchingDomain(cookieDomain: cookie.domain,
@@ -357,20 +363,16 @@ public class HybridNitroCookies: HybridNitroCookiesSpec {
         return Promise.async {
             if useWebKit == true {
                 if #available(iOS 11.0, *) {
-                    let store = await MainActor.run {
-                        WKWebsiteDataStore.default().httpCookieStore
-                    }
-                    let cookies = await withCheckedContinuation { continuation in
-                        store.getAllCookies { cookies in
-                            continuation.resume(returning: cookies)
-                        }
+                    let cookies: [HTTPCookie] = await self.withWebKitStore { store, done in
+                        store.getAllCookies { cookies in done(cookies) }
                     }
-                    for cookie in cookies {
-                        await withCheckedContinuation { continuation in
-                            store.delete(cookie) {
-                                continuation.resume(returning: ())
-                            }
+                    await self.withWebKitStoreVoid { store, done in
+                        let group = DispatchGroup()
+                        for cookie in cookies {
+                            group.enter()
+                            store.delete(cookie) { group.leave() }
                         }
+                        group.notify(queue: .main) { done() }
                     }
                     return true
                 } else {
@@ -434,13 +436,8 @@ public class HybridNitroCookies: HybridNitroCookiesSpec {
         return Promise.async {
             if useWebKit == true {
                 if #available(iOS 11.0, *) {
-                    let store = await MainActor.run {
-                        WKWebsiteDataStore.default().httpCookieStore
-                    }
-                    let cookies = await withCheckedContinuation { continuation in
-                        store.getAllCookies { cookies in
-                            continuation.resume(returning: cookies)
-                        }
+                    let cookies: [HTTPCookie] = await self.withWebKitStore { store, done in
+                        store.getAllCookies { cookies in done(cookies) }
                     }
                     return cookies.map { self.createCookieData(from: $0) }
                 } else {
@@ -464,13 +461,8 @@ public class HybridNitroCookies: HybridNitroCookiesSpec {
 
             if useWebKit == true {
                 if #available(iOS 11.0, *) {
-                    let store = await MainActor.run {
-                        WKWebsiteDataStore.default().httpCookieStore
-                    }
-                    let cookies = await withCheckedContinuation { continuation in
-                        store.getAllCookies { cookies in
-                            continuation.resume(returning: cookies)
-                        }
+                    let cookies: [HTTPCookie] = await self.withWebKitStore { store, done in
+                        store.getAllCookies { cookies in done(cookies) }
                     }
                     let matchingCookie = cookies.first { cookie in
                         cookie.name == name &&
@@ -479,10 +471,8 @@ public class HybridNitroCookies: HybridNitroCookiesSpec {
                     }
 
                     if let cookie = matchingCookie {
-                        await withCheckedContinuation { continuation in
-                            store.delete(cookie) {
-                                continuation.resume(returning: ())
-                            }
+                        await self.withWebKitStoreVoid { store, done in
+                            store.delete(cookie) { done() }
                         }
                         return true
                     } else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-cookies",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Fetch, Get Cookies 🍪 at the Speed of Nitro",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",