react-native-orientation-director 2.0.0 → 2.1.0

package/README.md

@@ -89,6 +89,7 @@ This library exports a class called: [RNOrientationDirector](https://github.com/
 | setHumanReadableOrientations             | Sets the mapping needed to convert orientation values to human readable strings   |
 | setHumanReadableAutoRotations            | Sets the mapping needed to convert auto rotation values to human readable strings |
 | resetSupportedInterfaceOrientations      | Resets the supported interface orientations to settings                           |
+| isLockableOrientation                    | Determines if orientation is lockable                                             |
 
 In addition, the library exposes the following hooks:
 
@@ -100,6 +101,26 @@ In addition, the library exposes the following hooks:
 
 Head over to the [example project](example) to see how to use the library.
 
+### Warning
+
+Please be aware that there is a subtle difference between the device orientation
+and the interface orientation.
+
+When you device is either in landscape left or right orientation, your interface
+is inverted, this is why lockTo method needs a second parameter to discriminate
+which type of orientation your are supplying.
+
+To match developers expectations, if you supply a device orientation and
+OrientationType.device, lockTo switches landscapeRight with left and vice versa
+to property align the interface orientation.
+
+This behavior comes from the native API, you can find more information in their
+documentation:
+
+1. [iOS - UIInterfaceOrientation](https://developer.apple.com/documentation/uikit/uiinterfaceorientation)
+2. [iOS - UIDeviceOrientation](https://developer.apple.com/documentation/uikit/uideviceorientation)
+3. [Android - getRotation](<https://developer.android.com/reference/android/view/Display#getRotation()>)
+
 ### Android
 
 Since on Android we need to deal with sensors and their usage, it is worth noting that the device orientation computation works

package/ios/implementation/OrientationDirectorImpl.swift

@@ -104,10 +104,8 @@ import UIKit
         return supportedInterfaceOrientations.reduce(UIInterfaceOrientationMask()) { $0.union($1) }
     }
 
-    // TODO: FIX BECAUSE IT ALWAYS RETURNS PORTRAIT AND ITS BROKEN
     private func initInterfaceOrientation() -> Orientation {
-        let interfaceOrientation = utils.getInterfaceOrientation()
-        return utils.convertToOrientationFrom(uiInterfaceOrientation: interfaceOrientation)
+        return self.getOrientationFromInterface()
     }
 
     private func initDeviceOrientation() -> Orientation {
@@ -163,18 +161,8 @@ import UIKit
         if (deviceOrientation == Orientation.FACE_UP || deviceOrientation == Orientation.FACE_DOWN) {
             return
         }
-
-        let newInterfaceOrientationMask = utils.convertToMaskFrom(deviceOrientation: deviceOrientation)
-        let isSupported = self.supportedInterfaceOrientations.contains(newInterfaceOrientationMask)
-        if (!isSupported) {
-            return
-        }
-
-        let newInterfaceOrientation = utils.convertToOrientationFrom(mask: newInterfaceOrientationMask)
-        if (newInterfaceOrientation == lastInterfaceOrientation) {
-            return
-        }
-
+        
+        let newInterfaceOrientation = self.getOrientationFromInterface()
         updateLastInterfaceOrientationTo(value: newInterfaceOrientation)
     }
 
@@ -187,4 +175,9 @@ import UIKit
         self.eventManager.sendInterfaceOrientationDidChange(orientationValue: value.rawValue)
         lastInterfaceOrientation = value
     }
+    
+    private func getOrientationFromInterface() -> Orientation {
+        let interfaceOrientation = utils.getInterfaceOrientation()
+        return utils.convertToOrientationFrom(uiInterfaceOrientation: interfaceOrientation)
+    }
 }

package/ios/implementation/Utils.swift

@@ -55,19 +55,6 @@ class Utils {
         }
     }
 
-    public func convertToOrientationFrom(mask: UIInterfaceOrientationMask) -> Orientation {
-        switch(mask) {
-        case .portraitUpsideDown:
-            return .PORTRAIT_UPSIDE_DOWN
-        case .landscapeRight:
-            return .LANDSCAPE_RIGHT
-        case .landscapeLeft:
-            return .LANDSCAPE_LEFT
-        default:
-            return .PORTRAIT
-        }
-    }
-
     /**
      Note: .portraitUpsideDown only works for devices with home button and iPads
      https://developer.apple.com/documentation/uikit/uiviewcontroller/1621435-supportedinterfaceorientations
@@ -87,25 +74,6 @@ class Utils {
         }
     }
 
-    /**
-     Note: .portraitUpsideDown only works for devices with home button and iPads
-     https://developer.apple.com/documentation/uikit/uiviewcontroller/1621435-supportedinterfaceorientations
-     */
-    public func convertToMaskFrom(deviceOrientation: Orientation) -> UIInterfaceOrientationMask {
-        switch(deviceOrientation) {
-        case .PORTRAIT:
-            return .portrait
-        case .LANDSCAPE_RIGHT:
-            return .landscapeLeft
-        case .PORTRAIT_UPSIDE_DOWN:
-            return .portraitUpsideDown
-        case .LANDSCAPE_LEFT:
-            return .landscapeRight
-        default:
-            return .all
-        }
-    }
-
     public func getInterfaceOrientation() -> UIInterfaceOrientation {
         guard let windowScene = self.getCurrentWindow()?.windowScene else {
             return UIInterfaceOrientation.unknown

package/lib/commonjs/RNOrientationDirector.js

@@ -8,6 +8,7 @@ var _reactNative = require("react-native");
 var _module = _interopRequireDefault(require("./module"));
 var _Orientation = require("./types/Orientation.enum");
 var _AutoRotation = require("./types/AutoRotation.enum");
+var _OrientationType = require("./types/OrientationType.enum");
 var _EventEmitter = _interopRequireDefault(require("./EventEmitter"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 class RNOrientationDirector {
@@ -37,7 +38,38 @@ class RNOrientationDirector {
   static getDeviceOrientation() {
     return _module.default.getDeviceOrientation();
   }
-  static lockTo(orientation) {
+
+  /**
+   * 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 = _OrientationType.OrientationType.interface) {
+    if (orientationType === _OrientationType.OrientationType.interface) {
+      _module.default.lockTo(orientation);
+      return;
+    }
+    if (orientation === _Orientation.Orientation.landscapeLeft) {
+      _module.default.lockTo(_Orientation.Orientation.landscapeRight);
+      return;
+    }
+    if (orientation === _Orientation.Orientation.landscapeRight) {
+      _module.default.lockTo(_Orientation.Orientation.landscapeLeft);
+      return;
+    }
     _module.default.lockTo(orientation);
   }
   static unlock() {
@@ -70,6 +102,25 @@ class RNOrientationDirector {
   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 === _Orientation.Orientation.unknown || orientation === _Orientation.Orientation.faceUp || orientation === _Orientation.Orientation.faceDown);
+  }
 }
 var _default = exports.default = RNOrientationDirector;
 //# sourceMappingURL=RNOrientationDirector.js.map

package/lib/commonjs/RNOrientationDirector.js.map

@@ -1 +1 @@
-{"version":3,"names":["_reactNative","require","_module","_interopRequireDefault","_Orientation","_AutoRotation","_EventEmitter","e","__esModule","default","RNOrientationDirector","_humanReadableOrientationsResource","Orientation","unknown","portrait","portraitUpsideDown","landscapeLeft","landscapeRight","faceUp","faceDown","_humanReadableAutoRotationsResource","AutoRotation","enabled","disabled","setHumanReadableOrientations","resource","setHumanReadableAutoRotations","getInterfaceOrientation","Module","getDeviceOrientation","lockTo","orientation","unlock","isLocked","isAutoRotationEnabled","Platform","OS","resetSupportedInterfaceOrientations","listenForDeviceOrientationChanges","callback","EventEmitter","addDeviceOrientationDidChangeListener","listenForInterfaceOrientationChanges","addInterfaceOrientationDidChangeListener","listenForLockChanges","addLockDidChangeListener","convertOrientationToHumanReadableString","convertAutoRotationToHumanReadableString","autoRotation","_default","exports"],"sourceRoot":"../../src","sources":["RNOrientationDirector.ts"],"mappings":"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","ignoreList":[]}
+{"version":3,"names":["_reactNative","require","_module","_interopRequireDefault","_Orientation","_AutoRotation","_OrientationType","_EventEmitter","e","__esModule","default","RNOrientationDirector","_humanReadableOrientationsResource","Orientation","unknown","portrait","portraitUpsideDown","landscapeLeft","landscapeRight","faceUp","faceDown","_humanReadableAutoRotationsResource","AutoRotation","enabled","disabled","setHumanReadableOrientations","resource","setHumanReadableAutoRotations","getInterfaceOrientation","Module","getDeviceOrientation","lockTo","orientation","orientationType","OrientationType","interface","unlock","isLocked","isAutoRotationEnabled","Platform","OS","resetSupportedInterfaceOrientations","listenForDeviceOrientationChanges","callback","EventEmitter","addDeviceOrientationDidChangeListener","listenForInterfaceOrientationChanges","addInterfaceOrientationDidChangeListener","listenForLockChanges","addLockDidChangeListener","convertOrientationToHumanReadableString","convertAutoRotationToHumanReadableString","autoRotation","isLockableOrientation","_default","exports"],"sourceRoot":"../../src","sources":["RNOrientationDirector.ts"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/index.js

@@ -15,6 +15,12 @@ Object.defineProperty(exports, "Orientation", {
     return _Orientation.Orientation;
   }
 });
+Object.defineProperty(exports, "OrientationType", {
+  enumerable: true,
+  get: function () {
+    return _OrientationType.OrientationType;
+  }
+});
 exports.default = void 0;
 Object.defineProperty(exports, "useDeviceOrientation", {
   enumerable: true,
@@ -36,6 +42,7 @@ Object.defineProperty(exports, "useIsInterfaceOrientationLocked", {
 });
 var _Orientation = require("./types/Orientation.enum");
 var _AutoRotation = require("./types/AutoRotation.enum");
+var _OrientationType = require("./types/OrientationType.enum");
 var _useDeviceOrientation = _interopRequireDefault(require("./hooks/useDeviceOrientation.hook"));
 var _useInterfaceOrientation = _interopRequireDefault(require("./hooks/useInterfaceOrientation.hook"));
 var _useIsInterfaceOrientationLocked = _interopRequireDefault(require("./hooks/useIsInterfaceOrientationLocked.hook"));

package/lib/commonjs/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["_Orientation","require","_AutoRotation","_useDeviceOrientation","_interopRequireDefault","_useInterfaceOrientation","_useIsInterfaceOrientationLocked","_RNOrientationDirector","e","__esModule","default","_default","exports","RNOrientationDirector"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,YAAA,GAAAC,OAAA;AACA,IAAAC,aAAA,GAAAD,OAAA;AAEA,IAAAE,qBAAA,GAAAC,sBAAA,CAAAH,OAAA;AAGA,IAAAI,wBAAA,GAAAD,sBAAA,CAAAH,OAAA;AAGA,IAAAK,gCAAA,GAAAF,sBAAA,CAAAH,OAAA;AAGA,IAAAM,sBAAA,GAAAH,sBAAA,CAAAH,OAAA;AAA4D,SAAAG,uBAAAI,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAAA,IAAAG,QAAA,GAAAC,OAAA,CAAAF,OAAA,GAC7CG,8BAAqB","ignoreList":[]}
+{"version":3,"names":["_Orientation","require","_AutoRotation","_OrientationType","_useDeviceOrientation","_interopRequireDefault","_useInterfaceOrientation","_useIsInterfaceOrientationLocked","_RNOrientationDirector","e","__esModule","default","_default","exports","RNOrientationDirector"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,YAAA,GAAAC,OAAA;AACA,IAAAC,aAAA,GAAAD,OAAA;AACA,IAAAE,gBAAA,GAAAF,OAAA;AAEA,IAAAG,qBAAA,GAAAC,sBAAA,CAAAJ,OAAA;AAGA,IAAAK,wBAAA,GAAAD,sBAAA,CAAAJ,OAAA;AAGA,IAAAM,gCAAA,GAAAF,sBAAA,CAAAJ,OAAA;AAGA,IAAAO,sBAAA,GAAAH,sBAAA,CAAAJ,OAAA;AAA4D,SAAAI,uBAAAI,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAAA,IAAAG,QAAA,GAAAC,OAAA,CAAAF,OAAA,GAC7CG,8BAAqB","ignoreList":[]}

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

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.OrientationType = void 0;
+let OrientationType = exports.OrientationType = /*#__PURE__*/function (OrientationType) {
+  OrientationType["device"] = "device";
+  OrientationType["interface"] = "interface";
+  return OrientationType;
+}({});
+//# sourceMappingURL=OrientationType.enum.js.map

package/lib/commonjs/types/OrientationType.enum.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["OrientationType","exports"],"sourceRoot":"../../../src","sources":["types/OrientationType.enum.ts"],"mappings":";;;;;;IAAYA,eAAe,GAAAC,OAAA,CAAAD,eAAA,0BAAfA,eAAe;EAAfA,eAAe;EAAfA,eAAe;EAAA,OAAfA,eAAe;AAAA","ignoreList":[]}

package/lib/module/RNOrientationDirector.js

@@ -2,6 +2,7 @@ import { Platform } from 'react-native';
 import Module from './module';
 import { Orientation } from './types/Orientation.enum';
 import { AutoRotation } from './types/AutoRotation.enum';
+import { OrientationType } from './types/OrientationType.enum';
 import EventEmitter from './EventEmitter';
 class RNOrientationDirector {
   static _humanReadableOrientationsResource = {
@@ -30,7 +31,38 @@ class RNOrientationDirector {
   static getDeviceOrientation() {
     return Module.getDeviceOrientation();
   }
-  static lockTo(orientation) {
+
+  /**
+   * 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 = OrientationType.interface) {
+    if (orientationType === OrientationType.interface) {
+      Module.lockTo(orientation);
+      return;
+    }
+    if (orientation === Orientation.landscapeLeft) {
+      Module.lockTo(Orientation.landscapeRight);
+      return;
+    }
+    if (orientation === Orientation.landscapeRight) {
+      Module.lockTo(Orientation.landscapeLeft);
+      return;
+    }
     Module.lockTo(orientation);
   }
   static unlock() {
@@ -63,6 +95,25 @@ class RNOrientationDirector {
   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 === Orientation.unknown || orientation === Orientation.faceUp || orientation === Orientation.faceDown);
+  }
 }
 export default RNOrientationDirector;
 //# sourceMappingURL=RNOrientationDirector.js.map

package/lib/module/RNOrientationDirector.js.map

@@ -1 +1 @@
-{"version":3,"names":["Platform","Module","Orientation","AutoRotation","EventEmitter","RNOrientationDirector","_humanReadableOrientationsResource","unknown","portrait","portraitUpsideDown","landscapeLeft","landscapeRight","faceUp","faceDown","_humanReadableAutoRotationsResource","enabled","disabled","setHumanReadableOrientations","resource","setHumanReadableAutoRotations","getInterfaceOrientation","getDeviceOrientation","lockTo","orientation","unlock","isLocked","isAutoRotationEnabled","OS","resetSupportedInterfaceOrientations","listenForDeviceOrientationChanges","callback","addDeviceOrientationDidChangeListener","listenForInterfaceOrientationChanges","addInterfaceOrientationDidChangeListener","listenForLockChanges","addLockDidChangeListener","convertOrientationToHumanReadableString","convertAutoRotationToHumanReadableString","autoRotation"],"sourceRoot":"../../src","sources":["RNOrientationDirector.ts"],"mappings":"AAAA,SAASA,QAAQ,QAAQ,cAAc;AACvC,OAAOC,MAAM,MAAM,UAAU;AAE7B,SAASC,WAAW,QAAQ,0BAA0B;AACtD,SAASC,YAAY,QAAQ,2BAA2B;AAKxD,OAAOC,YAAY,MAAM,gBAAgB;AAEzC,MAAMC,qBAAqB,CAAC;EAC1B,OAAeC,kCAAkC,GAC/C;IACE,CAACJ,WAAW,CAACK,OAAO,GAAG,SAAS;IAChC,CAACL,WAAW,CAACM,QAAQ,GAAG,UAAU;IAClC,CAACN,WAAW,CAACO,kBAAkB,GAAG,sBAAsB;IACxD,CAACP,WAAW,CAACQ,aAAa,GAAG,gBAAgB;IAC7C,CAACR,WAAW,CAACS,cAAc,GAAG,iBAAiB;IAC/C,CAACT,WAAW,CAACU,MAAM,GAAG,SAAS;IAC/B,CAACV,WAAW,CAACW,QAAQ,GAAG;EAC1B,CAAC;EAEH,OAAeC,mCAAmC,GAChD;IACE,CAACX,YAAY,CAACI,OAAO,GAAG,SAAS;IACjC,CAACJ,YAAY,CAACY,OAAO,GAAG,SAAS;IACjC,CAACZ,YAAY,CAACa,QAAQ,GAAG;EAC3B,CAAC;EAEHC,4BAA4BA,CAACC,QAA2C,EAAE;IACxEb,qBAAqB,CAACC,kCAAkC,GAAGY,QAAQ;EACrE;EAEAC,6BAA6BA,CAACD,QAA4C,EAAE;IAC1Eb,qBAAqB,CAACS,mCAAmC,GAAGI,QAAQ;EACtE;EAEA,OAAOE,uBAAuBA,CAAA,EAAyB;IACrD,OAAOnB,MAAM,CAACmB,uBAAuB,CAAC,CAAC;EACzC;EAEA,OAAOC,oBAAoBA,CAAA,EAAyB;IAClD,OAAOpB,MAAM,CAACoB,oBAAoB,CAAC,CAAC;EACtC;EAEA,OAAOC,MAAMA,CAACC,WAAgC,EAAE;IAC9CtB,MAAM,CAACqB,MAAM,CAACC,WAAW,CAAC;EAC5B;EAEA,OAAOC,MAAMA,CAAA,EAAG;IACdvB,MAAM,CAACuB,MAAM,CAAC,CAAC;EACjB;EAEA,OAAOC,QAAQA,CAAA,EAAG;IAChB,OAAOxB,MAAM,CAACwB,QAAQ,CAAC,CAAC;EAC1B;EAEA,OAAOC,qBAAqBA,CAAA,EAAG;IAC7B,IAAI1B,QAAQ,CAAC2B,EAAE,KAAK,SAAS,EAAE;MAC7B,OAAOxB,YAAY,CAACI,OAAO;IAC7B;IACA,OAAON,MAAM,CAACyB,qBAAqB,CAAC,CAAC,GACjCvB,YAAY,CAACY,OAAO,GACpBZ,YAAY,CAACa,QAAQ;EAC3B;EAEA,OAAOY,mCAAmCA,CAAA,EAAG;IAC3C3B,MAAM,CAAC2B,mCAAmC,CAAC,CAAC;EAC9C;EAEA,OAAOC,iCAAiCA,CACtCC,QAAiD,EACjD;IACA,OAAO1B,YAAY,CAAC2B,qCAAqC,CAACD,QAAQ,CAAC;EACrE;EAEA,OAAOE,oCAAoCA,CACzCF,QAAiD,EACjD;IACA,OAAO1B,YAAY,CAAC6B,wCAAwC,CAACH,QAAQ,CAAC;EACxE;EAEA,OAAOI,oBAAoBA,CAACJ,QAAsC,EAAE;IAClE,OAAO1B,YAAY,CAAC+B,wBAAwB,CAACL,QAAQ,CAAC;EACxD;EAEA,OAAOM,uCAAuCA,CAACb,WAAwB,EAAE;IACvE,OAAOlB,qBAAqB,CAACC,kCAAkC,CAC7DiB,WAAW,CACZ;EACH;EAEA,OAAOc,wCAAwCA,CAACC,YAA0B,EAAE;IAC1E,OAAOjC,qBAAqB,CAACS,mCAAmC,CAC9DwB,YAAY,CACb;EACH;AACF;AAEA,eAAejC,qBAAqB","ignoreList":[]}
+{"version":3,"names":["Platform","Module","Orientation","AutoRotation","OrientationType","EventEmitter","RNOrientationDirector","_humanReadableOrientationsResource","unknown","portrait","portraitUpsideDown","landscapeLeft","landscapeRight","faceUp","faceDown","_humanReadableAutoRotationsResource","enabled","disabled","setHumanReadableOrientations","resource","setHumanReadableAutoRotations","getInterfaceOrientation","getDeviceOrientation","lockTo","orientation","orientationType","interface","unlock","isLocked","isAutoRotationEnabled","OS","resetSupportedInterfaceOrientations","listenForDeviceOrientationChanges","callback","addDeviceOrientationDidChangeListener","listenForInterfaceOrientationChanges","addInterfaceOrientationDidChangeListener","listenForLockChanges","addLockDidChangeListener","convertOrientationToHumanReadableString","convertAutoRotationToHumanReadableString","autoRotation","isLockableOrientation"],"sourceRoot":"../../src","sources":["RNOrientationDirector.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/index.js

@@ -1,5 +1,6 @@
 export { Orientation } from './types/Orientation.enum';
 export { AutoRotation } from './types/AutoRotation.enum';
+export { OrientationType } from './types/OrientationType.enum';
 import useDeviceOrientation from './hooks/useDeviceOrientation.hook';
 export { useDeviceOrientation };
 import useInterfaceOrientation from './hooks/useInterfaceOrientation.hook';

package/lib/module/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["Orientation","AutoRotation","useDeviceOrientation","useInterfaceOrientation","useIsInterfaceOrientationLocked","RNOrientationDirector"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":"AAAA,SAASA,WAAW,QAAQ,0BAA0B;AACtD,SAASC,YAAY,QAAQ,2BAA2B;AAExD,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":[]}
+{"version":3,"names":["Orientation","AutoRotation","OrientationType","useDeviceOrientation","useInterfaceOrientation","useIsInterfaceOrientationLocked","RNOrientationDirector"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":"AAAA,SAASA,WAAW,QAAQ,0BAA0B;AACtD,SAASC,YAAY,QAAQ,2BAA2B;AACxD,SAASC,eAAe,QAAQ,8BAA8B;AAE9D,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/OrientationType.enum.js

@@ -0,0 +1,6 @@
+export let OrientationType = /*#__PURE__*/function (OrientationType) {
+  OrientationType["device"] = "device";
+  OrientationType["interface"] = "interface";
+  return OrientationType;
+}({});
+//# sourceMappingURL=OrientationType.enum.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["OrientationType"],"sourceRoot":"../../../src","sources":["types/OrientationType.enum.ts"],"mappings":"AAAA,WAAYA,eAAe,0BAAfA,eAAe;EAAfA,eAAe;EAAfA,eAAe;EAAA,OAAfA,eAAe;AAAA","ignoreList":[]}

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

@@ -1,6 +1,7 @@
 import type { HumanReadableOrientationsResource } from './types/HumanReadableOrientationsResource.type';
 import { Orientation } from './types/Orientation.enum';
 import { AutoRotation } from './types/AutoRotation.enum';
+import { OrientationType } from './types/OrientationType.enum';
 import type { OrientationEvent } from './types/OrientationEvent.interface';
 import type { LockableOrientation } from './types/LockableOrientation.type';
 import type { LockedEvent } from './types/LockedEvent.interface';
@@ -12,7 +13,25 @@ declare class RNOrientationDirector {
     setHumanReadableAutoRotations(resource: HumanReadableAutoRotationsResource): void;
     static getInterfaceOrientation(): Promise<Orientation>;
     static getDeviceOrientation(): Promise<Orientation>;
-    static lockTo(orientation: LockableOrientation): void;
+    /**
+     * 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: LockableOrientation, orientationType?: OrientationType): void;
     static unlock(): void;
     static isLocked(): boolean;
     static isAutoRotationEnabled(): AutoRotation;
@@ -22,6 +41,22 @@ declare class RNOrientationDirector {
     static listenForLockChanges(callback: (event: LockedEvent) => void): import("react-native").EmitterSubscription;
     static convertOrientationToHumanReadableString(orientation: Orientation): string;
     static convertAutoRotationToHumanReadableString(autoRotation: AutoRotation): string;
+    /**
+     * 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: Orientation): orientation is LockableOrientation;
 }
 export default RNOrientationDirector;
 //# sourceMappingURL=RNOrientationDirector.d.ts.map

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,iCAAiC,EAAE,MAAM,gDAAgD,CAAC;AACxG,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,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;AACjE,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,iDAAiD,CAAC;AAG1G,cAAM,qBAAqB;IACzB,OAAO,CAAC,MAAM,CAAC,kCAAkC,CAS7C;IAEJ,OAAO,CAAC,MAAM,CAAC,mCAAmC,CAK9C;IAEJ,4BAA4B,CAAC,QAAQ,EAAE,iCAAiC;IAIxE,6BAA6B,CAAC,QAAQ,EAAE,kCAAkC;IAI1E,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,qBAAqB;IAS5B,MAAM,CAAC,mCAAmC;IAI1C,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;IAKnD,MAAM,CAAC,oBAAoB,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI;IAIlE,MAAM,CAAC,uCAAuC,CAAC,WAAW,EAAE,WAAW;IAMvE,MAAM,CAAC,wCAAwC,CAAC,YAAY,EAAE,YAAY;CAK3E;AAED,eAAe,qBAAqB,CAAC"}
+{"version":3,"file":"RNOrientationDirector.d.ts","sourceRoot":"","sources":["../../../src/RNOrientationDirector.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,gDAAgD,CAAC;AACxG,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAC/D,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;AACjE,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,iDAAiD,CAAC;AAG1G,cAAM,qBAAqB;IACzB,OAAO,CAAC,MAAM,CAAC,kCAAkC,CAS7C;IAEJ,OAAO,CAAC,MAAM,CAAC,mCAAmC,CAK9C;IAEJ,4BAA4B,CAAC,QAAQ,EAAE,iCAAiC;IAIxE,6BAA6B,CAAC,QAAQ,EAAE,kCAAkC;IAI1E,MAAM,CAAC,uBAAuB,IAAI,OAAO,CAAC,WAAW,CAAC;IAItD,MAAM,CAAC,oBAAoB,IAAI,OAAO,CAAC,WAAW,CAAC;IAInD;;;;;;;;;;;;;;;;;OAiBG;IACH,MAAM,CAAC,MAAM,CACX,WAAW,EAAE,mBAAmB,EAChC,eAAe,GAAE,eAA2C;IAoB9D,MAAM,CAAC,MAAM;IAIb,MAAM,CAAC,QAAQ;IAIf,MAAM,CAAC,qBAAqB;IAS5B,MAAM,CAAC,mCAAmC;IAI1C,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;IAKnD,MAAM,CAAC,oBAAoB,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI;IAIlE,MAAM,CAAC,uCAAuC,CAAC,WAAW,EAAE,WAAW;IAMvE,MAAM,CAAC,wCAAwC,CAAC,YAAY,EAAE,YAAY;IAM1E;;;;;;;;;;;;;;OAcG;IACH,MAAM,CAAC,qBAAqB,CAC1B,WAAW,EAAE,WAAW,GACvB,WAAW,IAAI,mBAAmB;CAOtC;AAED,eAAe,qBAAqB,CAAC"}

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

@@ -1,5 +1,6 @@
 export { Orientation } from './types/Orientation.enum';
 export { AutoRotation } from './types/AutoRotation.enum';
+export { OrientationType } from './types/OrientationType.enum';
 import useDeviceOrientation from './hooks/useDeviceOrientation.hook';
 export { useDeviceOrientation };
 import useInterfaceOrientation from './hooks/useInterfaceOrientation.hook';

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;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAEzD,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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAE/D,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/OrientationType.enum.d.ts

@@ -0,0 +1,5 @@
+export declare enum OrientationType {
+    device = "device",
+    interface = "interface"
+}
+//# sourceMappingURL=OrientationType.enum.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"OrientationType.enum.d.ts","sourceRoot":"","sources":["../../../../src/types/OrientationType.enum.ts"],"names":[],"mappings":"AAAA,oBAAY,eAAe;IACzB,MAAM,WAAW;IACjB,SAAS,cAAc;CACxB"}

package/package.json

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

package/src/RNOrientationDirector.ts

@@ -3,6 +3,7 @@ import Module from './module';
 import type { HumanReadableOrientationsResource } from './types/HumanReadableOrientationsResource.type';
 import { Orientation } from './types/Orientation.enum';
 import { AutoRotation } from './types/AutoRotation.enum';
+import { OrientationType } from './types/OrientationType.enum';
 import type { OrientationEvent } from './types/OrientationEvent.interface';
 import type { LockableOrientation } from './types/LockableOrientation.type';
 import type { LockedEvent } from './types/LockedEvent.interface';
@@ -44,7 +45,43 @@ class RNOrientationDirector {
     return Module.getDeviceOrientation();
   }
 
-  static lockTo(orientation: LockableOrientation) {
+  /**
+   * 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: LockableOrientation,
+    orientationType: OrientationType = OrientationType.interface
+  ) {
+    if (orientationType === OrientationType.interface) {
+      Module.lockTo(orientation);
+      return;
+    }
+
+    if (orientation === Orientation.landscapeLeft) {
+      Module.lockTo(Orientation.landscapeRight);
+      return;
+    }
+
+    if (orientation === Orientation.landscapeRight) {
+      Module.lockTo(Orientation.landscapeLeft);
+      return;
+    }
+
     Module.lockTo(orientation);
   }
 
@@ -96,6 +133,31 @@ class RNOrientationDirector {
       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: Orientation
+  ): orientation is LockableOrientation {
+    return !(
+      orientation === Orientation.unknown ||
+      orientation === Orientation.faceUp ||
+      orientation === Orientation.faceDown
+    );
+  }
 }
 
 export default RNOrientationDirector;

package/src/index.tsx

@@ -1,5 +1,6 @@
 export { Orientation } from './types/Orientation.enum';
 export { AutoRotation } from './types/AutoRotation.enum';
+export { OrientationType } from './types/OrientationType.enum';
 
 import useDeviceOrientation from './hooks/useDeviceOrientation.hook';
 export { useDeviceOrientation };

package/src/types/OrientationType.enum.ts

@@ -0,0 +1,4 @@
+export enum OrientationType {
+  device = 'device',
+  interface = 'interface',
+}