@reactvision/react-viro 2.43.1 → 2.43.4

package/fabric-interop/ViroEventsManager.js

@@ -1,257 +0,0 @@
-/**
- * ViroEventsManager.js
- * JavaScript integration for ViroEventsTurboModule
- *
- * This module provides the JavaScript interface for handling
- * Viro JSI events through the TurboModule system
- */
-
-import { NativeEventEmitter, NativeModules } from "react-native";
-import ViroEventsTurboModule from "./specs/ViroEventsTurboModule";
-
-class ViroEventsManager {
-  constructor() {
-    this.eventEmitter = new NativeEventEmitter(ViroEventsTurboModule);
-    this.listeners = new Map();
-    this.callbackRegistry = new Map();
-
-    // Set up event listeners
-    this.setupEventListeners();
-  }
-
-  setupEventListeners() {
-    // Listen for JSI callbacks
-    this.eventEmitter.addListener("ViroJSICallback", (event) => {
-      this.handleJSICallback(event);
-    });
-
-    // Listen for node events
-    this.eventEmitter.addListener("ViroNodeEvent", (event) => {
-      this.handleNodeEvent(event);
-    });
-
-    // Listen for scene events
-    this.eventEmitter.addListener("ViroSceneEvent", (event) => {
-      this.handleSceneEvent(event);
-    });
-  }
-
-  /**
-   * Register a callback for JSI events
-   * @param {string} callbackId - The callback ID from JSI
-   * @param {function} callback - The JavaScript callback function
-   */
-  registerJSICallback(callbackId, callback) {
-    if (typeof callback === "function") {
-      this.callbackRegistry.set(callbackId, callback);
-      console.log(`[ViroEventsManager] Registered JSI callback: ${callbackId}`);
-    } else {
-      console.warn(
-        `[ViroEventsManager] Invalid callback for ID: ${callbackId}`
-      );
-    }
-  }
-
-  /**
-   * Unregister a JSI callback
-   * @param {string} callbackId - The callback ID to remove
-   */
-  unregisterJSICallback(callbackId) {
-    if (this.callbackRegistry.has(callbackId)) {
-      this.callbackRegistry.delete(callbackId);
-      console.log(
-        `[ViroEventsManager] Unregistered JSI callback: ${callbackId}`
-      );
-    }
-  }
-
-  /**
-   * Register a listener for node events
-   * @param {string} nodeId - The node ID
-   * @param {string} eventName - The event name
-   * @param {function} callback - The callback function
-   */
-  registerNodeEventListener(nodeId, eventName, callback) {
-    const key = `${nodeId}.${eventName}`;
-    this.listeners.set(key, callback);
-    console.log(`[ViroEventsManager] Registered node event listener: ${key}`);
-  }
-
-  /**
-   * Register a listener for scene events
-   * @param {string} sceneId - The scene ID
-   * @param {string} eventName - The event name
-   * @param {function} callback - The callback function
-   */
-  registerSceneEventListener(sceneId, eventName, callback) {
-    const key = `scene.${sceneId}.${eventName}`;
-    this.listeners.set(key, callback);
-    console.log(`[ViroEventsManager] Registered scene event listener: ${key}`);
-  }
-
-  /**
-   * Handle JSI callback events
-   * @private
-   */
-  handleJSICallback(event) {
-    const { callbackId, eventData, timestamp } = event;
-
-    console.log(
-      `[ViroEventsManager] Received JSI callback: ${callbackId}`,
-      eventData
-    );
-
-    const callback = this.callbackRegistry.get(callbackId);
-    if (callback) {
-      try {
-        callback(eventData);
-      } catch (error) {
-        console.error(
-          `[ViroEventsManager] Error executing JSI callback ${callbackId}:`,
-          error
-        );
-      }
-    } else {
-      console.warn(
-        `[ViroEventsManager] No callback registered for ID: ${callbackId}`
-      );
-    }
-  }
-
-  /**
-   * Handle node events
-   * @private
-   */
-  handleNodeEvent(event) {
-    const { nodeId, eventName, eventData, timestamp } = event;
-    const key = `${nodeId}.${eventName}`;
-
-    console.log(`[ViroEventsManager] Received node event: ${key}`, eventData);
-
-    const callback = this.listeners.get(key);
-    if (callback) {
-      try {
-        callback(eventData);
-      } catch (error) {
-        console.error(
-          `[ViroEventsManager] Error executing node event callback ${key}:`,
-          error
-        );
-      }
-    }
-  }
-
-  /**
-   * Handle scene events
-   * @private
-   */
-  handleSceneEvent(event) {
-    const { sceneId, eventName, eventData, timestamp } = event;
-    const key = `scene.${sceneId}.${eventName}`;
-
-    console.log(`[ViroEventsManager] Received scene event: ${key}`, eventData);
-
-    const callback = this.listeners.get(key);
-    if (callback) {
-      try {
-        callback(eventData);
-      } catch (error) {
-        console.error(
-          `[ViroEventsManager] Error executing scene event callback ${key}:`,
-          error
-        );
-      }
-    }
-  }
-
-  /**
-   * Check if the event system is ready
-   * @returns {boolean}
-   */
-  isEventSystemReady() {
-    try {
-      return ViroEventsTurboModule.isEventSystemReady();
-    } catch (error) {
-      console.error(
-        "[ViroEventsManager] Error checking event system status:",
-        error
-      );
-      return false;
-    }
-  }
-
-  /**
-   * Get the number of active listeners
-   * @returns {number}
-   */
-  getActiveListenerCount() {
-    try {
-      return ViroEventsTurboModule.getActiveListenerCount();
-    } catch (error) {
-      console.error("[ViroEventsManager] Error getting listener count:", error);
-      return 0;
-    }
-  }
-
-  /**
-   * Manually emit a JSI callback (for testing)
-   * @param {string} callbackId - The callback ID
-   * @param {object} eventData - The event data
-   */
-  emitJSICallback(callbackId, eventData = {}) {
-    try {
-      ViroEventsTurboModule.emitJSICallback(callbackId, eventData);
-    } catch (error) {
-      console.error("[ViroEventsManager] Error emitting JSI callback:", error);
-    }
-  }
-
-  /**
-   * Manually emit a node event (for testing)
-   * @param {string} nodeId - The node ID
-   * @param {string} eventName - The event name
-   * @param {object} eventData - The event data
-   */
-  emitNodeEvent(nodeId, eventName, eventData = {}) {
-    try {
-      ViroEventsTurboModule.emitNodeEvent(nodeId, eventName, eventData);
-    } catch (error) {
-      console.error("[ViroEventsManager] Error emitting node event:", error);
-    }
-  }
-
-  /**
-   * Manually emit a scene event (for testing)
-   * @param {string} sceneId - The scene ID
-   * @param {string} eventName - The event name
-   * @param {object} eventData - The event data
-   */
-  emitSceneEvent(sceneId, eventName, eventData = {}) {
-    try {
-      ViroEventsTurboModule.emitSceneEvent(sceneId, eventName, eventData);
-    } catch (error) {
-      console.error("[ViroEventsManager] Error emitting scene event:", error);
-    }
-  }
-
-  /**
-   * Clean up all listeners and callbacks
-   */
-  cleanup() {
-    console.log("[ViroEventsManager] Cleaning up event manager");
-
-    // Remove all event listeners
-    this.eventEmitter.removeAllListeners("ViroJSICallback");
-    this.eventEmitter.removeAllListeners("ViroNodeEvent");
-    this.eventEmitter.removeAllListeners("ViroSceneEvent");
-
-    // Clear registries
-    this.listeners.clear();
-    this.callbackRegistry.clear();
-
-    console.log("[ViroEventsManager] Event manager cleanup completed");
-  }
-}
-
-// Export singleton instance
-export default new ViroEventsManager();

package/fabric-interop/ViroFabricContainer.tsx

@@ -1,273 +0,0 @@
-/**
- * ViroFabricContainer
- *
- * This is the main container component that Fabric manages directly.
- * It serves as a viewport for the Viro rendering engine and delegates
- * rendering to the existing native implementation.
- */
-
-import React, { useEffect, useRef, useState } from "react";
-import {
-  requireNativeComponent,
-  UIManager,
-  findNodeHandle,
-  Platform,
-  View,
-  Text,
-  NativeEventEmitter,
-  NativeModules,
-} from "react-native";
-
-// Check if New Architecture is enabled
-const isNewArchitectureEnabled = () => {
-  if (global.__turboModuleProxy == null) {
-    throw new Error(
-      "Viro: New Architecture is not enabled. This library requires React Native New Architecture. " +
-        "Please enable it in your app by following the instructions at: " +
-        "https://reactnative.dev/docs/new-architecture-intro"
-    );
-  }
-
-  // We're assuming the minimum supported version (0.76.9+) since this is a Fabric-only component
-  return true;
-};
-
-// Check if the component exists in UIManager
-const isFabricComponentAvailable = () => {
-  isNewArchitectureEnabled(); // This will throw if New Architecture is not enabled
-
-  if (
-    !UIManager.getViewManagerConfig ||
-    UIManager.getViewManagerConfig("ViroFabricContainerView") == null
-  ) {
-    throw new Error(
-      "ViroFabricContainerView is not available. Make sure you have installed the native module properly."
-    );
-  }
-
-  return true;
-};
-
-// Define the native component
-// @ts-ignore - TypeScript doesn't know about the props of the native component
-const NativeViroFabricContainer = requireNativeComponent<any>(
-  "ViroFabricContainerView"
-);
-
-// Props for the container
-export interface ViroFabricContainerProps {
-  // General props
-  debug?: boolean;
-  style?: React.CSSProperties;
-
-  // AR specific props
-  arEnabled?: boolean;
-  autofocus?: boolean;
-  worldAlignment?: "Gravity" | "GravityAndHeading" | "Camera";
-  videoQuality?: "High" | "Low";
-
-  // Event callbacks
-  onInitialized?: (success: boolean) => void;
-  onTrackingUpdated?: (state: any) => void;
-  onCameraTransformUpdate?: (transform: any) => void;
-  onARSessionFailed?: (error: string) => void;
-
-  // Scene management callbacks
-  onSceneStateChanged?: (event: { sceneId: string; state: string }) => void;
-  onMemoryWarning?: (event: { memoryStats: Record<string, any> }) => void;
-
-  // Children components
-  children?: React.ReactNode;
-}
-
-/**
- * ViroFabricContainer is the main component that hosts the Viro rendering engine.
- * It creates a native view that the Viro renderer can draw on and manages the
- * lifecycle of the Viro system.
- */
-export const ViroFabricContainer: React.FC<ViroFabricContainerProps> = ({
-  debug = false,
-  arEnabled = false,
-  worldAlignment = "Gravity",
-  onInitialized,
-  onTrackingUpdated,
-  onCameraTransformUpdate,
-  onSceneStateChanged,
-  onMemoryWarning,
-  children,
-}) => {
-  // Reference to the native component
-  const containerRef = useRef<any>(null);
-
-  // Root node ID for the scene
-  const rootNodeId = useRef<string>("viro_root_scene");
-
-  // Event callback registry
-  const eventCallbacks = useRef<Record<string, (event: any) => void>>({});
-
-  // Set up event handling for JSI and fallback event emitter approach
-  useEffect(() => {
-    // Set up global event handler for JSI events
-    if (typeof global !== "undefined") {
-      // @ts-ignore - This property will be added by the native code
-      global.handleViroEvent = (callbackId: string, eventData: any) => {
-        // Find the callback in the registry and call it
-        const callback = eventCallbacks.current[callbackId];
-        if (callback) {
-          callback(eventData);
-        } else {
-          console.warn(`No callback found for ID: ${callbackId}`);
-        }
-      };
-    }
-
-    // Set up event emitter for fallback approach
-    const eventEmitter = new NativeEventEmitter(
-      NativeModules.ViroFabricManager
-    );
-
-    // Add the ViroEvent listener
-    const subscription = eventEmitter.addListener("ViroEvent", (event) => {
-      const { callbackId, data } = event;
-      const callback = eventCallbacks.current[callbackId];
-      if (callback) {
-        callback(data);
-      } else {
-        console.warn(
-          `No callback found for ID: ${callbackId} (via event emitter)`
-        );
-      }
-    });
-
-    return () => {
-      // Clean up event subscription
-      subscription.remove();
-
-      // Clean up global event handler
-      if (typeof global !== "undefined") {
-        // @ts-ignore - This property was added by us
-        delete global.handleViroEvent;
-      }
-    };
-  }, []);
-
-  // Initialize the Viro system when the component mounts
-  useEffect(() => {
-    if (containerRef.current && isFabricComponentAvailable()) {
-      const nodeHandle = findNodeHandle(containerRef.current);
-      if (!nodeHandle) {
-        console.error("Failed to get node handle for ViroFabricContainer");
-        return;
-      }
-
-      try {
-        // Use the codegenNativeCommands approach for New Architecture
-        const ViroFabricContainerCommands = UIManager.getViewManagerConfig(
-          "ViroFabricContainerView"
-        ).Commands;
-
-        if (!ViroFabricContainerCommands) {
-          console.error(
-            "ViroFabricContainerView commands not found in UIManager"
-          );
-          return;
-        }
-
-        // Call the native method to initialize
-        UIManager.dispatchViewManagerCommand(
-          nodeHandle,
-          ViroFabricContainerCommands.initialize,
-          [debug || false, arEnabled || false, worldAlignment || "Gravity"]
-        );
-      } catch (error) {
-        console.error("Failed to initialize ViroFabricContainer:", error);
-      }
-    }
-
-    // Cleanup when unmounting
-    return () => {
-      if (containerRef.current) {
-        const nodeHandle = findNodeHandle(containerRef.current);
-        if (!nodeHandle) return;
-
-        try {
-          // Use the same approach as initialize for cleanup
-          const ViroFabricContainerCommands = UIManager.getViewManagerConfig(
-            "ViroFabricContainerView"
-          ).Commands;
-
-          if (
-            !ViroFabricContainerCommands ||
-            !ViroFabricContainerCommands.cleanup
-          ) {
-            console.error(
-              "ViroFabricContainerView cleanup command not found in UIManager"
-            );
-            return;
-          }
-
-          // Call the native method to cleanup
-          UIManager.dispatchViewManagerCommand(
-            nodeHandle,
-            ViroFabricContainerCommands.cleanup,
-            []
-          );
-        } catch (error) {
-          console.error("Failed to cleanup ViroFabricContainer:", error);
-        }
-      }
-    };
-  }, [debug, arEnabled, worldAlignment]);
-
-  // Handle initialization event
-  const handleInitialized = (event: any) => {
-    if (onInitialized) {
-      onInitialized(event.nativeEvent.success);
-    }
-  };
-
-  // Handle tracking updated event
-  const handleTrackingUpdated = (event: any) => {
-    if (onTrackingUpdated) {
-      onTrackingUpdated(event.nativeEvent);
-    }
-  };
-
-  // Handle camera transform update event
-  const handleCameraTransformUpdate = (event: any) => {
-    if (onCameraTransformUpdate) {
-      onCameraTransformUpdate(event.nativeEvent);
-    }
-  };
-
-  // Handle scene state changed event
-  const handleSceneStateChanged = (event: any) => {
-    if (onSceneStateChanged) {
-      onSceneStateChanged(event.nativeEvent);
-    }
-  };
-
-  // Handle memory warning event
-  const handleMemoryWarning = (event: any) => {
-    if (onMemoryWarning) {
-      onMemoryWarning(event.nativeEvent);
-    }
-  };
-
-  // This will throw an error if the native component is not available or New Architecture is not enabled
-  isFabricComponentAvailable();
-
-  return (
-    <NativeViroFabricContainer
-      ref={containerRef}
-      style={{ flex: 1 }}
-      onInitialized={handleInitialized}
-      onTrackingUpdated={handleTrackingUpdated}
-      onCameraTransformUpdate={handleCameraTransformUpdate}
-      onSceneStateChanged={handleSceneStateChanged}
-      onMemoryWarning={handleMemoryWarning}
-    >
-      {children}
-    </NativeViroFabricContainer>
-  );
-};

package/fabric-interop/components/AR/ViroARPlane.tsx

@@ -1,108 +0,0 @@
-/**
- * ViroARPlane
- *
- * Container for Viro Components anchored to a detected plane.
- */
-
-import * as React from "react";
-import { useEffect, useState } from "react";
-import { ViroNode } from "../ViroNode";
-import { useViroNode } from "../ViroUtils";
-import {
-  registerEventListener,
-  unregisterEventListener,
-} from "../../NativeViro";
-import { ViroCommonProps, ViroObjectProps } from "./ViroCommonProps";
-import { ViroAnchorFoundMap, ViroAnchorUpdatedMap } from "../Types/ViroEvents";
-
-type Props = ViroCommonProps &
-  ViroObjectProps & {
-    anchorId?: string;
-    minHeight?: number;
-    minWidth?: number;
-    alignment?:
-      | "Horizontal"
-      | "HorizontalUpward"
-      | "HorizontalDownward"
-      | "Vertical";
-    onAnchorFound?: (anchorMap: ViroAnchorFoundMap) => void;
-    onAnchorUpdated?: (anchorMap: ViroAnchorUpdatedMap) => void;
-    onAnchorRemoved?: () => void;
-  };
-
-/**
- * Container for Viro Components anchored to a detected plane.
- */
-export function ViroARPlane(props: Props): React.ReactElement {
-  const {
-    anchorId,
-    minHeight,
-    minWidth,
-    alignment,
-    onAnchorFound,
-    onAnchorUpdated,
-    onAnchorRemoved,
-    children,
-    ...rest
-  } = props;
-
-  // Create the node
-  const nodeProps = {
-    ...rest,
-    anchorId,
-    minHeight,
-    minWidth,
-    alignment,
-  };
-
-  const nodeId = useViroNode("arPlane", nodeProps);
-
-  // Set up event listeners
-  useEffect(() => {
-    const anchorFoundCallbackId = onAnchorFound
-      ? registerEventListener(nodeId, "onAnchorFound", (event) => {
-          onAnchorFound(event.anchorFoundMap);
-        })
-      : null;
-
-    const anchorUpdatedCallbackId = onAnchorUpdated
-      ? registerEventListener(nodeId, "onAnchorUpdated", (event) => {
-          onAnchorUpdated(event.anchorUpdatedMap);
-        })
-      : null;
-
-    const anchorRemovedCallbackId = onAnchorRemoved
-      ? registerEventListener(nodeId, "onAnchorRemoved", () => {
-          onAnchorRemoved();
-        })
-      : null;
-
-    // Clean up event listeners
-    return () => {
-      if (anchorFoundCallbackId) {
-        unregisterEventListener(nodeId, "onAnchorFound", anchorFoundCallbackId);
-      }
-      if (anchorUpdatedCallbackId) {
-        unregisterEventListener(
-          nodeId,
-          "onAnchorUpdated",
-          anchorUpdatedCallbackId
-        );
-      }
-      if (anchorRemovedCallbackId) {
-        unregisterEventListener(
-          nodeId,
-          "onAnchorRemoved",
-          anchorRemovedCallbackId
-        );
-      }
-    };
-  }, [nodeId, onAnchorFound, onAnchorUpdated, onAnchorRemoved]);
-
-  // Render children within this node
-  return (
-    <ViroNode viroTag={nodeId} position={[0, 0, 0]}>
-      {children}
-    </ViroNode>
-  );
-}