@de./sdk 1.0.4 → 2.0.0

package/dist/allend/MSI/Controls.js

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