expo-dev-menu 2.2.0 → 3.0.0

package/ios/OverlayContainer/PassThroughView.swift

@@ -0,0 +1,24 @@
+//  Copyright (c) 2018, Applidium. All rights reserved
+//  PassThroughView.swift
+//  OverlayContainer
+//
+//  Created by Gaétan Zanella on 14/11/2018.
+//
+
+import UIKit
+
+/// A view which removes itself from the responder chain.
+///
+/// Use `PassThroughView` whenever you need to provide a backdrop view to an `OverlayContainerViewController`.
+open class PassThroughView: UIView {
+
+    // MARK: - UIView
+
+    open override func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? {
+        let view = super.hitTest(point, with: event)
+        if view == self {
+            return nil
+        }
+        return view
+    }
+}

package/ios/OverlayContainer/RubberBandOverlayTranslationFunction.swift

@@ -0,0 +1,44 @@
+//  Copyright (c) 2018, Applidium. All rights reserved
+//  RubberBandOverlayTranslationFunction.swift
+//  OverlayContainer
+//
+//  Created by Gaétan Zanella on 29/11/2018.
+//
+
+import UIKit
+
+/// `RubberBandOverlayTranslationFunction` specifies an overlay that will move linearly between
+/// the translation boundaris and limit its progression once reached.
+public class RubberBandOverlayTranslationFunction: OverlayTranslationFunction {
+
+    /// A factor defining how much the translation should be limited once one of the boundaries is reached.
+    public var factor: CGFloat = 0.5
+
+    public var bouncesAtMaximumHeight = true
+    public var bouncesAtMinimumHeight = true
+
+    // MARK: - Life Cycle
+
+    public init() {}
+
+    // MARK: - OverlayTranslationFunction
+
+    public func overlayTranslationHeight(using context: OverlayTranslationParameters) -> CGFloat {
+        if context.translation >= context.maximumHeight && bouncesAtMaximumHeight {
+            return logarithmicTranslation(translation: context.translation, limit: context.maximumHeight)
+        }
+        if context.translation <= context.minimumHeight && bouncesAtMinimumHeight {
+            let translation = context.minimumHeight + (context.minimumHeight - context.translation)
+            let height = logarithmicTranslation(translation: translation, limit: context.minimumHeight)
+            return context.minimumHeight - (height - context.minimumHeight)
+        }
+        return max(context.minimumHeight, min(context.translation, context.maximumHeight))
+    }
+
+    // MARK: - Private
+
+    private func logarithmicTranslation(translation: CGFloat, limit: CGFloat) -> CGFloat {
+        guard limit > 0 else { return 0 }
+        return (limit * (1 + factor * log10(translation / limit))).oc_rounded()
+    }
+}

package/ios/OverlayContainer/RushingForwardTargetNotchPolicy.swift

@@ -0,0 +1,52 @@
+//  Copyright (c) 2018, Applidium. All rights reserved
+//  RushingForwardTargetNotchPolicy.swift
+//  OverlayContainer
+//
+//  Created by Gaétan Zanella on 27/11/2018.
+//
+
+import UIKit
+
+private struct Constant {
+    static let minimumDuration: CGFloat = 0.1
+    static let minimumVelocity: CGFloat = 400
+}
+
+/// `RushingForwardTargetNotchPolicy` specifies a policy that will always move forward if a
+/// minimum velocity has been reached.
+public class RushingForwardTargetNotchPolicy: OverlayTranslationTargetNotchPolicy {
+
+    /// The minimum velocity to reach to move forward. The default value is 400 pt/s.
+    public var minimumVelocity: CGFloat = Constant.minimumVelocity
+    /// The minimum duration defines the minimum translation duration to expect.
+    public var minimumDuration: CGFloat = Constant.minimumDuration
+
+    // MARK: - Life Cycle
+
+    public init() {}
+
+    // MARK: - OverlayTranslationTargetNotchPolicy
+
+    public func targetNotchIndex(using context: OverlayContainerContextTargetNotchPolicy) -> Int {
+        guard !context.reachableIndexes.isEmpty else { return 0 }
+        let height = minimumDuration * -context.velocity.y + context.overlayTranslationHeight
+        let closestNotches = context.reachableIndexes.sorted {
+            let lhsHeight = context.height(forNotchAt: $0)
+            let rhsHeight = context.height(forNotchAt: $1)
+            let lhsDistance = abs(height - lhsHeight)
+            let rhsDistance = abs(height - rhsHeight)
+            return (lhsDistance, lhsHeight) < (rhsDistance, rhsHeight)
+        }
+        if context.reachableIndexes.count > 1 && abs(context.velocity.y) > minimumVelocity {
+            let lhs = closestNotches[0]
+            let rhs = closestNotches[1]
+            if context.velocity.y < 0 {
+                return max(lhs, rhs)
+            } else {
+                return min(lhs, rhs)
+            }
+        } else {
+            return closestNotches.first ?? 0
+        }
+    }
+}

package/ios/OverlayContainer/SpringOverlayTranslationAnimationController.swift

@@ -0,0 +1,70 @@
+//  Copyright (c) 2018, Applidium. All rights reserved
+//  SpringOverlayTranslationAnimationController.swift
+//  OverlayContainer
+//
+//  Created by Gaétan Zanella on 21/11/2018.
+//
+
+import UIKit
+
+private struct Constant {
+    static let defaultMass: CGFloat = 1
+    static let defaultDamping: CGFloat = 0.7
+    static let defaultRigidDamping: CGFloat = 0.9
+    static let defaultResponse: CGFloat = 0.3
+    static let minimumDamping: CGFloat = 1
+    static let minimumVelocityConsideration: CGFloat = 150
+    static let maximumVelocityConsideration: CGFloat = 3000
+}
+
+/// An `OverlayAnimatedTransitioning` implementation based on `UISpringTimingParameters`.
+public class SpringOverlayTranslationAnimationController: OverlayAnimatedTransitioning {
+
+    public var mass: CGFloat = Constant.defaultMass
+    public var damping: CGFloat = Constant.defaultDamping
+    public var response: CGFloat = Constant.defaultResponse
+
+    // MARK: - Life Cycle
+
+    public init() {}
+
+    public init(style: OverlayContainerViewController.OverlayStyle) {
+        switch style {
+        case .expandableHeight, .rigid:
+            // (gz) 2019-06-15 We also nullify the damping value when using rigid styles
+            // to avoid the panel to be lifted above the bottom of the screen.
+            damping = Constant.defaultRigidDamping
+        case .flexibleHeight:
+            damping = Constant.defaultDamping
+        }
+    }
+
+    // MARK: - OverlayAnimatedTransitioning
+
+    public func interruptibleAnimator(using context: OverlayContainerContextTransitioning) -> UIViewImplicitlyAnimating {
+        let velocity = min(
+            Constant.maximumVelocityConsideration,
+            max(abs(context.velocity.y), Constant.minimumVelocityConsideration)
+        )
+        let velocityRange = Constant.maximumVelocityConsideration - Constant.minimumVelocityConsideration
+        let normalizedVelocity = (velocity - Constant.minimumVelocityConsideration) / velocityRange
+        let normalizedDamping = normalizedVelocity * (damping - Constant.minimumDamping) + Constant.minimumDamping
+        let timing = UISpringTimingParameters(
+            damping: normalizedDamping,
+            response: response,
+            mass: mass
+        )
+        return UIViewPropertyAnimator(
+            duration: 0, // duration is ignored when using `UISpringTimingParameters.init(mass:stiffness:damping:initialVelocity)`
+            timingParameters: timing
+        )
+    }
+}
+
+extension UISpringTimingParameters {
+    convenience init(damping: CGFloat, response: CGFloat, mass: CGFloat) {
+        let stiffness = pow(2 * .pi / response, 2)
+        let damp = 4 * .pi * damping / response
+        self.init(mass: mass, stiffness: stiffness, damping: damp, initialVelocity: .zero)
+    }
+}

package/ios/Tests/DevMenuAppInstanceTest.swift

@@ -51,13 +51,11 @@ class DevMenuAppInstanceTest: QuickSpec {
         bridge: mockedBridge
       )
 
-      let extraModules = appInstance.extraModules(for: mockedBridge)
+        let extraModules = appInstance.extraModules(for: mockedBridge)
 
       expect(extraModules).toNot(beNil())
-      expect(extraModules?.first { type(of: $0).moduleName() == "ExpoDevMenuInternal" }).toNot(beNil())
-      expect(extraModules?.first { type(of: $0).moduleName() == "RNCSafeAreaProvider" }).toNot(beNil())
-      expect(extraModules?.first { type(of: $0).moduleName() == "RNCSafeAreaView" }).toNot(beNil())
       expect(extraModules?.first { type(of: $0).moduleName() == "DevLoadingView" }).toNot(beNil())
+      expect(extraModules?.first { type(of: $0).moduleName() == "DevSettings" }).toNot(beNil())
     }
   }
 }

package/ios/Tests/DevMenuInternalModuleTest.swift

@@ -1,19 +1,20 @@
-import Quick
-import Nimble
+import ExpoModulesTestCore
 
+@testable import ExpoModulesCore
 @testable import EXDevMenu
 
-class DevMenuInternalModuleTest: QuickSpec {
+class DevMenuInternalModuleTest: ExpoSpec {
   override func spec() {
+    let appContext = AppContext.create()
+    let module = DevMenuInternalModule(appContext: appContext)
+
     it("constants should contain information about key command support") {
       #if targetEnvironment(simulator)
           let doesDeviceSupportKeyCommands = true
       #else
           let doesDeviceSupportKeyCommands = false
       #endif
-      let module = DevMenuInternalModule(manager: DevMenuManager.shared)
-
-      let constants = module.constantsToExport()
+      let constants = module.definition().getConstants()
 
       expect(constants["doesDeviceSupportKeyCommands"] as? Bool).to(equal(doesDeviceSupportKeyCommands))
     }

package/mocks/react-native-gesture-handler/src/index.tsx

@@ -0,0 +1,39 @@
+import * as React from 'react';
+import { View, ViewProps } from 'react-native';
+
+function createHandler(): React.ComponentType<React.RefAttributes<any>> {
+  class Handler extends React.Component {
+    private refHandler = (node: any) => {
+      const child = React.Children.only(this.props.children);
+      // TODO(TS) fix ref type
+      const { ref }: any = child;
+      if (ref !== null) {
+        if (typeof ref === 'function') {
+          ref(node);
+        } else {
+          ref.current = node;
+        }
+      }
+    };
+
+    render() {
+      const child: any = React.Children.only(this.props.children);
+
+      return React.cloneElement(child, {
+        ref: this.refHandler,
+        collapsable: false,
+      });
+    }
+  }
+  return Handler;
+}
+
+export interface GestureHandlerRootViewProps extends React.PropsWithChildren<ViewProps> {}
+
+export default function GestureHandlerRootView({ ...rest }: GestureHandlerRootViewProps) {
+  return <View {...rest} />;
+}
+
+export type PanGestureHandler = typeof PanGestureHandler;
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export const PanGestureHandler = createHandler();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-dev-menu",
-  "version": "2.2.0",
+  "version": "3.0.0",
   "description": "Expo/React Native module with the developer menu.",
   "main": "build/DevMenu.js",
   "types": "build/DevMenu.d.ts",
@@ -48,7 +48,7 @@
     ]
   },
   "dependencies": {
-    "expo-dev-menu-interface": "1.1.1",
+    "expo-dev-menu-interface": "1.2.0",
     "semver": "^7.3.5"
   },
   "devDependencies": {
@@ -57,19 +57,19 @@
     "@testing-library/jest-native": "^4.0.4",
     "@testing-library/react-native": "^8.0.0",
     "babel-plugin-module-resolver": "^4.1.0",
-    "babel-preset-expo": "~9.3.0",
-    "expo-dev-client-components": "1.3.1",
+    "babel-preset-expo": "~9.4.0",
+    "expo-dev-client-components": "1.4.0",
     "expo-module-scripts": "^3.0.0",
     "fuse.js": "^6.4.6",
     "graphql": "^15.3.0",
     "graphql-tag": "^2.10.1",
     "react": "18.2.0",
-    "react-native": "0.71.6",
+    "react-native": "0.71.7",
     "use-subscription": "^1.8.0",
     "url": "^0.11.0"
   },
   "peerDependencies": {
     "expo": "*"
   },
-  "gitHead": "362ed24e78a57e9839afd2925d2af4aff7e28437"
+  "gitHead": "4ba50c428c8369bb6b3a51a860d4898ad4ccbe78"
 }

package/scripts/start.sh

@@ -1,7 +1,7 @@
 #!/usr/bin/env bash
 
 PACKAGER_PORT=2137
-PACKAGER_IP=`ifconfig en0 | grep inet | grep -v inet6 | awk '{print $2}'`
+PACKAGER_IP=`ifconfig | grep -v 127.0.0.1  | grep inet | grep -v inet6 | awk 'NR==1 {print $2}'`
 PACKAGER_HOST="$PACKAGER_IP:$PACKAGER_PORT"
 HOST_FILE='./assets/dev-menu-packager-host'
 

package/setupTests.ts

@@ -1,20 +1,9 @@
 import { cleanup } from '@testing-library/react-native';
-import 'react-native-gesture-handler/jestSetup';
 
 afterEach(cleanup);
 
 jest.mock('react-native/Libraries/Animated/NativeAnimatedHelper');
 
-jest.mock('react-native-reanimated', () => {
-  const Reanimated = require('react-native-reanimated/mock');
-
-  // The mock for `call` immediately calls the callback which is incorrect
-  // So we override it with a no-op
-  Reanimated.default.call = () => {};
-
-  return Reanimated;
-});
-
 jest.mock('react-native/Libraries/Components/Switch/Switch', () => {
   const View = require('react-native/Libraries/Components/View/View');
   const React = require('react');

package/src/DevMenu.ts

@@ -7,6 +7,14 @@ export function openMenu(): void {
   ExpoDevMenu.openMenu();
 }
 
+export function hideMenu(): void {
+  ExpoDevMenu.hideMenu();
+}
+
+export function closeMenu(): void {
+  ExpoDevMenu.closeMenu();
+}
+
 let hasRegisteredCallbackListener = false;
 
 function registerCallbackListener() {
@@ -33,11 +41,11 @@ export async function registerDevMenuItems(items: ExpoDevMenuItem[]) {
   }
 
   handlers = new Map();
-  const callbackNames: string[] = [];
+  const callbackNames: { name: string; shouldCollapse?: boolean }[] = [];
 
   items.forEach((item) => {
     handlers.set(item.name, item.callback);
-    callbackNames.push(item.name);
+    callbackNames.push({ name: item.name, shouldCollapse: item.shouldCollapse });
   });
 
   return await ExpoDevMenu.addDevMenuCallbacks(callbackNames);

package/src/ExpoDevMenu.types.ts

@@ -1,9 +1,12 @@
 export type ExpoDevMenuItem = {
   name: string;
   callback: () => void;
+  shouldCollapse?: boolean;
 };
 
 export type ExpoDevMenu = {
   openMenu();
-  addDevMenuCallbacks(names: string[]);
+  closeMenu();
+  hideMenu();
+  addDevMenuCallbacks(callbacks: { name: string; shouldCollapse?: boolean }[]);
 };

package/src/ExpoDevMenu.web.ts

@@ -5,6 +5,12 @@ export default {
   openMenu() {
     throw new WebUnsupportedError();
   },
+  closeMenu() {
+    throw new WebUnsupportedError();
+  },
+  hideMenu() {
+    throw new WebUnsupportedError();
+  },
   addDevMenuCallbacks() {
     throw new WebUnsupportedError();
   },

package/vendored/react-native-safe-area-context/ios/SafeAreaView/DevMenuRNCSafeAreaProvider.swift

@@ -0,0 +1,52 @@
+import React
+import ExpoModulesCore
+
+class SafeAreaProvider: ExpoView {
+  private var _currentSafeAreaInsets: UIEdgeInsets = .zero
+  private var _currentFrame: CGRect = .zero
+  private var _initialInsetsSent: Bool = false
+  let onInsetsChange = EventDispatcher()
+
+  override func safeAreaInsetsDidChange() {
+    invalidateSafeAreaInsets()
+  }
+
+  func invalidateSafeAreaInsets() {
+    guard !frame.size.equalTo(.zero) else {
+      return
+    }
+
+    let safeAreaInsets = safeAreaInsetsOrEmulate()
+    let frame = convert(bounds, to: nil)
+
+    if _initialInsetsSent &&
+      DevMenuUIEdgeInsetsEqualToEdgeInsetsWithThreshold(safeAreaInsets, _currentSafeAreaInsets, 1.0 / RCTScreenScale()) &&
+      frame.equalTo(_currentFrame) {
+      return
+    }
+
+    _initialInsetsSent = true
+    _currentSafeAreaInsets = safeAreaInsets
+    _currentFrame = frame
+
+    onInsetsChange([
+      "insets": [
+        "top": safeAreaInsets.top,
+        "right": safeAreaInsets.right,
+        "bottom": safeAreaInsets.bottom,
+        "left": safeAreaInsets.left
+      ],
+      "frame": [
+        "x": frame.origin.x,
+        "y": frame.origin.y,
+        "width": frame.size.width,
+        "height": frame.size.height
+      ]
+    ])
+  }
+
+  override func layoutSubviews() {
+    super.layoutSubviews()
+    invalidateSafeAreaInsets()
+  }
+}

package/vendored/react-native-safe-area-context/ios/SafeAreaView/DevMenuRNCSafeAreaProviderManager.swift

@@ -0,0 +1,54 @@
+import ExpoModulesCore
+
+public class RNCSafeAreaProviderManager: Module {
+  public func definition() -> ModuleDefinition {
+    Name("RNCSafeAreaProvider")
+    Constants([
+      "initialWindowMetrics": self.initialWindowMetrics
+    ])
+
+    View(SafeAreaProvider.self) {
+      Events("onInsetsChange")
+    }
+  }
+
+  private var initialWindowMetrics: [String: Any]? {
+    guard let window = UIApplication.shared.keyWindow else {
+      return [:]
+    }
+
+    if #available(iOS 11.0, *) {
+      let safeAreaInsets = window.safeAreaInsets
+
+      return [
+        "insets": [
+          "top": safeAreaInsets.top,
+          "right": safeAreaInsets.right,
+          "bottom": safeAreaInsets.bottom,
+          "left": safeAreaInsets.left
+        ],
+        "frame": [
+          "x": window.frame.origin.x,
+          "y": window.frame.origin.y,
+          "width": window.frame.size.width,
+          "height": window.frame.size.height
+        ]
+      ]
+    }
+
+    return [
+      "insets": [
+        "top": 20,
+        "right": 0,
+        "bottom": 0,
+        "left": 0
+      ],
+      "frame": [
+        "x": window.frame.origin.x,
+        "y": window.frame.origin.y,
+        "width": window.frame.size.width,
+        "height": window.frame.size.height
+      ]
+    ]
+  }
+}

package/vendored/react-native-safe-area-context/ios/SafeAreaView/DevMenuRNCSafeAreaViewEdges.swift

@@ -0,0 +1,9 @@
+import ExpoModulesCore
+
+enum SafeAreaViewEdges: Int, Enumerable {
+  case top = 0b1000
+  case right = 0b0100
+  case bottom = 0b0010
+  case left  = 0b0001
+  case all = 0b1111
+}

package/vendored/react-native-safe-area-context/ios/SafeAreaView/DevMenuRNCSafeAreaViewMode.swift

@@ -0,0 +1,7 @@
+import ExpoModulesCore
+
+enum SafeAreaViewMode: String, Enumerable {
+  case padding
+  case margin
+  case border
+}

package/vendored/react-native-safe-area-context/ios/SafeAreaView/RCTView+DevMenuSafeAreaCompat.swift

@@ -0,0 +1,47 @@
+import React
+
+func DevMenuUIEdgeInsetsEqualToEdgeInsetsWithThreshold(_ insets1: UIEdgeInsets, _ insets2: UIEdgeInsets, _ threshold: CGFloat) -> Bool {
+  return abs(insets1.left - insets2.left) <= threshold &&
+    abs(insets1.right - insets2.right) <= threshold &&
+    abs(insets1.top - insets2.top) <= threshold &&
+    abs(insets1.bottom - insets2.bottom) <= threshold
+}
+
+extension UIView {
+  var nativeSafeAreaSupport: Bool {
+    return responds(to: #selector(getter: safeAreaInsets))
+  }
+
+  func safeAreaInsetsOrEmulate() -> UIEdgeInsets {
+    if nativeSafeAreaSupport {
+      if #available(iOS 11.0, *) {
+        return safeAreaInsets
+      }
+    }
+    return emulatedSafeAreaInsets()
+  }
+
+  func emulatedSafeAreaInsets() -> UIEdgeInsets {
+    guard let vc = self.reactViewController() else {
+      return .zero
+    }
+
+    let topLayoutOffset = vc.topLayoutGuide.length
+    let bottomLayoutOffset = vc.bottomLayoutGuide.length
+    var safeArea = vc.view.bounds
+    safeArea.origin.y += topLayoutOffset
+    safeArea.size.height -= topLayoutOffset + bottomLayoutOffset
+    let localSafeArea = vc.view.convert(safeArea, to: self)
+    var safeAreaInsets = UIEdgeInsets.zero
+
+    if localSafeArea.minY > bounds.minY {
+      safeAreaInsets.top = localSafeArea.minY - bounds.minY
+    }
+
+    if localSafeArea.maxY < bounds.maxY {
+      safeAreaInsets.bottom = bounds.maxY - localSafeArea.maxY
+    }
+
+    return safeAreaInsets
+  }
+}

package/vendored/react-native-safe-area-context/src/InitialWindow.native.ts

@@ -1,15 +1,14 @@
-import { UIManager } from 'react-native';
+import { Platform, UIManager } from 'react-native';
+import { requireNativeModule } from 'expo-modules-core';
 import { Metrics } from './SafeArea.types';
 
-const RNCSafeAreaProviderConfig = UIManager.getViewManagerConfig(
-  'RNCSafeAreaProvider',
-) as any;
+const RNCSafeAreaProviderConstants =
+  Platform.OS === 'ios'
+    ? requireNativeModule('RNCSafeAreaProvider')
+    : (UIManager.getViewManagerConfig('RNCSafeAreaProvider') as any)?.Constants;
 
 export const initialWindowMetrics = (
-  RNCSafeAreaProviderConfig != null &&
-  RNCSafeAreaProviderConfig.Constants != null
-    ? RNCSafeAreaProviderConfig.Constants.initialWindowMetrics
-    : null
+  RNCSafeAreaProviderConstants != null ? RNCSafeAreaProviderConstants.initialWindowMetrics : null
 ) as Metrics | null;
 
 /**

package/vendored/react-native-safe-area-context/src/NativeSafeAreaProvider.native.tsx

@@ -1,6 +1,7 @@
-import { requireNativeComponent } from 'react-native';
+import { requireNativeComponent, Platform } from 'react-native';
+import { requireNativeViewManager } from 'expo-modules-core';
 import { NativeSafeAreaProviderProps } from './SafeArea.types';
 
-export default requireNativeComponent<NativeSafeAreaProviderProps>(
-  'RNCSafeAreaProvider',
-);
+export default Platform.OS === 'ios'
+  ? requireNativeViewManager<NativeSafeAreaProviderProps>('RNCSafeAreaProvider')
+  : requireNativeComponent<NativeSafeAreaProviderProps>('RNCSafeAreaProvider');

package/android/src/expo-44/java/expo/modules/devmenu/DevMenuPackageDelegate.kt

@@ -1,13 +0,0 @@
-package expo.modules.devmenu
-
-import android.content.Context
-import expo.modules.core.interfaces.ReactActivityHandler
-import expo.modules.core.interfaces.ReactActivityLifecycleListener
-
-object DevMenuPackageDelegate {
-  @JvmField
-  var enableAutoSetup: Boolean? = null
-
-  fun createReactActivityLifecycleListeners(activityContext: Context?): List<ReactActivityLifecycleListener> = emptyList()
-  fun createReactActivityHandlers(activityContext: Context?): List<ReactActivityHandler> = emptyList()
-}