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

package/ol/layers/MapboxStyleLayer.test.js

@@ -0,0 +1,232 @@
+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 OlMap from 'ol/Map';
+import View from 'ol/View';
+import gllib from 'maplibre-gl';
+import Layer from './Layer';
+import MaplibreLayer from './MaplibreLayer';
+import MapboxStyleLayer from './MapboxStyleLayer';
+let source;
+let layer;
+let map;
+let onClick;
+const styleLayer = {
+    id: 'layer',
+};
+describe('MapboxStyleLayer', () => {
+    beforeEach(() => {
+        onClick = jest.fn();
+        source = new MaplibreLayer({
+            name: 'Layer',
+            apiKey: 'foo',
+            url: 'https://foo.com/styles',
+        });
+        layer = new MapboxStyleLayer({
+            name: 'mapbox layer',
+            visible: true,
+            mapboxLayer: source,
+            styleLayer,
+            onClick,
+        });
+        map = new OlMap({
+            target: document.createElement('div'),
+            view: new View({ center: [0, 0] }),
+        });
+    });
+    afterEach(() => {
+        if (layer.map) {
+            layer.detachFromMap(map);
+        }
+        if (source.map) {
+            source.detachFromMap(map);
+        }
+    });
+    test('should be instanced.', () => {
+        expect(layer).toBeInstanceOf(MapboxStyleLayer);
+        expect(layer.styleLayers[0]).toBe(styleLayer);
+    });
+    test('should not initalized mapbox map.', () => {
+        layer.attachToMap();
+        expect(layer.mbMap).toBe();
+        layer.detachFromMap();
+    });
+    test('should initalized mapbox map.', () => {
+        source.attachToMap(map);
+        layer.attachToMap(map);
+        expect(layer.mapboxLayer.mbMap).toBeInstanceOf(gllib.Map);
+        layer.detachFromMap();
+        source.detachFromMap();
+    });
+    test('should called terminate on initalization.', () => {
+        const spy = jest.spyOn(layer, 'detachFromMap');
+        layer.attachToMap();
+        expect(spy).toHaveBeenCalledTimes(1);
+        layer.detachFromMap(map);
+    });
+    test('should return coordinates, features and a layer instance.', () => __awaiter(void 0, void 0, void 0, function* () {
+        source.attachToMap(map);
+        layer.attachToMap(map);
+        const data = yield layer.getFeatureInfoAtCoordinate([50, 50]);
+        expect(data.coordinate).toEqual([50, 50]);
+        expect(data.features).toEqual([]);
+        expect(data.layer).toBeInstanceOf(MapboxStyleLayer);
+        layer.detachFromMap(map);
+        source.detachFromMap(map);
+    }));
+    test('should call onClick callback', () => __awaiter(void 0, void 0, void 0, function* () {
+        const coordinate = [500, 500];
+        const features = [];
+        const evt = { type: 'singleclick', map, coordinate };
+        layer.attachToMap(map);
+        expect(onClick).toHaveBeenCalledTimes(0);
+        yield map.dispatchEvent(evt);
+        expect(onClick).toHaveBeenCalledTimes(1);
+        expect(onClick).toHaveBeenCalledWith(features, layer, coordinate);
+        layer.detachFromMap();
+    }));
+    test('should call super class terminate function.', () => {
+        layer.attachToMap(map);
+        const spy = jest.spyOn(Layer.prototype, 'detachFromMap');
+        layer.detachFromMap(map);
+        expect(spy).toHaveBeenCalledTimes(1);
+        spy.mockRestore();
+    });
+    test('should call super class terminate if the mapboxLayer associated has been terminated before.', () => {
+        layer.attachToMap(map);
+        source.detachFromMap(map);
+        const spy = jest.spyOn(Layer.prototype, 'detachFromMap');
+        layer.detachFromMap(map);
+        expect(spy).toHaveBeenCalledTimes(1);
+        spy.mockRestore();
+    });
+    test('should clone', () => {
+        const clone = layer.clone({ name: 'clone' });
+        expect(clone).not.toBe(layer);
+        expect(clone.name).toBe('clone');
+        expect(clone).toBeInstanceOf(MapboxStyleLayer);
+    });
+    test('should add layer on load', () => {
+        const style = { layers: [] };
+        layer.mapboxLayer.mbMap = {
+            getStyle: () => style,
+            getSource: () => ({}),
+            getLayer: () => null,
+            setLayoutProperty: () => null,
+            addLayer: (styleLayerr) => style.layers.push(styleLayerr),
+        };
+        layer.onLoad();
+        expect(style.layers[0]).toBe(styleLayer);
+    });
+    describe('should set disabled property to false on load', () => {
+        test('when layer uses styleLayer property', () => {
+            const styles = { layers: [] };
+            layer.mapboxLayer.mbMap = {
+                getStyle: () => styles,
+                getSource: () => ({}),
+                getLayer: () => null,
+                setLayoutProperty: () => null,
+                addLayer: (styleLayerr) => styles.layers.push(styleLayerr),
+            };
+            expect(layer).toBeInstanceOf(MapboxStyleLayer);
+            layer.onLoad();
+            expect(layer.disabled).toBe(false);
+        });
+    });
+    describe('should set disabled property to true on load', () => {
+        test('when layer uses styleLayersFilter property', () => {
+            const styles = { layers: [styleLayer] };
+            const layer2 = new MapboxStyleLayer({
+                name: 'mapbox layer',
+                mapboxLayer: source,
+                styleLayersFilter: () => false,
+            });
+            layer2.mapboxLayer.mbMap = {
+                getStyle: () => styles,
+                getSource: () => ({}),
+                getLayer: () => null,
+                setLayoutProperty: () => null,
+                addLayer: () => ({}),
+            };
+            layer2.onLoad();
+            expect(layer2.disabled).toBe(true);
+        });
+    });
+    describe('#getFeatureInfoAtCoordinate()', () => {
+        beforeEach(() => {
+            source.attachToMap(map);
+            source.mbMap.isStyleLoaded = jest.fn(() => true);
+            source.mbMap.getSource = jest.fn(() => true);
+        });
+        afterEach(() => {
+            source.mbMap.getSource.mockRestore();
+            source.mbMap.isStyleLoaded.mockRestore();
+        });
+        test('should request features on layers ids from styleLayers property', () => {
+            source.mbMap.getStyle = jest.fn(() => ({
+                layers: [{ id: 'foo' }, { id: 'layer' }, { id: 'bar' }],
+            }));
+            layer.attachToMap(map);
+            layer.mapboxLayer.getFeatureInfoAtCoordinate = jest.fn(() => Promise.resolve({ features: [] }));
+            layer.getFeatureInfoAtCoordinate([0, 0]).then(() => { });
+            expect(layer.mapboxLayer.getFeatureInfoAtCoordinate).toHaveBeenCalledWith([0, 0], { layers: ['layer'], validate: false });
+            layer.mapboxLayer.getFeatureInfoAtCoordinate.mockRestore();
+            source.mbMap.getStyle.mockRestore();
+        });
+        test('should request features on layers ids from styleLayersFilter property', () => {
+            source.mbMap.getStyle = jest.fn(() => ({
+                layers: [{ id: 'foo' }, { id: 'layer' }, { id: 'bar' }, { id: 'foo2' }],
+            }));
+            const layer2 = new MapboxStyleLayer({
+                name: 'mapbox layer',
+                visible: true,
+                mapboxLayer: source,
+                styleLayer,
+                styleLayersFilter: ({ id }) => /foo/.test(id),
+            });
+            layer2.attachToMap(map);
+            layer2.mapboxLayer.getFeatureInfoAtCoordinate = jest.fn(() => Promise.resolve({ features: [] }));
+            layer2.getFeatureInfoAtCoordinate([0, 0]).then(() => { });
+            expect(layer2.mapboxLayer.getFeatureInfoAtCoordinate).toHaveBeenCalledWith([0, 0], {
+                layers: ['foo', 'foo2'],
+                validate: false,
+            });
+            layer2.mapboxLayer.getFeatureInfoAtCoordinate.mockRestore();
+            source.mbMap.getStyle.mockRestore();
+        });
+        test('should request features on layers ids from queryRenderedLayersFilter property', () => {
+            source.mbMap.getStyle = jest.fn(() => ({
+                layers: [
+                    { id: 'foo' },
+                    { id: 'bar2' },
+                    { id: 'layer' },
+                    { id: 'bar' },
+                    { id: 'foo2' },
+                ],
+            }));
+            const layer2 = new MapboxStyleLayer({
+                name: 'mapbox layer',
+                visible: true,
+                mapboxLayer: source,
+                styleLayer,
+                styleLayersFilter: ({ id }) => /foo/.test(id),
+                queryRenderedLayersFilter: ({ id }) => /bar/.test(id),
+            });
+            layer2.attachToMap(map);
+            layer2.mapboxLayer.getFeatureInfoAtCoordinate = jest.fn(() => Promise.resolve({ features: [] }));
+            layer2.getFeatureInfoAtCoordinate([0, 0]).then(() => { });
+            expect(layer2.mapboxLayer.getFeatureInfoAtCoordinate).toHaveBeenCalledWith([0, 0], {
+                layers: ['bar2', 'bar'],
+                validate: false,
+            });
+            layer2.mapboxLayer.getFeatureInfoAtCoordinate.mockRestore();
+            source.mbMap.getStyle.mockRestore();
+        });
+    });
+});

package/ol/layers/MaplibreLayer.d.ts

@@ -20,7 +20,7 @@ export default class MaplibreLayer extends Layer {
      * @param {Object} newOptions Options to override
      * @return {MapboxLayer} A MapboxLayer
      */
-    clone(newOptions: any): MapboxLayer;
+    clone(newOptions: Object): MapboxLayer;
 }
 import Layer from "./Layer";
 import { Map } from "maplibre-gl";

package/ol/layers/MaplibreLayer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MaplibreLayer.d.ts","sourceRoot":"","sources":["../../../src/ol/layers/MaplibreLayer.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;GAaG;AACH;IACE,6CAEC;IAGD,gCAEC;IAED;;;;OAIG;IACH,oCAEC;CACF"}
+{"version":3,"file":"MaplibreLayer.d.ts","sourceRoot":"","sources":["../../../src/ol/layers/MaplibreLayer.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;GAaG;AACH;IACE,6CAEC;IAGD,gCAEC;IAED;;;;OAIG;IACH,kBAHW,MAAM,eAKhB;CACF"}

package/ol/layers/MaplibreLayer.js

@@ -1,35 +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);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var maplibre_gl_1 = require("maplibre-gl");
-var Layer_1 = require("./Layer");
-var MapboxLayerMixin_1 = require("../../common/mixins/MapboxLayerMixin");
-var utils_1 = require("../../common/utils");
+import { Map } from 'maplibre-gl';
+import Layer from './Layer';
+import mixin from '../../common/mixins/MapboxLayerMixin';
+import { getMaplibreRender } from '../../common/utils';
 /**
  * A class representing MaplibreLayer to display on BasicMap
  *
@@ -44,26 +16,20 @@ var utils_1 = require("../../common/utils");
  * @classproperty {ol/Map~Map} map - The map where the layer is displayed.
  * @extends {Layer}
  */
-var MaplibreLayer = /** @class */ (function (_super) {
-    __extends(MaplibreLayer, _super);
-    function MaplibreLayer() {
-        return _super !== null && _super.apply(this, arguments) || this;
+export default class MaplibreLayer extends mixin(Layer) {
+    getOlLayerRender() {
+        return getMaplibreRender(this);
     }
-    MaplibreLayer.prototype.getOlLayerRender = function () {
-        return (0, utils_1.getMaplibreRender)(this);
-    };
     // eslint-disable-next-line class-methods-use-this
-    MaplibreLayer.prototype.getMapboxMapClass = function () {
-        return maplibre_gl_1.Map;
-    };
+    getMapboxMapClass() {
+        return Map;
+    }
     /**
      * Create a copy of the MapboxLayer.
      * @param {Object} newOptions Options to override
      * @return {MapboxLayer} A MapboxLayer
      */
-    MaplibreLayer.prototype.clone = function (newOptions) {
-        return new MaplibreLayer(__assign(__assign({}, this.options), newOptions));
-    };
-    return MaplibreLayer;
-}((0, MapboxLayerMixin_1.default)(Layer_1.default)));
-exports.default = MaplibreLayer;
+    clone(newOptions) {
+        return new MaplibreLayer(Object.assign(Object.assign({}, this.options), newOptions));
+    }
+}

package/ol/layers/RealtimeLayer.d.ts

@@ -33,7 +33,7 @@ declare class RealtimeLayer extends Layer implements UserInteractionsLayerInterf
     /** @ignore */
     renderState: {
         center: number[];
-        zoom: any;
+        zoom: null;
         rotation: number;
     };
     attachToMap(map: any): void;
@@ -113,7 +113,7 @@ declare class RealtimeLayer extends Layer implements UserInteractionsLayerInterf
      * @param {Object} newOptions Options to override
      * @return {RealtimeLayer} A RealtimeLayer
      */
-    clone(newOptions: any): RealtimeLayer;
+    clone(newOptions: Object): RealtimeLayer;
 }
 import Layer from "./Layer";
 //# sourceMappingURL=RealtimeLayer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"RealtimeLayer.d.ts","sourceRoot":"","sources":["../../../src/ol/layers/RealtimeLayer.js"],"names":[],"mappings":";AAYA;;;;;;;;;;;;;;;;;GAiBG;AACH,qDAHgB,8BAA8B,EAC9B,sBAAsB;IAGpC;;;;;OAKG;IACH,sBA2FC;IApFC,cAAc;IACd,aAsEI;IApDQ,0BAA8C;IAI9C,mCAAuD;IAmDnE,iBAAmD;IAInD,cAAc;IACd;;;;MAIC;IAGH,4BAqBC;IANO,iBAAuB;IAgB/B;;;;OAIG;IACH,qDAYC;IAED;;;;OAIG;IACH,kCAHW,OAAO,QAiBjB;IAED;;;;OAIG;IACH,4CAuBC;IAPG,uBAAyC;IAS7C;;OAEG;IACH,0BAEC;IAED,+DAMC;IAED;;;;;OAKG;IACH,2BAaC;IAED;;;;;;OAMG;IAEH,2BAEC;IAED;;;;;OAKG;IACH,gCAKC;IAED;;;;;OAKG;IACH,gCAQC;IAED;;;;OAIG;IACH,wBAMC;IAED;;;;OAIG;IACH,gBAQC;IAED;;;OAGG;IACH,4BAiBC;IAED;;;;OAIG;IACH,wBAFY,aAAa,CAIxB;CACF"}
+{"version":3,"file":"RealtimeLayer.d.ts","sourceRoot":"","sources":["../../../src/ol/layers/RealtimeLayer.js"],"names":[],"mappings":";AAYA;;;;;;;;;;;;;;;;;GAiBG;AACH,qDAHgB,8BAA8B,EAC9B,sBAAsB;IAGpC;;;;;OAKG;IACH,sBA2FC;IApFC,cAAc;IACd,aAsEI;IApDQ,0BAA8C;IAI9C,mCAAuD;IAmDnE,iBAAmD;IAInD,cAAc;IACd;;;;MAIC;IAGH,4BAqBC;IANO,iBAAuB;IAgB/B;;;;OAIG;IACH,qDAYC;IAED;;;;OAIG;IACH,kCAHW,OAAO,QAiBjB;IAED;;;;OAIG;IACH,4CAuBC;IAPG,uBAAyC;IAS7C;;OAEG;IACH,0BAEC;IAED,+DAMC;IAED;;;;;OAKG;IACH,2BAaC;IAED;;;;;;OAMG;IAEH,2BAEC;IAED;;;;;OAKG;IACH,gCAKC;IAED;;;;;OAKG;IACH,gCAQC;IAED;;;;OAIG;IACH,wBAMC;IAED;;;;OAIG;IACH,gBAQC;IAED;;;OAGG;IACH,4BAiBC;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACL,aAAa,CAIxB;CACF"}