@applicaster/quick-brick-native-apple 5.16.0 → 5.18.0

package/apple/tvos/Views/FocusableView/FocusableView.swift

@@ -7,108 +7,106 @@
 //
 
 import Foundation
-import UIKit
 import React
+import UIKit
 
 /// RCTTVView subclass that has api how to conects to FocusableGroup
 public class FocusableView: ParallaxView {
-
-    @objc public var onViewFocus:RCTBubblingEventBlock?
-    @objc public var onViewPress:RCTBubblingEventBlock?
-    @objc public var onViewBlur:RCTBubblingEventBlock?
-    @objc public var isParallaxDisabled:Bool = false {
+    @objc public var onViewFocus: RCTBubblingEventBlock?
+    @objc public var onViewPress: RCTBubblingEventBlock?
+    @objc public var onViewBlur: RCTBubblingEventBlock?
+    @objc public var isParallaxDisabled: Bool = false {
         didSet {
             parallaxEffectOptions.parallaxMotionEffect.isDisabled = isParallaxDisabled
         }
     }
 
-    @objc public var isPressDisabled:Bool = false {
+    @objc public var isPressDisabled: Bool = false {
         didSet {
             isPressActionDisabled = isPressDisabled
         }
     }
-    
+
     /// Define if view can become focused
     @objc open var focusable = true
-    
-    @objc public var preferredFocus:Bool = false {
+
+    @objc public var preferredFocus: Bool = false {
         didSet {
             guard preferredFocus else {
                 return
             }
             DispatchQueue.main.async { [weak self] in
                 if let groupId = self?.groupId,
-                    let focusableGroup = focusableGroups[groupId] {
-                    //Update Prefered focus view in group
+                   let focusableGroup = focusableGroups[groupId]
+                {
+                    // Update Prefered focus view in group
                     focusableGroup.updatePrefferedFocusEnv(with: self!)
-                    
                 }
             }
         }
     }
+
     /// Define if this view is preffered tv focused View
-    @objc public var forceFocus:Bool = false {
-        
+    @objc public var forceFocus: Bool = false {
         didSet {
             guard forceFocus else {
                 return
             }
             DispatchQueue.main.async { [weak self] in
-                            FocusableGroupManager.updateFocus(self?.groupId,
-                                                              itemId: self?.itemId,
-                                                              needsForceUpdate: true,
-                                                              completion: nil)
+                FocusableGroupManager.updateFocus(self?.groupId,
+                                                  itemId: self?.itemId,
+                                                  needsForceUpdate: true,
+                                                  completion: nil)
             }
         }
     }
-    
-    public override var canBecomeFocused: Bool {
-        return focusable
+
+    override public var canBecomeFocused: Bool {
+        focusable
     }
-    
+
     /// Define if view was registered
-    var isViewRegistered:Bool = false
+    var isViewRegistered: Bool = false
 
-    public override init(frame: CGRect) {
+    override public init(frame: CGRect) {
         super.init(frame: frame)
         initialize()
     }
-    
+
     public required init?(coder aDecoder: NSCoder) {
         super.init(coder: aDecoder)
         initialize()
     }
-    
-    
+
     /// Initialize component
     func initialize() {
         delegate = self
     }
-    
+
     /// ID of the View provided by React-Native env
-    @objc public var itemId:String? {
+    @objc public var itemId: String? {
         didSet {
             registerView()
         }
     }
-    
+
     /// ID of the View provided by React-Native env
-    @objc public var groupId:String? {
+    @objc public var groupId: String? {
         didSet {
             registerView()
         }
     }
-    
+
     /// Register View in FocusableGroupManager
     func registerView() {
         guard itemId != nil,
-            groupId != nil,
-            isViewRegistered == false,
-            FocusableGroupManager.registerView(item: self) else {
-                return
+              groupId != nil,
+              isViewRegistered == false,
+              FocusableGroupManager.registerView(item: self)
+        else {
+            return
         }
-        
-        self.isViewRegistered = true
+
+        isViewRegistered = true
     }
 }
-

package/apple/tvos/Views/FocusableView/FocusableViewModule.swift

@@ -12,21 +12,20 @@ import React
 @objc(FocusableViewModule)
 public class FocusableViewModule: RCTViewManager {
     static let focusableViewModuleName = "FocusableViewModule"
-    
+
     override public static func moduleName() -> String? {
-        return focusableViewModuleName
+        focusableViewModuleName
     }
-    
+
     override public class func requiresMainQueueSetup() -> Bool {
-        return true
+        true
     }
-    
+
     override open var methodQueue: DispatchQueue {
-        return bridge.uiManager.methodQueue
+        bridge.uiManager.methodQueue
     }
-    
+
     override public func view() -> UIView? {
-        return FocusableView()
+        FocusableView()
     }
-    
 }

package/apple/tvos/Views/ParallaxView/Extensions/ParallaxableView+Extensions.swift

@@ -8,8 +8,7 @@
 
 import UIKit
 
-open class ParallaxViewActions<T: UIView> where T:ParallaxableView {
-
+open class ParallaxViewActions<T: UIView> where T: ParallaxableView {
     /// Closure will be called in animation block by ParallaxableView when view should change its appearance to the focused state
     open var setupUnfocusedState: ((T) -> Void)?
     /// Closure will be called in animation block by ParallaxableView when view should change its appearance to the unfocused state
@@ -19,16 +18,16 @@ open class ParallaxViewActions<T: UIView> where T:ParallaxableView {
     /// Closure will be called by ParallaxableView before the animation to the unfocused state start
     open var beforeResignFocusAnimation: ((T) -> Void)?
     /// Closure will be called when didFocusChange happened. In most cases default implementation should work
-    open var becomeFocused: ((T, _ context: UIFocusUpdateContext, _ animationCoordinator: UIFocusAnimationCoordinator, _ completion:@escaping(()->Void)) -> Void)?
+    open var becomeFocused: ((T, _ context: UIFocusUpdateContext, _ animationCoordinator: UIFocusAnimationCoordinator, _ completion: @escaping (() -> Void)) -> Void)?
     /// Closure will be called when didFocusChange happened. In most cases default implementation should work
-    open var resignFocus: ((T, _ context: UIFocusUpdateContext, _ animationCoordinator: UIFocusAnimationCoordinator, _ completion:@escaping(()->Void)) -> Void)?
+    open var resignFocus: ((T, _ context: UIFocusUpdateContext, _ animationCoordinator: UIFocusAnimationCoordinator, _ completion: @escaping (() -> Void)) -> Void)?
     /// Default implementation of the press begin animation for the ParallaxableView
-    open var animatePressIn: ((T, _ presses: Set<UIPress>, _ event: UIPressesEvent?, _ completion:@escaping(()->Void)) -> Void)?
+    open var animatePressIn: ((T, _ presses: Set<UIPress>, _ event: UIPressesEvent?, _ completion: @escaping (() -> Void)) -> Void)?
     /// Default implementation of the press ended animation for the ParallaxableView
-    open var animatePressOut: ((T, _ presses: Set<UIPress>, _ event: UIPressesEvent?, _ completion:@escaping(()->Void)) -> Void)?
+    open var animatePressOut: ((T, _ presses: Set<UIPress>, _ event: UIPressesEvent?, _ completion: @escaping (() -> Void)) -> Void)?
 
     public init() {
-        becomeFocused = { [weak self] (view: T, context, coordinator, completion) in
+        becomeFocused = { [weak self] (view: T, _, coordinator, completion) in
             self?.beforeBecomeFocusedAnimation?(view)
 
             coordinator.addCoordinatedAnimations({
@@ -37,21 +36,20 @@ open class ParallaxViewActions<T: UIView> where T:ParallaxableView {
             }, completion: {
                 completion()
             })
-            
         }
 
-        resignFocus = { [weak self] (view: T, context, coordinator, completion) in
+        resignFocus = { [weak self] (view: T, _, coordinator, completion) in
             self?.beforeResignFocusAnimation?(view)
 
             coordinator.addCoordinatedAnimations({
                 view.removeParallaxMotionEffects(with: view.parallaxEffectOptions)
                 self?.setupUnfocusedState?(view)
-            },  completion: {
+            }, completion: {
                 completion()
             })
         }
 
-        animatePressIn = { (view: T, presses, event, completion) in
+        animatePressIn = { (view: T, presses, _, completion) in
             for press in presses {
                 if case .select = press.type {
                     UIView.animate(withDuration: 0.12, animations: {
@@ -59,19 +57,17 @@ open class ParallaxViewActions<T: UIView> where T:ParallaxableView {
                     })
                     UIView.animate(withDuration: 0.12, animations: {
                         view.transform = CGAffineTransform(scaleX: 0.95, y: 0.95)
-                    }, completion: { (success) in
+                    }, completion: { _ in
                         completion()
                     })
                 }
             }
         }
 
-        animatePressOut = { [weak self] (view: T, presses, event, completion) in
+        animatePressOut = { [weak self] (view: T, presses, _, completion) in
             for press in presses {
                 if case .select = press.type {
-                    UIView.animate(withDuration: 0.12, animations: {
-                    
-                    })
+                    UIView.animate(withDuration: 0.12, animations: {})
                     UIView.animate(withDuration: 0.12, animations: {
                         if view.isFocused {
                             view.transform = CGAffineTransform.identity
@@ -80,30 +76,28 @@ open class ParallaxViewActions<T: UIView> where T:ParallaxableView {
                             view.transform = CGAffineTransform.identity
                             self?.setupUnfocusedState?(view)
                         }
-                    }, completion: { (success) in
+                    }, completion: { _ in
                         completion()
                     })
                 }
             }
         }
     }
-
 }
 
 public extension ParallaxableView where Self: UIView {
-
     // MARK: Properties
 
     /// Configure radius for parallaxView and glow effect if needed
     var cornerRadius: CGFloat {
         get {
-            return self.layer.cornerRadius
+            layer.cornerRadius
         }
         set {
-            self.layer.cornerRadius = newValue
+            layer.cornerRadius = newValue
 
             // Change the glowEffectContainerView corner radius only if it is a direct subview of the parallax view
-            if let glowEffectContainerView = parallaxEffectOptions.glowContainerView , self.subviews.contains(glowEffectContainerView) {
+            if let glowEffectContainerView = parallaxEffectOptions.glowContainerView, subviews.contains(glowEffectContainerView) {
                 glowEffectContainerView.layer.cornerRadius = newValue
             }
         }
@@ -117,13 +111,13 @@ public extension ParallaxableView where Self: UIView {
      - returns: Image with radial gradient/shadow to imitate glow
      */
     func getGlowImageView() -> UIImageView? {
-        return parallaxEffectOptions.glowContainerView?.subviews.filter({ (view) -> Bool in
+        parallaxEffectOptions.glowContainerView?.subviews.filter { view -> Bool in
             if let glowImageView = view as? UIImageView,
-                let glowImage = glowImageView.image , glowImage.accessibilityIdentifier == glowImageAccessibilityIdentifier {
+               let glowImage = glowImageView.image, glowImage.accessibilityIdentifier == glowImageAccessibilityIdentifier
+            {
                 return true
             }
             return false
-        }).first as? UIImageView
+        }.first as? UIImageView
     }
-
 }

package/apple/tvos/Views/ParallaxView/Extensions/UIView+ParallaxEffect.swift

@@ -6,8 +6,8 @@
 //
 //
 
-import UIKit
 import React
+import UIKit
 
 public protocol AnyParallaxableView {
     func addParallaxMotionEffects()
@@ -16,7 +16,6 @@ public protocol AnyParallaxableView {
 }
 
 extension UIView: AnyParallaxableView {
-    
     public func addParallaxMotionEffects() {
         var options = ParallaxEffectOptions()
         addParallaxMotionEffects(with: &options)
@@ -63,84 +62,83 @@ extension UIView: AnyParallaxableView {
 //
         let motionGroup = UIMotionEffectGroup()
         motionGroup.motionEffects = []
-        
+
         // Add parallax effect
         motionGroup.motionEffects?.append(options.parallaxMotionEffect)
-        
+
         // Configure shadow pan motion effect
         if options.shadowPanDeviation != 0 {
             let veriticalShadowEffect = UIInterpolatingMotionEffect(keyPath: "layer.shadowOffset.height", type: .tiltAlongVerticalAxis)
             veriticalShadowEffect.minimumRelativeValue = -options.shadowPanDeviation
-            veriticalShadowEffect.maximumRelativeValue = options.shadowPanDeviation/2
-            
+            veriticalShadowEffect.maximumRelativeValue = options.shadowPanDeviation / 2
+
             let horizontalShadowEffect = UIInterpolatingMotionEffect(keyPath: "layer.shadowOffset.width", type: .tiltAlongHorizontalAxis)
             horizontalShadowEffect.minimumRelativeValue = -options.shadowPanDeviation
             horizontalShadowEffect.maximumRelativeValue = options.shadowPanDeviation
-            
+
             motionGroup.motionEffects?.append(contentsOf: [veriticalShadowEffect, horizontalShadowEffect])
         }
-        
+
         addMotionEffect(motionGroup)
-        
+
         // Configure pan motion effect for the subviews
         if case .none = options.subviewsParallaxMode {
         } else {
-            if self.subviews.count > 1,
-                let rnView = self.subviews[1] as? RCTTVView,
-                let subviews = findSubview(view: rnView) {
+            if subviews.count > 1,
+               let rnView = subviews[1] as? RCTTVView,
+               let subviews = findSubview(view: rnView)
+            {
                 subviews.filter { $0 !== options.glowContainerView }
                     .enumerated()
                     .forEach { (index: Int, subview: UIView) in
                         let relativePanValue: Double
-                        
+
                         switch options.subviewsParallaxMode {
-                        case .basedOnHierarchyInParallaxView(let maxOffset, let multipler):
-                            relativePanValue = maxOffset / (Double(index+1)) * (multipler ?? 1.0)
+                        case let .basedOnHierarchyInParallaxView(maxOffset, multipler):
+                            relativePanValue = maxOffset / Double(index + 1) * (multipler ?? 1.0)
                         case .basedOnTag:
                             relativePanValue = Double(subview.tag)
                         default:
                             relativePanValue = 0.0
                         }
-                        
+
                         let verticalSubviewEffect = UIInterpolatingMotionEffect(keyPath: "center.y", type: .tiltAlongVerticalAxis)
                         verticalSubviewEffect.minimumRelativeValue = -relativePanValue
                         verticalSubviewEffect.maximumRelativeValue = relativePanValue
-                        
+
                         let horizontalSubviewEffect = UIInterpolatingMotionEffect(keyPath: "center.x", type: .tiltAlongHorizontalAxis)
                         horizontalSubviewEffect.minimumRelativeValue = -relativePanValue
                         horizontalSubviewEffect.maximumRelativeValue = relativePanValue
-                        
+
                         let group = UIMotionEffectGroup()
                         group.motionEffects = [verticalSubviewEffect, horizontalSubviewEffect]
                         subview.addMotionEffect(group)
-                }
-            }            
+                    }
+            }
         }
     }
-    
-    func findSubview(view:UIView?) -> [UIView]? {
-        
+
+    func findSubview(view: UIView?) -> [UIView]? {
         if let subviews = view?.subviews {
             if subviews.count > 1 {
                 return subviews
             } else {
-               return findSubview(view:subviews.first)
+                return findSubview(view: subviews.first)
             }
         }
-        
+
         return nil
     }
-    
+
     public func removeParallaxMotionEffects(with options: ParallaxEffectOptions? = nil) {
         motionEffects.removeAll()
         (options?.parallaxSubviewsContainer ?? self).subviews
             .filter { $0 !== options?.glowContainerView }
             .forEach { (subview: UIView) in
                 subview.motionEffects.removeAll()
-        }
+            }
 
 //        options?.glowImageView.motionEffects.removeAll()
 //        options?.glowImageView.removeFromSuperview()
     }
-    
 }

package/apple/tvos/Views/ParallaxView/Other/ParallaxEffectOptions.swift

@@ -9,7 +9,6 @@
 import UIKit
 
 public struct ParallaxEffectOptions {
-    
     /// Property allow to customize parallax effect (pan, angles, etc.)
     ///
     /// - seealso:
@@ -41,27 +40,24 @@ public struct ParallaxEffectOptions {
         self.parallaxSubviewsContainer = parallaxSubviewsContainer
         self.glowContainerView = glowContainerView
     }
-    
 }
 
 internal let glowImageAccessibilityIdentifier = "com.applicaster"
 
 extension ParallaxEffectOptions {
-    
     static func defaultGlowImageView() -> UIImageView {
-        
         if case let bundle = Bundle(for: ParallaxView.self),
-            let glowImage = UIImage(named: "gloweffect",
-                                    in: bundle,
-                                    compatibleWith: nil) {
+           let glowImage = UIImage(named: "gloweffect",
+                                   in: bundle,
+                                   compatibleWith: nil)
+        {
             glowImage.accessibilityIdentifier = glowImageAccessibilityIdentifier
             let imageView = UIImageView(image: glowImage)
             imageView.contentMode = .scaleAspectFit
-            
+
             return UIImageView(image: glowImage)
         } else {
             fatalError("Can't initialize gloweffect image")
         }
     }
-    
 }

package/apple/tvos/Views/ParallaxView/Other/ParallaxMotionEffect.swift

@@ -8,36 +8,33 @@
 import UIKit
 
 open class ParallaxMotionEffect: UIMotionEffect {
-
     // MARK: Properties
-    
-    
+
     /// Disables Motion Effect
     open var isDisabled = false
-    
+
     /// How far camera is from the object
     open var cameraPositionZ = CGFloat(0)
 
     /// The maximum angle horizontally
-    open var viewingAngleX = CGFloat(Double.pi/4/8)
+    open var viewingAngleX = CGFloat(Double.pi / 4 / 8)
 
     /// The maximum angle vertically
-    open var viewingAngleY = CGFloat(Double.pi/4/8)
+    open var viewingAngleY = CGFloat(Double.pi / 4 / 8)
 
     /// Maximum deviation relative to the center
     open var panValue = CGFloat(10)
 
     /// Perspective value. The closer is to 0 the deepest is the perspective
-    open var m34 = CGFloat(-1.0/700)
+    open var m34 = CGFloat(-1.0 / 700)
 
     // MARK: UIMotionEffect
 
-    override open func keyPathsAndRelativeValues(forViewerOffset viewerOffset: UIOffset) -> [String : Any]? {
-        
+    override open func keyPathsAndRelativeValues(forViewerOffset viewerOffset: UIOffset) -> [String: Any]? {
         guard isDisabled == false else {
             return nil
         }
-        
+
         var transform = CATransform3DIdentity
         transform.m34 = m34
 
@@ -45,12 +42,11 @@ open class ParallaxMotionEffect: UIMotionEffect {
         newViewerOffset.horizontal = newViewerOffset.horizontal <= -1.0 ? -1.0 : newViewerOffset.horizontal
         newViewerOffset.vertical = newViewerOffset.vertical <= -1.0 ? -1.0 : newViewerOffset.vertical
 
-        transform = CATransform3DTranslate(transform, panValue*newViewerOffset.horizontal, panValue*newViewerOffset.vertical, cameraPositionZ)
+        transform = CATransform3DTranslate(transform, panValue * newViewerOffset.horizontal, panValue * newViewerOffset.vertical, cameraPositionZ)
 
         transform = CATransform3DRotate(transform, viewingAngleX * newViewerOffset.vertical, 1, 0, 0)
         transform = CATransform3DRotate(transform, viewingAngleY * -newViewerOffset.horizontal, 0, 1, 0)
 
         return ["layer.transform": NSValue(caTransform3D: transform)]
     }
-
 }

package/apple/tvos/Views/ParallaxView/Other/ParallaxableView.swift

@@ -8,9 +8,7 @@
 import UIKit
 
 public protocol ParallaxableView: AnyObject {
-
     var parallaxEffectOptions: ParallaxEffectOptions { get set }
 
     var cornerRadius: CGFloat { get set }
-
 }

package/apple/tvos/Views/ParallaxView/ParallaxCollectionViewCell.swift

@@ -8,15 +8,14 @@
 import UIKit
 
 open class ParallaxCollectionViewCell: UICollectionViewCell, ParallaxableView {
-
     // MARK: Properties
 
     open var parallaxEffectOptions = ParallaxEffectOptions()
     open var parallaxViewActions = ParallaxViewActions<ParallaxCollectionViewCell>()
 
     // MARK: Initialization
-    
-    public override init(frame: CGRect) {
+
+    override public init(frame: CGRect) {
         super.init(frame: frame)
 
         commonInit()
@@ -44,19 +43,19 @@ open class ParallaxCollectionViewCell: UICollectionViewCell, ParallaxableView {
             parallaxEffectOptions.parallaxSubviewsContainer = contentView
         }
 
-        parallaxViewActions.setupUnfocusedState = { [weak self] (view) in
+        parallaxViewActions.setupUnfocusedState = { [weak self] view in
             guard let _self = self else { return }
             view.transform = CGAffineTransform.identity
 
-            view.layer.shadowOffset = CGSize(width: 0, height: _self.bounds.height*0.015)
+            view.layer.shadowOffset = CGSize(width: 0, height: _self.bounds.height * 0.015)
             view.layer.shadowRadius = 5
         }
 
-        parallaxViewActions.setupFocusedState = { [weak self] (view) in
+        parallaxViewActions.setupFocusedState = { [weak self] view in
             guard let _self = self else { return }
             view.transform = CGAffineTransform(scaleX: 1.15, y: 1.15)
 
-            view.layer.shadowOffset = CGSize(width: 0, height: _self.bounds.height*0.12)
+            view.layer.shadowOffset = CGSize(width: 0, height: _self.bounds.height * 0.12)
             view.layer.shadowRadius = 15
         }
 
@@ -66,7 +65,7 @@ open class ParallaxCollectionViewCell: UICollectionViewCell, ParallaxableView {
 
     // MARK: UIView
 
-    open override func layoutSubviews() {
+    override open func layoutSubviews() {
         super.layoutSubviews()
 
         guard let glowEffectContainerView = parallaxEffectOptions.glowContainerView else { return }
@@ -75,45 +74,45 @@ open class ParallaxCollectionViewCell: UICollectionViewCell, ParallaxableView {
             glowEffectContainerView.frame = glowSuperView.bounds
         }
 
-        let maxSize = max(glowEffectContainerView.frame.width, glowEffectContainerView.frame.height)*1.7
+        let maxSize = max(glowEffectContainerView.frame.width, glowEffectContainerView.frame.height) * 1.7
         // Make glow a litte bit bigger than the superview
 
         guard let glowImageView = getGlowImageView() else { return }
 
         glowImageView.frame = CGRect(x: 0, y: 0, width: maxSize, height: maxSize)
         // Position in the middle and under the top edge of the superview
-        glowImageView.center = CGPoint(x: glowEffectContainerView.frame.width/2, y: -glowImageView.frame.height)
+        glowImageView.center = CGPoint(x: glowEffectContainerView.frame.width / 2, y: -glowImageView.frame.height)
     }
 
     // MARK: UIResponder
 
     // Generally, all responders which do custom touch handling should override all four of these methods.
     // If you want to customize animations for press events do not forget to call super.
-    open override func pressesBegan(_ presses: Set<UIPress>, with event: UIPressesEvent?) {
+    override open func pressesBegan(_ presses: Set<UIPress>, with event: UIPressesEvent?) {
         parallaxViewActions.animatePressIn?(self, presses, event, {})
 
         super.pressesBegan(presses, with: event)
     }
 
-    open override func pressesCancelled(_ presses: Set<UIPress>, with event: UIPressesEvent?) {
-        parallaxViewActions.animatePressOut?(self, presses, event,{})
+    override open func pressesCancelled(_ presses: Set<UIPress>, with event: UIPressesEvent?) {
+        parallaxViewActions.animatePressOut?(self, presses, event, {})
 
         super.pressesCancelled(presses, with: event)
     }
 
-    open override func pressesEnded(_ presses: Set<UIPress>, with event: UIPressesEvent?) {
-        parallaxViewActions.animatePressOut?(self, presses, event,{})
+    override open func pressesEnded(_ presses: Set<UIPress>, with event: UIPressesEvent?) {
+        parallaxViewActions.animatePressOut?(self, presses, event, {})
 
         super.pressesEnded(presses, with: event)
     }
 
-    open override func pressesChanged(_ presses: Set<UIPress>, with event: UIPressesEvent?) {
+    override open func pressesChanged(_ presses: Set<UIPress>, with event: UIPressesEvent?) {
         super.pressesChanged(presses, with: event)
     }
 
     // MARK: UIFocusEnvironment
 
-    open override func didUpdateFocus(in context: UIFocusUpdateContext, with coordinator: UIFocusAnimationCoordinator) {
+    override open func didUpdateFocus(in context: UIFocusUpdateContext, with coordinator: UIFocusAnimationCoordinator) {
         super.didUpdateFocus(in: context, with: coordinator)
 
         if self == context.nextFocusedView {
@@ -121,8 +120,7 @@ open class ParallaxCollectionViewCell: UICollectionViewCell, ParallaxableView {
             parallaxViewActions.becomeFocused?(self, context, coordinator, {})
         } else if self == context.previouslyFocusedView {
             // Remove parallax effect
-            parallaxViewActions.resignFocus?(self, context, coordinator,{})
+            parallaxViewActions.resignFocus?(self, context, coordinator, {})
         }
     }
-
 }