@superfan-app/spotify-auth 0.1.42 → 0.1.44

package/ios/.swiftlint.yml

@@ -0,0 +1,27 @@
+disabled_rules:
+  - trailing_whitespace
+  - line_length
+  - function_body_length
+  - file_length
+  - type_body_length
+
+opt_in_rules:
+  - force_unwrapping
+  - empty_count
+  - empty_string
+
+included:
+  - .
+
+excluded:
+  - Pods
+  - Carthage
+  - vendor
+
+analyzer_rules:
+  - explicit_self
+  - unused_import
+  - unused_declaration
+
+force_cast: warning
+force_try: warning 

package/ios/SpotifyAuthAuth.swift

@@ -313,7 +313,7 @@ final class SpotifyAuthAuth: NSObject, SPTSessionManagerDelegate, SpotifyOAuthVi
     let bodyString = params.map { "\($0)=\($1)" }.joined(separator: "&")
     request.httpBody = bodyString.data(using: .utf8)
     
-    let task = URLSession.shared.dataTask(with: request) { [weak self] data, response, error in
+    let task = URLSession.shared.dataTask(with: request) { [weak self] data, _, error in
       if let error = error {
         self?.handleError(error, context: "token_refresh")
         return
@@ -550,50 +550,29 @@ final class SpotifyAuthAuth: NSObject, SPTSessionManagerDelegate, SpotifyOAuthVi
   // MARK: - Helpers
   
   private func stringToScope(scopeString: String) -> SPTScope? {
-    switch scopeString {
-    case "playlist-read-private":
-      return .playlistReadPrivate
-    case "playlist-read-collaborative":
-      return .playlistReadCollaborative
-    case "playlist-modify-public":
-      return .playlistModifyPublic
-    case "playlist-modify-private":
-      return .playlistModifyPrivate
-    case "user-follow-read":
-      return .userFollowRead
-    case "user-follow-modify":
-      return .userFollowModify
-    case "user-library-read":
-      return .userLibraryRead
-    case "user-library-modify":
-      return .userLibraryModify
-    case "user-read-birthdate":
-      return .userReadBirthDate
-    case "user-read-email":
-      return .userReadEmail
-    case "user-read-private":
-      return .userReadPrivate
-    case "user-top-read":
-      return .userTopRead
-    case "ugc-image-upload":
-      return .ugcImageUpload
-    case "streaming":
-      return .streaming
-    case "app-remote-control":
-      return .appRemoteControl
-    case "user-read-playback-state":
-      return .userReadPlaybackState
-    case "user-modify-playback-state":
-      return .userModifyPlaybackState
-    case "user-read-currently-playing":
-      return .userReadCurrentlyPlaying
-    case "user-read-recently-played":
-      return .userReadRecentlyPlayed
-    case "openid":
-      return .openid
-    default:
-      return nil
-    }
+    let scopeMapping: [String: SPTScope] = [
+      "playlist-read-private": .playlistReadPrivate,
+      "playlist-read-collaborative": .playlistReadCollaborative,
+      "playlist-modify-public": .playlistModifyPublic,
+      "playlist-modify-private": .playlistModifyPrivate,
+      "user-follow-read": .userFollowRead,
+      "user-follow-modify": .userFollowModify,
+      "user-library-read": .userLibraryRead,
+      "user-library-modify": .userLibraryModify,
+      "user-read-birthdate": .userReadBirthDate,
+      "user-read-email": .userReadEmail,
+      "user-read-private": .userReadPrivate,
+      "user-top-read": .userTopRead,
+      "ugc-image-upload": .ugcImageUpload,
+      "streaming": .streaming,
+      "app-remote-control": .appRemoteControl,
+      "user-read-playback-state": .userReadPlaybackState,
+      "user-modify-playback-state": .userModifyPlaybackState,
+      "user-read-currently-playing": .userReadCurrentlyPlaying,
+      "user-read-recently-played": .userReadRecentlyPlayed,
+      "openid": .openid
+    ]
+    return scopeMapping[scopeString]
   }
   
   private func handleError(_ error: Error, context: String) {
@@ -674,27 +653,29 @@ final class SpotifyAuthAuth: NSObject, SPTSessionManagerDelegate, SpotifyOAuthVi
 extension SPTScope {
   /// Converts an SPTScope value into an array of scope strings.
   func scopesToStringArray() -> [String] {
-    var scopes: [String] = []
-    if contains(.playlistReadPrivate) { scopes.append("playlist-read-private") }
-    if contains(.playlistReadCollaborative) { scopes.append("playlist-read-collaborative") }
-    if contains(.playlistModifyPublic) { scopes.append("playlist-modify-public") }
-    if contains(.playlistModifyPrivate) { scopes.append("playlist-modify-private") }
-    if contains(.userFollowRead) { scopes.append("user-follow-read") }
-    if contains(.userFollowModify) { scopes.append("user-follow-modify") }
-    if contains(.userLibraryRead) { scopes.append("user-library-read") }
-    if contains(.userLibraryModify) { scopes.append("user-library-modify") }
-    if contains(.userReadBirthDate) { scopes.append("user-read-birthdate") }
-    if contains(.userReadEmail) { scopes.append("user-read-email") }
-    if contains(.userReadPrivate) { scopes.append("user-read-private") }
-    if contains(.userTopRead) { scopes.append("user-top-read") }
-    if contains(.ugcImageUpload) { scopes.append("ugc-image-upload") }
-    if contains(.streaming) { scopes.append("streaming") }
-    if contains(.appRemoteControl) { scopes.append("app-remote-control") }
-    if contains(.userReadPlaybackState) { scopes.append("user-read-playback-state") }
-    if contains(.userModifyPlaybackState) { scopes.append("user-modify-playback-state") }
-    if contains(.userReadCurrentlyPlaying) { scopes.append("user-read-currently-playing") }
-    if contains(.userReadRecentlyPlayed) { scopes.append("user-read-recently-played") }
-    if contains(.openid) { scopes.append("openid") }
-    return scopes
+    let scopeMapping: [(SPTScope, String)] = [
+      (.playlistReadPrivate, "playlist-read-private"),
+      (.playlistReadCollaborative, "playlist-read-collaborative"),
+      (.playlistModifyPublic, "playlist-modify-public"),
+      (.playlistModifyPrivate, "playlist-modify-private"),
+      (.userFollowRead, "user-follow-read"),
+      (.userFollowModify, "user-follow-modify"),
+      (.userLibraryRead, "user-library-read"),
+      (.userLibraryModify, "user-library-modify"),
+      (.userReadBirthDate, "user-read-birthdate"),
+      (.userReadEmail, "user-read-email"),
+      (.userReadPrivate, "user-read-private"),
+      (.userTopRead, "user-top-read"),
+      (.ugcImageUpload, "ugc-image-upload"),
+      (.streaming, "streaming"),
+      (.appRemoteControl, "app-remote-control"),
+      (.userReadPlaybackState, "user-read-playback-state"),
+      (.userModifyPlaybackState, "user-modify-playback-state"),
+      (.userReadCurrentlyPlaying, "user-read-currently-playing"),
+      (.userReadRecentlyPlayed, "user-read-recently-played"),
+      (.openid, "openid")
+    ]
+    
+    return scopeMapping.filter { contains($0.0) }.map { $0.1 }
   }
 }

package/ios/SpotifyAuthModule.swift

@@ -1,7 +1,7 @@
 import ExpoModulesCore
 import SpotifyiOS
 
-let SPOTIFY_AUTHORIZATION_EVENT_NAME = "onSpotifyAuth"
+let spotifyAuthorizationEventName = "onSpotifyAuth"
 
 #if DEBUG
 func secureLog(_ message: String, sensitive: Bool = false) {
@@ -44,11 +44,11 @@ public class SpotifyAuthModule: Module {
         }
 
         Constants([
-            "AuthEventName": SPOTIFY_AUTHORIZATION_EVENT_NAME,
+            "AuthEventName": spotifyAuthorizationEventName
         ])
 
         // Defines event names that the module can send to JavaScript.
-        Events(SPOTIFY_AUTHORIZATION_EVENT_NAME)
+        Events(spotifyAuthorizationEventName)
 
         // Called when JS starts observing the event.
         OnStartObserving {
@@ -114,7 +114,7 @@ public class SpotifyAuthModule: Module {
             "token": token,
             "error": NSNull()  // Use NSNull() instead of nil.
         ]
-        sendEvent(SPOTIFY_AUTHORIZATION_EVENT_NAME, eventData)
+        sendEvent(spotifyAuthorizationEventName, eventData)
     }
 
     @objc
@@ -125,7 +125,7 @@ public class SpotifyAuthModule: Module {
             "token": NSNull(),  // Use NSNull() instead of nil.
             "error": NSNull()   // Use NSNull() instead of nil.
         ]
-        sendEvent(SPOTIFY_AUTHORIZATION_EVENT_NAME, eventData)
+        sendEvent(spotifyAuthorizationEventName, eventData)
     }
 
     @objc
@@ -157,7 +157,7 @@ public class SpotifyAuthModule: Module {
             "token": NSNull(),
             "error": errorData
         ]
-        sendEvent(SPOTIFY_AUTHORIZATION_EVENT_NAME, eventData)
+        sendEvent(spotifyAuthorizationEventName, eventData)
     }
 
     private func mapSpotifyError(_ error: SpotifyAuthError) -> [String: Any] {

package/ios/SpotifyOAuthView.swift

@@ -41,7 +41,8 @@ class SpotifyOAuthView: ExpoView {
     private var isAuthenticating = false
     private var expectedRedirectScheme: String?
     private var authTimeout: Timer?
-    private static let AUTH_TIMEOUT_INTERVAL: TimeInterval = 300 // 5 minutes
+    private static let authTimeoutInterval: TimeInterval = 300 // 5 minutes
+    private var observerToken: NSKeyValueObservation?
     
     required init(appContext: AppContext? = nil) {
         // Generate a random state string for CSRF protection
@@ -56,50 +57,68 @@ 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
+        }
+
         // 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)
-        ])
-        
-        // Start observing loading state
-        webView.addObserver(self, forKeyPath: #keyPath(WKWebView.isLoading), options: .new, context: nil)
-    }
-    
-    override func observeValue(forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey : Any]?, context: UnsafeMutableRawPointer?) {
-        if keyPath == #keyPath(WKWebView.isLoading) {
-            if let activityIndicator = subviews.first(where: { $0 is UIActivityIndicatorView }) as? UIActivityIndicatorView {
-                webView.isLoading ? activityIndicator.startAnimating() : activityIndicator.stopAnimating()
+            // Ensure cookies and data are not persisted
+            let dataStore = WKWebsiteDataStore.nonPersistent()
+            configuration.websiteDataStore = dataStore
+            return configuration
+        }()
+
+        // Initialize webview on main thread with error handling
+        do {
+            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),
+                
+                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"))
         }
     }
     
@@ -122,20 +141,20 @@ class SpotifyOAuthView: ExpoView {
         WKWebsiteDataStore.default().removeData(
             ofTypes: [WKWebsiteDataTypeCookies, WKWebsiteDataTypeSessionStorage],
             modifiedSince: Date(timeIntervalSince1970: 0)
-        ) { [weak self] in
-            self?.initiateAuthRequest(
-                clientId: clientId,
-                redirectUri: redirectUri,
-                scopes: scopes,
-                showDialog: showDialog,
-                campaign: campaign
-            )
-        }
+        ) { }
+        
+        self.initiateAuthRequest(
+            clientId: clientId,
+            redirectUri: redirectUri,
+            scopes: scopes,
+            showDialog: showDialog,
+            campaign: campaign
+        )
     }
     
     private func startAuthTimeout() {
         authTimeout?.invalidate()
-        authTimeout = Timer.scheduledTimer(withTimeInterval: Self.AUTH_TIMEOUT_INTERVAL, repeats: false) { [weak self] _ in
+        authTimeout = Timer.scheduledTimer(withTimeInterval: Self.authTimeoutInterval, repeats: false) { [weak self] _ in
             self?.handleTimeout()
         }
     }
@@ -192,7 +211,7 @@ class SpotifyOAuthView: ExpoView {
     }
     
     deinit {
-        webView.removeObserver(self, forKeyPath: #keyPath(WKWebView.isLoading))
+        observerToken?.invalidate()
         authTimeout?.invalidate()
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@superfan-app/spotify-auth",
-  "version": "0.1.42",
+  "version": "0.1.44",
   "description": "Spotify OAuth module for Expo",
   "main": "src/index.tsx",
   "types": "build/index.d.ts",
@@ -12,7 +12,8 @@
     "test": "expo-module test",
     "prepare": "expo-module prepare",
     "prepublishOnly": "expo-module prepublishOnly",
-    "expo-module": "expo-module"
+    "expo-module": "expo-module",
+    "check-ios": "./scripts/check-ios.sh"
   },
   "keywords": [
     "react-native",

package/scripts/check-ios.sh

@@ -0,0 +1,19 @@
+#!/bin/bash
+
+# Exit on error
+set -e
+
+echo "Checking iOS code..."
+
+# Install SwiftLint if not installed
+if ! command -v swiftlint &> /dev/null; then
+    echo "SwiftLint not found. Installing..."
+    brew install swiftlint
+fi
+
+# Run SwiftLint
+cd ios
+echo "Running SwiftLint..."
+swiftlint lint --quiet
+
+echo "iOS checks completed successfully!"