wip

Author: davdroman

Sources/AtomicTransition/AtomicTransitionBuilder.swift

@@ -1,5 +1,14 @@
 @resultBuilder
 public struct AtomicTransitionBuilder {
+    #if compiler(>=5.7)
+    public static func buildPartialBlock(first: some AtomicTransitionProtocol) -> some AtomicTransitionProtocol {
+        first
+    }
+
+    public static func buildPartialBlock(accumulated: some AtomicTransitionProtocol, next: some AtomicTransitionProtocol) -> some AtomicTransitionProtocol {
+        Combined(accumulated, next)
+    }
+    #else
     public static func buildBlock() -> Identity {
         Identity()
     }
@@ -101,4 +110,5 @@ public struct AtomicTransitionBuilder {
     ) -> Tuple<(T1, T2, T3, T4, T5, T6, T7)> {
         Tuple((t1, t2, t3, t4, t5, t6, t7))
     }
+    #endif
 }

Sources/AtomicTransition/Combined.swift

@@ -23,17 +23,26 @@ public struct Combined<TransitionA: AtomicTransitionProtocol, TransitionB: Atomi
     private let transitionA: TransitionA
     private let transitionB: TransitionB
 
-    init(transitionA: TransitionA, transitionB: TransitionB) {
+    init(_ transitionA: TransitionA, _ transitionB: TransitionB) {
         self.transitionA = transitionA
         self.transitionB = transitionB
     }
 
+    #if compiler(>=5.7)
+    public init(@AtomicTransitionBuilder _ builder: () -> Self) {
+        self = builder()
+    }
+    #else
     public init(@AtomicTransitionBuilder _ builder: () -> TransitionA) where TransitionB == Identity {
         self.init(transitionA: builder(), transitionB: Identity())
     }
+    #endif
 
     public func transition(_ view: TransientView, for operation: TransitionOperation, in container: Container) {
         transitionA.transition(view, for: operation, in: container)
         transitionB.transition(view, for: operation, in: container)
     }
 }
+
+extension Combined: Equatable where TransitionA: Equatable, TransitionB: Equatable {}
+extension Combined: Hashable where TransitionA: Hashable, TransitionB: Hashable {}

Sources/AtomicTransition/Identity.swift

@@ -14,3 +14,5 @@ public struct Identity: AtomicTransitionProtocol {
         // NO-OP
     }
 }
+
+extension Identity: Hashable {}

Sources/AtomicTransition/Move.swift

@@ -40,3 +40,49 @@ extension AtomicTransition {
         }
     }
 }
+
+public struct Move: AtomicTransitionProtocol {
+    private let edge: Edge
+
+    public init(edge: Edge) {
+        self.edge = edge
+    }
+
+    public func transition(_ view: TransientView, for operation: TransitionOperation, in container: Container) {
+        switch (edge, operation) {
+        case (.top, .insertion):
+            view.initial.translation.dy = -container.frame.height
+            view.animation.translation.dy = 0
+
+        case (.leading, .insertion):
+            view.initial.translation.dx = -container.frame.width
+            view.animation.translation.dx = 0
+
+        case (.trailing, .insertion):
+            view.initial.translation.dx = container.frame.width
+            view.animation.translation.dx = 0
+
+        case (.bottom, .insertion):
+            view.initial.translation.dy = container.frame.height
+            view.animation.translation.dy = 0
+
+        case (.top, .removal):
+            view.animation.translation.dy = -container.frame.height
+            view.completion.translation.dy = 0
+
+        case (.leading, .removal):
+            view.animation.translation.dx = -container.frame.width
+            view.completion.translation.dx = 0
+
+        case (.trailing, .removal):
+            view.animation.translation.dx = container.frame.width
+            view.completion.translation.dx = 0
+
+        case (.bottom, .removal):
+            view.animation.translation.dy = container.frame.height
+            view.completion.translation.dy = 0
+        }
+    }
+}
+
+extension Move: Hashable {}

Sources/AtomicTransition/Offset.swift

@@ -35,3 +35,28 @@ extension AtomicTransition {
         .offset(x: offset.width, y: offset.height)
     }
 }
+
+public struct Offset: AtomicTransitionProtocol {
+    private let x: CGFloat
+    private let y: CGFloat
+
+    public init(x: CGFloat, y: CGFloat) {
+        self.x = x
+        self.y = y
+    }
+
+    public func transition(_ view: TransientView, for operation: TransitionOperation, in container: Container) {
+        switch operation {
+        case .insertion:
+            view.initial.translation.dx += x
+            view.initial.translation.dy += y
+            view.animation.transform = .identity
+        case .removal:
+            view.animation.translation.dx += x
+            view.animation.translation.dy += y
+            view.completion.transform = .identity
+        }
+    }
+}
+
+extension Offset: Hashable {}

Sources/AtomicTransition/Opacity.swift

@@ -1,3 +1,5 @@
+import class UIKit.UIView
+
 extension AtomicTransition {
     /// A transition from transparent to opaque on insertion, and from opaque to transparent on removal.
     public static var opacity: Self {
@@ -13,3 +15,20 @@ extension AtomicTransition {
         }
     }
 }
+
+public struct Opacity: AtomicTransitionProtocol {
+    public init() {}
+
+    public func transition(_ view: TransientView, for operation: TransitionOperation, in container: Container) {
+        switch operation {
+        case .insertion:
+            view.initial.alpha = 0
+            view.animation.alpha = 1
+        case .removal:
+            view.animation.alpha = 0
+            view.completion.alpha = 1
+        }
+    }
+}
+
+extension Opacity: Hashable {}

Sources/AtomicTransition/Rotate.swift

@@ -15,3 +15,24 @@ extension AtomicTransition {
         }
     }
 }
+
+public struct Rotate: AtomicTransitionProtocol {
+    private let angle: Angle
+
+    public init(_ angle: Angle) {
+        self.angle = angle
+    }
+
+    public func transition(_ view: TransientView, for operation: TransitionOperation, in container: Container) {
+        switch operation {
+        case .insertion:
+            view.initial.rotation += angle.radians
+            view.animation.transform = .identity
+        case .removal:
+            view.animation.rotation += angle.radians
+            view.completion.transform = .identity
+        }
+    }
+}
+
+extension Rotate: Hashable {}

Sources/AtomicTransition/Scale.swift

@@ -23,3 +23,24 @@ extension AtomicTransition {
         .scale(.leastNonzeroMagnitude)
     }
 }
+
+public struct Scale: AtomicTransitionProtocol {
+    private let scale: CGFloat
+
+    public init(_ scale: CGFloat) {
+        self.scale = scale
+    }
+
+    public func transition(_ view: TransientView, for operation: TransitionOperation, in container: Container) {
+        switch operation {
+        case .insertion:
+            view.initial.scale = .init(width: scale, height: scale)
+            view.animation.transform = .identity
+        case .removal:
+            view.animation.scale = .init(width: scale, height: scale)
+            view.completion.transform = .identity
+        }
+    }
+}
+
+extension Scale: Hashable {}

Sources/AtomicTransition/ZPosition.swift

@@ -1,4 +1,5 @@
 @_spi(package) import Animator
+import class UIKit.UIView
 
 extension AtomicTransition {
     public enum ZPosition {
@@ -30,3 +31,19 @@ extension AtomicTransition {
         .zPosition(.back)
     }
 }
+
+public struct BringToFront: AtomicTransitionProtocol {
+    public func transition(_ view: TransientView, for operation: TransitionOperation, in container: Container) {
+        container.bringSubviewToFront(view.uiView)
+    }
+}
+
+extension BringToFront: Hashable {}
+
+public struct SendToBack: AtomicTransitionProtocol {
+    public func transition(_ view: TransientView, for operation: TransitionOperation, in container: Container) {
+        container.sendSubviewToBack(view.uiView)
+    }
+}
+
+extension SendToBack: Hashable {}