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

package/common/api/WebSocketAPI.d.ts

@@ -0,0 +1,95 @@
+export default WebSocketAPI;
+/**
+ * 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.
+ */
+declare class WebSocketAPI {
+    /**
+     * Get the websocket request string.
+     *
+     * @param {string} method Request mehtod {GET, SUB}.
+     * @param {Object} params Request parameters.
+     * @param {string} params.channel Channel name
+     * @param {string} [params.args] Request arguments
+     * @param {Number} [params.id] Request identifier
+     * @return {string} request string
+     * @private
+     */
+    private static getRequestString;
+    defineProperties(): void;
+    /**
+     * (Re)connect the websocket.
+     *
+     * @param {strin} url Websocket url.
+     * @param {function} onOpen Callback called when the websocket connection is opened and before subscriptions of previous subscriptions.
+     * @private
+     */
+    private connect;
+    /** @ignore */
+    websocket: WebSocket;
+    /**
+     * Close the websocket definitively.
+     *
+     * @private
+     */
+    private close;
+    messagesOnOpen: any[];
+    /**
+     * Sends a message to the websocket.
+     *
+     * @param {message} message Message to send.
+     * @private
+     */
+    private send;
+    /**
+     * Listen to websocket messages.
+     *
+     * @param {Object} params Parameters for the websocket get request
+     * @param {function} cb callback on listen
+     * @param {function} errorCb Callback on error
+     * @return {{onMessage: function, errorCb: function}} Object with onMessage and error callbacks
+     * @private
+     */
+    private listen;
+    /**
+     * Unlisten websocket messages.
+     *
+     * @param {Object} params Parameters for the websocket get request.
+     * @param {function} cb Callback used when listen.
+     * @private
+     */
+    private unlisten;
+    /**
+     * Sends a get request to the websocket.
+     *
+     * @param {Object} params Parameters for the websocket get request
+     * @param {function} cb callback on listen
+     * @param {function} errorCb Callback on error
+     * @private
+     */
+    private get;
+    /**
+     * Subscribe to a given channel.
+     *
+     * @param {Object} params Parameters for the websocket get request
+     * @param {function} cb callback on listen
+     * @param {function} errorCb Callback on error
+     * @param {boolean} quiet if false, no GET or SUB requests are send, only the callback is registered.
+     * @private
+     */
+    private subscribe;
+    /**
+     * 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
+     */
+    private unsubscribe;
+    subscriptions: any;
+    /**
+     * After an auto reconnection we need to re-subscribe to the channels.
+     */
+    subscribePreviousSubscriptions(): void;
+}
+//# sourceMappingURL=WebSocketAPI.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"WebSocketAPI.d.ts","sourceRoot":"","sources":["../../../src/common/api/WebSocketAPI.js"],"names":[],"mappings":";AAAA;;;;GAIG;AACH;IAiEE;;;;;;;;;;OAUG;IACH,gCAKC;IA5ED,yBA0DC;IAoBD;;;;;;OAMG;IACH,gBAiBC;IAZC,cAAc;IACd,qBAAmC;IAarC;;;;OAIG;IACH,cAOC;IAFG,sBAAwB;IAI5B;;;;;OAKG;IACH,aAsBC;IAED;;;;;;;;OAQG;IACH,eAsCC;IAED;;;;;;OAMG;IACH,iBAiBC;IAED;;;;;;;OAOG;IACH,YAIC;IAED;;;;;;;;OAQG;IACH,kBAqBC;IAED;;;;;OAKG;IACH,oBA8BC;IAfC,mBAEC;IAeH;;OAEG;IACH,uCAYC;CACF"}

package/common/api/WebSocketAPI.js

@@ -1,175 +1,320 @@
-class WebSocketAPI {
-  constructor() {
-    this.defineProperties();
-  }
-  defineProperties() {
-    Object.defineProperties(this, {
-      closed: {
-        get: () => !!(this.websocket && this.websocket.readyState === this.websocket.CLOSED)
-      },
-      closing: {
-        get: () => !!(this.websocket && this.websocket.readyState === this.websocket.CLOSING)
-      },
-      connecting: {
-        get: () => !!(this.websocket && this.websocket.readyState === this.websocket.CONNECTING)
-      },
-      open: {
-        get: () => !!(this.websocket && this.websocket.readyState === this.websocket.OPEN)
-      },
-      messagesOnOpen: {
-        value: [],
-        writable: true
-      },
-      subscriptions: {
-        value: [],
-        writable: true
-      },
-      subscribed: {
-        value: {},
-        writable: true
-      }
-    });
-  }
-  static getRequestString(method, params) {
-    let reqStr = `${method} ${params.channel}`;
-    reqStr += params.args ? ` ${params.args}` : "";
-    reqStr += params.id ? ` ${params.id}` : "";
-    return reqStr.trim();
-  }
-  connect(url, onOpen = () => {
-  }) {
-    if (this.websocket && !this.closed) {
-      this.websocket.close();
-    }
-    this.websocket = new WebSocket(url);
-    if (!this.open) {
-      this.websocket.addEventListener("open", () => {
-        onOpen();
-        this.subscribePreviousSubscriptions();
-      });
-    } else {
-      onOpen();
-      this.subscribePreviousSubscriptions();
-    }
-  }
-  close() {
-    if (this.websocket) {
-      this.websocket.onclose = null;
-      this.websocket.close();
-      this.websocket = null;
-      this.messagesOnOpen = [];
+"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];
+        }
     }
-  }
-  send(message) {
-    if (!this.websocket) {
-      return;
+    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() {
+        this.defineProperties();
     }
-    const send = () => {
-      this.websocket.send(message);
-    };
-    if (!this.open) {
-      if (!this.messagesOnOpen.includes(message)) {
-        this.messagesOnOpen.push(message);
-        this.websocket.addEventListener("open", () => {
-          this.messagesOnOpen = [];
-          send();
-        });
-        this.websocket.addEventListener("close", () => {
-          this.messagesOnOpen = [];
+    WebSocketAPI.prototype.defineProperties = function () {
+        var _this = this;
+        Object.defineProperties(this, {
+            closed: {
+                get: function () {
+                    return !!(_this.websocket &&
+                        _this.websocket.readyState === _this.websocket.CLOSED);
+                },
+            },
+            closing: {
+                get: function () {
+                    return !!(_this.websocket &&
+                        _this.websocket.readyState === _this.websocket.CLOSING);
+                },
+            },
+            connecting: {
+                get: function () {
+                    return !!(_this.websocket &&
+                        _this.websocket.readyState === _this.websocket.CONNECTING);
+                },
+            },
+            open: {
+                get: function () {
+                    return !!(_this.websocket && _this.websocket.readyState === _this.websocket.OPEN);
+                },
+            },
+            /**
+             * Array of message to send on open.
+             * @type {Array<string>}
+             * @private
+             */
+            messagesOnOpen: {
+                value: [],
+                writable: true,
+            },
+            /**
+             * Array of subscriptions.
+             * @type {Array<subscription>}
+             * @private
+             */
+            subscriptions: {
+                value: [],
+                writable: true,
+            },
+            /**
+             * List of channels subscribed.
+             * @type {Array<subscription>}
+             * @private
+             */
+            subscribed: {
+                value: {},
+                writable: true,
+            },
         });
-      }
-    } else if (!this.messagesOnOpen.includes(message)) {
-      send();
-    }
-  }
-  listen(params, cb, errorCb) {
-    this.unlisten(params, cb);
-    const onMessage = (evt) => {
-      let data = {};
-      try {
-        data = JSON.parse(evt.data);
-      } catch (err) {
-        console.error("WebSocket: unable to parse JSON data", err, evt.data);
-      }
-      let source = params.channel;
-      source += params.args ? ` ${params.args}` : "";
-      const contents = data.source === "buffer" ? data.content : [data];
-      contents.forEach((content) => {
-        if (content?.source === source && (!params.id || params.id === data.client_reference)) {
-          cb(content);
+    };
+    /**
+     * Get the websocket request string.
+     *
+     * @param {string} method Request mehtod {GET, SUB}.
+     * @param {Object} params Request parameters.
+     * @param {string} params.channel Channel name
+     * @param {string} [params.args] Request arguments
+     * @param {Number} [params.id] Request identifier
+     * @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) : '';
+        return reqStr.trim();
+    };
+    /**
+     * (Re)connect the websocket.
+     *
+     * @param {strin} url Websocket url.
+     * @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 () { }; }
+        if (this.websocket && !this.closed) {
+            this.websocket.close();
+        }
+        /** @ignore */
+        this.websocket = new WebSocket(url);
+        if (!this.open) {
+            this.websocket.addEventListener('open', function () {
+                onOpen();
+                _this.subscribePreviousSubscriptions();
+            });
+        }
+        else {
+            onOpen();
+            this.subscribePreviousSubscriptions();
         }
-      });
     };
-    if (this.websocket) {
-      this.websocket.addEventListener("message", onMessage);
-      if (errorCb) {
-        this.websocket.addEventListener("error", errorCb);
-        this.websocket.addEventListener("close", errorCb);
-      }
-    }
-    return { onMessageCb: onMessage, onErrorCb: errorCb };
-  }
-  unlisten(params, cb) {
-    if (!this.websocket) {
-      return;
-    }
-    this.subscriptions.filter((s) => s.params.channel === params.channel && (!cb || s.cb === cb)).forEach(({ onMessageCb, onErrorCb }) => {
-      if (this.websocket) {
-        this.websocket.removeEventListener("message", onMessageCb);
-        if (onErrorCb) {
-          this.websocket.removeEventListener("error", onErrorCb);
-          this.websocket.removeEventListener("close", onErrorCb);
+    /**
+     * Close the websocket definitively.
+     *
+     * @private
+     */
+    WebSocketAPI.prototype.close = function () {
+        if (this.websocket) {
+            this.websocket.onclose = null;
+            this.websocket.close();
+            this.websocket = null;
+            this.messagesOnOpen = [];
         }
-      }
-    });
-  }
-  get(params, cb, errorCb) {
-    const reqStr = WebSocketAPI.getRequestString("GET", params);
-    this.send(reqStr);
-    this.listen(params, cb, errorCb);
-  }
-  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;
-    } else {
-      this.subscriptions.push(newSubscr);
-    }
-    if (!this.subscribed[reqStr]) {
-      if (!newSubscr.quiet) {
-        this.send(`GET ${reqStr}`);
-        this.send(`SUB ${reqStr}`);
-      }
-      this.subscribed[reqStr] = true;
-    }
-  }
-  unsubscribe(source, cb) {
-    const toRemove = this.subscriptions.filter((s) => s.params.channel === source && (!cb || s.cb === cb));
-    toRemove.forEach(({ onMessageCb, onErrorCb }) => {
-      if (this.websocket) {
-        this.websocket.removeEventListener("message", onMessageCb);
-        if (onErrorCb) {
-          this.websocket.removeEventListener("error", onErrorCb);
-          this.websocket.removeEventListener("close", onErrorCb);
+    };
+    /**
+     * Sends a message to the websocket.
+     *
+     * @param {message} message Message to send.
+     * @private
+     */
+    WebSocketAPI.prototype.send = function (message) {
+        var _this = this;
+        if (!this.websocket) {
+            return;
         }
-      }
-    });
-    this.subscriptions = this.subscriptions.filter((s) => s.params.channel !== source || cb && s.cb !== cb);
-    if (source && this.subscribed[source] && !this.subscriptions.find((s) => s.params.channel === source) && toRemove.find((subscr) => !subscr.quiet)) {
-      this.send(`DEL ${source}`);
-      this.subscribed[source] = false;
-    }
-  }
-  subscribePreviousSubscriptions() {
-    Object.keys(this.subscribed).forEach((key) => {
-      this.subscribed[key] = false;
-    });
-    [...this.subscriptions].forEach((s) => {
-      this.subscribe(s.params, s.cb, s.errorCb, s.quiet);
-    });
-  }
-}
-export default WebSocketAPI;
+        var send = function () {
+            _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 = [];
+                    send();
+                });
+                this.websocket.addEventListener('close', function () {
+                    _this.messagesOnOpen = [];
+                });
+            }
+        }
+        else if (!this.messagesOnOpen.includes(message)) {
+            send();
+        }
+    };
+    /**
+     * Listen to websocket messages.
+     *
+     * @param {Object} params Parameters for the websocket get request
+     * @param {function} cb callback on listen
+     * @param {function} errorCb Callback on error
+     * @return {{onMessage: function, errorCb: function}} Object with onMessage and error callbacks
+     * @private
+     */
+    WebSocketAPI.prototype.listen = function (params, cb, errorCb) {
+        // Remove the previous identical callback
+        this.unlisten(params, cb);
+        var onMessage = function (evt) {
+            var data = {};
+            try {
+                data = JSON.parse(evt.data);
+            }
+            catch (err) {
+                // 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) : '';
+            // 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) {
+                // 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)) {
+                    cb(content);
+                }
+            });
+        };
+        if (this.websocket) {
+            this.websocket.addEventListener('message', onMessage);
+            if (errorCb) {
+                this.websocket.addEventListener('error', errorCb);
+                this.websocket.addEventListener('close', errorCb);
+            }
+        }
+        return { onMessageCb: onMessage, onErrorCb: errorCb };
+    };
+    /**
+     * Unlisten websocket messages.
+     *
+     * @param {Object} params Parameters for the websocket get request.
+     * @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);
+                }
+            }
+        });
+    };
+    /**
+     * Sends a get request to the websocket.
+     *
+     * @param {Object} params Parameters for the websocket get request
+     * @param {function} cb callback on listen
+     * @param {function} errorCb Callback on error
+     * @private
+     */
+    WebSocketAPI.prototype.get = function (params, cb, errorCb) {
+        var reqStr = WebSocketAPI.getRequestString('GET', params);
+        this.send(reqStr);
+        this.listen(params, cb, errorCb);
+    };
+    /**
+     * Subscribe to a given channel.
+     *
+     * @param {Object} params Parameters for the websocket get request
+     * @param {function} cb callback on listen
+     * @param {function} errorCb Callback on error
+     * @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 };
+        if (index > -1) {
+            this.subscriptions[index] = newSubscr;
+        }
+        else {
+            this.subscriptions.push(newSubscr);
+        }
+        if (!this.subscribed[reqStr]) {
+            if (!newSubscr.quiet) {
+                this.send("GET ".concat(reqStr));
+                this.send("SUB ".concat(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);
+                }
+            }
+        });
+        this.subscriptions = this.subscriptions.filter(function (s) { return 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.subscribed[source] = false;
+        }
+    };
+    /**
+     * After an auto reconnection we need to re-subscribe to the channels.
+     */
+    WebSocketAPI.prototype.subscribePreviousSubscriptions = function () {
+        var _this = this;
+        // 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;
+        });
+        // Subscribe all previous subscriptions.
+        __spreadArray([], this.subscriptions, true).forEach(function (s) {
+            _this.subscribe(s.params, s.cb, s.errorCb, s.quiet);
+        });
+    };
+    return WebSocketAPI;
+}());
+exports.default = WebSocketAPI;

package/common/controls/Control.d.ts

@@ -0,0 +1,74 @@
+export default Control;
+/**
+ * A class representing a control to display on map.
+ *
+ * @example
+ * const control = new Control();
+ *
+ * @classproperty {ol/Map~Map|mapboxgl.Map} map - The map which the control refers to.
+ * @classproperty {boolean} active - Active the control.
+ * @classproperty {HTMLElement} element - The HTML element used to render the control.
+ * @classproperty {HTMLElement} target - The HTML element where to render the element property. Default is the map's element. Read only.
+ */
+declare class Control extends BaseObject {
+    /**
+     * Constructor
+     *
+     * @param {Object} [options] Control options.
+     * @param {boolean} [options.active = true] Whether the control is active or not.
+     * @param {HTMLElement} [options.element] The HTML element used to render the control.
+     * @param {HTMLElement} [options.target] The HTML element where to render the element property. Default is the map's element.
+     * @param {function} [options.render] Render function called whenever the control needs to be rerendered.
+     */
+    constructor(options?: {
+        active?: boolean;
+        element?: HTMLElement;
+        target?: HTMLElement;
+        render?: Function;
+    });
+    /**
+     * @ignore
+     */
+    active: boolean;
+    /**
+     * Define control's properties.
+     *
+     * @private
+     */
+    private defineProperties;
+    /**
+     * Attach the control to the map. Add events, html element ...
+     */
+    attachToMap(map: any): void;
+    map: any;
+    /**
+     * Detach the control From the map. Remove events, html element ..
+     */
+    detachFromMap(): void;
+    /**
+     * Add listeners then renders the control.
+     * To be defined in inherited classes.
+     */
+    activate(): void;
+    /**
+     * Remove listeners added by activate() function then renders the control.
+     * To be defined in inherited classes.
+     */
+    deactivate(): void;
+    /**
+     * The default render function. It renders content in the HTML element.
+     * To be defined in inherited classes.
+     *
+     * @private
+     */
+    private render;
+    /**
+     * The default element to display if this.element is not defined.
+     * To be defined in inherited classes.
+     *
+     * @private
+     */
+    private createDefaultElement;
+}
+import BaseObject from "ol/Object";
+//# sourceMappingURL=Control.d.ts.map

package/common/controls/Control.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Control.d.ts","sourceRoot":"","sources":["../../../src/common/controls/Control.js"],"names":[],"mappings":";AAEA;;;;;;;;;;GAUG;AACH;IACE;;;;;;;;OAQG;IACH;QAL6B,MAAM,GAAxB,OAAO;QACe,OAAO,GAA7B,WAAW;QACW,MAAM,GAA5B,WAAW;QACQ,MAAM;OAenC;IAJC;;OAEG;IACH,gBAAoB;IAGtB;;;;OAIG;IACH,yBAmEC;IAED;;OAEG;IACH,4BAEC;IADC,SAAc;IAGhB;;OAEG;IACH,sBAEC;IAED;;;OAGG;IACH,iBAEC;IAED;;;OAGG;IAEH,mBAAe;IAEf;;;;;OAKG;IACH,eAAW;IAEX;;;;;OAKG;IAEH,6BAAyB;CAC1B"}