The Encapsulated Sheet Pattern: Domain-Driven Modal Presentation in SwiftUI

When managing modal presentation in SwiftUI, developers frequently face a dilemma between direct boolean bindings (.sheet(isPresented:)) and item bindings (.sheet(item:)). While .sheet(item:) binds presentation directly to optional data, it presents architectural trade-offs: the item passed to the sheet content closure is immutable value data, meaning two-way editing requires workarounds like class reference types or complex parent binding lookups. Moreover, spreading inline .sheet(item:) calls across multiple parent views, e.g. for add-new and edit-existing, leads to duplicated layout and lifecycle boilerplate.

The Encapsulated Sheet Pattern pairs a custom domain state struct with a dedicated View Modifier. This pattern uses Swift’s fileprivate access control on the presentation trigger while exposing explicit control methods like present() and dismiss(). This gives you the best of both worlds: single-source-of-truth boolean control paired with encapsulated draft state management.

1. Terminology: The Pattern Components

• State Struct: PersonalInfoEditor — Encapsulates draft state (name), presentation state (isPresented), title configuration, and validation logic (canSave()).
• View Modifier: PersonalInfoEditorSheet — A custom ViewModifier managing the modal lifecycle, navigation setup, and action bar layout.
• Modifier Extension: .personalInfoEditorSheet(editor:onSave:) — A declarative API extension on Viewthat attaches the presentation logic cleanly.

2. Solving Point-Free’s Domain Modeling Concerns with Access Control

In Point-Free’s functional architecture discussions, a key topic is domain modeling: ensuring illegal states are unrepresentable. A common issue with basic .sheet(isPresented:) calls is state desynchronization—for example, toggling isPresented = true without populating the underlying draft values, or failing to reset form state when dismissing.

       UNPROTECTED STATE                                    PROTECTED PATTERN
 ┌───────────────────────────┐                         ┌───────────────────────────┐
 │ @State isPresented = true │ ─── Can desync with ───>│ PersonalInfoEditor Struct │
 │ @State name = ""          │     draft payload       │ ├── fileprivate isPresented│
 └───────────────────────────┘                         │ ├── present(name:)        │
                                                       │ └── dismiss()             │
                                                       └───────────────────────────┘

The Encapsulated Sheet Pattern addresses this issue by using fileprivate(set) on isPresented.

struct PersonalInfoEditor {
    let title: String
    
    // 🔒 fileprivate prevents arbitrary external boolean toggling
    fileprivate var isPresented: Bool = false
    
    var name: String = "" {
        didSet{
            canSave = Person.isValid(name: name) && initialName != name
        }
    }
    private var initialName: String = ""
    
    fileprivate var canSave = false

    /// The primary entry point to trigger presentation—forces payload setup
    mutating func present(name: String = "") {
        self.name = name
        self.initialName = name
        self.isPresented = true
    }
    
    /// Publicly exposed dismissal method for programmatic control outside the struct's file
    mutating func dismiss() {
        isPresented = false
    }
    
    func canSave() -> Bool {
        Person.isValid(name: name) && initialName != name
    }
}

Why This Access Control Strategy Works

1. Enforced Payload Initialization: External views cannot execute editor.isPresented = true. They must call editor.present(name:), guaranteeing that name and initialName are initialized whenever the sheet opens.
2. Explicit Public Dismissal: Making dismiss() public allows callers outside the struct’s file boundaries to close the sheet programmatically (e.g., after custom async network operations or validation steps) without exposing raw mutation of isPresented.

3. Why Not Just Use .sheet(item:)?

Using .sheet(item:) is a common approach in SwiftUI, but it introduces specific structural challenges in real-world applications:

1. Immutability inside the Closure: .sheet(item: $optionalItem) { item in ... } passes a read-only snapshot (item) into the view hierarchy. If you need two-way binding inside the sheet (such as binding a TextFielddirectly to a property), item cannot be passed directly as a $binding. Developers often resort to reference types (classes) or indirect collection index bindings to work around this.
2. Duplicated Layout Boilerplate: Using .sheet(item:) directly across multiple parent views (like an AddPersonalInfo button vs. an EditPersonalInfo button) duplicates NavigationStack, ToolbarItem, and .disabled() validation logic across the codebase.

By consolidating layout inside PersonalInfoEditorSheet while using PersonalInfoEditor as a @Binding, two-way value bindings ($editor.name) remain straightforward, and layout logic is defined in a single location.

4. Decoupling Views from Domain Models

Notice how EditPersonalInfo and AddPersonalInfo do not import or accept Person instances directly. Instead, they operate strictly on raw primitives (String) passed to present(name:) and returned via completion callbacks.

This design keeps feature views completely decoupled from storage entities:

• The subviews only care about editing text.
• The parent view (ContentView) retains total authority over how changes map back to the actual domain model (Person).

5. Complete Code Implementation

Here is the complete implementation of the Encapsulated Sheet Pattern:

import SwiftUI

// MARK: - 1. Domain Model
struct Person: Identifiable {
    let id = UUID()
    var name: String
    
    static func isValid(name: String) -> Bool {
        !name.trimmingCharacters(in: .whitespaces).isEmpty
    }
}

// MARK: - 2. Encapsulated State Struct
struct PersonalInfoEditor {
    let title: String
    fileprivate(set) var isPresented: Bool = false
    
    var name: String = ""
    private var initialName: String = ""
    
    mutating func present(name: String = "") {
        self.name = name
        self.initialName = name
        self.isPresented = true
    }
    
    mutating func dismiss() {
        isPresented = false
    }
    
    func canSave() -> Bool {
        Person.isValid(name: name) && initialName != name
    }
}

// MARK: - 3. Custom View Modifier
struct PersonalInfoEditorSheet: ViewModifier {
    @Binding var editor: PersonalInfoEditor
    let onSave: () -> Void

    func body(content: Content) -> some View {
        content
            .sheet(isPresented: $editor.isPresented) {
                NavigationStack {
                    Form {
                        TextField("Name", text: $editor.name)
                    }
                    .navigationTitle(editor.title)
                    .toolbar {
                        ToolbarItem(placement: .cancellationAction) {
                            Button("Cancel") {
                                editor.dismiss()
                            }
                        }

                        ToolbarItem(placement: .confirmationAction) {
                            Button("Save") {
                                onSave()
                                editor.dismiss()
                            }
                            .disabled(!editor.canSave)
                        }
                    }
                }
            }
    }
}

// MARK: - 4. Declarative View Extension
extension View {
    func personalInfoEditorSheet(
        editor: Binding<PersonalInfoEditor>,
        onSave: @escaping () -> Void
    ) -> some View {
        self.modifier(
            PersonalInfoEditorSheet(
                editor: editor,
                onSave: onSave
            )
        )
    }
}

// MARK: - 5. Feature Call Sites (Decoupled from Person)

struct EditPersonalInfo: View {
    let initialName: String
    let onSave: (String) -> Void
    
    @State private var editor = PersonalInfoEditor(title: "Edit Personal Info")
    
    var body: some View {
        Button("Edit") {
            editor.present(name: initialName)
        }
        .personalInfoEditorSheet(editor: $editor) {
            onSave(editor.name)
        }
    }
}

struct AddPersonalInfo: View {
    let onSave: (String) -> Void
    
    @State private var editor = PersonalInfoEditor(title: "Add Personal Info")
    
    var body: some View {
        Button {
            editor.present(name: "")
        } label: {
            Label("Add Item", systemImage: "plus")
        }
        .personalInfoEditorSheet(editor: $editor) {
            onSave(editor.name)
        }
    }
}

// MARK: - 6. Host View
struct ContentView: View {
    @State var people = [Person(name: "Jim")]
    
    var body: some View {
        NavigationStack {
            List {
                ForEach(people) { person in
                    NavigationLink(person.name, value: person.id)
                }
            }
            .navigationDestination(for: Person.ID.self) { personID in
                if let $person = $people[id: personID] { // implemented in a Binding extension
                    Form {
                        Text(verbatim: $person.wrappedValue.name)
                    }
                    .toolbar {
                        EditPersonalInfo(
                            initialName: $person.wrappedValue.name
                        ) { updatedName in
                            $person.wrappedValue.name = updatedName
                        }
                    }
                } else {
                    ContentUnavailableView("Person Not Found", systemImage: "person.slash")
                }
            }
            .navigationTitle("Items")
            .toolbar {
                ToolbarItem(placement: .primaryAction) {
                    AddPersonalInfo { newName in
                        people.append(Person(name: newName))
                    }
                }
            }
        }
    }
}

Summary of Key Benefits

1. Domain Safety via Access Control: fileprivate(set) prevents rogue state updates by forcing presentation callers to go through present(name:), guaranteeing properly initialized draft state.
2. Flexible API Surface: Making dismiss() public gives external consumers programmatic dismissal capabilities while preserving protected control over presentation initialization.
3. Two-Way Value Bindings: Direct access to @State private var editor inside the modifier allows SwiftUI form controls to bind directly to $editor.name without needing reference-type wrappers or indirect index resolution.
4. Reusable UI Architecture: Navigation hierarchy, form styling, toolbars, and validation logic live entirely inside PersonalInfoEditorSheet, keeping parent views focused on orchestration.