react-native-orientation-director 1.3.0 → 2.0.0

package/android/src/test/java/com/orientationdirector/implementation/OrientationDirectorModuleImplTest.kt

@@ -0,0 +1,188 @@
+package com.orientationdirector.implementation
+
+import android.os.Looper
+import androidx.test.core.app.ApplicationProvider
+import com.facebook.react.bridge.BridgeReactContext
+import org.junit.Assert.*
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.InjectMocks
+import org.mockito.Mock
+import org.mockito.Mockito.`when`
+import org.mockito.MockitoAnnotations
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+
+@RunWith(RobolectricTestRunner::class)
+class OrientationDirectorModuleImplTest {
+  private var context = BridgeReactContext(ApplicationProvider.getApplicationContext())
+
+  @Mock
+  private val mockEventManager = EventManager(context)
+
+  @Mock
+  private val mockAutoRotationObserver = AutoRotationObserver(
+    context,
+    android.os.Handler(Looper.getMainLooper())
+  )
+
+  @InjectMocks
+  private val mModule = OrientationDirectorModuleImpl(context)
+
+  @Before
+  fun setup() {
+    MockitoAnnotations.openMocks(this)
+
+    // We stub this method because adaptInterfaceTo checks it
+    `when`(mockAutoRotationObserver.getLastAutoRotationStatus()).thenReturn(true)
+  }
+
+  @Test
+  @Config(
+    qualifiers = "port"
+  )
+  fun assert_initial_orientation_matches_portrait() {
+    val orientation = mModule.getInterfaceOrientation()
+
+    assertEquals(
+      "When user starts the app with the device in portrait, the initial interface should be portrait",
+      Orientation.PORTRAIT,
+      orientation
+    )
+  }
+
+  @Test
+  @Config(
+    qualifiers = "land"
+  )
+  fun assert_initial_orientation_matches_landscape_left() {
+    val orientation = mModule.getInterfaceOrientation()
+
+    assertEquals(
+      "When user starts the app with the device in landscape, the initial interface should be landscape left",
+      Orientation.LANDSCAPE_LEFT,
+      orientation
+    )
+  }
+
+  @Test
+  fun assert_initial_device_orientation_matches_unknown_at_startup() {
+    val orientation = mModule.getDeviceOrientation()
+
+    assertEquals(
+      "When user starts the app, the initial device orientation should be unknown",
+      Orientation.UNKNOWN,
+      orientation
+    )
+  }
+
+  @Test
+  fun assert_initial_is_locked_matches_false_at_startup() {
+    val isLocked = mModule.getIsLocked()
+
+    assertEquals(
+      "When user starts the app, interface orientation shouldn't be locked",
+      false,
+      isLocked
+    )
+  }
+
+  @Test
+  fun assert_is_locked_matches_true_after_lock_to_gets_executed() {
+    mModule.lockTo(1)
+    val isLocked = mModule.getIsLocked()
+
+    assertEquals(
+      "When lockTo is executed, getIsLocked should match true",
+      true,
+      isLocked
+    )
+  }
+
+  @Test
+  fun assert_interface_orientation_matches_locked_to_portrait() {
+    mModule.lockTo(1)
+
+    assertEquals(
+      "When the interface is locked to portrait, getInterfaceOrientation should return portrait",
+      Orientation.PORTRAIT,
+      mModule.getInterfaceOrientation()
+    )
+  }
+
+  @Test
+  fun assert_interface_orientation_matches_locked_to_landscape_right() {
+    mModule.lockTo(2)
+
+    assertEquals(
+      "When the interface is locked to landscape right, getInterfaceOrientation should return landscape right",
+      Orientation.LANDSCAPE_RIGHT,
+      mModule.getInterfaceOrientation()
+    )
+  }
+
+  @Test
+  fun assert_interface_orientation_matches_locked_to_portrait_upside_down() {
+    mModule.lockTo(3)
+
+    assertEquals(
+      "When the interface is locked to portrait upside down, getInterfaceOrientation should return portrait upside down",
+      Orientation.PORTRAIT_UPSIDE_DOWN,
+      mModule.getInterfaceOrientation()
+    )
+  }
+
+  @Test
+  fun assert_interface_orientation_matches_locked_to_landscape_left() {
+    mModule.lockTo(4)
+
+    assertEquals(
+      "When the interface is locked to landscape left, getInterfaceOrientation should return landscape left",
+      Orientation.LANDSCAPE_LEFT,
+      mModule.getInterfaceOrientation()
+    )
+  }
+
+  @Test
+  fun assert_is_locked_reset_when_unlock_is_executed() {
+    mModule.lockTo(1)
+    mModule.unlock()
+
+    assertEquals(
+      "When unlock is executed, getIsLocked should return false",
+      false,
+      mModule.getIsLocked()
+    )
+  }
+
+  @Test
+  @Config(
+    qualifiers = "port"
+  )
+  fun assert_interface_reset_to_portrait_on_unlock() {
+    mModule.lockTo(2)
+    mModule.unlock()
+
+    assertEquals(
+      "When unlock is executed, getInterfaceOrientation should match portrait when device is in portrait",
+      Orientation.PORTRAIT,
+      mModule.getInterfaceOrientation()
+    )
+  }
+
+  @Test
+  @Config(
+    qualifiers = "land"
+  )
+  fun assert_interface_reset_to_landscape_left_on_unlock() {
+    mModule.lockTo(2)
+    mModule.unlock()
+
+    assertEquals(
+      "When unlock is executed, getInterfaceOrientation should match landscape left when device is in landscape right",
+      Orientation.LANDSCAPE_LEFT,
+      mModule.getInterfaceOrientation()
+    )
+  }
+}

package/android/src/test/java/com/orientationdirector/implementation/UtilsTest.kt

@@ -0,0 +1,314 @@
+package com.orientationdirector.implementation
+
+import android.content.pm.ActivityInfo
+import android.os.Build
+import android.view.Surface
+import androidx.test.core.app.ApplicationProvider
+import com.facebook.react.bridge.BridgeReactContext
+import org.junit.Assert.*
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+
+@RunWith(RobolectricTestRunner::class)
+class UtilsTest {
+  private var context = BridgeReactContext(ApplicationProvider.getApplicationContext())
+  private var mUtils = Utils(context)
+
+  @Config(
+    sdk = [Build.VERSION_CODES.N],
+    qualifiers = "land"
+  )
+  @Test
+  fun assert_interface_rotation_matches_current_landscape() {
+    val rotation = mUtils.getInterfaceRotation()
+
+    assertEquals(
+      "When current interface orientation is landscape, rotation should be 1",
+      Surface.ROTATION_90,
+      rotation
+    )
+  }
+
+  @Config(
+    sdk = [Build.VERSION_CODES.R],
+    qualifiers = "port"
+  )
+  @Test
+  fun assert_interface_rotation_matches_current_portrait() {
+    val rotation = mUtils.getInterfaceRotation()
+
+    assertEquals(
+      "When current interface orientation is portrait, rotation should be 0",
+      Surface.ROTATION_0,
+      rotation
+    )
+  }
+
+  @Test
+  fun assert_device_orientation_is_portrait() {
+    val orientationAngles = FloatArray(3)
+    orientationAngles[1] = -(Math.PI / 2).toFloat()
+    orientationAngles[2] = -0f
+
+    val orientation = mUtils.convertToDeviceOrientationFrom(orientationAngles)
+
+    assertEquals(
+      "When pitch is half PI radians and roll is -0 radians, orientation should be portrait",
+      Orientation.PORTRAIT,
+      orientation
+    )
+  }
+
+  @Test
+  fun assert_device_orientation_is_landscape_right() {
+    val orientationAngles = FloatArray(3)
+    orientationAngles[1] = 0f
+    orientationAngles[2] = (Math.PI / 2).toFloat()
+
+    val orientation = mUtils.convertToDeviceOrientationFrom(orientationAngles)
+
+    assertEquals(
+      "When pitch is 0 radians and roll is half PI radians, orientation should be landscape right",
+      Orientation.LANDSCAPE_RIGHT,
+      orientation
+    )
+  }
+
+  @Test
+  fun assert_device_orientation_is_portrait_upside_down() {
+    val orientationAngles = FloatArray(3)
+    orientationAngles[1] = (Math.PI / 2).toFloat()
+    orientationAngles[2] = 0f
+
+    val orientation = mUtils.convertToDeviceOrientationFrom(orientationAngles)
+
+    assertEquals(
+      "When pitch is half PI radians and roll is 0 radians, orientation should be portrait upside down",
+      Orientation.PORTRAIT_UPSIDE_DOWN, orientation
+    )
+  }
+
+  @Test
+  fun assert_device_orientation_is_landscape_left() {
+    val orientationAngles = FloatArray(3)
+    orientationAngles[1] = 0f
+    orientationAngles[2] = -(Math.PI / 2).toFloat()
+
+    val orientation = mUtils.convertToDeviceOrientationFrom(orientationAngles)
+
+    assertEquals(
+      "When pitch is 0 radians and roll is negative half PI radians, orientation should be landscape left",
+      Orientation.LANDSCAPE_LEFT,
+      orientation
+    )
+  }
+
+  @Test
+  fun assert_device_orientation_is_face_down() {
+    val orientationAngles = FloatArray(3)
+    orientationAngles[1] = 0f
+    orientationAngles[2] = -(Math.PI).toFloat()
+
+    val orientation = mUtils.convertToDeviceOrientationFrom(orientationAngles)
+
+    assertEquals(
+      "When pitch is 0 radians and roll is negative PI radians, orientation should be face down",
+      Orientation.FACE_DOWN,
+      orientation
+    )
+  }
+
+  @Test
+  fun assert_device_orientation_is_face_up() {
+    val orientationAngles = FloatArray(3)
+    orientationAngles[1] = 0f
+    orientationAngles[2] = -0f
+
+    val orientation = mUtils.convertToDeviceOrientationFrom(orientationAngles)
+
+    assertEquals(
+      "When pitch is 0 radians and roll is negative 0 radians, orientation should be face up",
+      Orientation.FACE_UP,
+      orientation
+    )
+  }
+
+  @Test
+  fun assert_activity_orientation_conversion_from_portrait() {
+    val activityOrientation = mUtils.convertToActivityOrientationFrom(Orientation.PORTRAIT);
+
+    assertEquals(
+      "When orientation is portrait, activity orientation should be portrait",
+      ActivityInfo.SCREEN_ORIENTATION_PORTRAIT,
+      activityOrientation
+    )
+  }
+
+  @Test
+  fun assert_activity_orientation_conversion_from_landscape_right() {
+    val activityOrientation = mUtils.convertToActivityOrientationFrom(Orientation.LANDSCAPE_RIGHT);
+
+    assertEquals(
+      "When orientation is landscape right, activity orientation should be landscape",
+      ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE,
+      activityOrientation
+    )
+  }
+
+  @Test
+  fun assert_activity_orientation_conversion_from_portrait_upside_down() {
+    val activityOrientation =
+      mUtils.convertToActivityOrientationFrom(Orientation.PORTRAIT_UPSIDE_DOWN);
+
+    assertEquals(
+      "When orientation is portrait upside down, activity orientation should be reverse portrait",
+      ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT,
+      activityOrientation
+    )
+  }
+
+  @Test
+  fun assert_activity_orientation_conversion_from_landscape_left() {
+    val activityOrientation = mUtils.convertToActivityOrientationFrom(Orientation.LANDSCAPE_LEFT);
+
+    assertEquals(
+      "When orientation is landscape left, activity orientation should be reverse landscape",
+      ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE,
+      activityOrientation
+    )
+  }
+
+  @Test
+  fun assert_orientation_conversion_from_js_portrait() {
+    val orientation = mUtils.convertToOrientationFromJsValue(1)
+
+    assertEquals(
+      "When js value is 1, orientation should be portrait",
+      Orientation.PORTRAIT,
+      orientation
+    )
+  }
+
+  @Test
+  fun assert_orientation_conversion_from_js_landscape_right() {
+    val orientation = mUtils.convertToOrientationFromJsValue(2)
+
+    assertEquals(
+      "When js value is 2, orientation should be landscape right",
+      Orientation.LANDSCAPE_RIGHT,
+      orientation
+    )
+  }
+
+  @Test
+  fun assert_orientation_conversion_from_js_portrait_upside_down() {
+    val orientation = mUtils.convertToOrientationFromJsValue(3)
+
+    assertEquals(
+      "When js value is 3, orientation should be portrait upside down",
+      Orientation.PORTRAIT_UPSIDE_DOWN,
+      orientation
+    )
+  }
+
+  @Test
+  fun assert_orientation_conversion_from_js_landscape_left() {
+    val orientation = mUtils.convertToOrientationFromJsValue(4)
+
+    assertEquals(
+      "When js value is 4, orientation should be landscape left",
+      Orientation.LANDSCAPE_LEFT,
+      orientation
+    )
+  }
+
+  @Test
+  fun assert_orientation_conversion_from_screen_rotation_0() {
+    val orientation = mUtils.convertToOrientationFromScreenRotation(Surface.ROTATION_0)
+
+    assertEquals(
+      "When screen rotation is 0, orientation should be portrait",
+      Orientation.PORTRAIT,
+      orientation
+    )
+  }
+
+  @Test
+  fun assert_orientation_conversion_from_screen_rotation_90() {
+    val orientation = mUtils.convertToOrientationFromScreenRotation(Surface.ROTATION_90)
+
+    assertEquals(
+      "When screen rotation is 90, orientation should be landscape left",
+      Orientation.LANDSCAPE_LEFT,
+      orientation
+    )
+  }
+
+  @Test
+  fun assert_orientation_conversion_from_screen_rotation_180() {
+    val orientation = mUtils.convertToOrientationFromScreenRotation(Surface.ROTATION_180)
+
+    assertEquals(
+      "When screen rotation is 180, orientation should be portrait upside down",
+      Orientation.PORTRAIT_UPSIDE_DOWN,
+      orientation
+    )
+  }
+
+  @Test
+  fun assert_orientation_conversion_from_screen_rotation_270() {
+    val orientation = mUtils.convertToOrientationFromScreenRotation(Surface.ROTATION_270)
+
+    assertEquals(
+      "When screen rotation is 270, orientation should be landscape right",
+      Orientation.LANDSCAPE_RIGHT,
+      orientation
+    )
+  }
+
+  @Test
+  fun assert_interface_orientation_conversion_from_device_portrait() {
+    val orientation = mUtils.convertToInterfaceOrientationFrom(Orientation.PORTRAIT)
+
+    assertEquals(
+      "When device orientation is portrait, interface orientation should be portrait",
+      Orientation.PORTRAIT,
+      orientation
+    )
+  }
+
+  @Test
+  fun assert_interface_orientation_conversion_from_device_landscape_right() {
+    val orientation = mUtils.convertToInterfaceOrientationFrom(Orientation.LANDSCAPE_RIGHT)
+
+    assertEquals(
+      "When device orientation is landscape right, interface orientation should be landscape left",
+      Orientation.LANDSCAPE_LEFT,
+      orientation
+    )
+  }
+
+  @Test
+  fun assert_interface_orientation_conversion_from_device_portrait_upside_down() {
+    val orientation = mUtils.convertToInterfaceOrientationFrom(Orientation.PORTRAIT_UPSIDE_DOWN)
+
+    assertEquals(
+      "When device orientation is portrait upside down, interface orientation should be portrait upside down",
+      Orientation.PORTRAIT_UPSIDE_DOWN,
+      orientation
+    )
+  }
+
+  @Test
+  fun assert_interface_orientation_conversion_from_device_landscape_left() {
+    val orientation = mUtils.convertToInterfaceOrientationFrom(Orientation.LANDSCAPE_LEFT)
+
+    assertEquals(
+      "When device orientation is landscape left, interface orientation should be landscape right",
+      Orientation.LANDSCAPE_RIGHT,
+      orientation
+    )
+  }
+}

package/ios/OrientationDirector.mm

@@ -41,6 +41,11 @@ RCT_EXPORT_MODULE()
     return YES;
 }
 
++ (UIInterfaceOrientationMask)getSupportedInterfaceOrientationsForWindow
+{
+    return [_director supportedInterfaceOrientations];
+}
+
 ///////////////////////////////////////////////////////////////////////////////////////
 ///         EVENT EMITTER SETUP
 ///
@@ -62,49 +67,31 @@ RCT_EXPORT_MODULE()
 ///
 ///////////////////////////////////////////////////////////////////////////////////////
 
-+ (UIInterfaceOrientationMask)getSupportedInterfaceOrientationsForWindow
-{
-    return [_director supportedInterfaceOrientations];
-}
-
-#ifdef RCT_NEW_ARCH_ENABLED
-- (void)getInterfaceOrientation:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
-#else
+///////////////////////////////////////////////////////////////////////////////////////
+///         EXPORTED METHODS
+///
 RCT_EXPORT_METHOD(getInterfaceOrientation:(RCTPromiseResolveBlock)resolve
-                  rejecter:(RCTPromiseRejectBlock)reject)
-#endif
+                  reject:(RCTPromiseRejectBlock)reject)
 {
     dispatch_async(dispatch_get_main_queue(), ^{
         resolve(@([_director getInterfaceOrientation]));
     });
 }
 
-#ifdef RCT_NEW_ARCH_ENABLED
-- (void)getDeviceOrientation:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
-#else
 RCT_EXPORT_METHOD(getDeviceOrientation:(RCTPromiseResolveBlock)resolve
-                  rejecter:(RCTPromiseRejectBlock)reject)
-#endif
+                  reject:(RCTPromiseRejectBlock)reject)
 {
     dispatch_async(dispatch_get_main_queue(), ^{
         resolve(@([_director getDeviceOrientation]));
     });
 }
 
-#ifdef RCT_NEW_ARCH_ENABLED
-- (NSNumber *)isLocked
-#else
 RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(isLocked)
-#endif
 {
     return @([_director getIsLocked]);
 }
 
-#ifdef RCT_NEW_ARCH_ENABLED
-- (void)lockTo:(double)jsOrientation
-#else
 RCT_EXPORT_METHOD(lockTo:(double)jsOrientation)
-#endif
 {
     NSNumber *jsOrientationNumber = @(jsOrientation);
     dispatch_async(dispatch_get_main_queue(), ^{
@@ -112,22 +99,14 @@ RCT_EXPORT_METHOD(lockTo:(double)jsOrientation)
     });
 }
 
-#ifdef RCT_NEW_ARCH_ENABLED
-- (void)unlock
-#else
 RCT_EXPORT_METHOD(unlock)
-#endif
 {
     dispatch_async(dispatch_get_main_queue(), ^{
         [_director unlock];
     });
 }
 
-#ifdef RCT_NEW_ARCH_ENABLED
-- (void)resetSupportedInterfaceOrientations
-#else
 RCT_EXPORT_METHOD(resetSupportedInterfaceOrientations)
-#endif
 {
     dispatch_async(dispatch_get_main_queue(), ^{
         [_director resetSupportedInterfaceOrientations];
@@ -137,16 +116,12 @@ RCT_EXPORT_METHOD(resetSupportedInterfaceOrientations)
 /**
  This method is a pure stub since we cannot access auto rotation setting in iOS
  */
-#ifdef RCT_NEW_ARCH_ENABLED
-- (NSNumber *)isAutoRotationEnabled
-#else
 RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(isAutoRotationEnabled)
-#endif
 {
     return @(NO);
 }
-
-
+///
+///////////////////////////////////////////////////////////////////////////////////////
 
 // Don't compile this code when we build for the old architecture.
 #ifdef RCT_NEW_ARCH_ENABLED

package/lib/commonjs/EventEmitter.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _reactNative = require("react-native");
+var _module = _interopRequireWildcard(require("./module"));
+var _Event = _interopRequireDefault(require("./types/Event.enum"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+class EventEmitter {
+  static addDeviceOrientationDidChangeListener(callback) {
+    let listener = _module.ModuleEventEmitter.addListener(_Event.default.DeviceOrientationDidChange, callback);
+    if (_reactNative.Platform.OS !== 'android') {
+      return listener;
+    }
+    const listenerCount = _module.ModuleEventEmitter.listenerCount(_Event.default.DeviceOrientationDidChange);
+    if (listenerCount === 1) {
+      _module.default.enableOrientationSensors();
+    }
+    return EventEmitter.createDeviceOrientationListenerProxy(listener);
+  }
+  static addInterfaceOrientationDidChangeListener(callback) {
+    return _module.ModuleEventEmitter.addListener(_Event.default.InterfaceOrientationDidChange, callback);
+  }
+  static addLockDidChangeListener(callback) {
+    return _module.ModuleEventEmitter.addListener(_Event.default.LockDidChange, callback);
+  }
+  static createDeviceOrientationListenerProxy(listener) {
+    const handler = {
+      get(target, propertyKey, receiver) {
+        if (propertyKey === 'remove') {
+          disableOrientationSensorsIfLastListener();
+        }
+        return Reflect.get(target, propertyKey, receiver);
+      }
+    };
+    return new Proxy(listener, handler);
+    function disableOrientationSensorsIfLastListener() {
+      const listenerCount = _module.ModuleEventEmitter.listenerCount(_Event.default.DeviceOrientationDidChange);
+      if (listenerCount === 1) {
+        _module.default.disableOrientationSensors();
+      }
+    }
+  }
+}
+var _default = exports.default = EventEmitter;
+//# sourceMappingURL=EventEmitter.js.map

package/lib/commonjs/EventEmitter.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_reactNative","require","_module","_interopRequireWildcard","_Event","_interopRequireDefault","e","__esModule","default","_getRequireWildcardCache","WeakMap","r","t","has","get","n","__proto__","a","Object","defineProperty","getOwnPropertyDescriptor","u","hasOwnProperty","call","i","set","EventEmitter","addDeviceOrientationDidChangeListener","callback","listener","ModuleEventEmitter","addListener","Event","DeviceOrientationDidChange","Platform","OS","listenerCount","Module","enableOrientationSensors","createDeviceOrientationListenerProxy","addInterfaceOrientationDidChangeListener","InterfaceOrientationDidChange","addLockDidChangeListener","LockDidChange","handler","target","propertyKey","receiver","disableOrientationSensorsIfLastListener","Reflect","Proxy","disableOrientationSensors","_default","exports"],"sourceRoot":"../../src","sources":["EventEmitter.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/NativeOrientationDirector.js.map

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