@reactvision/react-viro 2.53.1 → 2.55.0

package/components/Viro360Image.tsx

@@ -37,6 +37,13 @@ type Props = ViewProps & {
   format?: "RGBA8" | "RGB565";
   steroMode?: "LeftRight" | "RightLeft" | "TopBottom" | "BottomTop" | "None";
   isHdr?: boolean;
+  /**
+   * When true, the image is rendered as a sky-effect overlay: it appears only over pixels
+   * semantically labeled as sky by ARCore/ARKit scene semantics, using alpha blending via
+   * the confidence texture for smooth boundary transitions. Requires scene semantics to be
+   * enabled on the AR session. Has no effect in VR mode. Default false.
+   */
+  skyEffect?: boolean;
   /**
    * Callback triggered when we are processing the assets to be
    * displayed in this 360 Photo (either downloading / reading from file).

package/components/ViroQuestEntryPoint.tsx

@@ -0,0 +1,79 @@
+import * as React from "react";
+import { BackHandler, findNodeHandle, StyleSheet } from "react-native";
+import {
+  VRQuestNavigatorBridge,
+  VRQuestIntent,
+} from "./Utilities/VRQuestNavigatorBridge";
+import { exitVRScene } from "./Utilities/VRModuleOpenXR";
+import { ViroVRSceneNavigator } from "./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.
+ */
+export function ViroQuestEntryPoint() {
+  const [intent, setIntent] = React.useState<VRQuestIntent | null>(
+    () => VRQuestNavigatorBridge.getIntent()
+  );
+  const navRef = React.useRef<ViroVRSceneNavigator>(null);
+
+  React.useEffect(() => 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 = BackHandler.addEventListener("hardwareBackPress", () => {
+      exitVRScene();
+      return true;
+    });
+    return () => sub.remove();
+  }, []);
+
+  // Forward bridge ops (push/pop/etc.) to the live navigator.
+  React.useEffect(() => {
+    if (!intent) return;
+    return 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 = findNodeHandle(navRef.current);
+      if (tag != null) VRQuestNavigatorBridge.setViewTag(tag);
+    }, 100);
+    return () => {
+      clearTimeout(t);
+      VRQuestNavigatorBridge.setViewTag(null);
+    };
+  }, [intent?.intentKey]);
+
+  if (!intent) return null;
+
+  const { initialScene, rendererConfig } = intent;
+
+  return (
+    <ViroVRSceneNavigator
+      ref={navRef}
+      key={intent.intentKey}
+      initialScene={initialScene}
+      {...rendererConfig}
+      style={StyleSheet.absoluteFill}
+    />
+  );
+}

package/components/ViroVRSceneNavigator.tsx

@@ -19,7 +19,10 @@ import {
   StyleSheet,
   ViewProps,
 } from "react-native";
-import { ViroExitViroEvent } from "./Types/ViroEvents";
+import {
+  ViroExitViroEvent,
+  ViroHandUpdateEvent,
+} from "./Types/ViroEvents";
 import {
   Viro3DPoint,
   ViroNativeRef,
@@ -27,6 +30,10 @@ import {
   ViroSceneDictionary,
 } from "./Types/ViroUtils";
 const ViroSceneNavigatorModule = NativeModules.VRTSceneNavigatorModule;
+const VRModuleOpenXR = NativeModules.VRModuleOpenXR as {
+  recenterTracking: (viewTag: number) => void;
+  setPassthroughEnabled: (viewTag: number, enabled: boolean) => void;
+} | undefined;
 
 type State = {
   sceneDictionary: ViroSceneDictionary;
@@ -78,10 +85,27 @@ type Props = ViewProps & {
   bloomEnabled?: boolean;
   shadowsEnabled?: boolean;
   multisamplingEnabled?: boolean;
+
+  /** Enable XR_FB_passthrough mixed-reality camera feed (Quest 3 / Quest Pro). */
+  passthroughEnabled?: boolean;
+
+  /**
+   * Enable skeletal hand tracking (Quest — requires com.oculus.permission.HAND_TRACKING in manifest).
+   * Pinch and grab gestures fire the same onClick/onDrag events as controller buttons.
+   */
+  handTrackingEnabled?: boolean;
+
+  /**
+   * Per-frame skeletal hand joint data. Fires at display refresh rate (72/90 Hz).
+   * null for a hand means it is not currently tracked.
+   */
+  onHandUpdate?: (event: NativeSyntheticEvent<ViroHandUpdateEvent>) => void;
 };
 
 /**
  * ViroVRSceneNavigator is used to transition between multiple scenes.
+ * Intended for OVR / Google Cardboard VR mode on non-Quest Android devices.
+ * On Meta Quest use ViroXRSceneNavigator instead.
  */
 export class ViroVRSceneNavigator extends React.Component<Props, State> {
   _component: ViroNativeRef = null;
@@ -90,9 +114,9 @@ export class ViroVRSceneNavigator extends React.Component<Props, State> {
    * Called from native when either the user physically decides to exit vr (hits
    * the "X" buton).
    */
-  _onExitViro(_event: NativeSyntheticEvent<ViroExitViroEvent>) {
+  _onExitViro = (_event: NativeSyntheticEvent<ViroExitViroEvent>) => {
     this.props.onExitViro && this.props.onExitViro();
-  }
+  };
 
   constructor(props: Props) {
     super(props);
@@ -134,7 +158,7 @@ export class ViroVRSceneNavigator extends React.Component<Props, State> {
    *
    * @todo: use Typescript function overloading rather than this inaccurate solution
    */
-  push(param1?: ViroScene | string, param2?: ViroScene) {
+  push = (param1?: ViroScene | string, param2?: ViroScene) => {
     var sceneKey = undefined;
     var scene = undefined;
     if (typeof param1 == "string") {
@@ -169,7 +193,7 @@ export class ViroVRSceneNavigator extends React.Component<Props, State> {
 
     this.incrementSceneReference(scene as ViroScene, sceneKey, false);
     this.addToHistory(sceneKey);
-  }
+  };
 
   /**
    * Replace the top scene in the stack with the given scene. The remainder of the back
@@ -182,7 +206,7 @@ export class ViroVRSceneNavigator extends React.Component<Props, State> {
    *
    * @todo: use Typescript function overloading rather than this inaccurate solution
    */
-  replace(param1?: ViroScene | string, param2?: ViroScene) {
+  replace = (param1?: ViroScene | string, param2?: ViroScene) => {
     var sceneKey = undefined;
     var scene = undefined;
     if (typeof param1 == "string") {
@@ -221,7 +245,7 @@ export class ViroVRSceneNavigator extends React.Component<Props, State> {
     this.popHistoryByN(1);
     this.incrementSceneReference(scene as ViroScene, sceneKey, false);
     this.addToHistory(sceneKey);
-  }
+  };
 
   /**
    * Jumps to a given scene that had been previously pushed. If the scene was not pushed, we
@@ -235,7 +259,7 @@ export class ViroVRSceneNavigator extends React.Component<Props, State> {
    *
    * @todo: use Typescript function overloading rather than this inaccurate solution
    */
-  jump(param1?: ViroScene | string, param2?: ViroScene) {
+  jump = (param1?: ViroScene | string, param2?: ViroScene) => {
     var sceneKey = undefined;
     var scene = undefined;
     if (typeof param1 == "string") {
@@ -270,13 +294,13 @@ export class ViroVRSceneNavigator extends React.Component<Props, State> {
 
     this.incrementSceneReference(scene as ViroScene, sceneKey, true);
     this.reorderHistory(sceneKey);
-  }
+  };
 
-  pop() {
+  pop = () => {
     this.popN(1);
-  }
+  };
 
-  popN(n: number) {
+  popN = (n: number) => {
     if (n === 0) {
       return;
     }
@@ -290,7 +314,7 @@ export class ViroVRSceneNavigator extends React.Component<Props, State> {
 
     this.decrementReferenceForLastNScenes(n);
     this.popHistoryByN(n);
-  }
+  };
 
   /**
    * Increments the reference count for a scene within sceneDictionary that is
@@ -426,20 +450,20 @@ export class ViroVRSceneNavigator extends React.Component<Props, State> {
     return -1;
   }
 
-  _recenterTracking() {
+  _recenterTracking = () => {
     ViroSceneNavigatorModule.recenterTracking(findNodeHandle(this));
-  }
+  };
 
-  async _project(point: Viro3DPoint) {
+  _project = async (point: Viro3DPoint) => {
     return await ViroSceneNavigatorModule.project(findNodeHandle(this), point);
-  }
+  };
 
-  async _unproject(point: Viro3DPoint) {
+  _unproject = async (point: Viro3DPoint) => {
     return await ViroSceneNavigatorModule.unproject(
       findNodeHandle(this),
       point
     );
-  }
+  };
 
   _renderSceneStackItems() {
     let views = [];
@@ -516,6 +540,7 @@ var styles = StyleSheet.create({
   },
 });
 
+
 var VRTVRSceneNavigator = requireNativeComponent<any>(
   "VRTVRSceneNavigator",
   // @ts-ignore

package/components/ViroXRSceneNavigator.tsx

@@ -0,0 +1,217 @@
+import * as React from "react";
+import { AppState, NativeModules, ViewProps } from "react-native";
+import { ViroARSceneNavigator } from "./AR/ViroARSceneNavigator";
+import { isQuest } from "./Utilities/ViroPlatform";
+import { VRQuestNavigatorBridge } from "./Utilities/VRQuestNavigatorBridge";
+
+const VRLauncher = NativeModules.VRLauncher as
+  | { launchVRScene?: () => void }
+  | undefined;
+
+// Quest VR requires a lifecycle-correct VRActivity that drives
+// ReactHostImpl.onHostResume(VRActivity) on entry. The skipActivityIdentity
+// AssertionOnHostPause feature flag (used to suppress the racy MainActivity.
+// onPause assertion when currentActivity has been promoted to VR) is only
+// honored on RN >= 0.83. Without it, MainActivity.onPause hard-crashes via
+// Assertions.assertCondition, so the entire VR path requires RN 0.83+.
+// AR continues to work on RN >= 0.81 (Expo 54+) — only the Quest VR launch
+// is gated.
+const MIN_RN_FOR_VR = { major: 0, minor: 83 };
+
+function checkRNVersionForVR(): void {
+  let version = "unknown";
+  try {
+    version = require("react-native/package.json").version as string;
+    const [maj, min] = version.split(".").map((n) => parseInt(n, 10));
+    if (
+      Number.isFinite(maj) &&
+      Number.isFinite(min) &&
+      (maj > MIN_RN_FOR_VR.major ||
+        (maj === MIN_RN_FOR_VR.major && min >= MIN_RN_FOR_VR.minor))
+    ) {
+      return;
+    }
+  } catch {
+    // fall through to throw with version="unknown"
+  }
+  throw new Error(
+    `[Viro] Meta Quest VR requires React Native >= ${MIN_RN_FOR_VR.major}.${MIN_RN_FOR_VR.minor} ` +
+      `(Expo SDK >= 55). Detected: ${version}. ` +
+      `AR features still work on this version — only ViroXRSceneNavigator's VR path on Quest is gated.`
+  );
+}
+
+type SceneFactory = { scene: () => React.JSX.Element };
+
+type Props = ViewProps & {
+  /**
+   * Scene used on both AR and VR platforms when no platform-specific scene is provided.
+   * Most apps want a different scene per platform — pass `arInitialScene` and
+   * `vrInitialScene` instead in that case.
+   */
+  initialScene?: SceneFactory;
+
+  /** Scene mounted on iOS / non-Quest Android (rendered via ViroARSceneNavigator). */
+  arInitialScene?: SceneFactory;
+
+  /**
+   * Scene mounted on Meta Quest (rendered via ViroVRSceneNavigator in VRActivity).
+   * On Quest, this scene is forwarded to VRActivity via VRQuestNavigatorBridge
+   * rather than rendered inline, because OpenXR exclusive display requires the
+   * VR intent category on the host Activity.
+   */
+  vrInitialScene?: SceneFactory;
+
+  // ── Forwarded to ViroARSceneNavigator ──────────────────────────────────────
+  worldAlignment?: "Gravity" | "GravityAndHeading" | "Camera";
+  autofocus?: boolean;
+  videoQuality?: "High" | "Low";
+  numberOfTrackedImages?: number;
+
+  // ── Forwarded to ViroVRSceneNavigator (Quest path via bridge) ──────────────
+  vrModeEnabled?: boolean;
+  passthroughEnabled?: boolean;
+  handTrackingEnabled?: boolean;
+  onExitViro?: () => void;
+
+  // ── Common ─────────────────────────────────────────────────────────────────
+  viroAppProps?: any;
+  hdrEnabled?: boolean;
+  pbrEnabled?: boolean;
+  bloomEnabled?: boolean;
+  shadowsEnabled?: boolean;
+  multisamplingEnabled?: boolean;
+  debug?: boolean;
+};
+
+/**
+ * Cross-reality scene navigator. Picks the right underlying navigator at runtime:
+ *
+ *  - **iOS / non-Quest Android** → `ViroARSceneNavigator` (rendered inline)
+ *  - **Meta Quest** → launches VRActivity via `VRLauncher.launchVRScene()` and
+ *    forwards all navigator operations (push/pop/etc.) to the
+ *    `ViroVRSceneNavigator` running there via `VRQuestNavigatorBridge`.
+ *    Render output is null — VRActivity owns the display.
+ *
+ * Pass `arInitialScene` / `vrInitialScene` when the AR and VR scenes differ.
+ * When only `initialScene` is provided it is used for both modes.
+ *
+ * Renderer flags (`hdrEnabled`, `pbrEnabled`, `bloomEnabled`, `shadowsEnabled`,
+ * `passthroughEnabled`, etc.) are forwarded to ViroVRSceneNavigator on Quest
+ * via the intent bridge.
+ */
+export const ViroXRSceneNavigator = React.forwardRef<unknown, Props>(
+  function ViroXRSceneNavigator(props, ref) {
+    const {
+      initialScene,
+      arInitialScene,
+      vrInitialScene,
+      // VR-only renderer config — forwarded via bridge on Quest
+      hdrEnabled,
+      pbrEnabled,
+      bloomEnabled,
+      shadowsEnabled,
+      multisamplingEnabled,
+      vrModeEnabled,
+      passthroughEnabled,
+      handTrackingEnabled,
+      onExitViro,
+      debug,
+      ...rest
+    } = props;
+
+    // Inner ref used on the AR path to capture the ViroARSceneNavigator instance.
+    const arRef = React.useRef<ViroARSceneNavigator>(null);
+
+    // Expose navigator interface on the ref.
+    // Quest: proxy push/pop/etc. through VRQuestNavigatorBridge to VRActivity.
+    // AR:    expose the underlying ViroARSceneNavigator instance directly.
+    React.useImperativeHandle(ref, () => {
+      if (isQuest) {
+        const bridgeNav = {
+          push:    (scene: any) => VRQuestNavigatorBridge.dispatchOp({ type: "push",    scene }),
+          replace: (scene: any) => VRQuestNavigatorBridge.dispatchOp({ type: "replace", scene }),
+          jump:    (scene: any) => VRQuestNavigatorBridge.dispatchOp({ type: "jump",    scene }),
+          pop:     ()           => VRQuestNavigatorBridge.dispatchOp({ type: "pop"              }),
+          popN:    (n: number)  => VRQuestNavigatorBridge.dispatchOp({ type: "popN",   n       }),
+        };
+        return { sceneNavigator: bridgeNav, arSceneNavigator: bridgeNav };
+      }
+      return arRef.current as any;
+    }, []);
+
+    // Track AppState so we can detect background → active transitions.
+    const appStateRef = React.useRef(AppState.currentState);
+    // Timestamp at which AppState last left "active". Lets us distinguish a
+    // genuine Quest-menu return (background lasts seconds) from racy
+    // background→active bounces caused by the dual-Activity ReactHost
+    // transitioning state (background lasts <500ms). Only the former should
+    // re-launch VR; the latter would trigger a no-op startActivity that can
+    // contribute to the lifecycle storm in some configurations.
+    const leftActiveAtRef = React.useRef(0);
+
+    // On Quest: register the intent (scene + renderer config) then launch VRActivity.
+    // Also re-launch when the app returns from background (e.g. Quest system menu),
+    // because VRActivity auto-finishes when MainActivity resumes.
+    React.useEffect(() => {
+      if (!isQuest) return;
+      checkRNVersionForVR();
+      const scene = vrInitialScene ?? initialScene;
+      if (scene) {
+        VRQuestNavigatorBridge.setIntent(scene, {
+          hdrEnabled,
+          pbrEnabled,
+          bloomEnabled,
+          shadowsEnabled,
+          multisamplingEnabled,
+          vrModeEnabled,
+          passthroughEnabled,
+          handTrackingEnabled,
+          onExitViro,
+          debug,
+        });
+      }
+      VRQuestNavigatorBridge.setVRActive(true);
+      VRLauncher?.launchVRScene?.();
+
+      const sub = AppState.addEventListener("change", (nextState) => {
+        const prev = appStateRef.current;
+        appStateRef.current = nextState;
+        if (prev === "active" && nextState !== "active") {
+          leftActiveAtRef.current = Date.now();
+        }
+        // Re-launch VR when the app returns from being backgrounded by the system
+        // (Quest menu, home, recents). Explicit exitVRScene() clears isVRActive()
+        // before finishing VRActivity, so Activity-transition-driven background→active
+        // cycles are ignored here.
+        if (prev !== "active" && nextState === "active" && VRQuestNavigatorBridge.isVRActive()) {
+          // Skip if we were only briefly out of "active" — that's a racy
+          // dual-Activity ReactHost bounce, not a genuine menu return.
+          const backgroundedFor = Date.now() - leftActiveAtRef.current;
+          if (leftActiveAtRef.current > 0 && backgroundedFor < 1500) return;
+          VRQuestNavigatorBridge.setVRActive(true);
+          VRLauncher?.launchVRScene?.();
+        }
+      });
+      return () => sub.remove();
+    }, []);
+
+    // Quest renders nothing here — VRActivity owns the display.
+    if (isQuest) return null;
+
+    const scene = arInitialScene ?? initialScene;
+    if (!scene) {
+      console.warn(
+        "[Viro] ViroXRSceneNavigator requires `arInitialScene` or `initialScene`."
+      );
+      return null;
+    }
+    return (
+      <ViroARSceneNavigator
+        ref={arRef}
+        initialScene={scene}
+        {...rest}
+      />
+    );
+  }
+);

package/components/VisionOS/ViroVisionOSModule.ts

@@ -0,0 +1,93 @@
+/**
+ * ViroVisionOSModule
+ *
+ * JavaScript API for controlling the visionOS ImmersiveSpace.
+ * On iOS / Android the calls are no-ops (module returns false / resolves silently).
+ *
+ * ── Host-app setup required ──────────────────────────────────────────────────
+ *
+ * 1. Add the ImmersiveSpace to your SwiftUI App struct (visionOS only):
+ *
+ *    #if os(visionOS)
+ *    import ViroReact
+ *    #endif
+ *
+ *    @main struct MyApp: App {
+ *      var body: some Scene {
+ *        WindowGroup {
+ *          ContentView()
+ *            #if os(visionOS)
+ *            .viroImmersiveSpaceController()
+ *            #endif
+ *        }
+ *        #if os(visionOS)
+ *        ImmersiveSpace(id: "ViroImmersive") {
+ *          ViroImmersiveSpaceView()
+ *        }
+ *        .immersionStyle(selection: .constant(.mixed), in: .mixed, .full, .progressive)
+ *        #endif
+ *      }
+ *    }
+ *
+ * 2. Call from JavaScript:
+ *
+ *    import { ViroVisionOSModule } from '@reactvision/react-viro';
+ *
+ *    await ViroVisionOSModule.enterImmersiveSpace('mixed');
+ *    // ... render Viro scene inside ImmersiveSpace ...
+ *    await ViroVisionOSModule.exitImmersiveSpace();
+ * ─────────────────────────────────────────────────────────────────────────────
+ */
+
+import { NativeModules, Platform } from "react-native";
+
+export type ImmersiveSpaceStyle = "mixed" | "full" | "progressive";
+
+/** @internal — raw NativeModule reference */
+const { VRTVisionOSModule } = NativeModules;
+
+/**
+ * Returns true if the app is running on Apple Vision Pro (visionOS).
+ * Uses the native module constant; falls back to Platform.isVision when
+ * available (React Native 0.83+).
+ */
+export function isVisionOS(): boolean {
+  // React Native 0.83+ exposes Platform.isVision on visionOS builds.
+  if ((Platform as any).isVision === true) return true;
+  // Fallback: check the native module constant.
+  return VRTVisionOSModule?.isVisionOS === true;
+}
+
+/**
+ * Opens the Viro ImmersiveSpace on visionOS.
+ *
+ * @param style  "mixed" (default) — virtual content blended over passthrough
+ *               "full"  — fully virtual, passthrough hidden
+ *               "progressive" — graduated immersion with crown dial
+ */
+export async function enterImmersiveSpace(
+  style: ImmersiveSpaceStyle = "mixed"
+): Promise<boolean> {
+  if (!VRTVisionOSModule) {
+    if (__DEV__) {
+      console.warn("[Viro] VRTVisionOSModule not available on this platform");
+    }
+    return false;
+  }
+  return VRTVisionOSModule.enterImmersiveSpace(style);
+}
+
+/**
+ * Dismisses the Viro ImmersiveSpace and returns to the window layer.
+ */
+export async function exitImmersiveSpace(): Promise<boolean> {
+  if (!VRTVisionOSModule) return false;
+  return VRTVisionOSModule.exitImmersiveSpace();
+}
+
+/** Convenience object matching the typical NativeModules pattern. */
+export const ViroVisionOSModule = {
+  isVisionOS,
+  enterImmersiveSpace,
+  exitImmersiveSpace,
+} as const;

package/dist/components/AR/ViroARCamera.d.ts

@@ -3,5 +3,5 @@ import { ViewProps } from "react-native";
 import { ViroCamera } from "../ViroCamera";
 export declare class ViroARCamera extends React.Component<ViewProps> {
     _component: ViroCamera | null;
-    render(): React.JSX.Element;
+    render(): React.JSX.Element | null;
 }

package/dist/components/AR/ViroARCamera.js

@@ -47,9 +47,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ViroARCamera = void 0;
 const React = __importStar(require("react"));
 const ViroCamera_1 = require("../ViroCamera");
+const ViroPlatform_1 = require("../Utilities/ViroPlatform");
 class ViroARCamera extends React.Component {
     _component = null;
     render() {
+        if (ViroPlatform_1.isQuest) {
+            console.warn("[Viro] ViroARCamera is not supported on Quest and will not render.");
+            return null;
+        }
         // Uncomment this to check props
         return (<ViroCamera_1.ViroCamera ref={(component) => {
                 this._component = component;

package/dist/components/AR/ViroARImageMarker.d.ts

@@ -19,5 +19,5 @@ export declare class ViroARImageMarker extends ViroBase<{}> {
     _onAnchorFound: (event: NativeSyntheticEvent<ViroARAnchorFoundEvent>) => void;
     _onAnchorUpdated: (event: NativeSyntheticEvent<ViroARAnchorUpdatedEvent>) => void;
     _onAnchorRemoved: (_event: NativeSyntheticEvent<ViroARAnchorRemovedEvent>) => void;
-    render(): React.JSX.Element;
+    render(): React.JSX.Element | null;
 }

package/dist/components/AR/ViroARImageMarker.js

@@ -47,6 +47,7 @@ exports.ViroARImageMarker = void 0;
 const React = __importStar(require("react"));
 const react_native_1 = require("react-native");
 const ViroBase_1 = require("../ViroBase");
+const ViroPlatform_1 = require("../Utilities/ViroPlatform");
 /**
  * Container for Viro Components anchored to a detected image.
  */
@@ -67,6 +68,10 @@ class ViroARImageMarker extends ViroBase_1.ViroBase {
         }
     };
     render() {
+        if (ViroPlatform_1.isQuest) {
+            console.warn("[Viro] ViroARImageMarker is not supported on Quest and will not render.");
+            return null;
+        }
         // Uncomment this line to check for misnamed props
         //checkMisnamedProps("ViroARImageMarker", this.props);
         let timeToFuse = undefined;

package/dist/components/AR/ViroARObjectMarker.d.ts

@@ -20,6 +20,6 @@ export declare class ViroARObjectMarker extends ViroBase<Props> {
     _onAnchorFound(event: NativeSyntheticEvent<ViroARAnchorFoundEvent>): void;
     _onAnchorUpdated(event: NativeSyntheticEvent<ViroARAnchorUpdatedEvent>): void;
     _onAnchorRemoved(_event: NativeSyntheticEvent<ViroARAnchorRemovedEvent>): void;
-    render(): React.JSX.Element;
+    render(): React.JSX.Element | null;
 }
 export {};

package/dist/components/AR/ViroARObjectMarker.js

@@ -47,6 +47,7 @@ exports.ViroARObjectMarker = void 0;
 const ViroBase_1 = require("../ViroBase");
 const React = __importStar(require("react"));
 const react_native_1 = require("react-native");
+const ViroPlatform_1 = require("../Utilities/ViroPlatform");
 /**
  * Container for Viro Components anchored to a detected object.
  */
@@ -67,6 +68,10 @@ class ViroARObjectMarker extends ViroBase_1.ViroBase {
         }
     }
     render() {
+        if (ViroPlatform_1.isQuest) {
+            console.warn("[Viro] ViroARObjectMarker is not supported on Quest and will not render.");
+            return null;
+        }
         // Uncomment this line to check for misnamed props
         //checkMisnamedProps("ViroARObjectMarker", this.props);
         let timeToFuse = undefined;

package/dist/components/AR/ViroARPlane.d.ts

@@ -25,6 +25,6 @@ export declare class ViroARPlane extends ViroBase<Props> {
     _onAnchorFound: (event: NativeSyntheticEvent<ViroARAnchorFoundEvent>) => void;
     _onAnchorUpdated: (event: NativeSyntheticEvent<ViroARAnchorUpdatedEvent>) => void;
     _onAnchorRemoved: (_event: NativeSyntheticEvent<ViroARAnchorRemovedEvent>) => void;
-    render(): React.JSX.Element;
+    render(): React.JSX.Element | null;
 }
 export {};

package/dist/components/AR/ViroARPlane.js

@@ -47,6 +47,7 @@ exports.ViroARPlane = void 0;
 const ViroBase_1 = require("../ViroBase");
 const React = __importStar(require("react"));
 const react_native_1 = require("react-native");
+const ViroPlatform_1 = require("../Utilities/ViroPlatform");
 /**
  * Container for Viro Components anchored to a detected plane.
  */
@@ -67,6 +68,10 @@ class ViroARPlane extends ViroBase_1.ViroBase {
         }
     };
     render() {
+        if (ViroPlatform_1.isQuest) {
+            console.warn("[Viro] ViroARPlane is not supported on Quest and will not render.");
+            return null;
+        }
         // Uncomment this line to check for misnamed props
         //checkMisnamedProps("ViroARPlane", this.props);
         let timeToFuse = undefined;