@superfan-app/spotify-auth 0.1.43 → 0.1.45

package/ios/SpotifyOAuthView.swift

@@ -57,54 +57,87 @@ class SpotifyOAuthView: ExpoView {
     }
     
     private func setupWebView() {
+        // Ensure we're on the main thread for UI setup
+        guard Thread.isMainThread else {
+            DispatchQueue.main.async { [weak self] in
+                self?.setupWebView()
+            }
+            return
+        }
+
+        secureLog("Setting up WebView configuration...")
         // Create a configuration that prevents data persistence
-        let config = WKWebViewConfiguration()
-        let prefs = WKWebpagePreferences()
-        prefs.allowsContentJavaScript = true
-        config.defaultWebpagePreferences = prefs
-        
-        // Ensure cookies and data are not persisted
-        let dataStore = WKWebsiteDataStore.nonPersistent()
-        config.websiteDataStore = dataStore
-        
-        webView = WKWebView(frame: .zero, configuration: config)
-        webView.navigationDelegate = self
-        webView.allowsBackForwardNavigationGestures = true
-        webView.customUserAgent = "SpotifyAuth-iOS/1.0" // Custom UA to identify our app
-        
-        // Add loading indicator
-        let activityIndicator = UIActivityIndicatorView(style: .medium)
-        activityIndicator.translatesAutoresizingMaskIntoConstraints = false
-        activityIndicator.hidesWhenStopped = true
-        
-        addSubview(webView)
-        addSubview(activityIndicator)
-        
-        // Setup constraints
-        webView.translatesAutoresizingMaskIntoConstraints = false
-        NSLayoutConstraint.activate([
-            webView.topAnchor.constraint(equalTo: topAnchor),
-            webView.leadingAnchor.constraint(equalTo: leadingAnchor),
-            webView.trailingAnchor.constraint(equalTo: trailingAnchor),
-            webView.bottomAnchor.constraint(equalTo: bottomAnchor),
+        let config: WKWebViewConfiguration = {
+            let configuration = WKWebViewConfiguration()
+            configuration.processPool = WKProcessPool() // Create a new process pool
+            let prefs = WKWebpagePreferences()
+            prefs.allowsContentJavaScript = true
+            configuration.defaultWebpagePreferences = prefs
             
-            activityIndicator.centerXAnchor.constraint(equalTo: centerXAnchor),
-            activityIndicator.centerYAnchor.constraint(equalTo: centerYAnchor)
-        ])
-        
-        // Setup modern KVO observation
-        observerToken = webView.observe(\.isLoading, options: [.new]) { [weak self] _, _ in
-            if let activityIndicator = self?.subviews.first(where: { $0 is UIActivityIndicatorView }) as? UIActivityIndicatorView {
-                if self?.webView.isLoading == true {
-                    activityIndicator.startAnimating()
-                } else {
-                    activityIndicator.stopAnimating()
+            // Ensure cookies and data are not persisted
+            let dataStore = WKWebsiteDataStore.nonPersistent()
+            configuration.websiteDataStore = dataStore
+            secureLog("WebView configuration created with non-persistent data store")
+            return configuration
+        }()
+
+        // Initialize webview on main thread with error handling
+        do {
+            webView = WKWebView(frame: .zero, configuration: config)
+            guard webView != nil else {
+                throw NSError(domain: "SpotifyAuth", code: -1, userInfo: [NSLocalizedDescriptionKey: "Failed to initialize WebView"])
+            }
+            secureLog("WebView successfully initialized")
+            
+            webView.navigationDelegate = self
+            webView.allowsBackForwardNavigationGestures = true
+            webView.customUserAgent = "SpotifyAuth-iOS/1.0" // Custom UA to identify our app
+            
+            // Add loading indicator
+            let activityIndicator = UIActivityIndicatorView(style: .medium)
+            activityIndicator.translatesAutoresizingMaskIntoConstraints = false
+            activityIndicator.hidesWhenStopped = true
+            
+            addSubview(webView)
+            addSubview(activityIndicator)
+            
+            // Setup constraints
+            webView.translatesAutoresizingMaskIntoConstraints = false
+            NSLayoutConstraint.activate([
+                webView.topAnchor.constraint(equalTo: topAnchor),
+                webView.leadingAnchor.constraint(equalTo: leadingAnchor),
+                webView.trailingAnchor.constraint(equalTo: trailingAnchor),
+                webView.bottomAnchor.constraint(equalTo: bottomAnchor),
+                
+                activityIndicator.centerXAnchor.constraint(equalTo: centerXAnchor),
+                activityIndicator.centerYAnchor.constraint(equalTo: centerYAnchor)
+            ])
+            
+            // Setup modern KVO observation
+            observerToken = webView.observe(\.isLoading, options: [.new]) { [weak self] _, _ in
+                if let activityIndicator = self?.subviews.first(where: { $0 is UIActivityIndicatorView }) as? UIActivityIndicatorView {
+                    if self?.webView.isLoading == true {
+                        activityIndicator.startAnimating()
+                    } else {
+                        activityIndicator.stopAnimating()
+                    }
                 }
             }
+        } catch {
+            secureLog("Failed to setup WebView: \(error.localizedDescription)")
+            delegate?.oauthView(self, didFailWithError: SpotifyOAuthError.authorizationError("Failed to initialize web view"))
         }
     }
     
     func startOAuthFlow(clientId: String, redirectUri: String, scopes: [String], showDialog: Bool = false, campaign: String? = nil) {
+        // Ensure we're on the main thread - WebView setup must be done on the main thread
+        if !Thread.isMainThread {
+            DispatchQueue.main.async { [weak self] in
+                self?.startOAuthFlow(clientId: clientId, redirectUri: redirectUri, scopes: scopes, showDialog: showDialog, campaign: campaign)
+            }
+            return
+        }
+
         guard !isAuthenticating else { return }
         isAuthenticating = true
         
@@ -120,18 +153,24 @@ class SpotifyOAuthView: ExpoView {
         startAuthTimeout()
         
         // Clear any existing cookies/data to ensure a fresh login
+        // Wait for completion before initiating the auth request
         WKWebsiteDataStore.default().removeData(
             ofTypes: [WKWebsiteDataTypeCookies, WKWebsiteDataTypeSessionStorage],
             modifiedSince: Date(timeIntervalSince1970: 0)
-        ) { }
-        
-        self.initiateAuthRequest(
-            clientId: clientId,
-            redirectUri: redirectUri,
-            scopes: scopes,
-            showDialog: showDialog,
-            campaign: campaign
-        )
+        ) { [weak self] in
+            // Ensure we're still in a valid state after the async operation
+            guard let self = self, self.isAuthenticating else { return }
+            
+            DispatchQueue.main.async {
+                self.initiateAuthRequest(
+                    clientId: clientId,
+                    redirectUri: redirectUri,
+                    scopes: scopes,
+                    showDialog: showDialog,
+                    campaign: campaign
+                )
+            }
+        }
     }
     
     private func startAuthTimeout() {
@@ -167,6 +206,14 @@ class SpotifyOAuthView: ExpoView {
             return
         }
         
+        // Verify webView is properly initialized
+        guard let webView = self.webView else {
+            secureLog("Error: WebView not initialized when attempting to load auth request")
+            isAuthenticating = false
+            delegate?.oauthView(self, didFailWithError: SpotifyOAuthError.authorizationError("WebView not initialized"))
+            return
+        }
+        
         var queryItems = [
             URLQueryItem(name: "client_id", value: clientId),
             URLQueryItem(name: "response_type", value: "code"),
@@ -189,7 +236,22 @@ class SpotifyOAuthView: ExpoView {
         }
         
         let request = URLRequest(url: url, cachePolicy: .reloadIgnoringLocalAndRemoteCacheData)
-        webView.load(request)
+        secureLog("Initiating auth request to URL: \(url.absoluteString)")
+        
+        DispatchQueue.main.async {
+            guard Thread.isMainThread else {
+                assertionFailure("WebView load not on main thread despite DispatchQueue.main.async")
+                return
+            }
+            
+            if webView.isLoading {
+                secureLog("Warning: WebView is already loading content, stopping previous load")
+                webView.stopLoading()
+            }
+            
+            webView.load(request)
+            self.secureLog("Auth request load initiated")
+        }
     }
     
     deinit {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@superfan-app/spotify-auth",
-  "version": "0.1.43",
+  "version": "0.1.45",
   "description": "Spotify OAuth module for Expo",
   "main": "src/index.tsx",
   "types": "build/index.d.ts",