Run SwiftFormat.

ElementX/Sources/Services/Timeline/TimelineItemProvider.swift

@@ -12,58 +12,58 @@ import MatrixRustSDK
 
 class TimelineItemProvider: TimelineItemProviderProtocol {
     private var cancellables = Set<AnyCancellable>()
-
+    
     private var roomTimelineObservationToken: TaskHandle?
-
+    
     /// Bridge from the SDK's synchronous callback into Swift Concurrency. Yielding is safe from any
     /// thread; a single long-lived `for await` consumer (set up in `init`) applies the diffs on the
     /// main actor in FIFO order, guaranteeing one in-flight update at a time.
     private let diffContinuation: AsyncStream<[TimelineDiff]>.Continuation
-
+    
     private let paginationStateSubject = CurrentValueSubject<TimelinePaginationState, Never>(.initial)
     var paginationState: TimelinePaginationState {
         paginationStateSubject.value
     }
-
+    
     private let itemProxiesSubject: CurrentValueSubject<[TimelineItemProxy], Never>
     private(set) var itemProxies: [TimelineItemProxy] = [] {
         didSet {
             itemProxiesSubject.send(itemProxies)
         }
     }
-
+    
     var updatePublisher: AnyPublisher<([TimelineItemProxy], TimelinePaginationState), Never> {
         itemProxiesSubject
             .combineLatest(paginationStateSubject)
             .eraseToAnyPublisher()
     }
-
+    
     let kind: TimelineKind
-
+    
     private let membershipChangeSubject = PassthroughSubject<Void, Never>()
     var membershipChangePublisher: AnyPublisher<Void, Never> {
         membershipChangeSubject
             .eraseToAnyPublisher()
     }
-
+    
     deinit {
         diffContinuation.finish()
         roomTimelineObservationToken?.cancel()
     }
-
+    
     init(timeline: Timeline, kind: TimelineKind, paginationStatePublisher: AnyPublisher<TimelinePaginationState, Never>) {
         itemProxiesSubject = CurrentValueSubject<[TimelineItemProxy], Never>([])
         self.kind = kind
-
+        
         let (diffStream, diffContinuation) = AsyncStream<[TimelineDiff]>.makeStream()
         self.diffContinuation = diffContinuation
-
+        
         paginationStatePublisher
             .sink { [weak self] in
                 self?.paginationStateSubject.send($0)
             }
             .store(in: &cancellables)
-
+        
         // `for await` guarantees FIFO ordering and that only one diff is being applied at a time.
         // The stream also allows to handle the sendable items in the listener.
         Task { [weak self] in
@@ -71,7 +71,7 @@ class TimelineItemProvider: TimelineItemProviderProtocol {
                 self?.updateItemsWithDiffs(diffs)
             }
         }
-
+        
         Task {
             roomTimelineObservationToken = await timeline.addListener(listener: SDKListener { diffs in
                 diffContinuation.yield(diffs)
@@ -128,11 +128,11 @@ class TimelineItemProvider: TimelineItemProviderProtocol {
             changes.append(.insert(offset: Int(index), element: itemProxy, associatedWith: nil))
         case .popBack:
             guard let itemProxy = itemProxies.last else { fatalError() }
-
+            
             changes.append(.remove(offset: itemProxies.count - 1, element: itemProxy, associatedWith: nil))
         case .popFront:
             guard let itemProxy = itemProxies.first else { fatalError() }
-
+            
             changes.append(.remove(offset: 0, element: itemProxy, associatedWith: nil))
         case .pushBack(let item):
             let itemProxy = TimelineItemProxy(item: item)
@@ -154,7 +154,7 @@ class TimelineItemProvider: TimelineItemProviderProtocol {
             for (index, itemProxy) in itemProxies.enumerated() {
                 changes.append(.remove(offset: index, element: itemProxy, associatedWith: nil))
             }
-
+            
             for (index, timelineItem) in items.enumerated() {
                 changes.append(.insert(offset: index, element: TimelineItemProxy(item: timelineItem), associatedWith: nil))
             }