Format Realtime package

Author: grdsdev

Package.swift

@@ -21,7 +21,8 @@ let package = Package(
     .library(name: "Storage", targets: ["Storage"]),
     .library(
       name: "Supabase",
-      targets: ["Supabase", "Functions", "PostgREST", "GoTrue", "Realtime", "Storage"]),
+      targets: ["Supabase", "Functions", "PostgREST", "GoTrue", "Realtime", "Storage"]
+    ),
   ],
   dependencies: [
     .package(url: "https://github.com/kishikawakatsumi/KeychainAccess", from: "4.2.2"),

Sources/Realtime/Defaults.swift

@@ -21,36 +21,36 @@
 import Foundation
 
 /// A collection of default values and behaviors used across the Client
-public class Defaults {
-
+public enum Defaults {
   /// Default timeout when sending messages
   public static let timeoutInterval: TimeInterval = 10.0
 
   /// Default interval to send heartbeats on
   public static let heartbeatInterval: TimeInterval = 30.0
 
-  /// Default maximum amount of time which the system may delay heartbeat events in order to minimize power usage
+  /// Default maximum amount of time which the system may delay heartbeat events in order to
+  /// minimize power usage
   public static let heartbeatLeeway: DispatchTimeInterval = .milliseconds(10)
 
   /// Default reconnect algorithm for the socket
   public static let reconnectSteppedBackOff: (Int) -> TimeInterval = { tries in
-    return tries > 9 ? 5.0 : [0.01, 0.05, 0.1, 0.15, 0.2, 0.25, 0.5, 1.0, 2.0][tries - 1]
+    tries > 9 ? 5.0 : [0.01, 0.05, 0.1, 0.15, 0.2, 0.25, 0.5, 1.0, 2.0][tries - 1]
   }
 
   /** Default rejoin algorithm for individual channels */
   public static let rejoinSteppedBackOff: (Int) -> TimeInterval = { tries in
-    return tries > 3 ? 10 : [1, 2, 5][tries - 1]
+    tries > 3 ? 10 : [1, 2, 5][tries - 1]
   }
 
   public static let vsn = "2.0.0"
 
   /// Default encode function, utilizing JSONSerialization.data
   public static let encode: (Any) -> Data = { json in
-    return
-      try! JSONSerialization
+    try! JSONSerialization
       .data(
         withJSONObject: json,
-        options: JSONSerialization.WritingOptions())
+        options: JSONSerialization.WritingOptions()
+      )
   }
 
   /// Default decode function, utilizing JSONSerialization.jsonObject
@@ -60,13 +60,15 @@ public class Defaults {
         try? JSONSerialization
         .jsonObject(
           with: data,
-          options: JSONSerialization.ReadingOptions())
+          options: JSONSerialization.ReadingOptions()
+        )
     else { return nil }
     return json
   }
 
-  public static let heartbeatQueue: DispatchQueue = DispatchQueue(
-    label: "com.phoenix.socket.heartbeat")
+  public static let heartbeatQueue: DispatchQueue = .init(
+    label: "com.phoenix.socket.heartbeat"
+  )
 }
 
 /// Represents the multiple states that a Channel can be in
@@ -81,7 +83,7 @@ public enum ChannelState: String {
 
 /// Represents the different events that can be sent through
 /// a channel regarding a Channel's lifecycle.
-public struct ChannelEvent {
+public enum ChannelEvent {
   public static let heartbeat = "heartbeat"
   public static let join = "phx_join"
   public static let leave = "phx_leave"

Sources/Realtime/Delegated.swift

@@ -23,7 +23,6 @@
 /// instead of added as a dependency to reduce the number of packages that
 /// ship with SwiftPhoenixClient
 public struct Delegated<Input, Output> {
-
   private(set) var callback: ((Input) -> Output?)?
 
   public init() {}
@@ -33,31 +32,29 @@ public struct Delegated<Input, Output> {
     with callback: @escaping (Target, Input) -> Output
   ) {
     self.callback = { [weak target] input in
-      guard let target = target else {
+      guard let target else {
         return nil
       }
       return callback(target, input)
     }
   }
 
   public func call(_ input: Input) -> Output? {
-    return self.callback?(input)
+    callback?(input)
   }
 
   public var isDelegateSet: Bool {
-    return callback != nil
+    callback != nil
   }
-
 }
 
 extension Delegated {
-
   public mutating func stronglyDelegate<Target: AnyObject>(
     to target: Target,
     with callback: @escaping (Target, Input) -> Output
   ) {
     self.callback = { input in
-      return callback(target, input)
+      callback(target, input)
     }
   }
 
@@ -66,49 +63,40 @@ extension Delegated {
   }
 
   public mutating func removeDelegate() {
-    self.callback = nil
+    callback = nil
   }
-
 }
 
 extension Delegated where Input == Void {
-
   public mutating func delegate<Target: AnyObject>(
     to target: Target,
     with callback: @escaping (Target) -> Output
   ) {
-    self.delegate(to: target, with: { target, voidInput in callback(target) })
+    delegate(to: target, with: { target, _ in callback(target) })
   }
 
   public mutating func stronglyDelegate<Target: AnyObject>(
     to target: Target,
     with callback: @escaping (Target) -> Output
   ) {
-    self.stronglyDelegate(to: target, with: { target, voidInput in callback(target) })
+    stronglyDelegate(to: target, with: { target, _ in callback(target) })
   }
-
 }
 
 extension Delegated where Input == Void {
-
   public func call() -> Output? {
-    return self.call(())
+    call(())
   }
-
 }
 
 extension Delegated where Output == Void {
-
   public func call(_ input: Input) {
-    self.callback?(input)
+    callback?(input)
   }
-
 }
 
 extension Delegated where Input == Void, Output == Void {
-
   public func call() {
-    self.call(())
+    call(())
   }
-
 }

Sources/Realtime/HeartbeatTimer.swift

@@ -28,10 +28,11 @@ import Foundation
  */
 
 class HeartbeatTimer {
+  // ----------------------------------------------------------------------
 
-  //----------------------------------------------------------------------
   // MARK: - Dependencies
-  //----------------------------------------------------------------------
+
+  // ----------------------------------------------------------------------
   // The interval to wait before firing the Timer
   let timeInterval: TimeInterval
 
@@ -44,13 +45,15 @@ class HeartbeatTimer {
   // UUID which specifies the Timer instance. Verifies that timers are different
   let uuid: String = UUID().uuidString
 
-  //----------------------------------------------------------------------
+  // ----------------------------------------------------------------------
+
   // MARK: - Properties
-  //----------------------------------------------------------------------
+
+  // ----------------------------------------------------------------------
   // The underlying, cancelable, resettable, timer.
-  private var temporaryTimer: DispatchSourceTimer? = nil
+  private var temporaryTimer: DispatchSourceTimer?
   // The event handler that is called by the timer when it fires.
-  private var temporaryEventHandler: (() -> Void)? = nil
+  private var temporaryEventHandler: (() -> Void)?
 
   /**
    Create a new HeartbeatTimer
@@ -89,7 +92,8 @@ class HeartbeatTimer {
       timer.schedule(
         deadline: DispatchTime.now() + self.timeInterval,
         repeating: self.timeInterval,
-        leeway: self.leeway)
+        leeway: self.leeway
+      )
 
       // Start the timer
       timer.resume()
@@ -111,7 +115,7 @@ class HeartbeatTimer {
    True if the Timer exists and has not been cancelled. False otherwise
    */
   var isValid: Bool {
-    guard let timer = self.temporaryTimer else { return false }
+    guard let timer = temporaryTimer else { return false }
     return !timer.isCancelled
   }
 
@@ -121,12 +125,12 @@ class HeartbeatTimer {
    */
   func fire() {
     guard isValid else { return }
-    self.temporaryEventHandler?()
+    temporaryEventHandler?()
   }
 }
 
 extension HeartbeatTimer: Equatable {
   static func == (lhs: HeartbeatTimer, rhs: HeartbeatTimer) -> Bool {
-    return lhs.uuid == rhs.uuid
+    lhs.uuid == rhs.uuid
   }
 }

Sources/Realtime/Message.swift

@@ -22,12 +22,11 @@ import Foundation
 
 /// Data that is received from the Server.
 public class Message {
-
   /// Reference number. Empty if missing
   public let ref: String
 
   /// Join Reference number
-  internal let joinRef: String?
+  let joinRef: String?
 
   /// Message topic
   public let topic: String
@@ -51,7 +50,7 @@ public class Message {
   /// message.payload["status"]
   /// ```
   public var status: String? {
-    return rawPayload["status"] as? String
+    rawPayload["status"] as? String
   }
 
   init(
@@ -64,23 +63,22 @@ public class Message {
     self.ref = ref
     self.topic = topic
     self.event = event
-    self.rawPayload = payload
+    rawPayload = payload
     self.joinRef = joinRef
   }
 
   init?(json: [Any?]) {
     guard json.count > 4 else { return nil }
-    self.joinRef = json[0] as? String
-    self.ref = json[1] as? String ?? ""
+    joinRef = json[0] as? String
+    ref = json[1] as? String ?? ""
 
     if let topic = json[2] as? String,
       let event = json[3] as? String,
       let payload = json[4] as? Payload
     {
-
       self.topic = topic
       self.event = event
-      self.rawPayload = payload
+      rawPayload = payload
     } else {
       return nil
     }