Add animated option when perform batchUpdate

Author: dangthaison91

Sources/DataSources/ASCollectionNode+Rx/ASCollectionNode+SectionViewType.swift

@@ -46,7 +46,13 @@ extension ASCollectionNode: SectionedViewType {
     }
 
     public func performBatchUpdates<S: SectionModelType>(_ changes: Changeset<S>, animationConfiguration: AnimationConfiguration) {
-        self.performBatch(animated: false, updates: {
+        self.performBatch(animated: true, updates: {
+            _performBatchUpdates(self, changes: changes, animationConfiguration: animationConfiguration)
+        }, completion: nil)
+    }
+
+    public func performBatchUpdates<S: SectionModelType>(_ changes: Changeset<S>, animated: Bool, animationConfiguration: AnimationConfiguration) {
+        self.performBatch(animated: animated, updates: {
             _performBatchUpdates(self, changes: changes, animationConfiguration: animationConfiguration)
         }, completion: nil)
     }

Sources/DataSources/ASCollectionNode+Rx/RxASCollectionAnimatedDataSource.swift

@@ -16,6 +16,7 @@ open class RxASCollectionAnimatedDataSource<S: AnimatableSectionModelType>: ASCo
 
     public typealias Element = [S]
     public var animationConfiguration = AnimationConfiguration()
+    public var animated: Bool = true
 
     var dataSet = false
 
@@ -30,27 +31,21 @@ open class RxASCollectionAnimatedDataSource<S: AnimatableSectionModelType>: ASCo
             #endif
             if !self.dataSet {
                 self.dataSet = true
-                DispatchQueue.main.async {
-                    dataSource.setSections(newSections)
-                    collectionNode.reloadData()
-                }
+                dataSource.setSections(newSections)
+                collectionNode.reloadData()
             } else {
                 let oldSections = dataSource.sectionModels
                 do {
                     let differences = try differencesForSectionedView(initialSections: oldSections, finalSections: newSections)
-                    DispatchQueue.main.async {
 
-                        for difference in differences {
-                            dataSource.setSections(difference.finalSections)
-                            collectionNode.performBatchUpdates(difference, animationConfiguration: self.animationConfiguration)
-                        }
+                    for difference in differences {
+                        dataSource.setSections(difference.finalSections)
+                        collectionNode.performBatchUpdates(difference, animated: self.animated, animationConfiguration: self.animationConfiguration)
                     }
                 } catch {
                     rxDebugFatalError("\(error)")
-                    DispatchQueue.main.async {
-                        self.setSections(newSections)
-                        collectionNode.reloadData()
-                    }
+                    self.setSections(newSections)
+                    collectionNode.reloadData()
                 }
             }
             }.on(observedEvent)

Sources/DataSources/ASTableNode+Rx/ASTableNode+SectionedViewType.swift

@@ -45,7 +45,13 @@ extension ASTableNode: SectionedViewType {
     }
 
     public func performBatchUpdates<S: SectionModelType>(_ changes: Changeset<S>, animationConfiguration: AnimationConfiguration) {
-        self.performBatch(animated: false, updates: {
+        self.performBatch(animated: true, updates: {
+            _performBatchUpdates(self, changes: changes, animationConfiguration: animationConfiguration)
+        }, completion: nil)
+    }
+
+    public func performBatchUpdates<S: SectionModelType>(_ changes: Changeset<S>, animated: Bool, animationConfiguration: AnimationConfiguration) {
+        self.performBatch(animated: animated, updates: {
             _performBatchUpdates(self, changes: changes, animationConfiguration: animationConfiguration)
         }, completion: nil)
     }

Sources/DataSources/ASTableNode+Rx/RxASTableAnimatedDataSource.swift

@@ -16,7 +16,8 @@ open class RxASTableAnimatedDataSource<S: AnimatableSectionModelType>: ASTableSe
 
     public typealias Element = [S]
     public var animationConfiguration = AnimationConfiguration()
-
+    public var animated: Bool = true
+    
     var dataSet = false
 
     public override init() {
@@ -30,29 +31,22 @@ open class RxASTableAnimatedDataSource<S: AnimatableSectionModelType>: ASTableSe
             #endif
             if !self.dataSet {
                 self.dataSet = true
-                DispatchQueue.main.async {
-                    dataSource.setSections(newSections)
-                    tableNode.reloadData()
-                }
+                dataSource.setSections(newSections)
+                tableNode.reloadData()
             } else {
                 let oldSections = dataSource.sectionModels
                 do {
                     let differences = try differencesForSectionedView(initialSections: oldSections, finalSections: newSections)
-                    DispatchQueue.main.async {
-                        for difference in differences {
-                            dataSource.setSections(difference.finalSections)
-                            tableNode.performBatchUpdates(difference, animationConfiguration: self.animationConfiguration)
-                        }
-                        tableNode.waitUntilAllUpdatesAreCommitted()
+                    for difference in differences {
+                        dataSource.setSections(difference.finalSections)
+                        tableNode.performBatchUpdates(difference, animated: self.animated, animationConfiguration: self.animationConfiguration)
                     }
                 } catch {
                     rxDebugFatalError("\(error)")
-                    DispatchQueue.main.async {
-                        self.setSections(newSections)
-                        tableNode.reloadData()
-                    }
+                    self.setSections(newSections)
+                    tableNode.reloadData()
                 }
             }
-        }.on(observedEvent)
+            }.on(observedEvent)
     }
 }

Sources/DataSources/SectionedViewType+BatchUpdate.swift

@@ -20,22 +20,22 @@ func indexSet(_ values: [Int]) -> IndexSet {
 func _performBatchUpdates<V: SectionedViewType, S: SectionModelType>(_ view: V, changes: Changeset<S>, animationConfiguration: AnimationConfiguration) {
     typealias I = S.Item
 
-    view.deleteSections(changes.deletedSections, animationStyle: .none)
+    view.deleteSections(changes.deletedSections, animationStyle: .fade)
     // Updated sections doesn't mean reload entire section, somebody needs to update the section view manually
     // otherwise all cells will be reloaded for nothing.
     //view.reloadSections(changes.updatedSections, animationStyle: rowAnimation)
-    view.insertSections(changes.insertedSections, animationStyle: .none)
+    view.insertSections(changes.insertedSections, animationStyle: .fade)
     for (from, to) in changes.movedSections {
         view.moveSection(from, to: to)
     }
 
     view.deleteItemsAtIndexPaths(
         changes.deletedItems.map { IndexPath(item: $0.itemIndex, section: $0.sectionIndex) },
-        animationStyle: .none
+        animationStyle: .fade
     )
     view.insertItemsAtIndexPaths(
         changes.insertedItems.map { IndexPath(item: $0.itemIndex, section: $0.sectionIndex) },
-        animationStyle: .none
+        animationStyle: .fade
     )
     view.reloadItemsAtIndexPaths(
         changes.updatedItems.map { IndexPath(item: $0.itemIndex, section: $0.sectionIndex) },