feat: Update package structure

- Avoid system frameworks imports in Interface declarations

Author: maximkrouk

Sources/IDFAPermissionsClient/IDFAPermissionsClient.swift

@@ -1,7 +1,3 @@
-#if !os(watchOS)
-import AppTrackingTransparency
-#endif
-
 public struct IDFAPermissionsClient {
   public init(
     requestAuthorizationStatus: Operations.RequestAuthorizationStatus,
@@ -19,41 +15,61 @@ public struct IDFAPermissionsClient {
 }
 
 extension IDFAPermissionsClient {
-  public enum AuthorizationStatus: String, Equatable {
-    case notDetermined = "Not Determined"
-    case restricted = "Restricted"
-    case denied = "Denied"
-    case authorized = "Authorized"
-    case unknown = "Unknown"
-    case unavailableWithTrackingEnabled = "Unavailable: Tracking Enabled"
-    case unavailableWithTrackingDisabled = "Unavailable: Tracking Disabled"
-    
-    #if !os(watchOS)
-    @available(iOS 14, macOS 11, tvOS 14, *)
-    public init(_ status: ATTrackingManager.AuthorizationStatus) {
-      switch status {
-      case .notDetermined: self = .notDetermined
-      case .authorized: self = .authorized
-      case .restricted: self = .restricted
-      case .denied: self = .denied
-      @unknown default: self = .unknown
+  public struct AuthorizationStatus: RawRepresentable, Equatable {
+    public enum RawValue: Equatable {
+      public enum TrackingManagerStatus: Int, Equatable {
+        case notDetermined = 0
+        case restricted = 1
+        case denied = 2
+        case authorized = 3
       }
+      
+      case trackingManager(TrackingManagerStatus)
+      case identifierManager(isTrackingEnabled: Bool)
+      case unknown
     }
 
-    @available(iOS 14, macOS 11, *)
-    public var status: ATTrackingManager.AuthorizationStatus? {
-      switch self {
-      case .notDetermined, .unknown: return .notDetermined
-      case .authorized: return .authorized
-      case .restricted: return .restricted
-      case .denied: return .denied
-      default: return .none
-      }
+    public var rawValue: RawValue
+    
+    public init(rawValue: RawValue) {
+      self.rawValue = rawValue
+    }
+    
+    public static var notDetermined: AuthorizationStatus {
+      return .init(rawValue: .trackingManager(.notDetermined))
+    }
+    
+    public static var restricted: AuthorizationStatus {
+      return .init(rawValue: .trackingManager(.restricted))
+    }
+    
+    public static var denied: AuthorizationStatus {
+      return .init(rawValue: .trackingManager(.denied))
+    }
+    
+    public static var authorized: AuthorizationStatus {
+      return .init(rawValue: .trackingManager(.authorized))
+    }
+    
+    public static var unknown: AuthorizationStatus {
+      return .init(rawValue: .unknown)
+    }
+    
+    public static var unavailableWithTrackingEnabled: AuthorizationStatus {
+      return .init(rawValue: .identifierManager(isTrackingEnabled: true))
+    }
+    
+    public static var unavailableWithTrackingDisabled: AuthorizationStatus {
+      return .init(rawValue: .identifierManager(isTrackingEnabled: false))
     }
-    #endif
 
     public var isPermissive: Bool {
       self == .authorized || self == .unavailableWithTrackingEnabled
     }
   }
 }
+
+public func ~=(
+  rhs: IDFAPermissionsClient.AuthorizationStatus,
+  lhs: IDFAPermissionsClient.AuthorizationStatus
+) -> Bool { return rhs == lhs }

Sources/IDFAPermissionsClientLive/AuthorizationStatus.swift

@@ -0,0 +1,28 @@
+#if !os(watchOS)
+import AppTrackingTransparency
+import IDFAPermissionsClient
+
+extension IDFAPermissionsClient.AuthorizationStatus {
+  @available(iOS 14, macOS 11, tvOS 14, *)
+  public init(_ status: ATTrackingManager.AuthorizationStatus) {
+    switch status {
+    case .notDetermined: self = .notDetermined
+    case .authorized: self = .authorized
+    case .restricted: self = .restricted
+    case .denied: self = .denied
+    @unknown default: self = .unknown
+    }
+  }
+  
+  @available(iOS 14, macOS 11, tvOS 14, *)
+  public var status: ATTrackingManager.AuthorizationStatus? {
+    switch self {
+    case .notDetermined: return .notDetermined
+    case .authorized: return .authorized
+    case .restricted: return .restricted
+    case .denied: return .denied
+    default: return .none
+    }
+  }
+}
+#endif

Sources/NotificationsPermissionsClient/NotificationPermissionsClient.swift

@@ -1,45 +1,65 @@
-import Combine
-import Prelude
-
-extension NotificationsPermissionsClient {
-  public enum Operations {}
+public struct NotificationsPermissionsClient {
+  public init(
+    requestAuthorizationStatus: Operations.RequestAuthorizationStatus,
+    requestAuthorization: Operations.RequestAuthorization,
+    configureRemoteNotifications: Operations.ConfigureRemoteNotifications
+  ) {
+    self.requestAuthorizationStatus = requestAuthorizationStatus
+    self.requestAuthorization = requestAuthorization
+    self.configureRemoteNotifications = configureRemoteNotifications
+  }
+  
+  public var requestAuthorizationStatus: Operations.RequestAuthorizationStatus
+  public var requestAuthorization: Operations.RequestAuthorization
+  public var configureRemoteNotifications: Operations.ConfigureRemoteNotifications
 }
 
-extension NotificationsPermissionsClient.Operations {
-  public struct RequestAuthorizationStatus: Function {
-    public typealias Input = Void
-    public typealias Output = AnyPublisher<NotificationsPermissionsClient.AuthorizationStatus, Never>
-    
-    public init(_ call: @escaping Signature) {
-      self.call = call
+extension NotificationsPermissionsClient {
+  public struct AuthorizationOptions: OptionSet, Equatable {
+    public var rawValue: UInt
+    public init(rawValue: UInt) {
+      self.rawValue = rawValue
     }
 
-    public let call: Signature
-  }
-  
-  public struct RequestAuthorization: Function {
-    public typealias Input = NotificationsPermissionsClient.AuthorizationOptions
-    public typealias Output = AnyPublisher<NotificationsPermissionsClient.AuthorizationStatus, Never>
+    public static var badge: AuthorizationOptions { .init(rawValue: 1 << 0) }
 
-    public init(_ call: @escaping Signature) {
-      self.call = call
-    }
+    public static var sound: AuthorizationOptions { .init(rawValue: 1 << 1) }
 
-    public let call: Signature
+    public static var alert: AuthorizationOptions { .init(rawValue: 1 << 2) }
 
-    public func callAsFunction(options: Input) -> Output {
-      return call(options)
-    }
+    public static var carPlay: AuthorizationOptions  { .init(rawValue: 1 << 3) }
+    
+    public static var criticalAlert: AuthorizationOptions  { .init(rawValue: 1 << 4) }
+    
+    public static var providesAppNotificationSettings: AuthorizationOptions  { .init(rawValue: 1 << 5) }
+    
+    public static var provisional: AuthorizationOptions  { .init(rawValue: 1 << 6) }
+    
+    #if os(iOS)
+    public static var announcement: AuthorizationOptions  { .init(rawValue: 1 << 7) }
+    #endif
   }
 
-  public struct ConfigureRemoteNotifications: Function {
-    public enum Input { case register, unregister }
-    public typealias Output = Void
+  public enum AuthorizationStatus: Equatable {
+    case notDetermined
+    case denied
+    case authorized
+    case provisional
 
-    public init(_ call: @escaping Signature) {
-      self.call = call
-    }
+    #if os(iOS)
+    @available(iOS 14.0, *)
+    case ephemeral
+    #endif
 
-    public let call: Signature
+    case unknown
+    
+    public var isPermissive: Bool {
+      #if os(iOS)
+      if #available(iOS 14.0, *) {
+        if self == .ephemeral { return true }
+      }
+      #endif
+      return self == .authorized || self == .provisional
+    }
   }
 }