expo-dev-menu 2.2.0 → 3.0.0

package/ios/OverlayContainer/Internal/DraggingOverlayContainerTransitionCoordinator.swift

@@ -0,0 +1,76 @@
+//  Copyright (c) 2018, Applidium. All rights reserved
+//  InterruptibleAnimatorOverlayContainerTransitionCoordinator.swift
+//  OverlayContainer
+//
+//  Created by Gaétan Zanella on 28/11/2018.
+//
+
+import UIKit
+
+private typealias Completion = (OverlayContainerTransitionCoordinatorContext) -> Void
+
+class DraggingOverlayContainerTransitionCoordinator: OverlayContainerTransitionCoordinator {
+
+    private let context: OverlayContainerTransitionCoordinatorContext
+
+    private var completions: [Completion] = []
+
+    // MARK: - Life Cycle
+
+    init(context: OverlayContainerTransitionCoordinatorContext) {
+        self.context = context
+    }
+
+    // MARK: - Public
+
+    func performCompletions(with context: OverlayContainerTransitionCoordinatorContext) {
+        completions.forEach { $0(context) }
+        completions = []
+    }
+
+    // MARK: - OverlayContainerTransitionCoordinatorContext
+
+    var isDragging: Bool {
+        return context.isDragging
+    }
+
+    var velocity: CGPoint {
+        return context.velocity
+    }
+
+    var isCancelled: Bool {
+        return context.isCancelled
+    }
+
+    var isAnimated: Bool {
+        return context.isAnimated
+    }
+
+    var targetTranslationHeight: CGFloat {
+        return context.targetTranslationHeight
+    }
+
+    var overlayTranslationHeight: CGFloat {
+        return context.overlayTranslationHeight
+    }
+
+    var notchIndexes: Range<Int> {
+        return context.notchIndexes
+    }
+
+    var reachableIndexes: [Int] {
+        return context.reachableIndexes
+    }
+
+    func height(forNotchAt index: Int) -> CGFloat {
+        return context.height(forNotchAt: index)
+    }
+
+    // MARK: - OverlayContainerTransitionCoordinator
+
+    func animate(alongsideTransition animation: ((OverlayContainerTransitionCoordinatorContext) -> Void)?,
+                 completion: ((OverlayContainerTransitionCoordinatorContext) -> Void)?) {
+        animation?(context)
+        completion.flatMap { completions.append($0) }
+    }
+}

package/ios/OverlayContainer/Internal/Extensions/CGFloat+Round.swift

@@ -0,0 +1,16 @@
+//  Copyright (c) 2018, Applidium. All rights reserved
+//  CGFloat+Round.swift
+//  FluxTire
+//
+//  Created by Gaétan Zanella on 17/10/2018.
+//  
+
+import Foundation
+import CoreGraphics
+
+extension CGFloat {
+    func oc_rounded(toDecimals decimals: Int = 2) -> CGFloat {
+        let multiplier = CGFloat(pow(Double(10), Double(decimals)))
+        return (self * multiplier).rounded() / multiplier
+    }
+}

package/ios/OverlayContainer/Internal/Extensions/CGGeometry+Utils.swift

@@ -0,0 +1,26 @@
+//  Copyright (c) 2018, Applidium. All rights reserved
+//  Geometry+Utils.swift
+//  OverlayContainer
+//
+//  Created by Gaétan Zanella on 22/11/2018.
+//
+
+import UIKit
+
+extension CGPoint {
+    func offset(by point: CGPoint) -> CGPoint {
+        return offsetBy(dx: point.x, dy: point.y)
+    }
+
+    func offsetBy(dx: CGFloat, dy: CGFloat) -> CGPoint {
+        return CGPoint(x: x + dx, y: y + dy)
+    }
+
+    func multiply(by multiplier: CGFloat) -> CGPoint {
+        return multiplyBy(dx: multiplier, dy: multiplier)
+    }
+
+    func multiplyBy(dx: CGFloat, dy: CGFloat) -> CGPoint {
+        return CGPoint(x: x * dx, y: y * dy)
+    }
+}

package/ios/OverlayContainer/Internal/Extensions/OverlayContainerViewControllerDelegate+Defaults.swift

@@ -0,0 +1,58 @@
+//  Copyright (c) 2018, Applidium. All rights reserved
+//  OverlayContainerViewControllerDelegate+Defaults.swift
+//  OverlayContainer
+//
+//  Created by Gaétan Zanella on 23/11/2018.
+//
+
+import UIKit
+
+public extension OverlayContainerViewControllerDelegate {
+    func overlayContainerViewController(_ containerViewController: OverlayContainerViewController,
+                                        transitioningDelegateForOverlay overlayViewController: UIViewController) -> OverlayTransitioningDelegate? {
+        return nil
+    }
+
+    func overlayContainerViewController(_ containerViewController: OverlayContainerViewController,
+                                        scrollViewDrivingOverlay overlayViewController: UIViewController) -> UIScrollView? {
+        return nil
+    }
+
+    func overlayContainerViewController(_ containerViewController: OverlayContainerViewController,
+                                        shouldStartDraggingOverlay overlayViewController: UIViewController,
+                                        at point: CGPoint,
+                                        in coordinateSpace: UICoordinateSpace) -> Bool {
+        let convertedPoint = coordinateSpace.convert(point, to: overlayViewController.view)
+        return overlayViewController.view.bounds.contains(convertedPoint)
+    }
+
+    func overlayContainerViewController(_ containerViewController: OverlayContainerViewController,
+                                        overlayTranslationFunctionForOverlay overlayViewController: UIViewController) -> OverlayTranslationFunction? {
+        return nil
+    }
+
+    func overlayContainerViewController(_ containerViewController: OverlayContainerViewController,
+                                        willMoveOverlay overlayViewController: UIViewController,
+                                        toNotchAt index: Int) {}
+
+    func overlayContainerViewController(_ containerViewController: OverlayContainerViewController,
+                                        didMoveOverlay overlayViewController: UIViewController,
+                                        toNotchAt index: Int) {}
+
+    func overlayContainerViewController(_ containerViewController: OverlayContainerViewController,
+                                        willStartDraggingOverlay overlayViewController: UIViewController) {}
+
+    func overlayContainerViewController(_ containerViewController: OverlayContainerViewController,
+                                        willEndDraggingOverlay overlayViewController: UIViewController,
+                                        atVelocity velocity: CGPoint) {}
+
+    func overlayContainerViewController(_ containerViewController: OverlayContainerViewController,
+                                        willTranslateOverlay overlayViewController: UIViewController,
+                                        transitionCoordinator: OverlayContainerTransitionCoordinator) {}
+
+    func overlayContainerViewController(_ containerViewController: OverlayContainerViewController,
+                                        canReachNotchAt index: Int,
+                                        forOverlay overlayViewController: UIViewController) -> Bool {
+        return true
+    }
+}

package/ios/OverlayContainer/Internal/Extensions/UIPanGesture+Utils.swift

@@ -0,0 +1,28 @@
+//  Copyright (c) 2018, Applidium. All rights reserved
+//  UIPanGesture+Utils.swift
+//  Pods
+//
+//  Created by Gaétan Zanella on 28/11/2018.
+//
+
+import UIKit
+
+extension UIPanGestureRecognizer {
+
+    enum VerticalDirection {
+        case up
+        case down
+        case none
+    }
+
+    var yDirection: VerticalDirection {
+        let yVelocity = velocity(in: nil).y
+        if yVelocity == 0 {
+            return .none
+        }
+        if yVelocity < 0 {
+            return .up
+        }
+        return .down
+    }
+}

package/ios/OverlayContainer/Internal/Extensions/UIScrollViiew+Utils.swift

@@ -0,0 +1,40 @@
+//  Copyright (c) 2018, Applidium. All rights reserved
+//  UIScrollViiew+Utils.swift
+//  Pods
+//
+//  Created by Gaétan Zanella on 28/11/2018.
+//
+
+import UIKit
+
+extension UIScrollView {
+
+    var scrollsUp: Bool {
+        return panGestureRecognizer.yDirection == .up
+    }
+
+    var isContentOriginInBounds: Bool {
+        topOffsetInContent <= 0.0
+    }
+
+    var topOffsetInContent: CGFloat {
+        contentOffset.y + oc_adjustedContentInset.top
+    }
+
+    func scrollToTop() {
+        contentOffset.y = -oc_adjustedContentInset.top
+    }
+}
+
+
+extension UIScrollView {
+    
+    var oc_adjustedContentInset: UIEdgeInsets {
+        if #available(iOS 11.0, *) {
+            return self.adjustedContentInset
+        } else {
+            // Fallback on earlier versions
+            return self.contentInset
+        }
+    }
+}

package/ios/OverlayContainer/Internal/Extensions/UIView+Constraints.swift

@@ -0,0 +1,28 @@
+//  Copyright (c) 2018, Applidium. All rights reserved
+//  UIView+Layout.swift
+//  OverlayContainer
+//
+//  Created by Gaétan Zanella on 19/11/2018.
+//
+
+import UIKit
+
+extension UIView {
+    func pinToSuperview(with insets: UIEdgeInsets = .zero, edges: UIRectEdge = .all) {
+        guard let superview = superview else { return }
+        translatesAutoresizingMaskIntoConstraints = false
+        if edges.contains(.top) {
+            topAnchor.constraint(equalTo: superview.topAnchor, constant: insets.top).isActive = true
+        }
+        if edges.contains(.bottom) {
+            bottomAnchor.constraint(equalTo: superview.bottomAnchor, constant: -insets.bottom).isActive = true
+        }
+        if edges.contains(.left) {
+            leadingAnchor.constraint(equalTo: superview.leadingAnchor, constant: insets.left).isActive = true
+        }
+        if edges.contains(.right) {
+            trailingAnchor.constraint(equalTo: superview.trailingAnchor, constant: -insets.right).isActive = true
+        }
+    }
+}
+

package/ios/OverlayContainer/Internal/Extensions/UIView+Subviews.swift

@@ -0,0 +1,14 @@
+//  Copyright (c) 2018, Applidium. All rights reserved
+//  UIView+Subviews.swift
+//  OverlayContainer
+//
+//  Created by Gaétan Zanella on 19/11/2018.
+//
+
+import UIKit
+
+extension UIView {
+    func removeAllSubviews() {
+        subviews.forEach { $0.removeFromSuperview() }
+    }
+}

package/ios/OverlayContainer/Internal/Extensions/UIViewController+Children.swift

@@ -0,0 +1,40 @@
+//  Copyright (c) 2018, Applidium. All rights reserved
+//  UIViewController+Children.swift
+//  OverlayContainer
+//
+//  Created by Gaétan Zanella on 19/11/2018.
+//
+
+import UIKit
+
+extension UIViewController {
+    func addChild(_ child: UIViewController, in containerView: UIView) {
+        guard containerView.isDescendant(of: view) else { return }
+        addChild(child)
+        containerView.addSubview(child.view)
+        child.view.pinToSuperview()
+        child.didMove(toParent: self)
+    }
+
+    func removeChild(_ child: UIViewController) {
+        child.willMove(toParent: nil)
+        child.view.removeFromSuperview()
+        child.removeFromParent()
+    }
+
+
+    func oc_findPresentationController<Controller: UIPresentationController>(_ type: Controller.Type) -> Controller? {
+        if let controller = presentationController as? Controller {
+            return controller
+        }
+        return parent?.oc_findPresentationController(Controller.self)
+    }
+
+    func oc_findChildren<Controller: UIViewController>(_ type: Controller.Type) -> [Controller] {
+        if let controller = self as? Controller {
+            return [controller]
+        } else {
+            return children.map { $0.oc_findChildren(type) }.flatMap { $0 }
+        }
+    }
+}

package/ios/OverlayContainer/Internal/HeightContraintOverlayTranslationController.swift

@@ -0,0 +1,296 @@
+//  Copyright (c) 2018, Applidium. All rights reserved
+//  HeightConstraintOverlayTranslationController.swift
+//  OverlayContainer
+//
+//  Created by Gaétan Zanella on 29/11/2018.
+//
+
+import UIKit
+
+typealias TranslationCompletionBlock = () -> Void
+
+enum TranslationType {
+    case toIndex(Int), basedOnTargetPolicy, toLastReachedNotchIndex
+}
+
+private struct TranslationMetaData {
+    let isAnimated: Bool
+    let velocity: CGPoint
+    let type: TranslationType
+}
+
+protocol HeightConstraintOverlayTranslationControllerDelegate: AnyObject {
+    func overlayViewController(for translationController: OverlayTranslationController) -> UIViewController?
+
+    func translationController(_ translationController: OverlayTranslationController,
+                               willMoveOverlayToNotchAt index: Int)
+    func translationController(_ translationController: OverlayTranslationController,
+                               didMoveOverlayToNotchAt index: Int)
+
+    func translationControllerWillStartDraggingOverlay(_ translationController: OverlayTranslationController)
+    func translationController(_ translationController: OverlayTranslationController,
+                               willEndDraggingAtVelocity velocity: CGPoint)
+    func translationController(_ translationController: OverlayTranslationController,
+                               willTranslateOverlayWith transitionCoordinator: OverlayContainerTransitionCoordinator)
+
+    func translationControllerDidScheduleTranslations(_ translationController: OverlayTranslationController)
+}
+
+class HeightConstraintOverlayTranslationController: OverlayTranslationController {
+
+    weak var delegate: HeightConstraintOverlayTranslationControllerDelegate?
+
+
+    private var overlayViewController: UIViewController? {
+        return delegate?.overlayViewController(for: self)
+    }
+
+    private var lastScheduledTranslationAnimator: UIViewImplicitlyAnimating?
+
+    private var translationEndNotchIndex = 0
+    private var deferredTranslation: TranslationMetaData?
+    private var deferredTranslationCompletionBlocks: [TranslationCompletionBlock] = []
+
+    private var translationStartHeight: CGFloat = 0.0
+    private var translationEndNotchHeight: CGFloat {
+        return configuration.heightForNotch(at: translationEndNotchIndex)
+    }
+
+    private let configuration: OverlayContainerConfiguration
+    private let translationHeightConstraint: NSLayoutConstraint
+    private var isDragging = false
+
+    // MARK: - Life Cycle
+
+    init(translationHeightConstraint: NSLayoutConstraint,
+         configuration: OverlayContainerConfiguration) {
+        self.translationHeightConstraint = translationHeightConstraint
+        self.configuration = configuration
+    }
+
+    // MARK: - Public
+
+    func hasPendingTranslation() -> Bool {
+        return deferredTranslation != nil
+    }
+
+    func performDeferredTranslations() {
+        guard let overlay = delegate?.overlayViewController(for: self),
+            let deferredTranslation = deferredTranslation else {
+                return
+        }
+        let completions = deferredTranslationCompletionBlocks
+        self.deferredTranslation = nil
+        self.deferredTranslationCompletionBlocks = []
+        let targetIndex: Int
+        switch deferredTranslation.type {
+        case .basedOnTargetPolicy:
+            let context = ConcreteOverlayContainerContextTargetNotchPolicy(
+                isDragging: false,
+                overlayViewController: overlay,
+                overlayTranslationHeight: translationHeight,
+                velocity: deferredTranslation.velocity,
+                notchHeightByIndex: configuration.notchHeightByIndex,
+                reachableIndexes: enabledNotchIndexes()
+            )
+            let policy = configuration.overlayTargetNotchPolicy(forOverlay: overlay)
+            targetIndex = policy.targetNotchIndex(using: context)
+        case let .toIndex(index):
+            targetIndex = index
+        case .toLastReachedNotchIndex:
+            targetIndex = lastTranslationEndNotchIndex
+        }
+        delegate?.translationController(self, willMoveOverlayToNotchAt: targetIndex)
+        let velocity = deferredTranslation.velocity
+        let isAnimated = deferredTranslation.isAnimated
+        translationEndNotchIndex = targetIndex
+        let targetHeight = configuration.heightForNotch(at: translationEndNotchIndex)
+        if isAnimated {
+            let height = translationHeight
+            let context = ConcreteOverlayContainerContextTransitioning(
+                isDragging: false,
+                isCancelled: false,
+                isAnimated: true,
+                overlayViewController: overlay,
+                overlayTranslationHeight: height,
+                velocity: velocity,
+                targetNotchIndex: translationEndNotchIndex,
+                targetTranslationHeight: targetHeight,
+                notchHeightByIndex: configuration.notchHeightByIndex,
+                reachableIndexes: enabledNotchIndexes()
+            )
+            let animationController = configuration.animationController(forOverlay: overlay)
+            let animator = animationController.interruptibleAnimator(using: context)
+            let coordinator = InterruptibleAnimatorOverlayContainerTransitionCoordinator(
+                animator: animator,
+                context: context
+            )
+            animator.addCompletion?({ [weak self] _ in
+                guard let self = self else { return }
+                if self.lastScheduledTranslationAnimator === animator {
+                    self.delegate?.translationController(self, didMoveOverlayToNotchAt: targetIndex)
+                    self.lastScheduledTranslationAnimator = nil
+                } else {
+                    coordinator.markAsCancelled()
+                }
+                completions.forEach { $0() }
+            })
+            delegate?.translationController(self, willTranslateOverlayWith: coordinator)
+            updateConstraint(toHeight: targetHeight)
+            animator.startAnimation()
+            lastScheduledTranslationAnimator = animator
+        } else {
+            translateOverlayWithoutAnimation(toHeight: targetHeight, isDragging: false)
+            completions.forEach { $0() }
+            delegate?.translationController(self, didMoveOverlayToNotchAt: targetIndex)
+        }
+    }
+
+    func scheduleOverlayTranslation(_ translationType: TranslationType,
+                                    velocity: CGPoint,
+                                    animated: Bool,
+                                    completion: (() -> Void)? = nil) {
+        deferredTranslation = TranslationMetaData(
+            isAnimated: animated,
+            velocity: velocity,
+            type: translationType
+        )
+        completion.flatMap { deferredTranslationCompletionBlocks.append($0) }
+    }
+
+    // MARK: - OverlayTranslationController
+
+    // Accessors
+
+    var lastTranslationEndNotchIndex: Int {
+        return translationEndNotchIndex
+    }
+
+    var translationHeight: CGFloat {
+        return translationHeightConstraint.constant
+    }
+
+    var translationPosition: OverlayTranslationPosition {
+        let isAtTop = translationHeight == maximumReachableNotchHeight()
+        let isAtBottom = translationHeight == minimumReachableNotchHeight()
+        if isAtTop && isAtBottom {
+            return .stationary
+        }
+        if isAtTop {
+            return .top
+        } else if isAtBottom {
+            return .bottom
+        } else {
+            return .inFlight
+        }
+    }
+
+    func isDraggable(at point: CGPoint, in coordinateSpace: UICoordinateSpace) -> Bool {
+        guard let overlay = overlayViewController else { return false }
+        return configuration.shouldStartDraggingOverlay(
+            overlay,
+            at: point,
+            in: coordinateSpace
+        )
+    }
+
+    func overlayHasReachedANotch() -> Bool {
+        return enabledNotchIndexes().contains {
+            configuration.heightForNotch(at: $0) == translationHeight
+        }
+    }
+
+    func startOverlayTranslation() {
+        isDragging = false
+        translationStartHeight = translationHeight
+    }
+
+    func dragOverlay(withOffset offset: CGFloat, usesFunction: Bool) {
+        guard let viewController = overlayViewController else { return }
+        let maximumHeight = maximumReachableNotchHeight()
+        let minimumHeight = minimumReachableNotchHeight()
+        let translation = translationStartHeight - offset
+        let height: CGFloat
+        if usesFunction {
+            let parameters = ConcreteOverlayTranslationParameters(
+                minimumHeight: minimumHeight,
+                maximumHeight: maximumHeight,
+                translation: translation
+            )
+            let function = configuration.overlayTranslationFunction(using: parameters, for: viewController)
+            height = function.overlayTranslationHeight(using: parameters)
+        } else {
+            height = max(minimumHeight, min(maximumHeight, translation))
+        }
+        if height != translationHeightConstraint.constant, !isDragging {
+            delegate?.translationControllerWillStartDraggingOverlay(self)
+            isDragging = true
+        }
+        translateOverlayWithoutAnimation(toHeight: max(height, 0), isDragging: true)
+    }
+
+    func endOverlayTranslation(withVelocity velocity: CGPoint) {
+        if isDragging {
+            delegate?.translationController(self, willEndDraggingAtVelocity: velocity)
+        }
+        guard overlayHasAmibiguousTranslationHeight() else { return }
+        scheduleOverlayTranslation(.basedOnTargetPolicy, velocity: velocity, animated: true)
+        delegate?.translationControllerDidScheduleTranslations(self)
+    }
+
+    // MARK: - Private
+
+    private func overlayHasAmibiguousTranslationHeight() -> Bool {
+        let heights = enabledNotchIndexes().map { configuration.heightForNotch(at: $0) }
+        guard let index = heights.firstIndex(where: { $0 == translationHeight }) else {
+            return true
+        }
+        return configuration.heightForNotch(at: index) != translationEndNotchHeight
+    }
+
+    private func translateOverlayWithoutAnimation(toHeight height: CGFloat, isDragging: Bool) {
+        guard let overlay = overlayViewController else { return }
+        let context = ConcreteOverlayContainerContextTransitioning(
+            isDragging: isDragging,
+            isCancelled: false,
+            isAnimated: false,
+            overlayViewController: overlay,
+            overlayTranslationHeight: height,
+            velocity: .zero,
+            targetNotchIndex: 0,
+            targetTranslationHeight: height,
+            notchHeightByIndex: configuration.notchHeightByIndex,
+            reachableIndexes: enabledNotchIndexes()
+        )
+        let coordinator = DraggingOverlayContainerTransitionCoordinator(context: context)
+        updateConstraint(toHeight: height)
+        delegate?.translationController(self, willTranslateOverlayWith: coordinator)
+        coordinator.performCompletions(with: context)
+    }
+
+    private func updateConstraint(toHeight height: CGFloat) {
+        guard translationHeightConstraint.constant != height else { return }
+        translationHeightConstraint.constant = height
+    }
+
+    private func enabledNotchIndexes() -> [Int] {
+        guard let controller = overlayViewController else { return [] }
+        return configuration.enabledNotchIndexes(for: controller)
+    }
+
+    private func minimumReachableNotchHeight() -> CGFloat {
+        let minimum = enabledNotchIndexes().first.flatMap {
+            configuration.heightForNotch(at: $0)
+        } ?? configuration.maximumNotchHeight
+        // (gz) 2019-04-11 If the overlay is still at a disabled notch
+        return min(translationEndNotchHeight, minimum)
+    }
+
+    private func maximumReachableNotchHeight() -> CGFloat {
+        let maximum = enabledNotchIndexes().last.flatMap {
+            configuration.heightForNotch(at: $0)
+        } ?? configuration.maximumNotchHeight
+        // (gz) 2019-04-11 If the overlay is still at a disabled notch
+        return max(translationEndNotchHeight, maximum)
+    }
+}