# What Is SectionKit? A Swift Framework for Data-Driven Collection Views

> Explore SectionKit, a Swift framework simplifying UICollectionView with reusable sections. Build type-safe lists easily and eliminate monolithic data sources.

- Repository: [神奇/sectionkit](https://github.com/linhay/sectionkit)
- Tags: getting-started
- Published: 2026-03-06

---

**SectionKit is a Swift framework that abstracts `UICollectionView` into reusable, composable sections, eliminating monolithic data sources through a mediator-based architecture that enables declarative, type-safe list construction.**

SectionKit, housed in the [linhay/sectionkit](https://github.com/linhay/sectionkit) repository, reimagines iOS collection view development by isolating UI concerns into self-contained "sections" rather than cramming logic into massive view controllers. Each section encapsulates its own model binding, cell registration, layout logic, and interaction handling, while a central manager coordinates everything behind the scenes.

## Core Architecture of SectionKit

The framework rests on a protocol-oriented design that prioritizes composition over inheritance, allowing developers to build heterogeneous lists by combining independent sections.

### The Mediator Pattern: SKCManager

At the heart of SectionKit sits **`SKCManager`**, a mediator that installs itself as the `UICollectionView` delegate and data source. Rather than forwarding events to a monolithic controller, `SKCManager` routes each delegate call to the appropriate section based on the global index path. This implementation in [`Sources/SectionKit/CollectionBase/SKCManager.swift`](https://github.com/linhay/sectionkit/blob/main/Sources/SectionKit/CollectionBase/SKCManager.swift) handles `dataSourceForward`, `flowLayoutForward`, and `prefetchForward` calls, ensuring sections remain unaware of their position in the larger collection.

### Section Protocol Hierarchy

Sections conform to a strict protocol hierarchy defined in [`Sources/SectionKit/CollectionBaseProtocol/SKCSectionProtocol.swift`](https://github.com/linhay/sectionkit/blob/main/Sources/SectionKit/CollectionBaseProtocol/SKCSectionProtocol.swift): **`SKCSectionProtocol`** → **`SKCAnySectionProtocol`** → **`SKCRawSectionProtocol`**. This type-erasure strategy allows `SKCManager` to store a heterogeneous array of sections while maintaining compile-time safety. The protocols define the contract for data source methods, layout configurations, action handling, and lifecycle callbacks.

### Concrete Implementation: SKCSingleTypeSection

For the common use case of homogeneous data arrays, **`SKCSingleTypeSection`** in [`Sources/SectionKit/CollectionSingleTypeSection/Entities/SKCSingleTypeSection.swift`](https://github.com/linhay/sectionkit/blob/main/Sources/SectionKit/CollectionSingleTypeSection/Entities/SKCSingleTypeSection.swift) provides a generic, chainable API. Generic over `Cell: UICollectionViewCell & SKConfigurableView & SKLoadViewProtocol`, this class offers fluent methods like `onCellAction(_:_:)`, `setHeader(_:model:)`, and `cellSafeSize` that eliminate boilerplate while preserving type safety.

## SectionUI: The Presentation Layer

**SectionUI** provides the visual integration layer, wrapping raw sections into usable interface components. Located under `Sources/SectionUI`, this layer includes **`SKWrapperCell`** and **`SKCWrapperReusableView`** helpers, plus ready-made subclasses like **`SKCollectionViewController`** that expose the manager via a `manager` property.

### Composable Layout Plugins

Instead of subclassing `UICollectionViewFlowLayout`, SectionKit uses a plugin-based architecture found in [`Sources/SectionUI/CollectionView/SectionCollectionView/FlowLayout/SKCLayoutPlugins.swift`](https://github.com/linhay/sectionkit/blob/main/Sources/SectionUI/CollectionView/SectionCollectionView/FlowLayout/SKCLayoutPlugins.swift). These composable objects attach to the manager to provide sticky headers, section backgrounds, alignment adjustments, and waterfall layouts. You mix and match behaviors—such as pinning headers with specific padding or adding decorative views—without touching layout delegate methods.

## Building a SectionKit Interface: Practical Examples

### Defining a Configurable Cell

Cells implement **`SKLoadViewProtocol`** (for automatic registration) and **`SKConfigurableView`** (for model binding):

```swift
class ItemCell: UICollectionViewCell,
                SKLoadViewProtocol,
                SKConfigurableView {
    struct Model {
        let title: String
        let subtitle: String
    }

    static func preferredSize(limit size: CGSize, model: Model?) -> CGSize {
        CGSize(width: size.width, height: 60)
    }

    func config(_ model: Model) {
        textLabel.text = model.title
        detailLabel.text = model.subtitle
    }

    private lazy var textLabel = UILabel()
    private lazy var detailLabel = UILabel()
}

```

### Binding Data and Handling Interactions

In a `SKCollectionViewController` subclass, you configure sections using a fluent API:

```swift
class MyViewController: SKCollectionViewController {

    private lazy var section = ItemCell.wrapperToSingleTypeSection()

    override func viewDidLoad() {
        super.viewDidLoad()

        // Configure actions
        section.onCellAction(.selected) { [weak self] context in
            print("Selected: \(context.model.title)")
        }

        // Provide models
        section.config(models: [
            .init(title: "Item 1", subtitle: "First"),
            .init(title: "Item 2", subtitle: "Second")
        ])

        // Display via the manager
        manager.reload(section)
    }
}

```

### Adding Headers and Layout Plugins

Method chaining extends section capabilities without subclassing:

```swift
section
    .setHeader(MyHeaderView.self, model: "Section Title")
    .setDecoration(BackgroundView.self) { ctx in
        ctx.view.backgroundColor = .systemGroupedBackground
        ctx.view.layer.cornerRadius = 12
    }
    .pinHeader { opts in
        opts.padding = 16
    }

```

### Reactive Programming with Combine

SectionKit integrates with Combine for automatic updates:

```swift
class ViewModel {
    @SKPublished var items: [ItemCell.Model] = []
}

let viewModel = ViewModel()
section.subscribe(models: viewModel.$items.eraseToAnyPublisher())

```

The `@SKPublished` property wrapper emits publishers that the section observes, triggering diff-based reloads automatically.

## Summary

- **SectionKit** abstracts `UICollectionView` into independent, reusable sections managed by `SKCManager`.
- The **mediator pattern** in [`SKCManager.swift`](https://github.com/linhay/sectionkit/blob/main/SKCManager.swift) eliminates massive view controllers by routing delegate calls to specific sections.
- **Type-safe protocols** (`SKCSectionProtocol` hierarchy) allow heterogeneous collections while maintaining compile-time checking.
- **SKCSingleTypeSection** provides a generic, chainable API for the common single-cell-type use case.
- **SectionUI** offers ready-made view controllers and a plugin-based layout system for sticky headers, decorations, and complex grids without subclassing `UICollectionViewFlowLayout`.
- **Combine integration** enables reactive data binding with automatic diff-based animations.

## Frequently Asked Questions

### What is the difference between SectionKit and SectionUI?

**SectionKit** contains the core framework logic—the `SKCManager` mediator, section protocols, and `SKCSingleTypeSection` implementation—while **SectionUI** provides the visual layer including `SKCollectionViewController`, wrapper views, and layout plugins. You can use SectionKit's data architecture independently, but SectionUI simplifies integrating it into view controllers.

### How does SectionKit handle heterogeneous collection views?

SectionKit manages heterogeneity through **type erasure**. While each `SKCSingleTypeSection` is generic over a specific cell type, they all conform to `SKCSectionProtocol`, allowing `SKCManager` to store them in a homogeneous array. The manager calculates global index paths and routes delegate methods to the correct section instance automatically.

### What layout features does SectionKit support beyond standard flow layout?

Through the plugin system in [`SKCLayoutPlugins.swift`](https://github.com/linhay/sectionkit/blob/main/SKCLayoutPlugins.swift), SectionKit supports **sticky section headers** with customizable pinning insets, **decoration views** for backgrounds and borders, **alignment plugins** for grid layouts, and **waterfall-style** arrangements. These compose together without subclassing `UICollectionViewFlowLayout`, allowing you to mix layout behaviors across different sections.

### Can SectionKit improve collection view performance?

Yes. SectionKit includes **SKHighPerformanceStore** for caching cell sizes and reducing layout calculations, plus automatic **diff-based reloading** that computes minimal update sets. The `prefetchForward` system in `SKCManager` coordinates data prefetching across sections, ensuring smooth scrolling even with complex, heterogeneous content.