mobility-toolbox-js 2.0.1-beta.13 → 2.1.0

package/common/api/WebSocketAPI.js

@@ -1,175 +1,341 @@
-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();
+/**
+ * Class used to facilitate connection to a WebSocketAPI and
+ * also to manage properly messages send to the WebSocketAPI.
+ * This class must not contain any specific implementation.
+ */
+class WebSocketAPI {
+    constructor() {
+        this.defineProperties();
     }
-    this.websocket = new WebSocket(url);
-    if (!this.open) {
-      this.websocket.addEventListener("open", () => {
-        onOpen();
-        this.subscribePreviousSubscriptions();
-      });
-    } else {
-      onOpen();
-      this.subscribePreviousSubscriptions();
+    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),
+            },
+            /**
+             * Array of message to send on open.
+             * @type {Array<string>}
+             * @private
+             */
+            messagesOnOpen: {
+                value: [],
+                writable: true,
+            },
+            /**
+             * Array of subscriptions.
+             * @type {Array<WebSocketSubscription>}
+             * @private
+             */
+            subscriptions: {
+                value: [],
+                writable: true,
+            },
+            /**
+             * List of channels subscribed.
+             * @type {WebSocketSubscribed}
+             * @private
+             */
+            subscribed: {
+                value: {},
+                writable: true,
+            },
+        });
     }
-  }
-  close() {
-    if (this.websocket) {
-      this.websocket.onclose = null;
-      this.websocket.close();
-      this.websocket = null;
-      this.messagesOnOpen = [];
+    /**
+     * Get the websocket request string.
+     *
+     * @param {string} method Request mehtod {GET, SUB}.
+     * @param {WebSocketParameters} params Request parameters.
+     * @param {string} params.channel Channel name
+     * @param {string} [params.args] Request arguments
+     * @param {Number|string} [params.id] Request identifier
+     * @return {string} request string
+     * @private
+     */
+    static getRequestString(method, params = {}) {
+        let reqStr = `${method} ${params.channel}`;
+        reqStr += params.args ? ` ${params.args}` : '';
+        reqStr += params.id ? ` ${params.id}` : '';
+        return reqStr.trim();
     }
-  }
-  send(message) {
-    if (!this.websocket) {
-      return;
+    /**
+     * (Re)connect the websocket.
+     *
+     * @param {string} url Websocket url.
+     * @param {function} onOpen Callback called when the websocket connection is opened and before subscriptions of previous subscriptions.
+     * @private
+     */
+    connect(url, onOpen = () => { }) {
+        var _a;
+        // if no url specify, close the current websocket and do nothing.
+        if (!url) {
+            (_a = this.websocket) === null || _a === void 0 ? void 0 : _a.close();
+            return;
+        }
+        // Behavior when a websocket already exists.
+        if (this.websocket) {
+            // If the current websocket has the same url and is open or is connecting, do nothing.
+            if (this.websocket.url === url && (this.open || this.connecting)) {
+                return;
+            }
+            // If the current websocket has not the same url and is open or is connecting, close it.
+            if (this.websocket.url !== url && (this.open || this.connecting)) {
+                this.websocket.close();
+            }
+        }
+        /** @ignore */
+        this.websocket = new WebSocket(url);
+        if (!this.open) {
+            this.websocket.addEventListener('open', () => {
+                onOpen();
+                this.subscribePreviousSubscriptions();
+            });
+        }
+        else {
+            onOpen();
+            this.subscribePreviousSubscriptions();
+        }
     }
-    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 = [];
-        });
-      }
-    } else if (!this.messagesOnOpen.includes(message)) {
-      send();
+    /**
+     * Close the websocket definitively.
+     *
+     * @private
+     */
+    close() {
+        if (this.websocket && (this.open || this.connecting)) {
+            this.websocket.onclose = () => { };
+            this.websocket.close();
+            this.messagesOnOpen = [];
+        }
+    }
+    /**
+     * Sends a message to the websocket.
+     *
+     * @param {message} message Message to send.
+     * @private
+     */
+    send(message) {
+        if (!this.websocket || this.closed || this.closing) {
+            return;
+        }
+        const send = () => {
+            var _a;
+            (_a = this.websocket) === null || _a === void 0 ? void 0 : _a.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', () => {
+                    this.messagesOnOpen = [];
+                    send();
+                });
+                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);
+            }
+        }
     }
-  }
-  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);
-        }
-      });
-    };
-    if (this.websocket) {
-      this.websocket.addEventListener("message", onMessage);
-      if (errorCb) {
-        this.websocket.addEventListener("error", errorCb);
-        this.websocket.addEventListener("close", errorCb);
-      }
+    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.
+     *
+     * @param {WebSocketParameters} 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
+     */
+    listen(params, cb, errorCb) {
+        // Remove the previous identical callback
+        this.unlisten(params, cb);
+        // 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);
+            }
+            catch (err) {
+                // eslint-disable-next-line no-console
+                console.error('WebSocket: unable to parse JSON data', err, evt.data);
+                return;
+            }
+            let source = params.channel;
+            source += params.args ? ` ${params.args}` : '';
+            // Buffer channel message return a list of other channels to propagate to proper callbacks.
+            let contents;
+            if (data.source === 'buffer') {
+                contents = data
+                    .content;
+            }
+            else {
+                contents = [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)) {
+                    cb(content);
+                }
+            });
+        };
+        this.addEvents(onMessage, 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
+     */
+    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);
+        });
     }
-    return { onMessageCb: onMessage, onErrorCb: errorCb };
-  }
-  unlisten(params, cb) {
-    if (!this.websocket) {
-      return;
+    /**
+     * 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} onMessage callback on message event
+     * @param {function} onError Callback on error and close event
+     * @private
+     */
+    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) => 
+        // @ts-ignore: Spread error
+        (...args) => {
+            // @ts-ignore: Spread error
+            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), errorCb && 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);
+        }
     }
-    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);
-        }
-      }
-    });
-  }
-  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);
+    /**
+     * 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
+     */
+    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;
+        }
     }
-    if (!this.subscribed[reqStr]) {
-      if (!newSubscr.quiet) {
-        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
+     */
+    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((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((s) => s.params.channel === source) &&
+            toRemove.find((subscr) => !subscr.quiet)) {
+            this.send(`DEL ${source}`);
+            this.subscribed[source] = false;
+        }
     }
-  }
-  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);
-        }
-      }
-    });
-    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;
+    /**
+     * After an auto reconnection we need to re-subscribe to the channels.
+     */
+    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((key) => {
+            this.subscribed[key] = false;
+        });
+        // Subscribe all previous subscriptions.
+        [...this.subscriptions].forEach((s) => {
+            this.subscribe(s.params, s.cb, s.errorCb, s.quiet);
+        });
     }
-  }
-  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;
+export default WebSocketAPI;

package/common/controls/ControlCommon.d.ts

@@ -0,0 +1,76 @@
+import BaseObject from 'ol/Object';
+import type { AnyMap } from '../../types';
+export type ControlCommonOptions = {
+    active?: Boolean;
+    element?: HTMLElement;
+    target?: HTMLElement;
+    render?: () => void;
+};
+/**
+ * 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 ControlCommon extends BaseObject {
+    active: Boolean;
+    map?: AnyMap;
+    target?: HTMLElement;
+    element?: HTMLElement;
+    /**
+     * 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?: ControlCommonOptions);
+    /**
+     * Define control's properties.
+     *
+     * @private
+     * @ignore
+     */
+    defineProperties(options: ControlCommonOptions): void;
+    /**
+     * Attach the control to the map. Add events, html element ...
+     */
+    attachToMap(map: AnyMap): void;
+    /**
+     * 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
+     */
+    render(options?: any): void;
+    /**
+     * The default element to display if this.element is not defined.
+     * To be defined in inherited classes.
+     *
+     * @private
+     */
+    createDefaultElement(): void;
+}
+export default ControlCommon;
+//# sourceMappingURL=ControlCommon.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ControlCommon.d.ts","sourceRoot":"","sources":["../../../src/common/controls/ControlCommon.ts"],"names":[],"mappings":"AACA,OAAO,UAAU,MAAM,WAAW,CAAC;AACnC,OAAO,KAAK,EAAE,MAAM,EAAgB,MAAM,aAAa,CAAC;AAExD,MAAM,MAAM,oBAAoB,GAAG;IACjC,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;CACrB,CAAC;AAEF;;;;;;;;;;GAUG;AACH,cAAM,aAAc,SAAQ,UAAU;IACpC,MAAM,EAAE,OAAO,CAAC;IAEhB,GAAG,CAAC,EAAE,MAAM,CAAC;IAEb,MAAM,CAAC,EAAE,WAAW,CAAC;IAErB,OAAO,CAAC,EAAE,WAAW,CAAC;IAEtB;;;;;;;;OAQG;gBACS,OAAO,GAAE,oBAAyB;IAe9C;;;;;OAKG;IACH,gBAAgB,CAAC,OAAO,EAAE,oBAAoB;IAuE9C;;OAEG;IACH,WAAW,CAAC,GAAG,EAAE,MAAM;IAIvB;;OAEG;IACH,aAAa;IAIb;;;OAGG;IACH,QAAQ;IAIR;;;OAGG;IAEH,UAAU;IAOV;;;;;OAKG;IAEH,MAAM,CAAC,OAAO,CAAC,EAAE,GAAG;IAKpB;;;;;OAKG;IAEH,oBAAoB;CAMrB;AAED,eAAe,aAAa,CAAC"}