### Configure DiffableTableController

Source: https://context7.com/sparrowcode/diffablekit/llms.txt

Use DiffableTableController to simplify table view setup with automatic cell registration and declarative section definitions.

```swift
import UIKit
import DiffableKit

class SettingsController: DiffableTableController {

    override func viewDidLoad() {
        super.viewDidLoad()

        configureDiffable(
            sections: [
                DiffableSection(
                    id: "appearance",
                    header: DiffableTextHeaderFooter(text: "Appearance"),
                    items: [
                        DiffableTableRow(
                            text: "Theme",
                            detail: "System",
                            accessoryType: .disclosureIndicator,
                            action: { item, indexPath in
                                print("Selected theme at \(indexPath)")
                            }
                        ),
                        DiffableTableRowSwitch(
                            text: "Dark Mode",
                            icon: UIImage(systemName: "moon.fill"),
                            isOn: false,
                            action: { isOn in
                                print("Dark mode toggled: \(isOn)")
                            }
                        )
                    ]
                )
            ],
            cellProviders: DiffableTableDataSource.CellProvider.default
        )
    }
}
```

--------------------------------

### Setup and Data Configuration in DiffableTableController

Source: https://context7.com/sparrowcode/diffablekit/llms.txt

This snippet shows how to set up a DiffableTableController by configuring its data source with sections and items. It uses DiffableSection and DiffableTableRow to define the structure and content of the table view.

```swift
import UIKit
import DiffableKit

class ItemLookupController: DiffableTableController {

    override func viewDidLoad() {
        super.viewDidLoad()
        setupData()
    }

    func setupData() {
        configureDiffable(
            sections: [
                DiffableSection(
                    id: "section-1",
                    items: [
                        DiffableTableRow(id: "item-a", text: "Item A"),
                        DiffableTableRow(id: "item-b", text: "Item B")
                    ]
                ),
                DiffableSection(
                    id: "section-2",
                    items: [
                        DiffableTableRow(id: "item-c", text: "Item C")
                    ]
                )
            ],
            cellProviders: DiffableTableDataSource.CellProvider.default
        )
    }

    func demonstrateLookups() {
        // Get item by ID
        if let item = diffableDataSource?.getItem(id: "item-a") {
            print("Found item: \(item.id)")
        }

        // Get item by index path
        let indexPath = IndexPath(row: 0, section: 0)
        if let item = diffableDataSource?.getItem(indexPath: indexPath) {
            print("Item at \(indexPath): \(item.id)")
        }

        // Get section by ID
        if let section = diffableDataSource?.getSection(id: "section-1") {
            print("Section has \(section.items.count) items")
        }

        // Get section by index
        if let section = diffableDataSource?.getSection(index: 1) {
            print("Second section: \(section.id)")
        }

        // Get index path for item ID
        if let path = diffableDataSource?.getIndexPath(id: "item-c") {
            print("item-c is at section \(path.section), row \(path.row)")
        }

        // Get index path for item object
        let row = DiffableTableRow(id: "item-b", text: "Item B")
        if let path = diffableDataSource?.getIndexPath(item: row) {
            print("item-b path: \(path)")
        }
    }
}

```

--------------------------------

### Implement Custom Cell Provider

Source: https://context7.com/sparrowcode/diffablekit/llms.txt

Extend `DiffableTableDataSource.CellProvider` to create a custom provider for your item type. This example, `colorCell`, configures a `UITableViewCell` to display the `ColorItem`'s name and a color swatch.

```swift
// Custom cell provider
extension DiffableTableDataSource.CellProvider {

    static var colorCell: DiffableTableDataSource.CellProvider {
        return DiffableTableDataSource.CellProvider { tableView, indexPath, item in
            guard let colorItem = item as? ColorItem else { return nil }

            let cell = tableView.dequeueReusableCell(withIdentifier: "ColorCell", for: indexPath)
            var content = cell.defaultContentConfiguration()
            content.text = colorItem.name

            // Create color swatch
            let size = CGSize(width: 24, height: 24)
            UIGraphicsBeginImageContextWithOptions(size, false, 0)
            colorItem.color.setFill()
            UIBezierPath(roundedRect: CGRect(origin: .zero, size: size), cornerRadius: 4).fill()
            content.image = UIGraphicsGetImageFromCurrentImageContext()
            UIGraphicsEndImageContext()

            cell.contentConfiguration = content
            return cell
        }
    }
}
```

--------------------------------

### Create a Dynamic DiffableSection

Source: https://context7.com/sparrowcode/diffablekit/llms.txt

Dynamically create sections based on state. This example shows how to conditionally add items to a section, such as notification preferences.

```swift
import UIKit
import DiffableKit

// Section with dynamic items
func createNotificationsSection(enabled: Bool) -> DiffableSection {
    var items: [DiffableItem] = [
        DiffableTableRowSwitch(
            id: "notifications-toggle",
            text: "Enable Notifications",
            isOn: enabled,
            action: { isOn in
                // Handle toggle
            }
        )
    ]

    // Conditionally add items based on state
    if enabled {
        items.append(DiffableTableRow(
            text: "Sound",
            detail: "Default",
            accessoryType: .disclosureIndicator
        ))
        items.append(DiffableTableRow(
            text: "Badge",
            detail: "On",
            accessoryType: .disclosureIndicator
        ))
    }

    return DiffableSection(
        id: "notifications",
        header: DiffableTextHeaderFooter(text: "Notifications"),
        items: items
    )
}
```

--------------------------------

### Define Custom Item Type

Source: https://context7.com/sparrowcode/diffablekit/llms.txt

Create a custom item class that conforms to `DiffableItem` to represent your data. This example defines a `ColorItem` with color and name properties.

```swift
import UIKit
import DiffableKit

// Custom item type
class ColorItem: DiffableItem {
    let color: UIColor
    let name: String

    init(id: String, color: UIColor, name: String) {
        self.color = color
        self.name = name
        super.init(id: id)
    }
}
```

--------------------------------

### Integrate Custom Cell Provider in Controller

Source: https://context7.com/sparrowcode/diffablekit/llms.txt

In your `DiffableTableController`, register the cell identifier and combine your custom cell provider with default providers. This example shows how to configure the `ColorPaletteController` with `ColorItem`s and a default row.

```swift
// Usage
class ColorPaletteController: DiffableTableController {

    override func viewDidLoad() {
        super.viewDidLoad()

        tableView.register(UITableViewCell.self, forCellReuseIdentifier: "ColorCell")

        // Combine default providers with custom provider
        var providers = DiffableTableDataSource.CellProvider.default
        providers.insert(.colorCell, at: 0)

        configureDiffable(
            sections: [
                DiffableSection(
                    id: "colors",
                    header: DiffableTextHeaderFooter(text: "Colors"),
                    items: [
                        ColorItem(id: "red", color: .systemRed, name: "Red"),
                        ColorItem(id: "blue", color: .systemBlue, name: "Blue"),
                        ColorItem(id: "green", color: .systemGreen, name: "Green"),
                        DiffableTableRow(text: "Custom", accessoryType: .disclosureIndicator)
                    ]
                )
            ],
            cellProviders: providers
        )
    }
}
```

--------------------------------

### Implement DiffableCollectionSection in a Controller

Source: https://context7.com/sparrowcode/diffablekit/llms.txt

Demonstrates setting up a DiffableCollectionController with expandable sections and custom layout configurations.

```swift
import UIKit
import DiffableKit

class OutlineController: DiffableCollectionController {

    var expandedSections: Set<String> = ["section-1"]

    override func viewDidLoad() {
        super.viewDidLoad()

        collectionView.collectionViewLayout = createOutlineLayout()
        collectionView.register(UICollectionViewListCell.self, forCellWithReuseIdentifier: "Cell")

        let cellProvider = DiffableCollectionDataSource.CellProvider { collectionView, indexPath, item in
            let cell = collectionView.dequeueReusableCell(withReuseIdentifier: "Cell", for: indexPath) as! UICollectionViewListCell
            var content = cell.defaultContentConfiguration()
            content.text = item.id
            cell.contentConfiguration = content
            return cell
        }

        updateSections()

        configureDiffable(
            sections: createSections(),
            cellProviders: [cellProvider]
        )
    }

    func createSections() -> [DiffableSection] {
        return [
            DiffableCollectionSection(
                id: "section-1",
                header: DiffableTextHeaderFooter(text: "Favorites"),
                headerAsFirstCell: true,
                items: [
                    DiffableItem(id: "Item A"),
                    DiffableItem(id: "Item B")
                ],
                expanded: expandedSections.contains("section-1")
            ),
            DiffableCollectionSection(
                id: "section-2",
                header: DiffableTextHeaderFooter(text: "Recent"),
                headerAsFirstCell: true,
                items: [
                    DiffableItem(id: "Item C"),
                    DiffableItem(id: "Item D")
                ],
                expanded: expandedSections.contains("section-2")
            )
        ]
    }

    func toggleSection(_ sectionId: String) {
        if expandedSections.contains(sectionId) {
            expandedSections.remove(sectionId)
        } else {
            expandedSections.insert(sectionId)
        }
        diffableDataSource?.set(createSections(), animated: true)
    }

    func createOutlineLayout() -> UICollectionViewLayout {
        var config = UICollectionLayoutListConfiguration(appearance: .insetGrouped)
        config.headerMode = .none
        return UICollectionViewCompositionalLayout.list(using: config)
    }

    func updateSections() {
        // Refresh sections based on expanded state
    }
}
```

--------------------------------

### Create DiffableTableRowSwitch for Settings

Source: https://context7.com/sparrowcode/diffablekit/llms.txt

Implement toggle switches for settings using DiffableTableRowSwitch. This model includes an `isOn` state and an action closure to handle changes.

```swift
import UIKit
import DiffableKit

class NotificationSettings {
    var pushEnabled = true
    var soundEnabled = true
    var badgeEnabled = false

    func createSwitchRows() -> [DiffableItem] {
        return [
            DiffableTableRowSwitch(
                id: "push-notifications",
                text: "Push Notifications",
                icon: UIImage(systemName: "bell.fill"),
                isOn: pushEnabled,
                action: { [weak self] isOn in
                    self?.pushEnabled = isOn
                    self?.saveSettings()
                }
            ),
            DiffableTableRowSwitch(
                id: "sound",
                text: "Sound",
                icon: UIImage(systemName: "speaker.wave.2.fill"),
                isOn: soundEnabled,
                action: { [weak self] isOn in
                    self?.soundEnabled = isOn
                }
            ),
            DiffableTableRowSwitch(
                id: "badge",
                text: "Badge",
                icon: UIImage(systemName: "app.badge.fill"),
                isOn: badgeEnabled,
                action: { [weak self] isOn in
                    self?.badgeEnabled = isOn
                }
            )
        ]
    }

    func saveSettings() {
        // Persist settings
    }
}
```

--------------------------------

### Configure a Settings Controller with DiffableKit

Source: https://github.com/sparrowcode/diffablekit/blob/main/README.md

Use DiffableTableController to define sections and rows declaratively. The cellProviders parameter handles the default cell configuration.

```swift
class SettingsController: DiffableTableController {

    override func viewDidLoad() {
        super.viewDidLoad()
        configureDiffable(
            sections: [
                DiffableSection(
                    id: "general",
                    header: DiffableTextHeaderFooter(text: "General"),
                    items: [
                        DiffableTableRow(text: "Theme", detail: "System", accessoryType: .disclosureIndicator)
                    ]
                )
            ],
            cellProviders: DiffableTableDataSource.CellProvider.default
        )
    }
}
```

--------------------------------

### Configure Diffable Collection View with Custom Layout

Source: https://context7.com/sparrowcode/diffablekit/llms.txt

This snippet demonstrates how to subclass DiffableCollectionController to configure a collection view with a custom compositional layout and a diffable data source. It includes setting up the layout, registering cells, and providing a custom cell provider for displaying items.

```swift
import UIKit
import DiffableKit

class GalleryController: DiffableCollectionController {

    override func viewDidLoad() {
        super.viewDidLoad()

        // Configure collection view layout
        collectionView.collectionViewLayout = createLayout()
        collectionView.register(UICollectionViewCell.self, forCellWithReuseIdentifier: "ImageCell")

        // Custom cell provider
        let imageProvider = DiffableCollectionDataSource.CellProvider { collectionView, indexPath, item in
            guard let wrapper = item as? DiffableWrapperItem,
                  let imageName = wrapper.model as? String else { return nil }

            let cell = collectionView.dequeueReusableCell(withReuseIdentifier: "ImageCell", for: indexPath)
            cell.contentView.backgroundColor = .systemGray5

            let imageView = UIImageView(image: UIImage(systemName: imageName))
            imageView.contentMode = .scaleAspectFit
            imageView.frame = cell.contentView.bounds
            imageView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
            cell.contentView.subviews.forEach { $0.removeFromSuperview() }
            cell.contentView.addSubview(imageView)

            return cell
        }

        configureDiffable(
            sections: [
                DiffableSection(id: "photos",
                                items: [
                                    DiffableWrapperItem(id: "1", model: "photo"),
                                    DiffableWrapperItem(id: "2", model: "photo.fill"),
                                    DiffableWrapperItem(id: "3", model: "photo.circle")
                                ])
            ],
            cellProviders: [imageProvider])
    }

    func createLayout() -> UICollectionViewLayout {
        let itemSize = NSCollectionLayoutSize(widthDimension: .fractionalWidth(0.33), heightDimension: .fractionalHeight(1.0))
        let item = NSCollectionLayoutItem(layoutSize: itemSize)
        item.contentInsets = NSDirectionalEdgeInsets(top: 4, leading: 4, bottom: 4, trailing: 4)

        let groupSize = NSCollectionLayoutSize(widthDimension: .fractionalWidth(1.0), heightDimension: .fractionalWidth(0.33))
        let group = NSCollectionLayoutGroup.horizontal(layoutSize: groupSize, subitems: [item])

        let section = NSCollectionLayoutSection(group: group)
        return UICollectionViewCompositionalLayout(section: section)
    }
}

```

--------------------------------

### Use DiffableWrapperItem for Custom Models

Source: https://context7.com/sparrowcode/diffablekit/llms.txt

Wraps custom model objects to be compatible with the diffable data source.

```swift
import UIKit
import DiffableKit

struct Product {
    let sku: String
    let name: String
    let price: Double
}

class ProductListController: DiffableTableController {

    let products = [
        Product(sku: "ABC123", name: "Widget", price: 9.99),
        Product(sku: "DEF456", name: "Gadget", price: 19.99)
    ]

    override func viewDidLoad() {
        super.viewDidLoad()

        // Custom cell provider for Product model
        let productProvider = DiffableTableDataSource.CellProvider { tableView, indexPath, item in
            guard let wrapper = item as? DiffableWrapperItem,
                  let product = wrapper.model as? Product else { return nil }

            let cell = tableView.dequeueReusableCell(withIdentifier: "ProductCell", for: indexPath)
            var content = cell.defaultContentConfiguration()
            content.text = product.name
            content.secondaryText = String(format: "$%.2f", product.price)
            cell.contentConfiguration = content
            return cell
        }

        tableView.register(UITableViewCell.self, forCellReuseIdentifier: "ProductCell")

        configureDiffable(
            sections: [
                DiffableSection(
                    id: "products",
                    items: products.map { product in
                        DiffableWrapperItem(
                            id: product.sku,
                            model: product,
                            action: { item, indexPath in
                                print("Selected product: \(product.name)")
                            }
                        )
                    }
                )
            ],
            cellProviders: [productProvider]
        )
    }
}
```

--------------------------------

### Create a Basic DiffableTableRow

Source: https://context7.com/sparrowcode/diffablekit/llms.txt

Define a standard table row with text, detail text, an icon, and an accessory type. Actions can be provided for row taps.

```swift
import UIKit
import DiffableKit

// Basic row with disclosure indicator
let profileRow = DiffableTableRow(
    text: "Profile",
    detail: "John Doe",
    icon: UIImage(systemName: "person.circle"),
    accessoryType: .disclosureIndicator,
    action: { item, indexPath in
        // Navigate to profile screen
    }
)
```

--------------------------------

### Display Subtitle Information with DiffableTableRowSubtitle

Source: https://context7.com/sparrowcode/diffablekit/llms.txt

Implement `DiffableTableRowSubtitle` to display a main text label and a secondary subtitle below it, suitable for contact lists or detailed item displays. An optional icon and accessory type can be configured.

```swift
import UIKit
import DiffableKit

struct Contact {
    let name: String
    let email: String
    let avatarName: String
}

class ContactsController: DiffableTableController {

    let contacts = [
        Contact(name: "Alice Smith", email: "alice@example.com", avatarName: "person.circle"),
        Contact(name: "Bob Johnson", email: "bob@example.com", avatarName: "person.circle.fill")
    ]

    override func viewDidLoad() {
        super.viewDidLoad() 

        configureDiffable(
            sections: [
                DiffableSection(
                    id: "contacts",
                    header: DiffableTextHeaderFooter(text: "Contacts"),
                    items: contacts.map { contact in
                        DiffableTableRowSubtitle(
                            id: contact.email,
                            text: contact.name,
                            subtitle: contact.email,
                            icon: UIImage(systemName: contact.avatarName),
                            accessoryType: .disclosureIndicator,
                            action: { item, indexPath in
                                print("Selected: \(contact.name)")
                            }
                        )
                    }
                )
            ],
            cellProviders: DiffableTableDataSource.CellProvider.default
        )
    }
}
```

--------------------------------

### Implement DiffableTableDelegate for Table Interactions

Source: https://context7.com/sparrowcode/diffablekit/llms.txt

Handles selection, swipe actions, and context menus within a DiffableTableController.

```swift
import UIKit
import DiffableKit

class TaskListController: DiffableTableController, DiffableTableDelegate {

    override func viewDidLoad() {
        super.viewDidLoad()
        diffableDataSource?.diffableDelegate = self
        loadTasks()
    }

    func loadTasks() {
        configureDiffable(
            sections: [
                DiffableSection(
                    id: "tasks",
                    items: [
                        DiffableTableRow(id: "task-1", text: "Complete report"),
                        DiffableTableRow(id: "task-2", text: "Review PR"),
                        DiffableTableRow(id: "task-3", text: "Update docs")
                    ]
                )
            ],
            cellProviders: DiffableTableDataSource.CellProvider.default
        )
    }

    // MARK: - DiffableTableDelegate

    func diffableTableView(_ tableView: UITableView, didSelectItem item: DiffableItem, indexPath: IndexPath) {
        tableView.deselectRow(at: indexPath, animated: true)
        print("Selected item: \(item.id)")
    }

    func diffableTableView(_ tableView: UITableView, trailingSwipeActionsConfigurationForItem item: DiffableItem, at indexPath: IndexPath) -> UISwipeActionsConfiguration? {
        let deleteAction = UIContextualAction(style: .destructive, title: "Delete") { [weak self] _, _, completion in
            self?.deleteTask(id: item.id)
            completion(true)
        }
        return UISwipeActionsConfiguration(actions: [deleteAction])
    }

    func diffableTableView(_ tableView: UITableView, contextMenuConfigurationForItem item: DiffableItem, at indexPath: IndexPath, point: CGPoint) -> UIContextMenuConfiguration? {
        return UIContextMenuConfiguration(identifier: nil, previewProvider: nil) { _ in
            let editAction = UIAction(title: "Edit", image: UIImage(systemName: "pencil")) { _ in
                print("Edit \(item.id)")
            }
            let shareAction = UIAction(title: "Share", image: UIImage(systemName: "square.and.arrow.up")) { _ in
                print("Share \(item.id)")
            }
            return UIMenu(children: [editAction, shareAction])
        }
    }

    func deleteTask(id: String) {
        // Remove task and update UI
    }
}
```

--------------------------------

### Create Tappable Buttons with DiffableTableRowButton

Source: https://context7.com/sparrowcode/diffablekit/llms.txt

Utilize `DiffableTableRowButton` for rows that act as tappable buttons. Each button can have text, an icon, and an optional detail text. The `action` closure is executed when the button is tapped.

```swift
import UIKit
import DiffableKit

class AccountController: DiffableTableController {

    override func viewDidLoad() {
        super.viewDidLoad() 

        configureDiffable(
            sections: [
                DiffableSection(
                    id: "actions",
                    items: [
                        DiffableTableRowButton(
                            id: "sign-out",
                            text: "Sign Out",
                            icon: UIImage(systemName: "rectangle.portrait.and.arrow.right"),
                            action: { [weak self] indexPath in
                                self?.showSignOutConfirmation()
                            }
                        ),
                        DiffableTableRowButton(
                            id: "delete-account",
                            text: "Delete Account",
                            detail: "This action cannot be undone",
                            icon: UIImage(systemName: "trash.fill"),
                            action: { [weak self] indexPath in
                                self?.showDeleteConfirmation()
                            }
                        )
                    ]
                )
            ],
            cellProviders: DiffableTableDataSource.CellProvider.default
        )
    }

    func showSignOutConfirmation() {
        // Present confirmation alert
    }

    func showDeleteConfirmation() {
        // Present destructive confirmation
    }
}
```

--------------------------------

### Manage Data with DiffableTableDataSource

Source: https://context7.com/sparrowcode/diffablekit/llms.txt

Use DiffableTableDataSource to manually manage snapshots, cell providers, and perform animated updates or reconfigurations.

```swift
import UIKit
import DiffableKit

class CustomTableViewController: UITableViewController {

    var dataSource: DiffableTableDataSource?

    override func viewDidLoad() {
        super.viewDidLoad()

        // Register cells
        tableView.register(DiffableTableViewCell.self, forCellReuseIdentifier: DiffableTableViewCell.reuseIdentifier)
        tableView.register(DiffableSubtitleTableViewCell.self, forCellReuseIdentifier: DiffableSubtitleTableViewCell.reuseIdentifier)
        tableView.register(DiffableButtonTableViewCell.self, forCellReuseIdentifier: DiffableButtonTableViewCell.reuseIdentifier)

        // Initialize data source with cell providers
        dataSource = DiffableTableDataSource(
            tableView: tableView,
            cellProviders: DiffableTableDataSource.CellProvider.default,
            headerFooterProviders: []
        )

        // Apply initial data
        dataSource?.set([
            DiffableSection(
                id: "main",
                items: [
                    DiffableTableRow(text: "Item 1", detail: "Detail 1"),
                    DiffableTableRow(text: "Item 2", detail: "Detail 2")
                ]
            )
        ], animated: false)
    }

    func updateContent() {
        // Calling set() automatically diffs and animates changes
        dataSource?.set([
            DiffableSection(
                id: "main",
                items: [
                    DiffableTableRow(text: "Item 1", detail: "Updated Detail"),
                    DiffableTableRow(text: "Item 3", detail: "New Item")
                ]
            )
        ], animated: true) {
            print("Animation completed")
        }
    }

    func reconfigureWithoutAnimation() {
        // Update cell contents without structural changes
        let updatedItem = DiffableTableRow(id: "Item 1", text: "Item 1", detail: "Reconfigured")
        dataSource?.reconfigure([updatedItem], animated: false)
    }
}
```

--------------------------------

### Implement Numeric Value Adjustment with DiffableTableRowStepper

Source: https://context7.com/sparrowcode/diffablekit/llms.txt

Use `DiffableTableRowStepper` to create a row with an integrated UIStepper for adjusting numeric values. The `action` closure is called with the new value when the stepper changes.

```swift
import UIKit
import DiffableKit

class QuantityController: DiffableTableController {

    var quantity: Double = 1

    override func viewDidLoad() {
        super.viewDidLoad() 
        updateUI()
    }

    func updateUI() {
        configureDiffable(
            sections: [
                DiffableSection(
                    id: "quantity",
                    header: DiffableTextHeaderFooter(text: "Quantity"),
                    items: [
                        DiffableTableRowStepper(
                            id: "item-quantity",
                            text: "Items: \(Int(quantity))",
                            icon: UIImage(systemName: "cart.fill"),
                            stepValue: 1,
                            value: quantity,
                            minimumValue: 1,
                            maximumValue: 99,
                            action: { [weak self] newValue in
                                self?.quantity = newValue
                                self?.updateUI()
                            }
                        )
                    ]
                )
            ],
            cellProviders: DiffableTableDataSource.CellProvider.default
        )
    }
}
```

--------------------------------

### Create a Basic DiffableSection

Source: https://context7.com/sparrowcode/diffablekit/llms.txt

Use DiffableSection to group items with optional header and footer views. This is useful for organizing content within a table view.

```swift
import UIKit
import DiffableKit

// Basic section with header and items
let generalSection = DiffableSection(
    id: "general",
    header: DiffableTextHeaderFooter(text: "General"),
    footer: DiffableTextHeaderFooter(text: "Configure general app settings"),
    items: [
        DiffableTableRow(text: "Language", detail: "English"),
        DiffableTableRow(text: "Region", detail: "United States")
    ]
)
```

--------------------------------

### Create a Non-Interactive DiffableTableRow

Source: https://context7.com/sparrowcode/diffablekit/llms.txt

Create a row that is not selectable by setting its selection style to .none. This is suitable for displaying static information.

```swift
import UIKit
import DiffableKit

// Row without action (non-interactive display)
let versionRow = DiffableTableRow(
    id: "version",
    text: "Version",
    detail: "1.0.0",
    selectionStyle: .none
)
```

--------------------------------

### Create a DiffableTableRow with Custom ID

Source: https://context7.com/sparrowcode/diffablekit/llms.txt

Assign a unique ID to a row for easier identification and retrieval. This is useful when you need to reference specific rows programmatically.

```swift
import UIKit
import DiffableKit

// Row with custom ID for lookup
let accountRow = DiffableTableRow(
    id: "account-settings",
    text: "Account",
    detail: "user@example.com",
    icon: UIImage(systemName: "gear"),
    accessoryType: .disclosureIndicator,
    selectionStyle: .default,
    action: { item, indexPath in
        print("Account tapped")
    }
)
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.