@tenthdart/react-native-nitro-orientation-locker 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Attique Rehman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/NitroOrientationLocker.podspec

@@ -0,0 +1,30 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "NitroOrientationLocker"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["repository"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => "16.0", :visionos => "1.0" }
+  s.source       = { :git => "#{package["repository"]}.git", :tag => "#{s.version}" }
+
+  s.source_files = [
+    "ios/**/*.{swift}",
+    "ios/**/*.{m,mm}",
+    "cpp/**/*.{hpp,cpp}"
+  ]
+
+  s.swift_version = "5.9"
+
+  load 'nitrogen/generated/ios/NitroOrientationLocker+autolinking.rb'
+  add_nitrogen_files(s)
+
+  s.dependency 'React-jsi'
+  s.dependency 'React-callinvoker'
+  install_modules_dependencies(s)
+end

package/README.md

@@ -0,0 +1,98 @@
+# @tenthdart/react-native-nitro-orientation-locker
+
+High-performance orientation lock for React Native, built on
+[Nitro Modules](https://nitro.margelo.com).
+
+- **New Architecture only.** Old-arch is not supported.
+- **iOS 16+ / visionOS 1.0+** — uses `requestGeometryUpdate`.
+- **Android API 24+** — uses `Activity.setRequestedOrientation`.
+- Auto-lock tablets and large-width screens to landscape with a single prop.
+- Imperative `acquireLock` / `releaseLock` for everything else.
+
+## Install
+
+```sh
+npm i @tenthdart/react-native-nitro-orientation-locker react-native-nitro-modules
+cd ios && pod install
+```
+
+Make sure the **New Architecture** is enabled in your app
+(`newArchEnabled=true` in `android/gradle.properties`,
+`RCT_NEW_ARCH_ENABLED=1` for iOS).
+
+### iOS host-app wiring
+
+So that iOS actually honors the requested orientation, route the app's
+supported-orientations delegate through `OrientationGate`:
+
+```swift
+// AppDelegate.swift
+import NitroOrientationLocker
+
+func application(
+  _ application: UIApplication,
+  supportedInterfaceOrientationsFor window: UIWindow?
+) -> UIInterfaceOrientationMask {
+  return OrientationGate.shared.supportedMask
+}
+```
+
+### Android host-app wiring
+
+Add `android:configChanges="orientation|screenSize|screenLayout|keyboardHidden"`
+to your `MainActivity` in `AndroidManifest.xml` so React Native doesn't tear
+down the JS context when orientation changes.
+
+## Usage
+
+### Auto-lock tablets to landscape
+
+Wrap your app once. Phones are unaffected; tablets (iPad / visionOS or
+Android `smallestScreenWidthDp >= 600`) are locked to landscape.
+
+```tsx
+import { OrientationLockerProvider } from '@tenthdart/react-native-nitro-orientation-locker';
+
+export default function App() {
+  return (
+    <OrientationLockerProvider lockTabletsToLandscape>
+      <RootNavigator />
+    </OrientationLockerProvider>
+  );
+}
+```
+
+### Imperative API
+
+```ts
+import { OrientationLocker } from '@tenthdart/react-native-nitro-orientation-locker';
+
+OrientationLocker.acquireLock('landscape');      // any landscape
+OrientationLocker.acquireLock('landscape-left'); // pinned
+OrientationLocker.acquireLock('portrait');
+OrientationLocker.releaseLock();
+
+OrientationLocker.isTablet;            // boolean
+OrientationLocker.currentOrientation;  // 'portrait' | 'landscape-left' | ...
+```
+
+### Orientation values
+
+| Value                   | iOS mask                          | Android                                          |
+| ----------------------- | --------------------------------- | ------------------------------------------------ |
+| `portrait`              | `.portrait`                       | `SCREEN_ORIENTATION_PORTRAIT`                    |
+| `portrait-upside-down`  | `.portraitUpsideDown`             | `SCREEN_ORIENTATION_REVERSE_PORTRAIT`            |
+| `landscape-left`        | `.landscapeLeft`                  | `SCREEN_ORIENTATION_LANDSCAPE`                   |
+| `landscape-right`       | `.landscapeRight`                 | `SCREEN_ORIENTATION_REVERSE_LANDSCAPE`           |
+| `landscape`             | `.landscape`                      | `SCREEN_ORIENTATION_SENSOR_LANDSCAPE`            |
+| `all`                   | `.all`                            | `SCREEN_ORIENTATION_UNSPECIFIED`                 |
+
+## How precedence works
+
+`acquireLock` always wins. Releasing it falls back to the tablet-landscape
+rule (if enabled and on a tablet); otherwise the app returns to its
+default supported orientations.
+
+## License
+
+MIT

package/android/CMakeLists.txt

@@ -0,0 +1,13 @@
+project(NitroOrientationLocker)
+cmake_minimum_required(VERSION 3.9.0)
+
+set(PACKAGE_NAME NitroOrientationLocker)
+set(CMAKE_CXX_STANDARD 20)
+
+include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/NitroOrientationLocker+autolinking.cmake)
+
+add_library(${PACKAGE_NAME} SHARED ${NitroOrientationLocker_SOURCES_AUTOLINKED})
+
+target_include_directories(${PACKAGE_NAME} PRIVATE ${NitroOrientationLocker_INCLUDES_AUTOLINKED})
+
+target_link_libraries(${PACKAGE_NAME} ${NitroOrientationLocker_LIBS_AUTOLINKED})

package/android/build.gradle

@@ -0,0 +1,138 @@
+buildscript {
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.6.1"
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:1.9.24"
+  }
+}
+
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+apply plugin: "com.android.library"
+apply plugin: "org.jetbrains.kotlin.android"
+apply from: "../nitrogen/generated/android/NitroOrientationLocker+autolinking.gradle"
+
+if (!isNewArchitectureEnabled()) {
+  throw new GradleException(
+    "react-native-nitro-orientation-locker requires the New Architecture to be enabled. " +
+    "Set newArchEnabled=true in android/gradle.properties."
+  )
+}
+
+apply plugin: "com.facebook.react"
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["NitroOrientationLocker_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["NitroOrientationLocker_" + name]).toInteger()
+}
+
+android {
+  namespace "com.margelo.nitro.orientationlocker"
+
+  ndkVersion getExtOrDefault("ndkVersion")
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+
+    externalNativeBuild {
+      cmake {
+        cppFlags "-frtti -fexceptions -Wall -Wextra -fstack-protector-all"
+        arguments "-DANDROID_STL=c++_shared", "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
+        abiFilters(*reactNativeArchitectures())
+      }
+    }
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+    }
+  }
+
+  buildFeatures {
+    buildConfig true
+    prefab true
+  }
+
+  packagingOptions {
+    excludes = [
+      "META-INF",
+      "META-INF/**",
+      "**/libc++_shared.so",
+      "**/libfbjni.so",
+      "**/libjsi.so",
+      "**/libfolly_json.so",
+      "**/libfolly_runtime.so",
+      "**/libglog.so",
+      "**/libhermes.so",
+      "**/libhermes-executor-debug.so",
+      "**/libhermes_executor.so",
+      "**/libreactnative.so",
+      "**/libreactnativejni.so",
+      "**/libturbomodulejsijni.so",
+      "**/libreact_nativemodule_core.so",
+      "**/libjscexecutor.so"
+    ]
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
+  }
+
+  kotlinOptions {
+    jvmTarget = "17"
+  }
+
+  sourceSets {
+    main {
+      java.srcDirs += [
+        "${project.buildDir}/generated/source/codegen/java"
+      ]
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+dependencies {
+  //noinspection GradleDynamicVersion
+  implementation "com.facebook.react:react-native:+"
+  implementation project(":react-native-nitro-modules")
+}
+
+react {
+  jsRootDir = file("../src/")
+  libraryName = "NitroOrientationLocker"
+  codegenJavaPackageName = "com.margelo.nitro.orientationlocker"
+}

package/android/gradle.properties

@@ -0,0 +1,5 @@
+NitroOrientationLocker_kotlinVersion=1.9.24
+NitroOrientationLocker_minSdkVersion=24
+NitroOrientationLocker_targetSdkVersion=34
+NitroOrientationLocker_compileSdkVersion=34
+NitroOrientationLocker_ndkVersion=26.1.10909125

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" />

package/android/src/main/java/com/margelo/nitro/orientationlocker/HybridOrientationLocker.kt

@@ -0,0 +1,99 @@
+package com.margelo.nitro.orientationlocker
+
+import android.app.Activity
+import android.content.pm.ActivityInfo
+import android.content.res.Configuration
+import android.view.Surface
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.NitroModules
+
+@DoNotStrip
+class HybridOrientationLocker : HybridOrientationLockerSpec() {
+
+  private var lockTabletsToLandscape = false
+  private var manualLock: String? = null
+
+  override val isTablet: Boolean
+    get() {
+      val context = NitroModules.applicationContext ?: return false
+      return context.resources.configuration.smallestScreenWidthDp >= 600
+    }
+
+  override val currentOrientation: String
+    get() {
+      val activity = NitroModules.applicationContext?.currentActivity ?: return "portrait"
+      val rotation = activity.windowManager.defaultDisplay.rotation
+      val orientation = activity.resources.configuration.orientation
+      return when (orientation) {
+        Configuration.ORIENTATION_LANDSCAPE -> when (rotation) {
+          Surface.ROTATION_270 -> "landscape-right"
+          else -> "landscape-left"
+        }
+        Configuration.ORIENTATION_PORTRAIT -> when (rotation) {
+          Surface.ROTATION_180 -> "portrait-upside-down"
+          else -> "portrait"
+        }
+        else -> "portrait"
+      }
+    }
+
+  override fun acquireLock(orientation: String) {
+    manualLock = orientation
+    apply()
+  }
+
+  override fun releaseLock() {
+    manualLock = null
+    if (lockTabletsToLandscape && isTablet) {
+      apply()
+    } else {
+      restoreUnspecified()
+    }
+  }
+
+  override fun setLockTabletsToLandscape(enabled: Boolean) {
+    lockTabletsToLandscape = enabled
+    when {
+      enabled && isTablet && manualLock == null -> apply()
+      !enabled && manualLock == null -> restoreUnspecified()
+    }
+  }
+
+  // region Private
+
+  private fun resolvedOrientation(): String {
+    manualLock?.let { return it }
+    if (lockTabletsToLandscape && isTablet) return "landscape"
+    return "all"
+  }
+
+  private fun apply() {
+    val target = resolvedOrientation()
+    setActivityOrientation(activityInfoFor(target))
+  }
+
+  private fun restoreUnspecified() {
+    setActivityOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED)
+  }
+
+  private fun activityInfoFor(orientation: String): Int = when (orientation) {
+    "portrait" -> ActivityInfo.SCREEN_ORIENTATION_PORTRAIT
+    "portrait-upside-down" -> ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT
+    "landscape-left" -> ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE
+    "landscape-right" -> ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE
+    "landscape" -> ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE
+    "all" -> ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED
+    else -> ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED
+  }
+
+  private fun setActivityOrientation(requested: Int) {
+    val activity: Activity = NitroModules.applicationContext?.currentActivity ?: return
+    activity.runOnUiThread {
+      if (activity.requestedOrientation != requested) {
+        activity.requestedOrientation = requested
+      }
+    }
+  }
+
+  // endregion
+}

package/ios/HybridOrientationLocker.swift

@@ -0,0 +1,118 @@
+import Foundation
+import UIKit
+import NitroModules
+
+final class HybridOrientationLocker: HybridOrientationLockerSpec {
+  private var lockTabletsToLandscape = false
+  private var manualLock: String? = nil
+
+  var isTablet: Bool {
+    UIDevice.current.userInterfaceIdiom == .pad
+  }
+
+  var currentOrientation: String {
+    switch effectiveDeviceOrientation() {
+    case .portrait: return "portrait"
+    case .portraitUpsideDown: return "portrait-upside-down"
+    case .landscapeLeft: return "landscape-left"
+    case .landscapeRight: return "landscape-right"
+    default: return "portrait"
+    }
+  }
+
+  func acquireLock(orientation: String) throws {
+    manualLock = orientation
+    apply()
+  }
+
+  func releaseLock() throws {
+    manualLock = nil
+    if !(lockTabletsToLandscape && isTablet) {
+      restoreAllOrientations()
+      return
+    }
+    apply()
+  }
+
+  func setLockTabletsToLandscape(enabled: Bool) throws {
+    lockTabletsToLandscape = enabled
+    if enabled && isTablet && manualLock == nil {
+      apply()
+    } else if !enabled && manualLock == nil {
+      restoreAllOrientations()
+    }
+  }
+
+  // MARK: - Private
+
+  private func resolvedOrientation() -> String {
+    if let manual = manualLock { return manual }
+    if lockTabletsToLandscape && isTablet { return "landscape" }
+    return "all"
+  }
+
+  private func apply() {
+    let target = resolvedOrientation()
+    let mask = mask(for: target)
+    OrientationGate.shared.supportedMask = mask
+    requestGeometryUpdate(mask: mask)
+  }
+
+  private func restoreAllOrientations() {
+    OrientationGate.shared.supportedMask = .all
+    requestGeometryUpdate(mask: .all)
+  }
+
+  private func mask(for orientation: String) -> UIInterfaceOrientationMask {
+    switch orientation {
+    case "portrait": return .portrait
+    case "portrait-upside-down": return .portraitUpsideDown
+    case "landscape-left": return .landscapeLeft
+    case "landscape-right": return .landscapeRight
+    case "landscape": return .landscape
+    case "all": return .all
+    default: return .all
+    }
+  }
+
+  private func requestGeometryUpdate(mask: UIInterfaceOrientationMask) {
+    DispatchQueue.main.async {
+      guard
+        let scene = UIApplication.shared.connectedScenes
+          .compactMap({ $0 as? UIWindowScene })
+          .first(where: { $0.activationState == .foregroundActive })
+          ?? UIApplication.shared.connectedScenes
+            .compactMap({ $0 as? UIWindowScene })
+            .first
+      else { return }
+
+      let geometryPreferences = UIWindowScene.GeometryPreferences.iOS(
+        interfaceOrientations: mask
+      )
+      scene.requestGeometryUpdate(geometryPreferences) { _ in }
+
+      scene.windows
+        .compactMap { $0.rootViewController }
+        .forEach { $0.setNeedsUpdateOfSupportedInterfaceOrientations() }
+    }
+  }
+
+  private func effectiveDeviceOrientation() -> UIDeviceOrientation {
+    let device = UIDevice.current.orientation
+    if device.isValidInterfaceOrientation { return device }
+
+    guard
+      let scene = UIApplication.shared.connectedScenes
+        .compactMap({ $0 as? UIWindowScene })
+        .first(where: { $0.activationState == .foregroundActive })
+    else { return .portrait }
+
+    switch scene.interfaceOrientation {
+    case .portrait: return .portrait
+    case .portraitUpsideDown: return .portraitUpsideDown
+    case .landscapeLeft: return .landscapeLeft
+    case .landscapeRight: return .landscapeRight
+    default: return .portrait
+    }
+  }
+}

package/ios/OrientationGate.swift

@@ -0,0 +1,22 @@
+import Foundation
+import UIKit
+
+/// Holds the currently-requested orientation mask so the host app's
+/// `application(_:supportedInterfaceOrientationsFor:)` delegate (or a
+/// `UIViewController` subclass) can honor it.
+///
+/// To wire it up in your host app's `AppDelegate.swift`:
+///
+/// ```swift
+/// func application(
+///   _ application: UIApplication,
+///   supportedInterfaceOrientationsFor window: UIWindow?
+/// ) -> UIInterfaceOrientationMask {
+///   return OrientationGate.shared.supportedMask
+/// }
+/// ```
+@objc public final class OrientationGate: NSObject {
+  @objc public static let shared = OrientationGate()
+  @objc public var supportedMask: UIInterfaceOrientationMask = .all
+  private override init() {}
+}

package/lib/commonjs/OrientationLocker.nitro.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=OrientationLocker.nitro.js.map

package/lib/commonjs/OrientationLocker.nitro.js.map

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

package/lib/commonjs/OrientationLockerProvider.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.OrientationLockerProvider = OrientationLockerProvider;
+var _react = _interopRequireWildcard(require("react"));
+var _index = require("./index");
+var _jsxRuntime = require("react/jsx-runtime");
+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); }
+function OrientationLockerProvider({
+  lockTabletsToLandscape = false,
+  children
+}) {
+  (0, _react.useEffect)(() => {
+    _index.OrientationLocker.setLockTabletsToLandscape(lockTabletsToLandscape);
+    return () => {
+      _index.OrientationLocker.setLockTabletsToLandscape(false);
+    };
+  }, [lockTabletsToLandscape]);
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(_jsxRuntime.Fragment, {
+    children: children
+  });
+}
+//# sourceMappingURL=OrientationLockerProvider.js.map

package/lib/commonjs/OrientationLockerProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_react","_interopRequireWildcard","require","_index","_jsxRuntime","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","OrientationLockerProvider","lockTabletsToLandscape","children","useEffect","OrientationLocker","setLockTabletsToLandscape","jsx","Fragment"],"sourceRoot":"../../src","sources":["OrientationLockerProvider.tsx"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,uBAAA,CAAAC,OAAA;AACA,IAAAC,MAAA,GAAAD,OAAA;AAA4C,IAAAE,WAAA,GAAAF,OAAA;AAAA,SAAAD,wBAAAI,CAAA,EAAAC,CAAA,6BAAAC,OAAA,MAAAC,CAAA,OAAAD,OAAA,IAAAE,CAAA,OAAAF,OAAA,YAAAN,uBAAA,YAAAA,CAAAI,CAAA,EAAAC,CAAA,SAAAA,CAAA,IAAAD,CAAA,IAAAA,CAAA,CAAAK,UAAA,SAAAL,CAAA,MAAAM,CAAA,EAAAC,CAAA,EAAAC,CAAA,KAAAC,SAAA,QAAAC,OAAA,EAAAV,CAAA,iBAAAA,CAAA,uBAAAA,CAAA,yBAAAA,CAAA,SAAAQ,CAAA,MAAAF,CAAA,GAAAL,CAAA,GAAAG,CAAA,GAAAD,CAAA,QAAAG,CAAA,CAAAK,GAAA,CAAAX,CAAA,UAAAM,CAAA,CAAAM,GAAA,CAAAZ,CAAA,GAAAM,CAAA,CAAAO,GAAA,CAAAb,CAAA,EAAAQ,CAAA,gBAAAP,CAAA,IAAAD,CAAA,gBAAAC,CAAA,OAAAa,cAAA,CAAAC,IAAA,CAAAf,CAAA,EAAAC,CAAA,OAAAM,CAAA,IAAAD,CAAA,GAAAU,MAAA,CAAAC,cAAA,KAAAD,MAAA,CAAAE,wBAAA,CAAAlB,CAAA,EAAAC,CAAA,OAAAM,CAAA,CAAAK,GAAA,IAAAL,CAAA,CAAAM,GAAA,IAAAP,CAAA,CAAAE,CAAA,EAAAP,CAAA,EAAAM,CAAA,IAAAC,CAAA,CAAAP,CAAA,IAAAD,CAAA,CAAAC,CAAA,WAAAO,CAAA,KAAAR,CAAA,EAAAC,CAAA;AAYrC,SAASkB,yBAAyBA,CAAC;EACxCC,sBAAsB,GAAG,KAAK;EAC9BC;AAC8B,CAAC,EAAsB;EACrD,IAAAC,gBAAS,EAAC,MAAM;IACdC,wBAAiB,CAACC,yBAAyB,CAACJ,sBAAsB,CAAC;IACnE,OAAO,MAAM;MACXG,wBAAiB,CAACC,yBAAyB,CAAC,KAAK,CAAC;IACpD,CAAC;EACH,CAAC,EAAE,CAACJ,sBAAsB,CAAC,CAAC;EAE5B,oBAAO,IAAArB,WAAA,CAAA0B,GAAA,EAAA1B,WAAA,CAAA2B,QAAA;IAAAL,QAAA,EAAGA;EAAQ,CAAG,CAAC;AACxB","ignoreList":[]}

package/lib/commonjs/index.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.OrientationLocker = void 0;
+Object.defineProperty(exports, "OrientationLockerProvider", {
+  enumerable: true,
+  get: function () {
+    return _OrientationLockerProvider.OrientationLockerProvider;
+  }
+});
+var _reactNativeNitroModules = require("react-native-nitro-modules");
+var _OrientationLockerProvider = require("./OrientationLockerProvider");
+const OrientationLockerHybrid = _reactNativeNitroModules.NitroModules.createHybridObject('OrientationLocker');
+const OrientationLocker = exports.OrientationLocker = {
+  get isTablet() {
+    return OrientationLockerHybrid.isTablet;
+  },
+  get currentOrientation() {
+    return OrientationLockerHybrid.currentOrientation;
+  },
+  acquireLock(orientation) {
+    OrientationLockerHybrid.acquireLock(orientation);
+  },
+  releaseLock() {
+    OrientationLockerHybrid.releaseLock();
+  },
+  setLockTabletsToLandscape(enabled) {
+    OrientationLockerHybrid.setLockTabletsToLandscape(enabled);
+  }
+};
+//# sourceMappingURL=index.js.map

package/lib/commonjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_reactNativeNitroModules","require","_OrientationLockerProvider","OrientationLockerHybrid","NitroModules","createHybridObject","OrientationLocker","exports","isTablet","currentOrientation","acquireLock","orientation","releaseLock","setLockTabletsToLandscape","enabled"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;;;;;;;;;;;AAAA,IAAAA,wBAAA,GAAAC,OAAA;AA6BA,IAAAC,0BAAA,GAAAD,OAAA;AArBA,MAAME,uBAAuB,GAC3BC,qCAAY,CAACC,kBAAkB,CAAwB,mBAAmB,CAAC;AAEtE,MAAMC,iBAAiB,GAAAC,OAAA,CAAAD,iBAAA,GAAG;EAC/B,IAAIE,QAAQA,CAAA,EAAY;IACtB,OAAOL,uBAAuB,CAACK,QAAQ;EACzC,CAAC;EACD,IAAIC,kBAAkBA,CAAA,EAAgB;IACpC,OAAON,uBAAuB,CAACM,kBAAkB;EACnD,CAAC;EACDC,WAAWA,CAACC,WAAwB,EAAQ;IAC1CR,uBAAuB,CAACO,WAAW,CAACC,WAAW,CAAC;EAClD,CAAC;EACDC,WAAWA,CAAA,EAAS;IAClBT,uBAAuB,CAACS,WAAW,CAAC,CAAC;EACvC,CAAC;EACDC,yBAAyBA,CAACC,OAAgB,EAAQ;IAChDX,uBAAuB,CAACU,yBAAyB,CAACC,OAAO,CAAC;EAC5D;AACF,CAAC","ignoreList":[]}

package/lib/commonjs/package.json

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

package/lib/module/OrientationLocker.nitro.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export {};
+//# sourceMappingURL=OrientationLocker.nitro.js.map

package/lib/module/OrientationLocker.nitro.js.map

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

package/lib/module/OrientationLockerProvider.js

@@ -0,0 +1,20 @@
+"use strict";
+
+import React, { useEffect } from 'react';
+import { OrientationLocker } from './index';
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+export function OrientationLockerProvider({
+  lockTabletsToLandscape = false,
+  children
+}) {
+  useEffect(() => {
+    OrientationLocker.setLockTabletsToLandscape(lockTabletsToLandscape);
+    return () => {
+      OrientationLocker.setLockTabletsToLandscape(false);
+    };
+  }, [lockTabletsToLandscape]);
+  return /*#__PURE__*/_jsx(_Fragment, {
+    children: children
+  });
+}
+//# sourceMappingURL=OrientationLockerProvider.js.map

package/lib/module/OrientationLockerProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["React","useEffect","OrientationLocker","Fragment","_Fragment","jsx","_jsx","OrientationLockerProvider","lockTabletsToLandscape","children","setLockTabletsToLandscape"],"sourceRoot":"../../src","sources":["OrientationLockerProvider.tsx"],"mappings":";;AAAA,OAAOA,KAAK,IAAIC,SAAS,QAAQ,OAAO;AACxC,SAASC,iBAAiB,QAAQ,SAAS;AAAC,SAAAC,QAAA,IAAAC,SAAA,EAAAC,GAAA,IAAAC,IAAA;AAY5C,OAAO,SAASC,yBAAyBA,CAAC;EACxCC,sBAAsB,GAAG,KAAK;EAC9BC;AAC8B,CAAC,EAAsB;EACrDR,SAAS,CAAC,MAAM;IACdC,iBAAiB,CAACQ,yBAAyB,CAACF,sBAAsB,CAAC;IACnE,OAAO,MAAM;MACXN,iBAAiB,CAACQ,yBAAyB,CAAC,KAAK,CAAC;IACpD,CAAC;EACH,CAAC,EAAE,CAACF,sBAAsB,CAAC,CAAC;EAE5B,oBAAOF,IAAA,CAAAF,SAAA;IAAAK,QAAA,EAAGA;EAAQ,CAAG,CAAC;AACxB","ignoreList":[]}