@reactvision/react-viro 2.41.3

package/dist/components/ViroSceneNavigator.d.ts

@@ -0,0 +1,143 @@
+import * as React from "react";
+import { ViewProps, NativeSyntheticEvent } from "react-native";
+import { ViroExitViroEvent } from "./Types/ViroEvents";
+import { Viro3DPoint } from "./Types/ViroUtils";
+import { ViroSceneDictionary } from "./Types/ViroUtils";
+import { ViroScene } from "./ViroScene";
+type Props = ViewProps & {
+    initialSceneKey?: string;
+    /**
+     * Calling vrModeEnabled allows switching to and from VR mode.
+     * When set to false, it transitions back to pre-VR (mono) mode.
+     * When set to true, we set thie view into a full VR mode.
+     * This is set to true by default.
+     *
+     * @deprecated This property was unused.
+     */
+    vrModeEnabled?: boolean;
+    /**
+     * A flag to enable/disable some debug features
+     */
+    debug?: boolean;
+    /**
+     * ViroSceneNavigator uses "scene" objects like the following to
+     * describe a scene.
+     */
+    initialScene: {
+        /**
+         * The React Class to render for this scene.
+         */
+        scene: ViroScene;
+    };
+    viroAppProps?: any;
+    /**
+     * Called when either the user physically decides to exit vr (hits
+     * the "X" buton).
+     */
+    onExitViro?: () => void;
+};
+type State = {
+    sceneDictionary: ViroSceneDictionary;
+    sceneHistory: string[];
+    currentSceneIndex: number;
+};
+/**
+ * ##### DEPRECATION WARNING - ViroSceneNavigator may be removed in future releases. Use ViroVRSceneNavigator instead #####
+ * ViroSceneNavigator is used to transition between multiple scenes.
+ *
+ * @deprecated
+ */
+export declare class ViroSceneNavigator extends React.Component<Props, State> {
+    _component: any;
+    sceneNavigator: {
+        push: (param1?: string | ViroScene, param2?: string | ViroScene) => void;
+        pop: () => void;
+        popN: (n: number) => void;
+        jump: (param1?: string | ViroScene, param2?: string | ViroScene) => void;
+        replace: (param1?: string | ViroScene, param2?: string | ViroScene) => void;
+        recenterTracking: () => void;
+        project: (point: Viro3DPoint) => Promise<any>;
+        unproject: (point: Viro3DPoint) => Promise<any>;
+        viroAppProps: any;
+    };
+    /**
+     * Called from native when either the user physically decides to exit vr (hits
+     * the "X" buton).
+     */
+    _onExitViro: (_event: NativeSyntheticEvent<ViroExitViroEvent>) => void;
+    constructor(props: Props);
+    getRandomTag(): string;
+    /**
+     * Pushes a scene and reference it with the given key if provided.
+     * If the scene has been previously pushed, we simply show the scene again.
+     * Note that the back history order of which scenes were pushed is preserved.
+     * Also note that scenes are reference counted and only a unique set of
+     * scenes are stored and mapped to within sceneDictionary.
+     *
+     * Can take in either 1 or two parameters in the form:
+     * push ("sceneKey");
+     * push ("sceneKey", scene);
+     * push (scene);
+     *
+     * @todo add typescript to overload the function, rather than the string | ViroScene typings
+     */
+    push(param1?: string | ViroScene, param2?: string | ViroScene): void;
+    /**
+     * Replace the top scene in the stack with the given scene. The remainder of the back
+     * history is kept in the same order as before.
+     *
+     * Can take in either 1 or two parameters in the form:
+     * replace ("sceneKey");
+     * replace ("sceneKey", scene);
+     * replace (scene);
+     *
+     * @todo add typescript to overload the function, rather than the string | ViroScene typings
+     */
+    replace(param1?: string | ViroScene, param2?: string | ViroScene): void;
+    /**
+     * Jumps to a given scene that had been previously pushed. If the scene was not pushed, we
+     * then push and jump to it. The back history is re-ordered such that jumped to scenes are
+     * re-ordered to the front. As such, only the back order of sequential jumps are preserved.
+     *
+     * Can take in either 1 or two parameters in the form:
+     * jump ("sceneKey");
+     * jump ("sceneKey", scene);
+     * jump (scene);
+     */
+    jump(param1?: string | ViroScene, param2?: string | ViroScene): void;
+    pop(): void;
+    popN(n: number): void;
+    /**
+     * Increments the reference count for a scene within sceneDictionary that is
+     * mapped to the given sceneKey. If no scenes are found / mapped, we create
+     * one, initialize it with a reference count of 1, and store it within the
+     * sceneDictionary for future reference.
+     */
+    incrementSceneReference(scene: ViroScene, sceneKey: string, limitOne: boolean): void;
+    /**
+     * Decrements the reference count for the last N scenes within
+     * the sceneHistory by 1. If nothing else references that given scene
+     * (counts equals 0), we then remove that scene from sceneDictionary.
+     */
+    decrementReferenceForLastNScenes(n: number): void;
+    /**
+     * Adds the given sceneKey to the sceneHistory and updates the currentSceneIndex to point
+     * to the scene on the top of the history stack (the most recent scene).
+     */
+    addToHistory(sceneKey: string): void;
+    /**
+     * Instead of preserving history, we find the last pushed sceneKey within the history stack
+     * matching the given sceneKey and re-order it to the front. We then update the
+     * currentSceneIndex to point to the scene on the top of the history stack
+     * (the most recent scene).
+     */
+    reorderHistory(sceneKey: string): void;
+    popHistoryByN(n: number): void;
+    getSceneIndex(sceneTag: string): number;
+    _project(point: Viro3DPoint): Promise<any>;
+    _unproject(point: Viro3DPoint): Promise<any>;
+    _recenterTracking(): void;
+    _renderSceneStackItems(): JSX.Element[];
+    render(): JSX.Element;
+}
+export {};

package/dist/components/ViroSceneNavigator.js

@@ -0,0 +1,402 @@
+/**
+ * Copyright (c) 2018-present, Viro Media, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @providesModule ViroSceneNavigator
+ * @flow
+ */
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ViroSceneNavigator = void 0;
+const React = __importStar(require("react"));
+const react_native_1 = require("react-native");
+var ViroSceneNavigatorModule = react_native_1.NativeModules.VRTSceneNavigatorModule;
+var mathRandomOffset = 0;
+/**
+ * ##### DEPRECATION WARNING - ViroSceneNavigator may be removed in future releases. Use ViroVRSceneNavigator instead #####
+ * ViroSceneNavigator is used to transition between multiple scenes.
+ *
+ * @deprecated
+ */
+class ViroSceneNavigator extends React.Component {
+    // TODO: type of this component (native component)
+    _component;
+    sceneNavigator = {
+        push: this.push,
+        pop: this.pop,
+        popN: this.popN,
+        jump: this.jump,
+        replace: this.replace,
+        // exitViro: this.exitViro, TODO: this was unused
+        recenterTracking: this._recenterTracking,
+        project: this._project,
+        unproject: this._unproject,
+        viroAppProps: this.props.viroAppProps || {},
+    };
+    /**
+     * Called from native when either the user physically decides to exit vr (hits
+     * the "X" buton).
+     */
+    _onExitViro = (_event) => {
+        this.props.onExitViro && this.props.onExitViro();
+    };
+    constructor(props) {
+        super(props);
+        var initialSceneTag = this.props.initialSceneKey;
+        if (initialSceneTag == null) {
+            initialSceneTag = this.getRandomTag();
+        }
+        var scene = {
+            sceneClass: this.props.initialScene,
+            tag: initialSceneTag,
+            referenceCount: 1,
+        };
+        var sceneDict = {};
+        sceneDict[scene.tag] = scene;
+        this.state = {
+            sceneDictionary: sceneDict,
+            sceneHistory: [scene.tag],
+            currentSceneIndex: 0,
+        };
+    }
+    getRandomTag() {
+        var randomTag = Math.random() + mathRandomOffset;
+        mathRandomOffset++;
+        return randomTag.toString();
+    }
+    /**
+     * Pushes a scene and reference it with the given key if provided.
+     * If the scene has been previously pushed, we simply show the scene again.
+     * Note that the back history order of which scenes were pushed is preserved.
+     * Also note that scenes are reference counted and only a unique set of
+     * scenes are stored and mapped to within sceneDictionary.
+     *
+     * Can take in either 1 or two parameters in the form:
+     * push ("sceneKey");
+     * push ("sceneKey", scene);
+     * push (scene);
+     *
+     * @todo add typescript to overload the function, rather than the string | ViroScene typings
+     */
+    push(param1, param2) {
+        var sceneKey = undefined;
+        var scene = undefined;
+        if (typeof param1 == "string") {
+            sceneKey = param1;
+            scene = param2;
+        }
+        else {
+            scene = param1;
+        }
+        if (scene == undefined && sceneKey == undefined) {
+            console.log("ERROR: pushing requires either the scene tag, or both the tag and scene.");
+            return;
+        }
+        else if (scene == undefined &&
+            sceneKey != undefined &&
+            !(sceneKey in this.state.sceneDictionary)) {
+            console.log("ERROR: Cannot push with a new sceneKey with no associated scene.");
+            return;
+        }
+        if (sceneKey == undefined ||
+            (typeof sceneKey == "string" && sceneKey.trim().length <= 0)) {
+            sceneKey = this.getRandomTag();
+        }
+        this.incrementSceneReference(scene, sceneKey, false);
+        this.addToHistory(sceneKey);
+    }
+    /**
+     * Replace the top scene in the stack with the given scene. The remainder of the back
+     * history is kept in the same order as before.
+     *
+     * Can take in either 1 or two parameters in the form:
+     * replace ("sceneKey");
+     * replace ("sceneKey", scene);
+     * replace (scene);
+     *
+     * @todo add typescript to overload the function, rather than the string | ViroScene typings
+     */
+    replace(param1, param2) {
+        var sceneKey = undefined;
+        var scene = undefined;
+        if (typeof param1 == "string") {
+            sceneKey = param1;
+            scene = param2;
+        }
+        else {
+            scene = param1;
+        }
+        if (scene == undefined && sceneKey == undefined) {
+            console.log("ERROR: replacing requires either the scene tag, or both the tag and scene.");
+            return;
+        }
+        else if (scene == undefined &&
+            sceneKey != undefined &&
+            !(sceneKey in this.state.sceneDictionary)) {
+            console.log("ERROR: Cannot replace with a new sceneKey with no associated scene.");
+            return;
+        }
+        if (sceneKey == undefined ||
+            (typeof sceneKey == "string" && sceneKey.trim().length <= 0)) {
+            sceneKey = this.getRandomTag();
+        }
+        // Pop 1 off the scene history (do not use popN because in this case we allow
+        // popping the root), then push this scene
+        this.decrementReferenceForLastNScenes(1);
+        this.popHistoryByN(1);
+        this.incrementSceneReference(scene, sceneKey, false);
+        this.addToHistory(sceneKey);
+    }
+    /**
+     * Jumps to a given scene that had been previously pushed. If the scene was not pushed, we
+     * then push and jump to it. The back history is re-ordered such that jumped to scenes are
+     * re-ordered to the front. As such, only the back order of sequential jumps are preserved.
+     *
+     * Can take in either 1 or two parameters in the form:
+     * jump ("sceneKey");
+     * jump ("sceneKey", scene);
+     * jump (scene);
+     */
+    jump(param1, param2) {
+        var sceneKey = undefined;
+        var scene = undefined;
+        if (typeof param1 == "string") {
+            sceneKey = param1;
+            scene = param2;
+        }
+        else {
+            scene = param1;
+        }
+        if (scene == undefined && sceneKey == undefined) {
+            console.log("ERROR: jumping requires either the scene tag, or both the tag and scene.");
+            return;
+        }
+        else if (scene == undefined &&
+            sceneKey != undefined &&
+            !(sceneKey in this.state.sceneDictionary)) {
+            console.log("ERROR: Cannot jump with a new sceneKey with no associated scene.");
+            return;
+        }
+        if (sceneKey === undefined ||
+            (typeof sceneKey == "string" && sceneKey.trim().length <= 0)) {
+            sceneKey = this.getRandomTag();
+        }
+        this.incrementSceneReference(scene, sceneKey, true);
+        this.reorderHistory(sceneKey);
+    }
+    pop() {
+        this.popN(1);
+    }
+    popN(n) {
+        if (n === 0) {
+            return;
+        }
+        if (this.state.sceneHistory.length - n <= 0) {
+            console.log("WARN: Attempted to pop the root scene in ViroSceneNavigator!");
+            return;
+        }
+        this.decrementReferenceForLastNScenes(n);
+        this.popHistoryByN(n);
+    }
+    /**
+     * Increments the reference count for a scene within sceneDictionary that is
+     * mapped to the given sceneKey. If no scenes are found / mapped, we create
+     * one, initialize it with a reference count of 1, and store it within the
+     * sceneDictionary for future reference.
+     */
+    incrementSceneReference(scene, sceneKey, limitOne) {
+        var currentSceneDictionary = this.state.sceneDictionary;
+        if (!(sceneKey in currentSceneDictionary)) {
+            var newScene = {
+                sceneClass: scene,
+                tag: sceneKey,
+                referenceCount: 0,
+            };
+            currentSceneDictionary[sceneKey] = newScene;
+        }
+        // Error out if there are no scenes matching the given sceneKey
+        var currentScene = currentSceneDictionary[sceneKey];
+        if (currentScene == null || currentScene === undefined) {
+            console.log("ERROR: No scene found for: " + sceneKey);
+            return;
+        }
+        // Update the scene's reference count and then the sceneDictionary
+        if ((limitOne && currentScene.referenceCount < 1) || !limitOne) {
+            currentScene.referenceCount++;
+        }
+        currentSceneDictionary[sceneKey] = currentScene;
+        // Finally update all states
+        this.setState({
+            sceneDictionary: currentSceneDictionary,
+        });
+    }
+    /**
+     * Decrements the reference count for the last N scenes within
+     * the sceneHistory by 1. If nothing else references that given scene
+     * (counts equals 0), we then remove that scene from sceneDictionary.
+     */
+    decrementReferenceForLastNScenes(n) {
+        var sceneHistory = this.state.sceneHistory;
+        var sceneDictionary = this.state.sceneDictionary;
+        // Now update and release any reference counts
+        for (var i = 1; i <= n; i++) {
+            var sceneTag = sceneHistory[sceneHistory.length - i];
+            var scene = sceneDictionary[sceneTag];
+            scene.referenceCount--;
+            if (scene.referenceCount <= 0) {
+                delete sceneDictionary[sceneTag];
+            }
+            else {
+                sceneDictionary[sceneTag] = scene;
+            }
+        }
+        // Finally update all states
+        this.setState({
+            sceneDictionary: sceneDictionary,
+        });
+    }
+    /**
+     * Adds the given sceneKey to the sceneHistory and updates the currentSceneIndex to point
+     * to the scene on the top of the history stack (the most recent scene).
+     */
+    addToHistory(sceneKey) {
+        var updatedHistory = this.state.sceneHistory.concat([sceneKey]);
+        var currentIndex = this.getSceneIndex(sceneKey);
+        this.setState({
+            currentSceneIndex: currentIndex,
+            sceneHistory: updatedHistory,
+        });
+    }
+    /**
+     * Instead of preserving history, we find the last pushed sceneKey within the history stack
+     * matching the given sceneKey and re-order it to the front. We then update the
+     * currentSceneIndex to point to the scene on the top of the history stack
+     * (the most recent scene).
+     */
+    reorderHistory(sceneKey) {
+        // Find the last sceneKey within sceneHistory and remove it.
+        var sceneHistory = this.state.sceneHistory;
+        for (var i = sceneHistory.length - 1; i >= 0; i--) {
+            if (sceneKey == sceneHistory[i]) {
+                sceneHistory.splice(i, 1);
+                break;
+            }
+        }
+        // Add back the sceneKey to the front of the History stack.
+        var updatedHistory = sceneHistory.concat([sceneKey]);
+        var currentIndex = this.getSceneIndex(sceneKey);
+        this.setState({
+            currentSceneIndex: currentIndex,
+            sceneHistory: updatedHistory,
+        });
+    }
+    popHistoryByN(n) {
+        var sceneHistory = this.state.sceneHistory;
+        sceneHistory.splice(sceneHistory.length - n, n);
+        var currentIndex = this.getSceneIndex(sceneHistory[sceneHistory.length - 1]);
+        // Finally update all states
+        this.setState({
+            currentSceneIndex: currentIndex,
+            sceneHistory: sceneHistory,
+        });
+    }
+    getSceneIndex(sceneTag) {
+        var sceneDictionary = this.state.sceneDictionary;
+        var i = 0;
+        for (var sceneKey in sceneDictionary) {
+            if (sceneTag == sceneDictionary[sceneKey].tag) {
+                return i;
+            }
+            i++;
+        }
+        // Unable to find the given sceneTag, return -1
+        return -1;
+    }
+    async _project(point) {
+        return await ViroSceneNavigatorModule.project((0, react_native_1.findNodeHandle)(this), point);
+    }
+    async _unproject(point) {
+        return await ViroSceneNavigatorModule.unproject((0, react_native_1.findNodeHandle)(this), point);
+    }
+    _recenterTracking() {
+        ViroSceneNavigatorModule.recenterTracking((0, react_native_1.findNodeHandle)(this));
+    }
+    _renderSceneStackItems() {
+        let views = [];
+        var i = 0;
+        var sceneDictionary = this.state.sceneDictionary;
+        for (var scene in sceneDictionary) {
+            var Component = sceneDictionary[scene].sceneClass.scene;
+            var props = sceneDictionary[scene].sceneClass.passProps;
+            views.push(<Component key={"scene" + i} sceneNavigator={this.sceneNavigator} {...props}/>);
+            i++;
+        }
+        return views;
+    }
+    render() {
+        // Uncomment this line to check for misnamed props
+        //checkMisnamedProps("ViroSceneNavigator", this.props);
+        console.warn("<ViroSceneNavigator> has been DEPRECATED. Please use <ViroVRSceneNavigator> instead.");
+        var items = this._renderSceneStackItems();
+        // update the sceneNavigator with the latest given props on every render
+        this.sceneNavigator.viroAppProps = this.props.viroAppProps;
+        // If the user simply passes us the props from the root React component,
+        // then we'll have an extra 'rootTag' key which React automatically includes
+        // so remove it.
+        if (this.sceneNavigator.viroAppProps?.rootTag) {
+            delete this.sceneNavigator.viroAppProps?.rootTag;
+        }
+        const { vrModeEnabled = true, // default to true
+        viroAppProps = {}, // Make sure viroAppProps aren't null to save us having to always check
+         } = this.props;
+        return (<VRTSceneNavigator ref={(component) => {
+                this._component = component;
+            }} {...this.props} vrModeEnabled={vrModeEnabled} viroAppProps={viroAppProps} currentSceneIndex={this.state.currentSceneIndex} style={(this.props.style, styles.container)} hasOnExitViroCallback={this.props.onExitViro != undefined} onExitViro={this._onExitViro}>
+        {items}
+      </VRTSceneNavigator>);
+    }
+}
+exports.ViroSceneNavigator = ViroSceneNavigator;
+var styles = react_native_1.StyleSheet.create({
+    container: {
+        flex: 1,
+        justifyContent: "center",
+        alignItems: "center",
+    },
+});
+var VRTSceneNavigator = (0, react_native_1.requireNativeComponent)("VRTSceneNavigator", 
+// @ts-ignore
+ViroSceneNavigator, {
+    nativeOnly: {
+        currentSceneIndex: true,
+        onExitViro: true,
+        hasOnExitViroCallback: true,
+    },
+});

package/dist/components/ViroSkyBox.d.ts

@@ -0,0 +1,23 @@
+import * as React from "react";
+import { ColorValue, NativeSyntheticEvent, ViewProps } from "react-native";
+import { ViroCubeMap } from "./Material/ViroMaterials";
+import { ViroLoadEndEvent, ViroLoadStartEvent } from "./Types/ViroEvents";
+import { ViroNativeRef } from "./Types/ViroUtils";
+type Props = ViewProps & {
+    source?: ViroCubeMap;
+    color?: ColorValue;
+    format?: "RGBA8" | "RGB565";
+    onLoadStart?: (event: NativeSyntheticEvent<ViroLoadStartEvent>) => void;
+    onLoadEnd?: (event: NativeSyntheticEvent<ViroLoadEndEvent>) => void;
+};
+/**
+ * Used to render a skybox as a scene background.
+ */
+export declare class ViroSkyBox extends React.Component<Props> {
+    _component: ViroNativeRef;
+    _onLoadStart: (event: NativeSyntheticEvent<ViroLoadStartEvent>) => void;
+    _onLoadEnd: (event: NativeSyntheticEvent<ViroLoadEndEvent>) => void;
+    setNativeProps: (nativeProps: Props) => void;
+    render(): JSX.Element;
+}
+export {};

package/dist/components/ViroSkyBox.js

@@ -0,0 +1,86 @@
+/**
+ * Copyright (c) 2015-present, Viro, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @providesModule ViroSkyBox
+ * @flow
+ */
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ViroSkyBox = void 0;
+const React = __importStar(require("react"));
+const react_native_1 = require("react-native");
+// @ts-ignore
+const resolveAssetSource_1 = __importDefault(require("react-native/Libraries/Image/resolveAssetSource"));
+const ViroProps_1 = require("./Utilities/ViroProps");
+/**
+ * Used to render a skybox as a scene background.
+ */
+class ViroSkyBox extends React.Component {
+    _component = null;
+    _onLoadStart = (event) => {
+        this.props.onLoadStart && this.props.onLoadStart(event);
+    };
+    _onLoadEnd = (event) => {
+        this.props.onLoadEnd && this.props.onLoadEnd(event);
+    };
+    setNativeProps = (nativeProps) => {
+        this._component?.setNativeProps(nativeProps);
+    };
+    render() {
+        (0, ViroProps_1.checkMisnamedProps)("ViroSkyBox", this.props);
+        // Create and set the native props.
+        var skyboxDict = {};
+        let nativeProps = Object.assign({}, this.props);
+        if (this.props.source !== undefined) {
+            for (var key in this.props.source) {
+                var s = (0, resolveAssetSource_1.default)(this.props.source[key]);
+                skyboxDict[key] = s;
+            }
+            nativeProps.source = skyboxDict;
+        }
+        nativeProps.onViroSkyBoxLoadStart = this._onLoadStart;
+        nativeProps.onViroSkyBoxLoadEnd = this._onLoadEnd;
+        nativeProps.color = this.props.color;
+        nativeProps.ref = (component) => {
+            this._component = component;
+        };
+        return <VRTSkyBox {...nativeProps}/>;
+    }
+}
+exports.ViroSkyBox = ViroSkyBox;
+var VRTSkyBox = (0, react_native_1.requireNativeComponent)("VRTSkybox", 
+// @ts-ignore
+ViroSkyBox, {
+    nativeOnly: { onViroSkyBoxLoadStart: true, onViroSkyBoxLoadEnd: true },
+});

package/dist/components/ViroSound.d.ts

@@ -0,0 +1,27 @@
+import * as React from "react";
+import { NativeSyntheticEvent, ViewProps } from "react-native";
+import { ViroErrorEvent, ViroSoundFinishEvent } from "./Types/ViroEvents";
+import { ViroNativeRef, ViroSoundMap, ViroSoundPreloadResult, ViroSource } from "./Types/ViroUtils";
+type Props = ViewProps & {
+    source: ViroSource;
+    paused?: boolean;
+    loop?: boolean;
+    muted?: boolean;
+    volume?: number;
+    onFinish?: (event: NativeSyntheticEvent<ViroSoundFinishEvent>) => void;
+    onError?: (event: NativeSyntheticEvent<ViroErrorEvent>) => void;
+};
+/**
+ * ViroSound is a component that plays a sound file.
+ */
+export declare class ViroSound extends React.Component<Props> {
+    _component: ViroNativeRef;
+    static preloadSounds: (soundMap: ViroSoundMap) => Promise<ViroSoundPreloadResult>;
+    static unloadSounds: (soundKeys: ViroSound[]) => void;
+    _onFinish: (event: NativeSyntheticEvent<ViroSoundFinishEvent>) => void;
+    _onError: (event: NativeSyntheticEvent<ViroErrorEvent>) => void;
+    setNativeProps: (nativeProps: Props) => void;
+    render(): JSX.Element;
+    seekToTime: (timeInSeconds: number) => void;
+}
+export {};