feat: rename files and classes for consistency

Renamed various files and classes to improve naming consistency across
the project. Updated references in the README.md and source files to
reflect these changes. This includes renaming classes like
QueueITApiClient to ApiClient, QueueITWaitingRoomProvider to
WaitingRoomProvider, and others.

Author: alexanderthoren

.swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata

@@ -168,29 +168,29 @@ When the user clicks back, the same check needs to be done.
 
 ### Getting the status of a waiting room
 
-If you're using version ```3.1.14``` or newer, it's possible to get the state of the waiting room using the new ```QueueITWaitingRoomProvider``` with one of the following methods:
+If you're using version ```3.1.14``` or newer, it's possible to get the state of the waiting room using the new ```WaitingRoomProvider``` with one of the following methods:
 
 * ```TryPass```
 * ```TryPassWithEnqueueToken``` 
 * ```TryPassWithEnqueueKey```
 
 Calling one of the above methods will trigger either the ```notifyProviderSuccess``` callback on success, or ```notifyProviderFailure``` callback on failure.
 
-When using the ```notifyProviderQueueITUnavailable``` from the ```ProviderSuccessDelegate``` it'll provide with a ```QueueTryPassResult``` depending on the ```isPassThrough``` result:
+When using the ```notifyProviderQueueITUnavailable``` from the ```ProviderSuccessDelegate``` it'll provide with a ```TryPassResult``` depending on the ```isPassThrough``` result:
 
-* ```true``` means that the ```QueueItToken``` is *not* empty, and more information is available in the ```QueueTryPassResult```
-* ```false``` means that the waiting room is *active*. You can show the visitor the waiting room by calling ```show``` from the ```QueueITWaitingRoomView```, by providing a ```queueUrl``` and ```targetUrl``` *([Read more about it here](#showing-the-queue-page-to-visitors))*
+* ```true``` means that the ```QueueItToken``` is *not* empty, and more information is available in the ```TryPassResult```
+* ```false``` means that the waiting room is *active*. You can show the visitor the waiting room by calling ```show``` from the ```WaitingRoomView```, by providing a ```queueUrl``` and ```targetUrl``` *([Read more about it here](#showing-the-queue-page-to-visitors))*
 
 ### Showing the queue page to visitors
 
-If you're using version ```3.1.14``` or newer, the ```QueueITWaitingRoomView``` class is available.
+If you're using version ```3.1.14``` or newer, the ```WaitingRoomView``` class is available.
 
-When the waiting room is queueing visitors, each visitor has to visit it once. Using the ```show``` method you can do this, you have to provide the ```queueUrl```, and the ```targetUrl``` which is returned by the ```notifyProviderSuccess``` from ```QueueITWaitingRoomProvider``` class, given the waiting room is *active* ([Read more about it here](#getting-the-status-of-a-waiting-room)) 
+When the waiting room is queueing visitors, each visitor has to visit it once. Using the ```show``` method you can do this, you have to provide the ```queueUrl```, and the ```targetUrl``` which is returned by the ```notifyProviderSuccess``` from ```WaitingRoomProvider``` class, given the waiting room is *active* ([Read more about it here](#getting-the-status-of-a-waiting-room)) 
 
 
 #### Sample code showing the queue page:
 ``` objc
--(void)notifyProviderSuccess:(QueueTryPassResult* _Nonnull) queuePassResult {   
+-(void)notifyProviderSuccess:(TryPassResult* _Nonnull) queuePassResult {   
    [self.waitingRoomView show:queuePassResult.queueUrl targetUrl:queuePassResult.targetUrl];
 }
 ```

README.md

@@ -3,13 +3,13 @@ import Foundation
 typealias QueueServiceSuccess = (Data) -> Void
 typealias QueueServiceFailure = (Error, String) -> Void
 
-class QueueITApiClient {
+class ApiClient {
     static let API_ROOT = "https://%@.queue-it.net/api/mobileapp/queue"
     static let TESTING_API_ROOT = "https://%@.test.queue-it.net/api/mobileapp/queue"
     private static var testingIsEnabled = false
-    private static var sharedInstance: QueueITApiClient?
+    private static var sharedInstance: ApiClient?
 
-    static func getInstance() -> QueueITApiClient {
+    static func getInstance() -> ApiClient {
         if sharedInstance == nil {
             sharedInstance = Connection()
         }
@@ -30,7 +30,7 @@ class QueueITApiClient {
         language: String?,
         enqueueToken: String?,
         enqueueKey: String?,
-        success: @escaping (QueueStatus?) -> Void,
+        success: @escaping (Status?) -> Void,
         failure: @escaping QueueServiceFailure
     ) {
         var bodyDict: [String: Any] = [
@@ -55,7 +55,7 @@ class QueueITApiClient {
             bodyDict["enqueueKey"] = enqueueKey
         }
 
-        let apiRoot = QueueITApiClient.testingIsEnabled ? QueueITApiClient.TESTING_API_ROOT : QueueITApiClient.API_ROOT
+        let apiRoot = ApiClient.testingIsEnabled ? ApiClient.TESTING_API_ROOT : ApiClient.API_ROOT
         var urlAsString = String(format: apiRoot, customerId)
         urlAsString += "/\(customerId)"
         urlAsString += "/\(eventOrAliasId)"
@@ -70,8 +70,8 @@ class QueueITApiClient {
                         with: data,
                         options: []
                     ) as? [String: Any] {
-                        let queueStatus = QueueStatus(dictionary: userDict)
-                        success(queueStatus)
+                        let Status = Status(dictionary: userDict)
+                        success(Status)
                     } else {
                         success(nil)
                     }
@@ -91,7 +91,7 @@ class QueueITApiClient {
     ) {
         guard let url = URL(string: path) else {
             let error = NSError(
-                domain: "QueueITApiClient",
+                domain: "ApiClient",
                 code: -1,
                 userInfo: [NSLocalizedDescriptionKey: "Invalid URL"]
             )

Sources/QueueITLib/NewQueueITApiClient.swift renamed to Sources/QueueITLib/ApiClient.swift

@@ -1,6 +1,6 @@
 import Foundation
 
-final class Connection: QueueITApiClient {
+final class Connection: ApiClient {
     private var connectionRequest: ConnectionRequest?
 
     override func submitRequest(

Sources/QueueITLib/NewConnection.swift renamed to Sources/QueueITLib/Connection.swift

@@ -1,4 +1,4 @@
-enum QueueConsts {
+enum Constants {
     static let queueCloseUrl = "queueit://close"
     static let queueRestartSessionUrl = "queueit://restartSession"
     static let sdkVersion = "iOS-3.4.4"

Sources/QueueITLib/NewConnectionRequest.swift renamed to Sources/QueueITLib/ConnectionRequest.swift

@@ -53,19 +53,19 @@ public final class QueueItEngine {
     public weak var queueViewDidAppearDelegate: QueueViewDidAppearDelegate?
 
     public weak var host: UIViewController?
-    private var waitingRoomProvider: QueueITWaitingRoomProvider
-    private var waitingRoomView: QueueITWaitingRoomView
+    private var waitingRoomProvider: WaitingRoomProvider
+    private var waitingRoomView: WaitingRoomView
 
     public init(host: UIViewController, customerId: String, eventOrAliasId: String, layoutName: String?, language: String?) {
         self.host = host
 
-        waitingRoomProvider = QueueITWaitingRoomProvider(
+        waitingRoomProvider = WaitingRoomProvider(
             customerId: customerId,
             eventOrAliasId: eventOrAliasId,
             layoutName: layoutName,
             language: language
         )
-        waitingRoomView = QueueITWaitingRoomView(host: host, eventId: eventOrAliasId)
+        waitingRoomView = WaitingRoomView(host: host, eventId: eventOrAliasId)
         waitingRoomView.delegate = self
         waitingRoomProvider.delegate = self
     }
@@ -95,7 +95,7 @@ public final class QueueItEngine {
     }
 }
 
-extension QueueItEngine: QueueITWaitingRoomViewDelegate {
+extension QueueItEngine: WaitingRoomViewDelegate {
     func notifyViewUserExited() {
         queueUserExitedDelegate?.notifyUserExited()
     }
@@ -126,8 +126,8 @@ extension QueueItEngine: QueueITWaitingRoomViewDelegate {
     }
 }
 
-extension QueueItEngine: QueueITWaitingRoomProviderDelegate {
-    func notifyProviderSuccess(queuePassResult: QueueTryPassResult) {
+extension QueueItEngine: WaitingRoomProviderDelegate {
+    func notifyProviderSuccess(queuePassResult: TryPassResult) {
         switch queuePassResult.redirectType {
         case "safetynet":
             let queuePassedInfo = QueuePassedInfo(queueitToken: queuePassResult.queueToken)

Sources/QueueITLib/NewQueueConsts.swift renamed to Sources/QueueITLib/Constants.swift

@@ -7,33 +7,33 @@ extension Notification.Name {
     static let reachabilityChanged = Notification.Name("kNetworkReachabilityChangedNotification")
 }
 
-final class QueueITReachability {
+final class Reachability {
     private var monitor: NWPathMonitor?
     private var isMonitoringLocalWiFi: Bool = false
     private var queue = DispatchQueue.global(qos: .background)
 
     private init() {}
 
-    static func reachabilityWithHostName(_ hostName: String) -> QueueITReachability {
-        let reachability = QueueITReachability()
+    static func reachabilityWithHostName(_ hostName: String) -> Reachability {
+        let reachability = Reachability()
         reachability.startMonitoringHost(hostName: hostName)
         return reachability
     }
 
-    static func reachabilityWithAddress(_ hostAddress: sockaddr_in) -> QueueITReachability {
-        let reachability = QueueITReachability()
+    static func reachabilityWithAddress(_ hostAddress: sockaddr_in) -> Reachability {
+        let reachability = Reachability()
         reachability.startMonitoringIP(address: hostAddress)
         return reachability
     }
 
-    static func reachabilityForInternetConnection() -> QueueITReachability {
-        let reachability = QueueITReachability()
+    static func reachabilityForInternetConnection() -> Reachability {
+        let reachability = Reachability()
         reachability.startMonitoringInternet()
         return reachability
     }
 
-    static func reachabilityForLocalWiFi() -> QueueITReachability {
-        let reachability = QueueITReachability()
+    static func reachabilityForLocalWiFi() -> Reachability {
+        let reachability = Reachability()
         reachability.startMonitoringWiFi()
         return reachability
     }
@@ -74,15 +74,15 @@ final class QueueITReachability {
     }
 }
 
-extension QueueITReachability {
+extension Reachability {
     enum NetworkStatus: Int {
         case notReachable = 0
         case reachableViaWiFi
         case reachableViaWWAN
     }
 }
 
-private extension QueueITReachability {
+private extension Reachability {
     func startMonitoringHost(hostName _: String) {
         monitor = NWPathMonitor(requiredInterfaceType: .other)
         monitor?.pathUpdateHandler = { _ in

Sources/QueueITLib/NewQueueITEngine.swift renamed to Sources/QueueITLib/QueueITEngine.swift

@@ -1,4 +1,4 @@
-struct QueueStatus {
+struct Status {
     let queueId: String
     let queueUrlString: String
     let eventTargetUrl: String
@@ -21,7 +21,7 @@ struct QueueStatus {
     }
 }
 
-private extension QueueStatus {
+private extension Status {
     enum Constants {
         static let KEY_QUEUE_ID = "QueueId"
         static let KEY_QUEUE_URL = "QueueUrl"