@reactvision/react-viro 2.54.0 → 2.55.0

package/dist/components/Utilities/VRModuleOpenXR.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VRModuleOpenXR = void 0;
+exports.exitVRScene = exitVRScene;
+exports.useVRViewTag = useVRViewTag;
+const react_1 = require("react");
+const react_native_1 = require("react-native");
+const VRQuestNavigatorBridge_1 = require("./VRQuestNavigatorBridge");
+/**
+ * Finishes VRActivity and returns the user to the panel (MainActivity).
+ * Safe to call on any platform — no-op when VRLauncher is unavailable.
+ */
+function exitVRScene() {
+    VRQuestNavigatorBridge_1.VRQuestNavigatorBridge.setVRActive(false);
+    react_native_1.NativeModules.VRLauncher
+        ?.exitVRScene?.();
+}
+/**
+ * Typed reference to the VRModuleOpenXR native module.
+ * undefined when not running on Meta Quest (no-op calls are safe via optional chaining).
+ */
+exports.VRModuleOpenXR = react_native_1.NativeModules.VRModuleOpenXR ?? undefined;
+/**
+ * Returns the live viewTag of the ViroVRSceneNavigator running in VRActivity,
+ * kept in sync via VRQuestNavigatorBridge.  null until ViroQuestEntryPoint has
+ * mounted and published the tag.
+ *
+ * Use this inside VR scenes when you need to call VRModuleOpenXR methods:
+ *
+ * ```tsx
+ * function MyVRScene() {
+ *   const viewTag = useVRViewTag();
+ *   const recenter = () => {
+ *     if (viewTag != null) VRModuleOpenXR?.recenterTracking?.(viewTag);
+ *   };
+ *   return <ViroScene>...</ViroScene>;
+ * }
+ * ```
+ */
+function useVRViewTag() {
+    const [tag, setTag] = (0, react_1.useState)(() => VRQuestNavigatorBridge_1.VRQuestNavigatorBridge.getViewTag());
+    (0, react_1.useEffect)(() => VRQuestNavigatorBridge_1.VRQuestNavigatorBridge.onViewTag(setTag), []);
+    return tag;
+}

package/dist/components/Utilities/VRQuestNavigatorBridge.d.ts

@@ -0,0 +1,85 @@
+/**
+ * VRQuestNavigatorBridge
+ *
+ * Carries VR "intents" and navigator operations from panel-Activity component
+ * trees to VRActivity. Both activities run in the same process and share the
+ * same Hermes JS engine, so a module-level store is sufficient — no native
+ * round-trip needed.
+ *
+ * Flow:
+ *   Panel (MainActivity)
+ *     ViroXRSceneNavigator mounts
+ *       → setIntent(scene, config)  — stores intent, notifies ViroQuestEntryPoint
+ *       → launchVRScene()           — OS switches to VRActivity
+ *       → ref.push(StudioScene)     — dispatchOp() queues the op
+ *
+ *   VRActivity mounts VRQuestScene → ViroQuestEntryPoint
+ *       → onIntent cb fires      — reads intentKey + initialScene + rendererConfig
+ *       → renders ViroVRSceneNavigator key={intentKey}  (fresh mount per intent)
+ *       → ViroQuestEntryPoint captures viewTag → setViewTag()
+ *       → subscribeOps() drains queued ops  — push(StudioScene) arrives
+ *
+ * Each call to setIntent() generates a new intentKey.  ViroQuestEntryPoint
+ * uses key={intentKey} on ViroVRSceneNavigator, guaranteeing a clean navigator
+ * stack whenever a different panel screen activates VR.
+ */
+export type VRNavigatorOp = {
+    type: "push";
+    scene: any;
+} | {
+    type: "pop";
+} | {
+    type: "popN";
+    n: number;
+} | {
+    type: "replace";
+    scene: any;
+} | {
+    type: "jump";
+    scene: any;
+};
+/** Renderer flags forwarded from ViroXRSceneNavigator to ViroVRSceneNavigator. */
+export type VRQuestRendererConfig = {
+    hdrEnabled?: boolean;
+    pbrEnabled?: boolean;
+    bloomEnabled?: boolean;
+    shadowsEnabled?: boolean;
+    multisamplingEnabled?: boolean;
+    vrModeEnabled?: boolean;
+    passthroughEnabled?: boolean;
+    handTrackingEnabled?: boolean;
+    debug?: boolean;
+    onExitViro?: () => void;
+};
+export type VRQuestIntent = {
+    intentKey: string;
+    initialScene: any;
+    rendererConfig?: VRQuestRendererConfig;
+};
+export declare const VRQuestNavigatorBridge: {
+    /**
+     * Record the scene and renderer config that VRActivity should use, and
+     * return a unique intent key. Call launchVRScene() after this.
+     */
+    setIntent(initialScene: any, rendererConfig?: VRQuestRendererConfig): string;
+    /** Current intent (may be null if VR has never been launched). */
+    getIntent(): VRQuestIntent | null;
+    /**
+     * Subscribe to intent changes. Fires immediately with the current intent if
+     * one exists so that ViroQuestEntryPoint can render even if it mounts after
+     * setIntent() was called.
+     */
+    onIntent(cb: (intent: VRQuestIntent) => void): () => void;
+    dispatchOp(op: VRNavigatorOp): void;
+    subscribeOps(cb: (op: VRNavigatorOp) => void): () => void;
+    setVRActive(active: boolean): void;
+    isVRActive(): boolean;
+    setViewTag(tag: number | null): void;
+    getViewTag(): number | null;
+    /**
+     * Subscribe to viewTag changes. Fires immediately with the current value.
+     * Use this inside VR scenes that need VRModuleOpenXR (recenterTracking,
+     * setPassthroughEnabled) without a direct ref to ViroVRSceneNavigator.
+     */
+    onViewTag(cb: (tag: number | null) => void): () => void;
+};

package/dist/components/Utilities/VRQuestNavigatorBridge.js

@@ -0,0 +1,124 @@
+"use strict";
+/**
+ * VRQuestNavigatorBridge
+ *
+ * Carries VR "intents" and navigator operations from panel-Activity component
+ * trees to VRActivity. Both activities run in the same process and share the
+ * same Hermes JS engine, so a module-level store is sufficient — no native
+ * round-trip needed.
+ *
+ * Flow:
+ *   Panel (MainActivity)
+ *     ViroXRSceneNavigator mounts
+ *       → setIntent(scene, config)  — stores intent, notifies ViroQuestEntryPoint
+ *       → launchVRScene()           — OS switches to VRActivity
+ *       → ref.push(StudioScene)     — dispatchOp() queues the op
+ *
+ *   VRActivity mounts VRQuestScene → ViroQuestEntryPoint
+ *       → onIntent cb fires      — reads intentKey + initialScene + rendererConfig
+ *       → renders ViroVRSceneNavigator key={intentKey}  (fresh mount per intent)
+ *       → ViroQuestEntryPoint captures viewTag → setViewTag()
+ *       → subscribeOps() drains queued ops  — push(StudioScene) arrives
+ *
+ * Each call to setIntent() generates a new intentKey.  ViroQuestEntryPoint
+ * uses key={intentKey} on ViroVRSceneNavigator, guaranteeing a clean navigator
+ * stack whenever a different panel screen activates VR.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VRQuestNavigatorBridge = void 0;
+// ── Intent store ────────────────────────────────────────────────────────────
+let _intent = null;
+const _intentListeners = new Set();
+// ── Op queue ─────────────────────────────────────────────────────────────────
+const _opListeners = new Set();
+const _opQueue = [];
+let _opCounter = 0;
+// ── VR active flag ────────────────────────────────────────────────────────────
+// True while VRActivity is running. Set to true just before launchVRScene(),
+// set to false by exitVRScene(). The AppState-based relaunch in
+// ViroXRSceneNavigator checks this so it only fires for system-level
+// backgrounding (Quest menu / home), not for explicit exits.
+let _vrActive = false;
+// ── ViewTag store ─────────────────────────────────────────────────────────────
+// ViroQuestEntryPoint populates this after ViroVRSceneNavigator mounts.
+// Panel-side code (e.g. VRModuleOpenXR.recenterTracking) reads it to target
+// the live native view without needing a direct ref to ViroVRSceneNavigator.
+let _viewTag = null;
+const _viewTagListeners = new Set();
+exports.VRQuestNavigatorBridge = {
+    // ── Called by ViroXRSceneNavigator when mounting on Quest ──────────────────
+    /**
+     * Record the scene and renderer config that VRActivity should use, and
+     * return a unique intent key. Call launchVRScene() after this.
+     */
+    setIntent(initialScene, rendererConfig) {
+        const intentKey = `vr-${Date.now()}-${++_opCounter}`;
+        _intent = { intentKey, initialScene, rendererConfig };
+        // Clear any stale ops from the previous intent.
+        _opQueue.length = 0;
+        _intentListeners.forEach((l) => l(_intent));
+        return intentKey;
+    },
+    /** Current intent (may be null if VR has never been launched). */
+    getIntent() {
+        return _intent;
+    },
+    /**
+     * Subscribe to intent changes. Fires immediately with the current intent if
+     * one exists so that ViroQuestEntryPoint can render even if it mounts after
+     * setIntent() was called.
+     */
+    onIntent(cb) {
+        _intentListeners.add(cb);
+        if (_intent)
+            cb(_intent);
+        return () => {
+            _intentListeners.delete(cb);
+        };
+    },
+    // ── Called by ViroXRSceneNavigator ref (push / pop / etc.) ────────────────
+    dispatchOp(op) {
+        if (_opListeners.size > 0) {
+            _opListeners.forEach((l) => l(op));
+        }
+        else {
+            _opQueue.push(op);
+        }
+    },
+    // ── Called by ViroQuestEntryPoint after ViroVRSceneNavigator mounts ────────
+    subscribeOps(cb) {
+        _opListeners.add(cb);
+        const pending = _opQueue.splice(0);
+        pending.forEach((op) => cb(op));
+        return () => {
+            _opListeners.delete(cb);
+        };
+    },
+    // ── VR active flag ────────────────────────────────────────────────────────
+    setVRActive(active) {
+        _vrActive = active;
+    },
+    isVRActive() {
+        return _vrActive;
+    },
+    // ── ViewTag — native node handle of the live ViroVRSceneNavigator ──────────
+    setViewTag(tag) {
+        _viewTag = tag;
+        _viewTagListeners.forEach((l) => l(tag));
+    },
+    getViewTag() {
+        return _viewTag;
+    },
+    /**
+     * Subscribe to viewTag changes. Fires immediately with the current value.
+     * Use this inside VR scenes that need VRModuleOpenXR (recenterTracking,
+     * setPassthroughEnabled) without a direct ref to ViroVRSceneNavigator.
+     */
+    onViewTag(cb) {
+        _viewTagListeners.add(cb);
+        cb(_viewTag);
+        return () => {
+            _viewTagListeners.delete(cb);
+        };
+    },
+};

package/dist/components/Utilities/ViroPlatform.d.ts

@@ -0,0 +1,10 @@
+export declare const isQuest: boolean;
+/**
+ * True when this app build includes the OpenXR VR native module (i.e. the
+ * Quest variant of react-viro is registered in `MainApplication`). Does NOT
+ * imply the current device is a Quest — for that, use `isQuest`.
+ *
+ * Useful when you need to decide whether `ViroVRSceneNavigator` *could* render
+ * if you forced VR mode (e.g., for in-app build diagnostics).
+ */
+export declare const hasOpenXRSupport: boolean;

package/dist/components/Utilities/ViroPlatform.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasOpenXRSupport = exports.isQuest = void 0;
+const react_native_1 = require("react-native");
+/**
+ * True only on actual Meta Quest hardware (Quest 1/2/Pro/3/3S).
+ *
+ * Detection is based on `Platform.constants` (Android `Build.MANUFACTURER`,
+ * `BRAND`, `MODEL`) — NOT on the presence of `NativeModules.VRModuleOpenXR`.
+ * The OpenXR module ships with any app built against the Quest variant of
+ * react-viro and is therefore present on regular Android phones too when the
+ * same APK targets both phone and Quest. Branding strings are the
+ * authoritative signal for "is the user wearing a Quest right now".
+ *
+ * Quest 1/2/Pro:  Manufacturer="Oculus", Brand="oculus"
+ * Quest 3/3S:     Manufacturer="Meta",   Brand="meta"
+ */
+function detectQuest() {
+    if (react_native_1.Platform.OS !== "android")
+        return false;
+    const c = (react_native_1.Platform.constants ?? {});
+    const manufacturer = (c.Manufacturer ?? "").toLowerCase();
+    const brand = (c.Brand ?? "").toLowerCase();
+    const model = (c.Model ?? "").toLowerCase();
+    if (manufacturer === "oculus" ||
+        manufacturer === "meta" ||
+        brand === "oculus" ||
+        brand === "meta") {
+        return true;
+    }
+    // Defensive: future hardware shipping under new manufacturer strings.
+    return /\bquest\b/.test(model);
+}
+exports.isQuest = detectQuest();
+/**
+ * True when this app build includes the OpenXR VR native module (i.e. the
+ * Quest variant of react-viro is registered in `MainApplication`). Does NOT
+ * imply the current device is a Quest — for that, use `isQuest`.
+ *
+ * Useful when you need to decide whether `ViroVRSceneNavigator` *could* render
+ * if you forced VR mode (e.g., for in-app build diagnostics).
+ */
+exports.hasOpenXRSupport = react_native_1.NativeModules.VRModuleOpenXR !== undefined;

package/dist/components/Utilities/ViroVersion.d.ts

@@ -1 +1 @@
-export declare const VIRO_VERSION = "2.54.0";
+export declare const VIRO_VERSION = "2.55.0";

package/dist/components/Utilities/ViroVersion.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VIRO_VERSION = void 0;
-exports.VIRO_VERSION = "2.54.0";
+exports.VIRO_VERSION = "2.55.0";

package/dist/components/Utilities/useAnySourceHover.d.ts

@@ -0,0 +1,36 @@
+import type { Viro3DPoint } from "../Types/ViroUtils";
+/**
+ * Aggregate `onHover` state across all input sources.
+ *
+ * On Quest (and any other backend that supports multiple simultaneous
+ * pointers — e.g. left + right controllers, or controller + tracked hand),
+ * Viro fires the node's `onHover` callback **per source**. A second pointer
+ * sweeping over an already-hovered node would otherwise produce spurious
+ * enter/exit toggles in JS even though the visual hover should remain "on".
+ *
+ * This hook tracks each source ID independently and exposes a single
+ * aggregated boolean — `true` whenever **any** source is hovering the node.
+ * Apps that don't care about per-source distinction (the common case for
+ * UI buttons) can just consume the boolean.
+ *
+ * Usage:
+ * ```tsx
+ * function MyButton() {
+ *   const [hovered, onHover] = useAnySourceHover();
+ *   return (
+ *     <ViroNode onHover={onHover}>
+ *       <ViroQuad materials={[hovered ? "btnHover" : "btnIdle"]} ... />
+ *     </ViroNode>
+ *   );
+ * }
+ * ```
+ *
+ * The handler signature matches Viro's `onHover` prop directly — pass it as
+ * `onHover={onHover}` with no wrapper. Internally the hook deduplicates per
+ * source so a sequence of `(true, …, src=A)` events from the same source
+ * produces at most one re-render.
+ */
+export declare function useAnySourceHover(): readonly [
+    boolean,
+    (isHovering: boolean, position: Viro3DPoint, source: unknown) => void
+];

package/dist/components/Utilities/useAnySourceHover.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAnySourceHover = useAnySourceHover;
+const react_1 = require("react");
+/**
+ * Aggregate `onHover` state across all input sources.
+ *
+ * On Quest (and any other backend that supports multiple simultaneous
+ * pointers — e.g. left + right controllers, or controller + tracked hand),
+ * Viro fires the node's `onHover` callback **per source**. A second pointer
+ * sweeping over an already-hovered node would otherwise produce spurious
+ * enter/exit toggles in JS even though the visual hover should remain "on".
+ *
+ * This hook tracks each source ID independently and exposes a single
+ * aggregated boolean — `true` whenever **any** source is hovering the node.
+ * Apps that don't care about per-source distinction (the common case for
+ * UI buttons) can just consume the boolean.
+ *
+ * Usage:
+ * ```tsx
+ * function MyButton() {
+ *   const [hovered, onHover] = useAnySourceHover();
+ *   return (
+ *     <ViroNode onHover={onHover}>
+ *       <ViroQuad materials={[hovered ? "btnHover" : "btnIdle"]} ... />
+ *     </ViroNode>
+ *   );
+ * }
+ * ```
+ *
+ * The handler signature matches Viro's `onHover` prop directly — pass it as
+ * `onHover={onHover}` with no wrapper. Internally the hook deduplicates per
+ * source so a sequence of `(true, …, src=A)` events from the same source
+ * produces at most one re-render.
+ */
+function useAnySourceHover() {
+    const sourcesRef = (0, react_1.useRef)({});
+    const [hovered, setHovered] = (0, react_1.useState)(false);
+    const onHover = (0, react_1.useCallback)((isHovering, _position, source) => {
+        const key = String(source ?? "default");
+        if (sourcesRef.current[key] === isHovering)
+            return;
+        sourcesRef.current[key] = isHovering;
+        const any = Object.values(sourcesRef.current).some(Boolean);
+        setHovered(any);
+    }, []);
+    return [hovered, onHover];
+}

package/dist/components/Utilities/useAnySourcePressed.d.ts

@@ -0,0 +1,37 @@
+import { ViroClickState } from "../Types/ViroEvents";
+import type { Viro3DPoint } from "../Types/ViroUtils";
+/**
+ * Aggregate `onClickState` "is being pressed" state across all input sources.
+ *
+ * Mirror of `useAnySourceHover` for clicks. Tracks per-source `CLICK_DOWN` /
+ * `CLICK_UP` events from any input source (right + left controllers / hands)
+ * and returns a single aggregated boolean — `true` whenever **any** source
+ * is currently holding the trigger / pinch on this node.
+ *
+ * The fully-completed `CLICKED` event is intentionally ignored here: it is
+ * informational ("a complete click happened") and shouldn't toggle the
+ * held-state. Apps that need the click event itself can use the regular
+ * `onClick` prop — those callbacks already pass the `source`.
+ *
+ * Usage:
+ * ```tsx
+ * function MyButton() {
+ *   const [pressed, onClickState] = useAnySourcePressed();
+ *   return (
+ *     <ViroNode onClickState={onClickState} onClick={...}>
+ *       <ViroQuad
+ *         scale={pressed ? [0.95, 0.95, 0.95] : [1, 1, 1]}
+ *         materials={[pressed ? "btnPressed" : "btnIdle"]}
+ *       />
+ *     </ViroNode>
+ *   );
+ * }
+ * ```
+ *
+ * Internally deduplicates per source so a sequence of `(CLICK_DOWN, src=A)`
+ * events from the same source produces at most one re-render.
+ */
+export declare function useAnySourcePressed(): readonly [
+    boolean,
+    (clickState: ViroClickState, position: Viro3DPoint, source: unknown) => void
+];

package/dist/components/Utilities/useAnySourcePressed.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAnySourcePressed = useAnySourcePressed;
+const react_1 = require("react");
+const ViroEvents_1 = require("../Types/ViroEvents");
+/**
+ * Aggregate `onClickState` "is being pressed" state across all input sources.
+ *
+ * Mirror of `useAnySourceHover` for clicks. Tracks per-source `CLICK_DOWN` /
+ * `CLICK_UP` events from any input source (right + left controllers / hands)
+ * and returns a single aggregated boolean — `true` whenever **any** source
+ * is currently holding the trigger / pinch on this node.
+ *
+ * The fully-completed `CLICKED` event is intentionally ignored here: it is
+ * informational ("a complete click happened") and shouldn't toggle the
+ * held-state. Apps that need the click event itself can use the regular
+ * `onClick` prop — those callbacks already pass the `source`.
+ *
+ * Usage:
+ * ```tsx
+ * function MyButton() {
+ *   const [pressed, onClickState] = useAnySourcePressed();
+ *   return (
+ *     <ViroNode onClickState={onClickState} onClick={...}>
+ *       <ViroQuad
+ *         scale={pressed ? [0.95, 0.95, 0.95] : [1, 1, 1]}
+ *         materials={[pressed ? "btnPressed" : "btnIdle"]}
+ *       />
+ *     </ViroNode>
+ *   );
+ * }
+ * ```
+ *
+ * Internally deduplicates per source so a sequence of `(CLICK_DOWN, src=A)`
+ * events from the same source produces at most one re-render.
+ */
+function useAnySourcePressed() {
+    const sourcesRef = (0, react_1.useRef)({});
+    const [pressed, setPressed] = (0, react_1.useState)(false);
+    const onClickState = (0, react_1.useCallback)((clickState, _position, source) => {
+        let next;
+        if (clickState === ViroEvents_1.ViroClickStateTypes.CLICK_DOWN) {
+            next = true;
+        }
+        else if (clickState === ViroEvents_1.ViroClickStateTypes.CLICK_UP) {
+            next = false;
+        }
+        else {
+            // CLICKED is fired between DOWN and UP for completed clicks —
+            // doesn't change held state, ignore.
+            return;
+        }
+        const key = String(source ?? "default");
+        if (sourcesRef.current[key] === next)
+            return;
+        sourcesRef.current[key] = next;
+        const any = Object.values(sourcesRef.current).some(Boolean);
+        setPressed(any);
+    }, []);
+    return [pressed, onClickState];
+}

package/dist/components/ViroQuestEntryPoint.d.ts

@@ -0,0 +1,13 @@
+import * as React from "react";
+/**
+ * Drop-in root component for VRActivity on Meta Quest.
+ *
+ * The library auto-registers this as 'VRQuestScene' when imported, so most
+ * apps need no manual setup. ViroXRSceneNavigator (panel side) calls
+ * setIntent() with the initial scene and renderer config before launching
+ * VRActivity. This component reads that intent, mounts ViroVRSceneNavigator
+ * with key={intentKey} (fresh stack per intent), and populates the bridge
+ * viewTag so VRModuleOpenXR ops (recenterTracking, setPassthroughEnabled)
+ * work without a direct ref to ViroVRSceneNavigator.
+ */
+export declare function ViroQuestEntryPoint(): React.JSX.Element | null;

package/dist/components/ViroQuestEntryPoint.js

@@ -0,0 +1,104 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ViroQuestEntryPoint = ViroQuestEntryPoint;
+const React = __importStar(require("react"));
+const react_native_1 = require("react-native");
+const VRQuestNavigatorBridge_1 = require("./Utilities/VRQuestNavigatorBridge");
+const VRModuleOpenXR_1 = require("./Utilities/VRModuleOpenXR");
+const ViroVRSceneNavigator_1 = require("./ViroVRSceneNavigator");
+/**
+ * Drop-in root component for VRActivity on Meta Quest.
+ *
+ * The library auto-registers this as 'VRQuestScene' when imported, so most
+ * apps need no manual setup. ViroXRSceneNavigator (panel side) calls
+ * setIntent() with the initial scene and renderer config before launching
+ * VRActivity. This component reads that intent, mounts ViroVRSceneNavigator
+ * with key={intentKey} (fresh stack per intent), and populates the bridge
+ * viewTag so VRModuleOpenXR ops (recenterTracking, setPassthroughEnabled)
+ * work without a direct ref to ViroVRSceneNavigator.
+ */
+function ViroQuestEntryPoint() {
+    const [intent, setIntent] = React.useState(() => VRQuestNavigatorBridge_1.VRQuestNavigatorBridge.getIntent());
+    const navRef = React.useRef(null);
+    React.useEffect(() => VRQuestNavigatorBridge_1.VRQuestNavigatorBridge.onIntent(setIntent), []);
+    // Wire hardware back button to exit VR. Apps that need custom back behaviour
+    // can call AppRegistry.registerComponent('VRQuestScene', ...) to override.
+    React.useEffect(() => {
+        const sub = react_native_1.BackHandler.addEventListener("hardwareBackPress", () => {
+            (0, VRModuleOpenXR_1.exitVRScene)();
+            return true;
+        });
+        return () => sub.remove();
+    }, []);
+    // Forward bridge ops (push/pop/etc.) to the live navigator.
+    React.useEffect(() => {
+        if (!intent)
+            return;
+        return VRQuestNavigatorBridge_1.VRQuestNavigatorBridge.subscribeOps((op) => {
+            const nav = navRef.current;
+            if (!nav)
+                return;
+            if (op.type === "push")
+                nav.push(op.scene);
+            else if (op.type === "pop")
+                nav.pop();
+            else if (op.type === "popN")
+                nav.popN(op.n);
+            else if (op.type === "replace")
+                nav.replace(op.scene);
+            else if (op.type === "jump")
+                nav.jump(op.scene);
+        });
+    }, [intent?.intentKey]);
+    // Publish the native view tag so VRModuleOpenXR callers can target this view.
+    React.useEffect(() => {
+        if (!intent)
+            return;
+        const t = setTimeout(() => {
+            const tag = (0, react_native_1.findNodeHandle)(navRef.current);
+            if (tag != null)
+                VRQuestNavigatorBridge_1.VRQuestNavigatorBridge.setViewTag(tag);
+        }, 100);
+        return () => {
+            clearTimeout(t);
+            VRQuestNavigatorBridge_1.VRQuestNavigatorBridge.setViewTag(null);
+        };
+    }, [intent?.intentKey]);
+    if (!intent)
+        return null;
+    const { initialScene, rendererConfig } = intent;
+    return (<ViroVRSceneNavigator_1.ViroVRSceneNavigator ref={navRef} key={intent.intentKey} initialScene={initialScene} {...rendererConfig} style={react_native_1.StyleSheet.absoluteFill}/>);
+}