UIKit Catalog: Creating and customizing views and controls

At a glance

Project structure

Source bundle/
└── UIKitCatalog/
    ├── AlertControllerViewController.swift
    ├── AppDelegate.swift
    ├── MenuButtonViewController.swift
    ├── OutlineViewController.swift
    ├── PickerViewController.swift
    ├── PointerInteractionButtonViewController.swift
    ├── TextFieldViewController.swift
    ├── ActivityIndicatorViewController.swift
    ├── ButtonViewController.swift
    ├── ProgressViewController.swift
    ├── SegmentedControlViewController.swift
    └── SliderViewController.swift

Structure observations

• The outline hierarchy is the navigation registry; app/scene delegates only establish lifecycle and initial UI.
• Feature controllers remain independent examples instead of a single monolithic switch over every control.
• CaseElement preserves each target view type at construction, then erases it to a uniform UIView configuration closure for the base table.

Overall architecture

flowchart LR
    ITEMS["OutlineItem hierarchy"] --> OUTLINE["OutlineViewController"]
    OUTLINE --> SNAPSHOT["Diffable outline snapshot"]
    SNAPSHOT --> SELECT["Selected leaf storyboardName"]
    SELECT --> STORYBOARD["Feature storyboard controller"]
    STORYBOARD --> BASE["BaseTableViewController"]
    BASE --> CASES["CaseElement array"]
    CASES --> CONTROL["Typed UIKit control configuration"]

Reference code

UIKitCatalog/OutlineViewController.swift:303 — leaf-to-feature routing

    private func pushOrPresentStoryboard(storyboardName: String) {
        let exampleStoryboard = UIStoryboard(name: storyboardName, bundle: nil)
        if let exampleViewController = exampleStoryboard.instantiateInitialViewController() {
            pushOrPresentViewController(viewController: exampleViewController)
        }
    }

    func collectionView(_ collectionView: UICollectionView, didSelectItemAt indexPath: IndexPath) {
        guard let menuItem = dataSource.itemIdentifier(for: indexPath) else { return }
        if let storyboardName = menuItem.storyboardName {
            pushOrPresentStoryboard(storyboardName: storyboardName)
        }
    }

Interpretation

Navigation and control configuration are both data-driven, at different scales. The outline routes to a feature, while each table feature supplies small typed configuration cases to shared table plumbing. This keeps catalog mechanics reusable without abstracting the individual UIKit APIs away.

Ownership and state

classDiagram
    OutlineViewController *-- OutlineItemArray : menuItems
    OutlineItem *-- OutlineItemArray : subitems
    OutlineViewController *-- UICollectionView : creates
    OutlineViewController *-- DiffableDataSource : creates
    BaseTableViewController *-- CaseElementArray : testCells
    CaseElement *-- ConfigurationClosure : configHandler
    FeatureController --|> BaseTableViewController

Ownership evidence

UIKitCatalog/OutlineViewController.swift:185 — private navigation registry

    private lazy var menuItems: [OutlineItem] = {
        return [
            controlsOutlineItem,
            viewsOutlineItem,
            pickersOutlineItem
        ]
    }()

    private func configureCollectionView() {
        let collectionView = UICollectionView(
            frame: view.bounds, collectionViewLayout: generateLayout())
        self.outlineCollectionView = collectionView
    }

Composition denotes source-visible construction and retained value state. Aggregation denotes a stored or injected collaborator whose exclusive lifetime the source does not prove.

Class and protocol design

UIKitCatalog/CaseElement.swift:10 — generic-to-erased case configuration

struct CaseElement {
    typealias ConfigurationClosure = (UIView) -> Void
    var configHandler: ConfigurationClosure

    init<V: UIView>(title: String, cellID: String,
                    configHandler: @escaping (V) -> Void) {
        self.title = title
        self.cellID = cellID
        self.configHandler = { view in
            guard let view = view as? V else { fatalError("Impossible") }
            configHandler(view)
        }
    }
}

The catalog relies on UIKit data-source/delegate callbacks and inheritance. It defines no local protocol abstraction; variability is represented by route values, subclasses, and configuration closures.

Access control

Reference code

UIKitCatalog/OutlineViewController.swift:199 — private outline implementation helpers

    private func configureCollectionView() {
        let collectionView = UICollectionView(
            frame: view.bounds, collectionViewLayout: generateLayout())
        view.addSubview(collectionView)
        self.outlineCollectionView = collectionView
        collectionView.delegate = self
    }

    private func configureDataSource() {
        // Cell registrations and the diffable provider stay local.
    }

The shared base class leaves testCells internal because cross-file subclasses must set it. The outline’s registry and mechanics are private because they have no such collaborator. No public, open, or fileprivate API is present.

Logic ownership and placement

Design patterns

Naming conventions

• Feature types name the demonstrated UIKit API (ButtonViewController, SliderViewController, VisualEffectViewController).
• Shared types name their catalog role (OutlineItem, CaseElement, BaseTableViewController).
• Routing metadata uses storyboardName; commands use concrete navigation verbs (pushOrPresentStoryboard).
• Most files follow one primary feature-controller type, with button configurations split into a focused extension file.

Architecture takeaways

• Represent a large sample catalog as route data, not an app-delegate dependency graph.
• Use a base controller only for truly repeated table mechanics; leave API-specific setup in feature controllers.
• A generic initializer plus erased closure can store heterogeneous UIKit configurations without a protocol hierarchy.

Source map

• Official Apple documentation