mobility-toolbox-js 2.0.0-beta.34 → 2.0.0-beta.37

package/mapbox/layers/Layer.js

@@ -1,44 +1,7 @@
-"use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var Observable_1 = require("ol/Observable");
-var proj_1 = require("ol/proj");
-var Layer_1 = require("../../common/layers/Layer");
-var UserInteractionsLayerMixin_1 = require("../../common/mixins/UserInteractionsLayerMixin");
+import { unByKey } from 'ol/Observable';
+import { transformExtent } from 'ol/proj';
+import LayerCommon from '../../common/layers/Layer';
+import userInteractionsMixin from '../../common/mixins/UserInteractionsLayerMixin';
 /**
  * A class representing a layer to display on an OpenLayers map.
  *
@@ -54,17 +17,13 @@ var UserInteractionsLayerMixin_1 = require("../../common/mixins/UserInteractions
  * @classproperty {ol/Map~Map} map - The map where the layer is displayed.
  * @extends {Layer}
  */
-var Layer = /** @class */ (function (_super) {
-    __extends(Layer, _super);
-    function Layer() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
+class Layer extends userInteractionsMixin(LayerCommon) {
     /**
      * Initialize the layer and listen to user events.
      * @param {ol/Map~Map} map
      */
-    Layer.prototype.attachToMap = function (map) {
-        _super.prototype.attachToMap.call(this, map);
+    attachToMap(map) {
+        super.attachToMap(map);
         if (!this.map) {
             return;
         }
@@ -72,15 +31,15 @@ var Layer = /** @class */ (function (_super) {
             this.toggleVisibleListeners();
             this.onChangeVisibleKey = this.on('change:visible', this.toggleVisibleListeners);
         }
-    };
-    Layer.prototype.detachFromMap = function () {
+    }
+    detachFromMap() {
         if (this.map) {
             this.deactivateUserInteractions();
-            (0, Observable_1.unByKey)(this.onChangeVisibleKey);
+            unByKey(this.onChangeVisibleKey);
         }
-        _super.prototype.detachFromMap.call(this);
-    };
-    Layer.prototype.activateUserInteractions = function () {
+        super.detachFromMap();
+    }
+    activateUserInteractions() {
         this.deactivateUserInteractions();
         if (this.map &&
             this.userInteractions &&
@@ -94,46 +53,45 @@ var Layer = /** @class */ (function (_super) {
             this.userHoverCallbacks.length) {
             this.map.on('mousemove', this.onUserMoveCallback);
         }
-    };
-    Layer.prototype.deactivateUserInteractions = function () {
+    }
+    deactivateUserInteractions() {
         if (this.map) {
             this.map.off('mousemove', this.onUserMoveCallback);
             this.map.off('click', this.onUserClickCallback);
         }
-    };
+    }
     /**
      * Toggle listeners needed when a layer is avisible or not.
      * @private
      */
-    Layer.prototype.toggleVisibleListeners = function () {
+    toggleVisibleListeners() {
         if (this.visible) {
             this.activateUserInteractions();
         }
         else {
             this.deactivateUserInteractions();
         }
-    };
+    }
     /**
      * Returns the current extent in mercator coordinates.
      */
-    Layer.prototype.getMercatorExtent = function () {
-        var bounds = this.map.getBounds().toArray();
-        return (0, proj_1.transformExtent)(__spreadArray(__spreadArray([], bounds[0], true), bounds[1], true), 'EPSG:4326', 'EPSG:3857');
-    };
+    getMercatorExtent() {
+        const bounds = this.map.getBounds().toArray();
+        return transformExtent([...bounds[0], ...bounds[1]], 'EPSG:4326', 'EPSG:3857');
+    }
     /**
      * Returns the equivalent zoom in Openlayers.
      */
-    Layer.prototype.getOlZoom = function () {
+    getOlZoom() {
         return this.map.getZoom() + 1;
-    };
+    }
     /**
      * Create a copy of the Layer.
      * @param {Object} newOptions Options to override
      * @return {Layer} A Layer
      */
-    Layer.prototype.clone = function (newOptions) {
-        return new Layer(__assign(__assign({}, this.options), newOptions));
-    };
-    return Layer;
-}((0, UserInteractionsLayerMixin_1.default)(Layer_1.default)));
-exports.default = Layer;
+    clone(newOptions) {
+        return new Layer(Object.assign(Object.assign({}, this.options), newOptions));
+    }
+}
+export default Layer;

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

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

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

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

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.d.ts

@@ -49,8 +49,8 @@ declare class RealtimeLayer extends Layer implements RealtimeLayerInterface {
         coordinates: any[][];
         animate: boolean;
         attribution: any;
-    };
-    beforeId: string;
+    } | undefined;
+    beforeId: string | undefined;
     layer: {
         id: any;
         type: string;
@@ -63,8 +63,8 @@ declare class RealtimeLayer extends Layer implements RealtimeLayerInterface {
             'raster-fade-duration': number;
             'raster-resampling': string;
         };
-    };
-    listeners: any[];
+    } | undefined;
+    listeners: any[] | undefined;
     /**
      * Start updating vehicles position.
      *

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

@@ -1 +1 @@
-{"version":3,"file":"RealtimeLayer.d.ts","sourceRoot":"","sources":["../../../src/mapbox/layers/RealtimeLayer.js"],"names":[],"mappings":";AASA;;;;;;;;;;;;;;;;GAgBG;AACH,qDAFgB,sBAAsB;IAGpC,0BAmBC;IAuGD,eAOC;IA0HD;;;;OAIG;IACH,eAEC;IAcD;;;;;OAKG;IACH,2BAMC;IA9QC,cAAc;IACd,eAA0C;IAoM5C,2BAYC;IA1MD;;;;;;OAMG;IACH,kDAHW,MAAM,QA8ChB;IA/BC;;;;;;MAOC;IAED,iBAAwB;IACxB;;;;;;;;;;;;MAYC;IAQD,iBAAqE;IAuBvE;;;;;;OAMG;IACH,uBAMC;IAED;;;;OAIG;IACH,sBAOC;IAWD;;;OAGG;IACH,4CAKC;IAED;;;;OAIG;IACH,kCAHW,OAAO,QAkDjB;IAED;;OAEG;IACH,0BAEC;IAED,+DAMC;IAgBD;;;;OAIG;IACH,wBAMC;IAED;;OAEG;IACH,sCAQC;IAWD,oEAUC;IAgBD;;;;;OAKG;IACH,gCAKC;CACF"}
+{"version":3,"file":"RealtimeLayer.d.ts","sourceRoot":"","sources":["../../../src/mapbox/layers/RealtimeLayer.js"],"names":[],"mappings":";AASA;;;;;;;;;;;;;;;;GAgBG;AACH,qDAFgB,sBAAsB;IAGpC,0BAmBC;IAuGD,eAOC;IA0HD;;;;OAIG;IACH,eAEC;IAcD;;;;;OAKG;IACH,2BAMC;IA9QC,cAAc;IACd,eAA0C;IAoM5C,2BAYC;IA1MD;;;;;;OAMG;IACH,kDAHW,MAAM,QA8ChB;IA/BC;;;;;;kBAOC;IAED,6BAAwB;IACxB;;;;;;;;;;;;kBAYC;IAQD,6BAAqE;IAuBvE;;;;;;OAMG;IACH,uBAMC;IAED;;;;OAIG;IACH,sBAOC;IAWD;;;OAGG;IACH,4CAKC;IAED;;;;OAIG;IACH,kCAHW,OAAO,QAkDjB;IAED;;OAEG;IACH,0BAEC;IAED,+DAMC;IAgBD;;;;OAIG;IACH,wBAMC;IAED;;OAEG;IACH,sCAQC;IAWD,oEAUC;IAgBD;;;;;OAKG;IACH,gCAKC;CACF"}