development: added MotionAnimation enum type and helper methods to CALayer and UIView as extensions

Sources/iOS/BasicMotion.swift

@@ -50,6 +50,220 @@ public enum AnimationKeyPath: String {
     case shadowPath
     case shadowPath
 }
 }
 
 
+public enum MotionAnimation {
+    case background(color: UIColor)
+    case corner(radius: CGFloat)
+    case transform(transform: CATransform3D)
+    case rotate(angle: CGFloat)
+    case rotateX(angle: CGFloat)
+    case rotateY(angle: CGFloat)
+    case rotateZ(angle: CGFloat)
+    case spin(rotations: CGFloat)
+    case spinX(rotations: CGFloat)
+    case spinY(rotations: CGFloat)
+    case spinZ(rotations: CGFloat)
+    case scale(by: CGFloat)
+    case scaleX(by: CGFloat)
+    case scaleY(by: CGFloat)
+    case scaleZ(by: CGFloat)
+    case move(by: CGPoint)
+    case moveX(by: CGFloat)
+    case moveY(by: CGFloat)
+    case moveZ(by: CGFloat)
+    case position(to: CGPoint)
+    case shadow(path: CGPath)
+}
+
+extension CALayer {
+
+    /**
+     A method that accepts CAAnimation objects and executes them on the
+     view's backing layer.
+     - Parameter animation: A CAAnimation instance.
+     */
+    open func animate(animation: CAAnimation) {
+        animation.delegate = self
+        
+        if let a = animation as? CABasicAnimation {
+            a.fromValue = (presentation() ?? self).value(forKeyPath: a.keyPath!)
+        }
+        
+        if let a = animation as? CAPropertyAnimation {
+            add(a, forKey: a.keyPath!)
+        } else if let a = animation as? CAAnimationGroup {
+            add(a, forKey: nil)
+        } else if let a = animation as? CATransition {
+            add(a, forKey: kCATransition)
+        }
+    }
+
+    /**
+     A delegation method that is executed when the backing layer stops
+     running an animation.
+     - Parameter animation: The CAAnimation instance that stopped running.
+     - Parameter flag: A boolean that indicates if the animation stopped
+     because it was completed or interrupted. True if completed, false
+     if interrupted.
+     */
+    open func animationDidStop(_ animation: CAAnimation, finished flag: Bool) {
+        guard let a = animation as? CAPropertyAnimation else {
+            if let a = (animation as? CAAnimationGroup)?.animations {
+                for x in a {
+                    animationDidStop(x, finished: true)
+                }
+            }
+            return
+        }
+        
+        guard let b = a as? CABasicAnimation else {
+            return
+        }
+        
+        guard let v = b.toValue else {
+            return
+        }
+        
+        guard let k = b.keyPath else {
+            return
+        }
+        
+        setValue(v, forKeyPath: k)
+        removeAnimation(forKey: k)
+    }
+    
+    open func motion(animations: MotionAnimation...) {
+        motion(animations: animations)
+    }
+    
+    open func motion(animations: [MotionAnimation]) {
+        motion(duration: 0.15, animations: animations)
+    }
+    
+    open func motion(duration: TimeInterval, animations: MotionAnimation...) {
+        motion(duration: duration, animations: animations)
+    }
+    
+    open func motion(duration: TimeInterval, animations: [MotionAnimation]) {
+        var a = [CABasicAnimation]()
+        
+        for v in animations {
+            
+            switch v {
+            case let .background(color):
+                a.append(Motion.background(color: color))
+            case let .corner(radius):
+                a.append(Motion.corner(radius: radius))
+            case let .transform(transform):
+                a.append(Motion.transform(transform: transform))
+            case let .rotate(angle):
+                a.append(Motion.rotate(angle: angle))
+            case let .rotateX(angle):
+                a.append(Motion.rotateX(angle: angle))
+            case let .rotateY(angle):
+                a.append(Motion.rotateY(angle: angle))
+            case let .rotateZ(angle):
+                a.append(Motion.rotateZ(angle: angle))
+            case let .spin(rotations):
+                a.append(Motion.spin(rotations: rotations))
+            case let .spinX(rotations):
+                a.append(Motion.spinX(rotations: rotations))
+            case let .spinY(rotations):
+                a.append(Motion.spinY(rotations: rotations))
+            case let .spinZ(rotations):
+                a.append(Motion.spinZ(rotations: rotations))
+            case let .scale(by):
+                a.append(Motion.scale(by: by))
+            case let .scaleX(by):
+                a.append(Motion.scaleX(by: by))
+            case let .scaleY(by):
+                a.append(Motion.scaleY(by: by))
+            case let .scaleZ(by):
+                a.append(Motion.scaleZ(by: by))
+            case let .move(by):
+                a.append(Motion.move(by: by))
+            case let .moveX(by):
+                a.append(Motion.moveX(by: by))
+            case let .moveY(by):
+                a.append(Motion.moveY(by: by))
+            case let .moveZ(by):
+                a.append(Motion.moveZ(by: by))
+            case let .position(to):
+                a.append(Motion.position(to: to))
+            case let .shadow(path):
+                a.append(Motion.shadow(path: path))
+            }
+        }
+        
+        animate(animation: Motion.animate(group: a))
+    }
+    
+    open func motion(delay: TimeInterval, animations: MotionAnimation...) {
+        motion(delay: delay, animations: animations)
+    }
+    
+    open func motion(delay: TimeInterval, animations: [MotionAnimation]) {
+        Motion.delay(time: delay) { [weak self] in
+            guard let s = self else {
+                return
+            }
+            
+            s.motion(animations: animations)
+        }
+    }
+    
+    open func motion(delay: TimeInterval, duration: TimeInterval, animations: MotionAnimation...) {
+        motion(delay: delay, duration: duration, animations: animations)
+    }
+    
+    open func motion(delay: TimeInterval, duration: TimeInterval, animations: [MotionAnimation]) {
+        Motion.delay(time: delay) { [weak self] in
+            guard let s = self else {
+                return
+            }
+            
+            s.motion(duration: duration, animations: animations)
+        }
+    }
+}
+
+@available(iOS 10, *)
+extension CALayer: CAAnimationDelegate {}
+
+extension UIView {
+    /**
+     A method that accepts CAAnimation objects and executes them on the
+     view's backing layer.
+     - Parameter animation: A CAAnimation instance.
+     */
+    open func animate(animation: CAAnimation) {
+        layer.animate(animation: animation)
+    }
+    
+    open func motion(animations: MotionAnimation...) {
+        layer.motion(animations: animations)
+    }
+    
+    open func motion(animations: [MotionAnimation]) {
+        layer.motion(animations: animations)
+    }
+    
+    open func motion(duration: TimeInterval, animations: MotionAnimation...) {
+        layer.motion(duration: duration, animations: animations)
+    }
+    
+    open func motion(duration: TimeInterval, animations: [MotionAnimation]) {
+        layer.motion(duration: duration, animations: animations)
+    }
+    
+    open func motion(delay: TimeInterval, animations: MotionAnimation...) {
+        layer.motion(delay: delay, animations: animations)
+    }
+    
+    open func motion(delay: TimeInterval, animations: [MotionAnimation]) {
+        layer.motion(delay: delay, animations: animations)
+    }
+}
+
 extension CABasicAnimation {
 extension CABasicAnimation {
     /**
     /**
      A convenience initializer that takes a given AnimationKeyPath.
      A convenience initializer that takes a given AnimationKeyPath.
@@ -67,18 +281,16 @@ extension Motion {
      - Parameter duration: An animation time duration.
      - Parameter duration: An animation time duration.
      - Returns: A CABasicAnimation.
      - Returns: A CABasicAnimation.
      */
      */
-	public static func backgroundColor(color: UIColor, duration: CFTimeInterval? = nil) -> CABasicAnimation {
+	public static func background(color: UIColor, duration: CFTimeInterval? = nil) -> CABasicAnimation {
 		let animation = CABasicAnimation(keyPath: .backgroundColor)
 		let animation = CABasicAnimation(keyPath: .backgroundColor)
 		animation.toValue = color.cgColor
 		animation.toValue = color.cgColor
 		animation.fillMode = AnimationFillModeToValue(mode: .forwards)
 		animation.fillMode = AnimationFillModeToValue(mode: .forwards)
 		animation.isRemovedOnCompletion = false
 		animation.isRemovedOnCompletion = false
 		animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
 		animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
-		
-        if let v = duration {
+		if let v = duration {
 			animation.duration = v
 			animation.duration = v
 		}
 		}
-		
-        return animation
+		return animation
 	}
 	}
 	
 	
     /**
     /**
@@ -87,18 +299,16 @@ extension Motion {
      - Parameter duration: An animation time duration.
      - Parameter duration: An animation time duration.
      - Returns: A CABasicAnimation.
      - Returns: A CABasicAnimation.
      */
      */
-    public static func cornerRadius(radius: CGFloat, duration: CFTimeInterval? = nil) -> CABasicAnimation {
+    public static func corner(radius: CGFloat, duration: CFTimeInterval? = nil) -> CABasicAnimation {
 		let animation = CABasicAnimation(keyPath: .cornerRadius)
 		let animation = CABasicAnimation(keyPath: .cornerRadius)
 		animation.toValue = radius
 		animation.toValue = radius
 		animation.fillMode = AnimationFillModeToValue(mode: .forwards)
 		animation.fillMode = AnimationFillModeToValue(mode: .forwards)
 		animation.isRemovedOnCompletion = false
 		animation.isRemovedOnCompletion = false
 		animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
 		animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
-		
-        if let v = duration {
+		if let v = duration {
 			animation.duration = v
 			animation.duration = v
 		}
 		}
-		
-        return animation
+		return animation
 	}
 	}
 	
 	
     /**
     /**
@@ -114,120 +324,155 @@ extension Motion {
 		animation.fillMode = AnimationFillModeToValue(mode: .forwards)
 		animation.fillMode = AnimationFillModeToValue(mode: .forwards)
 		animation.isRemovedOnCompletion = false
 		animation.isRemovedOnCompletion = false
 		animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
 		animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
-		
-        if let v = duration {
+		if let v = duration {
 			animation.duration = v
 			animation.duration = v
 		}
 		}
-		
-        return animation
+		return animation
 	}
 	}
 	
 	
     /**
     /**
      Creates a CABasicAnimation for the transform.rotation key path.
      Creates a CABasicAnimation for the transform.rotation key path.
      - Parameter angle: An optional CGFloat.
      - Parameter angle: An optional CGFloat.
-     - Parameter rotation: An optional CGFloat.
      - Parameter duration: An animation time duration.
      - Parameter duration: An animation time duration.
      - Returns: A CABasicAnimation.
      - Returns: A CABasicAnimation.
      */
      */
-    public static func rotate(angle: CGFloat? = nil, rotation: CGFloat? = nil, duration: CFTimeInterval? = nil) -> CABasicAnimation {
+    public static func rotate(angle: CGFloat, duration: CFTimeInterval? = nil) -> CABasicAnimation {
 		let animation = CABasicAnimation(keyPath: .rotation)
 		let animation = CABasicAnimation(keyPath: .rotation)
-        
-        if let v = angle {
-			animation.toValue = (CGFloat(M_PI) * v / 180) as NSNumber
-		} else if let v = rotation {
-			animation.toValue = (CGFloat(M_PI * 2) * v) as NSNumber
-		}
-		
-        animation.fillMode = AnimationFillModeToValue(mode: .forwards)
+        animation.toValue = (CGFloat(M_PI) * angle / 180) as NSNumber
+		animation.fillMode = AnimationFillModeToValue(mode: .forwards)
 		animation.isRemovedOnCompletion = false
 		animation.isRemovedOnCompletion = false
 		animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
 		animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
-		
-        if let v = duration {
+		if let v = duration {
 			animation.duration = v
 			animation.duration = v
 		}
 		}
 		return animation
 		return animation
 	}
 	}
-	
+    
     /**
     /**
      Creates a CABasicAnimation for the transform.rotation.x key path.
      Creates a CABasicAnimation for the transform.rotation.x key path.
      - Parameter angle: An optional CGFloat.
      - Parameter angle: An optional CGFloat.
-     - Parameter rotation: An optional CGFloat.
      - Parameter duration: An animation time duration.
      - Parameter duration: An animation time duration.
      - Returns: A CABasicAnimation.
      - Returns: A CABasicAnimation.
      */
      */
-    public static func rotateX(angle: CGFloat? = nil, rotation: CGFloat? = nil, duration: CFTimeInterval? = nil) -> CABasicAnimation {
+    public static func rotateX(angle: CGFloat, duration: CFTimeInterval? = nil) -> CABasicAnimation {
 		let animation = CABasicAnimation(keyPath: .rotationX)
 		let animation = CABasicAnimation(keyPath: .rotationX)
-		
-        if let v: CGFloat = angle {
-			animation.toValue = (CGFloat(M_PI) * v / 180) as NSNumber
-		} else if let v: CGFloat = rotation {
-			animation.toValue = (CGFloat(M_PI * 2) * v) as NSNumber
-		}
-		
-        animation.fillMode = AnimationFillModeToValue(mode: .forwards)
+		animation.toValue = (CGFloat(M_PI) * angle / 180) as NSNumber
+		animation.fillMode = AnimationFillModeToValue(mode: .forwards)
 		animation.isRemovedOnCompletion = false
 		animation.isRemovedOnCompletion = false
 		animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
 		animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
-		
-        if let v = duration {
+		if let v = duration {
 			animation.duration = v
 			animation.duration = v
 		}
 		}
-		
-        return animation
+		return animation
 	}
 	}
 	
 	
     /**
     /**
      Creates a CABasicAnimation for the transform.rotation.y key path.
      Creates a CABasicAnimation for the transform.rotation.y key path.
      - Parameter angle: An optional CGFloat.
      - Parameter angle: An optional CGFloat.
-     - Parameter rotation: An optional CGFloat.
      - Parameter duration: An animation time duration.
      - Parameter duration: An animation time duration.
      - Returns: A CABasicAnimation.
      - Returns: A CABasicAnimation.
      */
      */
-    public static func rotateY(angle: CGFloat? = nil, rotation: CGFloat? = nil, duration: CFTimeInterval? = nil) -> CABasicAnimation {
+    public static func rotateY(angle: CGFloat, duration: CFTimeInterval? = nil) -> CABasicAnimation {
 		let animation = CABasicAnimation(keyPath: .rotationY)
 		let animation = CABasicAnimation(keyPath: .rotationY)
-		
-        if let v = angle {
-			animation.toValue = (CGFloat(M_PI) * v / 180) as NSNumber
-		} else if let v = rotation {
-			animation.toValue = (CGFloat(M_PI * 2) * v) as NSNumber
-		}
-		
-        animation.fillMode = AnimationFillModeToValue(mode: .forwards)
+        animation.toValue = (CGFloat(M_PI) * angle / 180) as NSNumber
+		animation.fillMode = AnimationFillModeToValue(mode: .forwards)
 		animation.isRemovedOnCompletion = false
 		animation.isRemovedOnCompletion = false
 		animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
 		animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
-		
-        if let v = duration {
+		if let v = duration {
 			animation.duration = v
 			animation.duration = v
 		}
 		}
-		
-        return animation
+		return animation
 	}
 	}
 	
 	
     /**
     /**
      Creates a CABasicAnimation for the transform.rotation.z key path.
      Creates a CABasicAnimation for the transform.rotation.z key path.
      - Parameter angle: An optional CGFloat.
      - Parameter angle: An optional CGFloat.
-     - Parameter rotation: An optional CGFloat.
      - Parameter duration: An animation time duration.
      - Parameter duration: An animation time duration.
      - Returns: A CABasicAnimation.
      - Returns: A CABasicAnimation.
      */
      */
-    public static func rotateZ(angle: CGFloat? = nil, rotation: CGFloat? = nil, duration: CFTimeInterval? = nil) -> CABasicAnimation {
+    public static func rotateZ(angle: CGFloat, duration: CFTimeInterval? = nil) -> CABasicAnimation {
 		let animation = CABasicAnimation(keyPath: .rotationZ)
 		let animation = CABasicAnimation(keyPath: .rotationZ)
-		
-        if let v = angle {
-			animation.toValue = (CGFloat(M_PI) * v / 180) as NSNumber
-		} else if let v = rotation {
-			animation.toValue = (CGFloat(M_PI * 2) * v) as NSNumber
-		}
-		
-        animation.fillMode = AnimationFillModeToValue(mode: .forwards)
+        animation.toValue = (CGFloat(M_PI) * angle / 180) as NSNumber
+		animation.fillMode = AnimationFillModeToValue(mode: .forwards)
 		animation.isRemovedOnCompletion = false
 		animation.isRemovedOnCompletion = false
 		animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
 		animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
-		
-        if let v = duration {
+		if let v = duration {
 			animation.duration = v
 			animation.duration = v
 		}
 		}
-		
-        return animation
+		return animation
 	}
 	}
+    
+    /**
+     Creates a CABasicAnimation for the transform.rotation key path.
+     - Parameter rotations: An optional CGFloat.
+     - Parameter duration: An animation time duration.
+     - Returns: A CABasicAnimation.
+     */
+    public static func spin(rotations: CGFloat, duration: CFTimeInterval? = nil) -> CABasicAnimation {
+        let animation = CABasicAnimation(keyPath: .rotation)
+        animation.toValue = (CGFloat(M_PI * 2) * rotations) as NSNumber
+        animation.fillMode = AnimationFillModeToValue(mode: .forwards)
+        animation.isRemovedOnCompletion = false
+        animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
+        if let v = duration {
+            animation.duration = v
+        }
+        return animation
+    }
+    
+    /**
+     Creates a CABasicAnimation for the transform.rotation.x key path.
+     - Parameter rotations: An optional CGFloat.
+     - Parameter duration: An animation time duration.
+     - Returns: A CABasicAnimation.
+     */
+    public static func spinX(rotations: CGFloat, duration: CFTimeInterval? = nil) -> CABasicAnimation {
+        let animation = CABasicAnimation(keyPath: .rotationX)
+        animation.toValue = (CGFloat(M_PI * 2) * rotations) as NSNumber
+        animation.fillMode = AnimationFillModeToValue(mode: .forwards)
+        animation.isRemovedOnCompletion = false
+        animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
+        if let v = duration {
+            animation.duration = v
+        }
+        return animation
+    }
+    
+    /**
+     Creates a CABasicAnimation for the transform.rotation.y key path.
+     - Parameter rotations: An optional CGFloat.
+     - Parameter duration: An animation time duration.
+     - Returns: A CABasicAnimation.
+     */
+    public static func spinY(rotations: CGFloat, duration: CFTimeInterval? = nil) -> CABasicAnimation {
+        let animation = CABasicAnimation(keyPath: .rotationY)
+        animation.toValue = (CGFloat(M_PI * 2) * rotations) as NSNumber
+        animation.fillMode = AnimationFillModeToValue(mode: .forwards)
+        animation.isRemovedOnCompletion = false
+        animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
+        if let v = duration {
+            animation.duration = v
+        }
+        return animation
+    }
+    
+    /**
+     Creates a CABasicAnimation for the transform.rotation.z key path.
+     - Parameter rotations: An optional CGFloat.
+     - Parameter duration: An animation time duration.
+     - Returns: A CABasicAnimation.
+     */
+    public static func spinZ(rotations: CGFloat, duration: CFTimeInterval? = nil) -> CABasicAnimation {
+        let animation = CABasicAnimation(keyPath: .rotationZ)
+        animation.toValue = (CGFloat(M_PI * 2) * rotations) as NSNumber
+        animation.fillMode = AnimationFillModeToValue(mode: .forwards)
+        animation.isRemovedOnCompletion = false
+        animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
+        if let v = duration {
+            animation.duration = v
+        }
+        return animation
+    }
 
 
     /**
     /**
      Creates a CABasicAnimation for the transform.scale key path.
      Creates a CABasicAnimation for the transform.scale key path.
@@ -303,13 +548,13 @@ extension Motion {
 	
 	
     /**
     /**
      Creates a CABasicAnimation for the transform.translation key path.
      Creates a CABasicAnimation for the transform.translation key path.
-     - Parameter size: A CGSize.
+     - Parameter point: A CGPoint.
      - Parameter duration: An animation time duration.
      - Parameter duration: An animation time duration.
      - Returns: A CABasicAnimation.
      - Returns: A CABasicAnimation.
      */
      */
-    public static func translate(size: CGSize, duration: CFTimeInterval? = nil) -> CABasicAnimation {
+    public static func move(by point: CGPoint, duration: CFTimeInterval? = nil) -> CABasicAnimation {
 		let animation = CABasicAnimation(keyPath: .translation)
 		let animation = CABasicAnimation(keyPath: .translation)
-		animation.toValue = NSValue(cgSize: size)
+		animation.toValue = NSValue(cgPoint: point)
 		animation.fillMode = AnimationFillModeToValue(mode: .forwards)
 		animation.fillMode = AnimationFillModeToValue(mode: .forwards)
 		animation.isRemovedOnCompletion = false
 		animation.isRemovedOnCompletion = false
 		animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
 		animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
@@ -327,7 +572,7 @@ extension Motion {
      - Parameter duration: An animation time duration.
      - Parameter duration: An animation time duration.
      - Returns: A CABasicAnimation.
      - Returns: A CABasicAnimation.
      */
      */
-    public static func translateX(by translation: CGFloat, duration: CFTimeInterval? = nil) -> CABasicAnimation {
+    public static func moveX(by translation: CGFloat, duration: CFTimeInterval? = nil) -> CABasicAnimation {
 		let animation = CABasicAnimation(keyPath: .translationX)
 		let animation = CABasicAnimation(keyPath: .translationX)
 		animation.toValue = translation as NSNumber
 		animation.toValue = translation as NSNumber
 		animation.fillMode = AnimationFillModeToValue(mode: .forwards)
 		animation.fillMode = AnimationFillModeToValue(mode: .forwards)
@@ -347,7 +592,7 @@ extension Motion {
      - Parameter duration: An animation time duration.
      - Parameter duration: An animation time duration.
      - Returns: A CABasicAnimation.
      - Returns: A CABasicAnimation.
      */
      */
-    public static func translateY(by translation: CGFloat, duration: CFTimeInterval? = nil) -> CABasicAnimation {
+    public static func moveY(by translation: CGFloat, duration: CFTimeInterval? = nil) -> CABasicAnimation {
 		let animation = CABasicAnimation(keyPath: .translationY)
 		let animation = CABasicAnimation(keyPath: .translationY)
 		animation.toValue = translation as NSNumber
 		animation.toValue = translation as NSNumber
         animation.fillMode = AnimationFillModeToValue(mode: .forwards)
         animation.fillMode = AnimationFillModeToValue(mode: .forwards)
@@ -367,7 +612,7 @@ extension Motion {
      - Parameter duration: An animation time duration.
      - Parameter duration: An animation time duration.
      - Returns: A CABasicAnimation.
      - Returns: A CABasicAnimation.
      */
      */
-    public static func translateZ(by translation: CGFloat, duration: CFTimeInterval? = nil) -> CABasicAnimation {
+    public static func moveZ(by translation: CGFloat, duration: CFTimeInterval? = nil) -> CABasicAnimation {
 		let animation = CABasicAnimation(keyPath: .translationZ)
 		let animation = CABasicAnimation(keyPath: .translationZ)
 		animation.toValue = translation as NSNumber
 		animation.toValue = translation as NSNumber
         animation.fillMode = AnimationFillModeToValue(mode: .forwards)
         animation.fillMode = AnimationFillModeToValue(mode: .forwards)
@@ -407,7 +652,7 @@ extension Motion {
      - Parameter duration: An animation time duration.
      - Parameter duration: An animation time duration.
      - Returns: A CABasicAnimation.
      - Returns: A CABasicAnimation.
      */
      */
-    public static func shadowPath(to path: CGPath, duration: CFTimeInterval? = nil) -> CABasicAnimation {
+    public static func shadow(path: CGPath, duration: CFTimeInterval? = nil) -> CABasicAnimation {
 		let animation = CABasicAnimation(keyPath: .shadowPath)
 		let animation = CABasicAnimation(keyPath: .shadowPath)
 		animation.toValue = path
 		animation.toValue = path
         animation.fillMode = AnimationFillModeToValue(mode: .forwards)
         animation.fillMode = AnimationFillModeToValue(mode: .forwards)

Sources/iOS/Material+CALayer.swift

@@ -248,61 +248,6 @@ extension CALayer {
         }
         }
     }
     }
     
     
-    /**
-     A method that accepts CAAnimation objects and executes them on the
-     view's backing layer.
-     - Parameter animation: A CAAnimation instance.
-     */
-    open func animate(animation: CAAnimation) {        
-        animation.delegate = self
-        
-        if let a = animation as? CABasicAnimation {
-            a.fromValue = (presentation() ?? self).value(forKeyPath: a.keyPath!)
-        }
-        
-        if let a = animation as? CAPropertyAnimation {
-            add(a, forKey: a.keyPath!)
-        } else if let a = animation as? CAAnimationGroup {
-            add(a, forKey: nil)
-        } else if let a = animation as? CATransition {
-            add(a, forKey: kCATransition)
-        }
-    }
-    
-    /**
-     A delegation method that is executed when the backing layer stops
-     running an animation.
-     - Parameter animation: The CAAnimation instance that stopped running.
-     - Parameter flag: A boolean that indicates if the animation stopped
-     because it was completed or interrupted. True if completed, false
-     if interrupted.
-     */
-    open func animationDidStop(_ animation: CAAnimation, finished flag: Bool) {
-        guard let a = animation as? CAPropertyAnimation else {
-            if let a = (animation as? CAAnimationGroup)?.animations {
-                for x in a {
-                    animationDidStop(x, finished: true)
-                }
-            }
-            return
-        }
-        
-        guard let b = a as? CABasicAnimation else {
-            return
-        }
-        
-        guard let v = b.toValue else {
-            return
-        }
-        
-        guard let k = b.keyPath else {
-            return
-        }
-        
-        setValue(v, forKeyPath: k)
-        removeAnimation(forKey: k)
-    }
-    
     /// Manages the layout for the shape of the view instance.
     /// Manages the layout for the shape of the view instance.
     open func layoutShape() {
     open func layoutShape() {
         guard .none != shapePreset else {
         guard .none != shapePreset else {
@@ -335,12 +280,9 @@ extension CALayer {
         } else if nil == shadowPath {
         } else if nil == shadowPath {
             shadowPath = UIBezierPath(roundedRect: bounds, cornerRadius: cornerRadius).cgPath
             shadowPath = UIBezierPath(roundedRect: bounds, cornerRadius: cornerRadius).cgPath
         } else {
         } else {
-            let a = Motion.shadowPath(to: UIBezierPath(roundedRect: bounds, cornerRadius: cornerRadius).cgPath)
+            let a = Motion.shadow(path: UIBezierPath(roundedRect: bounds, cornerRadius: cornerRadius).cgPath)
             a.fromValue = shadowPath
             a.fromValue = shadowPath
             animate(animation: a)
             animate(animation: a)
         }
         }
     }
     }
 }
 }
-
-@available(iOS 10, *)
-extension CALayer: CAAnimationDelegate {}

Sources/iOS/Material+UIView.swift

@@ -268,15 +268,6 @@ extension UIView {
         }
         }
     }
     }
     
     
-    /**
-     A method that accepts CAAnimation objects and executes them on the
-     view's backing layer.
-     - Parameter animation: A CAAnimation instance.
-     */
-    open func animate(animation: CAAnimation) {
-        layer.animate(animation: animation)
-    }
-    
     /// Manages the layout for the shape of the view instance.
     /// Manages the layout for the shape of the view instance.
     open func layoutShape() {
     open func layoutShape() {
         layer.layoutShape()
         layer.layoutShape()

Sources/iOS/PulseMotion.swift

@@ -146,7 +146,7 @@ extension PulseMotion {
         
         
         switch animation {
         switch animation {
         case .centerWithBacking, .backing, .pointWithBacking, .tap:
         case .centerWithBacking, .backing, .pointWithBacking, .tap:
-            bLayer.add(Motion.backgroundColor(color: color.withAlphaComponent(opacity / 2), duration: duration), forKey: nil)
+            bLayer.add(Motion.background(color: color.withAlphaComponent(opacity / 2), duration: duration), forKey: nil)
         default:break
         default:break
         }
         }
         
         
@@ -182,7 +182,7 @@ extension PulseMotion {
             
             
             switch animation {
             switch animation {
             case .centerWithBacking, .backing, .pointWithBacking, .tap:
             case .centerWithBacking, .backing, .pointWithBacking, .tap:
-                bLayer.add(Motion.backgroundColor(color: color.withAlphaComponent(0), duration: duration), forKey: nil)
+                bLayer.add(Motion.background(color: color.withAlphaComponent(0), duration: duration), forKey: nil)
             default:break
             default:break
             }
             }
             
             
@@ -190,7 +190,7 @@ extension PulseMotion {
             case .center, .centerWithBacking, .centerRadialBeyondBounds, .radialBeyondBounds, .point, .pointWithBacking:
             case .center, .centerWithBacking, .centerRadialBeyondBounds, .radialBeyondBounds, .point, .pointWithBacking:
                 pLayer.add(Motion.animate(group: [
                 pLayer.add(Motion.animate(group: [
                     Motion.scale(by: .center == animation ? 1 : 1.325),
                     Motion.scale(by: .center == animation ? 1 : 1.325),
-                    Motion.backgroundColor(color: color.withAlphaComponent(0))
+                    Motion.background(color: color.withAlphaComponent(0))
                 ], duration: duration), forKey: nil)
                 ], duration: duration), forKey: nil)
             default:break
             default:break
             }
             }