@reactvision/react-viro 2.43.0 → 2.43.1

package/dist/fabric-interop/components/AR/ViroARTrackingTargets.js

@@ -0,0 +1,85 @@
+"use strict";
+/**
+ * ViroARTrackingTargets
+ *
+ * A utility for registering AR tracking targets.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerTargets = registerTargets;
+exports.getTarget = getTarget;
+exports.getAllTargets = getAllTargets;
+exports.clearTargets = clearTargets;
+exports.deleteTarget = deleteTarget;
+const ViroGlobal_1 = require("../ViroGlobal");
+// Tracking target registry
+const targets = {};
+/**
+ * Register AR tracking targets with the Viro system.
+ * @param targetMap A map of target names to target definitions.
+ */
+function registerTargets(targetMap) {
+    // Add targets to the registry
+    Object.entries(targetMap).forEach(([name, definition]) => {
+        targets[name] = definition;
+    });
+    // Register with native code if available
+    const nativeViro = (0, ViroGlobal_1.getNativeViro)();
+    if (nativeViro) {
+        nativeViro.setViroARImageTargets(targets);
+    }
+}
+/**
+ * Get a tracking target by name.
+ * @param name The name of the tracking target.
+ * @returns The tracking target definition, or undefined if not found.
+ */
+function getTarget(name) {
+    return targets[name];
+}
+/**
+ * Get all registered tracking targets.
+ * @returns A map of tracking target names to tracking target definitions.
+ */
+function getAllTargets() {
+    return { ...targets };
+}
+/**
+ * Clear all registered tracking targets.
+ */
+function clearTargets() {
+    // Clear the registry
+    Object.keys(targets).forEach((key) => {
+        delete targets[key];
+    });
+    // Clear native code if available
+    const nativeViro = (0, ViroGlobal_1.getNativeViro)();
+    if (nativeViro) {
+        nativeViro.setViroARImageTargets({});
+    }
+}
+/**
+ * Delete a specific tracking target.
+ * @param targetName The name of the tracking target to delete.
+ */
+function deleteTarget(targetName) {
+    // Remove the target from the registry
+    delete targets[targetName];
+    // Update native code if available
+    const nativeViro = (0, ViroGlobal_1.getNativeViro)();
+    if (nativeViro) {
+        // Since there's no direct method to delete a single target,
+        // we re-register all remaining targets
+        nativeViro.setViroARImageTargets(targets);
+    }
+}
+// Export the tracking targets object as the default export
+const ViroARTrackingTargets = {
+    registerTargets,
+    getTarget,
+    getAllTargets,
+    clearTargets,
+    deleteTarget,
+    // Add createTargets as an alias for registerTargets for backward compatibility
+    createTargets: registerTargets,
+};
+exports.default = ViroARTrackingTargets;

package/dist/fabric-interop/components/AR/ViroCommonProps.d.ts

@@ -0,0 +1,91 @@
+/**
+ * ViroCommonProps
+ *
+ * Common props for AR components.
+ */
+import { ViewProps } from "react-native";
+import { ViroEventHandler } from "../ViroUtils";
+import { ViroAnchor, ViroAnchorFoundMap, ViroAnchorUpdatedMap, ViroClickState, ViroPinchState, ViroRotateState } from "../Types/ViroEvents";
+import { Viro3DPoint, ViroPhysicsBody, ViroRotation, ViroScale, ViroSource } from "../Types/ViroUtils";
+export type ViroCommonProps = ViewProps & {
+    target?: string;
+    pauseUpdates?: boolean;
+    renderingOrder?: number;
+    visible?: boolean;
+    opacity?: number;
+    ignoreEventHandling?: boolean;
+    dragType?: "FixedDistance" | "FixedDistanceOrigin" | "FixedToWorld" | "FixedToPlane";
+    dragPlane?: {
+        planePoint: Viro3DPoint;
+        planeNormal: Viro3DPoint;
+        maxDistance: number;
+    };
+    onHover?: (isHovering: boolean, position: Viro3DPoint, source: ViroSource) => void;
+    onClick?: (position: Viro3DPoint, source: ViroSource) => void;
+    onClickState?: (clickState: ViroClickState, position: Viro3DPoint, source: ViroSource) => void;
+    onTouch?: (touchState: any, touchPos: Viro3DPoint, source: ViroSource) => void;
+    onScroll?: (scrollPos: Viro3DPoint, source: ViroSource) => void;
+    onSwipe?: (swipeState: any, source: ViroSource) => void;
+    onDrag?: (dragToPos: Viro3DPoint, source: ViroSource) => void;
+    onPinch?: (pinchState: ViroPinchState, scaleFactor: number, source: ViroSource) => void;
+    onRotate?: (rotateState: ViroRotateState, rotationFactor: number, source: ViroSource) => void;
+    onFuse?: {
+        callback: (source: any) => void;
+        timeToFuse?: number;
+    } | ((source: any) => void);
+    onCollision?: (viroTag: string, collidedPoint: Viro3DPoint, collidedNormal: Viro3DPoint) => void;
+    viroTag?: string;
+    onAnchorFound?: (anchorFoundMap: ViroAnchorFoundMap) => void;
+    onAnchorUpdated?: (anchorUpdatedMap: ViroAnchorUpdatedMap) => void;
+    onAnchorRemoved?: ((event?: ViroAnchor) => void) | (() => void);
+    onError?: ViroEventHandler;
+};
+export type ViroObjectProps = {
+    position?: Viro3DPoint;
+    scale?: ViroScale;
+    rotation?: ViroRotation;
+    scalePivot?: Viro3DPoint;
+    rotationPivot?: Viro3DPoint;
+    renderingOrder?: number;
+    visible?: boolean;
+    opacity?: number;
+    width?: number;
+    height?: number;
+    length?: number;
+    materials?: ViroSource[] | string | string[];
+    animation?: {
+        name?: string;
+        delay?: number;
+        loop?: boolean;
+        onStart?: () => void;
+        onFinish?: () => void;
+        run?: boolean;
+        interruptible?: boolean;
+    };
+    transformBehaviors?: string | string[];
+    lightReceivingBitMask?: number;
+    shadowCastingBitMask?: number;
+    onTransformUpdate?: (position: Viro3DPoint) => void;
+    /**
+     * Enables high accuracy event collision checks for this object.
+     * This can be useful for complex 3D objects where the default
+     * checking method of bounding boxes do not provide adequate
+     * collision detection coverage.
+     *
+     * NOTE: Enabling high accuracy event collision checks has a high
+     * performance cost and should be used sparingly / only when
+     * necessary.
+     *
+     * Flag is set to false by default.
+     */
+    highAccuracyEvents?: boolean;
+    /**
+     * DEPRECATION WARNING - highAccuracyGaze has been deprecated, please use highAccuracyEvents instead
+     * @deprecated
+     */
+    highAccuracyGaze?: boolean;
+    physicsBody?: ViroPhysicsBody;
+    onCollision?: () => void;
+    onAnimationStartViro?: () => void;
+    onAnimationFinishViro?: () => void;
+};

package/dist/fabric-interop/components/AR/ViroCommonProps.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * ViroCommonProps
+ *
+ * Common props for AR components.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/fabric-interop/components/Animation/ViroAnimations.d.ts

@@ -0,0 +1,48 @@
+/**
+ * ViroAnimations
+ *
+ * A utility for creating and managing animations.
+ */
+export type ViroAnimationTimingFunction = "Linear" | "EaseIn" | "EaseOut" | "EaseInEaseOut" | "Bounce";
+export interface ViroAnimationDefinition {
+    properties: Record<string, any>;
+    duration?: number;
+    delay?: number;
+    loop?: boolean;
+    easing?: ViroAnimationTimingFunction;
+}
+/**
+ * Register animations with the Viro system.
+ * @param animationMap A map of animation names to animation definitions.
+ */
+export declare function registerAnimations(animationMap: Record<string, ViroAnimationDefinition>): void;
+/**
+ * Get an animation by name.
+ * @param name The name of the animation.
+ * @returns The animation definition, or undefined if not found.
+ */
+export declare function getAnimation(name: string): ViroAnimationDefinition | undefined;
+/**
+ * Get all registered animations.
+ * @returns A map of animation names to animation definitions.
+ */
+export declare function getAllAnimations(): Record<string, ViroAnimationDefinition>;
+/**
+ * Execute an animation on a node.
+ * @param nodeId The ID of the node to animate.
+ * @param animationName The name of the animation to execute.
+ * @param options Options for the animation execution.
+ */
+export declare function executeAnimation(nodeId: string, animationName: string, options?: {
+    loop?: boolean;
+    delay?: number;
+    onStart?: () => void;
+    onFinish?: () => void;
+}): void;
+declare const ViroAnimations: {
+    registerAnimations: typeof registerAnimations;
+    getAnimation: typeof getAnimation;
+    getAllAnimations: typeof getAllAnimations;
+    executeAnimation: typeof executeAnimation;
+};
+export default ViroAnimations;

package/dist/fabric-interop/components/Animation/ViroAnimations.js

@@ -0,0 +1,64 @@
+"use strict";
+/**
+ * ViroAnimations
+ *
+ * A utility for creating and managing animations.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerAnimations = registerAnimations;
+exports.getAnimation = getAnimation;
+exports.getAllAnimations = getAllAnimations;
+exports.executeAnimation = executeAnimation;
+const ViroGlobal_1 = require("../ViroGlobal");
+// Animation registry
+const animations = {};
+/**
+ * Register animations with the Viro system.
+ * @param animationMap A map of animation names to animation definitions.
+ */
+function registerAnimations(animationMap) {
+    // Add animations to the registry
+    Object.entries(animationMap).forEach(([name, definition]) => {
+        animations[name] = definition;
+        // Register with native code if available
+        const nativeViro = (0, ViroGlobal_1.getNativeViro)();
+        if (nativeViro) {
+            nativeViro.createViroAnimation(name, definition);
+        }
+    });
+}
+/**
+ * Get an animation by name.
+ * @param name The name of the animation.
+ * @returns The animation definition, or undefined if not found.
+ */
+function getAnimation(name) {
+    return animations[name];
+}
+/**
+ * Get all registered animations.
+ * @returns A map of animation names to animation definitions.
+ */
+function getAllAnimations() {
+    return { ...animations };
+}
+/**
+ * Execute an animation on a node.
+ * @param nodeId The ID of the node to animate.
+ * @param animationName The name of the animation to execute.
+ * @param options Options for the animation execution.
+ */
+function executeAnimation(nodeId, animationName, options = {}) {
+    const nativeViro = (0, ViroGlobal_1.getNativeViro)();
+    if (!nativeViro)
+        return;
+    nativeViro.executeViroAnimation(nodeId, animationName, options);
+}
+// Export the animations object as the default export
+const ViroAnimations = {
+    registerAnimations,
+    getAnimation,
+    getAllAnimations,
+    executeAnimation,
+};
+exports.default = ViroAnimations;

package/dist/fabric-interop/components/Material/ViroMaterials.d.ts

@@ -0,0 +1,66 @@
+/**
+ * ViroMaterials
+ *
+ * A utility for creating and managing materials.
+ */
+export interface ViroMaterialDefinition {
+    diffuseColor?: string;
+    diffuseTexture?: {
+        uri: string;
+    } | number;
+    roughness?: number;
+    metalness?: number;
+    roughnessMap?: {
+        uri: string;
+    } | number;
+    metalnessMap?: {
+        uri: string;
+    } | number;
+    normalMap?: {
+        uri: string;
+    } | number;
+    lightingModel?: "Constant" | "Lambert" | "Blinn" | "Phong" | "Physical";
+    shininess?: number;
+    fresnelExponent?: number;
+    transparency?: number;
+    wrapS?: "Clamp" | "Repeat" | "Mirror";
+    wrapT?: "Clamp" | "Repeat" | "Mirror";
+    shader?: string;
+    shaderParams?: Record<string, any>;
+}
+/**
+ * Register materials with the Viro system.
+ * @param materialMap A map of material names to material definitions.
+ */
+export declare function registerMaterials(materialMap: Record<string, ViroMaterialDefinition>): void;
+/**
+ * Get a material by name.
+ * @param name The name of the material.
+ * @returns The material definition, or undefined if not found.
+ */
+export declare function getMaterial(name: string): ViroMaterialDefinition | undefined;
+/**
+ * Get all registered materials.
+ * @returns A map of material names to material definitions.
+ */
+export declare function getAllMaterials(): Record<string, ViroMaterialDefinition>;
+/**
+ * Update a material.
+ * @param name The name of the material to update.
+ * @param definition The new material definition.
+ */
+export declare function updateMaterial(name: string, definition: ViroMaterialDefinition): void;
+/**
+ * Delete materials from the Viro system.
+ * @param materialNames An array of material names to delete.
+ */
+export declare function deleteMaterials(materialNames: string[]): void;
+declare const ViroMaterials: {
+    registerMaterials: typeof registerMaterials;
+    getMaterial: typeof getMaterial;
+    getAllMaterials: typeof getAllMaterials;
+    updateMaterial: typeof updateMaterial;
+    deleteMaterials: typeof deleteMaterials;
+    createMaterials: typeof registerMaterials;
+};
+export default ViroMaterials;

package/dist/fabric-interop/components/Material/ViroMaterials.js

@@ -0,0 +1,85 @@
+"use strict";
+/**
+ * ViroMaterials
+ *
+ * A utility for creating and managing materials.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerMaterials = registerMaterials;
+exports.getMaterial = getMaterial;
+exports.getAllMaterials = getAllMaterials;
+exports.updateMaterial = updateMaterial;
+exports.deleteMaterials = deleteMaterials;
+const ViroGlobal_1 = require("../ViroGlobal");
+// Material registry
+const materials = {};
+/**
+ * Register materials with the Viro system.
+ * @param materialMap A map of material names to material definitions.
+ */
+function registerMaterials(materialMap) {
+    // Add materials to the registry
+    Object.entries(materialMap).forEach(([name, definition]) => {
+        materials[name] = definition;
+        // Register with native code if available
+        const nativeViro = (0, ViroGlobal_1.getNativeViro)();
+        if (nativeViro) {
+            nativeViro.createViroMaterial(name, definition);
+        }
+    });
+}
+/**
+ * Get a material by name.
+ * @param name The name of the material.
+ * @returns The material definition, or undefined if not found.
+ */
+function getMaterial(name) {
+    return materials[name];
+}
+/**
+ * Get all registered materials.
+ * @returns A map of material names to material definitions.
+ */
+function getAllMaterials() {
+    return { ...materials };
+}
+/**
+ * Update a material.
+ * @param name The name of the material to update.
+ * @param definition The new material definition.
+ */
+function updateMaterial(name, definition) {
+    // Update the registry
+    materials[name] = { ...materials[name], ...definition };
+    // Update native code if available
+    const nativeViro = (0, ViroGlobal_1.getNativeViro)();
+    if (nativeViro) {
+        nativeViro.updateViroMaterial(name, definition);
+    }
+}
+/**
+ * Delete materials from the Viro system.
+ * @param materialNames An array of material names to delete.
+ */
+function deleteMaterials(materialNames) {
+    // Remove materials from the registry
+    materialNames.forEach((name) => {
+        delete materials[name];
+    });
+    // Note: In the Fabric implementation, there's no direct native method to delete materials
+    // This implementation just removes them from the JS registry
+    // If a native method becomes available in the future, it can be called here
+    console.warn("ViroMaterials.deleteMaterials: Material deletion from native code is not supported in the Fabric implementation. " +
+        "Materials are only removed from the JavaScript registry.");
+}
+// Export the materials object as the default export
+const ViroMaterials = {
+    registerMaterials,
+    getMaterial,
+    getAllMaterials,
+    updateMaterial,
+    deleteMaterials,
+    // Add createMaterials as an alias for registerMaterials for backward compatibility
+    createMaterials: registerMaterials,
+};
+exports.default = ViroMaterials;

package/dist/fabric-interop/components/Types/ViroEvents.d.ts

@@ -0,0 +1,202 @@
+/**
+ * ViroEvents
+ *
+ * Type definitions for Viro event handling.
+ */
+import { ViroRotation } from "../ViroUtils";
+export declare enum ViroClickStateTypes {
+    CLICK_DOWN = 1,
+    CLICK_UP = 2,
+    CLICKED = 3
+}
+export type ViroClickState = ViroClickStateTypes.CLICK_DOWN | ViroClickStateTypes.CLICK_UP | ViroClickStateTypes.CLICKED;
+export declare enum ViroPinchStateTypes {
+    PINCH_START = 1,
+    PINCH_MOVE = 2,
+    PINCH_END = 3
+}
+export type ViroPinchState = ViroPinchStateTypes.PINCH_START | ViroPinchStateTypes.PINCH_MOVE | ViroPinchStateTypes.PINCH_END;
+export declare enum ViroRotateStateTypes {
+    ROTATE_START = 1,
+    ROTATE_MOVE = 2,
+    ROTATE_END = 3
+}
+export type ViroRotateState = ViroRotateStateTypes.ROTATE_START | ViroRotateStateTypes.ROTATE_MOVE | ViroRotateStateTypes.ROTATE_END;
+export type ViroSource = any;
+export type Viro3DPoint = [number, number, number];
+export type ViroClickEvent = {
+    position: Viro3DPoint;
+    source: ViroSource;
+};
+export type ViroClickStateEvent = {
+    clickState: ViroClickState;
+    position: Viro3DPoint;
+    source: ViroSource;
+};
+export type ViroHoverEvent = {
+    isHovering: boolean;
+    position: Viro3DPoint;
+    source: ViroSource;
+};
+export type ViroTouchEvent = {
+    touchState: any;
+    touchPos: Viro3DPoint;
+    source: ViroSource;
+};
+export type ViroScrollEvent = {
+    scrollPos: Viro3DPoint;
+    source: ViroSource;
+};
+export type ViroSwipeEvent = {
+    swipeState: any;
+    source: ViroSource;
+};
+export type ViroFuseEvent = {
+    source: ViroSource;
+};
+export type ViroPinchEvent = {
+    pinchState: ViroPinchState;
+    scaleFactor: number;
+    source: ViroSource;
+};
+export type ViroRotateEvent = {
+    rotateState: ViroRotateState;
+    rotationFactor: number;
+    source: ViroSource;
+};
+export type ViroDragEvent = {
+    dragToPos: Viro3DPoint;
+    source: ViroSource;
+};
+export type ViroAnchor = any;
+export type ViroAnchorFoundMap = any;
+export type ViroAnchorUpdatedMap = any;
+export type ViroPlaneUpdatedMap = any;
+export type ViroPlaneUpdatedEvent = any;
+export type ViroARPlaneSizes = any;
+export type ViroARHitTestResult = any;
+export type ViroARPointCloud = any;
+export type ViroARAnchorFoundEvent = {
+    anchorFoundMap: ViroAnchorFoundMap;
+    anchor: ViroAnchor;
+};
+export type ViroARAnchorUpdatedEvent = {
+    anchorUpdatedMap: ViroAnchorUpdatedMap;
+    anchor: ViroAnchor;
+};
+export type ViroARAnchorRemovedEvent = {
+    anchor: ViroAnchor;
+};
+export type ViroCameraARHitTestEvent = {
+    hitTestResults: ViroARHitTestResult[];
+    cameraOrientation: number[];
+};
+export type ViroCameraARHitTest = {
+    hitTestResults: ViroARHitTestResult[];
+    cameraOrientation: {
+        position: Viro3DPoint;
+        rotation: ViroRotation;
+        forward: Viro3DPoint;
+        up: Viro3DPoint;
+    };
+};
+export type ViroARPointCloudUpdateEvent = {
+    pointCloud: ViroARPointCloud;
+};
+export declare enum ViroTrackingStateConstants {
+    TRACKING_NORMAL = 0,
+    TRACKING_LIMITED = 1,
+    TRACKING_UNAVAILABLE = 2
+}
+export declare enum ViroARTrackingReasonConstants {
+    TRACKING_REASON_NONE = 0,
+    TRACKING_REASON_EXCESSIVE_MOTION = 1,
+    TRACKING_REASON_INSUFFICIENT_FEATURES = 2
+}
+export type ViroTrackingState = ViroTrackingStateConstants.TRACKING_NORMAL | ViroTrackingStateConstants.TRACKING_LIMITED | ViroTrackingStateConstants.TRACKING_UNAVAILABLE;
+export type ViroTrackingReason = ViroARTrackingReasonConstants.TRACKING_REASON_NONE | ViroARTrackingReasonConstants.TRACKING_REASON_EXCESSIVE_MOTION | ViroARTrackingReasonConstants.TRACKING_REASON_INSUFFICIENT_FEATURES;
+export type ViroTrackingUpdatedEvent = {
+    state: ViroTrackingState;
+    reason: ViroTrackingReason;
+};
+export declare enum ViroRecordingErrorConstants {
+    RECORD_ERROR_NONE = 0,
+    RECORD_ERROR_UNKNOWN = 1,
+    RECORD_ERROR_NO_PERMISSION = 2,
+    RECORD_ERROR_INITIALIZATION = 3,
+    RECORD_ERROR_WRITE_TO_FILE = 4,
+    RECORD_ERROR_ALREADY_RUNNING = 5,
+    RECORD_ERROR_ALREADY_STOPPED = 6
+}
+export type ViroErrorEvent = {
+    error: Error;
+};
+export type ViroCollisionEvent = {
+    viroTag: string;
+    collidedPoint: Viro3DPoint;
+    collidedNormal: Viro3DPoint;
+};
+export type ViroPlatformInfo = {
+    platform: string;
+    headset: string;
+    controller: string;
+};
+export type ViroPlatformEvent = {
+    platformInfoViro: ViroPlatformInfo;
+};
+export type ViroPlatformUpdateEvent = {
+    platformInfoViro: ViroPlatformInfo;
+};
+export type ViroCameraTransform = {
+    position: Viro3DPoint;
+    rotation: ViroRotation;
+    forward: Viro3DPoint;
+    up: Viro3DPoint;
+};
+export type ViroCameraTransformEvent = {
+    cameraTransform: number[];
+};
+export type ViroWorldOrigin = {
+    position: Viro3DPoint;
+    rotation: ViroRotation;
+};
+export type ViroNativeTransformUpdateEvent = {
+    position: Viro3DPoint;
+};
+export type ViroControllerStatus = any;
+export type ViroControllerStatusEvent = {
+    controllerStatus: ViroControllerStatus;
+    source: ViroSource;
+};
+export type ViroExitViroEvent = {};
+export type ViroAnimationStartEvent = {};
+export type ViroAnimationFinishEvent = {};
+export type ViroLoadStartEvent = {};
+export type ViroLoadEndEvent = {
+    success: boolean;
+};
+export type ViroLoadErrorEvent = ViroErrorEvent;
+export type ViroVideoBufferStartEvent = {};
+export type ViroVideoBufferEndEvent = {};
+export type ViroVideoUpdateTimeEvent = {
+    currentTime: number;
+    totalTime: number;
+};
+export type ViroVideoErrorEvent = ViroErrorEvent;
+export type ViroVideoFinishEvent = ViroErrorEvent;
+export type ViroAnimatedComponentStartEvent = {};
+export type ViroAnimatedComponentFinishEvent = {};
+export type ViroPortalEnterEvent = any;
+export type ViroPortalExitEvent = any;
+export type ViroSoundFinishEvent = any;
+export type ViroAmbientLightInfo = {
+    intensity: number;
+    color: string;
+};
+export type ViroAmbientLightUpdateEvent = {
+    ambientLightInfo: ViroAmbientLightInfo;
+};
+export type ViroARSupportResponse = {
+    supported: boolean;
+    reason?: string;
+};