SwiftUI View Refactor
Overview
Refactor SwiftUI views toward small, explicit, stable view types. Default to vanilla SwiftUI: local state in the view, shared dependencies in the environment, business logic in services/models, and view models only when the request or existing code clearly requires one.
Core Guidelines
1) View ordering (top → bottom)
- Enforce this ordering unless the existing file has a stronger local convention you must preserve.
- Environment
private/public let
@State / other stored properties
- computed
var (non-view)
init
body
- computed view builders / other view helpers
- helper / async functions
2) Default to MV, not MVVM
- Views should be lightweight state expressions and orchestration points, not containers for business logic.
- Favor
@State, @Environment, @Query, .task, .task(id:), and onChange before reaching for a view model.
- Inject services and shared models via
@Environment; keep domain logic in services/models, not in the view body.
- Do not introduce a view model just to mirror local view state or wrap environment dependencies.
- If a screen is getting large, split the UI into subviews before inventing a new view model layer.
3) Strongly prefer dedicated subview types over computed some View helpers
- Flag
body properties that are longer than roughly one screen or contain multiple logical sections.
- Prefer extracting dedicated
View types for non-trivial sections, especially when they have state, async work, branching, or deserve their own preview.
- Keep computed
some View helpers rare and small. Do not build an entire screen out of private var header: some View-style fragments.
- Pass small, explicit inputs (data, bindings, callbacks) into extracted subviews instead of handing down the entire parent state.
- If an extracted subview becomes reusable or independently meaningful, move it to its own file.
Prefer:
var body: some View {
List {
HeaderSection(title: title, subtitle: subtitle)
FilterSection(
filterOptions: filterOptions,
selectedFilter: $selectedFilter
)
ResultsSection(items: filteredItems)
FooterSection()
}
}
private struct HeaderSection: View {
let title: String
let subtitle: String
var body: some View {
VStack(alignment: .leading, spacing: 6) {
Text(title).font(.title2)
Text(subtitle).font(.subheadline)
}
}
}
private struct FilterSection: View {
let filterOptions: [FilterOption]
@Binding var selectedFilter: FilterOption
var body: some View {
ScrollView(.horizontal, showsIndicators: false) {
HStack {
ForEach(filterOptions, id: \.self) { option in
FilterChip(option: option, isSelected: option == selectedFilter)
.onTapGesture { selectedFilter = option }
}
}
}
}
}
Avoid:
var body: some View {
List {
header
filters
results
footer
}
}
private var header: some View {
VStack(alignment: .leading, spacing: 6) {
Text(title).font(.title2)
Text(subtitle).font(.subheadline)
}
}
3b) Extract actions and side effects out of body
- Do not keep non-trivial button actions inline in the view body.
- Do not bury business logic inside
.task, .onAppear, .onChange, or .refreshable.
- Prefer calling small private methods from the view, and move real business logic into services/models.
- The body should read like UI, not like a view controller.
Button("Save", action: save)
.disabled(isSaving)
.task(id: searchText) {
await reload(for: searchText)
}
private func save() {
Task { await saveAsync() }
}
private func reload(for searchText: String) async {
guard !searchText.isEmpty else {
results = []
return
}
await searchService.search(searchText)
}
4) Keep a stable view tree (avoid top-level conditional view swapping)
- Avoid
body or computed views that return completely different root branches via if/else.
- Prefer a single stable base view with conditions inside sections/modifiers (
overlay, opacity, disabled, toolbar, etc.).
- Root-level branch swapping causes identity churn, broader invalidation, and extra recomputation.
Prefer:
var body: some View {
List {
documentsListContent
}
.toolbar {
if canEdit {
editToolbar
}
}
}
Avoid:
var documentsListView: some View {
if canEdit {
editableDocumentsList
} else {
readOnlyDocumentsList
}
}
5) View model handling (only if already present or explicitly requested)
- Treat view models as a legacy or explicit-need pattern, not the default.
- Do not introduce a view model unless the request or existing code clearly calls for one.
- If a view model exists, make it non-optional when possible.
- Pass dependencies to the view via
init, then create the view model in the view's init.
- Avoid
bootstrapIfNeeded patterns and other delayed setup workarounds.
Example (Observation-based):
@State private var viewModel: SomeViewModel
init(dependency: Dependency) {
_viewModel = State(initialValue: SomeViewModel(dependency: dependency))
}
6) Observation usage
- For
@Observable reference types on iOS 17+, store them as @State in the owning view.
- Pass observables down explicitly; avoid optional state unless the UI genuinely needs it.
- If the deployment target includes iOS 16 or earlier, use
@StateObject at the owner and @ObservedObject when injecting legacy observable models.
Workflow
- Reorder the view to match the ordering rules.
- Remove inline actions and side effects from
body; move business logic into services/models and keep only thin orchestration in the view.
- Shorten long bodies by extracting dedicated subview types; avoid rebuilding the screen out of many computed
some View helpers.
- Ensure stable view structure: avoid top-level
if-based branch swapping; move conditions to localized sections/modifiers.
- If a view model exists or is explicitly required, replace optional view models with a non-optional
@State view model initialized in init.
- Confirm Observation usage:
@State for root @Observable models on iOS 17+, legacy wrappers only when the deployment target requires them.
- Keep behavior intact: do not change layout or business logic unless requested.
Notes
- Prefer small, explicit view types over large conditional blocks and large computed
some View properties.
- Keep computed view builders below
body and non-view computed vars above init.
- A good SwiftUI refactor should make the view read top-to-bottom as data flow plus layout, not as mixed layout and imperative logic.
- For MV-first guidance and rationale, see
references/mv-patterns.md.
- In addition to the references above, use web search to consult current Apple Developer documentation when SwiftUI APIs, Observation behavior, or platform guidance may have changed.
Large-view handling
When a SwiftUI view file exceeds ~300 lines, split it aggressively. Extract meaningful sections into dedicated View types instead of hiding complexity in many computed properties. Use private extensions with // MARK: - comments for actions and helpers, but do not treat extensions as a substitute for breaking a giant screen into smaller view types. If an extracted subview
is reused or
independently meaningful, move it into its own file.
1---
2name: swiftui-view-refactor
3description: Refactor SwiftUI view files into stable, testable structure. Use when splitting large views, tightening data flow, or cleaning Observation ownership.
4metadata:
5 source: https://skillmd.com/skills/duyet/swiftui-view-refactor
6---
7
8# SwiftUI View Refactor
9
10## Overview
11
12Refactor SwiftUI views toward small, explicit, stable view types. Default to vanilla SwiftUI: local state in the view, shared dependencies in the environment, business logic in services/models, and view models only when the request or existing code clearly requires one.
13
14## Core Guidelines
15
16### 1) View ordering (top → bottom)
17
18- Enforce this ordering unless the existing file has a stronger local convention you must preserve.
19- Environment
20- `private`/`public` `let`
21- `@State` / other stored properties
22- computed `var` (non-view)
23- `init`
24- `body`
25- computed view builders / other view helpers
26- helper / async functions
27
28### 2) Default to MV, not MVVM
29
30- Views should be lightweight state expressions and orchestration points, not containers for business logic.
31- Favor `@State`, `@Environment`, `@Query`, `.task`, `.task(id:)`, and `onChange` before reaching for a view model.
32- Inject services and shared models via `@Environment`; keep domain logic in services/models, not in the view body.
33- Do not introduce a view model just to mirror local view state or wrap environment dependencies.
34- If a screen is getting large, split the UI into subviews before inventing a new view model layer.
35
36### 3) Strongly prefer dedicated subview types over computed `some View` helpers
37
38- Flag `body` properties that are longer than roughly one screen or contain multiple logical sections.
39- Prefer extracting dedicated `View` types for non-trivial sections, especially when they have state, async work, branching, or deserve their own preview.
40- Keep computed `some View` helpers rare and small. Do not build an entire screen out of `private var header: some View`-style fragments.
41- Pass small, explicit inputs (data, bindings, callbacks) into extracted subviews instead of handing down the entire parent state.
42- If an extracted subview becomes reusable or independently meaningful, move it to its own file.
43
44Prefer:
45
46```swift
47var body: some View {
48 List {
49 HeaderSection(title: title, subtitle: subtitle)
50 FilterSection(
51 filterOptions: filterOptions,
52 selectedFilter: $selectedFilter
53 )
54 ResultsSection(items: filteredItems)
55 FooterSection()
56 }
57}
58
59private struct HeaderSection: View {
60 let title: String
61 let subtitle: String
62
63 var body: some View {
64 VStack(alignment: .leading, spacing: 6) {
65 Text(title).font(.title2)
66 Text(subtitle).font(.subheadline)
67 }
68 }
69}
70
71private struct FilterSection: View {
72 let filterOptions: [FilterOption]
73 @Binding var selectedFilter: FilterOption
74
75 var body: some View {
76 ScrollView(.horizontal, showsIndicators: false) {
77 HStack {
78 ForEach(filterOptions, id: \.self) { option in
79 FilterChip(option: option, isSelected: option == selectedFilter)
80 .onTapGesture { selectedFilter = option }
81 }
82 }
83 }
84 }
85}
86```
87
88Avoid:
89
90```swift
91var body: some View {
92 List {
93 header
94 filters
95 results
96 footer
97 }
98}
99
100private var header: some View {
101 VStack(alignment: .leading, spacing: 6) {
102 Text(title).font(.title2)
103 Text(subtitle).font(.subheadline)
104 }
105}
106```
107
108### 3b) Extract actions and side effects out of `body`
109
110- Do not keep non-trivial button actions inline in the view body.
111- Do not bury business logic inside `.task`, `.onAppear`, `.onChange`, or `.refreshable`.
112- Prefer calling small private methods from the view, and move real business logic into services/models.
113- The body should read like UI, not like a view controller.
114
115```swift
116Button("Save", action: save)
117 .disabled(isSaving)
118
119.task(id: searchText) {
120 await reload(for: searchText)
121}
122
123private func save() {
124 Task { await saveAsync() }
125}
126
127private func reload(for searchText: String) async {
128 guard !searchText.isEmpty else {
129 results = []
130 return
131 }
132 await searchService.search(searchText)
133}
134```
135
136### 4) Keep a stable view tree (avoid top-level conditional view swapping)
137
138- Avoid `body` or computed views that return completely different root branches via `if/else`.
139- Prefer a single stable base view with conditions inside sections/modifiers (`overlay`, `opacity`, `disabled`, `toolbar`, etc.).
140- Root-level branch swapping causes identity churn, broader invalidation, and extra recomputation.
141
142Prefer:
143
144```swift
145var body: some View {
146 List {
147 documentsListContent
148 }
149 .toolbar {
150 if canEdit {
151 editToolbar
152 }
153 }
154}
155```
156
157Avoid:
158
159```swift
160var documentsListView: some View {
161 if canEdit {
162 editableDocumentsList
163 } else {
164 readOnlyDocumentsList
165 }
166}
167```
168
169### 5) View model handling (only if already present or explicitly requested)
170
171- Treat view models as a legacy or explicit-need pattern, not the default.
172- Do not introduce a view model unless the request or existing code clearly calls for one.
173- If a view model exists, make it non-optional when possible.
174- Pass dependencies to the view via `init`, then create the view model in the view's `init`.
175- Avoid `bootstrapIfNeeded` patterns and other delayed setup workarounds.
176
177Example (Observation-based):
178
179```swift
180@State private var viewModel: SomeViewModel
181
182init(dependency: Dependency) {
183 _viewModel = State(initialValue: SomeViewModel(dependency: dependency))
184}
185```
186
187### 6) Observation usage
188
189- For `@Observable` reference types on iOS 17+, store them as `@State` in the owning view.
190- Pass observables down explicitly; avoid optional state unless the UI genuinely needs it.
191- If the deployment target includes iOS 16 or earlier, use `@StateObject` at the owner and `@ObservedObject` when injecting legacy observable models.
192
193## Workflow
194
1951. Reorder the view to match the ordering rules.
1962. Remove inline actions and side effects from `body`; move business logic into services/models and keep only thin orchestration in the view.
1973. Shorten long bodies by extracting dedicated subview types; avoid rebuilding the screen out of many computed `some View` helpers.
1984. Ensure stable view structure: avoid top-level `if`-based branch swapping; move conditions to localized sections/modifiers.
1995. If a view model exists or is explicitly required, replace optional view models with a non-optional `@State` view model initialized in `init`.
2006. Confirm Observation usage: `@State` for root `@Observable` models on iOS 17+, legacy wrappers only when the deployment target requires them.
2017. Keep behavior intact: do not change layout or business logic unless requested.
202
203## Notes
204
205- Prefer small, explicit view types over large conditional blocks and large computed `some View` properties.
206- Keep computed view builders below `body` and non-view computed vars above `init`.
207- A good SwiftUI refactor should make the view read top-to-bottom as data flow plus layout, not as mixed layout and imperative logic.
208- For MV-first guidance and rationale, see `references/mv-patterns.md`.
209- In addition to the references above, use web search to consult current Apple Developer documentation when SwiftUI APIs, Observation behavior, or platform guidance may have changed.
210
211## Large-view handling
212
213When a SwiftUI view file exceeds ~300 lines, split it aggressively. Extract meaningful sections into dedicated `View` types instead of hiding complexity in many computed properties. Use `private` extensions with `// MARK: -` comments for actions and helpers, but do not treat extensions as a substitute for breaking a giant screen into smaller view types. If an extracted subview
214is reused or
215independently meaningful, move it into its own file.