@callstack/react-native-brownfield 0.1.0 → 1.0.0-rc.0

package/android/src/main/java/com/callstack/reactnativebrownfield/ReactNativeFragment.kt

@@ -3,174 +3,168 @@ package com.callstack.reactnativebrownfield;
 import android.annotation.TargetApi
 import android.os.Build
 import android.os.Bundle
-import androidx.fragment.app.Fragment
 import android.view.KeyEvent
-import android.view.LayoutInflater
-import android.view.View
-import android.view.ViewGroup
 import com.facebook.infer.annotation.Assertions
-import com.facebook.react.ReactRootView
+import com.facebook.react.ReactFragment
+import com.facebook.react.ReactHost
+import com.facebook.react.ReactNativeHost
 import com.facebook.react.bridge.Callback
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.common.LifecycleState
+import com.facebook.react.defaults.DefaultReactHost.getDefaultReactHost
 import com.facebook.react.devsupport.DoubleTapReloadRecognizer
 import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler
 import com.facebook.react.modules.core.PermissionAwareActivity
 import com.facebook.react.modules.core.PermissionListener
 
-private const val MODULE_NAME = "com.callstack.reactnativebrownfield.FRAGMENT_MODULE_NAME"
-private const val INITIAL_PROPS = "com.callstack.reactnativebrownfield.FRAGMENT_INITIAL_PROPS"
-
-class ReactNativeFragment : Fragment(), PermissionAwareActivity {
-
-    private var reactRootView: ReactRootView? = null
-    private lateinit var doubleTapReloadRecognizer: DoubleTapReloadRecognizer
-    private lateinit var permissionsCallback: Callback
-    private var permissionListener: PermissionListener? = null
-
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        val moduleName = arguments?.getString(MODULE_NAME)!!
-        val initialProps = arguments?.getBundle(INITIAL_PROPS)
-
-        doubleTapReloadRecognizer = DoubleTapReloadRecognizer()
-
-        reactRootView = ReactRootView(context)
-        reactRootView?.startReactApplication(
-            ReactNativeBrownfield.shared.reactNativeHost.reactInstanceManager,
-            moduleName,
-            initialProps
-        )
-    }
-
-
-    override fun onCreateView(
-        inflater: LayoutInflater,
-        container: ViewGroup?,
-        savedInstanceState: Bundle?
-    ): View {
-        return reactRootView!!
+class ReactNativeFragment : ReactFragment(), PermissionAwareActivity {
+  private lateinit var doubleTapReloadRecognizer: DoubleTapReloadRecognizer
+  private lateinit var permissionsCallback: Callback
+  private var permissionListener: PermissionListener? = null
+
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+    doubleTapReloadRecognizer = DoubleTapReloadRecognizer()
+  }
+
+  override fun getReactHost(): ReactHost? {
+    return activity?.let {
+      getDefaultReactHost(
+        it.applicationContext,
+        ReactNativeBrownfield.shared.reactNativeHost
+      )
     }
-
-    override fun onResume() {
-        super.onResume()
-        if (ReactNativeBrownfield.shared.reactNativeHost.hasInstance()) {
-            ReactNativeBrownfield.shared.reactNativeHost.reactInstanceManager?.onHostResume(
-                activity,
-                activity as DefaultHardwareBackBtnHandler
-            )
-        }
+  }
+
+  override fun getReactNativeHost(): ReactNativeHost? {
+    return ReactNativeBrownfield.shared.reactNativeHost
+  }
+
+  override fun onResume() {
+    super.onResume()
+    if (ReactNativeBrownfield.shared.reactNativeHost.hasInstance()) {
+      ReactNativeBrownfield.shared.reactNativeHost.reactInstanceManager?.onHostResume(
+        activity,
+        activity as DefaultHardwareBackBtnHandler
+      )
     }
-
-    override fun onPause() {
-        super.onPause()
-        if (ReactNativeBrownfield.shared.reactNativeHost.hasInstance()) {
-            ReactNativeBrownfield.shared.reactNativeHost.reactInstanceManager?.onHostPause(
-                activity
-            )
-        }
+  }
+
+  override fun onPause() {
+    super.onPause()
+    if (ReactNativeBrownfield.shared.reactNativeHost.hasInstance()) {
+      ReactNativeBrownfield.shared.reactNativeHost.reactInstanceManager?.onHostPause(
+        activity
+      )
     }
+  }
 
-    override fun onDestroy() {
-        super.onDestroy()
-        reactRootView?.unmountReactApplication()
-        reactRootView = null
-        if (ReactNativeBrownfield.shared.reactNativeHost.hasInstance()) {
-            val reactInstanceMgr = ReactNativeBrownfield.shared.reactNativeHost.reactInstanceManager
-
-            if (reactInstanceMgr.lifecycleState != LifecycleState.RESUMED) {
-                reactInstanceMgr.onHostDestroy(activity)
-            }
-        }
-    }
+  override fun onDestroy() {
+    super.onDestroy()
+    if (ReactNativeBrownfield.shared.reactNativeHost.hasInstance()) {
+      val reactInstanceMgr = ReactNativeBrownfield.shared.reactNativeHost.reactInstanceManager
 
-    override fun onRequestPermissionsResult(
-        requestCode: Int,
-        permissions: Array<String>,
-        grantResults: IntArray
-    ) {
-        permissionsCallback = Callback {
-            if (permissionListener != null) {
-                permissionListener?.onRequestPermissionsResult(
-                    requestCode,
-                    permissions,
-                    grantResults
-                )
-
-                permissionListener = null
-            }
-        }
+      if (reactInstanceMgr.lifecycleState != LifecycleState.RESUMED) {
+        reactInstanceMgr.onHostDestroy(activity)
+      }
     }
+  }
+
+  override fun onRequestPermissionsResult(
+    requestCode: Int,
+    permissions: Array<String>,
+    grantResults: IntArray
+  ) {
+    permissionsCallback = Callback {
+      if (permissionListener != null) {
+        permissionListener?.onRequestPermissionsResult(
+          requestCode,
+          permissions,
+          grantResults
+        )
 
-    override fun checkPermission(permission: String, pid: Int, uid: Int): Int {
-        return requireActivity().checkPermission(permission, pid, uid)
+        permissionListener = null
+      }
     }
-
-    @TargetApi(Build.VERSION_CODES.M)
-    override fun checkSelfPermission(permission: String): Int {
-        return requireActivity().checkSelfPermission(permission)
+  }
+
+  override fun checkPermission(permission: String, pid: Int, uid: Int): Int {
+    return requireActivity().checkPermission(permission, pid, uid)
+  }
+
+  @TargetApi(Build.VERSION_CODES.M)
+  override fun checkSelfPermission(permission: String): Int {
+    return requireActivity().checkSelfPermission(permission)
+  }
+
+  override fun requestPermissions(
+    permissions: Array<String>,
+    requestCode: Int,
+    listener: PermissionListener?
+  ) {
+    permissionListener = listener
+    this.requestPermissions(permissions, requestCode)
+  }
+
+  override fun onKeyUp(keyCode: Int, event: KeyEvent): Boolean {
+    var handled = false
+    if (ReactNativeBrownfield.shared.reactNativeHost.useDeveloperSupport && ReactNativeBrownfield.shared.reactNativeHost.hasInstance()) {
+      if (keyCode == KeyEvent.KEYCODE_MENU) {
+        ReactNativeBrownfield.shared.reactNativeHost.reactInstanceManager.showDevOptionsDialog()
+        handled = true
+      }
+      val didDoubleTapR = activity?.currentFocus?.let {
+        Assertions.assertNotNull(doubleTapReloadRecognizer)
+          .didDoubleTapR(keyCode, it)
+      }
+      if (didDoubleTapR == true) {
+        ReactNativeBrownfield.shared.reactNativeHost.reactInstanceManager.devSupportManager.handleReloadJS()
+        handled = true
+      }
     }
-
-    @TargetApi(Build.VERSION_CODES.M)
-    override fun requestPermissions(
-        permissions: Array<String>,
-        requestCode: Int,
-        listener: PermissionListener
-    ) {
-        permissionListener = listener
-        this.requestPermissions(permissions, requestCode)
+    return handled
+  }
+
+  fun onBackPressed(backBtnHandler: DefaultHardwareBackBtnHandler) {
+    if (ReactNativeBrownfieldModule.shouldPopToNative) {
+      backBtnHandler.invokeDefaultOnBackPressed()
+    } else if (ReactNativeBrownfield.shared.reactNativeHost.hasInstance()) {
+      ReactNativeBrownfield.shared.reactNativeHost.reactInstanceManager.onBackPressed()
     }
-
-    fun onKeyUp(keyCode: Int, event: KeyEvent): Boolean {
-        var handled = false
-        if (ReactNativeBrownfield.shared.reactNativeHost.useDeveloperSupport && ReactNativeBrownfield.shared.reactNativeHost.hasInstance()) {
-            if (keyCode == KeyEvent.KEYCODE_MENU) {
-                ReactNativeBrownfield.shared.reactNativeHost.reactInstanceManager.showDevOptionsDialog()
-                handled = true
-            }
-            val didDoubleTapR = activity?.currentFocus?.let {
-                Assertions.assertNotNull(doubleTapReloadRecognizer)
-                    .didDoubleTapR(keyCode, it)
-            }
-            if (didDoubleTapR == true) {
-                ReactNativeBrownfield.shared.reactNativeHost.reactInstanceManager.devSupportManager.handleReloadJS()
-                handled = true
-            }
-        }
-        return handled
+  }
+
+  companion object {
+    @JvmStatic
+    @JvmOverloads
+    fun createReactNativeFragment(
+      moduleName: String,
+      initialProps: Bundle? = null
+    ): ReactNativeFragment {
+      val fragment = ReactNativeFragment()
+      val args = Bundle()
+      args.putString(ARG_COMPONENT_NAME, moduleName)
+      if (initialProps != null) {
+        args.putBundle(ARG_LAUNCH_OPTIONS, initialProps)
+      }
+      fragment.arguments = args
+      return fragment
     }
 
-    fun onBackPressed(backBtnHandler: DefaultHardwareBackBtnHandler) {
-        if(ReactNativeBrownfieldModule.shouldPopToNative) {
-            backBtnHandler.invokeDefaultOnBackPressed()
-        } else if (ReactNativeBrownfield.shared.reactNativeHost.hasInstance()) {
-            ReactNativeBrownfield.shared.reactNativeHost.reactInstanceManager.onBackPressed()
-        }
+    @JvmStatic
+    fun createReactNativeFragment(
+      moduleName: String,
+      initialProps: HashMap<String, *>
+    ): ReactNativeFragment {
+      return createReactNativeFragment(moduleName, PropsBundle.fromHashMap(initialProps))
     }
 
-    companion object {
-        @JvmStatic
-        @JvmOverloads
-        fun createReactNativeFragment(moduleName: String, initialProps: Bundle? = null): ReactNativeFragment {
-            val fragment = ReactNativeFragment()
-            val args = Bundle()
-            args.putString(MODULE_NAME, moduleName)
-            if (initialProps != null) {
-                args.putBundle(INITIAL_PROPS, initialProps)
-            }
-            fragment.arguments = args
-            return fragment
-        }
-
-        @JvmStatic
-        fun createReactNativeFragment(moduleName: String, initialProps: HashMap<String, *>): ReactNativeFragment {
-            return createReactNativeFragment(moduleName, PropsBundle.fromHashMap(initialProps))
-        }
-
-        @JvmStatic
-        fun createReactNativeFragment(moduleName: String, initialProps: WritableMap): ReactNativeFragment {
-            return createReactNativeFragment(moduleName, initialProps.toHashMap())
-        }
+    @JvmStatic
+    fun createReactNativeFragment(
+      moduleName: String,
+      initialProps: WritableMap
+    ): ReactNativeFragment {
+      return createReactNativeFragment(moduleName, initialProps.toHashMap())
     }
+  }
 
-}
+}

package/ios/ReactNativeBrownfield.swift

@@ -0,0 +1,119 @@
+import React
+import React_RCTAppDelegate
+import ReactAppDependencyProvider
+
+@objc public class ReactNativeBrownfield: RCTDefaultReactNativeFactoryDelegate {
+  @objc public static let shared = ReactNativeBrownfield()
+  private var onBundleLoaded: (() -> Void)?
+
+  /**
+   * Path to JavaScript root.
+   * Default value: "index"
+   */
+  @objc public var entryFile: String = "index"
+  /**
+   * Path to bundle fallback resource.
+   * Default value: nil
+   */
+  @objc public var fallbackResource: String? = nil
+  /**
+   * Path to JavaScript bundle file.
+   * Default value: "main.jsbundle"
+   */
+  @objc public var bundlePath: String = "main.jsbundle"
+  /**
+   * React Native factory instance created when starting React Native.
+   * Default value: nil
+   */
+  @objc public var reactNativeFactory: RCTReactNativeFactory? = nil
+  /**
+   * Root view factory used to create React Native views.
+   */
+  @objc lazy public var rootViewFactory: RCTRootViewFactory? = {
+    return reactNativeFactory?.rootViewFactory
+  }()
+
+  /**
+   * Starts React Native with default parameters.
+   */
+  @objc public func startReactNative() {
+    startReactNative(onBundleLoaded: nil)
+  }
+  
+  /**
+   * Starts React Native with optional callback when bundle is loaded.
+   * 
+   * @param onBundleLoaded Optional callback invoked after JS bundle is fully loaded.
+   */
+  @objc public func startReactNative(onBundleLoaded: (() -> Void)?) {
+    startReactNative(onBundleLoaded: onBundleLoaded, launchOptions: nil)
+  }
+  
+  /**
+   * Starts React Native with optional callback and launch options.
+   * 
+   * @param onBundleLoaded Optional callback invoked after JS bundle is fully loaded.
+   * @param launchOptions Launch options, typically passed from AppDelegate.
+   */
+  @objc public func startReactNative(onBundleLoaded: (() -> Void)?, launchOptions: [AnyHashable: Any]?) {
+    guard reactNativeFactory == nil else { return }
+    
+    self.dependencyProvider = RCTAppDependencyProvider()
+    self.reactNativeFactory = RCTReactNativeFactory(delegate: self)
+    
+    if let onBundleLoaded {
+      self.onBundleLoaded = onBundleLoaded
+      if RCTIsNewArchEnabled() {
+        NotificationCenter.default.addObserver(
+          self,
+          selector: #selector(jsLoaded),
+          name: NSNotification.Name("RCTInstanceDidLoadBundle"),
+          object: nil
+        )
+      } else {
+        NotificationCenter.default.addObserver(
+          self,
+          selector: #selector(jsLoaded),
+          name: NSNotification.Name("RCTJavaScriptDidLoadNotification"),
+          object: nil
+        )
+      }
+    }
+  }
+  
+  @objc private func jsLoaded(_ notification: Notification) {
+    onBundleLoaded?()
+    onBundleLoaded = nil
+    NotificationCenter.default.removeObserver(self)
+  }
+  
+  // MARK: - RCTReactNativeFactoryDelegate Methods
+  
+  @objc public override func sourceURL(for bridge: RCTBridge) -> URL? {
+    return bundleURL()
+  }
+  
+  public override func bundleURL() -> URL? {
+#if DEBUG
+    return RCTBundleURLProvider.sharedSettings().jsBundleURL(forBundleRoot: entryFile)
+#else
+    let resourceURLComponents = bundlePath.components(separatedBy: ".")
+    let withoutLast = resourceURLComponents[..<(resourceURLComponents.count - 1)]
+    let resourceName = withoutLast.joined()
+    let fileExtension = resourceURLComponents.last ?? ""
+    
+    return Bundle.main.url(forResource: resourceName, withExtension: fileExtension)
+#endif
+  }
+}
+
+extension Notification.Name {
+  /**
+   * Notification sent when React Native wants to navigate back to native screen.
+   */
+  public static let popToNative = Notification.Name("PopToNativeNotification")
+  /**
+   * Notification sent to enable/disable the pop gesture recognizer.
+   */
+  public static let togglePopGestureRecognizer = Notification.Name("TogglePopGestureRecognizerNotification")
+}

package/ios/ReactNativeBrownfieldModule.m

@@ -1,24 +1,21 @@
 #import "ReactNativeBrownfieldModule.h"
-#import "ReactNativeBrownfieldNotifications.h"
+
+#if __has_include("ReactNativeBrownfield/ReactNativeBrownfield-Swift.h")
+#import "ReactNativeBrownfield/ReactNativeBrownfield-Swift.h"
+#else
+#import "ReactNativeBrownfield-Swift.h"
+#endif
 
 @implementation ReactNativeBrownfieldModule
 
 RCT_EXPORT_MODULE(ReactNativeBrownfield);
 
 RCT_EXPORT_METHOD(setPopGestureRecognizerEnabled:(BOOL)enabled) {
-    NSDictionary *userInfo = [NSDictionary dictionaryWithObject:@(enabled) forKey:@"enabled"];
-    
-    [[NSNotificationCenter defaultCenter]
-        postNotificationName:TogglePopGestureRecognizerNotification
-        object:nil userInfo:userInfo];
+  [ReactNativeBrownfieldModuleImpl setPopGestureRecognizerEnabled:enabled];
 }
 
 RCT_EXPORT_METHOD(popToNative:(BOOL)animated) {
-    NSDictionary *userInfo = [NSDictionary dictionaryWithObject:@(animated) forKey:@"animated"];
-    
-    [[NSNotificationCenter defaultCenter]
-     postNotificationName:PopToNativeNotification
-     object:nil userInfo:userInfo];
+  [ReactNativeBrownfieldModuleImpl popToNativeWithAnimated:animated];
 }
 
 @end

package/ios/ReactNativeBrownfieldModule.swift

@@ -0,0 +1,18 @@
+import React
+
+@objcMembers
+public class ReactNativeBrownfieldModuleImpl: NSObject {
+  static public func setPopGestureRecognizerEnabled(_ enabled: Bool) {
+    let userInfo = ["enabled": enabled]
+    DispatchQueue.main.async {
+      NotificationCenter.default.post(name: Notification.Name.togglePopGestureRecognizer, object: nil, userInfo: userInfo)
+    }
+  }
+  
+  static public func popToNative(animated: Bool) {
+    let userInfo = ["animated": animated]
+    DispatchQueue.main.async {
+      NotificationCenter.default.post(name: Notification.Name.popToNative, object: nil, userInfo: userInfo)
+    }
+  }
+}

package/ios/ReactNativeView.swift

@@ -0,0 +1,42 @@
+import SwiftUI
+
+/**
+ A UIViewControllerRepresentable that bridges ReactNativeViewController to SwiftUI.
+ */
+struct ReactNativeViewRepresentable: UIViewControllerRepresentable {
+  var moduleName: String
+  var initialProperties: [String: Any] = [:]
+  
+  func makeUIViewController(context: Context) -> UIViewController {
+    return ReactNativeViewController(moduleName: moduleName)
+  }
+  
+  func updateUIViewController(_ uiViewController: UIViewController, context: Context) {}
+}
+
+/**
+ Exposes React Native view to SwiftUI.
+ Supports pop to native when using SwiftUI's NavigationView or NavigationStack.
+ */
+public struct ReactNativeView: View {
+  @Environment(\.dismiss) var dismiss
+  var moduleName: String
+  var initialProperties: [String: Any] = [:]
+  
+  public init(moduleName: String, initialProperties: [String : Any] = [:]) {
+    self.moduleName = moduleName
+    self.initialProperties = initialProperties
+  }
+  
+  public var body: some View {
+    ReactNativeViewRepresentable(
+      moduleName: moduleName,
+      initialProperties: initialProperties
+    )
+    .ignoresSafeArea(.all)
+    .onReceive(NotificationCenter.default.publisher(for: NSNotification.Name.popToNative))
+    { notification in
+      dismiss()
+    }
+  }
+}

package/ios/ReactNativeViewController.swift

@@ -0,0 +1,66 @@
+import UIKit
+import React
+
+@objc public class ReactNativeViewController: UIViewController {
+  private var moduleName: String
+  private var initialProperties: [String: Any]?
+  
+  @objc public init(moduleName: String, initialProperties: [String: Any]? = nil) {
+    self.moduleName = moduleName
+    self.initialProperties = initialProperties
+    super.init(nibName: nil, bundle: nil)
+  }
+  
+  required init?(coder: NSCoder) {
+    fatalError("init(coder:) has not been implemented")
+  }
+  
+  public override func viewDidLoad() {
+    super.viewDidLoad()
+    
+    guard let factory = ReactNativeBrownfield.shared.rootViewFactory else {
+      print("Error: You need to start React Native in order to use ReactNativeViewController, make sure to run BridgeManager.shared.startReactNative() before instantiating it.")
+      return
+    }
+    
+    if !moduleName.isEmpty {
+      view = factory.view(withModuleName: moduleName, initialProperties: initialProperties)
+      
+      NotificationCenter.default.addObserver(
+        self,
+        selector: #selector(togglePopGestureRecognizer(_:)),
+        name: NSNotification.Name.togglePopGestureRecognizer,
+        object: nil
+      )
+      
+      NotificationCenter.default.addObserver(
+        self,
+        selector: #selector(popToNative(_:)),
+        name: NSNotification.Name.popToNative,
+        object: nil
+      )
+    }
+  }
+  
+  deinit {
+    NotificationCenter.default.removeObserver(self)
+  }
+  
+  @objc private func togglePopGestureRecognizer(_ notification: Notification) {
+    guard let userInfo = notification.userInfo,
+          let enabled = userInfo["enabled"] as? Bool else { return }
+    
+    DispatchQueue.main.async { [weak self] in
+      self?.navigationController?.interactivePopGestureRecognizer?.isEnabled = enabled
+    }
+  }
+  
+  @objc private func popToNative(_ notification: Notification) {
+    guard let userInfo = notification.userInfo,
+          let animated = userInfo["animated"] as? Bool else { return }
+    
+    DispatchQueue.main.async { [weak self] in
+      self?.navigationController?.popViewController(animated: animated)
+    }
+  }
+}

package/lib/commonjs/RNBrownfieldSpec.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _reactNative = require("react-native");
+var _default = exports.default = _reactNative.TurboModuleRegistry.getEnforcing('ReactNativeBrownfield');
+//# sourceMappingURL=RNBrownfieldSpec.js.map

package/lib/commonjs/RNBrownfieldSpec.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_reactNative","require","_default","exports","default","TurboModuleRegistry","getEnforcing"],"sourceRoot":"../../src","sources":["RNBrownfieldSpec.ts"],"mappings":";;;;;;AACA,IAAAA,YAAA,GAAAC,OAAA;AAAmD,IAAAC,QAAA,GAAAC,OAAA,CAAAC,OAAA,GAqBpCC,gCAAmB,CAACC,YAAY,CAAO,uBAAuB,CAAC","ignoreList":[]}

package/lib/commonjs/index.js

@@ -5,21 +5,23 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 var _reactNative = require("react-native");
+var _RNBrownfieldSpec = _interopRequireDefault(require("./RNBrownfieldSpec"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const ReactNativeBrownfield = {
   popToNative: animated => {
     if (_reactNative.Platform.OS === 'ios') {
-      _reactNative.NativeModules.ReactNativeBrownfield.popToNative(animated);
+      _RNBrownfieldSpec.default.popToNative(animated);
     } else if (_reactNative.Platform.OS === 'android') {
-      _reactNative.NativeModules.ReactNativeBrownfield.popToNative();
+      _RNBrownfieldSpec.default.popToNative();
     } else {
       console.warn('Not implemented: popToNative');
     }
   },
   setNativeBackGestureAndButtonEnabled: enabled => {
     if (_reactNative.Platform.OS === 'ios') {
-      _reactNative.NativeModules.ReactNativeBrownfield.setPopGestureRecognizerEnabled(enabled);
+      _RNBrownfieldSpec.default.setPopGestureRecognizerEnabled(enabled);
     } else if (_reactNative.Platform.OS === 'android') {
-      _reactNative.NativeModules.ReactNativeBrownfield.setHardwareBackButtonEnabled(enabled);
+      _RNBrownfieldSpec.default.setHardwareBackButtonEnabled(enabled);
     } else {
       console.warn('Not implemented: setNativeGesturesAndButtonsEnabled');
     }

package/lib/commonjs/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["_reactNative","require","ReactNativeBrownfield","popToNative","animated","Platform","OS","NativeModules","console","warn","setNativeBackGestureAndButtonEnabled","enabled","setPopGestureRecognizerEnabled","setHardwareBackButtonEnabled","_default","exports","default"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;;;;;AAAA,IAAAA,YAAA,GAAAC,OAAA;AAEA,MAAMC,qBAAqB,GAAG;EAC5BC,WAAW,EAAGC,QAAkB,IAAW;IACzC,IAAIC,qBAAQ,CAACC,EAAE,KAAK,KAAK,EAAE;MACzBC,0BAAa,CAACL,qBAAqB,CAACC,WAAW,CAACC,QAAQ,CAAC;IAC3D,CAAC,MAAM,IAAIC,qBAAQ,CAACC,EAAE,KAAK,SAAS,EAAE;MACpCC,0BAAa,CAACL,qBAAqB,CAACC,WAAW,CAAC,CAAC;IACnD,CAAC,MAAM;MACLK,OAAO,CAACC,IAAI,CAAC,8BAA8B,CAAC;IAC9C;EACF,CAAC;EAEDC,oCAAoC,EAAGC,OAAgB,IAAW;IAChE,IAAIN,qBAAQ,CAACC,EAAE,KAAK,KAAK,EAAE;MACzBC,0BAAa,CAACL,qBAAqB,CAACU,8BAA8B,CAChED,OACF,CAAC;IACH,CAAC,MAAM,IAAIN,qBAAQ,CAACC,EAAE,KAAK,SAAS,EAAE;MACpCC,0BAAa,CAACL,qBAAqB,CAACW,4BAA4B,CAACF,OAAO,CAAC;IAC3E,CAAC,MAAM;MACLH,OAAO,CAACC,IAAI,CAAC,qDAAqD,CAAC;IACrE;EACF;AACF,CAAC;AAAC,IAAAK,QAAA,GAAAC,OAAA,CAAAC,OAAA,GAEad,qBAAqB","ignoreList":[]}
+{"version":3,"names":["_reactNative","require","_RNBrownfieldSpec","_interopRequireDefault","e","__esModule","default","ReactNativeBrownfield","popToNative","animated","Platform","OS","ReactNativeBrownfieldModule","console","warn","setNativeBackGestureAndButtonEnabled","enabled","setPopGestureRecognizerEnabled","setHardwareBackButtonEnabled","_default","exports"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;;;;;AAAA,IAAAA,YAAA,GAAAC,OAAA;AACA,IAAAC,iBAAA,GAAAC,sBAAA,CAAAF,OAAA;AAA6D,SAAAE,uBAAAC,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAE7D,MAAMG,qBAAqB,GAAG;EAC5BC,WAAW,EAAGC,QAAkB,IAAW;IACzC,IAAIC,qBAAQ,CAACC,EAAE,KAAK,KAAK,EAAE;MACzBC,yBAA2B,CAACJ,WAAW,CAACC,QAAQ,CAAC;IACnD,CAAC,MAAM,IAAIC,qBAAQ,CAACC,EAAE,KAAK,SAAS,EAAE;MACpCC,yBAA2B,CAACJ,WAAW,CAAC,CAAC;IAC3C,CAAC,MAAM;MACLK,OAAO,CAACC,IAAI,CAAC,8BAA8B,CAAC;IAC9C;EACF,CAAC;EAEDC,oCAAoC,EAAGC,OAAgB,IAAW;IAChE,IAAIN,qBAAQ,CAACC,EAAE,KAAK,KAAK,EAAE;MACzBC,yBAA2B,CAACK,8BAA8B,CAACD,OAAO,CAAC;IACrE,CAAC,MAAM,IAAIN,qBAAQ,CAACC,EAAE,KAAK,SAAS,EAAE;MACpCC,yBAA2B,CAACM,4BAA4B,CAACF,OAAO,CAAC;IACnE,CAAC,MAAM;MACLH,OAAO,CAACC,IAAI,CAAC,qDAAqD,CAAC;IACrE;EACF;AACF,CAAC;AAAC,IAAAK,QAAA,GAAAC,OAAA,CAAAd,OAAA,GAEaC,qBAAqB","ignoreList":[]}

package/lib/commonjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/lib/module/RNBrownfieldSpec.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import { TurboModuleRegistry } from 'react-native';
+export default TurboModuleRegistry.getEnforcing('ReactNativeBrownfield');
+//# sourceMappingURL=RNBrownfieldSpec.js.map

package/lib/module/RNBrownfieldSpec.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["TurboModuleRegistry","getEnforcing"],"sourceRoot":"../../src","sources":["RNBrownfieldSpec.ts"],"mappings":";;AACA,SAASA,mBAAmB,QAAQ,cAAc;AAqBlD,eAAeA,mBAAmB,CAACC,YAAY,CAAO,uBAAuB,CAAC","ignoreList":[]}