expo-dev-menu 2.2.0 → 3.0.0

package/ios/OverlayContainer/Internal/InterruptibleAnimatorOverlayContainerTransitionCoordinator.swift

@@ -0,0 +1,75 @@
+//  Copyright (c) 2018, Applidium. All rights reserved
+//  InterruptibleAnimatorOverlayContainerTransitionCoordinator.swift
+//  OverlayContainer
+//
+//  Created by Gaétan Zanella on 28/11/2018.
+//
+
+import UIKit
+
+class InterruptibleAnimatorOverlayContainerTransitionCoordinator: OverlayContainerTransitionCoordinator {
+
+    private let animator: UIViewImplicitlyAnimating
+    private let context: OverlayContainerTransitionCoordinatorContext
+
+    // MARK: - Life Cycle
+
+    init(animator: UIViewImplicitlyAnimating, context: OverlayContainerTransitionCoordinatorContext) {
+        self.animator = animator
+        self.context = context
+    }
+
+    // MARK: - Public
+
+    func markAsCancelled() {
+        isCancelled = true
+    }
+
+    // MARK: - OverlayContainerTransitionCoordinatorContext
+
+    private(set) var isCancelled = false
+
+    var isDragging: Bool {
+        return context.isDragging
+    }
+
+    var velocity: CGPoint {
+        return context.velocity
+    }
+
+    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)?) {
+        animator.addAnimations? { [weak self] in
+            self.flatMap { animation?($0) }
+        }
+        animator.addCompletion? { [weak self] _ in
+            self.flatMap { completion?($0) }
+        }
+    }
+}

package/ios/OverlayContainer/Internal/OverlayContainerConfiguration.swift

@@ -0,0 +1,63 @@
+//  Copyright (c) 2018, Applidium. All rights reserved
+//  OverlayContainerViewControllerDelegateWrapper.swift
+//  OverlayContainer
+//
+//  Created by Gaétan Zanella on 20/11/2018.
+//
+
+import UIKit
+
+protocol OverlayContainerConfiguration {
+
+    func numberOfNotches() -> Int
+    func heightForNotch(at index: Int) -> CGFloat
+
+    func canReachNotch(at index: Int, for overlayViewController: UIViewController) -> Bool
+    func animationController(forOverlay overlay: UIViewController) -> OverlayAnimatedTransitioning
+    func overlayTargetNotchPolicy(forOverlay overlay: UIViewController) -> OverlayTranslationTargetNotchPolicy
+
+    func scrollView(drivingOverlay controller: UIViewController) -> UIScrollView?
+
+    func shouldStartDraggingOverlay(_ viewController: UIViewController,
+                                    at point: CGPoint,
+                                    in coordinateSpace: UICoordinateSpace) -> Bool
+    func overlayTranslationFunction(using context: OverlayTranslationParameters,
+                                    for overlayViewController: UIViewController) -> OverlayTranslationFunction
+}
+
+protocol OverlayContainerConfigurationInvalidating: OverlayContainerConfiguration {
+    func invalidateOverlayMetrics()
+    func requestOverlayMetricsIfNeeded()
+}
+
+extension OverlayContainerConfiguration {
+    var maximumNotchIndex: Int {
+        return  max(numberOfNotches() - 1, 0)
+    }
+
+    var minimumNotchIndex: Int {
+        return 0
+    }
+
+    var maximumNotchHeight: CGFloat {
+        return heightForNotch(at: maximumNotchIndex)
+    }
+
+    var minimumNotchHeight: CGFloat {
+        return heightForNotch(at: minimumNotchIndex)
+    }
+
+    var notchHeightByIndex: [Int: CGFloat] {
+        return Dictionary(
+            uniqueKeysWithValues: (0..<numberOfNotches()).map { ($0, heightForNotch(at: $0)) }
+        )
+    }
+
+    func sortedHeights() -> [CGFloat] {
+        return Array(notchHeightByIndex.values.sorted())
+    }
+
+    func enabledNotchIndexes(for overlayContainer: UIViewController) -> [Int] {
+        return (0..<numberOfNotches()).filter { canReachNotch(at: $0, for: overlayContainer) }
+    }
+}

package/ios/OverlayContainer/Internal/OverlayContainerConfigurationImplementation.swift

@@ -0,0 +1,130 @@
+//  Copyright (c) 2018, Applidium. All rights reserved
+//  OverlayContainerViewControllerDelegateWrapper.swift
+//  OverlayContainer
+//
+//  Created by Gaétan Zanella on 20/11/2018.
+//
+
+import UIKit
+
+class OverlayContainerConfigurationImplementation: OverlayContainerConfigurationInvalidating {
+
+    private weak var overlayContainerViewController: OverlayContainerViewController?
+
+    weak var delegate: OverlayContainerViewControllerDelegate?
+
+    private(set) var notchHeightByIndex: [Int: CGFloat] = [:]
+
+    private var needsMetricUpdate = false
+
+    // MARK: - Life Cycle
+
+    init(overlayContainerViewController: OverlayContainerViewController) {
+        self.overlayContainerViewController = overlayContainerViewController
+    }
+
+    // MARK: - OverlayContainerConfigurationInvalidating
+
+    func invalidateOverlayMetrics() {
+        needsMetricUpdate = true
+    }
+
+    func requestOverlayMetricsIfNeeded() {
+        guard needsMetricUpdate else { return }
+        needsMetricUpdate = false
+        let numberOfNotches = requestNumberOfNotches()
+        assert(numberOfNotches >= 0, "The number of notches must be positive.")
+        let heights = (0..<numberOfNotches).map { requestHeightForNotch(at: $0) }
+        assert(heights.sorted() == heights, "The notches should be sorted by height. The notch at the first index must be the smaller one. \(heights)")
+        let values = heights.enumerated().map { ($0, $1) }
+        notchHeightByIndex = Dictionary(uniqueKeysWithValues: values)
+    }
+
+    // MARK: - OverlayContainerViewControllerConfiguration
+
+    func numberOfNotches() -> Int {
+        return notchHeightByIndex.count
+    }
+
+    func heightForNotch(at index: Int) -> CGFloat {
+        return notchHeightByIndex[index] ?? 0
+    }
+
+    func animationController(forOverlay overlay: UIViewController) -> OverlayAnimatedTransitioning {
+        guard let controller = overlayContainerViewController else {
+            return SpringOverlayTranslationAnimationController()
+        }
+        let transitioningDelegate = delegate?.overlayContainerViewController(
+            controller,
+            transitioningDelegateForOverlay: overlay
+        )
+        let defaultController = SpringOverlayTranslationAnimationController(style: controller.style)
+        return transitioningDelegate?.animationController(for: overlay) ?? defaultController
+    }
+
+    func overlayTargetNotchPolicy(forOverlay overlay: UIViewController) -> OverlayTranslationTargetNotchPolicy {
+        guard let controller = overlayContainerViewController else {
+            return RushingForwardTargetNotchPolicy()
+        }
+        let transitioningDelegate = delegate?.overlayContainerViewController(
+            controller,
+            transitioningDelegateForOverlay: overlay
+        )
+        return transitioningDelegate?.overlayTargetNotchPolicy(for: overlay) ?? RushingForwardTargetNotchPolicy()
+    }
+
+    func scrollView(drivingOverlay controller: UIViewController) -> UIScrollView? {
+        guard let containerController = overlayContainerViewController else { return nil }
+        return delegate?.overlayContainerViewController(containerController, scrollViewDrivingOverlay: controller)
+    }
+
+    func shouldStartDraggingOverlay(_ viewController: UIViewController,
+                                    at point: CGPoint,
+                                    in coordinateSpace: UICoordinateSpace) -> Bool {
+        guard let containerController = overlayContainerViewController else { return false }
+        return delegate?.overlayContainerViewController(
+            containerController,
+            shouldStartDraggingOverlay: viewController,
+            at: point,
+            in: coordinateSpace
+        ) ?? true
+    }
+
+    func overlayTranslationFunction(using context: OverlayTranslationParameters,
+                                    for overlayViewController: UIViewController) -> OverlayTranslationFunction {
+        guard let containerController = overlayContainerViewController else {
+            return RubberBandOverlayTranslationFunction()
+        }
+        return delegate?.overlayContainerViewController(
+            containerController,
+            overlayTranslationFunctionForOverlay: overlayViewController
+        ) ?? RubberBandOverlayTranslationFunction()
+    }
+
+    func canReachNotch(at index: Int, for overlayViewController: UIViewController) -> Bool {
+        guard let containerController = overlayContainerViewController else {
+            return true
+        }
+        return delegate?.overlayContainerViewController(
+            containerController,
+            canReachNotchAt: index,
+            forOverlay: overlayViewController
+        ) ?? true
+    }
+
+    // MARK: - Private
+
+    private func requestHeightForNotch(at index: Int) -> CGFloat {
+        guard let controller = overlayContainerViewController else { return 0 }
+        return delegate?.overlayContainerViewController(
+            controller,
+            heightForNotchAt: index,
+            availableSpace: controller.availableSpace
+        ) ?? 0
+    }
+
+    private func requestNumberOfNotches() -> Int {
+        guard let controller = overlayContainerViewController else { return 0 }
+        return delegate?.numberOfNotches(in: controller) ?? 0
+    }
+}

package/ios/OverlayContainer/Internal/OverlayScrollViewDelegate.swift

@@ -0,0 +1,16 @@
+//  Copyright (c) 2018, Applidium. All rights reserved
+//  OverlayScrollViewDelegate.swift
+//  OverlayContainer
+//
+//  Created by Gaétan Zanella on 20/11/2018.
+//
+
+import UIKit
+
+protocol OverlayScrollViewDelegate: AnyObject {
+    func overlayScrollViewWillBeginDragging(_ scrollView: UIScrollView)
+    func overlayScrollViewDidScroll(_ scrollView: UIScrollView)
+    func overlayScrollView(_ scrollView: UIScrollView,
+                           willEndDraggingwithVelocity velocity: CGPoint,
+                           targetContentOffset: UnsafeMutablePointer<CGPoint>)
+}

package/ios/OverlayContainer/Internal/OverlayScrollViewDelegateProxy.swift

@@ -0,0 +1,96 @@
+//  Copyright (c) 2018, Applidium. All rights reserved
+//  OverlayScrollViewDelegateProxy.swift
+//  OverlayContainer
+//
+//  Created by Gaétan Zanella on 20/11/2018.
+//
+
+import UIKit
+
+class OverlayScrollViewDelegateProxy: NSObject, UIScrollViewDelegate {
+
+    private var scrollViewObservation: NSKeyValueObservation?
+    private weak var originalDelegate: UIScrollViewDelegate?
+    private weak var scrollView: UIScrollView?
+    private weak var delegate: OverlayScrollViewDelegate?
+
+    // MARK: - Life Cycle
+
+    deinit {
+        cancelForwarding()
+    }
+
+    // MARK: - NSObject
+
+    override func responds(to aSelector: Selector!) -> Bool {
+        let originalDelegateRespondsToSelector = originalDelegate?.responds(to: aSelector) ?? false
+        return super.responds(to: aSelector) || originalDelegateRespondsToSelector
+    }
+
+    override func forwardingTarget(for aSelector: Selector!) -> Any? {
+        if originalDelegate?.responds(to: aSelector) == true {
+            return originalDelegate
+        } else {
+            return super.forwardingTarget(for: aSelector)
+        }
+    }
+
+    // MARK: - Public
+
+    func cancelForwarding() {
+        cancelForwarding(restoresDelegate: true)
+    }
+
+    func forward(to delegate: OverlayScrollViewDelegate, delegateInvocationsFrom scrollView: UIScrollView) {
+        guard !(scrollView.delegate === self) else { return }
+        cancelForwarding()
+        self.delegate = delegate
+        self.originalDelegate = scrollView.delegate
+        self.scrollView = scrollView
+        scrollView.delegate = self
+        scrollViewObservation = scrollView.observe(\.delegate) { [weak self] (scrollView, delegate) in
+            guard !(scrollView.delegate === self) else { return }
+            if let proxy = scrollView.delegate as? OverlayScrollViewDelegateProxy {
+                proxy.originalDelegate = self?.originalDelegate
+                self?.cancelForwarding(restoresDelegate: false)
+            } else {
+                self?.originalDelegate = scrollView.delegate
+                self?.scrollView = scrollView
+                scrollView.delegate = self
+            }
+        }
+    }
+
+    // MARK: - UIScrollViewDelegate
+
+    func scrollViewDidScroll(_ scrollView: UIScrollView) {
+        delegate?.overlayScrollViewDidScroll(scrollView)
+        originalDelegate?.scrollViewDidScroll?(scrollView)
+    }
+
+    func scrollViewWillEndDragging(_ scrollView: UIScrollView,
+                                   withVelocity velocity: CGPoint,
+                                   targetContentOffset: UnsafeMutablePointer<CGPoint>) {
+        delegate?.overlayScrollView(
+            scrollView,
+            willEndDraggingwithVelocity: velocity.multiply(by: -1000),
+            targetContentOffset: targetContentOffset
+        )
+        originalDelegate?.scrollViewWillEndDragging?(
+            scrollView,
+            withVelocity: velocity,
+            targetContentOffset: targetContentOffset
+        )
+    }
+
+    func scrollViewWillBeginDragging(_ scrollView: UIScrollView) {
+        delegate?.overlayScrollViewWillBeginDragging(scrollView)
+        originalDelegate?.scrollViewWillBeginDragging?(scrollView)
+    }
+
+    private func cancelForwarding(restoresDelegate: Bool) {
+        scrollViewObservation?.invalidate()
+        guard restoresDelegate else { return }
+        scrollView?.delegate = originalDelegate
+    }
+}

package/ios/OverlayContainer/Internal/OverlayTranslationController.swift

@@ -0,0 +1,26 @@
+//  Copyright (c) 2018, Applidium. All rights reserved
+//  OverlayTranslationController.swift
+//  OverlayContainer
+//
+//  Created by Gaétan Zanella on 29/11/2018.
+//
+
+import UIKit
+
+enum OverlayTranslationPosition {
+    case top, bottom, inFlight, stationary
+}
+
+protocol OverlayTranslationController: AnyObject {
+    var lastTranslationEndNotchIndex: Int { get }
+    var translationHeight: CGFloat { get }
+    var translationPosition: OverlayTranslationPosition { get }
+
+    func isDraggable(at point: CGPoint, in coordinateSpace: UICoordinateSpace) -> Bool
+
+    func overlayHasReachedANotch() -> Bool
+
+    func startOverlayTranslation()
+    func dragOverlay(withOffset offset: CGFloat, usesFunction: Bool)
+    func endOverlayTranslation(withVelocity velocity: CGPoint)
+}

package/ios/OverlayContainer/Internal/OverlayTranslationDriver.swift

@@ -0,0 +1,12 @@
+//  Copyright (c) 2018, Applidium. All rights reserved
+//  OverlayTranslationDriver.swift
+//  OverlayContainer
+//
+//  Created by Gaétan Zanella on 29/11/2018.
+//
+
+import UIKit
+
+protocol OverlayTranslationDriver {
+    func clean()
+}

package/ios/OverlayContainer/Internal/OverlayTranslationGestureRecognizer.swift

@@ -0,0 +1,40 @@
+//  Copyright (c) 2018, Applidium. All rights reserved
+//  OverlayScrollViewTranslationController.swift
+//  OverlayContainer
+//
+//  Created by Gaétan Zanella on 20/11/2018.
+//
+
+import UIKit
+
+class OverlayTranslationGestureRecognizer: UIPanGestureRecognizer {
+
+    weak var drivingScrollView: UIScrollView?
+
+    private(set) var startingLocation: CGPoint = .zero
+
+    // MARK: - Public
+
+    func cancel() {
+        isEnabled = false
+        isEnabled = true
+    }
+
+    // MARK: - UIGestureRecognizer
+
+    override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent) {
+        super.touchesBegan(touches, with: event)
+        startingLocation = location(in: view)
+    }
+
+    override func shouldRequireFailure(of otherGestureRecognizer: UIGestureRecognizer) -> Bool {
+        guard let gestures = drivingScrollView?.gestureRecognizers else {
+            return super.shouldRequireFailure(of: otherGestureRecognizer)
+        }
+        if gestures.contains(otherGestureRecognizer) {
+            return true
+        } else {
+            return super.shouldRequireFailure(of: otherGestureRecognizer)
+        }
+    }
+}

package/ios/OverlayContainer/Internal/PanGestureOverlayTranslationDriver.swift

@@ -0,0 +1,68 @@
+//  Copyright (c) 2018, Applidium. All rights reserved
+//  PanGestureOverlayTranslationDriver.swift
+//  OverlayContainer
+//
+//  Created by Gaétan Zanella on 29/11/2018.
+//
+
+import UIKit
+
+class PanGestureOverlayTranslationDriver: NSObject,
+                                          OverlayTranslationDriver,
+                                          UIGestureRecognizerDelegate {
+
+    private weak var translationController: OverlayTranslationController?
+    private let panGestureRecognizer: OverlayTranslationGestureRecognizer
+
+    // MARK: - Life Cycle
+
+    init(translationController: OverlayTranslationController,
+         panGestureRecognizer: OverlayTranslationGestureRecognizer) {
+        self.translationController = translationController
+        self.panGestureRecognizer = panGestureRecognizer
+        super.init()
+        panGestureRecognizer.delegate = self
+        panGestureRecognizer.addTarget(self, action: #selector(overlayPanGestureAction(_:)))
+    }
+
+    // MARK: - OverlayTranslationDriver
+
+    func clean() {
+        // no-op
+    }
+
+    // MARK: - UIGestureRecognizerDelegate
+
+    func gestureRecognizerShouldBegin(_ gestureRecognizer: UIGestureRecognizer) -> Bool {
+        guard let view = gestureRecognizer.view,
+              let gesture = gestureRecognizer as? OverlayTranslationGestureRecognizer else {
+            return false
+        }
+        return translationController?.isDraggable(at: gesture.startingLocation, in: view) ?? false
+    }
+
+    // MARK: - Action
+
+    @objc private func overlayPanGestureAction(_ sender: OverlayTranslationGestureRecognizer) {
+        guard let controller = translationController, let view = sender.view else { return }
+        let translation = sender.translation(in: nil)
+        switch sender.state {
+        case .began:
+            controller.startOverlayTranslation()
+            if controller.isDraggable(at: sender.startingLocation, in: view) {
+                controller.dragOverlay(withOffset: translation.y, usesFunction: true)
+            } else {
+                sender.cancel()
+            }
+        case .changed:
+            controller.dragOverlay(withOffset: translation.y, usesFunction: true)
+        case .failed, .ended, .cancelled:
+            let velocity = sender.velocity(in: nil)
+            controller.endOverlayTranslation(withVelocity: velocity)
+        case .possible:
+            break
+        @unknown default:
+            break
+        }
+    }
+}

package/ios/OverlayContainer/Internal/ScrollViewOverlayTranslationDriver.swift

@@ -0,0 +1,135 @@
+//  Copyright (c) 2018, Applidium. All rights reserved
+//  ScrollViewOverlayTranslationDriver.swift
+//  OverlayContainer
+//
+//  Created by Gaétan Zanella on 29/11/2018.
+//
+
+import UIKit
+
+class ScrollViewOverlayTranslationDriver: OverlayTranslationDriver, OverlayScrollViewDelegate {
+
+    weak var translationController: OverlayTranslationController?
+    weak var scrollView: UIScrollView?
+
+    private let scrollViewDelegateProxy = OverlayScrollViewDelegateProxy()
+
+    // (gz) 2018-11-27 The overlay transaction is not always equal to the scroll view translation.
+    // The user can scroll bottom then drag the overlay up repeatedly in a single gesture.
+    private var overlayTranslation: CGFloat = 0
+    private var scrollViewTranslation: CGFloat = 0
+    private var lastContentOffsetWhileScrolling: CGPoint = .zero
+
+    // MARK: - Life Cycle
+
+    init(translationController: OverlayTranslationController, scrollView: UIScrollView) {
+        self.translationController = translationController
+        self.scrollView = scrollView
+        scrollViewDelegateProxy.forward(to: self, delegateInvocationsFrom: scrollView)
+        lastContentOffsetWhileScrolling = scrollView.contentOffset
+    }
+
+    // MARK: - OverlayTranslationDriver
+
+    func clean() {
+        scrollViewDelegateProxy.cancelForwarding()
+    }
+
+    // MARK: - OverlayScrollViewDelegate
+
+    func overlayScrollViewWillBeginDragging(_ scrollView: UIScrollView) {
+        translationController?.startOverlayTranslation()
+    }
+
+    func overlayScrollViewDidScroll(_ scrollView: UIScrollView) {
+        guard let controller = translationController else { return }
+        let previousTranslation = scrollViewTranslation
+        scrollViewTranslation = scrollView.panGestureRecognizer.translation(in: scrollView).y
+        if shouldDragOverlay(following: scrollView) {
+            if scrollView.isContentOriginInBounds {
+                overlayTranslation += -scrollView.topOffsetInContent
+            } else {
+                overlayTranslation += scrollViewTranslation - previousTranslation
+            }
+            let offset = adjustedContentOffset(dragging: scrollView)
+            lastContentOffsetWhileScrolling = offset
+            scrollView.contentOffset = offset // Warning : calls `overlayScrollViewDidScroll(_:)` again
+            controller.dragOverlay(withOffset: overlayTranslation, usesFunction: false)
+        } else {
+            lastContentOffsetWhileScrolling = scrollView.contentOffset
+        }
+    }
+
+    func overlayScrollView(_ scrollView: UIScrollView,
+                           willEndDraggingwithVelocity velocity: CGPoint,
+                           targetContentOffset: UnsafeMutablePointer<CGPoint>) {
+        guard let controller = translationController else { return }
+        overlayTranslation = 0
+        scrollViewTranslation = 0
+        // (gz) 2018-11-27 We reset the translation each time the user ends dragging.
+        // Otherwise the calculation is wrong in `overlayScrollViewDidScroll(_:)`
+        // if the user drags the overlay while the animation did not finish.
+        scrollView.panGestureRecognizer.setTranslation(.zero, in: nil)
+        // (gz) 2018-01-24 We adjust the content offset and the velocity only if the overlay will be dragged.
+        switch controller.translationPosition {
+        case .bottom where targetContentOffset.pointee.y > -scrollView.oc_adjustedContentInset.top:
+            // (gz) 2018-11-26 The user raises its finger in the bottom position
+            // and the content offset will exceed the top content inset.
+            targetContentOffset.pointee.y = -scrollView.oc_adjustedContentInset.top
+        case .inFlight where !controller.overlayHasReachedANotch():
+            targetContentOffset.pointee.y = lastContentOffsetWhileScrolling.y
+        case .top, .bottom, .inFlight, .stationary:
+            break
+        }
+        // If the overlay is in flight and the user scrolls bottom, we ignore the velocity and we do not
+        // modify the target offset.
+        let adjustedVelocity: CGPoint
+        if shouldDragOverlay(following: scrollView) {
+            adjustedVelocity = velocity
+        } else {
+            adjustedVelocity = .zero
+        }
+        controller.endOverlayTranslation(withVelocity: adjustedVelocity)
+    }
+
+    // MARK: - Private
+
+    private func shouldDragOverlay(following scrollView: UIScrollView) -> Bool {
+        guard let controller = translationController, scrollView.isTracking else { return false }
+        let velocity = scrollView.panGestureRecognizer.velocity(in: nil).y
+        let movesUp = velocity < 0
+        switch controller.translationPosition {
+        case .bottom:
+            return !scrollView.isContentOriginInBounds && scrollView.scrollsUp
+        case .top:
+            return scrollView.isContentOriginInBounds && !movesUp
+        case .inFlight:
+            return scrollView.isContentOriginInBounds || scrollView.scrollsUp
+        case .stationary:
+            return false
+        }
+    }
+
+    private func adjustedContentOffset(dragging scrollView: UIScrollView) -> CGPoint {
+        guard let controller = translationController else { return .zero }
+        var contentOffset = lastContentOffsetWhileScrolling
+        let topInset = -scrollView.oc_adjustedContentInset.top
+        switch controller.translationPosition {
+        case .inFlight, .top:
+            // (gz) 2018-11-26 The user raised its finger in the top or in flight positions while scrolling bottom.
+            // If the scroll animation did not finish when the user translates the overlay,
+            // the content offset may have exceeded the top inset. We adjust it.
+            if contentOffset.y < topInset {
+                contentOffset.y = topInset
+            }
+        case .bottom, .stationary:
+            break
+        }
+        // (gz) 2018-11-26 Between two `overlayScrollViewDidScroll:` calls,
+        // the scrollView exceeds the top contentInset. We adjust the target.
+        if (contentOffset.y - topInset) * (scrollView.contentOffset.y - topInset) < 0 {
+            contentOffset.y = topInset
+        }
+        return contentOffset
+    }
+}

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

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