mobility-toolbox-js 1.6.4-beta.2 → 1.6.5

package/api/tralis/TralisAPI.js

@@ -64,6 +64,9 @@ class TralisAPI {
 
     /** @ignore */
     this.prefix = options.prefix || '';
+
+    /** @ignore */
+    this.onOpen = this.onOpen.bind(this);
   }
 
   defineProperties(options) {
@@ -149,16 +152,8 @@ class TralisAPI {
 
   open() {
     this.close();
-    this.conn.connect(this.url);
-
-    // Register BBOX and PROJECTION messages on open.
-    if (this.conn.connecting) {
-      this.conn.websocket.addEventListener('open', () => {
-        this.onOpen();
-      });
-    } else {
-      this.onOpen();
-    }
+    // Register BBOX and PROJECTION messages must be send before previous subscriptions.
+    this.conn.connect(this.url, this.onOpen);
 
     // Register reconnection on close.
     this.conn.websocket.onclose = () => {

package/api/tralis/WebSocketConnector.js

@@ -95,9 +95,11 @@ class WebSocketConnector {
   /**
    * (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
    */
-  connect(url) {
+  connect(url, onOpen = () => {}) {
     if (this.websocket && !this.closed) {
       this.websocket.close();
     }
@@ -107,9 +109,11 @@ class WebSocketConnector {
 
     if (!this.open) {
       this.websocket.addEventListener('open', () => {
+        onOpen();
         this.subscribePreviousSubscriptions();
       });
     } else {
+      onOpen();
       this.subscribePreviousSubscriptions();
     }
   }
@@ -124,6 +128,7 @@ class WebSocketConnector {
       this.websocket.onclose = null;
       this.websocket.close();
       this.websocket = null;
+      this.messagesOnOpen = [];
     }
   }
 
@@ -148,6 +153,9 @@ class WebSocketConnector {
           this.messagesOnOpen = [];
           send();
         });
+        this.websocket.addEventListener('close', () => {
+          this.messagesOnOpen = [];
+        });
       }
     } else if (!this.messagesOnOpen.includes(message)) {
       send();
@@ -260,7 +268,6 @@ class WebSocketConnector {
         this.send(`GET ${reqStr}`);
         this.send(`SUB ${reqStr}`);
       }
-
       this.subscribed[reqStr] = true;
     }
   }
@@ -307,6 +314,13 @@ class WebSocketConnector {
    * 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);

package/api/tralis/WebSocketConnector.test.js

@@ -28,6 +28,31 @@ describe('WebSocketConnector', () => {
       });
     });
 
+    describe('#close', () => {
+      test('should close the websocket and clear some property', async () => {
+        // eslint-disable-next-line no-unused-vars
+        const client = new Connector();
+        const subsc2 = {
+          params: 'foo',
+          cb: () => {},
+          errorCb: () => {},
+          quiet: false,
+        };
+        client.subscriptions = [subsc2];
+        client.messagesOnOpen = ['GET foo'];
+        client.connect(`ws://foo:1234`);
+        client.websocket.addEventListener = jest.fn();
+        client.websocket.removeEventListener = jest.fn();
+        client.websocket.close = jest.fn();
+        await server.connected;
+        expect(client.websocket).toBeDefined();
+        expect(client.messagesOnOpen).toEqual(['GET foo']);
+        client.close();
+        expect(client.messagesOnOpen).toEqual([]);
+        expect(client.websocket).toBeNull();
+      });
+    });
+
     describe('#connect', () => {
       test('create a new WebSocket.', async () => {
         const client = new Connector();
@@ -50,23 +75,44 @@ describe('WebSocketConnector', () => {
         expect(client.websocket.readyState).toBe(WebSocket.CONNECTING);
       });
 
-      test('subscribe previous subscriptions on open', async () => {
+      test('call onOpen function', async () => {
+        const onOpen = jest.fn();
         const client = new Connector();
         client.subscribe = jest.fn();
-        client.connect(`ws://foo:1234`);
+        client.connect(`ws://foo:1234`, onOpen);
         await server.connected;
         expect(client.websocket.readyState).toBe(WebSocket.OPEN);
+        expect(onOpen).toHaveBeenCalledTimes(1);
+      });
+
+      test('subscribe previous subscriptions on open (quiet or not)', async () => {
+        const client = new Connector();
+        client.subscribe = jest.fn();
+        client.send = jest.fn();
         const subsc = {
           params: 'foo',
           cb: () => {},
           errorCb: () => {},
           quiet: true,
         };
-        client.subscriptions = [subsc];
+        const subsc2 = {
+          params: 'foo',
+          cb: () => {},
+          errorCb: () => {},
+          quiet: false,
+        };
+        client.subscriptions = [subsc, subsc2];
+
+        client.connect(`ws://foo:1234`);
+        await server.connected;
+        expect(client.websocket.readyState).toBe(WebSocket.OPEN);
+        expect(client.subscribe).toHaveBeenCalledTimes(2);
+        client.subscribe.mockReset();
+
         client.connect(`ws://foo:12345`);
         await server2.connected;
         expect(client.websocket.readyState).toBe(WebSocket.OPEN);
-        expect(client.subscribe).toHaveBeenCalledTimes(1);
+        expect(client.subscribe).toHaveBeenCalledTimes(2);
         expect(client.subscribe).toHaveBeenCalledWith(
           subsc.params,
           subsc.cb,
@@ -74,6 +120,66 @@ describe('WebSocketConnector', () => {
           subsc.quiet,
         );
       });
+
+      test('send GET and SUB for not quiet previous subscriptions', async () => {
+        const client = new Connector();
+        client.send = jest.fn();
+        const subsc = {
+          params: { channel: 'foo' },
+          cb: () => {},
+          errorCb: () => {},
+          quiet: false,
+        };
+        client.subscriptions = [subsc];
+
+        client.connect(`ws://foo:1234`);
+        client.websocket.addEventListener = jest.fn();
+        client.websocket.removeEventListener = jest.fn();
+        await server.connected;
+        expect(client.websocket.readyState).toBe(WebSocket.OPEN);
+        expect(client.send).toHaveBeenCalledTimes(2);
+        expect(client.send.mock.calls[0]).toEqual(['GET foo']);
+        expect(client.send.mock.calls[1]).toEqual(['SUB foo']);
+        client.send.mockReset();
+
+        client.connect(`ws://foo:12345`);
+        client.websocket.addEventListener = jest.fn();
+        client.websocket.removeEventListener = jest.fn();
+        await server2.connected;
+        expect(client.websocket.readyState).toBe(WebSocket.OPEN);
+        // not quiet subscriptions will send GET and SUB requests.
+        expect(client.send).toHaveBeenCalledTimes(2);
+        expect(client.send.mock.calls[0]).toEqual(['GET foo']);
+        expect(client.send.mock.calls[1]).toEqual(['SUB foo']);
+      });
+
+      test('doesn\t send GET and SUB for quiet previous subscriptions', async () => {
+        const client = new Connector();
+        client.send = jest.fn();
+        const subsc = {
+          params: { channel: 'foo' },
+          cb: () => {},
+          errorCb: () => {},
+          quiet: true,
+        };
+        client.subscriptions = [subsc];
+
+        client.connect(`ws://foo:1234`);
+        client.websocket.addEventListener = jest.fn();
+        client.websocket.removeEventListener = jest.fn();
+        await server.connected;
+        expect(client.websocket.readyState).toBe(WebSocket.OPEN);
+        expect(client.send).toHaveBeenCalledTimes(0);
+        client.send.mockReset();
+
+        client.connect(`ws://foo:12345`);
+        client.websocket.addEventListener = jest.fn();
+        client.websocket.removeEventListener = jest.fn();
+        await server2.connected;
+        expect(client.websocket.readyState).toBe(WebSocket.OPEN);
+        // not quiet subscriptions will send GET and SUB requests.
+        expect(client.send).toHaveBeenCalledTimes(0);
+      });
     });
 
     describe('#subscribe', () => {
@@ -199,7 +305,11 @@ describe('WebSocketConnector', () => {
         client.subscribe(params2, cb2);
         expect(client.subscriptions.length).toBe(3);
         expect(client.websocket.removeEventListener).toBeCalledTimes(2);
-        expect(client.websocket.addEventListener).toBeCalledTimes(9);
+        expect(
+          client.websocket.addEventListener.mock.calls.filter(
+            (c) => c[0] === 'message',
+          ).length,
+        ).toBe(5);
 
         client.unsubscribe('foo');
         expect(client.subscriptions.length).toBe(1);

package/common/mixins/TrackerLayerMixin.js

@@ -398,6 +398,28 @@ const TrackerLayerMixin = (Base) =>
         //   writable: true,
         // },
       });
+
+      // When we use the delay style we want to display delayed train on top by default
+      if (this.useDelayStyle && !this.sort) {
+        this.sort = (traj1, traj2) => {
+          if (traj1.delay === null && traj2.delay !== null) {
+            return 1;
+          }
+          if (traj2.delay === null && traj1.delay !== null) {
+            return -1;
+          }
+
+          // We put cancelled train inbetween green and yellow trains
+          // >=180000ms corresponds to yellow train
+          if (traj1.cancelled && !traj2.cancelled) {
+            return traj2.delay < 180000 ? -1 : 1;
+          }
+          if (traj2.cancelled && !traj1.cancelled) {
+            return traj1.delay < 180000 ? 1 : -1;
+          }
+          return traj2.delay - traj1.delay;
+        };
+      }
     }
 
     /**

package/common/mixins/TralisLayerMixin.js

@@ -105,7 +105,7 @@ const TralisLayerMixin = (TrackerLayer) =>
       };
 
       // This property will call api.setBbox on each movend event
-      this.isUpdateBboxOnMoveEnd = options.isUpdateBboxOnMoveEnd || true;
+      this.isUpdateBboxOnMoveEnd = options.isUpdateBboxOnMoveEnd !== false;
 
       // Bind callbacks
       this.onTrajectoryMessage = this.onTrajectoryMessage.bind(this);
@@ -127,14 +127,18 @@ const TralisLayerMixin = (TrackerLayer) =>
         this.onDeleteTrajectoryMessage,
         this.isUpdateBboxOnMoveEnd,
       );
-      this.setBbox();
+
+      if (this.isUpdateBboxOnMoveEnd) {
+        // Update the bbox on each move end
+        this.setBbox();
+      }
     }
 
     stop() {
       super.stop();
-      this.api.close();
       this.api.unsubscribeTrajectory(this.onTrajectoryMessage);
       this.api.unsubscribeDeletedVehicles(this.onDeleteTrajectoryMessage);
+      this.api.close();
     }
 
     setBbox(extent, zoom) {
@@ -151,24 +155,23 @@ const TralisLayerMixin = (TrackerLayer) =>
         }
       }
 
-      if (this.isUpdateBboxOnMoveEnd) {
-        /* @ignore */
-        this.generalizationLevel = this.generalizationLevelByZoom[zoom];
-
-        const bbox = extent;
+      const bbox = [...extent];
 
+      if (this.isUpdateBboxOnMoveEnd) {
         bbox.push(zoom);
 
         if (this.tenant) {
           bbox.push(`tenant=${this.tenant}`);
         }
 
+        /* @ignore */
+        this.generalizationLevel = this.generalizationLevelByZoom[zoom];
         if (this.generalizationLevel) {
           bbox.push(`gen=${this.generalizationLevel}`);
         }
-
-        this.api.bbox = bbox;
       }
+
+      this.api.bbox = bbox;
     }
 
     setMode(mode) {

package/common/utils/timeUtils.js

@@ -42,31 +42,3 @@ export const getHoursAndMinutes = (timeInMs) => {
   const date = new Date(timeInMs);
   return `${pad(date.getHours())}:${pad(date.getMinutes())}`;
 };
-
-/**
- * Returns a string representing a delay.
- * @param {Number} timeInMs Delay time in milliseconds.
- * @ignore
- */
-export const getDelayString = (timeInMs) => {
-  const h = Math.floor(timeInMs / 3600000);
-  const m = Math.floor((timeInMs % 3600000) / 60000);
-  const s = Math.floor(((timeInMs % 3600000) % 60000) / 1000);
-
-  if (s === 0 && h === 0 && m === 0) {
-    return '0';
-  }
-  if (s === 0 && h === 0) {
-    return `${m}m`;
-  }
-  if (s === 0) {
-    return `${h}h${m}m`;
-  }
-  if (m === 0 && h === 0) {
-    return `${s}s`;
-  }
-  if (h === 0) {
-    return `${m}m${s}s`;
-  }
-  return `${h}h${m}m${s}s`;
-};

package/common/utils/timeUtils.test.js

@@ -1,9 +1,4 @@
-import {
-  getUTCDateString,
-  getUTCTimeString,
-  getHoursAndMinutes,
-  getDelayString,
-} from './timeUtils';
+import { getUTCDateString, getUTCTimeString } from './timeUtils';
 
 describe('timeUtils', () => {
   test('getUTCDateString should be correct.', () => {
@@ -18,12 +13,4 @@ describe('timeUtils', () => {
       '11:5:1.123',
     );
   });
-
-  test('getHoursAndMinutes should be correct.', () => {
-    expect(getHoursAndMinutes(123456)).toBe('00:02');
-  });
-
-  test('getDelayString should be correct.', () => {
-    expect(getDelayString(123456)).toBe('2m3s');
-  });
 });