Add support for more animation types (#1280)

* Add support for more animation types

* Add `Symbols` import to generated modifiers file

* Regenerate to combine symbol and text modifier changes

Author: carson-katri

Sources/LiveViewNative/Stylesheets/ParseableTypes/Animation+ParseableModifierValue.swift

@@ -17,14 +17,27 @@ extension Animation: ParseableModifierValue {
                 Base.EaseOut.parser(in: context).map(Base.easeOut)
                 Base.EaseInOut.parser(in: context).map(Base.easeInOut)
                 Base.Linear.parser(in: context).map(Base.linear)
-                ConstantAtomLiteral("spring").map({ Base.spring })
-                ConstantAtomLiteral("interactiveSpring").map({ Base.interactiveSpring })
-                ConstantAtomLiteral("interpolatingSpring").map({ Base.interpolatingSpring })
+                Base.Spring.parser(in: context).map(Base.spring)
+                ConstantAtomLiteral("spring").map({ Base.spring(.init()) })
+                Base.InteractiveSpring.parser(in: context).map(Base.interactiveSpring)
+                ConstantAtomLiteral("interactiveSpring").map({ Base.interactiveSpring(.init()) })
+                Base.InterpolatingSpring.parser(in: context).map(Base.interpolatingSpring)
+                ConstantAtomLiteral("interpolatingSpring").map({ Base.interpolatingSpring(.init()) })
                 Base.TimingCurve.parser(in: context).map(Base.timingCurve)
+                
+                BouncySpring.parser(in: context).map(Base.bouncy)
+                ConstantAtomLiteral("bouncy").map({ Base.bouncy(.init()) })
+                SmoothSpring.parser(in: context).map(Base.smooth)
+                ConstantAtomLiteral("smooth").map({ Base.smooth(.init()) })
+                SnappySpring.parser(in: context).map(Base.snappy)
+                ConstantAtomLiteral("snappy").map({ Base.snappy(.init()) })
             }
         } member: {
             OneOf {
                 Modifier.Delay.parser(in: context).map(Modifier.delay)
+                Modifier.RepeatCount.parser(in: context).map(Modifier.repeatCount)
+                Modifier.RepeatForever.parser(in: context).map(Modifier.repeatForever)
+                Modifier.Speed.parser(in: context).map(Modifier.speed)
             }
         }
         .map { (base: Base, members: [Modifier]) in
@@ -55,14 +68,20 @@ extension Animation: ParseableModifierValue {
                 } else {
                     Self.linear
                 }
-            case .spring:
-                Self.spring
-            case .interactiveSpring:
-                Self.interactiveSpring
-            case .interpolatingSpring:
-                Self.interpolatingSpring
+            case let .spring(spring):
+                spring.value
+            case let .interactiveSpring(interactiveSpring):
+                interactiveSpring.value
+            case let .interpolatingSpring(interpolatingSpring):
+                interpolatingSpring.value
             case let .timingCurve(timingCurve):
                 timingCurve.value
+            case let .bouncy(value):
+                Self.bouncy(duration: value.duration, extraBounce: value.extraBounce)
+            case let .smooth(value):
+                Self.smooth(duration: value.duration, extraBounce: value.extraBounce)
+            case let .snappy(value):
+                Self.snappy(duration: value.duration, extraBounce: value.extraBounce)
             }
             for modifier in members {
                 switch modifier {
@@ -86,10 +105,13 @@ extension Animation: ParseableModifierValue {
         case easeOut(EaseOut)
         case easeInOut(EaseInOut)
         case linear(Linear)
-        case spring
-        case interactiveSpring
-        case interpolatingSpring
+        case spring(Spring)
+        case interactiveSpring(InteractiveSpring)
+        case interpolatingSpring(InterpolatingSpring)
         case timingCurve(TimingCurve)
+        case bouncy(BouncySpring)
+        case smooth(SmoothSpring)
+        case snappy(SnappySpring)
 
         @ParseableExpression
         struct EaseIn {
@@ -135,6 +157,104 @@ extension Animation: ParseableModifierValue {
             }
         }
 
+        @ParseableExpression
+        struct Spring {
+            static let name = "spring"
+            
+            let value: Animation
+            
+            init() {
+                self.value = .spring
+            }
+            
+            @available(iOS 17.0, macOS 14, tvOS 17, watchOS 10, *)
+            init(
+                _ spring: SwiftUI.Spring,
+                blendDuration: Double = 0.0
+            ) {
+                self.value = .spring(spring, blendDuration: blendDuration)
+            }
+            
+            init(
+                duration: Double = 0.5,
+                bounce: Double = 0.0,
+                blendDuration: Double = 0
+            ) {
+                self.value = .spring(duration: duration, bounce: bounce, blendDuration: blendDuration)
+            }
+            
+            init(
+                response: Double = 0.5,
+                dampingFraction: Double = 0.825,
+                blendDuration: TimeInterval = 0
+            ) {
+                self.value = .spring(response: response, dampingFraction: dampingFraction, blendDuration: blendDuration)
+            }
+        }
+        
+        @ParseableExpression
+        struct InteractiveSpring {
+            static let name = "interactiveSpring"
+            
+            let value: Animation
+            
+            init() {
+                self.value = .interactiveSpring
+            }
+            
+            init(
+                response: Double = 0.15,
+                dampingFraction: Double = 0.86,
+                blendDuration: TimeInterval = 0.25
+            ) {
+                self.value = .interactiveSpring(response: response, dampingFraction: dampingFraction, blendDuration: blendDuration)
+            }
+            
+            init(
+                duration: TimeInterval = 0.15,
+                extraBounce: Double = 0.0,
+                blendDuration: TimeInterval = 0.25
+            ) {
+                self.value = .interactiveSpring(duration: duration, extraBounce: extraBounce, blendDuration: blendDuration)
+            }
+        }
+        
+        @ParseableExpression
+        struct InterpolatingSpring {
+            static let name = "interpolatingSpring"
+            
+            let value: Animation
+            
+            init() {
+                self.value = .interpolatingSpring
+            }
+            
+            @available(iOS 17.0, macOS 14, tvOS 17, watchOS 10, *)
+            init(
+                _ spring: SwiftUI.Spring,
+                initialVelocity: Double = 0.0
+            ) {
+                self.value = .interpolatingSpring(spring, initialVelocity: initialVelocity)
+            }
+            
+            init(
+                duration: TimeInterval = 0.5,
+                bounce: Double = 0.0,
+                initialVelocity: Double = 0.0
+            ) {
+                self.value = .interpolatingSpring(duration: duration, bounce: bounce, initialVelocity: initialVelocity)
+            }
+            
+            init(
+                mass: Double = 1.0,
+                stiffness: Double,
+                damping: Double,
+                initialVelocity: Double = 0.0
+            ) {
+                self.value = .interpolatingSpring(mass: mass, stiffness: stiffness, damping: damping, initialVelocity: initialVelocity)
+            }
+        }
+        
         @ParseableExpression
         struct TimingCurve {
             static let name = "timingCurve"
@@ -205,3 +325,108 @@ extension Animation: ParseableModifierValue {
         }
     }
 }
+
+@available(iOS 17.0, macOS 14, tvOS 17, watchOS 10, *)
+extension Spring: ParseableModifierValue {
+    public static func parser(in context: ParseableModifierContext) -> some Parser<Substring.UTF8View, Self> {
+        OneOf {
+            _Spring.parser(in: context).map(\.value)
+            ImplicitStaticMember {
+                OneOf {
+                    BouncySpring.parser(in: context).map({ Self.bouncy(duration: $0.duration, extraBounce: $0.extraBounce) })
+                    ConstantAtomLiteral("bouncy").map({ Self.bouncy })
+                    SmoothSpring.parser(in: context).map({ Self.smooth(duration: $0.duration, extraBounce: $0.extraBounce) })
+                    ConstantAtomLiteral("smooth").map({ Self.smooth })
+                    SnappySpring.parser(in: context).map({ Self.snappy(duration: $0.duration, extraBounce: $0.extraBounce) })
+                    ConstantAtomLiteral("snappy").map({ Self.snappy })
+                }
+            }
+        }
+    }
+    
+    @ParseableExpression
+    struct _Spring {
+        static let name = "Spring"
+        
+        let value: Spring
+        
+        init(
+            duration: Double = 0.5,
+            bounce: Double = 0.0
+        ) {
+            self.value = .init(duration: duration, bounce: bounce)
+        }
+        
+        init(
+            mass: Double = 1.0,
+            stiffness: Double,
+            damping: Double,
+            allowOverDamping: Bool = false
+        ) {
+            self.value = .init(mass: mass, stiffness: stiffness, damping: damping, allowOverDamping: allowOverDamping)
+        }
+        
+        init(
+            response: Double,
+            dampingRatio: Double
+        ) {
+            self.value = .init(response: response, dampingRatio: dampingRatio)
+        }
+        
+        init(
+            settlingDuration: Double,
+            dampingRatio: Double,
+            epsilon: Double = 0.001
+        ) {
+            self.value = .init(settlingDuration: settlingDuration, dampingRatio: dampingRatio, epsilon: epsilon)
+        }
+    }
+}
+
+@ParseableExpression
+struct BouncySpring {
+    static let name = "bouncy"
+    
+    let duration: Double
+    let extraBounce: Double
+    
+    init(
+        duration: Double = 0.5,
+        extraBounce: Double = 0.0
+    ) {
+        self.duration = duration
+        self.extraBounce = extraBounce
+    }
+}
+
+@ParseableExpression
+struct SmoothSpring {
+    static let name = "smooth"
+    
+    let duration: Double
+    let extraBounce: Double
+    
+    init(
+        duration: Double = 0.5,
+        extraBounce: Double = 0.0
+    ) {
+        self.duration = duration
+        self.extraBounce = extraBounce
+    }
+}
+
+@ParseableExpression
+struct SnappySpring {
+    static let name = "snappy"
+    
+    let duration: Double
+    let extraBounce: Double
+    
+    init(
+        duration: Double = 0.5,
+        extraBounce: Double = 0.0
+    ) {
+        self.duration = duration
+        self.extraBounce = extraBounce
+    }
+}

Sources/LiveViewNative/Stylesheets/ParseableTypes/AnySymbolEffect.swift

@@ -10,7 +10,7 @@ import Symbols
 import LiveViewNativeStylesheet
 
 @available(iOS 17.0, macOS 14.0, tvOS 17.0, watchOS 10.0, *)
-struct AnySymbolEffect: SymbolEffect, ContentTransitionSymbolEffect, ParseableModifierValue {
+struct AnySymbolEffect: SymbolEffect, ContentTransitionSymbolEffect, ParseableModifierValue, IndefiniteSymbolEffect, DiscreteSymbolEffect {
     let configuration: SymbolEffectConfiguration
 
     init(configuration: SymbolEffectConfiguration) {
@@ -363,3 +363,8 @@ extension SymbolEffectOptions: ParseableModifierValue {
         }
     }
 }
+
+@available(iOS 17.0, macOS 14.0, tvOS 17.0, watchOS 10.0, *)
+typealias AnyIndefiniteSymbolEffect = AnySymbolEffect
+@available(iOS 17.0, macOS 14.0, tvOS 17.0, watchOS 10.0, *)
+typealias AnyDiscreteSymbolEffect = AnySymbolEffect

Sources/LiveViewNative/Stylesheets/ParseableTypes/ContentTransition+ParseableModifierValue.swift

@@ -18,6 +18,7 @@ extension ContentTransition: ParseableModifierValue {
                 ConstantAtomLiteral("opacity").map({ Self.opacity })
                 NumericText.parser(in: context).map(\.value)
                 if #available(iOS 17.0, macOS 14.0, tvOS 17.0, watchOS 10.0, *) {
+                    SymbolEffect.parser(in: context).map(\.value)
                     ConstantAtomLiteral("symbolEffect").map({ Self.symbolEffect })
                 }
             }