mobility-toolbox-js 2.0.0-beta.36 → 2.0.0-beta.39

package/README.md

@@ -5,19 +5,25 @@ The tools in this library have been inspired by many projects realized for publi
 
 [![npm](https://img.shields.io/npm/v/mobility-toolbox-js.svg?style=flat-square)](https://www.npmjs.com/package/mobility-toolbox-js)
 [![Build](https://github.com/geops/mobility-toolbox-js/workflows/Build/badge.svg)](https://github.com/geops/mobility-toolbox-js/actions?query=workflow%3ABuild)
-[![Netlify Status](https://api.netlify.com/api/v1/badges/b368ab18-9dbf-416c-91f6-a82076b02c10/deploy-status)](https://app.netlify.com/sites/mobility-toolbox-js/deploys)
+![Vercel](https://vercelbadge.vercel.app/api/geops/mobility-toolbox-js)
 
-## Main Features
+## Documentation and examples
 
-* Display [real-time vehicle positions and prognosis data](http://tracker.geops.ch/) on a map.
-* Search for [stops and stations](https://maps2.trafimage.ch) all over the world.
-* Get [precise geographic courses](https://geops.github.io/geops-routing-demo/) for all modes of transport.
-* Generate beautiful maps for public transport, mobility and logistics
+Visit https://mobility-toolbox-js.vercel.app/
 
-## Documentation and examples
+## Demos
 
-Visit https://master--mobility-toolbox-js.netlify.app/
+* Display [real-time vehicle positions and prognosis data](http://tracker.geops.ch/) on a map.
+* Search for [stops and stations](https://maps.trafimage.ch) all over the world.
+* Get [precise geographic courses](https://routing-demo.geops.io/) for all modes of transport.
+* Generate beautiful [schematic](https://mobility.portal.geops.io/world.geops.networkplans) or [topographic](https://mobility.portal.geops.io) maps for public transport, mobility and logistics.
 
 ## Version 1.x.x
 
 The master branch is now open for the version 2 development. The version 1 is still available in [1.x.x](https://github.com/geops/mobility-toolbox-js/tree/1.x.x) branch.
+
+## Deploy
+
+This library website is deployed automatically using [Vercel](https://vercel.com/geops).
+For Vercel we have to add the nextjs and raw-loader modules in the dev dependencies of the main package.json.
+But those 2 librairies are not need to build the library.

package/api/RealtimeAPI.test.d.ts

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

package/api/RealtimeAPI.test.d.ts.map

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

package/api/RealtimeAPI.test.js

@@ -0,0 +1,67 @@
+import { RealtimeAPI, RealtimeModes } from '.';
+describe('RealtimeAPI', () => {
+    let api;
+    let get;
+    beforeEach(() => {
+        get = jest.fn((params, cb) => {
+            cb({ content: 'content' });
+        });
+        api = new RealtimeAPI();
+        api.wsApi = {
+            get,
+        };
+    });
+    describe('#getFullTrajectory() calls fullTrajectory channel', () => {
+        test('without parameters', (done) => {
+            api.getFullTrajectory().then(() => {
+                expect(get.mock.calls.length).toBe(1);
+                expect(get.mock.calls[0][0]).toEqual({
+                    channel: 'full_trajectory',
+                });
+                done();
+            });
+        });
+        [null, RealtimeModes.TOPOGRAPHIC].forEach((mode) => {
+            describe(`using mode ${mode}`, () => {
+                test('using id', (done) => {
+                    api.getFullTrajectory('foo', mode).then(() => {
+                        expect(get.mock.calls.length).toBe(1);
+                        expect(get.mock.calls[0][0]).toEqual({
+                            channel: 'full_trajectory_foo',
+                        });
+                        done();
+                    });
+                });
+                test('using id and generalizationLevel param', (done) => {
+                    api.getFullTrajectory('foo', mode, 5).then(() => {
+                        expect(get.mock.calls.length).toBe(1);
+                        expect(get.mock.calls[0][0]).toEqual({
+                            channel: 'full_trajectory_foo_gen5',
+                        });
+                        done();
+                    });
+                });
+            });
+        });
+        describe('using schematic mode ', () => {
+            test('using id', (done) => {
+                api.getFullTrajectory('foo', RealtimeModes.SCHEMATIC).then(() => {
+                    expect(get.mock.calls.length).toBe(1);
+                    expect(get.mock.calls[0][0]).toEqual({
+                        channel: 'full_trajectory_schematic_foo',
+                    });
+                    done();
+                });
+            });
+            test("doesn't use generalizationLevel param", (done) => {
+                api.getFullTrajectory('foo', RealtimeModes.SCHEMATIC, 10).then(() => {
+                    expect(get.mock.calls.length).toBe(1);
+                    expect(get.mock.calls[0][0]).toEqual({
+                        channel: 'full_trajectory_schematic_foo',
+                    });
+                    done();
+                });
+            });
+        });
+    });
+});

package/api/RoutingAPI.d.ts

@@ -1,5 +1,9 @@
-import HttpAPI, { HttpApiOptions } from '../common/api/HttpAPI';
+import HttpAPI from '../common/api/HttpAPI';
 import { RoutingParameters, RoutingResponse } from '../../types';
+export declare type RoutingAPIOptions = {
+    url?: string;
+    apiKey?: string;
+};
 /**
  * Access to the [geOps Routing service](https://developer.geops.io/apis/routing).
  *
@@ -19,7 +23,7 @@ declare class RoutingAPI extends HttpAPI {
      * @param {string} [options.url='https://api.geops.io/routing/v1/'] Service url.
      * @param {string} options.apiKey Access key for [geOps services](https://developer.geops.io/).
      */
-    constructor(options: HttpApiOptions);
+    constructor(options: RoutingAPIOptions);
     /**
      * Route.
      *

package/api/RoutingAPI.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RoutingAPI.d.ts","sourceRoot":"","sources":["../../src/api/RoutingAPI.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,EAAE,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEjE;;;;;;;;;;GAUG;AACH,cAAM,UAAW,SAAQ,OAAO;IAC9B;;;;;;OAMG;gBACS,OAAO,EAAE,cAAc;IAInC;;;;;;OAMG;IACH,KAAK,CACH,MAAM,EAAE,iBAAiB,EACzB,MAAM,EAAE,WAAW,GAClB,OAAO,CAAC,eAAe,CAAC;CAG5B;AAED,eAAe,UAAU,CAAC"}
+{"version":3,"file":"RoutingAPI.d.ts","sourceRoot":"","sources":["../../src/api/RoutingAPI.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,uBAAuB,CAAC;AAC5C,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEjE,oBAAY,iBAAiB,GAAG;IAC9B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF;;;;;;;;;;GAUG;AACH,cAAM,UAAW,SAAQ,OAAO;IAC9B;;;;;;OAMG;gBACS,OAAO,EAAE,iBAAiB;IAItC;;;;;;OAMG;IACH,KAAK,CACH,MAAM,EAAE,iBAAiB,EACzB,MAAM,EAAE,WAAW,GAClB,OAAO,CAAC,eAAe,CAAC;CAG5B;AAED,eAAe,UAAU,CAAC"}

package/api/RoutingAPI.test.d.ts

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

package/api/RoutingAPI.test.d.ts.map

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

package/api/RoutingAPI.test.js

@@ -0,0 +1,29 @@
+import fetch from 'jest-fetch-mock';
+import RoutingAPI from './RoutingAPI';
+let api;
+describe('RoutingAPI', () => {
+    beforeEach(() => {
+        global.fetch = fetch;
+        fetch.resetMocks();
+        api = new RoutingAPI({ apiKey: 'apiKey' });
+    });
+    describe('#route', () => {
+        test('should success', (done) => {
+            fetch.mockResponseOnce(JSON.stringify(global.fetchRouteResponse));
+            return api
+                .route({
+                mot: 'bus',
+                via: '47.3739194713294,8.538274823394632|47.37595378493421,8.537490375951839',
+            })
+                .then((featureCollection) => {
+                // Correct url
+                expect(fetch.mock.calls[0][0]).toEqual('https://api.geops.io/routing/v1/?key=apiKey&mot=bus&via=47.3739194713294%2C8.538274823394632%7C47.37595378493421%2C8.537490375951839');
+                // Correct search result (for bus mot)
+                expect(featureCollection.features[0].geometry.type).toEqual('LineString');
+                expect(featureCollection.features[0].properties.lines).toBeDefined();
+                expect(featureCollection.features[0].properties.station_to).toBeDefined();
+                done();
+            });
+        });
+    });
+});

package/api/StopsAPI.test.d.ts

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

package/api/StopsAPI.test.d.ts.map

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

package/api/StopsAPI.test.js

@@ -0,0 +1,26 @@
+import fetch from 'jest-fetch-mock';
+import StopsAPI from './StopsAPI';
+let api;
+describe('StopsAPI', () => {
+    beforeEach(() => {
+        global.fetch = fetch;
+        fetch.resetMocks();
+        api = new StopsAPI({ apiKey: 'apiKey' });
+    });
+    describe('#search', () => {
+        test('should success', (done) => {
+            fetch.mockResponseOnce(JSON.stringify(global.stopsSearchResponse));
+            return api
+                .search({
+                q: 'Bern',
+            })
+                .then((featureCollection) => {
+                // Correct url
+                expect(fetch.mock.calls[0][0]).toEqual('https://api.geops.io/stops/v1/?key=apiKey&q=Bern');
+                // Correct search result
+                expect(featureCollection.features[0].properties.name).toEqual('Bern');
+                done();
+            });
+        });
+    });
+});

package/common/api/HttpAPI.d.ts

@@ -1,6 +1,6 @@
 import BaseObject from 'ol/Object';
-export declare type HttpApiOptions = {
-    url?: string;
+export declare type HttpAPIOptions = {
+    url: string;
     apiKey?: string;
 };
 /**
@@ -18,9 +18,9 @@ export declare type HttpApiOptions = {
  * @classproperty {string} apiKey Api key to access the service.
  */
 declare class HttpAPI extends BaseObject {
-    url?: string;
+    url: string;
     apiKey?: string;
-    constructor(options: HttpApiOptions);
+    constructor(options: HttpAPIOptions);
     /**
      * Append the apiKey before sending the request.
      * @ignore

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

@@ -1 +1 @@
-{"version":3,"file":"HttpAPI.d.ts","sourceRoot":"","sources":["../../../src/common/api/HttpAPI.ts"],"names":[],"mappings":"AAAA,OAAO,UAAU,MAAM,WAAW,CAAC;AAGnC,oBAAY,cAAc,GAAG;IAC3B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AACF;;;;;;;;;;;;;GAaG;AACH,cAAM,OAAQ,SAAQ,UAAU;IAC9B,GAAG,CAAC,EAAE,MAAM,CAAC;IAEb,MAAM,CAAC,EAAE,MAAM,CAAC;gBAEJ,OAAO,EAAE,cAAc;IASnC;;;OAGG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,GAAG,CAAC;CAmCvE;AAED,eAAe,OAAO,CAAC"}
+{"version":3,"file":"HttpAPI.d.ts","sourceRoot":"","sources":["../../../src/common/api/HttpAPI.ts"],"names":[],"mappings":"AAAA,OAAO,UAAU,MAAM,WAAW,CAAC;AAGnC,oBAAY,cAAc,GAAG;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AACF;;;;;;;;;;;;;GAaG;AACH,cAAM,OAAQ,SAAQ,UAAU;IAC9B,GAAG,EAAE,MAAM,CAAC;IAEZ,MAAM,CAAC,EAAE,MAAM,CAAC;gBAEJ,OAAO,EAAE,cAAc;IASnC;;;OAGG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,GAAG,CAAC;CAmCvE;AAED,eAAe,OAAO,CAAC"}

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

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

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

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

package/common/api/HttpAPI.test.js

@@ -0,0 +1,54 @@
+import fetch from 'jest-fetch-mock';
+import API from './HttpAPI';
+let api;
+describe('HttpAPI', () => {
+    beforeEach(() => {
+        global.fetch = fetch;
+        fetch.resetMocks();
+        api = new API({ url: 'https://foo.ch', apiKey: 'apiKey' });
+    });
+    describe('#fetch', () => {
+        test('should success', () => {
+            fetch.mockResponseOnce(JSON.stringify({ foo: 'bar' }));
+            return api
+                .fetch('/path', {
+                q: 'Bern',
+                fooUndefined: undefined,
+                fooNull: null,
+                fooEmpty: '',
+            })
+                .then((response) => {
+                // Correct url
+                expect(fetch.mock.calls[0][0]).toEqual('https://foo.ch/path?key=apiKey&q=Bern&fooEmpty=');
+                // Correct search result
+                expect(response).toEqual({ foo: 'bar' });
+            });
+        });
+        describe('should display error message', () => {
+            test('reject error', (done) => {
+                fetch.mockRejectOnce(new Error('Fake error message'));
+                return api.fetch().catch((err) => {
+                    expect(err.name).toEqual('Error');
+                    expect(err.message).toEqual('Fake error message');
+                    done();
+                });
+            });
+            test('if the response is invalid json', (done) => {
+                fetch.mockResponseOnce('invalid json');
+                api.fetch().catch((err) => {
+                    expect(err.name).toEqual('FetchError');
+                    expect(err.message).toEqual('invalid json response body at  reason: Unexpected token i in JSON at position 0');
+                    done();
+                });
+            });
+            test('if the response contains an error message', (done) => {
+                fetch.mockResponseOnce('{"error":"foo2"}');
+                api.fetch().catch((err) => {
+                    expect(err.name).toEqual('Error');
+                    expect(err.message).toEqual('foo2');
+                    done();
+                });
+            });
+        });
+    });
+});

package/common/api/WebSocketAPI.d.ts

@@ -42,6 +42,8 @@ declare class WebSocketAPI {
      * @private
      */
     private send;
+    addEvents(onMessage: any, onError: any): void;
+    removeEvents(onMessage: any, onError: any): void;
     /**
      * Listen to websocket messages.
      *
@@ -62,13 +64,15 @@ declare class WebSocketAPI {
     private unlisten;
     /**
      * 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
      */
     private get;
+    requests: any[] | undefined;
     /**
      * Subscribe to a given channel.
      *

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

@@ -1 +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,wCAAmC;IAarC;;;;OAIG;IACH,cAOC;IAFG,kCAAwB;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"}
+{"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,wCAAmC;IAarC;;;;OAIG;IACH,cAOC;IAFG,kCAAwB;IAI5B;;;;;OAKG;IACH,aAsBC;IAED,8CASC;IAED,iDASC;IAED;;;;;;;;OAQG;IACH,eAgCC;IAED;;;;;;OAMG;IACH,iBAQC;IAED;;;;;;;;OAQG;IACH,YA4CC;IAlBG,4BAAkB;IAoBtB;;;;;;;;OAQG;IACH,kBAqBC;IAED;;;;;OAKG;IACH,oBAwBC;IAfC,mBAEC;IAeH;;OAEG;IACH,uCAYC;CACF"}

package/common/api/WebSocketAPI.js

@@ -137,6 +137,24 @@ class WebSocketAPI {
             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.
      *
@@ -148,7 +166,8 @@ class WebSocketAPI {
      */
     listen(params, cb, errorCb) {
         // Remove the previous identical callback
-        this.unlisten(params, cb);
+        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 {
@@ -170,13 +189,7 @@ class WebSocketAPI {
                 }
             });
         };
-        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 };
     }
     /**
@@ -187,33 +200,52 @@ class WebSocketAPI {
      * @private
      */
     unlisten(params, cb) {
-        if (!this.websocket) {
-            return;
-        }
-        this.subscriptions
+        [...(this.subscriptions || []), ...(this.requests || [])]
             .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);
-                }
-            }
+            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
      */
     get(params, cb, errorCb) {
-        const reqStr = WebSocketAPI.getRequestString('GET', params);
-        this.send(reqStr);
-        this.listen(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.
@@ -252,13 +284,7 @@ class WebSocketAPI {
     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.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,

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":""}