Communitygithub.com

IGTA-Tech/claude-skills-research

Utilisez-la pour implémenter des animations SwiftUI, comprendre VectorArithmetic, utiliser la macro @Animatable, choisir entre animations spring et timing curve, ou déboguer le comportement des animations – référence complète sur les animations d'iOS 13 à iOS 26.

Qu'est-ce que claude-skills-research ?

Cette compétence est un guide complet du système d'animation SwiftUI, couvrant les concepts fondamentaux (interpolation, protocole VectorArithmetic) jusqu'aux techniques avancées comme la macro @Animatable d'iOS 26. Elle explique pourquoi certains types de données (comme Int) ne peuvent pas être animés et comment utiliser Float/Double à la place. La compétence détaille le protocole Animatable, la conformité personnalisée avec AnimatablePair pour les données multidimensionnelles, et la macro @Animatable qui réduit le code boilerplate de 40%. Elle inclut des exemples concrets pour les applications fintech, santé, jeux et productivité, ainsi que des conseils de performance et des cas d'utilisation réels. Supporte iOS 13+ pour Animatable, iOS 17+ pour les animations spring par défaut, et iOS 26+ pour la macro @Animatable.

Compatible avec✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/IGTA-Tech/claude-skills-research/tree/HEAD/Axiom/.claude-plugin/plugins/axiom/skills/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. Cette compétence couvre le protocole Animatable, la macro @Animatable d'iOS 26, les types d'animations et le système Transaction.

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

Quand utiliser cette compétence

  • Implémenter des vues ou formes animées personnalisées
  • Comprendre pourquoi une propriété ne s'anime pas (Int vs Float/Double)
  • Choisir entre animations spring et timing curve
  • Utiliser la macro @Animatable (iOS 26+)
  • Conformer des vues au protocole Animatable
  • Déboguer le comportement de fusion des animations
  • Optimiser les performances des animations
  • Créer des animations complexes ou multi-étapes
  • Comprendre les valeurs modèle vs présentation
  • Implémenter des algorithmes d'animation personnalisés

Configuration système requise

iOS 13+ pour le protocole Animatable

iOS 17+ pour les animations spring par défaut, animations limitées

iOS 26+ pour la 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 l'exécution de cette animation, 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 de timing ou la fonction de vélocité de l'animation
  • Les animations spring utilisent une simulation physique
  • Les courbes de timing 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, qui fournit :

protocol VectorArithmetic {
    // Calculer la différence entre deux valeurs
    static func - (lhs: Self, rhs: Self) -> Self

    // Mettre à l'échelle les valeurs
    static func * (lhs: Self, rhs: Double) -> Self

    // Additionner les valeurs
    static func + (lhs: Self, rhs: Self) -> Self

    // Valeur zéro
    static var zero: Self { get }
}

Types conformes intégrés

  • 1 dimension : CGFloat, Double, Float, Angle
  • 2 dimensions : CGPoint, CGSize
  • 4 dimensions : CGRect

Point clé L'arithmétique vectorielle abstrait la dimensionnalité des données animées. SwiftUI peut animer tous ces types avec une seule implémentation générique.

Pourquoi Int ne peut pas être animé

Int n'est pas conforme à VectorArithmetic car :

  1. Pas de valeurs intermédiaires fractionnaires — Il n'y a pas de « 3,5 » entre 3 et 4
  2. Pas continu — Les entiers sont des valeurs discrètes
  3. La mise à l'échelle n'a pas de sens — Que signifie 5 × 0,5 pour un entier ?

Ce qui se passe quand on essaie

struct CounterView: View {
    @State private var count: Int = 0

    var body: some View {
        Text("\(count)")
            .animation(.spring, value: count)
    }
}

Résultat : SwiftUI remplace simplement l'ancien texte par le nouveau. Aucune interpolation n'a lieu.

Solution : Utiliser Float ou Double

struct AnimatedCounterView: View {
    @State private var count: Float = 0

    var body: some View {
        Text("\(Int(count))")
            .animation(.spring, value: count)
    }
}

Résultat : SwiftUI interpole 0.0 → ... → 100.0, et vous affichez l'entier arrondi à chaque frame.

Valeurs modèle vs présentation

Les attributs animables ont conceptuellement deux valeurs :

Valeur modèle

  • La valeur cible définie par votre code
  • Mise à jour immédiatement lors du changement d'état
  • 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)

Quand selected devient true :

  • Valeur modèle : Devient immédiatement 1.5
  • Valeur de présentation : Interpole 1.0 → 1.1 → 1.2 → 1.3 → 1.4 → 1.5 dans le 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 de forme

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

AnimatablePair pour les données multidimensionnelles

Pour animer plusieurs propriétés, utilisez AnimatablePair pour combiner des vecteurs.

Exemple : Implémentation de scaleEffect

struct ScaleEffectModifier: ViewModifier, Animatable {
    var scale: CGSize
    var anchor: UnitPoint

    // Combiner deux vecteurs 2D en un vecteur 4D
    var animatableData: AnimatablePair<CGSize.AnimatableData, UnitPoint.AnimatableData> {
        get {
            AnimatablePair(scale.animatableData, anchor.animatableData)
        }
        set {
            scale.animatableData = newValue.first
            anchor.animatableData = newValue.second
        }
    }

    func body(content: Content) -> some View {
        content.scaleEffect(scale, anchor: anchor)
    }
}

Comment ça marche

  • CGSize est à 2 dimensions (largeur, hauteur)
  • UnitPoint est à 2 dimensions (x, y)
  • AnimatablePair les fusionne en un vecteur à 4 dimensions
  • SwiftUI interpole les 4 valeurs ensemble

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 formes

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 marche

  1. number passe de 0 à 100
  2. SwiftUI appelle body pour chaque image de l'animation
  3. Chaque image reçoit une nouvelle valeur de 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 peut être coûteuse.

Quand vous conformez une vue à Animatable :

  • SwiftUI appelle le body de votre vue pour chaque image de l'animation
  • La mise en page est recalculée à chaque image
  • Cela se produit sur le thread principal

Les effets animables intégrés (comme .scaleEffect(), .opacity()) sont beaucoup plus efficaces :

  • Ils s'exécutent hors du thread principal
  • Ils n'appellent pas le body de votre vue
  • Ils mettent à jour uniquement la couche de rendu

Recommandation

  • Utilisez les effets intégrés autant que possible
  • N'utilisez la conformité Animatable personnalisée que si vous ne pouvez pas obtenir l'effet avec les modificateurs intégrés
  • Profilez avec Instruments si vous avez des problèmes de performances

Exemple : Animation de mise en page circulaire

// Ceci est coûteux mais nécessaire pour animer le long d'un chemin circulaire
@Animatable
struct RadialLayout: Layout {
    var offsetAngle: Angle

    var animatableData: Angle.AnimatableData {
        get { offsetAngle.animatableData }
        set { offsetAngle.animatableData = newValue }
    }

    func sizeThatFits(proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) -> CGSize {
        proposal.replacingUnspecifiedDimensions()
    }

    func placeSubviews(in bounds: CGRect, proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) {
        let radius = min(bounds.width, bounds.height) / 2
        let center = CGPoint(x: bounds.midX, y: bounds.midY)
        let angleStep = Angle.degrees(360.0 / Double(subviews.count))

        for (index, subview) in subviews.enumerated() {
            let angle = offsetAngle + angleStep * Double(index)
            let x = center.x + radius * cos(angle.radians)
            let y = center.y + radius * sin(angle.radians)

            subview.place(at: CGPoint(x: x, y: y), anchor: .center, proposal: .unspecified)
        }
    }
}

Pourquoi nécessaire : Animer offsetAngle nécessite de recalculer les positions à chaque image. Aucun modificateur intégré ne peut le faire.


Partie 3 : Macro @Animatable (iOS 26+)

Aperçu

La macro @Animatable élimine le code boilerplate nécessaire pour se conformer manuellement au protocole Animatable.

Avant iOS 26, vous deviez :

  1. Vous conformer manuellement à 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 — Drapeaux pour le développement uniquement
  • IDs — 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 // Pas animé

    @AnimatableIgnored
    var startTime: Date // Pas animé

    @AnimatableIgnored
    var debugEnabled: Bool // Pas animé

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

Cas d'utilisation concrets

Les animations numériques sont extrêmement courantes dans toutes les catégories d'applications :

Applications Fintech

@MainActor
@Animatable
struct StockPriceView: View {
    var price: Double
    var changePercent: Double

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

Cas d'usage : Animer les variations de prix d'actions, la valeur du portefeuille, les transitions de solde de compte

Santé et forme physique

@MainActor
@Animatable
struct HeartRateView: View {
    var bpm: Double

    @AnimatableIgnored
    var timestamp: Date

    var body: some View {
        VStack {
            Text("\(Int(bpm))")
                .font(.system(size: 60, weight: .bold))
            Text("BPM")
                .font(.caption)
                .foregroundColor(.secondary)
        }
    }
}

Cas d'usage : Indicateurs de fréquence cardiaque, compteurs de pas, calculs de calories, distance parcourue

Jeux

@MainActor
@Animatable
struct ScoreView: View {
    var score: Float
    var multiplier: Float

    var body: some View {
        HStack {
            Text("\(Int(score))")
                .font(.largeTitle)
            Text("×\(multiplier, format: .number.precision(.fractionLength(1)))")
                .font(.title2)
                .foregroundColor(.orange)
        }
    }
}

Cas d'usage : Animations de score, transitions XP, progression de niveau, multiplicateurs de combo

Applications de productivité

@MainActor
@Animatable
struct TimerView: View {
    var remainingSeconds: Double

    

…

[La suite du contenu original est tronquée dans la demande de traduction.]

Individual skills in this repo

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

IGTA-Tech/claude-skills-research

Use when localizing apps, using String Catalogs, generating type-safe symbols (Xcode 26+), handling plurals, RTL layouts, locale-aware formatting, or migrating from .strings files - comprehensive i18n patterns for Xcode 15-26

IGTA-Tech/claude-skills-research

Use when CAAnimation completion handler doesn't fire, spring physics look wrong on device, animation duration mismatches actual time, gesture + animation interaction causes jank, or timing differs between simulator and real hardware - systematic CAAnimation diagnosis with CATransaction patterns, frame rate awareness, and device-specific behavior

IGTA-Tech/claude-skills-research

This skill should be used when comparing two videos to analyze compression results or quality differences. Generates interactive HTML reports with quality metrics (PSNR, SSIM) and frame-by-frame visual comparisons. Triggers when users mention "compare videos", "video quality", "compression analysis", "before/after compression", or request quality assessment of compressed videos.

IGTA-Tech/claude-skills-research

Download YouTube videos and HLS streams (m3u8) from platforms like Mux, Vimeo, etc. using yt-dlp and ffmpeg. Use this skill when users request downloading videos, extracting audio, handling protected streams with authentication headers, or troubleshooting download issues like nsig extraction failures, 403 errors, or cookie extraction problems.

IGTA-Tech/claude-skills-research

Write high-converting landing page copy using proven frameworks like PAS (Problem-Agitate-Solution), AIDA, and StoryBrand. Creates headlines, value propositions, CTAs, and full page sections optimized for conversion. Use when users need landing page copy, sales page content, or marketing website text.

IGTA-Tech/claude-skills-research

Downloads videos from YouTube and other platforms for offline viewing, editing, or archival. Handles various formats and quality options.

IGTA-Tech/claude-skills-research

Download YouTube video transcripts when user provides a YouTube URL or asks to download/get/fetch a transcript from YouTube. Also use when user wants to transcribe or get captions/subtitles from a YouTube video.

Skills associés