Communitygithub.com

Patrones SwiftUI

Patrones de arquitectura SwiftUI, gestión de estado con @Observable, composición de vistas, navegación, optimización de rendimiento y mejores prácticas modernas para iOS/macOS UI.

¿Qué es Patrones SwiftUI?

Este skill proporciona una guía completa de patrones modernos para construir interfaces de usuario declarativas y performantes en SwiftUI para plataformas Apple. Cubre la gestión de estado con el framework Observation (reemplazando ObservableObject por @Observable), composición efectiva de vistas para limitar la invalidación de vistas, navegación tipada con NavigationStack y NavigationPath, optimización de rendimiento mediante el uso de contenedores perezosos (LazyVStack, LazyHStack), identificadores estables en ForEach, conformidad a Equatable, y técnicas para evitar trabajo costoso en la propiedad body. El skill es ideal para desarrolladores que trabajan con SwiftUI en Xcode y necesitan escribir código mantenible, eficiente y alineado con las últimas prácticas recomendadas por Apple. Además, incluye ejemplos prácticos de inyección de dependencias mediante @Environment, creación de ViewModifiers reutilizables, y anti-patrones a evitar como el uso de AnyView o ObservableObject en código nuevo.

Compatible con~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/ComeOnOliver/skillshub/tree/HEAD/skills/affaan-m/everything-claude-code/swiftui-patterns

Preguntar en tu IA favorita

Abre un nuevo chat con esta habilidad de agente ya precargada.

Documentación

¿Qué hace Patrones SwiftUI?

Patrones modernos de SwiftUI para construir interfaces de usuario declarativas y de alto rendimiento en plataformas Apple. Cubre el framework Observation, composición de vistas, navegación type-safe y optimización de rendimiento.

Cuándo activar

  • Construir vistas SwiftUI y gestionar estado (@State, @Observable, @Binding)
  • Diseñar flujos de navegación con NavigationStack
  • Estructurar modelos de vista (view models) y flujo de datos
  • Optimizar el rendimiento de renderizado para listas y diseños complejos
  • Trabajar con valores de entorno e inyección de dependencias en SwiftUI

Gestión de Estado

Selección de Property Wrappers

Elige el wrapper más simple que se ajuste:

WrapperCaso de uso
@StateTipos de valor locales a la vista (toggles, campos de formulario, presentación de hojas)
@BindingReferencia bidireccional al @State del padre
class con @Observable + @StateModelo propio con múltiples propiedades
class con @Observable (sin wrapper)Referencia de solo lectura pasada desde el padre
@BindableEnlace bidireccional a una propiedad de un @Observable
@EnvironmentDependencias compartidas inyectadas mediante .environment()

ViewModel con @Observable

Usa @Observable (no ObservableObject): rastrea cambios a nivel de propiedad, por lo que SwiftUI solo vuelve a renderizar las vistas que leen la propiedad modificada:

@Observable
final class ItemListViewModel {
    private(set) var items: [Item] = []
    private(set) var isLoading = false
    var searchText = ""

    private let repository: any ItemRepository

    init(repository: any ItemRepository = DefaultItemRepository()) {
        self.repository = repository
    }

    func load() async {
        isLoading = true
        defer { isLoading = false }
        items = (try? await repository.fetchAll()) ?? []
    }
}

Vista que consume el ViewModel

struct ItemListView: View {
    @State private var viewModel: ItemListViewModel

    init(viewModel: ItemListViewModel = ItemListViewModel()) {
        _viewModel = State(initialValue: viewModel)
    }

    var body: some View {
        List(viewModel.items) { item in
            ItemRow(item: item)
        }
        .searchable(text: $viewModel.searchText)
        .overlay { if viewModel.isLoading { ProgressView() } }
        .task { await viewModel.load() }
    }
}

Inyección mediante Environment

Reemplaza @EnvironmentObject por @Environment:

// Inyectar
ContentView()
    .environment(authManager)

// Consumir
struct ProfileView: View {
    @Environment(AuthManager.self) private var auth

    var body: some View {
        Text(auth.currentUser?.name ?? "Invitado")
    }
}

Composición de Vistas

Extraer subvistas para limitar la invalidación

Divide las vistas en structs pequeñas y enfocadas. Cuando el estado cambia, solo la subvista que lee ese estado se vuelve a renderizar:

struct OrderView: View {
    @State private var viewModel = OrderViewModel()

    var body: some View {
        VStack {
            OrderHeader(title: viewModel.title)
            OrderItemList(items: viewModel.items)
            OrderTotal(total: viewModel.total)
        }
    }
}

ViewModifier para estilos reutilizables

struct CardModifier: ViewModifier {
    func body(content: Content) -> some View {
        content
            .padding()
            .background(.regularMaterial)
            .clipShape(RoundedRectangle(cornerRadius: 12))
    }
}

extension View {
    func cardStyle() -> some View {
        modifier(CardModifier())
    }
}

Navegación

NavigationStack con tipos seguros

Usa NavigationStack con NavigationPath para enrutamiento programático y type-safe:

@Observable
final class Router {
    var path = NavigationPath()

    func navigate(to destination: Destination) {
        path.append(destination)
    }

    func popToRoot() {
        path = NavigationPath()
    }
}

enum Destination: Hashable {
    case detail(Item.ID)
    case settings
    case profile(User.ID)
}

struct RootView: View {
    @State private var router = Router()

    var body: some View {
        NavigationStack(path: $router.path) {
            HomeView()
                .navigationDestination(for: Destination.self) { dest in
                    switch dest {
                    case .detail(let id): ItemDetailView(itemID: id)
                    case .settings: SettingsView()
                    case .profile(let id): ProfileView(userID: id)
                    }
                }
        }
        .environment(router)
    }
}

Rendimiento

Usar contenedores perezosos para colecciones grandes

LazyVStack y LazyHStack crean vistas solo cuando son visibles:

ScrollView {
    LazyVStack(spacing: 8) {
        ForEach(items) { item in
            ItemRow(item: item)
        }
    }
}

Identificadores estables

Usa siempre identificadores estables y únicos en ForEach; evita usar índices de arreglos:

// Usar conformidad a Identifiable o id explícito
ForEach(items, id: \.stableID) { item in
    ItemRow(item: item)
}

Evitar trabajo costoso en body

  • Nunca realices I/O, llamadas de red o cálculos pesados dentro de body
  • Usa .task {} para trabajo asíncrono; se cancela automáticamente cuando la vista desaparece
  • Usa .sensoryFeedback() y .geometryGroup() con moderación en scroll views
  • Minimiza .shadow(), .blur() y .mask() en listas: provocan renderizado fuera de pantalla

Conformidad Equatable

Para vistas con cuerpos costosos, conforma a Equatable para evitar renderizados innecesarios:

struct ExpensiveChartView: View, Equatable {
    let dataPoints: [DataPoint] // DataPoint debe conformar a Equatable

    static func == (lhs: Self, rhs: Self) -> Bool {
        lhs.dataPoints == rhs.dataPoints
    }

    var body: some View {
        // Renderizado complejo de gráfico
    }
}

Previews

Usa la macro #Preview con datos mock en línea para iteración rápida:

#Preview("Estado vacío") {
    ItemListView(viewModel: ItemListViewModel(repository: EmptyMockRepository()))
}

#Preview("Cargado") {
    ItemListView(viewModel: ItemListViewModel(repository: PopulatedMockRepository()))
}

Anti-patrones a evitar

  • Usar ObservableObject / @Published / @StateObject / @EnvironmentObject en código nuevo — migrar a @Observable
  • Poner trabajo asíncrono directamente en body o init — usar .task {} o métodos de carga explícitos
  • Crear view models como @State dentro de vistas hijas que no poseen los datos — pasarlos desde el padre
  • Usar AnyView para borrado de tipos — preferir @ViewBuilder o Group para vistas condicionales
  • Ignorar los requisitos de Sendable al pasar datos a/desde actores

Referencias

Ver skill: swift-actor-persistence para patrones de persistencia basados en actores. Ver skill: swift-protocol-di-testing para DI basada en protocolos y pruebas con Swift Testing.

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

ComeOnOliver/skillshub

Create stunning, animation-rich HTML presentations from scratch or by converting PowerPoint files. Use when the user wants to build a presentation, convert a PPT/PPTX to web, or create slides for a talk/pitch. Helps non-designers discover their aesthetic through visual exploration rather than abstract choices.

ComeOnOliver/skillshub

Next.js 16+ 和 Turbopack — 增量打包、文件系统缓存、开发速度,以及何时使用 Turbopack 与 webpack。

ComeOnOliver/skillshub

See, Understand, Act on video and audio. See- ingest from local files, URLs, RTSP/live feeds, or live record desktop; return realtime context and playable stream links. Understand- extract frames, build visual/semantic/temporal indexes, and search moments with timestamps and auto-clips. Act- transcode and normalize (codec, fps, resolution, aspect ratio), perform timeline edits (subtitles, text/image overlays, branding, audio overlays, dubbing, translation), generate media assets (image, audio, video), and create real time alerts for events from live streams or desktop capture.

ComeOnOliver/skillshub

AI-assisted video editing workflows for cutting, structuring, and augmenting real footage. Covers the full pipeline from raw capture through FFmpeg, Remotion, ElevenLabs, fal.ai, and final polish in Descript or CapCut. Use when the user wants to edit video, cut footage, create vlogs, or build video content.

ComeOnOliver/skillshub

Next.js 15 애플리케이션을 위한 프론트엔드 개발 가이드라인. React 19, TypeScript, Shadcn/ui, Tailwind CSS를 사용한 모던 패턴. Server Components, Client Components, App Router, 파일 구조, Shadcn/ui 컴포넌트, 성능 최적화, TypeScript 모범 사례 포함. 컴포넌트, 페이지, 기능 생성, 데이터 페칭, 스타일링, 라우팅, 프론트엔드 코드 작업 시 사용.

ComeOnOliver/skillshub

Provides Tamagui patterns for config v4, compiler optimization, styled context, and cross-platform styling. Must use when working with Tamagui projects (tamagui.config.ts, @tamagui imports).

ComeOnOliver/skillshub

Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.

ComeOnOliver/skillshub

Create high-converting, visually distinctive landing pages. Use when building marketing pages, product launches, SaaS homepages, or any single-page conversion-focused website. Guides section-by-section composition with anti-AI-slop principles.

ComeOnOliver/skillshub

Auto-loaded context for Portfolio Buddy 2 development. Use for ANY task involving: React 19 development, TypeScript, portfolio analysis features, metrics calculations, trading strategy comparison, or working with the Portfolio Buddy 2 codebase. Contains tech stack, known issues, and architectural constraints.

ComeOnOliver/skillshub

Next.js development tooling via MCP. Inspect routes, components, build info, and debug Next.js apps. Use when working on Next.js applications, debugging routing, or inspecting app structure. NOT for general React or non-Next.js projects.

ComeOnOliver/skillshub

Implement UI using Shadcn MCP (atoms/theme) and 21st.dev MCP (complex sections). Use when adding buttons, layouts, or generating landing pages.

ComeOnOliver/skillshub

A conceptual skill for building an API client in Next.js that handles JWT tokens

ComeOnOliver/skillshub

Best practices and patterns for Next.js App Router, Server Actions, and Routing in this project.

ComeOnOliver/skillshub

The Design System, Theme, and UX rules for the Physical AI Hub.

ComeOnOliver/skillshub

Comprehensive frontend development skill for building modern, performant web applications using ReactJS, NextJS, TypeScript, Tailwind CSS. Includes component scaffolding, performance optimization, bundle analysis, and UI best practices. Use when developing frontend features, optimizing performance, implementing UI/UX designs, managing state, or reviewing frontend code.

ComeOnOliver/skillshub

This document captures learnings from fixing keyboard navigation issues when floating components (Select, DropdownMenu, Popover) have CSS open/close animations.

ComeOnOliver/skillshub

Build Next.js 16 applications with correct patterns and distinctive design. Use when creating pages, layouts, dynamic routes, upgrading from Next.js 15, or implementing proxy.ts. Covers breaking changes (async params/searchParams, Turbopack, cacheComponents) and frontend aesthetics. NOT when building non-React or backend-only applications.

ComeOnOliver/skillshub

Comprehensive Framer Motion animation library for React. Covers motion components, variants, gestures, page transitions, and scroll animations. Use when adding animations to React/Next.js applications.

ComeOnOliver/skillshub

Next.js 16+ uses App Router with Server Components by default. Client Components are only used when interactivity is needed (hooks, event handlers, browser APIs).

ComeOnOliver/skillshub

Build interfaces that resonate, not just render. This skill enforces bold, intentional

Skills relacionados