react-native-orientation-director 1.0.1 → 1.1.0

package/README.md

@@ -1,14 +1,25 @@
+![NPM Version](https://img.shields.io/npm/v/react-native-orientation-director)
+
+---
+
 # react-native-orientation-director
 
 A simple library that allows you to handle orientation changes in your React Native app.
 Written in Kotlin, Swift and Typescript. It supports both the Old and New React Native architecture.
 
+This library takes inspiration from and builds upon the following amazing alternatives:
+
+1. [react-native-orientation-locker](https://github.com/wonday/react-native-orientation-locker)
+2. [react-native-orientation-handler](https://github.com/KroosX4V/react-native-orientation-manager)
+
 ## Features
 
 - [x] Get the current orientation of the device
 - [x] Get the current orientation of the interface
+- [x] Get the current interface orientation status (locked or unlocked)
 - [x] Listen to device orientation changes
 - [x] Listen to interface orientation changes
+- [x] Listen to interface orientation status changes
 - [x] Lock the interface orientation to a specific orientation
 - [x] Unlock the interface orientation
 
@@ -23,7 +34,7 @@ npm install react-native-orientation-director
 yarn add react-native-orientation-director
 ```
 
-Don't forget to run pod-install
+Don't forget to run pod-install.
 
 ## Setup
 
@@ -53,17 +64,20 @@ This library exports a class called: [RNOrientationDirector](https://github.com/
 | getDeviceOrientation                    | Returns the last device orientation                                             |
 | lockTo                                  | Locks the interface to a specific orientation                                   |
 | unlock                                  | Unlock the interface                                                            |
+| isLocked                                | Returns the current interface orientation status (locked / unlocked)            |
 | listenForDeviceOrientationChanges       | Triggers a provided callback each time the device orientation changes           |
 | listenForInterfaceOrientationChanges    | Triggers a provided callback each time the interface orientation changes        |
+| listenForLockChanges                    | Triggers a provided callback each time the interface orientation status changes |
 | convertOrientationToHumanReadableString | Returns a human readable string based on the given orientation                  |
 | setLocalizedStringProvider              | Sets the mapping needed to convert orientation values to human readable strings |
 
 In addition, the library exposes the following hooks:
 
-| Hook                                                                                                                                            | Description                                                      |
-|-------------------------------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------|
-| [useInterfaceOrientation](https://github.com/gladiuscode/react-native-orientation-director/blob/main/src/hooks/useInterfaceOrientation.hook.ts) | Returns the current interface orientation and listens to changes |
-| [useDeviceOrientation](https://github.com/gladiuscode/react-native-orientation-director/blob/main/src/hooks/useDeviceOrientation.hook.ts)       | Returns the current device orientation and listens to changes    |
+| Hook                                                                                                                                                            | Description                                                             |
+|-----------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------|
+| [useInterfaceOrientation](https://github.com/gladiuscode/react-native-orientation-director/blob/main/src/hooks/useInterfaceOrientation.hook.ts)                 | Returns the current interface orientation and listens to changes        |
+| [useDeviceOrientation](https://github.com/gladiuscode/react-native-orientation-director/blob/main/src/hooks/useDeviceOrientation.hook.ts)                       | Returns the current device orientation and listens to changes           |
+| [useIsInterfaceOrientationLocked](https://github.com/gladiuscode/react-native-orientation-director/blob/main/src/hooks/useIsInterfaceOrientationLocked.hook.ts) | Returns the current interface orientation status and listens to changes |
 
 Head over to the [example project](example) to see how to use the library.
 
@@ -78,10 +92,6 @@ Head over to the [example project](example) to see how to use the library.
 
 See the [contributing guide](CONTRIBUTING.md) to learn how to contribute to the repository and the development workflow.
 
-## License
-
-MIT
-
 ---
 
 Made with [create-react-native-library](https://github.com/callstack/react-native-builder-bob)

package/android/src/main/java/com/orientationdirector/OrientationDirectorModule.kt

@@ -38,6 +38,11 @@ class OrientationDirectorModule internal constructor(context: ReactApplicationCo
     orientationDirectorImpl.unlock()
   }
 
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  override fun isLocked(): Boolean {
+    return orientationDirectorImpl.isLocked
+  }
+
   @ReactMethod()
   override fun addListener(eventName: String) {}
 

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

@@ -4,15 +4,18 @@ import android.content.pm.ActivityInfo
 import com.facebook.react.bridge.ReactApplicationContext
 
 class OrientationDirectorImpl internal constructor(private val context: ReactApplicationContext) {
-  private var mUtils = OrientationDirectorUtilsImpl()
+  private var mUtils = OrientationDirectorUtilsImpl(context)
   private var mEventEmitter = OrientationEventManager(context)
   private var mSensorListener = OrientationSensorListener(context)
   private var mLifecycleListener = OrientationLifecycleListener()
-  private var isLocked: Boolean = false
+
+  private var initialSupportedInterfaceOrientations = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED
   private var lastInterfaceOrientation = Orientation.UNKNOWN
   private var lastDeviceOrientation = Orientation.UNKNOWN
   private var initialized = false
 
+  var isLocked: Boolean = false
+
   init {
     mSensorListener.setOnOrientationChangedCallback { orientation ->
       onOrientationChanged(orientation)
@@ -39,8 +42,11 @@ class OrientationDirectorImpl internal constructor(private val context: ReactApp
       mSensorListener.disable()
     }
 
+    initialSupportedInterfaceOrientations =
+      context.currentActivity?.requestedOrientation ?: initialSupportedInterfaceOrientations
     lastInterfaceOrientation = initInterfaceOrientation()
     lastDeviceOrientation = initDeviceOrientation()
+    isLocked = initIsLocked()
 
     initialized = true
   }
@@ -54,34 +60,24 @@ class OrientationDirectorImpl internal constructor(private val context: ReactApp
   }
 
   fun lockTo(jsOrientation: Int) {
-    val interfaceOrientation = mUtils.getOrientationEnumFrom(jsOrientation)
+    val interfaceOrientation = mUtils.getOrientationFromJsOrientation(jsOrientation)
     val screenOrientation =
       mUtils.getActivityOrientationFrom(interfaceOrientation)
     context.currentActivity?.requestedOrientation = screenOrientation
     mEventEmitter.sendInterfaceOrientationDidChange(interfaceOrientation.ordinal)
     lastInterfaceOrientation = interfaceOrientation
-    isLocked = true
+    updateIsLockedTo(true)
   }
 
   fun unlock() {
     context.currentActivity?.requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED
-    isLocked = false
+    updateIsLockedTo(false)
     adaptInterfaceTo(getDeviceOrientation())
   }
 
   private fun initInterfaceOrientation(): Orientation {
-    val activityOrientation = context.currentActivity!!.requestedOrientation
-    if (
-      mUtils.isActivityInPortraitOrientation(activityOrientation) ||
-      mUtils.isActivityInLandscapeOrientation(activityOrientation)
-    ) {
-      return mUtils.getInterfaceOrientationFrom(activityOrientation)
-    }
-
-    val lastRotationDetected = mSensorListener.getLastRotationDetected()
-      ?: return lastInterfaceOrientation
-
-    return mUtils.getDeviceOrientationFrom(lastRotationDetected)
+    val rotation = mUtils.getInterfaceRotation()
+    return mUtils.getOrientationFromRotation(rotation)
   }
 
   private fun initDeviceOrientation(): Orientation {
@@ -91,6 +87,17 @@ class OrientationDirectorImpl internal constructor(private val context: ReactApp
     return mUtils.getDeviceOrientationFrom(lastRotationDetected)
   }
 
+  private fun initIsLocked(): Boolean {
+    val activity = context.currentActivity ?: return false
+    return listOf(
+      ActivityInfo.SCREEN_ORIENTATION_PORTRAIT,
+      ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE,
+      ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT,
+      ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE,
+      ActivityInfo.SCREEN_ORIENTATION_LOCKED,
+    ).contains(activity.requestedOrientation)
+  }
+
   private fun onOrientationChanged(rawDeviceOrientation: Int) {
     val deviceOrientation = mUtils.getDeviceOrientationFrom(rawDeviceOrientation)
     mEventEmitter.sendDeviceOrientationDidChange(deviceOrientation.ordinal)
@@ -111,6 +118,11 @@ class OrientationDirectorImpl internal constructor(private val context: ReactApp
     mEventEmitter.sendInterfaceOrientationDidChange(lastInterfaceOrientation.ordinal)
   }
 
+  private fun updateIsLockedTo(value: Boolean) {
+    mEventEmitter.sendLockDidChange(value)
+    isLocked = value
+  }
+
   companion object {
     const val NAME = "OrientationDirectorImpl"
   }

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

@@ -1,8 +1,23 @@
 package com.orientationdirector.implementation
 
+import android.content.Context
 import android.content.pm.ActivityInfo
+import android.os.Build
+import android.view.Surface
+import android.view.WindowManager
+import com.facebook.react.bridge.ReactContext
 
-class OrientationDirectorUtilsImpl() {
+class OrientationDirectorUtilsImpl(val context: ReactContext) {
+
+  fun getInterfaceRotation(): Int {
+    return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+      context.currentActivity?.display?.rotation ?: Surface.ROTATION_0
+    } else {
+      val windowManager = context.getSystemService(Context.WINDOW_SERVICE) as WindowManager
+      @Suppress("DEPRECATION")
+      windowManager.defaultDisplay.rotation
+    }
+  }
 
   fun getDeviceOrientationFrom(rotation: Int): Orientation {
     var orientation = Orientation.UNKNOWN
@@ -22,29 +37,6 @@ class OrientationDirectorUtilsImpl() {
     return orientation
   }
 
-  fun getInterfaceOrientationFrom(activityInfo: Int): Orientation {
-    return when (activityInfo) {
-      ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE -> Orientation.LANDSCAPE_RIGHT
-      ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT -> Orientation.PORTRAIT_UPSIDE_DOWN
-      ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE -> Orientation.LANDSCAPE_LEFT
-      else -> Orientation.PORTRAIT
-    };
-  }
-
-  fun isActivityInLandscapeOrientation(orientation: Int): Boolean {
-    return listOf(
-      ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE,
-      ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE,
-    ).contains(orientation);
-  }
-
-  fun isActivityInPortraitOrientation(orientation: Int): Boolean {
-    return listOf(
-      ActivityInfo.SCREEN_ORIENTATION_PORTRAIT,
-      ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT,
-    ).contains(orientation);
-  }
-
   fun getActivityOrientationFrom(interfaceOrientation: Orientation): Int {
     return when (interfaceOrientation) {
       Orientation.LANDSCAPE_RIGHT -> ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE
@@ -54,7 +46,7 @@ class OrientationDirectorUtilsImpl() {
     }
   }
 
-  fun getOrientationEnumFrom(jsOrientation: Int): Orientation {
+  fun getOrientationFromJsOrientation(jsOrientation: Int): Orientation {
     return when (jsOrientation) {
       2 -> Orientation.LANDSCAPE_RIGHT
       3 -> Orientation.PORTRAIT_UPSIDE_DOWN
@@ -62,4 +54,13 @@ class OrientationDirectorUtilsImpl() {
       else -> Orientation.PORTRAIT
     }
   }
+
+  fun getOrientationFromRotation(rotation: Int): Orientation {
+    return when(rotation) {
+      Surface.ROTATION_270 -> Orientation.LANDSCAPE_RIGHT
+      Surface.ROTATION_90 -> Orientation.LANDSCAPE_LEFT
+      Surface.ROTATION_180 -> Orientation.PORTRAIT_UPSIDE_DOWN
+      else -> Orientation.PORTRAIT
+    }
+  }
 }

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

@@ -9,6 +9,7 @@ import com.facebook.react.modules.core.DeviceEventManagerModule
 enum class Event {
   DeviceOrientationDidChange,
   InterfaceOrientationDidChange,
+  LockDidChange,
 }
 
 class OrientationEventManager(private val context: ReactApplicationContext) {
@@ -27,6 +28,13 @@ class OrientationEventManager(private val context: ReactApplicationContext) {
     sendEvent(Event.InterfaceOrientationDidChange, params)
   }
 
+  fun sendLockDidChange(value: Boolean) {
+    val params = Arguments.createMap().apply {
+      putBoolean("locked", value)
+    }
+    sendEvent(Event.LockDidChange, params)
+  }
+
   private fun sendEvent(eventName: Event, params: WritableMap?) {
     Log.d(NAME, "sendEvent - $eventName")
     Log.d(NAME, "sendEvent - $params")

package/android/src/oldarch/OrientationDirectorSpec.kt

@@ -6,11 +6,12 @@ import com.facebook.react.bridge.Promise
 
 abstract class OrientationDirectorSpec internal constructor(context: ReactApplicationContext) :
   ReactContextBaseJavaModule(context) {
-
   abstract fun getInterfaceOrientation(promise: Promise)
   abstract fun getDeviceOrientation(promise: Promise)
   abstract fun lockTo(orientation: Double)
   abstract fun unlock()
+
+  abstract fun isLocked(): Boolean
   abstract fun addListener(eventName: String)
   abstract fun removeListeners(count: Double)
 }

package/ios/OrientationDirector.mm

@@ -64,7 +64,7 @@ RCT_EXPORT_MODULE()
 
 + (UIInterfaceOrientationMask)getSupportedInterfaceOrientationsForWindow
 {
-    return [_director supportedInterfaceOrientation];
+    return [_director supportedInterfaceOrientations];
 }
 
 #ifdef RCT_NEW_ARCH_ENABLED
@@ -114,6 +114,15 @@ RCT_EXPORT_METHOD(unlock)
     });
 }
 
+#ifdef RCT_NEW_ARCH_ENABLED
+- (NSNumber *)isLocked
+#else
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(isLocked)
+#endif
+{
+    return @([_director isLocked]);
+}
+
 // Don't compile this code when we build for the old architecture.
 #ifdef RCT_NEW_ARCH_ENABLED
 - (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:

package/ios/implementation/OrientationDirectorImpl.swift

@@ -12,19 +12,24 @@ import UIKit
     private static let TAG = "OrientationDirectorImpl"
     private let sensorListener: OrientationSensorListener
     private let eventManager: OrientationEventManager
-    private var isLocked: Bool = false
-    private var lastInterfaceOrientation: Orientation = Orientation.UNKNOWN
-    private var lastDeviceOrientation: Orientation = Orientation.UNKNOWN
+    private var initialSupportedInterfaceOrientations: UIInterfaceOrientationMask = UIInterfaceOrientationMask.all
+    private var lastInterfaceOrientation = Orientation.UNKNOWN
+    private var lastDeviceOrientation = Orientation.UNKNOWN
 
-    @objc public var supportedInterfaceOrientation: UIInterfaceOrientationMask = UIInterfaceOrientationMask.all
+    @objc public var supportedInterfaceOrientations: UIInterfaceOrientationMask = UIInterfaceOrientationMask.all
+    @objc public var isLocked = false
 
     @objc public override init() {
         eventManager = OrientationEventManager()
         sensorListener = OrientationSensorListener()
         super.init()
         sensorListener.setOnOrientationChanged(callback: self.onOrientationChanged)
+        initialSupportedInterfaceOrientations = initInitialSupportedInterfaceOrientations()
         lastInterfaceOrientation = initInterfaceOrientation()
         lastDeviceOrientation = initDeviceOrientation()
+        isLocked = initIsLocked()
+
+        supportedInterfaceOrientations = initialSupportedInterfaceOrientations
     }
 
     ///////////////////////////////////////////////////////////////////////////////////////
@@ -51,17 +56,22 @@ import UIKit
 
         eventManager.sendInterfaceOrientationDidChange(orientationValue: orientation.rawValue)
         lastInterfaceOrientation = orientation
-        isLocked = true
+        updateIsLockedTo(value: true)
     }
 
     @objc public func unlock() {
         self.requestInterfaceUpdateTo(mask: UIInterfaceOrientationMask.all)
 
         let deviceOrientation = OrientationDirectorUtils.getOrientationFrom(deviceOrientation: UIDevice.current.orientation)
-        isLocked = false
+        updateIsLockedTo(value: false)
         self.adaptInterfaceTo(deviceOrientation: deviceOrientation)
     }
 
+    private func initInitialSupportedInterfaceOrientations() -> UIInterfaceOrientationMask {
+        let supportedInterfaceOrientations = OrientationDirectorUtils.readSupportedInterfaceOrientationsFromBundle()
+        return supportedInterfaceOrientations.reduce(UIInterfaceOrientationMask()) { $0.union($1) }
+    }
+
     private func initInterfaceOrientation() -> Orientation {
         let interfaceOrientation = OrientationDirectorUtils.getInterfaceOrientation()
         return OrientationDirectorUtils.getOrientationFrom(uiInterfaceOrientation: interfaceOrientation)
@@ -71,8 +81,17 @@ import UIKit
         return OrientationDirectorUtils.getOrientationFrom(deviceOrientation: UIDevice.current.orientation)
     }
 
+    private func initIsLocked() -> Bool {
+        let supportedOrientations = OrientationDirectorUtils.readSupportedInterfaceOrientationsFromBundle()
+        if (supportedOrientations.count > 1) {
+            return false
+        }
+
+        return supportedOrientations.first != UIInterfaceOrientationMask.all
+    }
+
     private func requestInterfaceUpdateTo(mask: UIInterfaceOrientationMask) {
-        self.supportedInterfaceOrientation = mask
+        self.supportedInterfaceOrientations = mask
 
         DispatchQueue.main.async {
             if #available(iOS 16.0, *) {
@@ -122,5 +141,10 @@ import UIKit
 
         self.eventManager.sendInterfaceOrientationDidChange(orientationValue: deviceOrientation.rawValue)
         lastInterfaceOrientation = deviceOrientation
-      }
+    }
+
+    private func updateIsLockedTo(value: Bool) {
+        eventManager.sendLockDidChange(value: value)
+        isLocked = value
+    }
 }

package/ios/implementation/OrientationDirectorUtils.swift

@@ -107,5 +107,26 @@ class OrientationDirectorUtils {
             .flatMap { $0.windows }
             .last { $0.isKeyWindow }
     }
+    
+    public static func readSupportedInterfaceOrientationsFromBundle() -> [UIInterfaceOrientationMask] {
+        guard let rawOrientations = Bundle.main.object(forInfoDictionaryKey: "UISupportedInterfaceOrientations") as? [String] else {
+            return [UIInterfaceOrientationMask.all]
+        }
+        
+        return rawOrientations.compactMap { orientation in
+            switch orientation {
+            case "UIInterfaceOrientationPortrait":
+                return UIInterfaceOrientationMask.portrait
+            case "UIInterfaceOrientationLandscapeLeft":
+                return UIInterfaceOrientationMask.landscapeLeft
+            case "UIInterfaceOrientationLandscapeRight":
+                return UIInterfaceOrientationMask.landscapeRight
+            case "UIInterfaceOrientationPortraitUpsideDown":
+                return UIInterfaceOrientationMask.portraitUpsideDown
+            default:
+                return UIInterfaceOrientationMask.allButUpsideDown
+            }
+        }
+    }
 
 }

package/ios/implementation/OrientationEventManager.swift

@@ -35,6 +35,19 @@ import Foundation
         let params = Dictionary(dictionaryLiteral: ("orientation", orientationValue))
         delegate.sendEvent(name: Event.InterfaceOrientationDidChange.rawValue, params: params as NSDictionary)
     }
+    
+    func sendLockDidChange(value: Bool) {
+        guard let delegate = delegate else {
+            return
+        }
+
+        if (!delegate.isJsListening) {
+            return
+        }
+
+        let params = Dictionary(dictionaryLiteral: ("locked", value))
+        delegate.sendEvent(name: Event.LockDidChange.rawValue, params: params as NSDictionary)
+    }
 }
 
 @objc public protocol OrientationEventEmitterDelegate {
@@ -48,6 +61,7 @@ public extension OrientationEventManager {
   enum Event: String, CaseIterable {
     case DeviceOrientationDidChange
     case InterfaceOrientationDidChange
+    case LockDidChange
   }
 
   @objc static var supportedEvents: [String] {

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,GAYpCC,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,GAapCC,gCAAmB,CAACC,YAAY,CAAO,qBAAqB,CAAC","ignoreList":[]}

package/lib/commonjs/RNOrientationDirector.js

@@ -35,12 +35,18 @@ class RNOrientationDirector {
   static unlock() {
     _module.default.unlock();
   }
+  static isLocked() {
+    return _module.default.isLocked();
+  }
   static listenForDeviceOrientationChanges(callback) {
     return _module.EventEmitter.addListener(_Event.default.DeviceOrientationDidChange, callback);
   }
   static listenForInterfaceOrientationChanges(callback) {
     return _module.EventEmitter.addListener(_Event.default.InterfaceOrientationDidChange, callback);
   }
+  static listenForLockChanges(callback) {
+    return _module.EventEmitter.addListener(_Event.default.LockDidChange, callback);
+  }
   static convertOrientationToHumanReadableString(orientation) {
     return RNOrientationDirector._localizedStringProvider[orientation];
   }

package/lib/commonjs/RNOrientationDirector.js.map

@@ -1 +1 @@
-{"version":3,"names":["_module","_interopRequireWildcard","require","_Event","_interopRequireDefault","_Orientation","obj","__esModule","default","_getRequireWildcardCache","e","WeakMap","r","t","has","get","n","__proto__","a","Object","defineProperty","getOwnPropertyDescriptor","u","hasOwnProperty","call","i","set","RNOrientationDirector","_localizedStringProvider","Orientation","unknown","portrait","portraitUpsideDown","landscapeLeft","landscapeRight","faceUp","faceDown","setLocalizedStringProvider","provider","getInterfaceOrientation","Module","getDeviceOrientation","lockTo","orientation","unlock","listenForDeviceOrientationChanges","callback","EventEmitter","addListener","Event","DeviceOrientationDidChange","listenForInterfaceOrientationChanges","InterfaceOrientationDidChange","convertOrientationToHumanReadableString","_default","exports"],"sourceRoot":"../../src","sources":["RNOrientationDirector.ts"],"mappings":"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","ignoreList":[]}
+{"version":3,"names":["_module","_interopRequireWildcard","require","_Event","_interopRequireDefault","_Orientation","obj","__esModule","default","_getRequireWildcardCache","e","WeakMap","r","t","has","get","n","__proto__","a","Object","defineProperty","getOwnPropertyDescriptor","u","hasOwnProperty","call","i","set","RNOrientationDirector","_localizedStringProvider","Orientation","unknown","portrait","portraitUpsideDown","landscapeLeft","landscapeRight","faceUp","faceDown","setLocalizedStringProvider","provider","getInterfaceOrientation","Module","getDeviceOrientation","lockTo","orientation","unlock","isLocked","listenForDeviceOrientationChanges","callback","EventEmitter","addListener","Event","DeviceOrientationDidChange","listenForInterfaceOrientationChanges","InterfaceOrientationDidChange","listenForLockChanges","LockDidChange","convertOrientationToHumanReadableString","_default","exports"],"sourceRoot":"../../src","sources":["RNOrientationDirector.ts"],"mappings":";;;;;;AAAA,IAAAA,OAAA,GAAAC,uBAAA,CAAAC,OAAA;AACA,IAAAC,MAAA,GAAAC,sBAAA,CAAAF,OAAA;AAEA,IAAAG,YAAA,GAAAH,OAAA;AAAuD,SAAAE,uBAAAE,GAAA,WAAAA,GAAA,IAAAA,GAAA,CAAAC,UAAA,GAAAD,GAAA,KAAAE,OAAA,EAAAF,GAAA;AAAA,SAAAG,yBAAAC,CAAA,6BAAAC,OAAA,mBAAAC,CAAA,OAAAD,OAAA,IAAAE,CAAA,OAAAF,OAAA,YAAAF,wBAAA,YAAAA,CAAAC,CAAA,WAAAA,CAAA,GAAAG,CAAA,GAAAD,CAAA,KAAAF,CAAA;AAAA,SAAAT,wBAAAS,CAAA,EAAAE,CAAA,SAAAA,CAAA,IAAAF,CAAA,IAAAA,CAAA,CAAAH,UAAA,SAAAG,CAAA,eAAAA,CAAA,uBAAAA,CAAA,yBAAAA,CAAA,WAAAF,OAAA,EAAAE,CAAA,QAAAG,CAAA,GAAAJ,wBAAA,CAAAG,CAAA,OAAAC,CAAA,IAAAA,CAAA,CAAAC,GAAA,CAAAJ,CAAA,UAAAG,CAAA,CAAAE,GAAA,CAAAL,CAAA,OAAAM,CAAA,KAAAC,SAAA,UAAAC,CAAA,GAAAC,MAAA,CAAAC,cAAA,IAAAD,MAAA,CAAAE,wBAAA,WAAAC,CAAA,IAAAZ,CAAA,oBAAAY,CAAA,OAAAC,cAAA,CAAAC,IAAA,CAAAd,CAAA,EAAAY,CAAA,SAAAG,CAAA,GAAAP,CAAA,GAAAC,MAAA,CAAAE,wBAAA,CAAAX,CAAA,EAAAY,CAAA,UAAAG,CAAA,KAAAA,CAAA,CAAAV,GAAA,IAAAU,CAAA,CAAAC,GAAA,IAAAP,MAAA,CAAAC,cAAA,CAAAJ,CAAA,EAAAM,CAAA,EAAAG,CAAA,IAAAT,CAAA,CAAAM,CAAA,IAAAZ,CAAA,CAAAY,CAAA,YAAAN,CAAA,CAAAR,OAAA,GAAAE,CAAA,EAAAG,CAAA,IAAAA,CAAA,CAAAa,GAAA,CAAAhB,CAAA,EAAAM,CAAA,GAAAA,CAAA;AAKvD,MAAMW,qBAAqB,CAAC;EAC1B,OAAeC,wBAAwB,GACrC;IACE,CAACC,wBAAW,CAACC,OAAO,GAAG,SAAS;IAChC,CAACD,wBAAW,CAACE,QAAQ,GAAG,UAAU;IAClC,CAACF,wBAAW,CAACG,kBAAkB,GAAG,sBAAsB;IACxD,CAACH,wBAAW,CAACI,aAAa,GAAG,gBAAgB;IAC7C,CAACJ,wBAAW,CAACK,cAAc,GAAG,iBAAiB;IAC/C,CAACL,wBAAW,CAACM,MAAM,GAAG,SAAS;IAC/B,CAACN,wBAAW,CAACO,QAAQ,GAAG;EAC1B,CAAC;EAEHC,0BAA0BA,CACxBC,QAAuD,EACvD;IACAX,qBAAqB,CAACC,wBAAwB,GAAGU,QAAQ;EAC3D;EAEA,OAAOC,uBAAuBA,CAAA,EAAyB;IACrD,OAAOC,eAAM,CAACD,uBAAuB,CAAC,CAAC;EACzC;EAEA,OAAOE,oBAAoBA,CAAA,EAAyB;IAClD,OAAOD,eAAM,CAACC,oBAAoB,CAAC,CAAC;EACtC;EAEA,OAAOC,MAAMA,CAACC,WAAgC,EAAE;IAC9CH,eAAM,CAACE,MAAM,CAACC,WAAW,CAAC;EAC5B;EAEA,OAAOC,MAAMA,CAAA,EAAG;IACdJ,eAAM,CAACI,MAAM,CAAC,CAAC;EACjB;EAEA,OAAOC,QAAQA,CAAA,EAAG;IAChB,OAAOL,eAAM,CAACK,QAAQ,CAAC,CAAC;EAC1B;EAEA,OAAOC,iCAAiCA,CACtCC,QAAiD,EACjD;IACA,OAAOC,oBAAY,CAACC,WAAW,CAACC,cAAK,CAACC,0BAA0B,EAAEJ,QAAQ,CAAC;EAC7E;EAEA,OAAOK,oCAAoCA,CACzCL,QAAiD,EACjD;IACA,OAAOC,oBAAY,CAACC,WAAW,CAC7BC,cAAK,CAACG,6BAA6B,EACnCN,QACF,CAAC;EACH;EAEA,OAAOO,oBAAoBA,CAACP,QAA4C,EAAE;IACxE,OAAOC,oBAAY,CAACC,WAAW,CAACC,cAAK,CAACK,aAAa,EAAER,QAAQ,CAAC;EAChE;EAEA,OAAOS,uCAAuCA,CAC5Cb,WAAwB,EAChB;IACR,OAAOhB,qBAAqB,CAACC,wBAAwB,CAACe,WAAW,CAAC;EACpE;AACF;AAAC,IAAAc,QAAA,GAAAC,OAAA,CAAAlD,OAAA,GAEcmB,qBAAqB","ignoreList":[]}

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

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireDefault(require("react"));
+var _RNOrientationDirector = _interopRequireDefault(require("../RNOrientationDirector"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * 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;
+//# sourceMappingURL=useIsInterfaceOrientationLocked.hook.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["_react","_interopRequireDefault","require","_RNOrientationDirector","obj","__esModule","default","useIsInterfaceOrientationLocked","orientation","setOrientation","React","useState","RNOrientationDirector","isLocked","useEffect","onChange","event","locked","subscription","listenForLockChanges","remove","_default","exports"],"sourceRoot":"../../../src","sources":["hooks/useIsInterfaceOrientationLocked.hook.ts"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,sBAAA,CAAAC,OAAA;AACA,IAAAC,sBAAA,GAAAF,sBAAA,CAAAC,OAAA;AAA6D,SAAAD,uBAAAG,GAAA,WAAAA,GAAA,IAAAA,GAAA,CAAAC,UAAA,GAAAD,GAAA,KAAAE,OAAA,EAAAF,GAAA;AAG7D;AACA;AACA;AACA;AACA,MAAMG,+BAA+B,GAAGA,CAAA,KAAM;EAC5C,MAAM,CAACC,WAAW,EAAEC,cAAc,CAAC,GAAGC,cAAK,CAACC,QAAQ,CAAU,MAC5DC,8BAAqB,CAACC,QAAQ,CAAC,CACjC,CAAC;EAEDH,cAAK,CAACI,SAAS,CAAC,MAAM;IACpB,MAAMC,QAAQ,GAAIC,KAAkB,IAAK;MACvCP,cAAc,CAACO,KAAK,CAACC,MAAM,CAAC;IAC9B,CAAC;IAED,MAAMC,YAAY,GAAGN,8BAAqB,CAACO,oBAAoB,CAACJ,QAAQ,CAAC;IACzE,OAAO,MAAM;MACXG,YAAY,CAACE,MAAM,CAAC,CAAC;IACvB,CAAC;EACH,CAAC,EAAE,EAAE,CAAC;EAEN,OAAOZ,WAAW;AACpB,CAAC;AAAC,IAAAa,QAAA,GAAAC,OAAA,CAAAhB,OAAA,GAEaC,+BAA+B","ignoreList":[]}

package/lib/commonjs/index.js

@@ -22,9 +22,16 @@ Object.defineProperty(exports, "useInterfaceOrientation", {
     return _useInterfaceOrientation.default;
   }
 });
+Object.defineProperty(exports, "useIsInterfaceOrientationLocked", {
+  enumerable: true,
+  get: function () {
+    return _useIsInterfaceOrientationLocked.default;
+  }
+});
 var _Orientation = require("./types/Orientation.enum");
 var _useDeviceOrientation = _interopRequireDefault(require("./hooks/useDeviceOrientation.hook"));
 var _useInterfaceOrientation = _interopRequireDefault(require("./hooks/useInterfaceOrientation.hook"));
+var _useIsInterfaceOrientationLocked = _interopRequireDefault(require("./hooks/useIsInterfaceOrientationLocked.hook"));
 var _RNOrientationDirector = _interopRequireDefault(require("./RNOrientationDirector"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 var _default = exports.default = _RNOrientationDirector.default;

package/lib/commonjs/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["_Orientation","require","_useDeviceOrientation","_interopRequireDefault","_useInterfaceOrientation","_RNOrientationDirector","obj","__esModule","default","_default","exports","RNOrientationDirector"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,YAAA,GAAAC,OAAA;AAEA,IAAAC,qBAAA,GAAAC,sBAAA,CAAAF,OAAA;AAGA,IAAAG,wBAAA,GAAAD,sBAAA,CAAAF,OAAA;AAGA,IAAAI,sBAAA,GAAAF,sBAAA,CAAAF,OAAA;AAA4D,SAAAE,uBAAAG,GAAA,WAAAA,GAAA,IAAAA,GAAA,CAAAC,UAAA,GAAAD,GAAA,KAAAE,OAAA,EAAAF,GAAA;AAAA,IAAAG,QAAA,GAAAC,OAAA,CAAAF,OAAA,GAC7CG,8BAAqB","ignoreList":[]}
+{"version":3,"names":["_Orientation","require","_useDeviceOrientation","_interopRequireDefault","_useInterfaceOrientation","_useIsInterfaceOrientationLocked","_RNOrientationDirector","obj","__esModule","default","_default","exports","RNOrientationDirector"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,YAAA,GAAAC,OAAA;AAEA,IAAAC,qBAAA,GAAAC,sBAAA,CAAAF,OAAA;AAGA,IAAAG,wBAAA,GAAAD,sBAAA,CAAAF,OAAA;AAGA,IAAAI,gCAAA,GAAAF,sBAAA,CAAAF,OAAA;AAGA,IAAAK,sBAAA,GAAAH,sBAAA,CAAAF,OAAA;AAA4D,SAAAE,uBAAAI,GAAA,WAAAA,GAAA,IAAAA,GAAA,CAAAC,UAAA,GAAAD,GAAA,KAAAE,OAAA,EAAAF,GAAA;AAAA,IAAAG,QAAA,GAAAC,OAAA,CAAAF,OAAA,GAC7CG,8BAAqB","ignoreList":[]}

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

@@ -7,6 +7,7 @@ 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/Event.enum.js.map

@@ -1 +1 @@
-{"version":3,"names":["Event","_default","exports","default"],"sourceRoot":"../../../src","sources":["types/Event.enum.ts"],"mappings":";;;;;;IAAKA,KAAK,0BAALA,KAAK;EAALA,KAAK;EAALA,KAAK;EAAA,OAALA,KAAK;AAAA,EAALA,KAAK;AAAA,IAAAC,QAAA,GAAAC,OAAA,CAAAC,OAAA,GAKKH,KAAK","ignoreList":[]}
+{"version":3,"names":["Event","_default","exports","default"],"sourceRoot":"../../../src","sources":["types/Event.enum.ts"],"mappings":";;;;;;IAAKA,KAAK,0BAALA,KAAK;EAALA,KAAK;EAALA,KAAK;EAALA,KAAK;EAAA,OAALA,KAAK;AAAA,EAALA,KAAK;AAAA,IAAAC,QAAA,GAAAC,OAAA,CAAAC,OAAA,GAMKH,KAAK","ignoreList":[]}

package/lib/commonjs/types/LockedEvent.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=LockedEvent.interface.js.map

package/lib/commonjs/types/LockedEvent.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["types/LockedEvent.interface.ts"],"mappings":"","ignoreList":[]}

package/lib/module/NativeOrientationDirector.js.map

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

package/lib/module/RNOrientationDirector.js

@@ -26,12 +26,18 @@ class RNOrientationDirector {
   static unlock() {
     Module.unlock();
   }
+  static isLocked() {
+    return Module.isLocked();
+  }
   static listenForDeviceOrientationChanges(callback) {
     return EventEmitter.addListener(Event.DeviceOrientationDidChange, callback);
   }
   static listenForInterfaceOrientationChanges(callback) {
     return EventEmitter.addListener(Event.InterfaceOrientationDidChange, callback);
   }
+  static listenForLockChanges(callback) {
+    return EventEmitter.addListener(Event.LockDidChange, callback);
+  }
   static convertOrientationToHumanReadableString(orientation) {
     return RNOrientationDirector._localizedStringProvider[orientation];
   }

package/lib/module/RNOrientationDirector.js.map

@@ -1 +1 @@
-{"version":3,"names":["Module","EventEmitter","Event","Orientation","RNOrientationDirector","_localizedStringProvider","unknown","portrait","portraitUpsideDown","landscapeLeft","landscapeRight","faceUp","faceDown","setLocalizedStringProvider","provider","getInterfaceOrientation","getDeviceOrientation","lockTo","orientation","unlock","listenForDeviceOrientationChanges","callback","addListener","DeviceOrientationDidChange","listenForInterfaceOrientationChanges","InterfaceOrientationDidChange","convertOrientationToHumanReadableString"],"sourceRoot":"../../src","sources":["RNOrientationDirector.ts"],"mappings":"AAAA,OAAOA,MAAM,IAAIC,YAAY,QAAQ,UAAU;AAC/C,OAAOC,KAAK,MAAM,oBAAoB;AAEtC,SAASC,WAAW,QAAQ,0BAA0B;AAItD,MAAMC,qBAAqB,CAAC;EAC1B,OAAeC,wBAAwB,GACrC;IACE,CAACF,WAAW,CAACG,OAAO,GAAG,SAAS;IAChC,CAACH,WAAW,CAACI,QAAQ,GAAG,UAAU;IAClC,CAACJ,WAAW,CAACK,kBAAkB,GAAG,sBAAsB;IACxD,CAACL,WAAW,CAACM,aAAa,GAAG,gBAAgB;IAC7C,CAACN,WAAW,CAACO,cAAc,GAAG,iBAAiB;IAC/C,CAACP,WAAW,CAACQ,MAAM,GAAG,SAAS;IAC/B,CAACR,WAAW,CAACS,QAAQ,GAAG;EAC1B,CAAC;EAEHC,0BAA0BA,CACxBC,QAAuD,EACvD;IACAV,qBAAqB,CAACC,wBAAwB,GAAGS,QAAQ;EAC3D;EAEA,OAAOC,uBAAuBA,CAAA,EAAyB;IACrD,OAAOf,MAAM,CAACe,uBAAuB,CAAC,CAAC;EACzC;EAEA,OAAOC,oBAAoBA,CAAA,EAAyB;IAClD,OAAOhB,MAAM,CAACgB,oBAAoB,CAAC,CAAC;EACtC;EAEA,OAAOC,MAAMA,CAACC,WAAgC,EAAE;IAC9ClB,MAAM,CAACiB,MAAM,CAACC,WAAW,CAAC;EAC5B;EAEA,OAAOC,MAAMA,CAAA,EAAG;IACdnB,MAAM,CAACmB,MAAM,CAAC,CAAC;EACjB;EAEA,OAAOC,iCAAiCA,CACtCC,QAAiD,EACjD;IACA,OAAOpB,YAAY,CAACqB,WAAW,CAACpB,KAAK,CAACqB,0BAA0B,EAAEF,QAAQ,CAAC;EAC7E;EAEA,OAAOG,oCAAoCA,CACzCH,QAAiD,EACjD;IACA,OAAOpB,YAAY,CAACqB,WAAW,CAC7BpB,KAAK,CAACuB,6BAA6B,EACnCJ,QACF,CAAC;EACH;EAEA,OAAOK,uCAAuCA,CAC5CR,WAAwB,EAChB;IACR,OAAOd,qBAAqB,CAACC,wBAAwB,CAACa,WAAW,CAAC;EACpE;AACF;AAEA,eAAed,qBAAqB","ignoreList":[]}
+{"version":3,"names":["Module","EventEmitter","Event","Orientation","RNOrientationDirector","_localizedStringProvider","unknown","portrait","portraitUpsideDown","landscapeLeft","landscapeRight","faceUp","faceDown","setLocalizedStringProvider","provider","getInterfaceOrientation","getDeviceOrientation","lockTo","orientation","unlock","isLocked","listenForDeviceOrientationChanges","callback","addListener","DeviceOrientationDidChange","listenForInterfaceOrientationChanges","InterfaceOrientationDidChange","listenForLockChanges","LockDidChange","convertOrientationToHumanReadableString"],"sourceRoot":"../../src","sources":["RNOrientationDirector.ts"],"mappings":"AAAA,OAAOA,MAAM,IAAIC,YAAY,QAAQ,UAAU;AAC/C,OAAOC,KAAK,MAAM,oBAAoB;AAEtC,SAASC,WAAW,QAAQ,0BAA0B;AAKtD,MAAMC,qBAAqB,CAAC;EAC1B,OAAeC,wBAAwB,GACrC;IACE,CAACF,WAAW,CAACG,OAAO,GAAG,SAAS;IAChC,CAACH,WAAW,CAACI,QAAQ,GAAG,UAAU;IAClC,CAACJ,WAAW,CAACK,kBAAkB,GAAG,sBAAsB;IACxD,CAACL,WAAW,CAACM,aAAa,GAAG,gBAAgB;IAC7C,CAACN,WAAW,CAACO,cAAc,GAAG,iBAAiB;IAC/C,CAACP,WAAW,CAACQ,MAAM,GAAG,SAAS;IAC/B,CAACR,WAAW,CAACS,QAAQ,GAAG;EAC1B,CAAC;EAEHC,0BAA0BA,CACxBC,QAAuD,EACvD;IACAV,qBAAqB,CAACC,wBAAwB,GAAGS,QAAQ;EAC3D;EAEA,OAAOC,uBAAuBA,CAAA,EAAyB;IACrD,OAAOf,MAAM,CAACe,uBAAuB,CAAC,CAAC;EACzC;EAEA,OAAOC,oBAAoBA,CAAA,EAAyB;IAClD,OAAOhB,MAAM,CAACgB,oBAAoB,CAAC,CAAC;EACtC;EAEA,OAAOC,MAAMA,CAACC,WAAgC,EAAE;IAC9ClB,MAAM,CAACiB,MAAM,CAACC,WAAW,CAAC;EAC5B;EAEA,OAAOC,MAAMA,CAAA,EAAG;IACdnB,MAAM,CAACmB,MAAM,CAAC,CAAC;EACjB;EAEA,OAAOC,QAAQA,CAAA,EAAG;IAChB,OAAOpB,MAAM,CAACoB,QAAQ,CAAC,CAAC;EAC1B;EAEA,OAAOC,iCAAiCA,CACtCC,QAAiD,EACjD;IACA,OAAOrB,YAAY,CAACsB,WAAW,CAACrB,KAAK,CAACsB,0BAA0B,EAAEF,QAAQ,CAAC;EAC7E;EAEA,OAAOG,oCAAoCA,CACzCH,QAAiD,EACjD;IACA,OAAOrB,YAAY,CAACsB,WAAW,CAC7BrB,KAAK,CAACwB,6BAA6B,EACnCJ,QACF,CAAC;EACH;EAEA,OAAOK,oBAAoBA,CAACL,QAA4C,EAAE;IACxE,OAAOrB,YAAY,CAACsB,WAAW,CAACrB,KAAK,CAAC0B,aAAa,EAAEN,QAAQ,CAAC;EAChE;EAEA,OAAOO,uCAAuCA,CAC5CX,WAAwB,EAChB;IACR,OAAOd,qBAAqB,CAACC,wBAAwB,CAACa,WAAW,CAAC;EACpE;AACF;AAEA,eAAed,qBAAqB","ignoreList":[]}

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

@@ -0,0 +1,21 @@
+import React from 'react';
+import RNOrientationDirector from '../RNOrientationDirector';
+/**
+ * Hook that returns whether the interface is locked.
+ * It listens for changes and updates the state accordingly.
+ */
+const useIsInterfaceOrientationLocked = () => {
+  const [orientation, setOrientation] = React.useState(() => RNOrientationDirector.isLocked());
+  React.useEffect(() => {
+    const onChange = event => {
+      setOrientation(event.locked);
+    };
+    const subscription = RNOrientationDirector.listenForLockChanges(onChange);
+    return () => {
+      subscription.remove();
+    };
+  }, []);
+  return orientation;
+};
+export default useIsInterfaceOrientationLocked;
+//# sourceMappingURL=useIsInterfaceOrientationLocked.hook.js.map

package/lib/module/hooks/useIsInterfaceOrientationLocked.hook.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["React","RNOrientationDirector","useIsInterfaceOrientationLocked","orientation","setOrientation","useState","isLocked","useEffect","onChange","event","locked","subscription","listenForLockChanges","remove"],"sourceRoot":"../../../src","sources":["hooks/useIsInterfaceOrientationLocked.hook.ts"],"mappings":"AAAA,OAAOA,KAAK,MAAM,OAAO;AACzB,OAAOC,qBAAqB,MAAM,0BAA0B;AAG5D;AACA;AACA;AACA;AACA,MAAMC,+BAA+B,GAAGA,CAAA,KAAM;EAC5C,MAAM,CAACC,WAAW,EAAEC,cAAc,CAAC,GAAGJ,KAAK,CAACK,QAAQ,CAAU,MAC5DJ,qBAAqB,CAACK,QAAQ,CAAC,CACjC,CAAC;EAEDN,KAAK,CAACO,SAAS,CAAC,MAAM;IACpB,MAAMC,QAAQ,GAAIC,KAAkB,IAAK;MACvCL,cAAc,CAACK,KAAK,CAACC,MAAM,CAAC;IAC9B,CAAC;IAED,MAAMC,YAAY,GAAGV,qBAAqB,CAACW,oBAAoB,CAACJ,QAAQ,CAAC;IACzE,OAAO,MAAM;MACXG,YAAY,CAACE,MAAM,CAAC,CAAC;IACvB,CAAC;EACH,CAAC,EAAE,EAAE,CAAC;EAEN,OAAOV,WAAW;AACpB,CAAC;AAED,eAAeD,+BAA+B","ignoreList":[]}

package/lib/module/index.js

@@ -3,6 +3,8 @@ import useDeviceOrientation from './hooks/useDeviceOrientation.hook';
 export { useDeviceOrientation };
 import useInterfaceOrientation from './hooks/useInterfaceOrientation.hook';
 export { useInterfaceOrientation };
+import useIsInterfaceOrientationLocked from './hooks/useIsInterfaceOrientationLocked.hook';
+export { useIsInterfaceOrientationLocked };
 import RNOrientationDirector from './RNOrientationDirector';
 export default RNOrientationDirector;
 //# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["Orientation","useDeviceOrientation","useInterfaceOrientation","RNOrientationDirector"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":"AAAA,SAASA,WAAW,QAAQ,0BAA0B;AAEtD,OAAOC,oBAAoB,MAAM,mCAAmC;AACpE,SAASA,oBAAoB;AAE7B,OAAOC,uBAAuB,MAAM,sCAAsC;AAC1E,SAASA,uBAAuB;AAEhC,OAAOC,qBAAqB,MAAM,yBAAyB;AAC3D,eAAeA,qBAAqB","ignoreList":[]}
+{"version":3,"names":["Orientation","useDeviceOrientation","useInterfaceOrientation","useIsInterfaceOrientationLocked","RNOrientationDirector"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":"AAAA,SAASA,WAAW,QAAQ,0BAA0B;AAEtD,OAAOC,oBAAoB,MAAM,mCAAmC;AACpE,SAASA,oBAAoB;AAE7B,OAAOC,uBAAuB,MAAM,sCAAsC;AAC1E,SAASA,uBAAuB;AAEhC,OAAOC,+BAA+B,MAAM,8CAA8C;AAC1F,SAASA,+BAA+B;AAExC,OAAOC,qBAAqB,MAAM,yBAAyB;AAC3D,eAAeA,qBAAqB","ignoreList":[]}

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

@@ -1,6 +1,7 @@
 var Event = /*#__PURE__*/function (Event) {
   Event["DeviceOrientationDidChange"] = "DeviceOrientationDidChange";
   Event["InterfaceOrientationDidChange"] = "InterfaceOrientationDidChange";
+  Event["LockDidChange"] = "LockDidChange";
   return Event;
 }(Event || {});
 export default Event;

package/lib/module/types/Event.enum.js.map

@@ -1 +1 @@
-{"version":3,"names":["Event"],"sourceRoot":"../../../src","sources":["types/Event.enum.ts"],"mappings":"IAAKA,KAAK,0BAALA,KAAK;EAALA,KAAK;EAALA,KAAK;EAAA,OAALA,KAAK;AAAA,EAALA,KAAK;AAKV,eAAeA,KAAK","ignoreList":[]}
+{"version":3,"names":["Event"],"sourceRoot":"../../../src","sources":["types/Event.enum.ts"],"mappings":"IAAKA,KAAK,0BAALA,KAAK;EAALA,KAAK;EAALA,KAAK;EAALA,KAAK;EAAA,OAALA,KAAK;AAAA,EAALA,KAAK;AAMV,eAAeA,KAAK","ignoreList":[]}

package/lib/module/types/LockedEvent.interface.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=LockedEvent.interface.js.map

package/lib/module/types/LockedEvent.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["types/LockedEvent.interface.ts"],"mappings":"","ignoreList":[]}

package/lib/typescript/src/NativeOrientationDirector.d.ts

@@ -4,6 +4,7 @@ export interface Spec extends TurboModule {
     getDeviceOrientation(): Promise<number>;
     lockTo(orientation: number): void;
     unlock(): void;
+    isLocked(): boolean;
     addListener: (eventType: string) => void;
     removeListeners: (count: number) => void;
 }

package/lib/typescript/src/NativeOrientationDirector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NativeOrientationDirector.d.ts","sourceRoot":"","sources":["../../../src/NativeOrientationDirector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAGhD,MAAM,WAAW,IAAK,SAAQ,WAAW;IACvC,uBAAuB,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IAC3C,oBAAoB,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IACxC,MAAM,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,MAAM,IAAI,IAAI,CAAC;IAEf,WAAW,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;IACzC,eAAe,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CAC1C;;AAED,wBAA6E"}
+{"version":3,"file":"NativeOrientationDirector.d.ts","sourceRoot":"","sources":["../../../src/NativeOrientationDirector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAGhD,MAAM,WAAW,IAAK,SAAQ,WAAW;IACvC,uBAAuB,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IAC3C,oBAAoB,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IACxC,MAAM,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,MAAM,IAAI,IAAI,CAAC;IACf,QAAQ,IAAI,OAAO,CAAC;IAEpB,WAAW,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;IACzC,eAAe,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CAC1C;;AAED,wBAA6E"}

package/lib/typescript/src/RNOrientationDirector.d.ts

@@ -2,6 +2,7 @@ import type { InterfaceOrientationToLocalizedStringProvider } from './types/Inte
 import { Orientation } from './types/Orientation.enum';
 import type { OrientationEvent } from './types/OrientationEvent.interface';
 import type { LockableOrientation } from './types/LockableOrientation.type';
+import type { LockedEvent } from './types/LockedEvent.interface';
 declare class RNOrientationDirector {
     private static _localizedStringProvider;
     setLocalizedStringProvider(provider: InterfaceOrientationToLocalizedStringProvider): void;
@@ -9,8 +10,10 @@ declare class RNOrientationDirector {
     static getDeviceOrientation(): Promise<Orientation>;
     static lockTo(orientation: LockableOrientation): void;
     static unlock(): void;
+    static isLocked(): boolean;
     static listenForDeviceOrientationChanges(callback: (orientation: OrientationEvent) => void): import("react-native").EmitterSubscription;
     static listenForInterfaceOrientationChanges(callback: (orientation: OrientationEvent) => void): import("react-native").EmitterSubscription;
+    static listenForLockChanges(callback: (orientation: LockedEvent) => void): import("react-native").EmitterSubscription;
     static convertOrientationToHumanReadableString(orientation: Orientation): string;
 }
 export default RNOrientationDirector;

package/lib/typescript/src/RNOrientationDirector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RNOrientationDirector.d.ts","sourceRoot":"","sources":["../../../src/RNOrientationDirector.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,6CAA6C,EAAE,MAAM,4DAA4D,CAAC;AAChI,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAC;AAC3E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AAE5E,cAAM,qBAAqB;IACzB,OAAO,CAAC,MAAM,CAAC,wBAAwB,CASnC;IAEJ,0BAA0B,CACxB,QAAQ,EAAE,6CAA6C;IAKzD,MAAM,CAAC,uBAAuB,IAAI,OAAO,CAAC,WAAW,CAAC;IAItD,MAAM,CAAC,oBAAoB,IAAI,OAAO,CAAC,WAAW,CAAC;IAInD,MAAM,CAAC,MAAM,CAAC,WAAW,EAAE,mBAAmB;IAI9C,MAAM,CAAC,MAAM;IAIb,MAAM,CAAC,iCAAiC,CACtC,QAAQ,EAAE,CAAC,WAAW,EAAE,gBAAgB,KAAK,IAAI;IAKnD,MAAM,CAAC,oCAAoC,CACzC,QAAQ,EAAE,CAAC,WAAW,EAAE,gBAAgB,KAAK,IAAI;IAQnD,MAAM,CAAC,uCAAuC,CAC5C,WAAW,EAAE,WAAW,GACvB,MAAM;CAGV;AAED,eAAe,qBAAqB,CAAC"}
+{"version":3,"file":"RNOrientationDirector.d.ts","sourceRoot":"","sources":["../../../src/RNOrientationDirector.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,6CAA6C,EAAE,MAAM,4DAA4D,CAAC;AAChI,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAC;AAC3E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AAC5E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAEjE,cAAM,qBAAqB;IACzB,OAAO,CAAC,MAAM,CAAC,wBAAwB,CASnC;IAEJ,0BAA0B,CACxB,QAAQ,EAAE,6CAA6C;IAKzD,MAAM,CAAC,uBAAuB,IAAI,OAAO,CAAC,WAAW,CAAC;IAItD,MAAM,CAAC,oBAAoB,IAAI,OAAO,CAAC,WAAW,CAAC;IAInD,MAAM,CAAC,MAAM,CAAC,WAAW,EAAE,mBAAmB;IAI9C,MAAM,CAAC,MAAM;IAIb,MAAM,CAAC,QAAQ;IAIf,MAAM,CAAC,iCAAiC,CACtC,QAAQ,EAAE,CAAC,WAAW,EAAE,gBAAgB,KAAK,IAAI;IAKnD,MAAM,CAAC,oCAAoC,CACzC,QAAQ,EAAE,CAAC,WAAW,EAAE,gBAAgB,KAAK,IAAI;IAQnD,MAAM,CAAC,oBAAoB,CAAC,QAAQ,EAAE,CAAC,WAAW,EAAE,WAAW,KAAK,IAAI;IAIxE,MAAM,CAAC,uCAAuC,CAC5C,WAAW,EAAE,WAAW,GACvB,MAAM;CAGV;AAED,eAAe,qBAAqB,CAAC"}

package/lib/typescript/src/hooks/useIsInterfaceOrientationLocked.hook.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Hook that returns whether the interface is locked.
+ * It listens for changes and updates the state accordingly.
+ */
+declare const useIsInterfaceOrientationLocked: () => boolean;
+export default useIsInterfaceOrientationLocked;
+//# sourceMappingURL=useIsInterfaceOrientationLocked.hook.d.ts.map

package/lib/typescript/src/hooks/useIsInterfaceOrientationLocked.hook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useIsInterfaceOrientationLocked.hook.d.ts","sourceRoot":"","sources":["../../../../src/hooks/useIsInterfaceOrientationLocked.hook.ts"],"names":[],"mappings":"AAIA;;;GAGG;AACH,QAAA,MAAM,+BAA+B,eAiBpC,CAAC;AAEF,eAAe,+BAA+B,CAAC"}

package/lib/typescript/src/index.d.ts

@@ -3,6 +3,8 @@ import useDeviceOrientation from './hooks/useDeviceOrientation.hook';
 export { useDeviceOrientation };
 import useInterfaceOrientation from './hooks/useInterfaceOrientation.hook';
 export { useInterfaceOrientation };
+import useIsInterfaceOrientationLocked from './hooks/useIsInterfaceOrientationLocked.hook';
+export { useIsInterfaceOrientationLocked };
 import RNOrientationDirector from './RNOrientationDirector';
 export default RNOrientationDirector;
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAEvD,OAAO,oBAAoB,MAAM,mCAAmC,CAAC;AACrE,OAAO,EAAE,oBAAoB,EAAE,CAAC;AAEhC,OAAO,uBAAuB,MAAM,sCAAsC,CAAC;AAC3E,OAAO,EAAE,uBAAuB,EAAE,CAAC;AAEnC,OAAO,qBAAqB,MAAM,yBAAyB,CAAC;AAC5D,eAAe,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAEvD,OAAO,oBAAoB,MAAM,mCAAmC,CAAC;AACrE,OAAO,EAAE,oBAAoB,EAAE,CAAC;AAEhC,OAAO,uBAAuB,MAAM,sCAAsC,CAAC;AAC3E,OAAO,EAAE,uBAAuB,EAAE,CAAC;AAEnC,OAAO,+BAA+B,MAAM,8CAA8C,CAAC;AAC3F,OAAO,EAAE,+BAA+B,EAAE,CAAC;AAE3C,OAAO,qBAAqB,MAAM,yBAAyB,CAAC;AAC5D,eAAe,qBAAqB,CAAC"}

package/lib/typescript/src/types/Event.enum.d.ts

@@ -1,6 +1,7 @@
 declare enum Event {
     DeviceOrientationDidChange = "DeviceOrientationDidChange",
-    InterfaceOrientationDidChange = "InterfaceOrientationDidChange"
+    InterfaceOrientationDidChange = "InterfaceOrientationDidChange",
+    LockDidChange = "LockDidChange"
 }
 export default Event;
 //# sourceMappingURL=Event.enum.d.ts.map

package/lib/typescript/src/types/Event.enum.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Event.enum.d.ts","sourceRoot":"","sources":["../../../../src/types/Event.enum.ts"],"names":[],"mappings":"AAAA,aAAK,KAAK;IACR,0BAA0B,+BAA+B;IACzD,6BAA6B,kCAAkC;CAChE;AAED,eAAe,KAAK,CAAC"}
+{"version":3,"file":"Event.enum.d.ts","sourceRoot":"","sources":["../../../../src/types/Event.enum.ts"],"names":[],"mappings":"AAAA,aAAK,KAAK;IACR,0BAA0B,+BAA+B;IACzD,6BAA6B,kCAAkC;IAC/D,aAAa,kBAAkB;CAChC;AAED,eAAe,KAAK,CAAC"}

package/lib/typescript/src/types/LockedEvent.interface.d.ts

@@ -0,0 +1,4 @@
+export interface LockedEvent {
+    locked: boolean;
+}
+//# sourceMappingURL=LockedEvent.interface.d.ts.map

package/lib/typescript/src/types/LockedEvent.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LockedEvent.interface.d.ts","sourceRoot":"","sources":["../../../../src/types/LockedEvent.interface.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,OAAO,CAAC;CACjB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-orientation-director",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "A Modern React Native library that allows you to access orientation",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",

package/src/NativeOrientationDirector.ts

@@ -6,6 +6,7 @@ export interface Spec extends TurboModule {
   getDeviceOrientation(): Promise<number>;
   lockTo(orientation: number): void;
   unlock(): void;
+  isLocked(): boolean;
 
   addListener: (eventType: string) => void;
   removeListeners: (count: number) => void;

package/src/RNOrientationDirector.ts

@@ -4,6 +4,7 @@ import type { InterfaceOrientationToLocalizedStringProvider } from './types/Inte
 import { Orientation } from './types/Orientation.enum';
 import type { OrientationEvent } from './types/OrientationEvent.interface';
 import type { LockableOrientation } from './types/LockableOrientation.type';
+import type { LockedEvent } from './types/LockedEvent.interface';
 
 class RNOrientationDirector {
   private static _localizedStringProvider: InterfaceOrientationToLocalizedStringProvider =
@@ -39,6 +40,10 @@ class RNOrientationDirector {
     Module.unlock();
   }
 
+  static isLocked() {
+    return Module.isLocked();
+  }
+
   static listenForDeviceOrientationChanges(
     callback: (orientation: OrientationEvent) => void
   ) {
@@ -54,6 +59,10 @@ class RNOrientationDirector {
     );
   }
 
+  static listenForLockChanges(callback: (orientation: LockedEvent) => void) {
+    return EventEmitter.addListener(Event.LockDidChange, callback);
+  }
+
   static convertOrientationToHumanReadableString(
     orientation: Orientation
   ): string {

package/src/hooks/useIsInterfaceOrientationLocked.hook.ts

@@ -0,0 +1,28 @@
+import React from 'react';
+import RNOrientationDirector from '../RNOrientationDirector';
+import type { LockedEvent } from '../types/LockedEvent.interface';
+
+/**
+ * Hook that returns whether the interface is locked.
+ * It listens for changes and updates the state accordingly.
+ */
+const useIsInterfaceOrientationLocked = () => {
+  const [orientation, setOrientation] = React.useState<boolean>(() =>
+    RNOrientationDirector.isLocked()
+  );
+
+  React.useEffect(() => {
+    const onChange = (event: LockedEvent) => {
+      setOrientation(event.locked);
+    };
+
+    const subscription = RNOrientationDirector.listenForLockChanges(onChange);
+    return () => {
+      subscription.remove();
+    };
+  }, []);
+
+  return orientation;
+};
+
+export default useIsInterfaceOrientationLocked;

package/src/index.tsx

@@ -6,5 +6,8 @@ export { useDeviceOrientation };
 import useInterfaceOrientation from './hooks/useInterfaceOrientation.hook';
 export { useInterfaceOrientation };
 
+import useIsInterfaceOrientationLocked from './hooks/useIsInterfaceOrientationLocked.hook';
+export { useIsInterfaceOrientationLocked };
+
 import RNOrientationDirector from './RNOrientationDirector';
 export default RNOrientationDirector;

package/src/types/Event.enum.ts

@@ -1,6 +1,7 @@
 enum Event {
   DeviceOrientationDidChange = 'DeviceOrientationDidChange',
   InterfaceOrientationDidChange = 'InterfaceOrientationDidChange',
+  LockDidChange = 'LockDidChange',
 }
 
 export default Event;

package/src/types/LockedEvent.interface.ts

@@ -0,0 +1,3 @@
+export interface LockedEvent {
+  locked: boolean;
+}