Add FlatSection

Sources/Composed/Core/Section.swift

@@ -82,4 +82,9 @@ public protocol SectionUpdateDelegate: class {
     ///   - destinationIndex: The final index where the element will be moved to
     func section(_ section: Section, move sourceIndex: Int, to destinationIndex: Int)
 
+    /// Notifies the delegate that the section invalidated its header.
+    /// - Parameters:
+    ///   - section: The section where the move should be performed
+    func sectionDidInvalidateHeader(_ section: Section)
+
 }

Sources/Composed/Core/SectionProviderMapping.swift

@@ -82,6 +82,11 @@ public protocol SectionProviderMappingDelegate: class {
     ///   - destinationIndexPath: The final indexPath
     func mapping(_ mapping: SectionProviderMapping, move sourceIndexPath: IndexPath, to destinationIndexPath: IndexPath)
 
+    /// Notifies the delegate that the section invalidated its header.
+    /// - Parameters:
+    ///   - sectionIndex: The index of the section that invalidated its header.
+    func mappingDidInvalidateHeader(at sectionIndex: Int)
+
 }
 
 /// An object that encapsulates the logic required to map `SectionProvider`s to a global context,
@@ -229,6 +234,11 @@ public final class SectionProviderMapping: SectionProviderUpdateDelegate, Sectio
         delegate?.mapping(self, didMoveElementsAt: [(source, destination)])
     }
 
+    public func sectionDidInvalidateHeader(_ section: Section) {
+        guard let sectionOffset = self.sectionOffset(of: section) else { return }
+        delegate?.mappingDidInvalidateHeader(at: sectionOffset)
+    }
+
     // Rebuilds the cached providers to improve lookup performance.
     // This is generally only required when a sections are either inserted or removed, so it should be fairly efficient.
     private func rebuildSectionOffsets() {

Sources/Composed/Sections/FlatSection.swift

@@ -0,0 +1,176 @@
+/// A section that flattens each of its children in to a single section.
+open class FlatSection: Section, CustomReflectable {
+    open private(set) var children: [Section] = []
+
+    public var numberOfElements: Int {
+        children.map(\.numberOfElements).reduce(0, +)
+    }
+
+    public var updateDelegate: SectionUpdateDelegate?
+
+    public var customMirror: Mirror {
+        Mirror(
+            self,
+            children: [
+                "children": children,
+            ]
+        )
+    }
+
+    public init() {}
+
+    public func append(_ section: Section) {
+        updateDelegate?.willBeginUpdating(self)
+
+        let indexOfFirstChildElement = numberOfElements
+        children.append(section)
+        section.updateDelegate = self
+
+        (0..<section.numberOfElements)
+            .map { $0 + indexOfFirstChildElement }
+            .forEach { index in
+                updateDelegate?.section(self, didInsertElementAt: index)
+            }
+
+        updateDelegate?.didEndUpdating(self)
+    }
+
+    public func insert(_ section: Section, at index: Int) {
+        updateDelegate?.willBeginUpdating(self)
+
+        let sectionOffset = index > 0
+            ? offset(for: children[index - 1])!
+            : 0
+        children.insert(section, at: index)
+        section.updateDelegate = self
+
+        (0..<section.numberOfElements)
+            .map { $0 + sectionOffset }
+            .forEach { index in
+                updateDelegate?.section(self, didInsertElementAt: index)
+            }
+
+        updateDelegate?.didEndUpdating(self)
+    }
+
+    public func insert(_ section: Section, after existingSection: Section) {
+        guard let existingSectionIndex = children.firstIndex(where: { $0 === existingSection }) else { return }
+
+        insert(section, at: existingSectionIndex + 1)
+    }
+
+    public func remove(_ section: Section) {
+        guard let index = children.firstIndex(where: { $0 === section }) else { return }
+
+        updateDelegate?.willBeginUpdating(self)
+
+        let sectionOffset = offset(for: section)!
+        children.remove(at: index)
+        if section.updateDelegate === self {
+            section.updateDelegate = nil
+        }
+
+        (0..<section.numberOfElements).forEach { index in
+            updateDelegate?.section(self, didRemoveElementAt: index + sectionOffset)
+        }
+
+        updateDelegate?.didEndUpdating(self)
+    }
+
+    public func section(at index: Int) -> (section: Section, offset: Int)? {
+        var offset = 0
+
+        for child in children {
+            if offset == index {
+                return (child, offset)
+            } else if index < offset + child.numberOfElements {
+                return (child, offset)
+            }
+
+            offset += child.numberOfElements
+        }
+
+        return nil
+    }
+
+    private func offset(for section: Section) -> Int? {
+        var offset = 0
+
+        for child in children {
+            if child === section {
+                return offset
+            }
+
+            offset += child.numberOfElements
+        }
+
+        return nil
+    }
+
+    private func indexesRange(for section: Section) -> Range<Int>? {
+        guard let sectionOffset = offset(for: section) else { return nil }
+        return (sectionOffset..<sectionOffset + section.numberOfElements)
+    }
+}
+
+extension FlatSection: SectionUpdateDelegate {
+    public func willBeginUpdating(_ section: Section) {
+        updateDelegate?.willBeginUpdating(self)
+    }
+
+    public func didEndUpdating(_ section: Section) {
+        updateDelegate?.didEndUpdating(self)
+    }
+
+    public func invalidateAll(_ section: Section) {
+        updateDelegate?.invalidateAll(self)
+    }
+
+    public func section(_ section: Section, didInsertElementAt index: Int) {
+        guard let sectionOffset = offset(for: section) else { return }
+        updateDelegate?.section(self, didInsertElementAt: sectionOffset + index)
+    }
+
+    public func section(_ section: Section, didRemoveElementAt index: Int) {
+        guard let sectionOffset = offset(for: section) else { return }
+        updateDelegate?.section(self, didRemoveElementAt: sectionOffset + index)
+    }
+
+    public func section(_ section: Section, didUpdateElementAt index: Int) {
+        guard let sectionOffset = offset(for: section) else { return }
+        updateDelegate?.section(self, didUpdateElementAt: sectionOffset + index)
+    }
+
+    public func section(_ section: Section, didMoveElementAt index: Int, to newIndex: Int) {
+        guard let sectionOffset = offset(for: section) else { return }
+        updateDelegate?.section(self, didMoveElementAt: sectionOffset + index, to: newIndex + index)
+    }
+
+    public func selectedIndexes(in section: Section) -> [Int] {
+        guard let allSelectedIndexes = updateDelegate?.selectedIndexes(in: self) else { return [] }
+        guard let sectionIndexes = indexesRange(for: section) else { return [] }
+
+        return allSelectedIndexes
+            .filter(sectionIndexes.contains(_:))
+            .map { $0 - sectionIndexes.startIndex }
+    }
+
+    public func section(_ section: Section, select index: Int) {
+        guard let sectionOffset = offset(for: section) else { return }
+        updateDelegate?.section(self, select: sectionOffset + index)
+    }
+
+    public func section(_ section: Section, deselect index: Int) {
+        guard let sectionOffset = offset(for: section) else { return }
+        updateDelegate?.section(self, deselect: sectionOffset + index)
+    }
+
+    public func section(_ section: Section, move sourceIndex: Int, to destinationIndex: Int) {
+        guard let sectionOffset = offset(for: section) else { return }
+        updateDelegate?.section(self, move: sourceIndex + sectionOffset, to: destinationIndex + sectionOffset)
+    }
+
+    public func sectionDidInvalidateHeader(_ section: Section) {
+        // Headers of children are currently ignored.
+    }
+}

Sources/ComposedLayouts/CollectionCompositionalLayoutHandler.swift

@@ -3,7 +3,7 @@ import ComposedUI
 
 @available(iOS 13.0, *)
 /// Conform your section to this protocol to provide a layout section for a `UICollectionViewCompositionalLayout`
-public protocol CompositionalLayoutHandler: CollectionSectionProvider {
+public protocol CompositionalLayoutHandler: UICollectionViewSection {
 
     /// Return a layout section for this section
     /// - Parameter environment: The current environment for this layout

Sources/ComposedLayouts/CollectionFlowLayoutHandler.swift

@@ -31,7 +31,7 @@ public struct CollectionFlowLayoutEnvironment {
 }
 
 /// Conform your section to this protocol to override sizing and metric values for a `UICollectionViewFlowLayout`
-public protocol CollectionFlowLayoutHandler: CollectionSectionProvider {
+public protocol CollectionFlowLayoutHandler: UICollectionViewSection {
 
     /// Return the size for the element at the specified index
     /// - Parameters: