### Combine Extensions: Weak References and Async/Await

Source: https://context7.com/pffan91/appextensions/llms.txt

Demonstrates using Combine framework utilities for managing weak references to avoid retain cycles and integrating async/await with publishers. It includes examples for binding UI elements and converting publisher streams to async functions.

```swift
import Combine
import AppExtensions

class ProfileViewModel {
    @Published var username: String = ""
    @Published var avatarURL: String = ""

    private var cancellables: Cancellables = []  // Typealias for Set<AnyCancellable>

    func bind(to view: ProfileView) {
        // Avoid retain cycles with weak reference assignment
        $username
            .assign(to: \.text, onWeak: view.nameLabel)
            .store(in: &cancellables)

        $avatarURL
            .compactMap { URL(string: $0) }
            .sink { [weak view] url in
                view?.loadAvatar(from: url)
            }
            .store(in: &cancellables)
    }
}

// Convert publisher to async/await
class UserService {
    func fetchUser(id: Int) -> AnyPublisher<User, Error> {
        URLSession.shared
            .dataTaskPublisher(for: URL(string: "https://api.example.com/users/\(id)")!)
            .map(\.data)
            .decode(type: User.self, decoder: JSONDecoder())
            .eraseToAnyPublisher()
    }

    func getUser(id: Int) async throws -> User {
        let publisher = fetchUser(id: id)
        return try await publisher.async()
    }
}

// Usage in async context
Task {
    do {
        let user = try await userService.getUser(id: 123)
        print("Fetched user: \(user.name)")
    } catch {
        print("Error: \(error)")
    }
}
```

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

### UIWindow Extensions: Animated Root View Controller Transitions

Source: https://context7.com/pffan91/appextensions/llms.txt

Offers extensions for UIWindow to perform animated root view controller transitions with customizable effects such as direction, duration, style, and background. It includes examples for simple fades, custom color backgrounds, and image-based backgrounds.

```swift
import UIKit
import AppExtensions

// Simple fade transition
window.setRootViewController(newViewController)

// Custom transition options
var options = UIWindow.TransitionOptions()
options.direction = .toLeft
options.duration = 0.4
options.style = .easeInOut

window.setRootViewController(mainViewController, options: options)

// Advanced transition with background
var slideOptions = UIWindow.TransitionOptions()
slideOptions.direction = .toTop
slideOptions.duration = 0.5
slideOptions.style = .linear
slideOptions.background = .solidColor(.black)

window.setRootViewController(onboardingVC, options: slideOptions)

// Transition with custom background view
let backgroundView = UIImageView(image: UIImage(named: "splash"))
backgroundView.contentMode = .scaleAspectFill

var customOptions = UIWindow.TransitionOptions()
customOptions.direction = .fade
customOptions.background = .customView(backgroundView)

window.setRootViewController(homeVC, options: customOptions)

// Practical usage for app state transitions
func logout() {
    let loginVC = LoginViewController()

    var options = UIWindow.TransitionOptions()
    options.direction = .toBottom
    options.duration = 0.3

    UIApplication.shared.currentWindow?.setRootViewController(loginVC, options: options)
}
```

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

### Bundle Extensions: App Version and Build Number Access

Source: https://context7.com/pffan91/appextensions/llms.txt

Demonstrates extensions for Foundation.Bundle to easily access the app's version number and build number. Includes practical examples for displaying this information in UI elements and using it for version comparison or in API headers.

```swift
import Foundation
import AppExtensions

// Get app version
let version = Bundle.main.versionNumber  // "1.0.2"

// Get build number
let build = Bundle.main.buildNumber  // "68"

// Display in settings or about screen
aboutLabel.text = "Version \(Bundle.main.versionNumber) (\(Bundle.main.buildNumber))"

// Version comparison for feature flags
if let version = Bundle.main.versionNumber,
   version.compare("2.0.0", options: .numeric) == .orderedDescending {
    enableNewFeatures()
}

// Include in API requests
struct APIClient {
    var headers: [String: String] {
        [
            "X-App-Version": Bundle.main.versionNumber ?? "unknown",
            "X-Build-Number": Bundle.main.buildNumber ?? "unknown"
        ]
    }
}
```

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

### UIViewController Extensions: Navigation and Presentation Helpers

Source: https://context7.com/pffan91/appextensions/llms.txt

Offers extensions for UIViewController to simplify navigation and presentation tasks. Includes helpers for getting the current visible view controller, finding the topmost view controller in a hierarchy, changing the root view controller with animation, dismissing entire modal stacks, hiding the keyboard on tap, adding child view controllers, re-enabling swipe-to-back gestures, and calculating SwiftUI view heights for UIKit integration.

```swift
import UIKit
import AppExtensions

// Get current visible view controller
if let currentVC = UIViewController.current {
    currentVC.present(alertController, animated: true)
}

// Find topmost view controller in hierarchy
let topVC = navigationController.topmostViewController

// Change root view controller with animation
view.window?.changeRootViewController(with: newViewController, animated: true)

// Dismiss entire modal stack
viewController.dismissAllViewControllers(animated: true) {
    print("All modals dismissed")
}

// Dismiss keyboard on tap
override func viewDidLoad() {
    super.viewDidLoad()
    hideKeyboardOnTapInside()
}

// Add child view controller
let childVC = MapViewController()
addChild(viewController: childVC)
view.addSubview(childVC.view)
childVC.view.constrainToSides()

// Re-enable swipe-to-back after custom back button
navigationController?.enableSwipeToBack()

// Calculate SwiftUI view height for UIKit integration
let swiftUIView = MySwiftUIView()
let height = calculateHeight(for: swiftUIView, width: view.bounds.width)
```

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

### Array Extensions: Safe Access and Identifiable Operations

Source: https://context7.com/pffan91/appextensions/llms.txt

Provides extensions for Swift arrays to enable safe subscripting, preventing crashes when accessing out-of-bounds indices. It also includes utilities for moving elements within an array and performing operations on `Identifiable` arrays, such as accessing, modifying, checking for existence, getting the index of, and sorting `UIView` arrays by position.

```swift
import Foundation
import AppExtensions

// Safe subscripting (returns Optional)
let numbers = [1, 2, 3, 4, 5]
let safeValue = numbers[safe: 10]  // nil (no crash)
let validValue = numbers[safe: 2]  // Optional(3)

// Move elements
var items = ["A", "B", "C", "D"]
items.moveElement(at: 0, to: 3)  // ["B", "C", "D", "A"]

// Identifiable array operations
struct User: Identifiable {
    let id: UUID
    var name: String
}

var users: [User] = [...]

// Access by ID
if let user = users[id: someID] {
    print(user.name)
}

// Modify by ID
users[id: someID]?.name = "Updated Name"

// Check existence
let exists = users.contains(userToFind)

// Get index
if let index = users.index(of: userToFind) {
    users.remove(at: index)
}

// Sort UIView array by position
let sortedViews = viewArray.sortedArrayByPosition()
```

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

### Create URLs from Strings in Swift

Source: https://context7.com/pffan91/appextensions/llms.txt

Provides convenient initializers for creating URL objects from string literals. Supports creating URLs for web endpoints and local files. Requires the AppExtensions library.

```swift
import Foundation
import AppExtensions

// Create URL from string literal
let apiEndpoint: URL = "https://api.example.com/v1/users"
let localFile: URL = "file:///path/to/document.pdf"

// Use in URLRequest
var request = URLRequest(url: "https://example.com/api")
request.httpMethod = "POST"

// Array of URLs
let endpoints: [URL] = [
    "https://api.example.com/users",
    "https://api.example.com/posts",
    "https://api.example.com/comments"
]
```

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

### UIImage Extensions: Image Creation, Manipulation, and Async Loading

Source: https://context7.com/pffan91/appextensions/llms.txt

Provides extensions for UIImage to create placeholder images, scale, resize, adjust alpha and tint, convert to Base64, load images asynchronously from URLs, utilize SF Symbols with configurations, and support GIF images. It also includes async loading for UIImageView with caching and rounding corners.

```swift
import UIKit
import AppExtensions

// Create placeholder images
let placeholder = UIImage.empty(size: CGSize(width: 200, height: 200), color: .lightGray)

// Scaling and resizing
let scaled = originalImage.scaled(by: 0.5)
let thumbnail = originalImage.resizedImage(newWidth: 100)

// Alpha and tinting
let fadedImage = originalImage.with(alpha: 0.7)
let tintedImage = originalImage.tintImage(color: .blue)

// Base64 conversion
let base64String = myImage.toBase64()

// Async image loading
Task {
    do {
        let image = try await UIImage.loadImage(from: "https://example.com/image.jpg")
        imageView.image = image
    } catch {
        print("Failed to load image: (error)")
    }
}

// SF Symbols with configurations
let smallIcon = UIImage(systemName: "star.fill")?.smallSymbol
let mediumIcon = UIImage(systemName: "heart.fill")?.mediumSymbol
let largeIcon = UIImage(systemName: "arrow.right")?.largeSymbol

// GIF support
let gifFromBundle = UIImage.gifImageWithName("loading")
let gifFromURL = UIImage.gifImageWithURL("https://example.com/animation.gif")

// UIImageView async loading with cache
Task {
    await imageView.loadImageAsync(
        from: "https://example.com/photo.jpg",
        placeholder: UIImage(systemName: "photo")
    )
}

// Round corners for aspect fit imagesimageView.roundCornersForAspectFit(radius: 8)
```

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

### Codable Extensions for JSON Handling (Swift)

Source: https://context7.com/pffan91/appextensions/llms.txt

Offers convenient methods for JSON encoding and decoding of Codable objects. Includes extensions for decoding from JSON strings, encoding to JSON strings, and converting to/from dictionaries. Simplifies common data serialization tasks.

```swift
import Foundation
import AppExtensions

struct User: Codable {
    let id: Int
    let name: String
    let email: String
}

// Decode from JSON string
let jsonString = """
{
    "id": 1,
    "name": "John Doe",
    "email": "john@example.com"
}
"""

if let user = User.from(json: jsonString) {
    print(user.name)
}

// Alternative initializer
do {
    let user = try User(JSONString: jsonString)
    print(user.email)
} catch {
    print("Decoding failed: \(error)")
}

// Encode to JSON string
let newUser = User(id: 2, name: "Jane Smith", email: "jane@example.com")
if let json = newUser.json() {
    print(json)
    // {"id":2,"name":"Jane Smith","email":"jane@example.com"}
}

// Convert to dictionary
if let dict = newUser.dictionary {
    print(dict["name"] as? String)  // "Jane Smith"
}

// Use in API requests
struct APIClient {
    func sendUser(_ user: User) async throws {
        guard let jsonString = user.json() else { return }
        let data = jsonString.data(using: .utf8)!

        var request = URLRequest(url: "https://api.example.com/users")
        request.httpMethod = "POST"
        request.httpBody = data
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")

        let (_, response) = try await URLSession.shared.data(for: request)
        // Handle response...
    }
}
```

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

### UIApplication Extensions: Window and View Controller Access

Source: https://context7.com/pffan91/appextensions/llms.txt

Provides helper extensions for UIApplication to access the current key window, active window, and the topmost visible view controller. It also includes functionality to retrieve the app icon and present alerts from anywhere in the app.

```swift
import UIKit
import AppExtensions

// Get current key window (multi-scene compatible)
if let window = UIApplication.shared.currentWindow {
    window.backgroundColor = .systemBackground
}

// Get active window
if let activeWindow = UIApplication.shared.activeWindow {
    activeWindow.makeKeyAndVisible()
}

// Find topmost visible view controller
if let topVC = UIApplication.shared.topViewController() {
    topVC.present(alertController, animated: true)
}

// Get app icon as image
if let iconImage = UIApplication.shared.icon {
    shareIconView.image = iconImage
}

// Practical usage for presenting alerts from anywhere
extension UIApplication {
    func showAlert(title: String, message: String) {
        let alert = UIAlertController(title: title, message: message, preferredStyle: .alert)
        alert.addAction(UIAlertAction(title: "OK", style: .default))

        if let topVC = self.topViewController() {
            topVC.present(alert, animated: true)
        }
    }
}

// Usage
UIApplication.shared.showAlert(title: "Error", message: "Network connection failed")
```

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

### UIColor Extensions for Color Initialization and Manipulation in Swift

Source: https://context7.com/pffan91/appextensions/llms.txt

Provides extensions for UIColor to facilitate color creation from hex strings (supporting various formats like #RGB, #RRGGBB, #RRGGBBAA), RGB values, and integer hex representations. It also includes utilities for converting colors to hex strings, modifying alpha values, and generating solid color images.

```swift
import UIKit
import AppExtensions

// Hex string initialization (supports #RGB, #RRGGBB, #RRGGBBAA)
let red = UIColor(hex: "#FF0000")
let semiTransparent = UIColor(hex: "#FF000080")

// Display P3 color space for Figma compatibility
let figmaColor = UIColor(hex: "#4A90E2", useDisplayP3: false)

// RGB with 0-255 values
let orange = UIColor(r: 255, g: 165, b: 0)
let purple = UIColor(r: 128, g: 0, b: 128, a: 0.5)

// Integer hex value
let blue = UIColor(0x0000FF)

// Convert color to hex string
let hexValue = UIColor.red.hexString  // "#FF0000"

// Alpha modification
let fadedRed = UIColor.red.alpha(0.5)

// Generate solid color image
let colorImage = UIColor.blue.image(with: CGSize(width: 100, height: 100))
imageView.image = colorImage
```

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

### UIView Enhancements for Layout, Animation, and Visual Effects in Swift

Source: https://context7.com/pffan91/appextensions/llms.txt

Offers extensions for UIView to simplify view hierarchy navigation, Auto Layout constraints, applying visual effects like shadows and blur, performing animations, capturing screenshots, and debugging. These utilities reduce boilerplate code for common UI manipulation tasks.

```swift
import UIKit
import AppExtensions

// Find containing view controller
if let viewController = myView.findViewController() {
    viewController.navigationController?.pushViewController(nextVC, animated: true)
}

// Auto Layout helpers
let contentView = UIView()
view.addSubview(contentView)
contentView.centerInSuperview()
contentView.constrainToSides(margin: 16)

// Visual effects
myView.setShadow(
    color: .black,
    shadowOffset: CGSize(width: 0, height: 2),
    shadowOpacity: 0.3,
    shadowRadius: 4
)

myView.roundCorners([.topLeft, .topRight], radius: 12)

myView.applyGradient(
    colors: [UIColor.blue, UIColor.purple],
    locations: [0, 1]
)

myView.addBlurEffect(style: .regular)

// Animations
errorLabel.shake(maxValue: 10, step: 10, duration: 0.5)
button.pulse(duration: 0.3)
loadingIcon.rotate(duration: 1.0, autoreverses: false)
successView.bounce(duration: 0.5)
achievementView.tada(duration: 0.8, repeatInterval: nil)

// Screenshot capture
let screenshot = myView.snapshot()
let highResScreenshot = myView.takeScreenshot(scale: 3.0)

// Debug helpers
#if DEBUG
myView.debugBorder()
suspiciousView.debugWithRedBorder()
#endif

// Frame shortcuts
myView.top = 100
myView.left = 20
myView.centerX = view.bounds.width / 2
```

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

### DispatchQueue Extensions for Async Operations (Swift)

Source: https://context7.com/pffan91/appextensions/llms.txt

Simplifies asynchronous operations using DispatchQueue. Provides extensions for executing code on the main or background queues, delayed execution, and debouncing. Useful for UI updates, background tasks, and managing event frequency.

```swift
import Foundation
import AppExtensions

// Execute on main queue
DispatchQueue.main {
    self.updateUI()
}

// Execute on background queue
DispatchQueue.background {
    let result = self.performHeavyComputation()
    DispatchQueue.main {
        self.displayResult(result)
    }
}

// Delayed execution on main queue
DispatchQueue.delay(2.0) {
    self.showWelcomeMessage()
}

// Debounced function (useful for search fields)
class SearchViewController: UIViewController {
    lazy var performSearch = DispatchQueue.main.debounce(delay: 0.3) { [weak self] in
        self?.executeSearch()
    }

    func textFieldDidChange(_ textField: UITextField) {
        // Will only execute 0.3 seconds after user stops typing
        performSearch()
    }

    func executeSearch() {
        // Perform actual search
        print("Searching for: \(searchField.text ?? "")")
    }
}

// Debounce for API rate limiting
lazy var saveData = DispatchQueue.background.debounce(delay: 1.0) {
    self.syncToServer()
}
```

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

### Cryptographic Hashing Functions (Swift)

Source: https://context7.com/pffan91/appextensions/llms.txt

Provides global functions for common cryptographic hash algorithms like MD5 and SHA-256. Useful for tasks such as password hashing, file integrity verification, and API request signing. Note: SHA-256 is suitable for basic hashing but consider more robust security measures for production password storage.

```swift
import Foundation
import AppExtensions

// MD5 hashing
let md5Hash = MD5("password123")
// "482c811da5d5b4bc6d497ffa98491e38"

// SHA-256 hashing
let sha256Hash = SHA256("sensitive_data")
// "a591a6d40bf420404a011733cfb7b190d62c65bf0bcda32b57b277d9ad9f146e"

// Use for password hashing (consider using more secure methods in production)
func hashPassword(_ password: String) -> String {
    return SHA256(password + "app_salt")
}

// File integrity verification
let fileData = try Data(contentsOf: fileURL)
let fileHash = SHA256(fileData.base64EncodedString())

// API request signing
let timestamp = String(Date().timeIntervalSince1970)
let signature = SHA256("(apiKey)(timestamp)(requestBody)")
```

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

### Type-Safe UserDefaults with Property Wrapper (Swift)

Source: https://context7.com/pffan91/appextensions/llms.txt

Implements type-safe storage for UserDefaults using a property wrapper. Supports basic types, collections, custom suites, and typed keys. Ensures data is automatically persisted and retrieved.

```swift
import Foundation
import AppExtensions

class AppSettings {
    // Basic types
    @UserDefault("username", .standard)
    var username: String = "Guest"

    @UserDefault("isLoggedIn", .standard)
    var isLoggedIn: Bool = false

    @UserDefault("userId", .standard)
    var userId: Int = 0

    @UserDefault("lastLoginDate", .standard)
    var lastLoginDate: Date?

    // Arrays and dictionaries
    @UserDefault("favoriteColors", .standard)
    var favoriteColors: [String] = []

    @UserDefault("userPreferences", .standard)
    var preferences: [String: Any] = [: ]

    // Custom UserDefaults suite
    @UserDefault("teamId", UserDefaults(suiteName: "group.com.example.app")!)
    var teamId: String?

    // Typed keys
    static let themeKey = UserDefault.Key<String>("appTheme")

    @UserDefault(themeKey, .standard)
    var theme: String = "light"
}

// Usage
let settings = AppSettings()
settings.username = "john_doe"
settings.isLoggedIn = true
settings.favoriteColors.append("blue")

print(settings.username)  // Automatically persisted and retrieved
```

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

### String Manipulation and Utility Extensions in Swift

Source: https://context7.com/pffan91/appextensions/llms.txt

Provides extensions for String to perform various operations including Base64 encoding/decoding, SHA-256 hashing, boolean conversion, URL encoding, HTML to attributed string conversion, safe subscript access, password generation, size calculation, and safe numeric conversions. These utilities aim to streamline common string processing tasks in Swift development.

```swift
import AppExtensions

// Base64 encoding/decoding
let encoded = "Hello World".toBase64()
let decoded = encoded?.fromBase64()

// SHA-256 hashing
let hash = "password123".sha256()

// Boolean conversion from string
let isTrue = "yes".toBool()  // true
let isFalse = "off".toBool() // false

// Localization shorthand
let greeting = "welcome_message".localized

// URL encoding
let encoded = "hello world".urlEncoded  // "hello%20world"

// HTML to attributed string
if let attributed = "<p>Hello <b>World</b></p>".htmlToAttributedString() {
    label.attributedText = attributed
}

// Safe subscript access
let str = "Hello"
let char = str[0]           // "H"
let substring = str[0..<3]  // "Hel"

// Password generation
let password = String.generatePassword(length: 16)

// Size calculation for layout
let size = "Sample Text".sizeOfString(
    constrainedToWidth: 200,
    font: .systemFont(ofSize: 16)
)

// Safe numeric conversion
let value = "123".intValue    // 123
let invalid = "abc".intValue  // 0 (safe default)
```

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

### Numeric Extensions: Byte Size and Time Interval Conversions

Source: https://context7.com/pffan91/appextensions/llms.txt

Extends numeric types (Double, Int) for convenient conversions related to byte sizes (KB, MB, GB) and time intervals (seconds, minutes, hours, days). Also includes a utility to convert Int to CGFloat.

```swift
import Foundation
import AppExtensions

// Byte size conversions
let fileSize = 2.5.MB      // 2,621,440 bytes
let largeFile = 1.2.GB     // 1,288,490,188.8 bytes
let smallFile = 500.KB     // 512,000 bytes

// Time interval conversions
DispatchQueue.main.asyncAfter(deadline: .now() + 5.seconds) {
    print("Executed after 5 seconds")
}

let sessionTimeout = 30.minutes  // 1800 seconds
let cacheExpiry = 24.hours       // 86400 seconds
let retentionPeriod = 7.days     // 604800 seconds

// Int to CGFloat conversion
let spacing: Int = 16
view.layer.cornerRadius = spacing.toFloat
```

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

### Style NSAttributedString with Swift

Source: https://context7.com/pffan91/appextensions/llms.txt

Demonstrates basic and complex styling of NSAttributedString using chainable methods. Supports color, font, links, underline, concatenation, image attachments, font scaling, and font name replacement. Converts to mutableattributed strings for further manipulation.

```swift
import UIKit
import AppExtensions

// Basic styling
let styled = NSAttributedString(string: "Hello World")
    .with(color: .blue)
    .with(font: .systemFont(ofSize: 18, weight: .bold))

// Complex styling
let complex = NSAttributedString(string: "Click here to learn more")
    .with(color: .label)
    .with(font: .systemFont(ofSize: 16))
    .with(link: URL(string: "https://example.com")!, for: "here")
    .with(underline: .single)

// label.attributedText = complex

// Concatenation with operator
let title = NSAttributedString(string: "Error: ")
    .with(color: .red)
    .with(font: .boldSystemFont(ofSize: 14))

let message = NSAttributedString(string: "Connection failed")
    .with(color: .secondaryLabel)
    .with(font: .systemFont(ofSize: 14))

// label.attributedText = title + message

// Add image attachments
let icon = UIImage(systemName: "star.fill")!
let text = NSAttributedString(string: "Premium Feature ")
    .with(color: .systemYellow)
    .append(icon)

// Scale all fonts
let originalText = NSAttributedString(string: "Sample")
    .with(font: .systemFont(ofSize: 12))
let scaled = originalText.with(scale: 1.5)  // Now 18pt

// Replace font names
let webText = NSAttributedString(string: "Web Content")
    .with(font: UIFont(name: "Arial", size: 14)!)
let nativeText = webText.with(replacedFonts: ["Arial": "San Francisco"])

// Convert to mutable
let mutableText = styled.mutable
mutableText.addAttribute(.kern, value: 2.0, range: NSRange(location: 0, length: mutableText.length))
```

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

### Optional Extensions: String Handling

Source: https://context7.com/pffan91/appextensions/llms.txt

Extends the `Optional` type for `String` to provide convenient methods for handling nil or empty string values. Includes `orEmpty` to return an empty string if the optional is nil, and `valueOr` to return a default value if the optional is nil or an empty string.

```swift
import Foundation
import AppExtensions

// Get value or empty string
let username: String? = nil
label.text = username.orEmpty  // ""

// Get value or default, checking for empty
let displayName = username.valueOr("Guest")  // "Guest"

let emptyName: String? = ""
let result = emptyName.valueOr("Anonymous")  // "Anonymous"
```

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

### Type-Safe UICollectionView Handling in Swift

Source: https://context7.com/pffan91/appextensions/llms.txt

Provides type-safe registration and dequeuing for UICollectionView cells and supplementary views. Simplifies handling of different view types and eliminates casting. Requires the AppExtensions library.

```swift
import UIKit
import AppExtensions

class PhotoGridViewController: UIViewController {
    let collectionView: UICollectionView = ...

    override func viewDidLoad() {
        super.viewDidLoad()

        // Type-safe cell registration
        collectionView.register(PhotoCell.self)
        collectionView.register(nib: UINib(nibName: "FeaturedCell", bundle: nil), FeaturedCell.self)

        // Register supplementary views
        collectionView.register(HeaderView.self, of: .header)
        collectionView.register(FooterView.self, of: .footer)
    }
}

extension PhotoGridViewController: UICollectionViewDataSource {
    func collectionView(_ collectionView: UICollectionView, cellForItemAt indexPath: IndexPath) -> UICollectionViewCell {
        // Type-safe dequeuing
        let cell: PhotoCell = collectionView.dequeue(for: indexPath)
        cell.configure(with: photos[indexPath.item])
        return cell
    }

    func collectionView(_ collectionView: UICollectionView, viewForSupplementaryElementOfKind kind: String, at indexPath: IndexPath) -> UICollectionReusableView {
        let header: HeaderView = collectionView.dequeue(of: .header, for: indexPath)
        header.title = sections[indexPath.section]
        return header
    }
}
```

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

### Date Extensions: Component Extraction

Source: https://context7.com/pffan91/appextensions/llms.txt

Provides extensions for the `Date` type to easily extract components such as the year. This simplifies accessing specific parts of a date object without manual calculations.

```swift
import Foundation
import AppExtensions

let date = Date()
let currentYear = date.year  // 2025

let birthday = Date(timeIntervalSince1970: 946684800)
let birthYear = birthday.year  // 2000
```

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

### Type-Safe UITableView Registration and Dequeuing in Swift

Source: https://context7.com/pffan91/appextensions/llms.txt

Enables type-safe registration and dequeuing of UITableView cells and views, eliminating the need for casting. Supports registering custom cells, NIB-based cells, and header/footer views. Requires the AppExtensions library.

```swift
import UIKit
import AppExtensions

class MyTableViewController: UITableViewController {
    override func viewDidLoad() {
        super.viewDidLoad()

        // Type-safe registration
        tableView.register(CustomCell.self)
        tableView.register(nib: UINib(nibName: "NibCell", bundle: nil), CustomNibCell.self)

        // Register header/footer views
        tableView.register(CustomHeaderView.self, for: .header)
    }

    override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        // Type-safe dequeuing (no casting needed)
        let cell: CustomCell = tableView.dequeue(for: indexPath)
        cell.configure(with: items[indexPath.row])
        return cell
    }

    override func tableView(_ tableView: UITableView, viewForHeaderInSection section: Int) -> UIView? {
        let header: CustomHeaderView = tableView.dequeue(for: .header, section: section)
        return header
    }

    func scrollToEnd() {
        tableView.scrollToBottom()
    }

    func isValidIndexPath(_ indexPath: IndexPath) -> Bool {
        return tableView.hasRow(at: indexPath)
    }
}
```

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

### Convert Boolean to String in Swift

Source: https://context7.com/pffan91/appextensions/llms.txt

Converts boolean values (true/false) to their string representations ('on'/'off'). Useful for API payloads or UI display. Requires the AppExtensions library.

```swift
import Foundation
import AppExtensions

let isEnabled = true
let statusString = isEnabled.toString()  // "on"

let isDisabled = false
let disabledString = isDisabled.toString()  // "off"

// Useful for API payloads
let payload = [
    "notifications": notifications.toString(),
    "darkMode": darkMode.toString()
]
```

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

### UIButton Extensions for Utilities in Swift

Source: https://context7.com/pffan91/appextensions/llms.txt

Adds utility functions to UIButton, including the ability to store associated objects like URLs and add spacing between the title and button edges. Requires the AppExtensions library.

```swift
import UIKit
import AppExtensions

// Store associated URL data
button.pdfURL = URL(string: "https://example.com/document.pdf")

// Later retrieve it
@objc func buttonTapped(_ sender: UIButton) {
    if let pdfURL = sender.pdfURL {
        openPDF(at: pdfURL)
    }
}

// Add horizontal padding around title
button.addSpacingBetweenTitleAndEdges(spacing: 20)
```

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