mobility-toolbox-js 3.0.0-beta.19 → 3.0.0-beta.20

package/api/RoutingAPI.d.ts

@@ -1,9 +1,9 @@
-import HttpAPI from './HttpAPI';
 import { RoutingParameters, RoutingResponse } from '../types';
-export type RoutingAPIOptions = {
-    url?: string;
+import HttpAPI from './HttpAPI';
+export interface RoutingAPIOptions {
     apiKey?: string;
-};
+    url?: string;
+}
 /**
  * This class provides convenience methods to use to the [geOps Routing API](https://developer.geops.io/apis/routing).
  *

package/api/StopsAPI.d.ts

@@ -1,9 +1,9 @@
-import HttpAPI from './HttpAPI';
 import { StopsParameters, StopsResponse } from '../types';
-export type StopsAPIOptions = {
-    url?: string;
+import HttpAPI from './HttpAPI';
+export interface StopsAPIOptions {
     apiKey?: string;
-};
+    url?: string;
+}
 /**
  * This class provides convenience methods to use to the [geOps Stops API](https://developer.geops.io/apis/stops/).
  *

package/api/WebSocketAPI.d.ts

@@ -1,49 +1,43 @@
 import { RealtimeTrajectoryResponse } from '../types';
-export declare type WebSocketAPIParameters = {
+export declare interface WebSocketAPIParameters {
+    args?: number | string;
     channel?: string;
-    args?: string | number;
-    id?: string | number;
-};
-export declare type WebSocketAPIMessageEventData<T> = {
-    timestamp: number;
-    source: string;
+    id?: number | string;
+}
+export declare interface WebSocketAPIMessageEventData<T> {
+    client_reference: null | number | string;
     content: T;
-    client_reference: string | number | null;
-};
-export type WebSocketAPIBufferMessageEventData = WebSocketAPIMessageEventData<RealtimeTrajectoryResponse[]> & {
+    source: string;
+    timestamp: number;
+}
+export type WebSocketAPIBufferMessageEventData = {
     source: 'buffer';
-};
-export type WebSocketAPIMessageEvent = Event & {
+} & WebSocketAPIMessageEventData<RealtimeTrajectoryResponse[]>;
+export type WebSocketAPIMessageEvent = {
     data: string;
-};
-export interface WebSocketAPIMessageEventListener {
-    (evt: WebSocketAPIMessageEvent): void;
-}
+} & Event;
+export type WebSocketAPIMessageEventListener = (evt: WebSocketAPIMessageEvent) => void;
 /**
  * This type represents a function that has been call with each feature returned by the websocket.
  */
-export interface WebSocketAPIMessageCallback<T> {
-    (data: WebSocketAPIMessageEventData<T>): void;
-}
-export declare type WebSocketAPISubscription = {
-    params: WebSocketAPIParameters;
+export type WebSocketAPIMessageCallback<T> = (data: WebSocketAPIMessageEventData<T>) => void;
+export declare interface WebSocketAPISubscription {
     cb: WebSocketAPIMessageCallback<any>;
     errorCb?: EventListener;
-    onMessageCb: WebSocketAPIMessageEventListener;
     onErrorCb?: EventListener;
-    quiet: boolean;
-};
-export declare type WebSocketAPISubscribed = {
-    [index: string]: boolean;
-};
-export declare type WebSocketAPIRequest = {
+    onMessageCb: WebSocketAPIMessageEventListener;
     params: WebSocketAPIParameters;
+    quiet: boolean;
+}
+export type WebSocketAPISubscribed = Record<string, boolean>;
+export declare interface WebSocketAPIRequest {
     cb: WebSocketAPIMessageCallback<any>;
     errorCb?: EventListener;
-    onMessageCb: WebSocketAPIMessageEventListener;
     onErrorCb?: EventListener;
-    requestString: String;
-};
+    onMessageCb: WebSocketAPIMessageEventListener;
+    params: WebSocketAPIParameters;
+    requestString: string;
+}
 /**
  * Class used to facilitate connection to a WebSocketAPI and
  * also to manage properly messages send to the WebSocketAPI.
@@ -51,17 +45,16 @@ export declare type WebSocketAPIRequest = {
  * @private
  */
 declare class WebSocketAPI {
-    websocket?: WebSocket;
     closed?: boolean;
     closing?: boolean;
     connecting?: boolean;
+    messagesOnOpen: string[];
     open?: boolean;
-    messagesOnOpen: Array<string>;
-    subscriptions: Array<WebSocketAPISubscription>;
+    requests: WebSocketAPIRequest[];
     subscribed: WebSocketAPISubscribed;
-    requests: Array<WebSocketAPIRequest>;
+    subscriptions: WebSocketAPISubscription[];
+    websocket?: WebSocket;
     constructor();
-    defineProperties(): void;
     /**
      * Get the websocket request string.
      *
@@ -74,29 +67,32 @@ declare class WebSocketAPI {
      * @private
      */
     static getRequestString(method: string, params?: WebSocketAPIParameters): string;
+    addEvents(onMessage: WebSocketAPIMessageEventListener, onError?: EventListener): void;
     /**
-     * (Re)connect the websocket.
+     * Close the websocket definitively.
      *
-     * @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: string, onOpen?: () => void): void;
+    close(): void;
     /**
-     * Close the websocket definitively.
+     * (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
      */
-    close(): void;
+    connect(url: string, onOpen?: () => void): void;
+    defineProperties(): void;
     /**
-     * Sends a message to the websocket.
+     * 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 {message} message Message to send.
+     * @param {Object} params Parameters for the websocket get request
+     * @param {function} cb callback on message event
+     * @param {function} errorCb Callback on error and close event
      * @private
      */
-    send(message: string): void;
-    addEvents(onMessage: WebSocketAPIMessageEventListener, onError?: EventListener): void;
-    removeEvents(onMessage: WebSocketAPIMessageEventListener, onError?: EventListener): void;
+    get(params: WebSocketAPIParameters, cb: WebSocketAPIMessageCallback<any>, errorCb?: EventListener): void;
     /**
      * Listen to websocket messages.
      *
@@ -107,27 +103,17 @@ declare class WebSocketAPI {
      * @private
      */
     listen(params: WebSocketAPIParameters, cb: WebSocketAPIMessageCallback<any>, errorCb?: EventListener): {
-        onMessageCb: WebSocketAPIMessageEventListener;
         onErrorCb?: EventListener;
+        onMessageCb: WebSocketAPIMessageEventListener;
     };
+    removeEvents(onMessage: WebSocketAPIMessageEventListener, onError?: EventListener): void;
     /**
-     * Unlisten websocket messages.
-     *
-     * @param {Object} params Parameters for the websocket get request.
-     * @param {function} cb Callback used when listen.
-     * @private
-     */
-    unlisten(params: WebSocketAPIParameters, cb: WebSocketAPIMessageCallback<any>): void;
-    /**
-     * 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.
+     * Sends a message to the websocket.
      *
-     * @param {Object} params Parameters for the websocket get request
-     * @param {function} cb callback on message event
-     * @param {function} errorCb Callback on error and close event
+     * @param {message} message Message to send.
      * @private
      */
-    get(params: WebSocketAPIParameters, cb: WebSocketAPIMessageCallback<any>, errorCb?: EventListener): void;
+    send(message: string): void;
     /**
      * Subscribe to a given channel.
      *
@@ -138,6 +124,18 @@ declare class WebSocketAPI {
      * @private
      */
     subscribe(params: WebSocketAPIParameters, cb: WebSocketAPIMessageCallback<any>, errorCb?: EventListener, quiet?: boolean): void;
+    /**
+     * After an auto reconnection we need to re-subscribe to the channels.
+     */
+    subscribePreviousSubscriptions(): void;
+    /**
+     * Unlisten websocket messages.
+     *
+     * @param {Object} params Parameters for the websocket get request.
+     * @param {function} cb Callback used when listen.
+     * @private
+     */
+    unlisten(params: WebSocketAPIParameters, cb: WebSocketAPIMessageCallback<any>): void;
     /**
      * Unsubscribe from a channel.
      * @param {string} source source to unsubscribe from
@@ -145,9 +143,5 @@ declare class WebSocketAPI {
      * @private
      */
     unsubscribe(source: string, cb?: WebSocketAPIMessageCallback<any>): void;
-    /**
-     * After an auto reconnection we need to re-subscribe to the channels.
-     */
-    subscribePreviousSubscriptions(): void;
 }
 export default WebSocketAPI;

package/api/WebSocketAPI.js

@@ -8,52 +8,6 @@ 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),
-            },
-            /**
-             * 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,
-            },
-        });
-    }
     /**
      * Get the websocket request string.
      *
@@ -71,6 +25,27 @@ class WebSocketAPI {
         reqStr += params.id ? ` ${params.id}` : '';
         return reqStr.trim();
     }
+    addEvents(onMessage, onError) {
+        if (this.websocket) {
+            this.websocket.addEventListener('message', onMessage);
+            if (onError) {
+                this.websocket.addEventListener('error', onError);
+                this.websocket.addEventListener('close', onError);
+            }
+        }
+    }
+    /**
+     * Close the websocket definitively.
+     *
+     * @private
+     */
+    close() {
+        if (this.websocket && (this.open || this.connecting)) {
+            this.websocket.onclose = () => { };
+            this.websocket.close();
+            this.messagesOnOpen = [];
+        }
+    }
     /**
      * (Re)connect the websocket.
      *
@@ -109,65 +84,94 @@ class WebSocketAPI {
             this.subscribePreviousSubscriptions();
         }
     }
-    /**
-     * Close the websocket definitively.
-     *
-     * @private
-     */
-    close() {
-        if (this.websocket && (this.open || this.connecting)) {
-            this.websocket.onclose = () => { };
-            this.websocket.close();
-            this.messagesOnOpen = [];
-        }
+    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),
+            },
+            /**
+             * Array of message to send on open.
+             * @type {Array<string>}
+             * @private
+             */
+            messagesOnOpen: {
+                value: [],
+                writable: true,
+            },
+            open: {
+                get: () => !!(this.websocket && this.websocket.readyState === this.websocket.OPEN),
+            },
+            /**
+             * List of channels subscribed.
+             * @type {WebSocketSubscribed}
+             * @private
+             */
+            subscribed: {
+                value: {},
+                writable: true,
+            },
+            /**
+             * Array of subscriptions.
+             * @type {Array<WebSocketSubscription>}
+             * @private
+             */
+            subscriptions: {
+                value: [],
+                writable: true,
+            },
+        });
     }
     /**
-     * Sends a message to the websocket.
+     * 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 {message} message Message to send.
+     * @param {Object} params Parameters for the websocket get request
+     * @param {function} cb callback on message event
+     * @param {function} errorCb Callback on error and close event
      * @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);
+    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-expect-error : Spread error
+        (...args) => {
+            // @ts-expect-error : Spread error
+            callback(...args);
+            const index = this.requests.findIndex((request) => requestString === request.requestString && cb === request.cb);
+            const { onErrorCb, onMessageCb } = this.requests[index];
+            this.removeEvents(onMessageCb, onErrorCb);
+            this.requests.splice(index, 1);
         };
-        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();
+        const { onErrorCb, onMessageCb } = this.listen(params, once(cb), errorCb && once(errorCb));
+        // Store requests and callbacks to be able to remove them.
+        if (!this.requests) {
+            this.requests = [];
         }
-    }
-    addEvents(onMessage, onError) {
-        if (this.websocket) {
-            this.websocket.addEventListener('message', onMessage);
-            if (onError) {
-                this.websocket.addEventListener('error', onError);
-                this.websocket.addEventListener('close', onError);
-            }
+        const index = this.requests.findIndex((request) => requestString === request.requestString && cb === request.cb);
+        const newReq = {
+            cb,
+            errorCb,
+            onErrorCb,
+            onMessageCb,
+            params,
+            requestString,
+        };
+        if (index > -1) {
+            this.requests[index] = newReq;
         }
-    }
-    removeEvents(onMessage, onError) {
-        if (this.websocket) {
-            this.websocket.removeEventListener('message', onMessage);
-            if (onError) {
-                this.websocket.removeEventListener('error', onError);
-                this.websocket.removeEventListener('close', onError);
-            }
+        else {
+            this.requests.push(newReq);
         }
     }
     /**
@@ -213,64 +217,46 @@ class WebSocketAPI {
             });
         };
         this.addEvents(onMessage, errorCb);
-        return { onMessageCb: onMessage, onErrorCb: errorCb };
+        return { onErrorCb: errorCb, onMessageCb: onMessage };
     }
-    /**
-     * 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);
-        });
+    removeEvents(onMessage, onError) {
+        if (this.websocket) {
+            this.websocket.removeEventListener('message', onMessage);
+            if (onError) {
+                this.websocket.removeEventListener('error', onError);
+                this.websocket.removeEventListener('close', onError);
+            }
+        }
     }
     /**
-     * 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.
+     * Sends a message to the websocket.
      *
-     * @param {Object} params Parameters for the websocket get request
-     * @param {function} cb callback on message event
-     * @param {function} errorCb Callback on error and close event
+     * @param {message} message Message to send.
      * @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 = [];
+    send(message) {
+        if (!this.websocket || this.closed || this.closing) {
+            return;
         }
-        const index = this.requests.findIndex((request) => requestString === request.requestString && cb === request.cb);
-        const newReq = {
-            params,
-            requestString,
-            cb,
-            errorCb,
-            onMessageCb,
-            onErrorCb,
+        const send = () => {
+            var _a;
+            (_a = this.websocket) === null || _a === void 0 ? void 0 : _a.send(message);
         };
-        if (index > -1) {
-            this.requests[index] = newReq;
+        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 {
-            this.requests.push(newReq);
+        else if (!this.messagesOnOpen.includes(message)) {
+            send();
         }
     }
     /**
@@ -283,10 +269,10 @@ class WebSocketAPI {
      * @private
      */
     subscribe(params, cb, errorCb, quiet = false) {
-        const { onMessageCb, onErrorCb } = this.listen(params, cb, errorCb);
+        const { onErrorCb, onMessageCb } = 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 };
+        const newSubscr = { cb, errorCb, onErrorCb, onMessageCb, params, quiet };
         if (index > -1) {
             this.subscriptions[index] = newSubscr;
         }
@@ -301,6 +287,35 @@ class WebSocketAPI {
             this.subscribed[reqStr] = true;
         }
     }
+    /**
+     * 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);
+        });
+    }
+    /**
+     * 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(({ onErrorCb, onMessageCb }) => {
+            this.removeEvents(onMessageCb, onErrorCb);
+        });
+    }
     /**
      * Unsubscribe from a channel.
      * @param {string} source source to unsubscribe from
@@ -309,7 +324,7 @@ class WebSocketAPI {
      */
     unsubscribe(source, cb) {
         const toRemove = this.subscriptions.filter((s) => s.params.channel === source && (!cb || s.cb === cb));
-        toRemove.forEach(({ onMessageCb, onErrorCb }) => {
+        toRemove.forEach(({ onErrorCb, onMessageCb }) => {
             this.removeEvents(onMessageCb, onErrorCb);
         });
         this.subscriptions = this.subscriptions.filter((s) => s.params.channel !== source || (cb && s.cb !== cb));
@@ -323,20 +338,5 @@ class WebSocketAPI {
             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);
-        });
-    }
 }
 export default WebSocketAPI;

package/api/index.js

@@ -1,3 +1,3 @@
+export { default as RealtimeAPI, RealtimeModes } from './RealtimeAPI';
 export { default as RoutingAPI } from './RoutingAPI';
 export { default as StopsAPI } from './StopsAPI';
-export { default as RealtimeAPI, RealtimeModes } from './RealtimeAPI';