Communitygithub.com

ComeOnOliver/skillshub

À utiliser pour implémenter des animations SwiftUI, comprendre VectorArithmetic, utiliser la macro @Animatable, les transitions de zoom, le pont d'animation UIKit/AppKit, choisir entre les animations ressort et courbes temporelles ou déboguer le comportement des animations – référence complète sur les animations d'iOS 13 à iOS 26.

Qu'est-ce que skillshub ?

Ce skill est un guide complet et détaillé sur le système d'animation de SwiftUI, couvrant des concepts fondamentaux comme le protocole VectorArithmetic et l'interpolation jusqu'aux fonctionnalités avancées spécifiques aux versions récentes d'iOS (comme la macro @Animatable introduite avec iOS 26). Il explique clairement pourquoi certains types comme Int ne peuvent pas être animés et comment contourner cette limitation. Le contenu est structuré en plusieurs parties : d'abord les bases de l'interpolation et du protocole Animatable, puis l'utilisation de la macro @Animatable qui réduit considérablement le code boilerplate, suivi des différents types d'animations (courbes temporelles, ressorts, animations d'ordre supérieur), et enfin le système de transactions avec withAnimation et le modificateur animation(). Le skill détaille également les techniques avancées comme les animations scopées (iOS 17+), les transitions de zoom (iOS 18+), le protocole CustomAnimation, et les bonnes pratiques pour optimiser les performances en réservant les conformances Animatable personnalisées aux cas où les modificateurs intégrés ne suffisent pas. Il fournit de nombreux exemples de code concrets, des comparaisons avant/après pour la macro @Animatable, et des conseils pour choisir entre les animations ressort (recommandées depuis iOS 17) et les animations par courbes temporelles. Les plateformes supportées sont iOS 13+ pour les bases, avec des fonctionnalités supplémentaires disponibles à partir d'iOS 17, 18 et 26.

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/ComeOnOliver/skillshub/tree/HEAD/skills/CharlesWiltgen/Axiom/axiom-swiftui-animation-ref

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Animation SwiftUI

Aperçu

Guide complet du système d'animation de SwiftUI, des concepts fondamentaux aux techniques avancées. Ce skill couvre le protocole Animatable, la macro @Animatable (iOS 26), les types d'animations et le système de Transaction.

Principe fondamental : L'animation dans SwiftUI est une interpolation mathématique dans le temps, alimentée par le protocole VectorArithmetic. Comprendre cette fondation déverrouille toute la puissance du système d'animation déclaratif de SwiftUI.

Configuration système requise

  • iOS 13+ : Protocole Animatable, animations temporelles/ressort
  • iOS 17+ : Animations ressort par défaut, animations scopées, PhaseAnimator, KeyframeAnimator
  • iOS 18+ : Transitions de zoom, pont d'animation UIKit/AppKit
  • iOS 26+ : Macro @Animatable

Partie 1 : Comprendre l'Animation

Qu'est-ce que l'Interpolation

L'animation est le processus de génération de valeurs intermédiaires entre un état de départ et un état d'arrivée.

Exemple : Animation d'opacité

.opacity(0) → .opacity(1)

Pendant que cette animation s'exécute, SwiftUI calcule des valeurs intermédiaires :

0.0 → 0.02 → 0.05 → 0.1 → 0.25 → 0.4 → 0.6 → 0.8 → 1.0

Comment les valeurs sont distribuées

  • Déterminé par la courbe temporelle ou la fonction de vélocité de l'animation
  • Les animations ressort utilisent une simulation physique
  • Les courbes temporelles utilisent des courbes de Bézier
  • Chaque type d'animation calcule les valeurs différemment

Protocole VectorArithmetic

SwiftUI exige que les données animées soient conformes à VectorArithmetic — fournissant la soustraction, la mise à l'échelle, l'addition et une valeur nulle. Cela permet à SwiftUI d'interpoler entre deux valeurs quelconques.

Types conformes intégrés : CGFloat, Double, Float, Angle (1D), CGPoint, CGSize (2D), CGRect (4D).

Point clé : L'arithmétique vectorielle fait abstraction de la dimensionnalité. SwiftUI anime tous ces types avec une seule implémentation générique.

Pourquoi Int ne peut pas être animé

Int n'est pas conforme à VectorArithmetic — il n'existe pas d'intermédiaires fractionnaires entre 3 et 4. SwiftUI change simplement la valeur brusquement.

Solution : Utilisez Float/Double et affichez comme Int :

@State private var count: Float = 0
// ...
Text("\(Int(count))")
    .animation(.spring, value: count)

Valeurs de Modèle vs de Présentation

Les attributs animables ont conceptuellement deux valeurs :

Valeur de Modèle

  • La valeur cible définie par votre code
  • Mise à jour immédiatement lorsque l'état change
  • Ce que vous écrivez dans le corps de votre vue

Valeur de Présentation

  • La valeur interpolée actuelle en cours de rendu
  • Mise à jour image par image pendant l'animation
  • Ce que l'utilisateur voit réellement

Exemple

.scaleEffect(selected ? 1.5 : 1.0)

Lorsque selected devient true :

  • Valeur de modèle : devient immédiatement 1.5
  • Valeur de présentation : interpole 1.0 → 1.1 → 1.2 → 1.3 → 1.4 → 1.5 au fil du temps

Partie 2 : Protocole Animatable

Aperçu

Le protocole Animatable permet aux vues d'animer leurs propriétés en définissant quelles données doivent être interpolées.

protocol Animatable {
    associatedtype AnimatableData: VectorArithmetic

    var animatableData: AnimatableData { get set }
}

SwiftUI crée un attribut animable pour toute vue conforme à ce protocole.

Vues Animables Intégrées

De nombreux modificateurs SwiftUI sont conformes à Animatable :

Effets visuels

  • .scaleEffect() — Anime la transformation d'échelle
  • .rotationEffect() — Anime la rotation
  • .offset() — Anime le décalage de position
  • .opacity() — Anime la transparence
  • .blur() — Anime le rayon de flou
  • .shadow() — Anime les propriétés d'ombre

Tous les types Shape

  • Circle, Rectangle, RoundedRectangle
  • Capsule, Ellipse, Path
  • Implémentations personnalisées de Shape

AnimatablePair pour les Données Multidimensionnelles

Lors de l'animation de plusieurs propriétés, utilisez AnimatablePair pour combiner des vecteurs. Par exemple, scaleEffect combine CGSize (2D) et UnitPoint (2D) en un vecteur 4D via AnimatablePair<CGSize.AnimatableData, UnitPoint.AnimatableData>. Accédez aux composants via .first et .second. La macro @Animatable (iOS 26+) élimine complètement ce code répétitif.

Conformité Animatable Personnalisée

Quand l'utiliser

  • Animer une mise en page personnalisée (comme RadialLayout)
  • Animer du code de dessin personnalisé
  • Animer des propriétés qui affectent les chemins de forme

Exemple : Vue de nombre animée

struct AnimatableNumberView: View, Animatable {
    var number: Double

    var animatableData: Double {
        get { number }
        set { number = newValue }
    }

    var body: some View {
        Text("\(Int(number))")
            .font(.largeTitle)
    }
}

// Utilisation
AnimatableNumberView(number: value)
    .animation(.spring, value: value)

Comment ça fonctionne

  1. number passe de 0 à 100
  2. SwiftUI appelle body pour chaque image de l'animation
  3. Chaque image reçoit une nouvelle valeur number : 0 → 5 → 15 → 30 → 55 → 80 → 100
  4. Le texte se met à jour pour afficher l'entier interpolé

Avertissement sur les Performances

La conformité Animatable personnalisée est coûteuse — SwiftUI appelle body pour chaque image sur le thread principal. Les effets intégrés (.scaleEffect(), .opacity()) s'exécutent hors du thread principal et n'appellent pas body. Utilisez la conformité personnalisée uniquement lorsque les modificateurs intégrés ne peuvent pas réaliser l'effet (par exemple, animer une Layout personnalisée qui repositionne les sous-vues image par image).


Partie 3 : Macro @Animatable (iOS 26+)

Aperçu

La macro @Animatable élimine le code répétitif lié à la conformité manuelle au protocole Animatable.

Avant iOS 26, vous deviez :

  1. Être manuellement conforme à Animatable
  2. Écrire le getter et le setter de animatableData
  3. Utiliser AnimatablePair pour plusieurs propriétés
  4. Exclure manuellement les propriétés non animables

iOS 26+, il suffit d'ajouter @Animatable :

@MainActor
@Animatable
struct MyView: View {
    var scale: CGFloat
    var opacity: Double

    var body: some View {
        // ...
    }
}

La macro automatiquement :

  • Génère la conformité Animatable
  • Inspecte toutes les propriétés stockées
  • Crée animatableData à partir des propriétés conformes à VectorArithmetic
  • Gère les données multidimensionnelles avec AnimatablePair

Comparaison Avant/Après

Avant la macro @Animatable

struct HikingRouteShape: Shape {
    var startPoint: CGPoint
    var endPoint: CGPoint
    var elevation: Double
    var drawingDirection: Bool // On ne veut pas animer ceci

    // Déclaration manuelle fastidieuse de animatableData
    var animatableData: AnimatablePair<AnimatablePair<CGFloat, CGFloat>,
                        AnimatablePair<Double, AnimatablePair<CGFloat, CGFloat>>> {
        get {
            AnimatablePair(
                AnimatablePair(startPoint.x, startPoint.y),
                AnimatablePair(elevation, AnimatablePair(endPoint.x, endPoint.y))
            )
        }
        set {
            startPoint = CGPoint(x: newValue.first.first, y: newValue.first.second)
            elevation = newValue.second.first
            endPoint = CGPoint(x: newValue.second.second.first, y: newValue.second.second.second)
        }
    }

    func path(in rect: CGRect) -> Path {
        // Code de dessin
    }
}

Après la macro @Animatable

@Animatable
struct HikingRouteShape: Shape {
    var startPoint: CGPoint
    var endPoint: CGPoint
    var elevation: Double

    @AnimatableIgnored
    var drawingDirection: Bool // Exclu de l'animation

    func path(in rect: CGRect) -> Path {
        // Code de dessin
    }
}

Lignes de code : 20 → 12 (réduction de 40%)

@AnimatableIgnored

Utilisez @AnimatableIgnored pour exclure des propriétés de l'animation.

Quand l'utiliser

  • Valeurs de débogage — Indicateurs réservés au développement
  • Identifiants — Identifiants qui ne doivent pas être animés
  • Horodatages — Quand la vue a été créée/mise à jour
  • État interne — Comptabilité non visuelle
  • Types non VectorArithmetic — Couleurs, chaînes, booléens

Exemple

@MainActor
@Animatable
struct ProgressView: View {
    var progress: Double // Animé
    var totalItems: Int // Animé (si Float, pas si Int)

    @AnimatableIgnored
    var title: String // Non animé

    @AnimatableIgnored
    var startTime: Date // Non animé

    @AnimatableIgnored
    var debugEnabled: Bool // Non animé

    var body: some View {
        VStack {
            Text(title)
            ProgressBar(value: progress)
            if debugEnabled {
                Text("Démarré : \(startTime.formatted())")
            }
        }
    }
}

Cas d'Utilisation Réel

@Animatable fonctionne pour tout affichage numérique — prix d'actions, fréquence cardiaque, scores, minuteurs, barres de progression :

@MainActor
@Animatable
struct AnimatedValueView: View {
    var value: Double
    var changePercent: Double

    @AnimatableIgnored
    var label: String

    var body: some View {
        VStack(alignment: .trailing) {
            Text("\(value, format: .number.precision(.fractionLength(2)))")
                .font(.title)
            Text("\(changePercent > 0 ? "+" : "")\(changePercent, format: .percent)")
                .foregroundStyle(changePercent > 0 ? .green : .red)
        }
    }
}

// Utilisation
AnimatedValueView(value: currentPrice, changePercent: 0.025, label: "Price")
    .animation(.spring(duration: 0.8), value: currentPrice)

Partie 4 : Types d'Animation

Animations par Courbes Temporelles

Les animations par courbes temporelles utilisent des courbes de Bézier pour contrôler la vitesse de l'animation dans le temps.

Préréglages intégrés

.animation(.linear)          // Vitesse constante
.animation(.easeIn)          // Commence lentement, finit vite
.animation(.easeOut)         // Commence vite, finit lentement
.animation(.easeInOut)       // Début et fin lents, milieu rapide

Courbes temporelles personnalisées

let customCurve = UnitCurve(
    startControlPoint: CGPoint(x: 0.2, y: 0),
    endControlPoint: CGPoint(x: 0.8, y: 1)
)

.animation(.timingCurve(customCurve, duration: 0.5))

Durée

Toutes les animations par courbes temporelles acceptent une durée optionnelle :

.animation(.easeInOut(duration: 0.3))
.animation(.linear(duration: 1.0))

Par défaut : 0,35 seconde

Animations Ressort

Les animations ressort utilisent une simulation physique pour créer un mouvement naturel et organique.

Préréglages intégrés

.animation(.smooth)     // Pas de rebond (par défaut depuis iOS 17)
.animation(.snappy)     // Petite quantité de rebond
.animation(.bouncy)     // Plus grande quantité de rebond

Ressorts personnalisés

.animation(.spring(duration: 0.6, bounce: 0.3))

Paramètres

  • duration — Durée perçue de l'animation
  • bounce — Quantité de rebond (0 = pas de rebond, 1 = très rebondissant)

Beaucoup plus intuitif que les paramètres de ressort traditionnels (masse, rigidité, amortissement).

Animations d'Ordre Supérieur

Modifiez les animations de base pour créer des effets complexes.

Délai

.animation(.spring.delay(0.5))

Attend 0,5 seconde avant de démarrer l'animation.

Répétition

.animation(.easeInOut.repeatCount(3, autoreverses: true))
.animation(.linear.repeatForever(autoreverses: false))

Répète l'animation plusieurs fois ou indéfiniment.

Vitesse

.animation(.spring.speed(2.0))  // 2x plus rapide
.animation(.spring.speed(0.5))  // 2x plus lent

Multiplie la vitesse de l'animation.

Changements d'Animation par Défaut (iOS 17+)

Avant iOS 17

withAnimation {
    // Utilisait une courbe temporelle par défaut
}

iOS 17+

withAnimation {
    // Utilise le ressort .smooth par défaut
}

Pourquoi ce changement : Les animations ressort semblent plus naturelles et préservent la vélocité lorsqu'elles sont interrompues.

Recommandation : Adoptez les ressorts. Ils rendent votre interface plus réactive et soignée.


Partie 5 : Système de Transaction

withAnimation

La façon la plus courante de déclencher une animation.

Button("Agrandir") {
    withAnimation(.spring) {
        scale = 1.5
    }
}

Comment ça fonctionne

  1. withAnimation ouvre une transaction
  2. Définit l'animation dans le dictionnaire de la transaction
  3. Exécute la fermeture (changements d'état)
  4. La transaction se propage dans la hiérarchie des vues
  5. Les attributs animables vérifient l'animation et interpole

Animation explicite

withAnimation(.spring(duration: 0.6, bounce: 0.4)) {
    isExpanded.toggle()
}

Pas d'animation

withAnimation(nil) {
    // Les changements se produisent immédiatement, pas d'animation
    resetState()
}

Modificateur animation() de Vue

Appliquez des animations à des valeurs spécifiques dans une vue.

Utilisation de base

Circle()
    .fill(isActive ? .blue : .gray)
    .animation(.spring, value: isActive)

Comment ça fonctionne : L'animation ne s'applique que lorsque isActive change. Les autres changements d'état ne déclencheront pas cette animation.

Plusieurs animations sur la même vue

Circle()
    .scaleEffect(scale)
    .animation(.bouncy, value: scale)
    .opacity(opacity)
    .animation(.easeInOut, value: opacity)

Différentes animations pour différentes propriétés.

Animations Scopées (iOS 17+)

Limitez étroitement les animations à des attributs animables spécifiques.

Problème avec l'ancienne approche

struct AvatarView: View {
    var selected: Bool

    var body: some View {
        Image("avatar")
            .scaleEffect(selected ? 1.5 : 1.0)
            .animation(.spring, value: selected)
            // ⚠️ Si l'image change aussi lorsque selected change,
            //    la transition d'image est également animée (accidentellement)
    }
}

Solution : Animation scopée

struct AvatarView: View {
    var selected: Bool

    var body: some View {
        Image("avatar")
            .animation(.spring, value: selected) {
                $0.scaleEffect(selected ? 1.5 : 1.0)
            }
            // ✅ Seul scaleEffect est animé, la transition d'image ne l'est pas
    }
}

Comment ça fonctionne

  • L'animation ne s'applique qu'aux attributs dans la fermeture
  • Les autres attributs ne sont pas affectés
  • Empêche les animations accidentelles

Clés de Transaction Personnalisées

Définissez des types TransactionKey personnalisés pour propager le contexte à travers le système de transaction. Utilisez withTransaction pour définir des valeurs et le modificateur .transaction pour les lire. Cela permet d'appliquer différentes animations selon la façon dont un changement d'état a été déclenché (tap vs programmatique).


Partie 6 : Sujets Avancés

Protocole CustomAnimation

Impl

... (le texte original a été tronqué, merci de fournir le contenu complet si vous souhaitez que je continue la traduction)

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

SwiftUI architecture patterns, state management with @Observable, view composition, navigation, performance optimization, and modern iOS/macOS UI best practices.

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

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

Skills associés