mobility-toolbox-js 2.0.0-beta.34 → 2.0.0-beta.37

package/common/api/WebSocketAPI.js

@@ -1,48 +1,28 @@
-"use strict";
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * Class used to facilitate connection to a WebSocket and
  * also to manage properly messages send to the WebSocket.
  * This class must not contain any specific implementation.
  */
-var WebSocketAPI = /** @class */ (function () {
-    function WebSocketAPI() {
+class WebSocketAPI {
+    constructor() {
         this.defineProperties();
     }
-    WebSocketAPI.prototype.defineProperties = function () {
-        var _this = this;
+    defineProperties() {
         Object.defineProperties(this, {
             closed: {
-                get: function () {
-                    return !!(_this.websocket &&
-                        _this.websocket.readyState === _this.websocket.CLOSED);
-                },
+                get: () => !!(this.websocket &&
+                    this.websocket.readyState === this.websocket.CLOSED),
             },
             closing: {
-                get: function () {
-                    return !!(_this.websocket &&
-                        _this.websocket.readyState === _this.websocket.CLOSING);
-                },
+                get: () => !!(this.websocket &&
+                    this.websocket.readyState === this.websocket.CLOSING),
             },
             connecting: {
-                get: function () {
-                    return !!(_this.websocket &&
-                        _this.websocket.readyState === _this.websocket.CONNECTING);
-                },
+                get: () => !!(this.websocket &&
+                    this.websocket.readyState === this.websocket.CONNECTING),
             },
             open: {
-                get: function () {
-                    return !!(_this.websocket && _this.websocket.readyState === _this.websocket.OPEN);
-                },
+                get: () => !!(this.websocket && this.websocket.readyState === this.websocket.OPEN),
             },
             /**
              * Array of message to send on open.
@@ -72,7 +52,7 @@ var WebSocketAPI = /** @class */ (function () {
                 writable: true,
             },
         });
-    };
+    }
     /**
      * Get the websocket request string.
      *
@@ -84,12 +64,12 @@ var WebSocketAPI = /** @class */ (function () {
      * @return {string} request string
      * @private
      */
-    WebSocketAPI.getRequestString = function (method, params) {
-        var reqStr = "".concat(method, " ").concat(params.channel);
-        reqStr += params.args ? " ".concat(params.args) : '';
-        reqStr += params.id ? " ".concat(params.id) : '';
+    static getRequestString(method, params) {
+        let reqStr = `${method} ${params.channel}`;
+        reqStr += params.args ? ` ${params.args}` : '';
+        reqStr += params.id ? ` ${params.id}` : '';
         return reqStr.trim();
-    };
+    }
     /**
      * (Re)connect the websocket.
      *
@@ -97,69 +77,84 @@ var WebSocketAPI = /** @class */ (function () {
      * @param {function} onOpen Callback called when the websocket connection is opened and before subscriptions of previous subscriptions.
      * @private
      */
-    WebSocketAPI.prototype.connect = function (url, onOpen) {
-        var _this = this;
-        if (onOpen === void 0) { onOpen = function () { }; }
+    connect(url, onOpen = () => { }) {
         if (this.websocket && !this.closed) {
             this.websocket.close();
         }
         /** @ignore */
         this.websocket = new WebSocket(url);
         if (!this.open) {
-            this.websocket.addEventListener('open', function () {
+            this.websocket.addEventListener('open', () => {
                 onOpen();
-                _this.subscribePreviousSubscriptions();
+                this.subscribePreviousSubscriptions();
             });
         }
         else {
             onOpen();
             this.subscribePreviousSubscriptions();
         }
-    };
+    }
     /**
      * Close the websocket definitively.
      *
      * @private
      */
-    WebSocketAPI.prototype.close = function () {
+    close() {
         if (this.websocket) {
             this.websocket.onclose = null;
             this.websocket.close();
             this.websocket = null;
             this.messagesOnOpen = [];
         }
-    };
+    }
     /**
      * Sends a message to the websocket.
      *
      * @param {message} message Message to send.
      * @private
      */
-    WebSocketAPI.prototype.send = function (message) {
-        var _this = this;
+    send(message) {
         if (!this.websocket) {
             return;
         }
-        var send = function () {
-            _this.websocket.send(message);
+        const send = () => {
+            this.websocket.send(message);
         };
         if (!this.open) {
             // This 'if' avoid sending 2 identical BBOX message on open,
             if (!this.messagesOnOpen.includes(message)) {
                 this.messagesOnOpen.push(message);
-                this.websocket.addEventListener('open', function () {
-                    _this.messagesOnOpen = [];
+                this.websocket.addEventListener('open', () => {
+                    this.messagesOnOpen = [];
                     send();
                 });
-                this.websocket.addEventListener('close', function () {
-                    _this.messagesOnOpen = [];
+                this.websocket.addEventListener('close', () => {
+                    this.messagesOnOpen = [];
                 });
             }
         }
         else if (!this.messagesOnOpen.includes(message)) {
             send();
         }
-    };
+    }
+    addEvents(onMessage, onError) {
+        if (this.websocket) {
+            this.websocket.addEventListener('message', onMessage);
+            if (onError) {
+                this.websocket.addEventListener('error', onError);
+                this.websocket.addEventListener('close', onError);
+            }
+        }
+    }
+    removeEvents(onMessage, onError) {
+        if (this.websocket) {
+            this.websocket.removeEventListener('message', onMessage);
+            if (onError) {
+                this.websocket.removeEventListener('error', onError);
+                this.websocket.removeEventListener('close', onError);
+            }
+        }
+    }
     /**
      * Listen to websocket messages.
      *
@@ -169,11 +164,12 @@ var WebSocketAPI = /** @class */ (function () {
      * @return {{onMessage: function, errorCb: function}} Object with onMessage and error callbacks
      * @private
      */
-    WebSocketAPI.prototype.listen = function (params, cb, errorCb) {
+    listen(params, cb, errorCb) {
         // Remove the previous identical callback
-        this.unlisten(params, cb);
-        var onMessage = function (evt) {
-            var data = {};
+        this.unlisten(params, cb, errorCb);
+        // We wrap the message callback to be sure we only propagate the message if it is for the right channel.
+        const onMessage = (evt) => {
+            let data = {};
             try {
                 data = JSON.parse(evt.data);
             }
@@ -181,11 +177,11 @@ var WebSocketAPI = /** @class */ (function () {
                 // eslint-disable-next-line no-console
                 console.error('WebSocket: unable to parse JSON data', err, evt.data);
             }
-            var source = params.channel;
-            source += params.args ? " ".concat(params.args) : '';
+            let source = params.channel;
+            source += params.args ? ` ${params.args}` : '';
             // Buffer channel message return a list of other channels to propagate to proper callbacks.
-            var contents = data.source === 'buffer' ? data.content : [data];
-            contents.forEach(function (content) {
+            const contents = data.source === 'buffer' ? data.content : [data];
+            contents.forEach((content) => {
                 // Because of backend optimization, the last content is null.
                 if ((content === null || content === void 0 ? void 0 : content.source) === source &&
                     (!params.id || params.id === data.client_reference)) {
@@ -193,15 +189,9 @@ var WebSocketAPI = /** @class */ (function () {
                 }
             });
         };
-        if (this.websocket) {
-            this.websocket.addEventListener('message', onMessage);
-            if (errorCb) {
-                this.websocket.addEventListener('error', errorCb);
-                this.websocket.addEventListener('close', errorCb);
-            }
-        }
+        this.addEvents(onMessage, errorCb);
         return { onMessageCb: onMessage, onErrorCb: errorCb };
-    };
+    }
     /**
      * Unlisten websocket messages.
      *
@@ -209,37 +199,54 @@ var WebSocketAPI = /** @class */ (function () {
      * @param {function} cb Callback used when listen.
      * @private
      */
-    WebSocketAPI.prototype.unlisten = function (params, cb) {
-        var _this = this;
-        if (!this.websocket) {
-            return;
-        }
-        this.subscriptions
-            .filter(function (s) { return s.params.channel === params.channel && (!cb || s.cb === cb); })
-            .forEach(function (_a) {
-            var onMessageCb = _a.onMessageCb, onErrorCb = _a.onErrorCb;
-            if (_this.websocket) {
-                _this.websocket.removeEventListener('message', onMessageCb);
-                if (onErrorCb) {
-                    _this.websocket.removeEventListener('error', onErrorCb);
-                    _this.websocket.removeEventListener('close', onErrorCb);
-                }
-            }
+    unlisten(params, cb) {
+        [...(this.subscriptions || []), ...(this.requests || [])]
+            .filter((s) => s.params.channel === params.channel && (!cb || s.cb === cb))
+            .forEach(({ onMessageCb, onErrorCb }) => {
+            this.removeEvents(onMessageCb, onErrorCb);
         });
-    };
+    }
     /**
      * Sends a get request to the websocket.
+     * The callback is called only once, when the response is received or when the call returns an error.
      *
      * @param {Object} params Parameters for the websocket get request
-     * @param {function} cb callback on listen
-     * @param {function} errorCb Callback on error
+     * @param {function} onMessage callback on message event
+     * @param {function} onError Callback on error and close event
      * @private
      */
-    WebSocketAPI.prototype.get = function (params, cb, errorCb) {
-        var reqStr = WebSocketAPI.getRequestString('GET', params);
-        this.send(reqStr);
-        this.listen(params, cb, errorCb);
-    };
+    get(params, cb, errorCb) {
+        const requestString = WebSocketAPI.getRequestString('GET', params);
+        this.send(requestString);
+        // We wrap the callbacks to make sure they are called only once.
+        const once = (callback) => (...args) => {
+            callback(...args);
+            const index = this.requests.findIndex((request) => requestString === request.requestString && cb === request.cb);
+            const { onMessageCb, onErrorCb } = this.requests[index];
+            this.removeEvents(onMessageCb, onErrorCb);
+            this.requests.splice(index, 1);
+        };
+        const { onMessageCb, onErrorCb } = this.listen(params, once(cb), once(errorCb));
+        // Store requests and callbacks to be able to remove them.
+        if (!this.requests) {
+            this.requests = [];
+        }
+        const index = this.requests.findIndex((request) => requestString === request.requestString && cb === request.cb);
+        const newReq = {
+            params,
+            requestString,
+            cb,
+            errorCb,
+            onMessageCb,
+            onErrorCb,
+        };
+        if (index > -1) {
+            this.requests[index] = newReq;
+        }
+        else {
+            this.requests.push(newReq);
+        }
+    }
     /**
      * Subscribe to a given channel.
      *
@@ -249,12 +256,11 @@ var WebSocketAPI = /** @class */ (function () {
      * @param {boolean} quiet if false, no GET or SUB requests are send, only the callback is registered.
      * @private
      */
-    WebSocketAPI.prototype.subscribe = function (params, cb, errorCb, quiet) {
-        if (quiet === void 0) { quiet = false; }
-        var _a = this.listen(params, cb, errorCb), onMessageCb = _a.onMessageCb, onErrorCb = _a.onErrorCb;
-        var reqStr = WebSocketAPI.getRequestString('', params);
-        var index = this.subscriptions.findIndex(function (subcr) { return params.channel === subcr.params.channel && cb === subcr.cb; });
-        var newSubscr = { params: params, cb: cb, errorCb: errorCb, onMessageCb: onMessageCb, onErrorCb: onErrorCb, quiet: quiet };
+    subscribe(params, cb, errorCb, quiet = false) {
+        const { onMessageCb, onErrorCb } = this.listen(params, cb, errorCb);
+        const reqStr = WebSocketAPI.getRequestString('', params);
+        const index = this.subscriptions.findIndex((subcr) => params.channel === subcr.params.channel && cb === subcr.cb);
+        const newSubscr = { params, cb, errorCb, onMessageCb, onErrorCb, quiet };
         if (index > -1) {
             this.subscriptions[index] = newSubscr;
         }
@@ -263,58 +269,48 @@ var WebSocketAPI = /** @class */ (function () {
         }
         if (!this.subscribed[reqStr]) {
             if (!newSubscr.quiet) {
-                this.send("GET ".concat(reqStr));
-                this.send("SUB ".concat(reqStr));
+                this.send(`GET ${reqStr}`);
+                this.send(`SUB ${reqStr}`);
             }
             this.subscribed[reqStr] = true;
         }
-    };
+    }
     /**
      * Unsubscribe from a channel.
      * @param {string} source source to unsubscribe from
      * @param {function} cb Callback function to unsubscribe. If null all subscriptions for the channel will be unsubscribed.
      * @private
      */
-    WebSocketAPI.prototype.unsubscribe = function (source, cb) {
-        var _this = this;
-        var toRemove = this.subscriptions.filter(function (s) { return s.params.channel === source && (!cb || s.cb === cb); });
-        toRemove.forEach(function (_a) {
-            var onMessageCb = _a.onMessageCb, onErrorCb = _a.onErrorCb;
-            if (_this.websocket) {
-                _this.websocket.removeEventListener('message', onMessageCb);
-                if (onErrorCb) {
-                    _this.websocket.removeEventListener('error', onErrorCb);
-                    _this.websocket.removeEventListener('close', onErrorCb);
-                }
-            }
+    unsubscribe(source, cb) {
+        const toRemove = this.subscriptions.filter((s) => s.params.channel === source && (!cb || s.cb === cb));
+        toRemove.forEach(({ onMessageCb, onErrorCb }) => {
+            this.removeEvents(onMessageCb, onErrorCb);
         });
-        this.subscriptions = this.subscriptions.filter(function (s) { return s.params.channel !== source || (cb && s.cb !== cb); });
+        this.subscriptions = this.subscriptions.filter((s) => s.params.channel !== source || (cb && s.cb !== cb));
         // If there is no more subscriptions to this channel, and the removed subscriptions didn't register quietly,
         // we DEL it.
         if (source &&
             this.subscribed[source] &&
-            !this.subscriptions.find(function (s) { return s.params.channel === source; }) &&
-            toRemove.find(function (subscr) { return !subscr.quiet; })) {
-            this.send("DEL ".concat(source));
+            !this.subscriptions.find((s) => s.params.channel === source) &&
+            toRemove.find((subscr) => !subscr.quiet)) {
+            this.send(`DEL ${source}`);
             this.subscribed[source] = false;
         }
-    };
+    }
     /**
      * After an auto reconnection we need to re-subscribe to the channels.
      */
-    WebSocketAPI.prototype.subscribePreviousSubscriptions = function () {
-        var _this = this;
+    subscribePreviousSubscriptions() {
         // Before to subscribe previous subscriptions we make sure they
         // are all defined as unsubscribed, because this code is asynchrone
         // and a subscription could have been added in between.
-        Object.keys(this.subscribed).forEach(function (key) {
-            _this.subscribed[key] = false;
+        Object.keys(this.subscribed).forEach((key) => {
+            this.subscribed[key] = false;
         });
         // Subscribe all previous subscriptions.
-        __spreadArray([], this.subscriptions, true).forEach(function (s) {
-            _this.subscribe(s.params, s.cb, s.errorCb, s.quiet);
+        [...this.subscriptions].forEach((s) => {
+            this.subscribe(s.params, s.cb, s.errorCb, s.quiet);
         });
-    };
-    return WebSocketAPI;
-}());
-exports.default = WebSocketAPI;
+    }
+}
+export default WebSocketAPI;

package/common/api/WebSocketAPI.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=WebSocketAPI.test.d.ts.map

package/common/api/WebSocketAPI.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebSocketAPI.test.d.ts","sourceRoot":"","sources":["../../../src/common/api/WebSocketAPI.test.js"],"names":[],"mappings":""}