@symbiote-native/screen-orientation 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 A. Prokopenko
+
+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/README.md

@@ -0,0 +1,171 @@
+# @symbiote-native/screen-orientation
+
+Port of [`expo-screen-orientation`](https://docs.expo.dev/versions/latest/sdk/screen-orientation/)
+for [SymbioteNative](../../README.md) — orientation locking (`lockAsync`/`lockPlatformAsync`/
+`unlockAsync`), reading the current orientation and lock, and an auto-updating orientation-change
+subscription, reachable from every adapter (React, Vue, Angular), not just React.
+
+Built the same way as [`@symbiote-native/network`](../network) and
+[`@symbiote-native/device`](../device), an `expo-modules-core`-based wrapper (see the
+`symbiote-expo-native-module` project skill for the full mechanism: why `expo-modules-core` is
+depended on directly and never the `expo` meta-package, why the upstream JS is hand-ported into
+`core/` rather than imported, and how autolinking picks up the native module).
+
+## Install
+
+```bash
+npm install @symbiote-native/screen-orientation
+```
+
+Depends on `expo-screen-orientation` and `expo-modules-core` directly (regular dependencies,
+pinned to exact versions — never a caret range, since this package's `core/` is hand-ported against
+one specific native API shape and a newer resolve could silently drift the two apart). Never
+install `expo-screen-orientation` yourself, and never add the `expo` package to this project — it
+bundles its own Metro/Babel pipeline that conflicts with this project's own.
+
+### Required one-time step: native autolinking wiring
+
+Unlike a plain RN native module, `expo-screen-orientation`'s native code is discovered by
+`expo-modules-autolinking`, not RN's own `react-native.config.cjs` mechanism — this needs wiring
+into the native host app **once**, covering this package and every other `expo-modules-core`
+package (`@symbiote-native/network`, `@symbiote-native/device`, `@symbiote-native/sensors`, ...)
+with zero further changes:
+
+| Platform | Touches |
+|---|---|
+| iOS | `ios/Podfile` — add `use_expo_modules!` |
+| iOS | `AppDelegate.swift` — Expo's runtime-bootstrap hook |
+| Android | `settings.gradle` / `app/build.gradle` — resolve and include the Expo Gradle projects |
+| Android | `MainApplication.kt` — Expo's bootstrap hook, plus a hand-written native-module name map (there's no `expo` meta-package here to auto-generate one) |
+
+Full mechanics — the Podfile pieces that normally ship inside the `expo` package, the `expo`
+peer-dependency exclusion list — live in the `symbiote-expo-native-module` skill. Reference
+implementation: `.examples/expo-react/ios/Podfile` and
+`.examples/expo-react/android/app/src/main/java/com/canary/MainApplication.kt`.
+
+No platform permission string is needed for screen-orientation's surface — locking and reading the
+current orientation read/write system state with no runtime permission prompt on either platform.
+
+## Shape
+
+```
+src/core/               screen-orientation.ts — lock*/unlock/get* functions +
+                        addOrientationChangeListener subscription. native-module.ts resolves the
+                        native module through expo-modules-core's requireNativeModule. types.ts —
+                        Orientation/OrientationLock/SizeClassIOS/WebOrientationLock/WebOrientation
+                        enums, PlatformOrientationInfo, ScreenOrientationInfo,
+                        OrientationChangeEvent, hand-ported from ScreenOrientation.types.ts, plus
+                        ScreenOrientationState (this package's own hook/composable/service shape).
+src/react/hooks/        @symbiote-native/screen-orientation/react   — useScreenOrientation
+src/vue/composables/    @symbiote-native/screen-orientation/vue     — useScreenOrientation (same name)
+src/angular/services/   @symbiote-native/screen-orientation/angular — ScreenOrientationService
+                        (`.connect()` returns a Signal)
+```
+
+Each adapter's hook/composable/service is a thin lifecycle wrapper (seed from one-shot
+`getOrientationAsync()`/`getOrientationLockAsync()` calls, subscribe to
+`addOrientationChangeListener`, unsubscribe on unmount) over the same `core` functions — the
+subscription logic is written once and shared by all three.
+
+## Use it
+
+```tsx
+// React — examples/expo-react/screens/ScreenOrientationScreen.tsx
+import { lockAsync, OrientationLock } from '@symbiote-native/screen-orientation';
+import { useScreenOrientation } from '@symbiote-native/screen-orientation/react';
+
+function ScreenOrientationScreen() {
+  const { orientation, orientationLock } = useScreenOrientation();
+
+  return (
+    <>
+      <Text>Orientation: {orientation}</Text>
+      <Text>Lock: {orientationLock}</Text>
+      <Button title="Lock landscape" onPress={() => lockAsync(OrientationLock.LANDSCAPE)} />
+    </>
+  );
+}
+```
+
+```vue
+<!-- Vue — examples/expo-vue-sfc/screens/ScreenOrientationScreen.vue -->
+<script setup lang="ts">
+import { Text } from '@symbiote-native/vue';
+import { lockAsync, OrientationLock } from '@symbiote-native/screen-orientation';
+import { useScreenOrientation } from '@symbiote-native/screen-orientation/vue';
+
+const screenOrientation = useScreenOrientation(); // Ref<ScreenOrientationState>
+</script>
+<template>
+  <Text>Orientation: {{ screenOrientation.orientation }}</Text>
+  <Text>Lock: {{ screenOrientation.orientationLock }}</Text>
+</template>
+```
+
+```ts
+// Angular — examples/expo-angular/src/screens/ScreenOrientationScreen.ts
+import { Component, inject } from '@angular/core';
+import { Text } from '@symbiote-native/angular';
+import { ScreenOrientationService } from '@symbiote-native/screen-orientation/angular';
+
+@Component({
+  standalone: true,
+  imports: [Text],
+  template: `<Text>Orientation: {{ screenOrientation().orientation }}</Text>`,
+})
+export class ScreenOrientationScreen {
+  readonly screenOrientation = inject(ScreenOrientationService).connect(); // Signal<ScreenOrientationState>
+}
+```
+
+## API
+
+A mix of stateless async functions and one listener-based subscription
+(`addOrientationChangeListener`), with its own adapter-level lifecycle hook.
+
+```ts
+lockAsync(orientationLock): Promise<void>                    // locks to one of the OrientationLock values
+lockPlatformAsync(options): Promise<void>                    // locks via a platform-specific param
+unlockAsync(): Promise<void>                                 // unlocks back to OrientationLock.DEFAULT
+getOrientationAsync(): Promise<Orientation>                   // the device's current orientation
+getOrientationLockAsync(): Promise<OrientationLock>           // the current lock
+getPlatformOrientationLockAsync(): Promise<PlatformOrientationInfo>
+supportsOrientationLockAsync(orientationLock): Promise<boolean>
+addOrientationChangeListener(listener): EventSubscription     // fires whenever orientation/lock changes
+```
+
+Plus `Orientation` (enum: `UNKNOWN`/`PORTRAIT_UP`/`PORTRAIT_DOWN`/`LANDSCAPE_LEFT`/
+`LANDSCAPE_RIGHT`), `OrientationLock` (enum: `DEFAULT`/`ALL`/`PORTRAIT`/`PORTRAIT_UP`/
+`PORTRAIT_DOWN`/`LANDSCAPE`/`LANDSCAPE_LEFT`/`LANDSCAPE_RIGHT`/`OTHER`/`UNKNOWN`), `SizeClassIOS`,
+`WebOrientationLock`, `WebOrientation`, `PlatformOrientationInfo`, `ScreenOrientationInfo`,
+`OrientationChangeEvent` — ported from upstream's `ScreenOrientation.types.ts`.
+
+```ts
+import { getOrientationAsync, addOrientationChangeListener } from '@symbiote-native/screen-orientation';
+
+// framework-scoped entry points re-export the same free functions, plus a lifecycle
+// hook/composable/service:
+import { useScreenOrientation } from '@symbiote-native/screen-orientation/react';
+import { useScreenOrientation } from '@symbiote-native/screen-orientation/vue';
+import { ScreenOrientationService } from '@symbiote-native/screen-orientation/angular';
+```
+
+`useScreenOrientation` seeds its initial value (`{ orientation: Orientation.UNKNOWN,
+orientationLock: OrientationLock.UNKNOWN }`) from one-shot `getOrientationAsync()`/
+`getOrientationLockAsync()` calls, then subscribes to `addOrientationChangeListener` for updates,
+and unsubscribes on unmount.
+
+**Note (Android):** `expo-screen-orientation` doesn't emit its own `expoDidUpdateDimensions`
+event on Android — the module piggybacks on RN's own `Dimensions.addEventListener('change', ...)`
+there instead, re-fetching the lock and orientation on every dimensions change. iOS and web both
+subscribe to the native `expoDidUpdateDimensions` event directly.
+
+## Test it
+
+No Fabric/Descriptor angle at all — screen-orientation is a pure async-function + `EventEmitter`
+listener surface, never a view. Tests inject a fake native-module object in place of the real
+`requireNativeModule` resolution (`src/core/screen-orientation.test.ts`,
+`src/{react,vue,angular}/**/*.test.{ts,tsx}`, `vitest`), the same pattern
+`@symbiote-native/network`/`@symbiote-native/device`/`@symbiote-native/sensors` use — no
+`installFabric()`, no ViewConfig. Native rendering itself is verified on-device — see the parent
+[README](../../README.md).

package/build/angular/index.d.ts

@@ -0,0 +1,2 @@
+export { ScreenOrientationService } from './services/screen-orientation.service';
+export { lockAsync, lockPlatformAsync, unlockAsync, getOrientationAsync, getOrientationLockAsync, getPlatformOrientationLockAsync, supportsOrientationLockAsync, addOrientationChangeListener, removeOrientationChangeListeners, removeOrientationChangeListener, Orientation, OrientationLock, SizeClassIOS, WebOrientationLock, WebOrientation, type PlatformOrientationInfo, type ScreenOrientationInfo, type OrientationChangeEvent, type OrientationChangeListener, type ScreenOrientationState, type EventSubscription, } from '../core';

package/build/angular/index.js

@@ -0,0 +1,4 @@
+// ScreenOrientationService is the Angular-only lifecycle half; the free functions and event
+// subscription plumbing all live in core, shared with React/Vue.
+export { ScreenOrientationService } from './services/screen-orientation.service';
+export { lockAsync, lockPlatformAsync, unlockAsync, getOrientationAsync, getOrientationLockAsync, getPlatformOrientationLockAsync, supportsOrientationLockAsync, addOrientationChangeListener, removeOrientationChangeListeners, removeOrientationChangeListener, Orientation, OrientationLock, SizeClassIOS, WebOrientationLock, WebOrientation, } from '../core';

package/build/angular/services/screen-orientation.service/index.d.ts

@@ -0,0 +1,6 @@
+import { type Signal } from '@angular/core';
+import { type ScreenOrientationState } from '../../../core';
+export declare class ScreenOrientationService {
+    private readonly injector;
+    connect(): Signal<ScreenOrientationState>;
+}

package/build/angular/services/screen-orientation.service/index.js

@@ -0,0 +1,75 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import { effect, inject, Injectable, Injector, signal } from '@angular/core';
+import { addOrientationChangeListener, getOrientationAsync, getOrientationLockAsync, Orientation, OrientationLock, } from '../../../core';
+// Angular twin of React's `useScreenOrientation` hook and Vue's `useScreenOrientation`
+// composable.
+//
+//   readonly screenOrientation = inject(ScreenOrientationService).connect();
+//   // template: {{ screenOrientation().orientation }}
+let ScreenOrientationService = (() => {
+    let _classDecorators = [Injectable({ providedIn: 'root' })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var ScreenOrientationService = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ScreenOrientationService = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        injector = inject(Injector);
+        connect() {
+            const screenOrientation = signal({
+                orientation: Orientation.UNKNOWN,
+                orientationLock: OrientationLock.UNKNOWN,
+            });
+            effect(onCleanup => {
+                Promise.all([getOrientationAsync(), getOrientationLockAsync()]).then(([orientation, orientationLock]) => screenOrientation.set({ orientation, orientationLock }));
+                const subscription = addOrientationChangeListener(event => screenOrientation.set({
+                    orientation: event.orientationInfo.orientation,
+                    orientationLock: event.orientationLock,
+                }));
+                onCleanup(() => subscription.remove());
+            }, { injector: this.injector });
+            return screenOrientation.asReadonly();
+        }
+    };
+    return ScreenOrientationService = _classThis;
+})();
+export { ScreenOrientationService };

package/build/core/index.d.ts

@@ -0,0 +1,3 @@
+export { lockAsync, lockPlatformAsync, unlockAsync, getOrientationAsync, getOrientationLockAsync, getPlatformOrientationLockAsync, supportsOrientationLockAsync, addOrientationChangeListener, removeOrientationChangeListeners, removeOrientationChangeListener, } from './screen-orientation';
+export { Orientation, OrientationLock, SizeClassIOS, WebOrientationLock, WebOrientation, type PlatformOrientationInfo, type ScreenOrientationInfo, type OrientationChangeEvent, type OrientationChangeListener, type ScreenOrientationState, } from './types';
+export type { EventSubscription } from 'expo-modules-core';

package/build/core/index.js

@@ -0,0 +1,2 @@
+export { lockAsync, lockPlatformAsync, unlockAsync, getOrientationAsync, getOrientationLockAsync, getPlatformOrientationLockAsync, supportsOrientationLockAsync, addOrientationChangeListener, removeOrientationChangeListeners, removeOrientationChangeListener, } from './screen-orientation';
+export { Orientation, OrientationLock, SizeClassIOS, WebOrientationLock, WebOrientation, } from './types';

package/build/core/native-module.d.ts

@@ -0,0 +1,13 @@
+import type { EventSubscription } from 'expo-modules-core';
+import type { Orientation, OrientationChangeEvent, OrientationLock, WebOrientationLock } from './types';
+export type IPlatformOrientationParam = number | Orientation[] | WebOrientationLock;
+export type INativeScreenOrientationModule = {
+    lockAsync?(orientationLock: OrientationLock): Promise<void>;
+    lockPlatformAsync?(platformOrientationParam: IPlatformOrientationParam): Promise<void>;
+    getOrientationAsync?(): Promise<Orientation>;
+    getOrientationLockAsync?(): Promise<OrientationLock>;
+    getPlatformOrientationLockAsync?(): Promise<IPlatformOrientationParam>;
+    supportsOrientationLockAsync?(orientationLock: OrientationLock): Promise<boolean>;
+    addListener(eventName: 'expoDidUpdateDimensions', listener: (event: OrientationChangeEvent) => void): EventSubscription;
+};
+export declare const expoScreenOrientation: INativeScreenOrientationModule;

package/build/core/native-module.js

@@ -0,0 +1,3 @@
+import { requireNativeModule } from 'expo-modules-core';
+const EXPO_SCREEN_ORIENTATION_MODULE_NAME = 'ExpoScreenOrientation';
+export const expoScreenOrientation = requireNativeModule(EXPO_SCREEN_ORIENTATION_MODULE_NAME);

package/build/core/screen-orientation.d.ts

@@ -0,0 +1,24 @@
+import { type EventSubscription } from 'expo-modules-core';
+import { Orientation, OrientationLock, type OrientationChangeListener, type PlatformOrientationInfo } from './types';
+/** Locks the screen to the given orientation. */
+export declare function lockAsync(orientationLock: OrientationLock): Promise<void>;
+/** Locks the screen to a platform-specific orientation param — Android constant, iOS
+ * orientation array, or web `WebOrientationLock`. */
+export declare function lockPlatformAsync(options: PlatformOrientationInfo): Promise<void>;
+/** Unlocks the screen orientation back to the system default. */
+export declare function unlockAsync(): Promise<void>;
+/** Gets the device's current screen orientation. */
+export declare function getOrientationAsync(): Promise<Orientation>;
+/** Gets the current orientation lock, falling back to the last value set via `lockAsync()`/
+ * `lockPlatformAsync()` when the native method itself isn't available. */
+export declare function getOrientationLockAsync(): Promise<OrientationLock>;
+/** Gets the current orientation lock as a platform-specific value. */
+export declare function getPlatformOrientationLockAsync(): Promise<PlatformOrientationInfo>;
+/** Whether the given orientation lock is supported on this device. */
+export declare function supportsOrientationLockAsync(orientationLock: OrientationLock): Promise<boolean>;
+/** Subscribes to orientation-change events. */
+export declare function addOrientationChangeListener(listener: OrientationChangeListener): EventSubscription;
+/** Removes every orientation-change listener registered via `addOrientationChangeListener()`. */
+export declare function removeOrientationChangeListeners(): void;
+/** Removes a single orientation-change listener's subscription. */
+export declare function removeOrientationChangeListener(subscription: EventSubscription): void;

package/build/core/screen-orientation.js

@@ -0,0 +1,152 @@
+// Hand-ported from .vendors/expo/packages/expo-screen-orientation/src/ScreenOrientation.ts
+// (sdk-57). Unlike battery, upstream ScreenOrientation throws UnavailabilityError when the
+// native method is absent — same convention as packages/network/src/core/network.ts.
+import { Platform, UnavailabilityError } from 'expo-modules-core';
+import { Dimensions } from 'react-native';
+import { expoScreenOrientation } from './native-module';
+import { Orientation, OrientationLock, WebOrientationLock, } from './types';
+const NATIVE_MODULE_NAME = 'ScreenOrientation';
+let _orientationChangeSubscribers = [];
+let _lastOrientationLock = OrientationLock.UNKNOWN;
+/** Locks the screen to the given orientation. */
+export async function lockAsync(orientationLock) {
+    if (!expoScreenOrientation.lockAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'lockAsync');
+    }
+    const orientationLocks = Object.values(OrientationLock);
+    if (!orientationLocks.includes(orientationLock)) {
+        throw new TypeError(`Invalid Orientation Lock: ${orientationLock}`);
+    }
+    if (orientationLock === OrientationLock.OTHER) {
+        return;
+    }
+    await expoScreenOrientation.lockAsync(orientationLock);
+    _lastOrientationLock = orientationLock;
+}
+/** Locks the screen to a platform-specific orientation param — Android constant, iOS
+ * orientation array, or web `WebOrientationLock`. */
+export async function lockPlatformAsync(options) {
+    if (!expoScreenOrientation.lockPlatformAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'lockPlatformAsync');
+    }
+    const { screenOrientationConstantAndroid, screenOrientationArrayIOS, screenOrientationLockWeb } = options;
+    let platformOrientationParam;
+    if (Platform.OS === 'android' && screenOrientationConstantAndroid) {
+        if (isNaN(screenOrientationConstantAndroid)) {
+            throw new TypeError(`lockPlatformAsync Android platform: screenOrientationConstantAndroid cannot be called with ${screenOrientationConstantAndroid}`);
+        }
+        platformOrientationParam = screenOrientationConstantAndroid;
+    }
+    else if (Platform.OS === 'ios' && screenOrientationArrayIOS) {
+        if (!Array.isArray(screenOrientationArrayIOS)) {
+            throw new TypeError(`lockPlatformAsync iOS platform: screenOrientationArrayIOS cannot be called with ${screenOrientationArrayIOS}`);
+        }
+        const orientations = Object.values(Orientation);
+        for (const orientation of screenOrientationArrayIOS) {
+            if (!orientations.includes(orientation)) {
+                throw new TypeError(`lockPlatformAsync iOS platform: ${orientation} is not a valid Orientation`);
+            }
+        }
+        platformOrientationParam = screenOrientationArrayIOS;
+    }
+    else if (Platform.OS === 'web' && screenOrientationLockWeb) {
+        const webOrientationLocks = Object.values(WebOrientationLock);
+        if (!webOrientationLocks.includes(screenOrientationLockWeb)) {
+            throw new TypeError(`Invalid Web Orientation Lock: ${screenOrientationLockWeb}`);
+        }
+        platformOrientationParam = screenOrientationLockWeb;
+    }
+    if (!platformOrientationParam) {
+        throw new TypeError('lockPlatformAsync cannot be called with undefined option properties');
+    }
+    await expoScreenOrientation.lockPlatformAsync(platformOrientationParam);
+    _lastOrientationLock = OrientationLock.OTHER;
+}
+/** Unlocks the screen orientation back to the system default. */
+export async function unlockAsync() {
+    if (!expoScreenOrientation.lockAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'lockAsync');
+    }
+    await expoScreenOrientation.lockAsync(OrientationLock.DEFAULT);
+}
+/** Gets the device's current screen orientation. */
+export async function getOrientationAsync() {
+    if (!expoScreenOrientation.getOrientationAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'getOrientationAsync');
+    }
+    return expoScreenOrientation.getOrientationAsync();
+}
+/** Gets the current orientation lock, falling back to the last value set via `lockAsync()`/
+ * `lockPlatformAsync()` when the native method itself isn't available. */
+export async function getOrientationLockAsync() {
+    if (!expoScreenOrientation.getOrientationLockAsync) {
+        return _lastOrientationLock;
+    }
+    return expoScreenOrientation.getOrientationLockAsync();
+}
+/** Gets the current orientation lock as a platform-specific value. */
+export async function getPlatformOrientationLockAsync() {
+    const platformOrientationLock = await expoScreenOrientation.getPlatformOrientationLockAsync?.();
+    if (Platform.OS === 'android' && typeof platformOrientationLock === 'number') {
+        return { screenOrientationConstantAndroid: platformOrientationLock };
+    }
+    if (Platform.OS === 'ios' && Array.isArray(platformOrientationLock)) {
+        return { screenOrientationArrayIOS: platformOrientationLock };
+    }
+    if (Platform.OS === 'web' && typeof platformOrientationLock === 'string') {
+        return { screenOrientationLockWeb: platformOrientationLock };
+    }
+    return {};
+}
+/** Whether the given orientation lock is supported on this device. */
+export async function supportsOrientationLockAsync(orientationLock) {
+    if (!expoScreenOrientation.supportsOrientationLockAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'supportsOrientationLockAsync');
+    }
+    const orientationLocks = Object.values(OrientationLock);
+    if (!orientationLocks.includes(orientationLock)) {
+        throw new TypeError(`Invalid Orientation Lock: ${orientationLock}`);
+    }
+    return expoScreenOrientation.supportsOrientationLockAsync(orientationLock);
+}
+/** Subscribes to orientation-change events. */
+export function addOrientationChangeListener(listener) {
+    if (typeof listener !== 'function') {
+        throw new TypeError(`addOrientationChangeListener cannot be called with ${listener}`);
+    }
+    const subscription = createDidUpdateDimensionsSubscription(listener);
+    _orientationChangeSubscribers.push(subscription);
+    return subscription;
+}
+/** Removes every orientation-change listener registered via `addOrientationChangeListener()`. */
+export function removeOrientationChangeListeners() {
+    let i = _orientationChangeSubscribers.length;
+    while (i--) {
+        _orientationChangeSubscribers[i]?.remove();
+        _orientationChangeSubscribers.pop();
+    }
+}
+/** Removes a single orientation-change listener's subscription. */
+export function removeOrientationChangeListener(subscription) {
+    if (!subscription || !subscription.remove) {
+        throw new TypeError('Must pass in a valid subscription');
+    }
+    subscription.remove();
+    _orientationChangeSubscribers = _orientationChangeSubscribers.filter(sub => sub !== subscription);
+}
+// IMPORTANT: Android doesn't emit `expoDidUpdateDimensions` — RN's own Dimensions module does,
+// so on Android we piggyback on RN's own `Dimensions.addEventListener('change', ...)` instead.
+function createDidUpdateDimensionsSubscription(listener) {
+    if (Platform.OS === 'web' || Platform.OS === 'ios') {
+        return expoScreenOrientation.addListener('expoDidUpdateDimensions', async (update) => {
+            listener(update);
+        });
+    }
+    return Dimensions.addEventListener('change', async () => {
+        const [orientationLock, orientation] = await Promise.all([
+            getOrientationLockAsync(),
+            getOrientationAsync(),
+        ]);
+        listener({ orientationInfo: { orientation }, orientationLock });
+    });
+}

package/build/core/types.d.ts

@@ -0,0 +1,85 @@
+export declare enum Orientation {
+    UNKNOWN = 0,
+    PORTRAIT_UP = 1,
+    PORTRAIT_DOWN = 2,
+    LANDSCAPE_LEFT = 3,
+    LANDSCAPE_RIGHT = 4
+}
+/**
+ * Values that can be passed to `lockAsync()`. `ALL`/`PORTRAIT` are invalid on devices that
+ * don't support `PORTRAIT_DOWN`.
+ */
+export declare enum OrientationLock {
+    /** iOS: all orientations except `PORTRAIT_DOWN`. Android: system decides. */
+    DEFAULT = 0,
+    /** All four possible orientations. */
+    ALL = 1,
+    /** Any portrait orientation. */
+    PORTRAIT = 2,
+    /** Right-side-up portrait only. */
+    PORTRAIT_UP = 3,
+    /** Upside-down portrait only. */
+    PORTRAIT_DOWN = 4,
+    /** Any landscape orientation. */
+    LANDSCAPE = 5,
+    /** Left landscape only. */
+    LANDSCAPE_LEFT = 6,
+    /** Right landscape only. */
+    LANDSCAPE_RIGHT = 7,
+    /** A platform-specific orientation — not a valid `lockAsync()` policy. */
+    OTHER = 8,
+    /** Unknown lock — not a valid `lockAsync()` policy. */
+    UNKNOWN = 9
+}
+/** Each iOS device has a default set of UIKit size classes. */
+export declare enum SizeClassIOS {
+    UNKNOWN = 0,
+    COMPACT = 1,
+    REGULAR = 2
+}
+export declare enum WebOrientationLock {
+    PORTRAIT_PRIMARY = "portrait-primary",
+    PORTRAIT_SECONDARY = "portrait-secondary",
+    PORTRAIT = "portrait",
+    LANDSCAPE_PRIMARY = "landscape-primary",
+    LANDSCAPE_SECONDARY = "landscape-secondary",
+    LANDSCAPE = "landscape",
+    ANY = "any",
+    NATURAL = "natural",
+    UNKNOWN = "unknown"
+}
+export declare enum WebOrientation {
+    PORTRAIT_PRIMARY = "portrait-primary",
+    PORTRAIT_SECONDARY = "portrait-secondary",
+    LANDSCAPE_PRIMARY = "landscape-primary",
+    LANDSCAPE_SECONDARY = "landscape-secondary"
+}
+export type PlatformOrientationInfo = {
+    /** @platform android */
+    screenOrientationConstantAndroid?: number;
+    /** @platform ios */
+    screenOrientationArrayIOS?: Orientation[];
+    /** @platform web */
+    screenOrientationLockWeb?: WebOrientationLock;
+};
+export type ScreenOrientationInfo = {
+    orientation: Orientation;
+    /** @platform ios */
+    verticalSizeClass?: SizeClassIOS;
+    /** @platform ios */
+    horizontalSizeClass?: SizeClassIOS;
+};
+export type OrientationChangeEvent = {
+    orientationLock: OrientationLock;
+    orientationInfo: ScreenOrientationInfo;
+};
+export type OrientationChangeListener = (event: OrientationChangeEvent) => void;
+/**
+ * The shape shared by every adapter's `useScreenOrientation()` hook/composable/service — not an
+ * upstream expo-screen-orientation type (upstream ships no reactive hook of its own), defined once
+ * here so React/Vue/Angular all consume the identical shape instead of three ad-hoc declarations.
+ */
+export type ScreenOrientationState = {
+    orientation: Orientation;
+    orientationLock: OrientationLock;
+};

package/build/core/types.js

@@ -0,0 +1,64 @@
+// Hand-ported from .vendors/expo/packages/expo-screen-orientation/src/ScreenOrientation.types.ts
+// (sdk-57) — plain enums/data shapes, no `expo` meta-package import to swap out (same as
+// packages/network's types.ts).
+export var Orientation;
+(function (Orientation) {
+    Orientation[Orientation["UNKNOWN"] = 0] = "UNKNOWN";
+    Orientation[Orientation["PORTRAIT_UP"] = 1] = "PORTRAIT_UP";
+    Orientation[Orientation["PORTRAIT_DOWN"] = 2] = "PORTRAIT_DOWN";
+    Orientation[Orientation["LANDSCAPE_LEFT"] = 3] = "LANDSCAPE_LEFT";
+    Orientation[Orientation["LANDSCAPE_RIGHT"] = 4] = "LANDSCAPE_RIGHT";
+})(Orientation || (Orientation = {}));
+/**
+ * Values that can be passed to `lockAsync()`. `ALL`/`PORTRAIT` are invalid on devices that
+ * don't support `PORTRAIT_DOWN`.
+ */
+export var OrientationLock;
+(function (OrientationLock) {
+    /** iOS: all orientations except `PORTRAIT_DOWN`. Android: system decides. */
+    OrientationLock[OrientationLock["DEFAULT"] = 0] = "DEFAULT";
+    /** All four possible orientations. */
+    OrientationLock[OrientationLock["ALL"] = 1] = "ALL";
+    /** Any portrait orientation. */
+    OrientationLock[OrientationLock["PORTRAIT"] = 2] = "PORTRAIT";
+    /** Right-side-up portrait only. */
+    OrientationLock[OrientationLock["PORTRAIT_UP"] = 3] = "PORTRAIT_UP";
+    /** Upside-down portrait only. */
+    OrientationLock[OrientationLock["PORTRAIT_DOWN"] = 4] = "PORTRAIT_DOWN";
+    /** Any landscape orientation. */
+    OrientationLock[OrientationLock["LANDSCAPE"] = 5] = "LANDSCAPE";
+    /** Left landscape only. */
+    OrientationLock[OrientationLock["LANDSCAPE_LEFT"] = 6] = "LANDSCAPE_LEFT";
+    /** Right landscape only. */
+    OrientationLock[OrientationLock["LANDSCAPE_RIGHT"] = 7] = "LANDSCAPE_RIGHT";
+    /** A platform-specific orientation — not a valid `lockAsync()` policy. */
+    OrientationLock[OrientationLock["OTHER"] = 8] = "OTHER";
+    /** Unknown lock — not a valid `lockAsync()` policy. */
+    OrientationLock[OrientationLock["UNKNOWN"] = 9] = "UNKNOWN";
+})(OrientationLock || (OrientationLock = {}));
+/** Each iOS device has a default set of UIKit size classes. */
+export var SizeClassIOS;
+(function (SizeClassIOS) {
+    SizeClassIOS[SizeClassIOS["UNKNOWN"] = 0] = "UNKNOWN";
+    SizeClassIOS[SizeClassIOS["COMPACT"] = 1] = "COMPACT";
+    SizeClassIOS[SizeClassIOS["REGULAR"] = 2] = "REGULAR";
+})(SizeClassIOS || (SizeClassIOS = {}));
+export var WebOrientationLock;
+(function (WebOrientationLock) {
+    WebOrientationLock["PORTRAIT_PRIMARY"] = "portrait-primary";
+    WebOrientationLock["PORTRAIT_SECONDARY"] = "portrait-secondary";
+    WebOrientationLock["PORTRAIT"] = "portrait";
+    WebOrientationLock["LANDSCAPE_PRIMARY"] = "landscape-primary";
+    WebOrientationLock["LANDSCAPE_SECONDARY"] = "landscape-secondary";
+    WebOrientationLock["LANDSCAPE"] = "landscape";
+    WebOrientationLock["ANY"] = "any";
+    WebOrientationLock["NATURAL"] = "natural";
+    WebOrientationLock["UNKNOWN"] = "unknown";
+})(WebOrientationLock || (WebOrientationLock = {}));
+export var WebOrientation;
+(function (WebOrientation) {
+    WebOrientation["PORTRAIT_PRIMARY"] = "portrait-primary";
+    WebOrientation["PORTRAIT_SECONDARY"] = "portrait-secondary";
+    WebOrientation["LANDSCAPE_PRIMARY"] = "landscape-primary";
+    WebOrientation["LANDSCAPE_SECONDARY"] = "landscape-secondary";
+})(WebOrientation || (WebOrientation = {}));

package/build/react/hooks/use-screen-orientation/index.d.ts

@@ -0,0 +1,2 @@
+import { type ScreenOrientationState } from '../../../core';
+export declare function useScreenOrientation(): ScreenOrientationState;