@reactvision/react-viro 2.43.0 → 2.43.1

package/dist/fabric-interop/NativeViro.js

@@ -0,0 +1,262 @@
+"use strict";
+/**
+ * NativeViro - JSI Bridge Functions
+ *
+ * This module provides direct JSI functions to communicate with the native Viro implementation.
+ * These functions bypass the React Native bridge and codegen, providing direct access to
+ * the existing native implementation.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCallbackId = exports.generateNodeId = void 0;
+exports.handleViroEvent = handleViroEvent;
+exports.registerEventListener = registerEventListener;
+exports.unregisterEventListener = unregisterEventListener;
+exports.initializeViro = initializeViro;
+exports.createScene = createScene;
+exports.activateScene = activateScene;
+exports.deactivateScene = deactivateScene;
+exports.destroyScene = destroyScene;
+exports.getSceneState = getSceneState;
+exports.getMemoryStats = getMemoryStats;
+exports.performMemoryCleanup = performMemoryCleanup;
+exports.createNode = createNode;
+exports.updateNode = updateNode;
+exports.deleteNode = deleteNode;
+exports.addChild = addChild;
+exports.removeChild = removeChild;
+exports.createMaterial = createMaterial;
+exports.updateMaterial = updateMaterial;
+exports.createAnimation = createAnimation;
+exports.executeAnimation = executeAnimation;
+exports.setARPlaneDetection = setARPlaneDetection;
+exports.setARImageTargets = setARImageTargets;
+exports.isViroJSIAvailable = isViroJSIAvailable;
+// The global NativeViro object is injected by the native code
+// Note: The type declaration is in the generated .d.ts file
+// We don't redeclare it here to avoid conflicts
+// Additional methods that may not be in the type declaration
+// These are accessed using type assertions in the components
+// - recenterTracking(nodeId: string): void
+// - project(nodeId: string, point: [number, number, number]): Promise<[number, number, number]>
+// - unproject(nodeId: string, point: [number, number, number]): Promise<[number, number, number]>
+// Event callback registry
+const eventCallbacks = {};
+// Generate a unique ID for nodes
+let nextNodeId = 1;
+const generateNodeId = () => `viro_node_${nextNodeId++}`;
+exports.generateNodeId = generateNodeId;
+// Generate a unique ID for callbacks
+let nextCallbackId = 1;
+const generateCallbackId = () => `viro_callback_${nextCallbackId++}`;
+exports.generateCallbackId = generateCallbackId;
+// Event handler that receives events from native code
+function handleViroEvent(callbackId, event) {
+    const callback = eventCallbacks[callbackId];
+    if (callback) {
+        callback(event);
+    }
+    else {
+        console.warn(`No callback found for ID: ${callbackId}`);
+    }
+}
+// Set up the global event handler
+if (typeof global !== "undefined") {
+    // @ts-ignore - This property will be added by the native code
+    global.handleViroEvent = handleViroEvent;
+}
+const ViroGlobal_1 = require("./components/ViroGlobal");
+// Register a JS callback for native events
+function registerEventListener(nodeId, eventName, callback) {
+    const callbackId = (0, exports.generateCallbackId)();
+    eventCallbacks[callbackId] = callback;
+    // Register with native code
+    const nativeViro = (0, ViroGlobal_1.getNativeViro)();
+    if (nativeViro) {
+        nativeViro.registerEventCallback(nodeId, eventName, callbackId);
+    }
+    return callbackId;
+}
+// Unregister a callback
+function unregisterEventListener(nodeId, eventName, callbackId) {
+    delete eventCallbacks[callbackId];
+    // Unregister with native code
+    const nativeViro = (0, ViroGlobal_1.getNativeViro)();
+    if (nativeViro) {
+        nativeViro.unregisterEventCallback(nodeId, eventName, callbackId);
+    }
+}
+// Initialize the Viro platform
+function initializeViro(config) {
+    const nativeViro = (0, ViroGlobal_1.getNativeViro)();
+    if (nativeViro) {
+        return nativeViro.initialize(config);
+    }
+    return Promise.reject(new Error("NativeViro not available"));
+}
+// Scene Management Functions
+function createScene(sceneId, sceneType, props = {}) {
+    const nativeViro = (0, ViroGlobal_1.getNativeViro)();
+    if (nativeViro && nativeViro.createViroScene) {
+        nativeViro.createViroScene(sceneId, sceneType, props);
+    }
+    else {
+        console.warn("Scene management not available - createScene");
+    }
+}
+function activateScene(sceneId) {
+    const nativeViro = (0, ViroGlobal_1.getNativeViro)();
+    if (nativeViro && nativeViro.activateViroScene) {
+        nativeViro.activateViroScene(sceneId);
+    }
+    else {
+        console.warn("Scene management not available - activateScene");
+    }
+}
+function deactivateScene(sceneId) {
+    const nativeViro = (0, ViroGlobal_1.getNativeViro)();
+    if (nativeViro && nativeViro.deactivateViroScene) {
+        nativeViro.deactivateViroScene(sceneId);
+    }
+    else {
+        console.warn("Scene management not available - deactivateScene");
+    }
+}
+function destroyScene(sceneId) {
+    const nativeViro = (0, ViroGlobal_1.getNativeViro)();
+    if (nativeViro && nativeViro.destroyViroScene) {
+        nativeViro.destroyViroScene(sceneId);
+    }
+    else {
+        console.warn("Scene management not available - destroyScene");
+    }
+}
+function getSceneState(sceneId) {
+    const nativeViro = (0, ViroGlobal_1.getNativeViro)();
+    if (nativeViro && nativeViro.getViroSceneState) {
+        return nativeViro.getViroSceneState(sceneId);
+    }
+    return null;
+}
+function getMemoryStats() {
+    const nativeViro = (0, ViroGlobal_1.getNativeViro)();
+    if (nativeViro && nativeViro.getViroMemoryStats) {
+        return nativeViro.getViroMemoryStats();
+    }
+    return null;
+}
+function performMemoryCleanup() {
+    const nativeViro = (0, ViroGlobal_1.getNativeViro)();
+    if (nativeViro && nativeViro.performViroMemoryCleanup) {
+        nativeViro.performViroMemoryCleanup();
+    }
+    else {
+        console.warn("Memory management not available - performMemoryCleanup");
+    }
+}
+// Node Management Functions (enhanced)
+function createNode(nodeId, nodeType, props = {}) {
+    const nativeViro = (0, ViroGlobal_1.getNativeViro)();
+    if (nativeViro) {
+        nativeViro.createViroNode(nodeId, nodeType, props);
+    }
+    else {
+        console.warn("NativeViro not available - createNode");
+    }
+}
+function updateNode(nodeId, props) {
+    const nativeViro = (0, ViroGlobal_1.getNativeViro)();
+    if (nativeViro) {
+        nativeViro.updateViroNode(nodeId, props);
+    }
+    else {
+        console.warn("NativeViro not available - updateNode");
+    }
+}
+function deleteNode(nodeId) {
+    const nativeViro = (0, ViroGlobal_1.getNativeViro)();
+    if (nativeViro) {
+        nativeViro.deleteViroNode(nodeId);
+    }
+    else {
+        console.warn("NativeViro not available - deleteNode");
+    }
+}
+function addChild(parentId, childId) {
+    const nativeViro = (0, ViroGlobal_1.getNativeViro)();
+    if (nativeViro) {
+        nativeViro.addViroNodeChild(parentId, childId);
+    }
+    else {
+        console.warn("NativeViro not available - addChild");
+    }
+}
+function removeChild(parentId, childId) {
+    const nativeViro = (0, ViroGlobal_1.getNativeViro)();
+    if (nativeViro) {
+        nativeViro.removeViroNodeChild(parentId, childId);
+    }
+    else {
+        console.warn("NativeViro not available - removeChild");
+    }
+}
+// Material Management Functions (enhanced)
+function createMaterial(materialName, properties) {
+    const nativeViro = (0, ViroGlobal_1.getNativeViro)();
+    if (nativeViro) {
+        nativeViro.createViroMaterial(materialName, properties);
+    }
+    else {
+        console.warn("NativeViro not available - createMaterial");
+    }
+}
+function updateMaterial(materialName, properties) {
+    const nativeViro = (0, ViroGlobal_1.getNativeViro)();
+    if (nativeViro) {
+        nativeViro.updateViroMaterial(materialName, properties);
+    }
+    else {
+        console.warn("NativeViro not available - updateMaterial");
+    }
+}
+// Animation Management Functions (enhanced)
+function createAnimation(animationName, properties) {
+    const nativeViro = (0, ViroGlobal_1.getNativeViro)();
+    if (nativeViro) {
+        nativeViro.createViroAnimation(animationName, properties);
+    }
+    else {
+        console.warn("NativeViro not available - createAnimation");
+    }
+}
+function executeAnimation(nodeId, animationName, options = {}) {
+    const nativeViro = (0, ViroGlobal_1.getNativeViro)();
+    if (nativeViro) {
+        nativeViro.executeViroAnimation(nodeId, animationName, options);
+    }
+    else {
+        console.warn("NativeViro not available - executeAnimation");
+    }
+}
+// AR Configuration Functions (enhanced)
+function setARPlaneDetection(config) {
+    const nativeViro = (0, ViroGlobal_1.getNativeViro)();
+    if (nativeViro) {
+        nativeViro.setViroARPlaneDetection(config);
+    }
+    else {
+        console.warn("NativeViro not available - setARPlaneDetection");
+    }
+}
+function setARImageTargets(targets) {
+    const nativeViro = (0, ViroGlobal_1.getNativeViro)();
+    if (nativeViro) {
+        nativeViro.setViroARImageTargets(targets);
+    }
+    else {
+        console.warn("NativeViro not available - setARImageTargets");
+    }
+}
+// Check if the JSI interface is available
+function isViroJSIAvailable() {
+    return (0, ViroGlobal_1.isNativeViroAvailable)();
+}

package/dist/fabric-interop/ViroEventsManager.d.ts

@@ -0,0 +1,83 @@
+declare const _default: ViroEventsManager;
+export default _default;
+declare class ViroEventsManager {
+    eventEmitter: NativeEventEmitter;
+    listeners: Map<any, any>;
+    callbackRegistry: Map<any, any>;
+    setupEventListeners(): void;
+    /**
+     * Register a callback for JSI events
+     * @param {string} callbackId - The callback ID from JSI
+     * @param {function} callback - The JavaScript callback function
+     */
+    registerJSICallback(callbackId: string, callback: Function): void;
+    /**
+     * Unregister a JSI callback
+     * @param {string} callbackId - The callback ID to remove
+     */
+    unregisterJSICallback(callbackId: string): void;
+    /**
+     * 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: string, eventName: string, callback: Function): void;
+    /**
+     * 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: string, eventName: string, callback: Function): void;
+    /**
+     * Handle JSI callback events
+     * @private
+     */
+    private handleJSICallback;
+    /**
+     * Handle node events
+     * @private
+     */
+    private handleNodeEvent;
+    /**
+     * Handle scene events
+     * @private
+     */
+    private handleSceneEvent;
+    /**
+     * Check if the event system is ready
+     * @returns {boolean}
+     */
+    isEventSystemReady(): boolean;
+    /**
+     * Get the number of active listeners
+     * @returns {number}
+     */
+    getActiveListenerCount(): number;
+    /**
+     * Manually emit a JSI callback (for testing)
+     * @param {string} callbackId - The callback ID
+     * @param {object} eventData - The event data
+     */
+    emitJSICallback(callbackId: string, eventData?: object): void;
+    /**
+     * 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: string, eventName: string, eventData?: object): void;
+    /**
+     * 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: string, eventName: string, eventData?: object): void;
+    /**
+     * Clean up all listeners and callbacks
+     */
+    cleanup(): void;
+}
+import { NativeEventEmitter } from "react-native";

package/dist/fabric-interop/ViroEventsManager.js

@@ -0,0 +1,222 @@
+"use strict";
+/**
+ * ViroEventsManager.js
+ * JavaScript integration for ViroEventsTurboModule
+ *
+ * This module provides the JavaScript interface for handling
+ * Viro JSI events through the TurboModule system
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_native_1 = require("react-native");
+const ViroEventsTurboModule_1 = __importDefault(require("./specs/ViroEventsTurboModule"));
+class ViroEventsManager {
+    constructor() {
+        this.eventEmitter = new react_native_1.NativeEventEmitter(ViroEventsTurboModule_1.default);
+        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_1.default.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_1.default.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_1.default.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_1.default.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_1.default.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
+exports.default = new ViroEventsManager();

package/dist/fabric-interop/ViroFabricContainer.d.ts

@@ -0,0 +1,34 @@
+/**
+ * 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 from "react";
+export interface ViroFabricContainerProps {
+    debug?: boolean;
+    style?: React.CSSProperties;
+    arEnabled?: boolean;
+    autofocus?: boolean;
+    worldAlignment?: "Gravity" | "GravityAndHeading" | "Camera";
+    videoQuality?: "High" | "Low";
+    onInitialized?: (success: boolean) => void;
+    onTrackingUpdated?: (state: any) => void;
+    onCameraTransformUpdate?: (transform: any) => void;
+    onARSessionFailed?: (error: string) => void;
+    onSceneStateChanged?: (event: {
+        sceneId: string;
+        state: string;
+    }) => void;
+    onMemoryWarning?: (event: {
+        memoryStats: Record<string, any>;
+    }) => void;
+    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 declare const ViroFabricContainer: React.FC<ViroFabricContainerProps>;