react-native-orientation-director 2.5.0 → 2.6.0

package/android/src/main/java/com/orientationdirector/implementation/OrientationSensorsEventListener.kt

@@ -10,12 +10,20 @@ import com.facebook.react.bridge.ReactApplicationContext
 class OrientationSensorsEventListener(
   context: ReactApplicationContext,
 ) : SensorEventListener {
-  private var mSensorManager: SensorManager = context.getSystemService(SENSOR_SERVICE) as SensorManager
+  private var mSensorManager: SensorManager =
+    context.getSystemService(SENSOR_SERVICE) as SensorManager
 
-  private var mAccelerometerSensor: Sensor? = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)
-  private var mMagneticFieldSensor: Sensor? = mSensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD)
+  private var mRotationSensor: Sensor? =
+    mSensorManager.getDefaultSensor(Sensor.TYPE_ROTATION_VECTOR)
+  private var mAccelerometerSensor: Sensor? =
+    mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)
+  private var mMagneticFieldSensor: Sensor? =
+    mSensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD)
 
-  private var hasRequiredSensors: Boolean = mAccelerometerSensor != null && mMagneticFieldSensor != null
+  private var hasRotationSensor: Boolean =
+   mRotationSensor != null
+  private var hasAccelerometerAndMagneticFieldSensors: Boolean =
+    mAccelerometerSensor != null && mMagneticFieldSensor != null
 
   private val accelerometerReading = FloatArray(3)
   private val magnetometerReading = FloatArray(3)
@@ -32,6 +40,59 @@ class OrientationSensorsEventListener(
       return
     }
 
+    if (event.sensor.type == Sensor.TYPE_ROTATION_VECTOR) {
+      computeOrientationFromRotationSensor(event.values);
+      return
+    }
+
+    computeOrientationFromOtherSensors(event)
+  }
+
+  override fun onAccuracyChanged(sensor: Sensor?, accuracy: Int) {}
+
+  fun enable() {
+    if (hasRotationSensor) {
+      mSensorManager.registerListener(
+        this,
+        mRotationSensor,
+        SensorManager.SENSOR_DELAY_NORMAL,
+        SensorManager.SENSOR_DELAY_UI
+      )
+      return
+    }
+
+    if (hasAccelerometerAndMagneticFieldSensors) {
+      mSensorManager.registerListener(
+        this,
+        mAccelerometerSensor,
+        SensorManager.SENSOR_DELAY_NORMAL,
+        SensorManager.SENSOR_DELAY_UI
+      )
+      mSensorManager.registerListener(
+        this,
+        mMagneticFieldSensor,
+        SensorManager.SENSOR_DELAY_NORMAL,
+        SensorManager.SENSOR_DELAY_UI
+      )
+      return
+    }
+  }
+
+  fun disable() {
+    mSensorManager.unregisterListener(this)
+  }
+
+  private fun computeOrientationFromRotationSensor(values: FloatArray) {
+    val rotationMatrix = FloatArray(9)
+    SensorManager.getRotationMatrixFromVector(rotationMatrix, values)
+
+    val orientationAngles = FloatArray(3)
+    SensorManager.getOrientation(rotationMatrix, orientationAngles)
+
+    notifyOrientationAnglesChanged(orientationAngles)
+  }
+
+  private fun computeOrientationFromOtherSensors(event: SensorEvent) {
     if (event.sensor.type == Sensor.TYPE_ACCELEROMETER) {
       System.arraycopy(event.values, 0, accelerometerReading, 0, accelerometerReading.size)
     }
@@ -54,6 +115,10 @@ class OrientationSensorsEventListener(
     val orientationAngles = FloatArray(3)
     SensorManager.getOrientation(rotationMatrix, orientationAngles)
 
+    notifyOrientationAnglesChanged(orientationAngles)
+  }
+
+  private fun notifyOrientationAnglesChanged(orientationAngles: FloatArray) {
     if (lastComputedOrientationAngles.contentEquals(orientationAngles)) {
       return
     }
@@ -61,19 +126,4 @@ class OrientationSensorsEventListener(
     onOrientationAnglesChangedCallback?.invoke(orientationAngles)
     lastComputedOrientationAngles = orientationAngles
   }
-
-  override fun onAccuracyChanged(sensor: Sensor?, accuracy: Int) {}
-
-  fun enable() {
-    if (!hasRequiredSensors) {
-      return
-    }
-
-    mSensorManager.registerListener(this, mAccelerometerSensor, SensorManager.SENSOR_DELAY_NORMAL)
-    mSensorManager.registerListener(this, mMagneticFieldSensor, SensorManager.SENSOR_DELAY_NORMAL)
-  }
-
-  fun disable() {
-    mSensorManager.unregisterListener(this)
-  }
 }

package/android/src/main/java/com/orientationdirector/implementation/Utils.kt

@@ -26,7 +26,9 @@ class Utils(private val context: ReactContext) {
     val rollDegrees = Math.toDegrees(rollRadians.toDouble()).toFloat()
 
     // This is needed to account for inaccuracy due to subtle movements such as tilting
-    val tolerance = 20f
+    val pitchToleranceDefault = 5f
+    val rollTolerance = 0f
+    val toleranceForFaceUpOrDown = 5f;
 
     //////////////////////////////////////
     // These limits are set based on SensorManager.getOrientation reference
@@ -38,12 +40,17 @@ class Utils(private val context: ReactContext) {
     //
     //////////////////////////////////////
 
+    val isPitchInLandscapeModeRange =
+      checkIfValueIsBetweenTolerance(pitchDegrees, pitchToleranceDefault)
+    val isPitchCloseToFaceUpOrDown =
+      checkIfValueIsBetweenTolerance(pitchDegrees, toleranceForFaceUpOrDown)
+
     return when {
-      rollDegrees.equals(-0f) && (pitchDegrees.equals(0f) || pitchDegrees.equals(-0f)) -> Orientation.FACE_UP
-      rollDegrees.equals(-180f) && (pitchDegrees.equals(0f) || pitchDegrees.equals(-0f)) -> Orientation.FACE_DOWN
-      rollDegrees in tolerance..landscapeRightLimit - tolerance -> Orientation.LANDSCAPE_RIGHT
-      rollDegrees in landscapeLeftLimit + tolerance..-tolerance -> Orientation.LANDSCAPE_LEFT
-      pitchDegrees in portraitLimit..-0f -> Orientation.PORTRAIT
+      checkIfRollIsCloseToFaceUp(rollDegrees) && isPitchCloseToFaceUpOrDown -> Orientation.FACE_UP
+      checkIfRollIsCloseToFaceDown(rollDegrees) && isPitchCloseToFaceUpOrDown -> Orientation.FACE_DOWN
+      rollDegrees in rollTolerance..landscapeRightLimit - rollTolerance && isPitchInLandscapeModeRange -> Orientation.LANDSCAPE_RIGHT
+      rollDegrees in landscapeLeftLimit + rollTolerance..-rollTolerance && isPitchInLandscapeModeRange -> Orientation.LANDSCAPE_LEFT
+      pitchDegrees in portraitLimit..pitchToleranceDefault -> Orientation.PORTRAIT
       else -> Orientation.PORTRAIT_UPSIDE_DOWN
     }
   }
@@ -94,4 +101,24 @@ class Utils(private val context: ReactContext) {
 
     return context.currentActivity!!.requestedOrientation;
   }
+
+  private fun checkIfValueIsBetweenTolerance(value: Float, tolerance: Float): Boolean {
+    return value > -tolerance && value < tolerance
+  }
+
+  private fun checkIfRollIsCloseToFaceDown(value: Float): Boolean {
+    val landscapeLimit = 180f
+    val faceDownLimit = 170f
+
+    return value in faceDownLimit..landscapeLimit  ||
+      value in -landscapeLimit..-faceDownLimit;
+  }
+
+  private fun checkIfRollIsCloseToFaceUp(value: Float): Boolean {
+    val landscapeLimit = 0f
+    val faceUpLimit = 10f
+
+    return value in landscapeLimit..faceUpLimit ||
+      value in -faceUpLimit..-landscapeLimit
+  }
 }

package/ios/implementation/OrientationDirectorImpl.swift

@@ -19,6 +19,13 @@ import UIKit
     private var lastInterfaceOrientation = Orientation.UNKNOWN
     private var lastDeviceOrientation = Orientation.UNKNOWN
     private var isLocked = false
+  
+    /// # Only on iOS < 16
+    /// This variable is needed to prevent a loop where
+    /// we lock the interface to a specific orientation
+    /// and the sensor picks it up, therefore triggering
+    /// the orientation did change event.
+    private var isLocking = false
 
     @objc public var supportedInterfaceOrientations: UIInterfaceOrientationMask = UIInterfaceOrientationMask.all
 
@@ -56,6 +63,7 @@ import UIKit
     }
 
     @objc public func lockTo(jsValue: NSNumber) {
+        self.isLocking = true;
         let jsOrientation = utils.convertToOrientationFrom(jsValue: jsValue)
         let mask = utils.convertToMaskFrom(jsOrientation: jsOrientation)
         self.requestInterfaceUpdateTo(mask: mask)
@@ -65,17 +73,20 @@ import UIKit
         let orientationCanBeUpdatedDirectly = jsOrientation != Orientation.LANDSCAPE
         if orientationCanBeUpdatedDirectly {
             updateLastInterfaceOrientationTo(value: jsOrientation)
+            self.isLocking = false;
             return
         }
 
         let lastInterfaceOrientationIsAlreadyInLandscape = lastInterfaceOrientation == Orientation.LANDSCAPE_RIGHT || lastInterfaceOrientation == Orientation.LANDSCAPE_LEFT
         if lastInterfaceOrientationIsAlreadyInLandscape {
             updateLastInterfaceOrientationTo(value: lastInterfaceOrientation)
+            self.isLocking = false;
             return
         }
 
         let systemDefaultLandscapeOrientation = Orientation.LANDSCAPE_RIGHT
         updateLastInterfaceOrientationTo(value: systemDefaultLandscapeOrientation)
+        self.isLocking = false;
     }
 
     @objc public func unlock() {
@@ -155,14 +166,19 @@ import UIKit
                 print("\(OrientationDirectorImpl.TAG) - requestGeometryUpdate error", error)
             }
         } else {
-            UIDevice.current.setValue(mask.rawValue, forKey: "orientation")
+            let interfaceOrientation = self.utils.convertToInterfaceOrientationFrom(mask: mask)
+            UIDevice.current.setValue(interfaceOrientation.rawValue, forKey: "orientation")
             UIViewController.attemptRotationToDeviceOrientation()
         }
     }
 
     private func onOrientationChanged(uiDeviceOrientation: UIDeviceOrientation) {
         let deviceOrientation = utils.convertToOrientationFrom(deviceOrientation: uiDeviceOrientation)
-        self.eventManager.sendDeviceOrientationDidChange(orientationValue: deviceOrientation.rawValue)
+        
+        if (!self.isLocking) {
+          self.eventManager.sendDeviceOrientationDidChange(orientationValue: deviceOrientation.rawValue)
+        }
+      
         lastDeviceOrientation = deviceOrientation
         adaptInterfaceTo(deviceOrientation: deviceOrientation)
     }

package/ios/implementation/Utils.swift

@@ -78,6 +78,21 @@ class Utils {
         }
     }
 
+    public func convertToInterfaceOrientationFrom(mask: UIInterfaceOrientationMask) -> UIInterfaceOrientation {
+      switch mask {
+        case .portrait:
+          return .portrait
+        case .landscapeRight:
+          return .landscapeRight
+        case .portraitUpsideDown:
+          return .portraitUpsideDown
+        case .landscapeLeft:
+          return .landscapeLeft
+        default:
+          return .unknown
+      }
+    }
+
     public func getInterfaceOrientation() -> UIInterfaceOrientation {
         guard let windowScene = self.getCurrentWindow()?.windowScene else {
             return UIInterfaceOrientation.unknown

package/lib/commonjs/EventEmitter.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _reactNative = require("react-native");
+var _module = _interopRequireWildcard(require("./module.js"));
+var _EventEnum = _interopRequireDefault(require("./types/Event.enum.js"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+class EventEmitter {
+  static addDeviceOrientationDidChangeListener(callback) {
+    let listener = _module.ModuleEventEmitter.addListener(_EventEnum.default.DeviceOrientationDidChange, callback);
+    if (_reactNative.Platform.OS !== 'android') {
+      return listener;
+    }
+    const listenerCount = _module.ModuleEventEmitter.listenerCount(_EventEnum.default.DeviceOrientationDidChange);
+    if (listenerCount === 1) {
+      _module.default.enableOrientationSensors();
+    }
+    return EventEmitter.createDeviceOrientationListenerProxy(listener);
+  }
+  static addInterfaceOrientationDidChangeListener(callback) {
+    return _module.ModuleEventEmitter.addListener(_EventEnum.default.InterfaceOrientationDidChange, callback);
+  }
+  static addLockDidChangeListener(callback) {
+    return _module.ModuleEventEmitter.addListener(_EventEnum.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(_EventEnum.default.DeviceOrientationDidChange);
+      if (listenerCount === 1) {
+        _module.default.disableOrientationSensors();
+      }
+    }
+  }
+}
+var _default = exports.default = EventEmitter;

package/lib/commonjs/NativeOrientationDirector.js

@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _reactNative = require("react-native");
+var _default = exports.default = _reactNative.TurboModuleRegistry.getEnforcing('OrientationDirector');

package/lib/commonjs/RNOrientationDirector.js

@@ -0,0 +1,126 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _reactNative = require("react-native");
+var _module = _interopRequireDefault(require("./module.js"));
+var _OrientationEnum = require("./types/Orientation.enum.js");
+var _AutoRotationEnum = require("./types/AutoRotation.enum.js");
+var _OrientationTypeEnum = require("./types/OrientationType.enum.js");
+var _EventEmitter = _interopRequireDefault(require("./EventEmitter.js"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class RNOrientationDirector {
+  static _humanReadableOrientationsResource = {
+    [_OrientationEnum.Orientation.unknown]: 'Unknown',
+    [_OrientationEnum.Orientation.portrait]: 'Portrait',
+    [_OrientationEnum.Orientation.portraitUpsideDown]: 'Portrait Upside Down',
+    [_OrientationEnum.Orientation.landscapeLeft]: 'Landscape Left',
+    [_OrientationEnum.Orientation.landscapeRight]: 'Landscape Right',
+    [_OrientationEnum.Orientation.landscape]: 'Landscape',
+    [_OrientationEnum.Orientation.faceUp]: 'Face Up',
+    [_OrientationEnum.Orientation.faceDown]: 'Face Down'
+  };
+  static _humanReadableAutoRotationsResource = {
+    [_AutoRotationEnum.AutoRotation.unknown]: 'Unknown',
+    [_AutoRotationEnum.AutoRotation.enabled]: 'Enabled',
+    [_AutoRotationEnum.AutoRotation.disabled]: 'Disabled'
+  };
+  setHumanReadableOrientations(resource) {
+    RNOrientationDirector._humanReadableOrientationsResource = resource;
+  }
+  setHumanReadableAutoRotations(resource) {
+    RNOrientationDirector._humanReadableAutoRotationsResource = resource;
+  }
+  static getInterfaceOrientation() {
+    return _module.default.getInterfaceOrientation();
+  }
+  static getDeviceOrientation() {
+    return _module.default.getDeviceOrientation();
+  }
+
+  /**
+   * Please be aware that device orientation is not the
+   * same as interface orientation.
+   *
+   * Specifically, landscape left and right are inverted:
+   *
+   * - landscapeLeft in device orientation is landscapeRight in interface orientation
+   * - landscapeRight in device orientation is landscapeLeft in interface orientation
+   *
+   * This is a behavior of the native API.
+   *
+   * When you pass an orientation value, do provide orientationType
+   * as well if the orientation value is not an interface orientation.
+   * Example: when using listenForDeviceOrientationChanges.
+   *
+   * @param orientation any lockable orientation enum value
+   * @param orientationType any orientation type enum value
+   */
+  static lockTo(orientation, orientationType = _OrientationTypeEnum.OrientationType.interface) {
+    if (orientationType === _OrientationTypeEnum.OrientationType.interface) {
+      _module.default.lockTo(orientation);
+      return;
+    }
+    if (orientation === _OrientationEnum.Orientation.landscapeLeft) {
+      _module.default.lockTo(_OrientationEnum.Orientation.landscapeRight);
+      return;
+    }
+    if (orientation === _OrientationEnum.Orientation.landscapeRight) {
+      _module.default.lockTo(_OrientationEnum.Orientation.landscapeLeft);
+      return;
+    }
+    _module.default.lockTo(orientation);
+  }
+  static unlock() {
+    _module.default.unlock();
+  }
+  static isLocked() {
+    return _module.default.isLocked();
+  }
+  static isAutoRotationEnabled() {
+    if (_reactNative.Platform.OS !== 'android') {
+      return _AutoRotationEnum.AutoRotation.unknown;
+    }
+    return _module.default.isAutoRotationEnabled() ? _AutoRotationEnum.AutoRotation.enabled : _AutoRotationEnum.AutoRotation.disabled;
+  }
+  static resetSupportedInterfaceOrientations() {
+    _module.default.resetSupportedInterfaceOrientations();
+  }
+  static listenForDeviceOrientationChanges(callback) {
+    return _EventEmitter.default.addDeviceOrientationDidChangeListener(callback);
+  }
+  static listenForInterfaceOrientationChanges(callback) {
+    return _EventEmitter.default.addInterfaceOrientationDidChangeListener(callback);
+  }
+  static listenForLockChanges(callback) {
+    return _EventEmitter.default.addLockDidChangeListener(callback);
+  }
+  static convertOrientationToHumanReadableString(orientation) {
+    return RNOrientationDirector._humanReadableOrientationsResource[orientation];
+  }
+  static convertAutoRotationToHumanReadableString(autoRotation) {
+    return RNOrientationDirector._humanReadableAutoRotationsResource[autoRotation];
+  }
+
+  /**
+   * This method checks if the given orientation is lockable
+   * by interface perspective.
+   *
+   * All orientations are lockable except for unknown, faceUp
+   * and faceDown.
+   *
+   * This method is useful when you want to lock the interface
+   * orientation from a given device orientation.
+   *
+   * Example: with listenForDeviceOrientationChanges
+   *
+   * @param orientation any orientation enum value
+   * @returns true if the orientation is lockable
+   */
+  static isLockableOrientation(orientation) {
+    return !(orientation === _OrientationEnum.Orientation.unknown || orientation === _OrientationEnum.Orientation.faceUp || orientation === _OrientationEnum.Orientation.faceDown);
+  }
+}
+var _default = exports.default = RNOrientationDirector;

package/lib/commonjs/hooks/useDeviceOrientation.hook.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _RNOrientationDirector = _interopRequireDefault(require("../RNOrientationDirector.js"));
+var _OrientationEnum = require("../types/Orientation.enum.js");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * Hook that returns the current device orientation.
+ * It listens for orientation changes and updates the state accordingly.
+ */
+const useDeviceOrientation = () => {
+  const initialRender = (0, _react.useRef)(false);
+  const [orientation, setOrientation] = _react.default.useState(_OrientationEnum.Orientation.unknown);
+  _react.default.useEffect(() => {
+    if (initialRender.current) {
+      return;
+    }
+    initialRender.current = true;
+    _RNOrientationDirector.default.getDeviceOrientation().then(setOrientation);
+  }, []);
+  _react.default.useEffect(() => {
+    const onChange = event => {
+      setOrientation(event.orientation);
+    };
+    const subscription = _RNOrientationDirector.default.listenForDeviceOrientationChanges(onChange);
+    return () => {
+      subscription.remove();
+    };
+  }, []);
+  return orientation;
+};
+var _default = exports.default = useDeviceOrientation;

package/lib/commonjs/hooks/useInterfaceOrientation.hook.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _RNOrientationDirector = _interopRequireDefault(require("../RNOrientationDirector.js"));
+var _OrientationEnum = require("../types/Orientation.enum.js");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * Hook that returns the current interface orientation.
+ * It listens for orientation changes and updates the state accordingly.
+ */
+const useInterfaceOrientation = () => {
+  const initialRender = (0, _react.useRef)(false);
+  const [orientation, setOrientation] = _react.default.useState(_OrientationEnum.Orientation.unknown);
+  _react.default.useEffect(() => {
+    if (initialRender.current) {
+      return;
+    }
+    initialRender.current = true;
+    _RNOrientationDirector.default.getInterfaceOrientation().then(setOrientation);
+  }, []);
+  _react.default.useEffect(() => {
+    const onChange = event => {
+      setOrientation(event.orientation);
+    };
+    const subscription = _RNOrientationDirector.default.listenForInterfaceOrientationChanges(onChange);
+    return () => {
+      subscription.remove();
+    };
+  }, []);
+  return orientation;
+};
+var _default = exports.default = useInterfaceOrientation;

package/lib/commonjs/hooks/useIsInterfaceOrientationLocked.hook.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireDefault(require("react"));
+var _RNOrientationDirector = _interopRequireDefault(require("../RNOrientationDirector.js"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Hook that returns whether the interface is locked.
+ * It listens for changes and updates the state accordingly.
+ */
+const useIsInterfaceOrientationLocked = () => {
+  const [orientation, setOrientation] = _react.default.useState(() => _RNOrientationDirector.default.isLocked());
+  _react.default.useEffect(() => {
+    const onChange = event => {
+      setOrientation(event.locked);
+    };
+    const subscription = _RNOrientationDirector.default.listenForLockChanges(onChange);
+    return () => {
+      subscription.remove();
+    };
+  }, []);
+  return orientation;
+};
+var _default = exports.default = useIsInterfaceOrientationLocked;

package/lib/commonjs/index.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "AutoRotation", {
+  enumerable: true,
+  get: function () {
+    return _AutoRotationEnum.AutoRotation;
+  }
+});
+Object.defineProperty(exports, "Orientation", {
+  enumerable: true,
+  get: function () {
+    return _OrientationEnum.Orientation;
+  }
+});
+Object.defineProperty(exports, "OrientationType", {
+  enumerable: true,
+  get: function () {
+    return _OrientationTypeEnum.OrientationType;
+  }
+});
+exports.default = void 0;
+Object.defineProperty(exports, "useDeviceOrientation", {
+  enumerable: true,
+  get: function () {
+    return _useDeviceOrientationHook.default;
+  }
+});
+Object.defineProperty(exports, "useInterfaceOrientation", {
+  enumerable: true,
+  get: function () {
+    return _useInterfaceOrientationHook.default;
+  }
+});
+Object.defineProperty(exports, "useIsInterfaceOrientationLocked", {
+  enumerable: true,
+  get: function () {
+    return _useIsInterfaceOrientationLockedHook.default;
+  }
+});
+var _OrientationEnum = require("./types/Orientation.enum.js");
+var _AutoRotationEnum = require("./types/AutoRotation.enum.js");
+var _OrientationTypeEnum = require("./types/OrientationType.enum.js");
+var _useDeviceOrientationHook = _interopRequireDefault(require("./hooks/useDeviceOrientation.hook.js"));
+var _useInterfaceOrientationHook = _interopRequireDefault(require("./hooks/useInterfaceOrientation.hook.js"));
+var _useIsInterfaceOrientationLockedHook = _interopRequireDefault(require("./hooks/useIsInterfaceOrientationLocked.hook.js"));
+var _RNOrientationDirector = _interopRequireDefault(require("./RNOrientationDirector.js"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+var _default = exports.default = _RNOrientationDirector.default;

package/lib/commonjs/module.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.ModuleEventEmitter = void 0;
+var _reactNative = require("react-native");
+const LINKING_ERROR = `The package 'react-native-orientation-director' doesn't seem to be linked. Make sure: \n\n` + _reactNative.Platform.select({
+  ios: "- You have run 'pod install'\n",
+  default: ''
+}) + '- You rebuilt the app after installing the package\n' + '- You are not using Expo Go\n';
+
+// @ts-expect-error
+const isTurboModuleEnabled = global.__turboModuleProxy != null;
+const Module = isTurboModuleEnabled ? require('./NativeOrientationDirector').default : _reactNative.NativeModules.OrientationDirector;
+const OrientationDirectorModule = Module ? Module : new Proxy({}, {
+  get() {
+    throw new Error(LINKING_ERROR);
+  }
+});
+const ModuleEventEmitter = exports.ModuleEventEmitter = new _reactNative.NativeEventEmitter(Module);
+var _default = exports.default = OrientationDirectorModule;

package/lib/commonjs/package.json

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

package/lib/commonjs/types/AutoRotation.enum.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AutoRotation = void 0;
+let AutoRotation = exports.AutoRotation = /*#__PURE__*/function (AutoRotation) {
+  AutoRotation[AutoRotation["unknown"] = 0] = "unknown";
+  AutoRotation[AutoRotation["enabled"] = 1] = "enabled";
+  AutoRotation[AutoRotation["disabled"] = 2] = "disabled";
+  return AutoRotation;
+}({});

package/lib/commonjs/types/Event.enum.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var Event = /*#__PURE__*/function (Event) {
+  Event["DeviceOrientationDidChange"] = "DeviceOrientationDidChange";
+  Event["InterfaceOrientationDidChange"] = "InterfaceOrientationDidChange";
+  Event["LockDidChange"] = "LockDidChange";
+  return Event;
+}(Event || {});
+var _default = exports.default = Event;

package/lib/commonjs/types/HumanReadableAutoRotationsResource.type.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/lib/commonjs/types/HumanReadableOrientationsResource.type.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});