@wwdrew/expo-spotify-sdk 0.5.0 → 0.7.0

package/ios/ExpoSpotifySDKModule.swift

@@ -1,37 +1,109 @@
 import ExpoModulesCore
 import SpotifyiOS
 
-public class ExpoSpotifySDKModule: Module {
-
-    public func definition() -> ModuleDefinition {
+private let SDK_VERSION = "0.5.0"
+private let EVENT_SESSION_CHANGE = "onSessionChange"
 
-        let spotifySession = ExpoSpotifySessionManager.shared
+public class ExpoSpotifySDKModule: Module {
+  public func definition() -> ModuleDefinition {
+    Name("ExpoSpotifySDK")
+    Events(EVENT_SESSION_CHANGE)
 
-        Name("ExpoSpotifySDK")
+    Function("isAvailable") { () -> Bool in
+      SpotifyAuthCoordinator.shared?.isSpotifyAppInstalled() ?? false
+    }
 
-        Function("isAvailable") {
-            return spotifySession.spotifyAppInstalled()
+    AsyncFunction("authenticateAsync") { (config: AuthenticateOptions) async throws -> [String: Any?] in
+      do {
+        guard let coordinator = SpotifyAuthCoordinator.shared else {
+          throw SpotifyError.invalidConfiguration(
+            "Missing `ExpoSpotifySDK` configuration in Info.plist. " +
+            "Did you add @wwdrew/expo-spotify-sdk to your Expo plugins?"
+          )
         }
+        if config.scopes.isEmpty {
+          throw SpotifyError.invalidConfiguration("`scopes` must contain at least one entry")
+        }
+        let scopes = SPTScopeSerializer.deserialize(config.scopes)
+        let session = try await coordinator.authenticate(
+          scopes: scopes,
+          tokenSwapURL: config.tokenSwapURL.flatMap(URL.init),
+          tokenRefreshURL: config.tokenRefreshURL.flatMap(URL.init),
+          showDialog: config.showDialog
+        )
+        let map = self.sessionToMap(session)
+        self.sendEvent(EVENT_SESSION_CHANGE, ["type": "didInitiate", "session": map])
+        return map
+      } catch let error as SpotifyError {
+        self.sendEvent(EVENT_SESSION_CHANGE, [
+          "type": "didFail",
+          "error": ["code": error.code, "message": error.message],
+        ])
+        throw GenericException("\(error.code): \(error.message)")
+      }
+    }
 
-        AsyncFunction("authenticateAsync") { (config: [String: Any], promise: Promise) in
-            guard let scopes = config["scopes"] as? [String] else {
-                promise.reject("INVALID_CONFIG", "Invalid SpotifyConfig object")
-                return
-            }
-
-            let tokenSwapURL = config["tokenSwapURL"] as? String
-            let tokenRefreshURL = config["tokenRefreshURL"] as? String
-
-            spotifySession.authenticate(scopes: scopes, tokenSwapURL: tokenSwapURL, tokenRefreshURL: tokenRefreshURL).done { session in
-                promise.resolve([
-                    "accessToken": session.accessToken,
-                    "refreshToken": session.refreshToken,
-                    "expirationDate": Int(session.expirationDate.timeIntervalSince1970 * 1000),
-                    "scopes": SPTScopeSerializer.serializeScopes(session.scope)
-                ])
-            }.catch { error in
-                promise.reject(error)
-            }
+    AsyncFunction("refreshSessionAsync") { (options: RefreshOptions) async throws -> [String: Any?] in
+      do {
+        guard let configuration = ExpoSpotifyConfiguration.fromInfoPlist() else {
+          throw SpotifyError.invalidConfiguration(
+            "Missing `ExpoSpotifySDK` configuration in Info.plist."
+          )
+        }
+        if options.refreshToken.isEmpty {
+          throw SpotifyError.invalidConfiguration("`refreshToken` is required")
         }
+        if options.tokenRefreshURL.isEmpty {
+          throw SpotifyError.invalidConfiguration("`tokenRefreshURL` is required")
+        }
+        let client = SpotifyTokenRefreshClient(sdkVersion: SDK_VERSION, clientID: configuration.clientID)
+        let result = try await client.refresh(
+          refreshToken: options.refreshToken,
+          tokenRefreshURL: options.tokenRefreshURL,
+          previousScopes: []
+        )
+        let map: [String: Any?] = [
+          "accessToken": result.accessToken,
+          "refreshToken": result.refreshToken,
+          "expirationDate": result.expirationDate,
+          "scopes": result.scopes,
+        ]
+        self.sendEvent(EVENT_SESSION_CHANGE, ["type": "didRenew", "session": map])
+        return map
+      } catch let error as SpotifyError {
+        self.sendEvent(EVENT_SESSION_CHANGE, [
+          "type": "didFail",
+          "error": ["code": error.code, "message": error.message],
+        ])
+        throw GenericException("\(error.code): \(error.message)")
+      } catch let error as SpotifyRefreshError {
+        self.sendEvent(EVENT_SESSION_CHANGE, [
+          "type": "didFail",
+          "error": ["code": error.code, "message": error.message],
+        ])
+        throw GenericException("\(error.code): \(error.message)")
+      }
     }
+  }
+
+  private func sessionToMap(_ session: SPTSession) -> [String: Any?] {
+    return [
+      "accessToken": session.accessToken,
+      "refreshToken": session.refreshToken.isEmpty ? nil : session.refreshToken,
+      "expirationDate": Int(session.expirationDate.timeIntervalSince1970 * 1000),
+      "scopes": SPTScopeSerializer.serialize(session.scope),
+    ]
+  }
+}
+
+struct AuthenticateOptions: Record {
+  @Field var scopes: [String] = []
+  @Field var tokenSwapURL: String? = nil
+  @Field var tokenRefreshURL: String? = nil
+  @Field var showDialog: Bool = false
+}
+
+struct RefreshOptions: Record {
+  @Field var refreshToken: String = ""
+  @Field var tokenRefreshURL: String = ""
 }

package/ios/SPTScopeSerializer.swift

@@ -1,44 +1,45 @@
+import Foundation
 import SpotifyiOS
 
-class SPTScopeSerializer {
-    static let scopeMap: [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-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,
-    ]
-    
-    static func serializeScopes(_ scopes: SPTScope) -> [String] {
-        var serializedScopes = [String]()
-        for (scopeString, scopeValue) in scopeMap {
-            if scopes.contains(scopeValue) {
-                serializedScopes.append(scopeString)
-            }
-        }
-        return serializedScopes
+enum SPTScopeSerializer {
+  /// Single source of truth for the string ↔ SPTScope mapping. Order is
+  /// preserved on round-trip via `serialize` (sorted alphabetically) so output
+  /// is deterministic.
+  static let scopeMap: [(String, SPTScope)] = [
+    ("app-remote-control", .appRemoteControl),
+    ("playlist-modify-private", .playlistModifyPrivate),
+    ("playlist-modify-public", .playlistModifyPublic),
+    ("playlist-read-collaborative", .playlistReadCollaborative),
+    ("playlist-read-private", .playlistReadPrivate),
+    ("streaming", .streaming),
+    ("ugc-image-upload", .ugcImageUpload),
+    ("user-follow-modify", .userFollowModify),
+    ("user-follow-read", .userFollowRead),
+    ("user-library-modify", .userLibraryModify),
+    ("user-library-read", .userLibraryRead),
+    ("user-modify-playback-state", .userModifyPlaybackState),
+    ("user-read-currently-playing", .userReadCurrentlyPlaying),
+    ("user-read-email", .userReadEmail),
+    ("user-read-playback-state", .userReadPlaybackState),
+    ("user-read-private", .userReadPrivate),
+    ("user-read-recently-played", .userReadRecentlyPlayed),
+    ("user-top-read", .userTopRead),
+  ]
+
+  static func serialize(_ scopes: SPTScope) -> [String] {
+    scopeMap.compactMap { (string, value) in
+      scopes.contains(value) ? string : nil
     }
-    
-    static func deserializeScopes(_ scopes: [String]) -> SPTScope {
-        var deserializedScopes: SPTScope = []
-        for scopeString in scopes {
-            if let scopeValue = scopeMap[scopeString] {
-                deserializedScopes.insert(scopeValue)
-            }
-        }
-        return deserializedScopes
+  }
+
+  static func deserialize(_ scopes: [String]) -> SPTScope {
+    var result: SPTScope = []
+    let lookup = Dictionary(uniqueKeysWithValues: scopeMap)
+    for string in scopes {
+      if let value = lookup[string] {
+        result.insert(value)
+      }
     }
+    return result
+  }
 }

package/ios/SpotifyAuthCoordinator.swift

@@ -0,0 +1,186 @@
+import Foundation
+import SpotifyiOS
+
+/// Public, structured errors thrown by the coordinator. Each case carries the
+/// JS-facing error code in `code`, mirroring the Android `CodedException`
+/// taxonomy.
+enum SpotifyError: Error {
+  case invalidConfiguration(String)
+  case authInProgress
+  case userCancelled
+  case spotifyNotInstalled
+  case underlying(Error)
+
+  var code: String {
+    switch self {
+    case .invalidConfiguration: return "INVALID_CONFIG"
+    case .authInProgress:       return "AUTH_IN_PROGRESS"
+    case .userCancelled:        return "USER_CANCELLED"
+    case .spotifyNotInstalled:  return "SPOTIFY_NOT_INSTALLED"
+    case .underlying:           return "UNKNOWN"
+    }
+  }
+
+  var message: String {
+    switch self {
+    case .invalidConfiguration(let m): return m
+    case .authInProgress:              return "Another authentication request is already in progress"
+    case .userCancelled:               return "Authentication was cancelled by the user"
+    case .spotifyNotInstalled:         return "The Spotify app is not installed on this device"
+    case .underlying(let err):         return err.localizedDescription
+    }
+  }
+}
+
+/// `actor` ensures `pending` is mutated only on the actor's serial executor;
+/// no manual locks needed.
+actor SpotifyAuthCoordinator {
+  static let shared: SpotifyAuthCoordinator? = SpotifyAuthCoordinator.create()
+
+  private let sptConfiguration: SPTConfiguration
+  private let sessionManager: SPTSessionManager
+  private let bridge: SpotifySessionDelegateBridge
+  private var pending: CheckedContinuation<SPTSession, Error>?
+
+  private init(sptConfiguration: SPTConfiguration, sessionManager: SPTSessionManager, bridge: SpotifySessionDelegateBridge) {
+    self.sptConfiguration = sptConfiguration
+    self.sessionManager = sessionManager
+    self.bridge = bridge
+    bridge.coordinator = self
+  }
+
+  private static func create() -> SpotifyAuthCoordinator? {
+    guard
+      let configuration = ExpoSpotifyConfiguration.fromInfoPlist(),
+      let sptConfig = configuration.sptConfiguration
+    else {
+      NSLog("[ExpoSpotifySDK] Missing or invalid `ExpoSpotifySDK` Info.plist entry")
+      return nil
+    }
+    let bridge = SpotifySessionDelegateBridge()
+    let manager = SPTSessionManager(configuration: sptConfig, delegate: bridge)
+    return SpotifyAuthCoordinator(sptConfiguration: sptConfig, sessionManager: manager, bridge: bridge)
+  }
+
+  /// Synchronous getter used by the module's `Function("isAvailable")`. Safe
+  /// to call from any thread because the underlying SDK property is read-only
+  /// state derived from the installed-apps query.
+  nonisolated func isSpotifyAppInstalled() -> Bool {
+    sessionManager.isSpotifyAppInstalled
+  }
+
+  /// Synchronous URL-handler dispatcher used by the AppDelegate / SceneDelegate
+  /// subscribers to forward redirects to the SPTSessionManager.
+  nonisolated func handleOpenURL(_ url: URL, options: [UIApplication.OpenURLOptionsKey: Any]) -> Bool {
+    sessionManager.application(UIApplication.shared, open: url, options: options)
+  }
+
+  func authenticate(
+    scopes: SPTScope,
+    tokenSwapURL: URL?,
+    tokenRefreshURL: URL?,
+    showDialog: Bool = false
+  ) async throws -> SPTSession {
+    guard pending == nil else { throw SpotifyError.authInProgress }
+
+    // SPTConfiguration is a reference type shared with the session manager, so
+    // mutating it here takes effect for the upcoming initiateSession call.
+    sptConfiguration.tokenSwapURL = tokenSwapURL
+    sptConfiguration.tokenRefreshURL = tokenRefreshURL
+    // alwaysShowAuthorizationDialog is a property on SPTSessionManager, not an
+    // SPTAuthorizationOptions flag (the options enum has no such case).
+    sessionManager.alwaysShowAuthorizationDialog = showDialog
+
+    NSLog(
+      "[ExpoSpotifySDK] initiateSession redirectURL=%@ tokenSwapURL=%@ tokenRefreshURL=%@ showDialog=%d",
+      sptConfiguration.redirectURL.absoluteString,
+      tokenSwapURL?.absoluteString ?? "nil",
+      tokenRefreshURL?.absoluteString ?? "nil",
+      showDialog ? 1 : 0
+    )
+
+    return try await withCheckedThrowingContinuation { (cont: CheckedContinuation<SPTSession, Error>) in
+      self.pending = cont
+      Task { @MainActor in
+        self.sessionManager.initiateSession(with: scopes, options: .default, campaign: nil)
+      }
+    }
+  }
+
+  func deliver(_ result: Result<SPTSession, Error>) {
+    let cont = pending
+    pending = nil
+    cont?.resume(with: result)
+  }
+}
+
+/// `SPTSessionManagerDelegate` requires NSObject conformance, which an actor
+/// can't satisfy directly. The bridge is a tiny NSObject that hops the call
+/// onto the actor's executor.
+final class SpotifySessionDelegateBridge: NSObject, SPTSessionManagerDelegate {
+  weak var coordinator: SpotifyAuthCoordinator?
+
+  func sessionManager(manager _: SPTSessionManager, didInitiate session: SPTSession) {
+    NSLog(
+      "[ExpoSpotifySDK] didInitiate accessToken.length=%d refreshToken.length=%d expirationDate=%@ scope=%lu",
+      session.accessToken.count,
+      session.refreshToken.count,
+      session.expirationDate as NSDate,
+      session.scope.rawValue
+    )
+    Task { await coordinator?.deliver(.success(session)) }
+  }
+
+  func sessionManager(manager _: SPTSessionManager, didFailWith error: Error) {
+    let mapped: Error = mapSDKError(error)
+    NSLog("[ExpoSpotifySDK] didFailWithError %@", String(describing: error))
+    Task { await coordinator?.deliver(.failure(mapped)) }
+  }
+
+  func sessionManager(manager _: SPTSessionManager, didRenew session: SPTSession) {
+    NSLog(
+      "[ExpoSpotifySDK] didRenew accessToken.length=%d refreshToken.length=%d",
+      session.accessToken.count,
+      session.refreshToken.count
+    )
+    Task { await coordinator?.deliver(.success(session)) }
+  }
+
+  /// Translate a few well-known SDK error shapes into our taxonomy.
+  private func mapSDKError(_ error: Error) -> Error {
+    let nsError = error as NSError
+    let description = nsError.localizedDescription.lowercased()
+    if description.contains("cancel") {
+      return SpotifyError.userCancelled
+    }
+    return SpotifyError.underlying(NSError(
+      domain: nsError.domain,
+      code: nsError.code,
+      userInfo: [NSLocalizedDescriptionKey: describeError(nsError)]
+    ))
+  }
+
+  /// Build a diagnostic string from an NSError that includes the domain,
+  /// code, localized description, and the full chain of underlying errors.
+  /// Used because `SPTError` (and many `URLSession` errors it wraps) often
+  /// have an empty `localizedDescription`, surfacing as "undefined reason"
+  /// in JS without this expansion.
+  private func describeError(_ error: NSError) -> String {
+    var parts: [String] = []
+    parts.append("\(error.domain) code \(error.code)")
+    let desc = error.localizedDescription
+    if !desc.isEmpty {
+      parts.append("\"\(desc)\"")
+    }
+    var ui = error.userInfo
+    ui.removeValue(forKey: NSUnderlyingErrorKey)
+    ui.removeValue(forKey: NSLocalizedDescriptionKey)
+    if !ui.isEmpty {
+      parts.append("userInfo=\(ui)")
+    }
+    if let underlying = error.userInfo[NSUnderlyingErrorKey] as? NSError {
+      parts.append("→ underlying: \(describeError(underlying))")
+    }
+    return parts.joined(separator: " ")
+  }
+}

package/ios/SpotifySDK/SpotifyiOS.xcframework/ios-arm64/SpotifyiOS.framework/Headers/SPTConfiguration.h

@@ -51,7 +51,7 @@ NS_ASSUME_NONNULL_BEGIN
 - (instancetype)initWithClientID:(NSString *)clientID redirectURL:(NSURL *)redirectURL NS_DESIGNATED_INITIALIZER;
 
 /**
- Convenience intializer for `SPtConfiguration`
+ Convenience initializer for `SPTConfiguration`
 
  @param clientID Your client ID obtained from developer.spotify.com
  @param redirectURL Your redirect URL for Spotify to open your app again after authorization

package/ios/SpotifySDK/SpotifyiOS.xcframework/ios-arm64/SpotifyiOS.framework/Headers/SPTError.h

@@ -10,13 +10,12 @@ SPT_EXPORT NSErrorDomain const SPTLoginErrorDomain;
 typedef NS_ENUM(NSUInteger, SPTErrorCode) {
     /// Unknown error code
     SPTUnknownErrorCode NS_SWIFT_NAME(unknown) = 0,
-    /// Authorization failed
-    SPTAuthorizationFailedErrorCode NS_SWIFT_NAME(authorizationFailed),
-    /// Renew session failed
-    SPTRenewSessionFailedErrorCode NS_SWIFT_NAME(renewSessionFailed),
-    /// Failed to parse the returned JSON
-    SPTJSONFailedErrorCode NS_SWIFT_NAME(jsonFailed),
-};
+        /// Authorization failed
+        SPTAuthorizationFailedErrorCode NS_SWIFT_NAME(authorizationFailed),
+            /// Renew session failed
+            SPTRenewSessionFailedErrorCode NS_SWIFT_NAME(renewSessionFailed),
+                                                         /// Failed to parse the returned JSON
+                                                         SPTJSONFailedErrorCode NS_SWIFT_NAME(jsonFailed) };
 
 /// Spotify-specific errors. Use NSUnderlyingErrorKey to see the underlying error
 @interface SPTError : NSError

package/ios/SpotifySDK/SpotifyiOS.xcframework/ios-arm64/SpotifyiOS.framework/Headers/SPTScope.h

@@ -30,42 +30,46 @@
 typedef NS_OPTIONS(NSUInteger, SPTScope) {
     /// Read access to user's private playlists.
     SPTPlaylistReadPrivateScope NS_SWIFT_NAME(playlistReadPrivate) = (1 << 0),
-    /// Include collaborative playlists when requesting a user's playlists.
-    SPTPlaylistReadCollaborativeScope NS_SWIFT_NAME(playlistReadCollaborative) = (1 << 1),
-    /// Write access to a user's public playlists.
-    SPTPlaylistModifyPublicScope NS_SWIFT_NAME(playlistModifyPublic) = (1 << 2),
-    /// Write access to a user's private playlists.
-    SPTPlaylistModifyPrivateScope NS_SWIFT_NAME(playlistModifyPrivate) = (1 << 3),
-    /// Read access to the list of artists and other users that the user follows.
-    SPTUserFollowReadScope NS_SWIFT_NAME(userFollowRead) = (1 << 4),
-    /// Write/delete access to the list of artists and other users that the user follows.
-    SPTUserFollowModifyScope NS_SWIFT_NAME(userFollowModify) = (1 << 5),
-    /// Read access to a user's "Your Music" library.
-    SPTUserLibraryReadScope NS_SWIFT_NAME(userLibraryRead) = (1 << 6),
-    /// Write/delete access to a user's "Your Music" library.
-    SPTUserLibraryModifyScope NS_SWIFT_NAME(userLibraryModify) = (1 << 7),
-    /// Read access to the user's birthdate.
-    SPTUserReadBirthDateScope NS_SWIFT_NAME(userReadBirthDate) = (1 << 8),
-    /// Read access to user’s email address.
-    SPTUserReadEmailScope NS_SWIFT_NAME(userReadEmail) = (1 << 9),
-    /// Read access to user’s subscription details (type of user account).
-    SPTUserReadPrivateScope NS_SWIFT_NAME(userReadPrivate) = (1 << 10),
-    /// Read access to a user's top artists and tracks.
-    SPTUserTopReadScope NS_SWIFT_NAME(userTopRead) = (1 << 11),
-    /// Upload user generated content images
-    SPTUGCImageUploadScope NS_SWIFT_NAME(ugcImageUpload) = (1 << 12),
-    /// Control playback of a Spotify track.
-    SPTStreamingScope NS_SWIFT_NAME(streaming) = (1 << 13),
-    /// Use App Remote to control playback in the Spotify app
-    SPTAppRemoteControlScope NS_SWIFT_NAME(appRemoteControl) = (1 << 14),
-    /// Read access to a user’s player state.
-    SPTUserReadPlaybackStateScope NS_SWIFT_NAME(userReadPlaybackState) = (1 << 15),
-    /// Write access to a user’s playback state
-    SPTUserModifyPlaybackStateScope NS_SWIFT_NAME(userModifyPlaybackState) = (1 << 16),
-    /// Read access to a user’s currently playing track
-    SPTUserReadCurrentlyPlayingScope NS_SWIFT_NAME(userReadCurrentlyPlaying) = (1 << 17),
-    /// Read access to a user’s currently playing track
-    SPTUserReadRecentlyPlayedScope NS_SWIFT_NAME(userReadRecentlyPlayed) = (1 << 18),
-    /// Indicate that the application intends to use OIDC to verify the user's identity
-    SPTOpenIdScope NS_SWIFT_NAME(openid) = (1 << 19),
-};
+        /// Include collaborative playlists when requesting a user's playlists.
+        SPTPlaylistReadCollaborativeScope NS_SWIFT_NAME(playlistReadCollaborative) = (1 << 1),
+            /// Write access to a user's public playlists.
+            SPTPlaylistModifyPublicScope NS_SWIFT_NAME(playlistModifyPublic) = (1 << 2),
+                /// Write access to a user's private playlists.
+                SPTPlaylistModifyPrivateScope NS_SWIFT_NAME(playlistModifyPrivate) = (1 << 3),
+                    /// Read access to the list of artists and other users that the user follows.
+                    SPTUserFollowReadScope NS_SWIFT_NAME(userFollowRead) = (1 << 4),
+                        /// Write/delete access to the list of artists and other users that the user follows.
+                        SPTUserFollowModifyScope NS_SWIFT_NAME(userFollowModify) = (1 << 5),
+                            /// Read access to a user's "Your Music" library.
+                            SPTUserLibraryReadScope NS_SWIFT_NAME(userLibraryRead) = (1 << 6),
+                                /// Write/delete access to a user's "Your Music" library.
+                                SPTUserLibraryModifyScope NS_SWIFT_NAME(userLibraryModify) = (1 << 7),
+                                    /// Read access to the user's birthdate.
+                                    SPTUserReadBirthDateScope NS_SWIFT_NAME(userReadBirthDate) = (1 << 8),
+                                        /// Read access to user’s email address.
+                                        SPTUserReadEmailScope NS_SWIFT_NAME(userReadEmail) = (1 << 9),
+                                            /// Read access to user’s subscription details (type of user account).
+                                            SPTUserReadPrivateScope NS_SWIFT_NAME(userReadPrivate) = (1 << 10),
+                                                /// Read access to a user's top artists and tracks.
+                                                SPTUserTopReadScope NS_SWIFT_NAME(userTopRead) = (1 << 11),
+                                                    /// Upload user generated content images
+                                                    SPTUGCImageUploadScope NS_SWIFT_NAME(ugcImageUpload) = (1 << 12),
+                                                        /// Control playback of a Spotify track.
+                                                        SPTStreamingScope NS_SWIFT_NAME(streaming) = (1 << 13),
+                                                            /// Use App Remote to control playback in the Spotify app
+                                                            SPTAppRemoteControlScope NS_SWIFT_NAME(appRemoteControl) = (1 << 14),
+                                                                /// Read access to a user’s player state.
+                                                                SPTUserReadPlaybackStateScope NS_SWIFT_NAME(userReadPlaybackState) = (1 << 15),
+                                                                    /// Write access to a user’s playback state
+                                                                    SPTUserModifyPlaybackStateScope NS_SWIFT_NAME(userModifyPlaybackState) = (1 << 16),
+                                                                        /// Read access to a user’s currently playing
+                                                                        /// track
+                                                                        SPTUserReadCurrentlyPlayingScope NS_SWIFT_NAME(userReadCurrentlyPlaying) = (1 << 17),
+                                                                            /// Read access to a user’s currently
+                                                                            /// playing track
+                                                                            SPTUserReadRecentlyPlayedScope NS_SWIFT_NAME(userReadRecentlyPlayed) = (1 << 18),
+                                                                                /// Indicate that the application
+                                                                                /// intends to use OIDC to verify the
+                                                                                /// user's identity
+                                                                                SPTOpenIdScope NS_SWIFT_NAME(openid) = (1 << 19),
+                                                                            };

package/ios/SpotifySDK/SpotifyiOS.xcframework/ios-arm64/SpotifyiOS.framework/Headers/SPTSessionManager.h

@@ -8,11 +8,15 @@ NS_ASSUME_NONNULL_BEGIN
 
 /// Options for determining the most suitable method for authorization
 typedef NS_OPTIONS(NSUInteger, SPTAuthorizationOptions) {
-    /// Authorize using a suitable method. If Spotify is installed the app will be used instead of a web view
+    /// Authorize using a suitable method. If Spotify is installed the app will be used instead of ASWebAuthentication.
     SPTDefaultAuthorizationOption NS_SWIFT_NAME(default) = (0),
-    /// Authorize using only the Spotify client. If Spotify is not installed authorization will fail.
-    SPTClientAuthorizationOption NS_SWIFT_NAME(clientOnly) = (1 << 0),
-} NS_SWIFT_NAME(AuthorizationOptions);
+        /// Authorize using only the Spotify client. If Spotify is not installed authorization will fail.
+        SPTClientAuthorizationOption NS_SWIFT_NAME(clientOnly) = (1 << 0),
+            /// Use this option if you have reached the limit of `LSApplicationQueriesSchemes` in your Info.plist
+            /// Attempt to open Spotify app directly without using `canOpenURL`. Falls back to ASWebAuthentication if
+            /// opening fails.
+            SPTSpotifySchemeNotRegisteredAuthorizationOption NS_SWIFT_NAME(spotifySchemeNotRegistered) = (1 << 1),
+        } NS_SWIFT_NAME(AuthorizationOptions);
 
 typedef NSString *const SPTAuthorizationCode;
 

package/ios/SpotifySDK/SpotifyiOS.xcframework/ios-arm64/SpotifyiOS.framework/Headers/SpotifyiOS.h

@@ -4,4 +4,4 @@
 #import "SPTLogin.h"
 #import "SpotifyAppRemote.h"
 
-#endif /* _SPOTIFYIOS_ */
+#endif /* _SPOTIFYIOS_ */

package/ios/SpotifySDK/SpotifyiOS.xcframework/ios-arm64_x86_64-simulator/SpotifyiOS.framework/Headers/SPTConfiguration.h

@@ -51,7 +51,7 @@ NS_ASSUME_NONNULL_BEGIN
 - (instancetype)initWithClientID:(NSString *)clientID redirectURL:(NSURL *)redirectURL NS_DESIGNATED_INITIALIZER;
 
 /**
- Convenience intializer for `SPtConfiguration`
+ Convenience initializer for `SPTConfiguration`
 
  @param clientID Your client ID obtained from developer.spotify.com
  @param redirectURL Your redirect URL for Spotify to open your app again after authorization

package/ios/SpotifySDK/SpotifyiOS.xcframework/ios-arm64_x86_64-simulator/SpotifyiOS.framework/Headers/SPTError.h

@@ -10,13 +10,12 @@ SPT_EXPORT NSErrorDomain const SPTLoginErrorDomain;
 typedef NS_ENUM(NSUInteger, SPTErrorCode) {
     /// Unknown error code
     SPTUnknownErrorCode NS_SWIFT_NAME(unknown) = 0,
-    /// Authorization failed
-    SPTAuthorizationFailedErrorCode NS_SWIFT_NAME(authorizationFailed),
-    /// Renew session failed
-    SPTRenewSessionFailedErrorCode NS_SWIFT_NAME(renewSessionFailed),
-    /// Failed to parse the returned JSON
-    SPTJSONFailedErrorCode NS_SWIFT_NAME(jsonFailed),
-};
+        /// Authorization failed
+        SPTAuthorizationFailedErrorCode NS_SWIFT_NAME(authorizationFailed),
+            /// Renew session failed
+            SPTRenewSessionFailedErrorCode NS_SWIFT_NAME(renewSessionFailed),
+                                                         /// Failed to parse the returned JSON
+                                                         SPTJSONFailedErrorCode NS_SWIFT_NAME(jsonFailed) };
 
 /// Spotify-specific errors. Use NSUnderlyingErrorKey to see the underlying error
 @interface SPTError : NSError