Only reconfigure visible supplementary views when applying snapshots

Similar to e2a1478bb3f4ac4dae26f422dc9c62185b48018c.

optimize the headers, footers, and other supplementary views that we reconfigure.

previously, we already had a lot of escape hatches where we could short circuit this loop through all the sections and all their views.

this adds another early return by only checking the sections that are visible. if a section is not visible, we can skip it.

when a previously not visible section scrolls on screen, it will go through the whole dequeue + configure flow for all its cells and views. so this should be safe to do.

**visibility notes**

determining section visibility is a bit of a "hack" -- there's no direct API for this, so instead we need to check for supplementary views that are visible via `indexPathsForVisibleSupplementaryElements`. from there we can derive the visible section indexes, and then resolve their identifiers.

all of that is necessary because we cannot query supplementary views directly like we can for items. `DiffableDataSource` provides `self.itemIdentifier(for: indexPath)` but there is no equivalent for supplementary views.

it's all a bit roundabout, but it works.

Author: jessesquires

Sources/CollectionViewModel.swift

@@ -194,6 +194,22 @@ public struct CollectionViewModel: Hashable, DiffableViewModel {
         let tuples = allCells.map { ($0.id, $0) }
         return Dictionary(uniqueKeysWithValues: tuples)
     }
+
+    func allSupplementaryViewKinds() -> Set<String> {
+        var allKinds = Set<String>()
+        self.sections.forEach {
+            if let header = $0.header {
+                allKinds.insert(header.registration.viewType.kind)
+            }
+            if let footer = $0.footer {
+                allKinds.insert(footer.registration.viewType.kind)
+            }
+            $0.supplementaryViews.forEach {
+                allKinds.insert($0.registration.viewType.kind)
+            }
+        }
+        return allKinds
+    }
 }
 
 // MARK: Collection, RandomAccessCollection

Sources/DiffableDataSource.swift

@@ -180,9 +180,16 @@ final class DiffableDataSource: UICollectionViewDiffableDataSource<AnyHashable,
     ) {
         let allSourceSections = source.allSectionsByIdentifier()
 
+        let visibleSectionIds = self._visibleSectionIdentifiersFrom(destination: destination)
+
         for sectionIndex in 0..<destination.sections.count {
             let destinationSection = destination.sections[sectionIndex]
 
+            // If this section is not visible, skip it.
+            guard visibleSectionIds.contains(destinationSection.id) else {
+                continue
+            }
+
             // If this section does not have any supplementary views, skip it.
             guard destinationSection.hasSupplementaryViews else {
                 continue
@@ -243,6 +250,27 @@ final class DiffableDataSource: UICollectionViewDiffableDataSource<AnyHashable,
         }
     }
 
+    private func _visibleSectionIdentifiersFrom(destination: CollectionViewModel) -> Set<UniqueIdentifier> {
+        // Using supplementary views as a proxy for the sections that are visible.
+        // Limitations in the APIs require this.
+        // Unfortunately, we cannot do the same thing as `_visibleItemIdentifiers()` above,
+        // because we cannot query directly for supplementary view items.
+        let allKinds = destination.allSupplementaryViewKinds()
+        let visibleIndexPaths = allKinds.flatMap {
+            self._collectionView.indexPathsForVisibleSupplementaryElements(ofKind: $0)
+        }
+        let visibleSections = visibleIndexPaths.map { $0.section }
+
+        // These are the current, existing (that is, "source") section identifiers.
+        let visibleSourceSectionIdentifiers = visibleSections.compactMap { self.sectionIdentifier(for: $0) }
+
+        // This is ok, because in terms of needing to "reload" supplementary views,
+        // we only need to know what remained visible from the source snapshot.
+        // Anything that has been newly inserted (from the "destination") will
+        // be getting configured for the first time.
+        return Set(visibleSourceSectionIdentifiers)
+    }
+
     private func _reconfigureSupplementaryView(model: AnySupplementaryViewModel, item: Int, section: Int) {
         let indexPath = IndexPath(item: item, section: section)
         if let view = self._collectionView.supplementaryView(forElementKind: model._kind, at: indexPath) {