mobility-toolbox-js 2.0.0-beta.35 → 2.0.0-beta.38

package/mapbox/layers/Layer.test.js

@@ -0,0 +1,204 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Map } from 'maplibre-gl';
+import { toLonLat } from 'ol/proj';
+import Layer from './Layer';
+let map;
+let mapElement;
+describe('Layer', () => {
+    beforeEach(() => {
+        mapElement = document.createElement('div');
+        const { style } = mapElement;
+        style.position = 'absolute';
+        style.left = '0px';
+        style.top = '0px';
+        style.width = '400px';
+        style.height = '400px';
+        mapElement.setAttribute('id', 'map');
+        document.body.appendChild(mapElement);
+        map = new Map({
+            container: document.getElementById('map'),
+            style: `path/to/style`,
+            center: toLonLat([831634, 5933959]),
+            zoom: 9,
+        });
+    });
+    afterEach(() => {
+        document.body.removeChild(mapElement);
+    });
+    test('should initialize.', () => {
+        const layer = new Layer({ name: 'Layer' });
+        expect(layer).toBeInstanceOf(Layer);
+    });
+    test('should be visible by default.', () => {
+        const layer = new Layer({ name: 'Layer' });
+        expect(layer.visible).toBe(true);
+    });
+    test('should be invisible if defined.', () => {
+        const layer = new Layer({ name: 'Layer', visible: false });
+        expect(layer.visible).toBe(false);
+    });
+    test('should be invisible if set.', () => {
+        const layer = new Layer({ name: 'Layer' });
+        layer.visible = false;
+        expect(layer.visible).toBe(false);
+    });
+    test('should visibility stay unchanged', () => {
+        const layer = new Layer({ name: 'Layer', visible: false });
+        layer.visible = false;
+        expect(layer.visible).toBe(false);
+    });
+    test('should return its name.', () => {
+        const layer = new Layer({ name: 'Layer', visible: false });
+        expect(layer.name).toEqual('Layer');
+    });
+    test('should call terminate on initialization.', () => {
+        const layer = new Layer({ name: 'Layer' });
+        const spy = jest.spyOn(layer, 'detachFromMap');
+        layer.attachToMap(map);
+        expect(spy).toHaveBeenCalledTimes(1);
+    });
+    test('should listen for click/hover events when layer is visible by default then should not when hidden.', () => __awaiter(void 0, void 0, void 0, function* () {
+        global.console.error = jest.fn();
+        const layer = new Layer({ name: 'Layer' });
+        expect(layer.visible).toBe(true);
+        const spy = jest.fn();
+        const spy2 = jest.fn();
+        layer.onHover(spy);
+        layer.onClick(spy2);
+        layer.attachToMap(map);
+        expect(spy).toHaveBeenCalledTimes(0);
+        expect(spy2).toHaveBeenCalledTimes(0);
+        yield map.fire('mousemove', {
+            type: 'mousemove',
+            lngLat: { toArray: () => [0, 0] },
+            coordinate: [0, 0],
+        });
+        yield map.fire('click', {
+            type: 'click',
+            lngLat: { toArray: () => [0, 0] },
+        });
+        expect(spy).toHaveBeenCalledTimes(1);
+        expect(spy2).toHaveBeenCalledTimes(1);
+        spy.mockReset();
+        spy2.mockReset();
+        layer.visible = false;
+        yield map.fire('mousemove', {
+            type: 'mousemove',
+            lngLat: { toArray: () => [0, 0] },
+        });
+        yield map.fire('click', {
+            type: 'click',
+            lngLat: { toArray: () => [0, 0] },
+        });
+        expect(spy).toHaveBeenCalledTimes(0);
+        expect(spy2).toHaveBeenCalledTimes(0);
+        global.console.error.mockRestore();
+    }));
+    test('should not listen for click/hover events when layer is not visible by default then should not when visible.', () => __awaiter(void 0, void 0, void 0, function* () {
+        global.console.error = jest.fn();
+        const layer = new Layer({ name: 'Layer', visible: false });
+        expect(layer.visible).toBe(false);
+        const spy = jest.fn();
+        const spy2 = jest.fn();
+        layer.onHover(spy);
+        layer.onClick(spy2);
+        layer.attachToMap(map);
+        expect(spy).toHaveBeenCalledTimes(0);
+        expect(spy2).toHaveBeenCalledTimes(0);
+        yield map.fire('mousemove', {
+            type: 'mousemove',
+            lngLat: { toArray: () => [0, 0] },
+            coordinate: [0, 0],
+        });
+        yield map.fire('click', {
+            type: 'click',
+            lngLat: { toArray: () => [0, 0] },
+        });
+        expect(spy).toHaveBeenCalledTimes(0);
+        expect(spy2).toHaveBeenCalledTimes(0);
+        spy.mockReset();
+        spy2.mockReset();
+        layer.visible = true;
+        yield map.fire('mousemove', {
+            type: 'mousemove',
+            lngLat: { toArray: () => [0, 0] },
+            coordinate: [0, 0],
+        });
+        yield map.fire('click', {
+            type: 'click',
+            lngLat: { toArray: () => [0, 0] },
+        });
+        expect(spy).toHaveBeenCalledTimes(1);
+        expect(spy2).toHaveBeenCalledTimes(1);
+        global.console.error.mockRestore();
+    }));
+    test('should not listen for click/hover events  after layer.detachFromMap()', () => __awaiter(void 0, void 0, void 0, function* () {
+        global.console.error = jest.fn();
+        const layer = new Layer({ name: 'Layer', visible: true });
+        expect(layer.visible).toBe(true);
+        const spy = jest.fn();
+        const spy2 = jest.fn();
+        const spy3 = jest.fn();
+        const spy4 = jest.fn();
+        layer.onHover(spy);
+        layer.onClick(spy2);
+        layer.attachToMap(map);
+        // Test event after attached to map
+        layer.onHover(spy3);
+        layer.onClick(spy4);
+        expect(spy).toHaveBeenCalledTimes(0);
+        expect(spy2).toHaveBeenCalledTimes(0);
+        expect(spy3).toHaveBeenCalledTimes(0);
+        expect(spy4).toHaveBeenCalledTimes(0);
+        yield map.fire('mousemove', {
+            type: 'mousemove',
+            lngLat: { toArray: () => [0, 0] },
+            coordinate: [0, 0],
+        });
+        yield map.fire('click', {
+            type: 'click',
+            lngLat: { toArray: () => [0, 0] },
+        });
+        expect(spy).toHaveBeenCalledTimes(1);
+        expect(spy2).toHaveBeenCalledTimes(1);
+        expect(spy3).toHaveBeenCalledTimes(1);
+        expect(spy4).toHaveBeenCalledTimes(1);
+        spy.mockReset();
+        spy2.mockReset();
+        spy3.mockReset();
+        spy4.mockReset();
+        layer.detachFromMap();
+        yield map.fire('mousemove', {
+            type: 'mousemove',
+            lngLat: { toArray: () => [0, 0] },
+            coordinate: [0, 0],
+        });
+        yield map.fire('click', {
+            type: 'click',
+            lngLat: { toArray: () => [0, 0] },
+        });
+        expect(spy).toHaveBeenCalledTimes(0);
+        expect(spy2).toHaveBeenCalledTimes(0);
+        expect(spy3).toHaveBeenCalledTimes(0);
+        expect(spy4).toHaveBeenCalledTimes(0);
+        global.console.error.mockRestore();
+    }));
+    test('should clone', () => {
+        const layer = new Layer({
+            name: 'Layer',
+            copyrights: ['bar'],
+        });
+        const clone = layer.clone({ name: 'clone' });
+        expect(clone).not.toBe(layer);
+        expect(clone.name).toBe('clone');
+        expect(clone).toBeInstanceOf(Layer);
+    });
+});

package/mapbox/layers/RealtimeLayer.test.d.ts

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

package/mapbox/layers/RealtimeLayer.test.d.ts.map

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

package/mapbox/layers/RealtimeLayer.test.js

@@ -0,0 +1,10 @@
+import RealtimeLayer from './RealtimeLayer';
+let layer;
+describe('RealtimeLayer', () => {
+    beforeEach(() => {
+        layer = new RealtimeLayer();
+    });
+    test('should be instanced.', () => {
+        expect(layer).toBeInstanceOf(RealtimeLayer);
+    });
+});

package/mbt.js

@@ -33492,8 +33492,26 @@ uniform ${i3} ${o3} u_${a3};
         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(params, cb, errorCb) {
-      this.unlisten(params, cb);
+      this.unlisten(params, cb, errorCb);
       const onMessage = (evt) => {
         let data = {};
         try {
@@ -33510,33 +33528,42 @@ uniform ${i3} ${o3} u_${a3};
           }
         });
       };
-      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 };
     }
     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);
-          }
-        }
+      [...this.subscriptions || [], ...this.requests || []].filter((s) => s.params.channel === params.channel && (!cb || s.cb === cb)).forEach(({ onMessageCb, onErrorCb }) => {
+        this.removeEvents(onMessageCb, onErrorCb);
       });
     }
     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);
+      const once = (callback) => (...args) => {
+        callback(...args);
+        const index2 = this.requests.findIndex((request) => requestString === request.requestString && cb === request.cb);
+        const { onMessageCb: onMessageCb2, onErrorCb: onErrorCb2 } = this.requests[index2];
+        this.removeEvents(onMessageCb2, onErrorCb2);
+        this.requests.splice(index2, 1);
+      };
+      const { onMessageCb, onErrorCb } = this.listen(params, once(cb), once(errorCb));
+      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(params, cb, errorCb, quiet = false) {
       const { onMessageCb, onErrorCb } = this.listen(params, cb, errorCb);
@@ -33559,13 +33586,7 @@ uniform ${i3} ${o3} u_${a3};
     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 (source && this.subscribed[source] && !this.subscriptions.find((s) => s.params.channel === source) && toRemove.find((subscr) => !subscr.quiet)) {
@@ -35649,7 +35670,7 @@ uniform ${i3} ${o3} u_${a3};
       getTextSize: getTextSize2
     } = options;
     const { zoom, pixelRatio } = viewState;
-    let { type, cancelled } = trajectory.properties;
+    let { type } = trajectory.properties;
     const {
       train_id: id,
       line,
@@ -35658,7 +35679,7 @@ uniform ${i3} ${o3} u_${a3};
       operator_provides_realtime_journey: operatorProvidesRealtime
     } = trajectory.properties;
     let { name, text_color: textColor, color } = line || {};
-    cancelled = cancelled === true || state === "JOURNEY_CANCELLED";
+    const cancelled = state === "JOURNEY_CANCELLED";
     if (!type) {
       type = "Rail";
     }
@@ -35756,7 +35777,7 @@ uniform ${i3} ${o3} u_${a3};
   var canvas;
   var realtimeSimpleStyle = () => {
     if (!canvas) {
-      document.createElement("canvas");
+      canvas = document.createElement("canvas");
       canvas.width = 15;
       canvas.height = 15;
       const ctx = canvas.getContext("2d");
@@ -48271,6 +48292,9 @@ uniform ${i3} ${o3} u_${a3};
         size: [0, 0]
       };
       super.loadMbMap();
+      if (!this.mbMap) {
+        return;
+      }
       this.mbMap.once("load", () => {
         this.mbMap.resize();
         this.copyrights = getMapboxMapCopyrights_default(this.mbMap) || [];