Made room state event collapsing configurable, expose it in the developer menu. Allow the UserSetting property wrappers to only store values in memory (+11 squashed commits)

Squashed commits:
[42e45fc] Even more tweaks following code review
[5dcd5be] Add swift-algoritms and switch bubbling detection to its `chunked` method
[4ac70ed] Move the groupBy implementation to Collection instead of Array
[6aeffc3] Tweaks following code review
[0ca5ac2] Bubbles working again, grouping computed closer to the UI level
[3a66030] Refactor how timeline items are built in the RoomTimelineController
[57d51e9] Remove grouping from timeline items
[8608950] Remove the RoomTimelineViewFactory, update the GroupRoomTimelineView
[9e52e61] Add array grouping extension, unit tests and switched the timeline controller to it
[7d213a1] First attempt
[90bb1d7] Remove now unused `RoomTimelineController` `updatedTimelineItem` calback

ElementX/Sources/Other/Extensions/Array.swift

@@ -0,0 +1,69 @@
+//
+// Copyright 2023 New Vector Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import Foundation
+
+extension Array {
+    func groupBy(_ isGroupable: (Element) -> Bool) -> [[Element]] {
+        var newItems = [[Element]]()
+        
+        // Cache groupable states to avoid recomputing them later
+        let groupableStateByIndex = map(isGroupable)
+        
+        var itemsToBeGrouped = [Element]()
+        for (index, currentItem) in enumerated() {
+            let previousItem = self[safe: index - 1]
+            let nextItem = self[safe: index + 1]
+            
+            if groupableStateByIndex[safe: index] == true {
+                // At the begining of a groupable slice, very first message
+                if previousItem == nil, groupableStateByIndex[safe: index + 1] == true {
+                    itemsToBeGrouped.append(currentItem)
+                }
+                // Still at the begining of a groupable slice
+                else if groupableStateByIndex[safe: index - 1] == false, groupableStateByIndex[safe: index + 1] == true {
+                    itemsToBeGrouped.append(currentItem)
+                }
+                // In the middle of a groupable slice
+                else if !itemsToBeGrouped.isEmpty {
+                    itemsToBeGrouped.append(currentItem)
+                }
+                // Solitary groupable item
+                else {
+                    newItems.append([currentItem])
+                }
+                
+                // Last item in the list. Try finishing the groupable slice
+                if nextItem == nil, !itemsToBeGrouped.isEmpty {
+                    newItems.append(itemsToBeGrouped)
+                    itemsToBeGrouped.removeAll()
+                }
+                
+            } else {
+                // Finished a groupable slice
+                if !itemsToBeGrouped.isEmpty {
+                    newItems.append(itemsToBeGrouped)
+                    itemsToBeGrouped.removeAll()
+                }
+                
+                // Append the current element too
+                newItems.append([currentItem])
+            }
+        }
+        
+        return newItems
+    }
+}

ElementX/Sources/Other/UserSettingPropertyWrapper.swift

@@ -26,25 +26,31 @@ import Foundation
 @propertyWrapper
 struct UserSetting<Value: Equatable> {
     private let key: String
-    private let defaultValue: Value
-    private let storage: UserDefaults
+    private var defaultValue: Value
+    private let storage: UserDefaults?
     private let publisher: CurrentValueSubject<Value, Never>
     
-    init(key: String, defaultValue: Value, storage: UserDefaults = .standard) {
+    init(key: String, defaultValue: Value, persistIn storage: UserDefaults?) {
         self.key = key
         self.defaultValue = defaultValue
         self.storage = storage
         
-        let value = storage.value(forKey: key) as? Value ?? defaultValue
+        let value = storage?.value(forKey: key) as? Value ?? defaultValue
         publisher = CurrentValueSubject<Value, Never>(value)
     }
     
     var wrappedValue: Value {
         get {
-            let value = storage.value(forKey: key) as? Value
+            let value = storage?.value(forKey: key) as? Value
             return value ?? defaultValue
         }
         set {
+            guard let storage else {
+                defaultValue = newValue
+                publisher.send(defaultValue)
+                return
+            }
+            
             if let optional = newValue as? AnyOptional, optional.isNil {
                 storage.removeObject(forKey: key)
                 publisher.send(defaultValue)
@@ -61,8 +67,8 @@ struct UserSetting<Value: Equatable> {
 }
 
 extension UserSetting where Value: ExpressibleByNilLiteral {
-    init(key: String, storage: UserDefaults = .standard) {
-        self.init(key: key, defaultValue: nil, storage: storage)
+    init(key: String, persistIn storage: UserDefaults?) {
+        self.init(key: key, defaultValue: nil, persistIn: storage)
     }
 }
 
@@ -74,28 +80,34 @@ extension UserSetting where Value: ExpressibleByNilLiteral {
 @propertyWrapper
 struct UserSettingRawRepresentable<Value: RawRepresentable & Equatable> {
     private let key: String
-    private let defaultValue: Value
-    private let storage: UserDefaults
+    private var defaultValue: Value
+    private let storage: UserDefaults?
     private let publisher: CurrentValueSubject<Value, Never>
     
-    init(key: String, defaultValue: Value, storage: UserDefaults = .standard) {
+    init(key: String, defaultValue: Value, persistIn storage: UserDefaults?) {
         self.key = key
         self.defaultValue = defaultValue
         self.storage = storage
         
-        let value = (storage.value(forKey: key) as? Value.RawValue).flatMap { Value(rawValue: $0) } ?? defaultValue
+        let value = (storage?.value(forKey: key) as? Value.RawValue).flatMap { Value(rawValue: $0) } ?? defaultValue
         publisher = CurrentValueSubject<Value, Never>(value)
     }
     
     var wrappedValue: Value {
         get {
-            guard let value = storage.value(forKey: key) as? Value.RawValue else {
+            guard let value = storage?.value(forKey: key) as? Value.RawValue else {
                 return defaultValue
             }
             
             return Value(rawValue: value) ?? defaultValue
         }
         set {
+            guard let storage else {
+                defaultValue = newValue
+                publisher.send(defaultValue)
+                return
+            }
+            
             if let optional = newValue as? AnyOptional, optional.isNil {
                 storage.removeObject(forKey: key)
                 publisher.send(newValue)
@@ -112,8 +124,8 @@ struct UserSettingRawRepresentable<Value: RawRepresentable & Equatable> {
 }
 
 extension UserSettingRawRepresentable where Value: ExpressibleByNilLiteral {
-    init(key: String, storage: UserDefaults = .standard) {
-        self.init(key: key, defaultValue: nil, storage: storage)
+    init(key: String, persistIn storage: UserDefaults?) {
+        self.init(key: key, defaultValue: nil, persistIn: storage)
     }
 }