expo-dev-menu 2.1.4 → 3.0.0

package/ios/OverlayContainer/Internal/Views/OverlayContainerView.swift

@@ -0,0 +1,10 @@
+//  Copyright (c) 2018, Applidium. All rights reserved
+//  OverlayContainerView.swift
+//  OverlayContainer
+//
+//  Created by Gaétan Zanella on 14/11/2018.
+//
+
+import UIKit
+
+class OverlayContainerView: PassThroughView {}

package/ios/OverlayContainer/Internal/Views/OverlayTranslationContainerView.swift

@@ -0,0 +1,10 @@
+//  Copyright (c) 2018, Applidium. All rights reserved
+//  OverlayTranslationView.swift
+//  OverlayContainer
+//
+//  Created by Gaétan Zanella on 14/11/2018.
+//
+
+import UIKit
+
+class OverlayTranslationContainerView: PassThroughView {}

package/ios/OverlayContainer/Internal/Views/OverlayTranslationView.swift

@@ -0,0 +1,10 @@
+//  Copyright (c) 2018, Applidium. All rights reserved
+//  OverlayTranslationView.swift
+//  OverlayContainer
+//
+//  Created by Gaétan Zanella on 14/11/2018.
+//
+
+import UIKit
+
+class OverlayTranslationView: PassThroughView {}

package/ios/OverlayContainer/OverlayContainerPresentationController.swift

@@ -0,0 +1,88 @@
+//  Copyright (c) 2018, Applidium. All rights reserved
+//  OverlayContainerPresentationController.swift
+//  
+//
+//  Created by Gaétan Zanella on 07/04/2020.
+//
+
+import UIKit
+
+/// An abstract class that can be used to manage the transition animations and the presentation of overlay containers onscreen.
+///
+/// Any overlay containers currently in the presented view controller hierarchy will be coupled with it.
+/// It lets you add custom presentation behaviors based on the current state of the presented overlay containers.
+///
+/// This class is meant to be subclassed. Before you consider subclassing, though, you should look at
+/// the `OverlayContainerSheetPresentationController` class to see if it can be adapted to your presentation behavior.
+open class OverlayContainerPresentationController: UIPresentationController {
+
+    // MARK: - Internal
+
+    open override func presentationTransitionWillBegin() {
+        super.presentationTransitionWillBegin()
+        findPresentedContainers().forEach { $0.overlayContainerPresentationTransitionWillBegin() }
+    }
+
+    open override func dismissalTransitionDidEnd(_ completed: Bool) {
+        super.dismissalTransitionDidEnd(completed)
+        findPresentedContainers().forEach { $0.overlayContainerDismissalTransitionDidEnd() }
+    }
+
+    // MARK: - Public
+
+    /// Tells the presentation controller when the user is about to start dragging the overlay view controller.
+    ///
+    /// - parameter containerViewController: The container requesting this information.
+    /// - parameter overlayViewController: The overlay view controller.
+    open func overlayContainerViewController(_ containerViewController: OverlayContainerViewController,
+                                             willStartDraggingOverlay overlayViewController: UIViewController) {}
+
+    /// Tells the presentation controller when the user finishs dragging the overlay view controller with the specified velocity.
+    ///
+    /// - parameter containerViewController: The container requesting this information.
+    /// - parameter overlayViewController: The overlay view controller.
+    /// - parameter velocity: The overlay velocity at the moment the touch was released.
+    open func overlayContainerViewController(_ containerViewController: OverlayContainerViewController,
+                                             willEndDraggingOverlay overlayViewController: UIViewController,
+                                             atVelocity velocity: CGPoint) {}
+
+    /// Tells the presentation controller when the container is about to move the overlay view controller to the specified notch.
+    ///
+    /// In some cases, the overlay view controller may not successfully reach the specified notch.
+    /// If the user cancels the translation for instance. Use `overlayContainerViewController(_:didMove:toNotchAt:)`
+    /// if you need to be notified each time the translation succeeds.
+    ///
+    /// - parameter containerViewController: The container requesting this information.
+    /// - parameter overlayViewController: The overlay view controller.
+    /// - parameter index: The notch index the overlay view controller is about to reach.
+    open func overlayContainerViewController(_ containerViewController: OverlayContainerViewController,
+                                             willMoveOverlay overlayViewController: UIViewController,
+                                             toNotchAt index: Int) {}
+
+    /// Tells the presentation controller when the container has moved the overlay view controller to the specified notch.
+    ///
+    /// - parameter containerViewController: The container requesting this information.
+    /// - parameter overlayViewController: The overlay view controller.
+    /// - parameter index: The notch index the overlay view controller has reached.
+    open func overlayContainerViewController(_ containerViewController: OverlayContainerViewController,
+                                             didMoveOverlay overlayViewController: UIViewController,
+                                             toNotchAt index: Int) {}
+
+    /// Tells the presentation controller whenever the overlay view controller is about to be translated.
+    ///
+    /// The delegate typically implements this method to coordinate presentation changes alongside
+    /// the overlay view controller translation.
+    ///
+    /// - parameter containerViewController: The container requesting this information.
+    /// - parameter overlayViewController: The overlay view controller.
+    /// - parameter transitionCoordinator: The transition coordinator object associated with the translation.
+    open func overlayContainerViewController(_ containerViewController: OverlayContainerViewController,
+                                             willTranslateOverlay overlayViewController: UIViewController,
+                                             transitionCoordinator: OverlayContainerTransitionCoordinator) {}
+
+    // MARK: - Private
+
+    private func findPresentedContainers() -> [OverlayContainerViewController] {
+        presentedViewController.oc_findChildren(OverlayContainerViewController.self)
+    }
+}

package/ios/OverlayContainer/OverlayContainerSheetDimmingView.swift

@@ -0,0 +1,81 @@
+//  Copyright (c) 2018, Applidium. All rights reserved
+//  OverlayContainerPresentationDimmingView.swift
+//  OverlayContainer
+//
+//  Created by Gaétan Zanella on 08/04/2020.
+//
+
+import UIKit
+
+/// An interface that enables a view to coordinate its appearance change alongside the container presentation animations and the presented overlay translations.
+public protocol OverlayContainerSheetDimmingView: UIView {
+    /// Notifies the view that the presentation animations are about to start.
+    func presentationTransitionWillBegin()
+    /// Notifies the view that the presentation animations starts. This method is called in an animation block.
+    func presentationTransitionDidBegin()
+    /// Notifies the view that the dismissal animations are about to start.
+    func dismissalTransitionWillBegin()
+    /// Notifies the view that the dismissal animations starts. This method is called in an animation block.
+    func dismissalTransitionDidBegin()
+    /// Notifies the view that a presented overlay is about to be moved. This method is called in an animation block.
+    ///
+    /// - parameter context: The context object containing information about the current overlay container state.
+    func overlayViewControllerWillTranslate(context: OverlayContainerTransitionCoordinatorContext)
+}
+
+public extension OverlayContainerSheetDimmingView {
+    func presentationTransitionWillBegin() {}
+    func presentationTransitionDidBegin() {}
+    func dismissalTransitionWillBegin() {}
+    func dismissalTransitionDidBegin() {}
+    func overlayViewControllerWillTranslate(context: OverlayContainerTransitionCoordinatorContext) {}
+}
+
+/// An `OverlayContainerSheetDimmingView` class that coordinates its alpha value alongside the container presentation animations
+/// and the presented overlay translations.
+open class TransparentOverlayContainerSheetDimmingView: UIView, OverlayContainerSheetDimmingView {
+
+    /// The view alpha when the container is dismissed.
+    open var dismissedAlpha: CGFloat = 0.0
+    /// The view alpha when the overlay reaches its minimum notch.
+    open var minimumAlpha: CGFloat = 0.3
+    /// The view alpha when the overlay reaches its maximum notch.
+    open var maximumAlpha: CGFloat = 0.6
+
+    // MARK: - Life Cycle
+
+    public override init(frame: CGRect) {
+        super.init(frame: frame)
+        setUp()
+    }
+
+    public required init?(coder aDecoder: NSCoder) {
+        super.init(coder: aDecoder)
+        setUp()
+    }
+
+    // MARK: - OverlayContainerSheetDimmingView
+
+    open func presentationTransitionWillBegin() {
+        alpha = dismissedAlpha
+    }
+
+    open func presentationTransitionDidBegin() {
+        alpha = minimumAlpha
+    }
+
+    public func dismissalTransitionDidBegin() {
+        alpha = dismissedAlpha
+    }
+
+    public func overlayViewControllerWillTranslate(context: OverlayContainerTransitionCoordinatorContext) {
+        let target = minimumAlpha + context.translationProgress() * (maximumAlpha - minimumAlpha)
+        alpha = max(min(target, 1.0), 0)
+    }
+
+    // MARK: - Private
+
+    private func setUp() {
+        backgroundColor = .black
+    }
+}

package/ios/OverlayContainer/OverlayContainerSheetDismissalPolicy.swift

@@ -0,0 +1,91 @@
+//  Copyright (c) 2018, Applidium. All rights reserved
+//  OverlayContainerSheetDismissalPolicy.swift
+//  OverlayContainer
+//
+//  Created by Gaétan Zanella on 07/04/2020.
+//
+
+import UIKit
+
+/// A protocol that provides contextual information on the drag-to-dismiss gesture state.
+public protocol OverlayContainerSheetDismissalPolicyContext: OverlayContainerTransitionContext {
+    /// The expected translation height once the animation ended.
+    var targetTranslationHeight: CGFloat { get }
+}
+
+/// A protocol that defines the dismissal policy associated to an overlay container sheet controller.
+public protocol OverlayContainerSheetDismissalPolicy {
+    /// Asks the policy if the presented view controller should be dismissed when a drag-to-dismiss gesture happens.
+    ///
+    /// - parameter context: The context object containing information about the current overlay container state.
+    ///
+    /// - returns: `true` if the presented view controller should be dismissed or `false` if it should not.
+    func shouldDismiss(using context: OverlayContainerSheetDismissalPolicyContext) -> Bool
+}
+
+/// The policy used by the sheet presentation controller by default.
+public struct ThresholdOverlayContainerSheetDismissalPolicy: OverlayContainerSheetDismissalPolicy {
+
+    /// `Position` defines a position that can dismiss the overlay container.
+    public enum Position {
+        /// The policy ignores the overlay translation height
+        case none
+        /// If the overlay goes under the specified notch, the policy dismisses it.
+        case notch(index: Int)
+        /// If the overlay goes under the specified translation height, the policy dismisses it.
+        case translationHeight(CGFloat)
+    }
+
+    /// `Velocity` defines a velocity that can dismiss the overlay container.
+    public enum Velocity {
+        /// The policy ignores the overlay translation velocity
+        case none
+        /// If the overlay goes faster than the specified value, the policy dismisses the container.
+        case value(CGFloat)
+    }
+
+    /// A velocity that can trigger a dismissal.
+    public var dismissingVelocity: Velocity
+
+    /// A position that can trigger a dismissal.
+    public var dismissingPosition: Position
+
+    // MARK: - Life Cycle
+
+    /// Creates a `ThresholdOverlayContainerSheetDismissalPolicy` instance.
+    ///
+    /// - parameter dismissingVelocity: A velocity that can trigger a dismissal. The default value is `2400.0` pts/s.
+    /// - parameter dismissingPosition: A position that can trigger a dismissal. The default value is the first container notch.
+    ///
+    /// - returns: The new`ThresholdOverlayContainerSheetDismissalPolicy` instance.
+    public init(dismissingVelocity: Velocity = .value(2400.0),
+                dismissingPosition: Position = .notch(index: 0)) {
+        self.dismissingVelocity = dismissingVelocity
+        self.dismissingPosition = dismissingPosition
+    }
+
+    // MARK: - OverlayContainerDimissingPolicy
+
+    public func shouldDismiss(using context: OverlayContainerSheetDismissalPolicyContext) -> Bool {
+        guard !context.isDragging else { return false  }
+        let translationHeight = context.targetTranslationHeight
+        switch dismissingPosition {
+        case .none:
+            break
+        case let .notch(index):
+            if translationHeight < context.height(forNotchAt: index) {
+                return true
+            }
+        case let .translationHeight(height):
+            if translationHeight < height {
+                return true
+            }
+        }
+        switch dismissingVelocity {
+        case .none:
+            return false
+        case let .value(value):
+            return context.velocity.y > value
+        }
+    }
+}

package/ios/OverlayContainer/OverlayContainerSheetPresentationController.swift

@@ -0,0 +1,156 @@
+//  Copyright (c) 2018, Applidium. All rights reserved
+//  OverlayContainerSheetPresentationController.swift
+//  OverlayContainer
+//
+//  Created by Gaétan Zanella on 08/04/2020.
+//
+
+import UIKit
+
+/// An `OverlayContainerPresentationController` subclass that can be used to manage the transition animations and the presentation of overlay containers onscreen.
+///
+/// It adds a dimming layer over the presenting content and changes its appearance based on the current container translations.
+/// It also includes two dismissal gestures: tap-to-dismiss and drag-to-dismiss.
+///
+/// You can subclass this class if you need an extra level of customization.
+open class OverlayContainerSheetPresentationController: OverlayContainerPresentationController {
+
+    // MARK: - Public properties
+
+    /// The delegate of the presentation controller.
+    open weak var sheetDelegate: OverlayContainerSheetPresentationControllerDelegate?
+
+    /// A dimming view added in the container view.
+    ///
+    /// The default implementation of this property returns the view you provided in the `init` method.
+    open private(set) var dimmingView: OverlayContainerSheetDimmingView?
+
+    /// The underlying gesture recognizer for tap-to-dismiss gesture.
+    open private(set) lazy var dismissingTapGestureRecognizer: UITapGestureRecognizer = self.makeTapGestureRecognizer()
+
+    // MARK: - Private properties
+
+    private lazy var tapGestureRecognizerView: UIView = self.makeTapGestureRecognizerView()
+
+    // MARK: - Life Cycle
+
+    /// Initializes and returns a presentation controller for transitioning between the specified view controllers.
+    ///
+    /// - parameter dimmingView: The view used as a dimming view. The default value is a `TransparentOverlayContainerPresentationDimmingView` instance.
+    /// - parameter presentedViewController: The view controller being presented modally.
+    /// - parameter dimmingView: The view controller whose content represents the starting point of the transition.
+    ///
+    /// - returns: The new `OverlayContainerPresentationController` instance.
+    ///
+    /// The `presentedViewController` can be an overlay container or the parent view controller of an overlay container.
+    public init(dimmingView: OverlayContainerSheetDimmingView? = TransparentOverlayContainerSheetDimmingView(),
+                presentedViewController: UIViewController,
+                presenting: UIViewController?) {
+        self.dimmingView = dimmingView
+        super.init(
+            presentedViewController: presentedViewController,
+            presenting: presenting
+        )
+    }
+
+    // MARK: - OverlayContainerPresentationController
+
+    open override func overlayContainerViewController(_ containerViewController: OverlayContainerViewController,
+                                                      willTranslateOverlay overlayViewController: UIViewController,
+                                                      transitionCoordinator: OverlayContainerTransitionCoordinator) {
+        let dismissalContext = ConcreteOverlayContainerDismissalPolicyContext(
+            context: transitionCoordinator
+        )
+        transitionCoordinator.animate(alongsideTransition: { [weak self] context in
+            self?.dimmingView?.overlayViewControllerWillTranslate(context: context)
+        }, completion: nil)
+        let policy = makeDismissalPolicy()
+        if !presentedViewController.isBeingDismissed && policy.shouldDismiss(using: dismissalContext) {
+            presentingViewController.dismiss(animated: true, completion: nil)
+        }
+    }
+
+    // MARK: - UIPresentationController
+
+    open override func presentationTransitionWillBegin() {
+        super.presentationTransitionWillBegin()
+        startDimmingViewPresentationTransition()
+        setUpTapGesture()
+    }
+
+    open override func dismissalTransitionWillBegin() {
+        super.dismissalTransitionWillBegin()
+        startDimmingViewDismissalTransition()
+    }
+
+    open override func presentationTransitionDidEnd(_ completed: Bool) {
+        super.presentationTransitionDidEnd(completed)
+        guard !completed else { return }
+        dimmingView?.removeFromSuperview()
+        tapGestureRecognizerView.removeFromSuperview()
+    }
+
+    // MARK: - Action
+
+    @objc private func tapGestureAction(_ sender: UITapGestureRecognizer) {
+        let shouldDismiss = sheetDelegate?.overlayContainerSheetPresentationControllerShouldDismissOnTap(self) ?? true
+        guard shouldDismiss else { return }
+        presentedViewController.dismiss(animated: true, completion: nil)
+    }
+
+    // MARK: - Private
+
+    private func setUpTapGesture() {
+        guard tapGestureRecognizerView.superview == nil,
+            dismissingTapGestureRecognizer.isEnabled else {
+                return
+        }
+        containerView?.addSubview(tapGestureRecognizerView)
+        tapGestureRecognizerView.pinToSuperview()
+        tapGestureRecognizerView.addGestureRecognizer(dismissingTapGestureRecognizer)
+    }
+
+    private func startDimmingViewPresentationTransition() {
+        guard let dimmingView = dimmingView else { return }
+        if dimmingView.superview == nil {
+            containerView?.addSubview(dimmingView)
+            dimmingView.pinToSuperview()
+        }
+        containerView?.layoutIfNeeded()
+        dimmingView.presentationTransitionWillBegin()
+        presentedViewController.transitionCoordinator?.animate(alongsideTransition: { _ in
+            dimmingView.presentationTransitionDidBegin()
+        }, completion: nil)
+    }
+
+    private func startDimmingViewDismissalTransition() {
+        guard let dimmingView = dimmingView else { return }
+        dimmingView.dismissalTransitionWillBegin()
+        presentedViewController.transitionCoordinator?.animate(alongsideTransition: { _ in
+            dimmingView.dismissalTransitionDidBegin()
+        }, completion: nil)
+    }
+
+    private func makeDismissalPolicy() -> OverlayContainerSheetDismissalPolicy {
+        sheetDelegate?.overlayContainerSheetDismissalPolicy(for: self) ?? ThresholdOverlayContainerSheetDismissalPolicy()
+    }
+
+    private func makeTapGestureRecognizerView() -> UIView {
+        UIView()
+    }
+
+    private func makeTapGestureRecognizer() -> UITapGestureRecognizer {
+        UITapGestureRecognizer(target: self, action: #selector(tapGestureAction(_:)))
+    }
+}
+
+public extension OverlayContainerSheetPresentationControllerDelegate {
+
+    func overlayContainerSheetPresentationControllerShouldDismissOnTap(_ presentationController: OverlayContainerSheetPresentationController) -> Bool {
+        true
+    }
+
+    func overlayContainerSheetDismissalPolicy(for presentationController: OverlayContainerSheetPresentationController) -> OverlayContainerSheetDismissalPolicy {
+        ThresholdOverlayContainerSheetDismissalPolicy()
+    }
+}

package/ios/OverlayContainer/OverlayContainerSheetPresentationControllerDelegate.swift

@@ -0,0 +1,26 @@
+//  Copyright (c) 2018, Applidium. All rights reserved
+//  OverlayContainerSheetPresentationControllerDelegate.swift
+//  OverlayContainer
+//
+//  Created by Gaétan Zanella on 08/04/2020.
+//
+
+import UIKit
+
+/// The presentation controller delegate is responsible for defining the aspect and the behavior of the controller.
+public protocol OverlayContainerSheetPresentationControllerDelegate: AnyObject {
+
+    /// Asks the delegate for the dismissal policy associated to the specified presentation controller.
+    ///
+    /// The default implementation of this method returns a `ThresholdOverlayContainerSheetDismissalPolicy` instance.
+    ///
+    /// - parameter presentationController: The presentation controller requesting this information.
+    func overlayContainerSheetDismissalPolicy(for presentationController: OverlayContainerSheetPresentationController) -> OverlayContainerSheetDismissalPolicy
+
+    /// Asks the delegate if the presentation controller should dismiss the presented containers when a touch occured in the presentation container view.
+    ///
+    /// The default implementation of this method returns `true`.
+    ///
+    /// - parameter presentationController: The presentation controller requesting this information.
+    func overlayContainerSheetPresentationControllerShouldDismissOnTap(_ presentationController: OverlayContainerSheetPresentationController) -> Bool
+}

package/ios/OverlayContainer/OverlayContainerTransitionCoordinator.swift

@@ -0,0 +1,80 @@
+//  Copyright (c) 2018, Applidium. All rights reserved
+//  OverlayAnimationCoordinator.swift
+//  OverlayContainer
+//
+//  Created by Gaétan Zanella on 14/11/2018.
+//
+
+import UIKit
+
+/// A protocol that provides information about the current overlay translation.
+public protocol OverlayContainerTransitionContext {
+    /// A Boolean value that indicates whether the user is currently dragging the overlay.
+    var isDragging: Bool { get }
+    /// The overlay velocity.
+    var velocity: CGPoint { get }
+    /// The current translation height.
+    var overlayTranslationHeight: CGFloat { get }
+    /// The notch indexes.
+    var notchIndexes: Range<Int> { get }
+    /// The reachable indexes. Some indexes might be disabled by the `canReachNotchAt` delegate method.
+    var reachableIndexes: [Int] { get }
+    /// Returns the height of the specified notch.
+    func height(forNotchAt index: Int) -> CGFloat
+}
+
+public extension OverlayContainerTransitionContext {
+
+    func minimumReachableHeight() -> CGFloat {
+        return reachableIndexes.first.flatMap { height(forNotchAt: $0) } ?? 0
+    }
+
+    func maximumReachableHeight() -> CGFloat {
+        return reachableIndexes.last.flatMap { height(forNotchAt: $0) } ?? 0
+    }
+
+    func minimumHeight() -> CGFloat {
+        return notchIndexes.first.flatMap { height(forNotchAt: $0) } ?? 0
+    }
+
+    func maximumHeight() -> CGFloat {
+        return notchIndexes.last.flatMap { height(forNotchAt: $0) } ?? 0
+    }
+}
+
+
+/// A protocol that provides information about an in-progress translation.
+/// Do not adopt this protocol in your own classes. Use the one provided by the `OverlayContainerTransitionCoordinator`.
+public protocol OverlayContainerTransitionCoordinatorContext: OverlayContainerTransitionContext {
+    /// A Boolean value indicating whether the transition is explicitly animated.
+    var isAnimated: Bool { get }
+    /// A Boolean value indicating whether the transition was cancelled.
+    var isCancelled: Bool { get }
+    /// The overlay height the container expects to reach.
+    var targetTranslationHeight: CGFloat { get }
+}
+
+/// A protocol that provides support for animations associated with an overlay translation.
+///
+/// Do not adopt this procotol in your own classes. Use the one provided by the `OverlayContainerDelegate` to
+/// add any extra animations alongside the translation animations.
+public protocol OverlayContainerTransitionCoordinator: OverlayContainerTransitionCoordinatorContext {
+    /// Runs the specified animations at the same time as overlay translation end animations.
+    func animate(alongsideTransition animation: ((OverlayContainerTransitionCoordinatorContext) -> Void)?,
+                 completion: ((OverlayContainerTransitionCoordinatorContext) -> Void)?)
+}
+
+public extension OverlayContainerTransitionCoordinatorContext {
+
+    func translationProgress() -> CGFloat {
+        let maximum = maximumReachableHeight()
+        let minimum = minimumReachableHeight()
+        return maximum != minimum ? (targetTranslationHeight - minimum) / (maximum - minimum) : 0
+    }
+
+    func overallTranslationProgress() -> CGFloat {
+        let maximum = maximumHeight()
+        let minimum = minimumHeight()
+        return maximum != minimum ? (targetTranslationHeight - minimum) / (maximum - minimum) : 0
+    }
+}