Text Editing Agent Skill

Styled Text Editing

Patterns for displaying styled text and building rich text editors in SwiftUI. Covers Text styling, AttributedString, TextEditor with selection-based formatting, and custom formatting definitions.

When This Skill Activates

Use this skill when the user:

• Wants to display styled or formatted text
• Needs rich text editing with bold/italic/underline controls
• Asks about AttributedString or TextEditor
• Wants text formatting toolbars
• Asks about Markdown rendering in Text views
• Needs custom text attributes or formatting constraints
• Wants selection-based text formatting

Decision Tree

What text feature do you need?
|
+- Display styled read-only text
|  +- Simple styling (one style) -> Text Styling section below
|  +- Mixed styles in one string -> AttributedString section below
|  +- Markdown content -> Markdown section below
|
+- Edit plain text
|  +- TextEditor(text: $stringBinding)
|
+- Edit rich/styled text
|  +- Basic rich editor -> Rich Text Editing section below
|  +- With formatting toolbar -> Formatting Controls section below
|  +- With custom constraints -> Custom Formatting section below

API Availability

| API | Minimum Version | Notes |

|-----|----------------|-------|

| Text with modifiers | iOS 13 | .font(), .bold(), .italic() |

| TextEditor(text:) | iOS 14 | Plain string binding |

| .foregroundStyle() | iOS 15 | Preferred over .foregroundColor() |

| AttributedString | iOS 15 | Rich text model |

| .bold(condition) | iOS 16 | Conditional bold/italic |

| .underline(pattern:) | iOS 16 | Dash, dot patterns |

| TextEditor(text:selection:) | iOS 18 | AttributedString + selection |

| AttributedTextSelection | iOS 18 | Selection-based formatting |

| text.transformAttributes(in:) | iOS 18 | Modify attributes in selection |

| AttributedTextFormattingDefinition | iOS 18 | Custom formatting constraints |

| @Environment(\.fontResolutionContext) | iOS 18 | Resolve font properties |

Top 5 Mistakes

| # | Mistake | Fix |

|---|---------|-----|

| 1 | Using .foregroundColor() on new projects | Use .foregroundStyle() — supports gradients and ShapeStyle |

| 2 | .animation(.spring()) without value: on text | Deprecated in iOS 15 — always pass value: parameter |

| 3 | Expecting full Markdown in Text | Text only supports inline Markdown: bold, *italic*, [links]. No lists, tables, code blocks, images |

| 4 | Creating new AttributedString instances on every body evaluation | Cache complex AttributedString objects in @State or computed properties outside body |

| 5 | Using TextEditor(text: $string) for rich text | Use TextEditor(text: $attributedString, selection: $selection) with AttributedString binding (iOS 18+) |

Text Styling Quick Reference

// Font
Text("Hello").font(.headline)
Text("Custom").font(.system(size: 24, design: .rounded))

// Weight
Text("Bold").fontWeight(.bold)

// Color — prefer foregroundStyle over foregroundColor
Text("Styled").foregroundStyle(.red)
Text("Gradient").foregroundStyle(
    .linearGradient(colors: [.yellow, .blue], startPoint: .top, endPoint: .bottom)
)

// Decorations
Text("Bold").bold()
Text("Conditional").bold(someCondition)
Text("Underline").underline(true, pattern: .dash, color: .blue)
Text("Strike").strikethrough(true, pattern: .dot, color: .red)

// Layout
Text("Centered").multilineTextAlignment(.center)
Text("Spaced").lineSpacing(10)
Text("Truncated").lineLimit(2).truncationMode(.tail)

AttributedString

// Create and style ranges
var text = AttributedString("Red and Blue")
if let redRange = text.range(of: "Red") {
    text[redRange].foregroundColor = .red
    text[redRange].font = .headline
}
if let blueRange = text.range(of: "Blue") {
    text[blueRange].foregroundColor = .blue
    text[blueRange].underlineStyle = .single
}

// Display
Text(text)

Available Attributes

| Attribute | Type | Example |

|-----------|------|---------|

| .font | Font | .headline |

| .foregroundColor | Color | .red |

| .backgroundColor | Color | .yellow |

| .underlineStyle | UnderlineStyle | .single |

| .underlineColor | Color | .blue |

| .strikethroughStyle | UnderlineStyle | .single |

| .strikethroughColor | Color | .red |

| .inlinePresentationIntent | InlinePresentationIntent | .stronglyEmphasized (bold), .emphasized (italic) |

Rich Text Editing (iOS 18+)

struct RichTextEditorView: View {
    @State private var text = AttributedString("Select text to format")
    @State private var selection = AttributedTextSelection()

    @Environment(\.fontResolutionContext) private var fontResolutionContext

    var body: some View {
        VStack {
            TextEditor(text: $text, selection: $selection)
                .frame(height: 200)

            HStack {
                Button(action: toggleBold) {
                    Image(systemName: "bold")
                }
                Button(action: toggleItalic) {
                    Image(systemName: "italic")
                }
                Button(action: toggleUnderline) {
                    Image(systemName: "underline")
                }
            }
        }
    }

    private func toggleBold() {
        text.transformAttributes(in: &selection) {
            let font = $0.font ?? .default
            let resolved = font.resolve(in: fontResolutionContext)
            $0.font = font.bold(!resolved.isBold)
        }
    }

    private func toggleItalic() {
        text.transformAttributes(in: &selection) {
            let font = $0.font ?? .default
            let resolved = font.resolve(in: fontResolutionContext)
            $0.font = font.italic(!resolved.isItalic)
        }
    }

    private func toggleUnderline() {
        text.transformAttributes(in: &selection) {
            if $0.underlineStyle != nil {
                $0.underlineStyle = nil
            } else {
                $0.underlineStyle = .single
            }
        }
    }
}

Reading Selection Attributes

// Get current attributes at the selection/cursor
let attributes = selection.typingAttributes(in: text)
let currentColor = attributes.foregroundColor ?? .primary

Custom Formatting Definition (iOS 18+)

Constrain which formatting options are available in the editor:

struct MyTextFormatting: AttributedTextFormattingDefinition {
    typealias Scope = AttributeScopes.SwiftUIAttributes

    static let fontWeight = ValueConstraint(
        \.font,
        constraint: { font in
            guard let font = font else { return nil }
            let weight = font.resolve().weight
            return font.weight(weight == .bold ? .regular : .bold)
        }
    )
}

// Apply to TextEditor
TextEditor(text: $text, selection: $selection)
    .textFormattingDefinition(MyTextFormatting.self)

Markdown in Text

// Inline markdown support
Text("This is **bold** and *italic* text")
Text("Visit [Apple](https://www.apple.com)")
Text("Code: `inline code`")

Markdown Limitations

Text supports only inline Markdown:

• ✅ Bold (text), italic (*text*), links, inline code
• ❌ Line breaks, block formatting, lists, tables, code blocks, images, block quotes

Review Checklist

Text Display

• [ ] Using .foregroundStyle() instead of deprecated .foregroundColor()
• [ ] .lineLimit() paired with .help() tooltip or .textSelection(.enabled) for truncated text
• [ ] Dynamic Type supported — using system font styles, not hardcoded sizes
• [ ] Colors adapt to dark mode — using system colors or semantic styles

AttributedString

• [ ] Complex AttributedString cached in @State, not recreated in body
• [ ] Range lookups use safe if let range = text.range(of:) pattern
• [ ] Appropriate attributes used (.inlinePresentationIntent for semantic bold/italic)

TextEditor

• [ ] Rich text uses TextEditor(text: $attributedString, selection: $selection) (iOS 18+)
• [ ] Formatting toolbar uses text.transformAttributes(in: &selection) pattern
• [ ] Font resolution uses @Environment(\.fontResolutionContext) for toggle logic
• [ ] Accessibility labels provided for formatting buttons

Localization

• [ ] User-facing strings use LocalizedStringKey
• [ ] Markdown in localized strings uses Text(LocalizedStringKey("Bold text"))

References

• SwiftUI Text and Symbol Modifiers
• Building Rich SwiftUI Text Experiences
• AttributedString Documentation
• TextEditor Documentation