@de./sdk 1.0.5 → 2.0.0

package/dist/allend/MSI/Controls.js

@@ -0,0 +1,773 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const FUNCTION_EVENT_TIMEOUT = 12000, FUNCTION_EVENT_TIMEOUT_MESSAGE = 'Event timeout';
+class Controls {
+    constructor(chn, options) {
+        this.chn = chn;
+        this.options = options;
+    }
+    /**
+     * Listen to MSI events
+     */
+    on(event, listener) {
+        this.chn.on(event, listener);
+    }
+    /**
+     * Remove a listener of MSI events
+     */
+    off(event, listener) {
+        this.chn.off(event, listener);
+    }
+    /**
+     * Remove all listen of MSI events
+     */
+    removeListeners(listener) {
+        this.chn.removeListeners(listener);
+    }
+    /**
+     * Refresh access token to remote server
+     *
+     * Updating the local copy alone is not enough: the gateway captured the token
+     * it was bound with, so it has to be told about the rotation as well.
+     *
+     * @param token - Latest access token
+     */
+    refreshToken(token) {
+        return new Promise((resolve, reject) => {
+            if (!token)
+                return reject('Undefined Access Token');
+            this.options.accessToken = token;
+            // Set timeout
+            const timeout = setTimeout(() => reject(FUNCTION_EVENT_TIMEOUT_MESSAGE), FUNCTION_EVENT_TIMEOUT);
+            this.chn.emit('refresh:token', token, (error) => {
+                clearTimeout(timeout);
+                if (error)
+                    return reject(error);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Update map style
+     *
+     * @param style - Map style ID
+     */
+    setMapStyle(style) {
+        return new Promise((resolve, reject) => {
+            // Set timeout
+            const timeout = setTimeout(() => reject(FUNCTION_EVENT_TIMEOUT_MESSAGE), FUNCTION_EVENT_TIMEOUT);
+            // Set style
+            this.chn.emit('set:map:style', style, (error) => {
+                clearTimeout(timeout);
+                if (error)
+                    return reject(error);
+                resolve();
+            });
+        });
+    }
+    /**
+     * @return - User's current GPS location
+     */
+    getCurrentLocation() {
+        return new Promise((resolve, reject) => {
+            // Set timeout
+            const timeout = setTimeout(() => reject(FUNCTION_EVENT_TIMEOUT_MESSAGE), FUNCTION_EVENT_TIMEOUT);
+            // Get current location
+            this.chn.emit('get:current:location', (error, location) => {
+                clearTimeout(timeout);
+                if (error)
+                    return reject(error);
+                resolve(location);
+            });
+        });
+    }
+    /**
+     * Pin user's current location on the current active map
+     *
+     * @return - User's current GPS location coordinates or `null` when it failed
+     */
+    pinCurrentLocation() {
+        return new Promise((resolve, reject) => {
+            // Set timeout
+            const timeout = setTimeout(() => reject(FUNCTION_EVENT_TIMEOUT_MESSAGE), FUNCTION_EVENT_TIMEOUT);
+            // Pin user's current location on the map
+            this.chn.emit('pin:current:location', (error, location) => {
+                clearTimeout(timeout);
+                if (error)
+                    return reject(error);
+                resolve(location);
+            });
+        });
+    }
+    /**
+     * Set live location tracking options
+     *
+     * @param options - User location tracking options
+     */
+    setLiveLocationOptions(options) {
+        return new Promise((resolve, reject) => {
+            // Set timeout
+            const timeout = setTimeout(() => reject(FUNCTION_EVENT_TIMEOUT_MESSAGE), FUNCTION_EVENT_TIMEOUT);
+            // Set live location options
+            this.chn.emit('set:live:options', options, (error) => {
+                clearTimeout(timeout);
+                if (error)
+                    return reject(error);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Start tracking user's live location
+     */
+    trackLiveLocation() {
+        return new Promise((resolve, reject) => {
+            // Set timeout
+            const timeout = setTimeout(() => reject(FUNCTION_EVENT_TIMEOUT_MESSAGE), FUNCTION_EVENT_TIMEOUT);
+            // Start live location tracking
+            this.chn.emit('track:live:location', (error) => {
+                clearTimeout(timeout);
+                if (error)
+                    return reject(error);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Stop tracking user's live location
+     */
+    untrackLiveLocation() {
+        return new Promise((resolve, reject) => {
+            // Set timeout
+            const timeout = setTimeout(() => reject(FUNCTION_EVENT_TIMEOUT_MESSAGE), FUNCTION_EVENT_TIMEOUT);
+            // Stop live location tracking
+            this.chn.emit('untrack:live:location', (error) => {
+                clearTimeout(timeout);
+                if (error)
+                    return reject(error);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Enable drag pick functionality
+     *
+     * @param location - (Optional) Initial location for drag pick
+     */
+    enableDragPickLocation(location) {
+        return new Promise((resolve, reject) => {
+            // Set timeout
+            const timeout = setTimeout(() => reject(FUNCTION_EVENT_TIMEOUT_MESSAGE), FUNCTION_EVENT_TIMEOUT);
+            // Enable drag pick
+            this.chn.emit('enable:dragpick:location', location, (error) => {
+                clearTimeout(timeout);
+                if (error)
+                    return reject(error);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Disable drag pick functionality
+     */
+    disableDragPickLocation() {
+        return new Promise((resolve, reject) => {
+            // Set timeout
+            const timeout = setTimeout(() => reject(FUNCTION_EVENT_TIMEOUT_MESSAGE), FUNCTION_EVENT_TIMEOUT);
+            // Disable drag pick
+            this.chn.emit('disable:dragpick:location', (error) => {
+                clearTimeout(timeout);
+                if (error)
+                    return reject(error);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Set drag pick content
+     *
+     * @param type - Content type for drag pick
+     * @param content - Content data for drag pick
+     */
+    setDragPickContent(type, content) {
+        return new Promise((resolve, reject) => {
+            // Set timeout
+            const timeout = setTimeout(() => reject(FUNCTION_EVENT_TIMEOUT_MESSAGE), FUNCTION_EVENT_TIMEOUT);
+            // Set drag pick content
+            this.chn.emit('set:dragpick:content', { type, content }, (error) => {
+                clearTimeout(timeout);
+                if (error)
+                    return reject(error);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Get a location coordinates of placed that matched this name
+     *
+     * @param name - Place name to resolve
+     * @return - Array list of coordinates
+     */
+    resolvePlace(name) {
+        return new Promise((resolve, reject) => {
+            // Set timeout
+            const timeout = setTimeout(() => reject(FUNCTION_EVENT_TIMEOUT_MESSAGE), FUNCTION_EVENT_TIMEOUT);
+            // Get location coordinates from place name
+            this.chn.emit('resolve:place', name, (error, data) => {
+                clearTimeout(timeout);
+                if (error)
+                    return reject(error);
+                resolve(data);
+            });
+        });
+    }
+    /**
+     * Get a location details of placed that matched this coordinates
+     *
+     * @param coords - Coordinates
+     * @return - Array list of geocoding data
+     */
+    resolveCoordinates(coords) {
+        return new Promise((resolve, reject) => {
+            // Set timeout
+            const timeout = setTimeout(() => reject(FUNCTION_EVENT_TIMEOUT_MESSAGE), FUNCTION_EVENT_TIMEOUT);
+            // Get location place from coordinates
+            this.chn.emit('resolve:coordinates', coords, (error, data) => {
+                clearTimeout(timeout);
+                if (error)
+                    return reject(error);
+                resolve(data);
+            });
+        });
+    }
+    /**
+     * Search a location or places
+     *
+     * @param input - Place in string
+     * @return - Autocompletion list matched places
+     */
+    searchQuery(input) {
+        return new Promise((resolve, reject) => {
+            // Set timeout
+            const timeout = setTimeout(() => reject(FUNCTION_EVENT_TIMEOUT_MESSAGE), FUNCTION_EVENT_TIMEOUT);
+            // Launch search query
+            this.chn.emit('search:query', input, (error, data) => {
+                clearTimeout(timeout);
+                if (error)
+                    return reject(error);
+                resolve(data);
+            });
+        });
+    }
+    /**
+     * Select a suggested place by the search
+     *
+     * @param index - Index of place in suggested list
+     * @return - More details of selected place
+     */
+    searchSelect(index) {
+        return new Promise((resolve, reject) => {
+            // Set timeout
+            const timeout = setTimeout(() => reject(FUNCTION_EVENT_TIMEOUT_MESSAGE), FUNCTION_EVENT_TIMEOUT);
+            // Get place's details
+            this.chn.emit('search:select', index, (error, data) => {
+                clearTimeout(timeout);
+                if (error)
+                    return reject(error);
+                resolve(data);
+            });
+        });
+    }
+    /**
+     * Show nearby entities around coordinates
+     *
+     * @param list - Array of entity specifications
+     */
+    showNearby(list) {
+        return new Promise((resolve, reject) => {
+            // Set timeout
+            const timeout = setTimeout(() => reject(FUNCTION_EVENT_TIMEOUT_MESSAGE), FUNCTION_EVENT_TIMEOUT);
+            // Show nearby entities
+            this.chn.emit('show:nearby', list, (error) => {
+                clearTimeout(timeout);
+                if (error)
+                    return reject(error);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Remove all displaying nearby entities
+     */
+    removeNearby() {
+        return new Promise((resolve, reject) => {
+            // Set timeout
+            const timeout = setTimeout(() => reject(FUNCTION_EVENT_TIMEOUT_MESSAGE), FUNCTION_EVENT_TIMEOUT);
+            // Remove nearby entities
+            this.chn.emit('remove:nearby', (error) => {
+                clearTimeout(timeout);
+                if (error)
+                    return reject(error);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Add a new nearby entity
+     *
+     * @param entity - Entity specification
+     */
+    addNearbyEntity(entity) {
+        return new Promise((resolve, reject) => {
+            // Set timeout
+            const timeout = setTimeout(() => reject(FUNCTION_EVENT_TIMEOUT_MESSAGE), FUNCTION_EVENT_TIMEOUT);
+            // Add nearby entity
+            this.chn.emit('add:nearby:entity', entity, (error) => {
+                clearTimeout(timeout);
+                if (error)
+                    return reject(error);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Update a nearby entity position
+     *
+     * @param activePosition - Entity ID and new position
+     */
+    moveNearbyEntity(activePosition) {
+        return new Promise((resolve, reject) => {
+            // Set timeout
+            const timeout = setTimeout(() => reject(FUNCTION_EVENT_TIMEOUT_MESSAGE), FUNCTION_EVENT_TIMEOUT);
+            // Move nearby entity
+            this.chn.emit('move:nearby:entity', activePosition, (error) => {
+                clearTimeout(timeout);
+                if (error)
+                    return reject(error);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Remove a nearby entity
+     *
+     * @param id - Entity ID to remove
+     */
+    removeNearbyEntity(id) {
+        return new Promise((resolve, reject) => {
+            // Set timeout
+            const timeout = setTimeout(() => reject(FUNCTION_EVENT_TIMEOUT_MESSAGE), FUNCTION_EVENT_TIMEOUT);
+            // Remove nearby entity
+            this.chn.emit('remove:nearby:entity', id, (error) => {
+                clearTimeout(timeout);
+                if (error)
+                    return reject(error);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Set complete route with journey specifications
+     *
+     * @param journey - Journey specifications including route ID, origin, destination, waypoints, and options
+     */
+    setRoute(journey) {
+        return new Promise((resolve, reject) => {
+            // Set timeout
+            const timeout = setTimeout(() => reject(FUNCTION_EVENT_TIMEOUT_MESSAGE), FUNCTION_EVENT_TIMEOUT);
+            // Set route
+            this.chn.emit('set:route', journey, (error) => {
+                clearTimeout(timeout);
+                if (error)
+                    return reject(error);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Draw route
+     *
+     * @param routeId - Route identifier
+     */
+    drawRoute(routeId, data, options) {
+        return new Promise((resolve, reject) => {
+            // Set timeout
+            const timeout = setTimeout(() => reject(FUNCTION_EVENT_TIMEOUT_MESSAGE), FUNCTION_EVENT_TIMEOUT);
+            // Draw route
+            this.chn.emit('draw:route', { routeId, data, options }, (error) => {
+                clearTimeout(timeout);
+                if (error)
+                    return reject(error);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Remove route
+     *
+     * @param routeId - Route identifier
+     */
+    removeRoute(routeId) {
+        return new Promise((resolve, reject) => {
+            // Set timeout
+            const timeout = setTimeout(() => reject(FUNCTION_EVENT_TIMEOUT_MESSAGE), FUNCTION_EVENT_TIMEOUT);
+            // Remove route
+            this.chn.emit('remove:route', routeId, (error) => {
+                clearTimeout(timeout);
+                if (error)
+                    return reject(error);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Set route origin
+     *
+     * @param routeId - Route identifier
+     * @param point - Waypoint specification for origin
+     */
+    setRouteOrigin(routeId, point) {
+        return new Promise((resolve, reject) => {
+            // Set timeout
+            const timeout = setTimeout(() => reject(FUNCTION_EVENT_TIMEOUT_MESSAGE), FUNCTION_EVENT_TIMEOUT);
+            // Set route origin
+            this.chn.emit('set:route:origin', { routeId, point }, (error) => {
+                clearTimeout(timeout);
+                if (error)
+                    return reject(error);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Remove route origin
+     *
+     * @param routeId - Route identifier
+     */
+    removeRouteOrigin(routeId) {
+        return new Promise((resolve, reject) => {
+            // Set timeout
+            const timeout = setTimeout(() => reject(FUNCTION_EVENT_TIMEOUT_MESSAGE), FUNCTION_EVENT_TIMEOUT);
+            // Remove route origin
+            this.chn.emit('remove:route:origin', { routeId }, (error) => {
+                clearTimeout(timeout);
+                if (error)
+                    return reject(error);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Set route destination
+     *
+     * @param routeId - Route identifier
+     * @param point - Waypoint specification for destination
+     */
+    setRouteDestination(routeId, point) {
+        return new Promise((resolve, reject) => {
+            // Set timeout
+            const timeout = setTimeout(() => reject(FUNCTION_EVENT_TIMEOUT_MESSAGE), FUNCTION_EVENT_TIMEOUT);
+            // Set route destination
+            this.chn.emit('set:route:destination', { routeId, point }, (error) => {
+                clearTimeout(timeout);
+                if (error)
+                    return reject(error);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Remove route destination
+     *
+     * @param routeId - Route identifier
+     */
+    removeRouteDestination(routeId) {
+        return new Promise((resolve, reject) => {
+            // Set timeout
+            const timeout = setTimeout(() => reject(FUNCTION_EVENT_TIMEOUT_MESSAGE), FUNCTION_EVENT_TIMEOUT);
+            // Remove route destination
+            this.chn.emit('remove:route:destination', { routeId }, (error) => {
+                clearTimeout(timeout);
+                if (error)
+                    return reject(error);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Add a route waypoint
+     *
+     * @param routeId - Route identifier
+     * @param point - Waypoint specification
+     */
+    addRouteWaypoint(routeId, point) {
+        return new Promise((resolve, reject) => {
+            // Set timeout
+            const timeout = setTimeout(() => reject(FUNCTION_EVENT_TIMEOUT_MESSAGE), FUNCTION_EVENT_TIMEOUT);
+            // Add route waypoint
+            this.chn.emit('add:route:waypoint', { routeId, point }, (error) => {
+                clearTimeout(timeout);
+                if (error)
+                    return reject(error);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Update a route waypoint
+     *
+     * @param routeId - Route identifier
+     * @param point - Waypoint specification with index
+     */
+    updateRouteWaypoint(routeId, point) {
+        return new Promise((resolve, reject) => {
+            // Set timeout
+            const timeout = setTimeout(() => reject(FUNCTION_EVENT_TIMEOUT_MESSAGE), FUNCTION_EVENT_TIMEOUT);
+            // Update route waypoint
+            this.chn.emit('update:route:waypoint', { routeId, point }, (error) => {
+                clearTimeout(timeout);
+                if (error)
+                    return reject(error);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Remove a route waypoint
+     *
+     * @param routeId - Route identifier
+     * @param index - Waypoint index to remove
+     */
+    removeRouteWaypoint(routeId, index) {
+        return new Promise((resolve, reject) => {
+            // Set timeout
+            const timeout = setTimeout(() => reject(FUNCTION_EVENT_TIMEOUT_MESSAGE), FUNCTION_EVENT_TIMEOUT);
+            // Remove route waypoint
+            this.chn.emit('remove:route:waypoint', { routeId, index }, (error) => {
+                clearTimeout(timeout);
+                if (error)
+                    return reject(error);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Fit route bounds
+     *
+     * @param routeId - Route identifier
+     * @param margin - Margin in px
+     */
+    fitRouteBounds(routeId, margin) {
+        return new Promise((resolve, reject) => {
+            // Set timeout
+            const timeout = setTimeout(() => reject(FUNCTION_EVENT_TIMEOUT_MESSAGE), FUNCTION_EVENT_TIMEOUT);
+            this.chn.emit('fit:route:bounds', { routeId, margin }, (error) => {
+                clearTimeout(timeout);
+                if (error)
+                    return reject(error);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Fit all/many routes bounds
+     *
+     * @param options - Routes fit bounds options
+     */
+    fitRoutesBounds(options) {
+        return new Promise((resolve, reject) => {
+            // Set timeout
+            const timeout = setTimeout(() => reject(FUNCTION_EVENT_TIMEOUT_MESSAGE), FUNCTION_EVENT_TIMEOUT);
+            this.chn.emit('fit:routes:bounds', options, (error) => {
+                clearTimeout(timeout);
+                if (error)
+                    return reject(error);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Set waypoint caption
+     *
+     * @param routeId - Route identifier
+     * @param id - Waypoint identifier (string or number)
+     * @param caption - Caption information to set
+     */
+    setWaypointCaption(routeId, id, caption) {
+        return new Promise((resolve, reject) => {
+            // Set timeout
+            const timeout = setTimeout(() => reject(FUNCTION_EVENT_TIMEOUT_MESSAGE), FUNCTION_EVENT_TIMEOUT);
+            // Set waypoint caption
+            this.chn.emit('set:waypoint:caption', { routeId, id, caption }, (error) => {
+                clearTimeout(timeout);
+                if (error)
+                    return reject(error);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Update waypoint caption
+     *
+     * @param routeId - Route identifier
+     * @param id - Waypoint identifier (string or number)
+     * @param caption - Caption information to update
+     */
+    updateWaypointCaption(routeId, id, caption) {
+        return new Promise((resolve, reject) => {
+            // Set timeout
+            const timeout = setTimeout(() => reject(FUNCTION_EVENT_TIMEOUT_MESSAGE), FUNCTION_EVENT_TIMEOUT);
+            // Update waypoint caption
+            this.chn.emit('update:waypoint:caption', { routeId, id, caption }, (error) => {
+                clearTimeout(timeout);
+                if (error)
+                    return reject(error);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Remove waypoint caption
+     *
+     * @param routeId - Route identifier
+     * @param id - Waypoint identifier (string or number)
+     */
+    removeWaypointCaption(routeId, id) {
+        return new Promise((resolve, reject) => {
+            // Set timeout
+            const timeout = setTimeout(() => reject(FUNCTION_EVENT_TIMEOUT_MESSAGE), FUNCTION_EVENT_TIMEOUT);
+            // Remove waypoint caption
+            this.chn.emit('remove:waypoint:caption', { routeId, id }, (error) => {
+                clearTimeout(timeout);
+                if (error)
+                    return reject(error);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Mount navigation route
+     *
+     * @param routeId - Route identifier for navigation
+     */
+    mountNavigation(routeId) {
+        return new Promise((resolve, reject) => {
+            // Set timeout
+            const timeout = setTimeout(() => reject(FUNCTION_EVENT_TIMEOUT_MESSAGE), FUNCTION_EVENT_TIMEOUT);
+            // Mount navigation
+            this.chn.emit('mount:navigation', routeId, (error) => {
+                clearTimeout(timeout);
+                if (error)
+                    return reject(error);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Unmount navigation route
+     */
+    unmountNavigation() {
+        return new Promise((resolve, reject) => {
+            // Set timeout
+            const timeout = setTimeout(() => reject(FUNCTION_EVENT_TIMEOUT_MESSAGE), FUNCTION_EVENT_TIMEOUT);
+            // Unmount navigation
+            this.chn.emit('unmount:navigation', (error) => {
+                clearTimeout(timeout);
+                if (error)
+                    return reject(error);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Load navigation direction
+     */
+    loadNavigation() {
+        return new Promise((resolve, reject) => {
+            // Set timeout
+            const timeout = setTimeout(() => reject(FUNCTION_EVENT_TIMEOUT_MESSAGE), FUNCTION_EVENT_TIMEOUT);
+            // Load navigation
+            this.chn.emit('load:navigation', (error) => {
+                clearTimeout(timeout);
+                if (error)
+                    return reject(error);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Set initial navigation position
+     *
+     * @param position - Initial GPS location for navigation
+     */
+    setInitialNavigationPosition(position) {
+        return new Promise((resolve, reject) => {
+            // Set timeout
+            const timeout = setTimeout(() => reject(FUNCTION_EVENT_TIMEOUT_MESSAGE), FUNCTION_EVENT_TIMEOUT);
+            // Set initial navigation position
+            this.chn.emit('initial:navigation:position', position, (error) => {
+                clearTimeout(timeout);
+                if (error)
+                    return reject(error);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Navigate to new position
+     *
+     * @param position - Current GPS location for navigation update
+     */
+    navigate(position) {
+        return new Promise((resolve, reject) => {
+            // Set timeout
+            const timeout = setTimeout(() => reject(FUNCTION_EVENT_TIMEOUT_MESSAGE), FUNCTION_EVENT_TIMEOUT);
+            // Navigate
+            this.chn.emit('navigate:navigation:direction', position, (error) => {
+                clearTimeout(timeout);
+                if (error)
+                    return reject(error);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Upsert navigation direction data
+     *
+     * @param routeId - Route identifier for navigation
+     * @param direction - Direction data
+     * @param position - (Optional) Current GPS position
+     * @params options - Route options
+     */
+    casting(routeId, direction, position, options) {
+        return new Promise((resolve, reject) => {
+            // Set timeout
+            const timeout = setTimeout(() => reject(FUNCTION_EVENT_TIMEOUT_MESSAGE), FUNCTION_EVENT_TIMEOUT);
+            // Casting navigation direction
+            this.chn.emit('casting:navigation:direction', { routeId, direction, position, options }, (error) => {
+                clearTimeout(timeout);
+                if (error)
+                    return reject(error);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Dismiss navigation
+     */
+    dismissNavigation() {
+        return new Promise((resolve, reject) => {
+            // Set timeout
+            const timeout = setTimeout(() => reject(FUNCTION_EVENT_TIMEOUT_MESSAGE), FUNCTION_EVENT_TIMEOUT);
+            // Dismiss navigation
+            this.chn.emit('dismiss:navigation', (error) => {
+                clearTimeout(timeout);
+                if (error)
+                    return reject(error);
+                resolve();
+            });
+        });
+    }
+}
+exports.default = Controls;
+//# sourceMappingURL=Controls.js.map