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

package/ol/controls/CopyrightControl.test.d.ts

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

package/ol/controls/CopyrightControl.test.d.ts.map

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

package/ol/controls/CopyrightControl.test.js

@@ -0,0 +1,177 @@
+import View from 'ol/View';
+import Tile from 'ol/Tile';
+import TileLayer from 'ol/layer/Tile';
+import TileSource from 'ol/source/Tile';
+import { createXYZ } from 'ol/tilegrid';
+import { Map } from 'ol';
+import Layer from '../layers/Layer';
+import CopyrightControl from './CopyrightControl';
+const tileLoadFunction = () => {
+    const tile = new Tile([0, 0, -1], 2 /* LOADED */);
+    tile.getImage = () => {
+        const image = new Image();
+        image.width = 256;
+        image.height = 256;
+        return image;
+    };
+    return tile;
+};
+const getOLTileLayer = () => {
+    const layer = new TileLayer({
+        source: new TileSource({
+            projection: 'EPSG:3857',
+            tileGrid: createXYZ(),
+        }),
+    });
+    layer.getSource().getTile = tileLoadFunction;
+    return layer;
+};
+const getLayer = (copyrights, visible = true) => new Layer({
+    visible,
+    copyrights,
+    olLayer: getOLTileLayer(),
+});
+describe('CopyrightControl', () => {
+    let map;
+    beforeEach(() => {
+        const target = document.createElement('div');
+        document.body.appendChild(target);
+        map = new Map({
+            target,
+            view: new View({
+                center: [0, 0],
+                zoom: 0,
+            }),
+        });
+        getLayer(true, 'bar').attachToMap(map);
+        map.setSize([200, 200]);
+        map.renderSync();
+    });
+    afterEach(() => {
+        if (map) {
+            map.setTarget(null);
+            map = null;
+        }
+    });
+    test('should be activate by default', () => {
+        const control = new CopyrightControl();
+        expect(control.active).toBe(true);
+    });
+    test('renders a string copyright', () => {
+        const control = new CopyrightControl();
+        control.attachToMap(map);
+        expect(control.element.innerHTML).toBe('');
+        getLayer('copyright').attachToMap(map);
+        map.renderSync();
+        expect(control.element.innerHTML).toBe('copyright');
+    });
+    test('renders an array of copyrights', () => {
+        const control = new CopyrightControl();
+        control.attachToMap(map);
+        expect(control.element.innerHTML).toBe('');
+        getLayer(['copyright 1', 'copyright 2']).attachToMap(map);
+        map.renderSync();
+        expect(control.element.innerHTML).toBe('copyright 1 | copyright 2');
+    });
+    test('renders unique copyrights', () => {
+        const control = new CopyrightControl();
+        control.attachToMap(map);
+        expect(control.element.innerHTML).toBe('');
+        getLayer(['copyright 1', 'copyright 2']).attachToMap(map);
+        getLayer('copyright 1').attachToMap(map);
+        getLayer(['copyright 2']).attachToMap(map);
+        map.renderSync();
+        expect(control.element.innerHTML).toBe('copyright 1 | copyright 2');
+    });
+    test("doesn't render copyright of an hidden layer", () => {
+        const control = new CopyrightControl();
+        control.attachToMap(map);
+        expect(control.element.innerHTML).toBe('');
+        const layer1 = getLayer('copyright hidden', false);
+        layer1.attachToMap(map);
+        const layer2 = getLayer('copyright', true);
+        layer2.attachToMap(map);
+        map.renderSync();
+        expect(control.element.innerHTML).toBe('copyright');
+        // the we update visibility of both layers
+        layer1.visible = true;
+        map.renderSync();
+        layer2.visible = false;
+        map.renderSync();
+        expect(control.element.innerHTML).toBe('copyright hidden');
+    });
+    test('should activate the control on construction then deactivate it', () => {
+        getLayer('copyright 1').attachToMap(map);
+        const control = new CopyrightControl({ active: true });
+        control.attachToMap(map);
+        map.renderSync();
+        expect(control.element.parentNode).toBe(map.getTargetElement());
+        // Should be activated by default.
+        expect(control.active).toBe(true);
+        expect(control.element.innerHTML).toBe('copyright 1');
+        // on deactivation
+        control.active = false;
+        map.renderSync();
+        expect(control.element.innerHTML).toBe('');
+    });
+    test('should deactivate the control on constrcution then activate it', () => {
+        getLayer('copyright 1').attachToMap(map);
+        const control = new CopyrightControl({ active: false });
+        control.attachToMap(map);
+        map.renderSync();
+        expect(control.element.parentNode).toBe(map.getTargetElement());
+        // Should be activated by default.
+        expect(control.active).toBe(false);
+        map.renderSync();
+        expect(control.element.innerHTML).toBe('');
+        // on deactivation
+        control.active = true;
+        map.renderSync();
+        expect(control.element.innerHTML).toBe('copyright 1');
+    });
+    test('should add copyrights in the map container element then remove it.', () => {
+        getLayer('copyright value').attachToMap(map);
+        map.renderSync();
+        const control = new CopyrightControl();
+        // Add control
+        control.attachToMap(map);
+        expect(control.element.parentNode).toBe(map.getTargetElement());
+        // Remove control
+        control.detachFromMap();
+        expect(control.element.parentNode).toBe(null);
+    });
+    test('should add copyrights in the target element then remove it.', () => {
+        getLayer(['copyright value']).attachToMap(map);
+        map.renderSync();
+        const target = document.createElement('div');
+        target.setAttribute('id', 'copyright');
+        document.body.appendChild(target);
+        const control = new CopyrightControl({
+            target: document.getElementById('copyright'),
+        });
+        // Add control
+        control.attachToMap(map);
+        expect(control.element.parentNode).toBe(target);
+        // Remove control
+        control.detachFromMap();
+        expect(control.element.parentNode).toBe(null);
+    });
+    test('renders custom copyrights with the render method ', () => {
+        const control = new CopyrightControl({
+            active: true,
+            render() {
+                if (!this.element) {
+                    return;
+                }
+                this.element.innerHTML = this.active
+                    ? this.getCopyrights().join(', ')
+                    : '';
+            },
+        });
+        control.attachToMap(map);
+        getLayer(['copyright 1', 'copyright 2', 'copyright 3']).attachToMap(map);
+        map.renderSync();
+        // Add control
+        expect(control.element.innerHTML).toBe('copyright 1, copyright 2, copyright 3');
+    });
+});

package/ol/controls/RoutingControl.d.ts

@@ -65,7 +65,7 @@ declare class RoutingControl extends Control implements RoutingInterface {
     /** @ignore */
     stopsApiUrl: any;
     /** @ignore */
-    api: any;
+    api: RoutingAPI;
     /** @ignore */
     routingLayer: any;
     /** @ignore */
@@ -175,6 +175,7 @@ declare class RoutingControl extends Control implements RoutingInterface {
     graphsResolutions: any;
 }
 import Control from "../../common/controls/Control";
+import { RoutingAPI } from "../../api";
 import { Feature } from "ol";
 import { GeoJSON } from "ol/format";
 //# sourceMappingURL=RoutingControl.d.ts.map

package/ol/controls/RoutingControl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RoutingControl.d.ts","sourceRoot":"","sources":["../../../src/ol/controls/RoutingControl.js"],"names":[],"mappings":";AAiDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wDAFgB,gBAAgB;IAoH9B;;;;OAIG;IACH,oCAMC;IA5HD,0BA+GC;IAlFC,qDAAqD;IACrD,iBAAoB;IAEpB,cAAc;IACd,YAAgD;IAEhD,cAAc;IACd,SAA+B;IAE/B,cAAc;IACd,gBAAsC;IAEtC,cAAc;IACd,sBAAsD;IAEtD,cAAc;IACd,qBAAuD;IAEvD,cAAc;IACd,0BAAiE;IAEjE,cAAc;IACd,qBAA0B;IAE1B,cAAc;IACd,wBAA0B;IAE1B,cAAc;IACd,YAA4B;IAE5B,cAAc;IACd,iBAAqD;IAErD,cAAc;IACd,gBAAkB;IAElB,cAAc;IACd,iBAA0E;IAE1E,cAAc;IACd,SAEE;IAEF,cAAc;IACd,kBAKI;IAEJ,cAAc;IACd,kBAUI;IAEJ,cAAc;IACd,iBAAmB;IAoXrB;;;;;OAKG;IACH,mBAeC;IA4CD;;;;;OAKG;IACH,oBAqBC;IArED;;;;OAIG;IACH,sBAmCC;IAxaC,cAAc;IACd,2KAA+C;IAmBjD;;;;;;;;;OASG;IACH,wGAYC;IAED;;;;OAIG;IACH,uBAFW,MAAM,QAYhB;IAED;;;OAGG;IACH,8BAFW,MAAM,MAAM,MAAM,CAAC,CAAC,QAS9B;IAED;;OAEG;IACH,cASC;IAED;;;OAGG;IACH,sBAeC;IAED;;;;;;OAMG;IACH,kBA0HC;IAED;;;;OAIG;IACH,qBAkHC;IA2DC,cAAc;IACd;;;;kBAIC;IAsCD,cAAc;IACd,uCAA+C;IAYjD;;;OAGG;IACH,gCA8BC;IA7BC;;;OAGG;IAEH,0BAoBE;IAMJ;;;OAGG;IACH,qBAOC;IAFC,cAAc;IACd,mBAAgE;IAGlE;;;OAGG;IACH,wBAEC;IAKG,cAAc;IACd,4BAEE;IAEF,cAAc;IACd,uBAGC;CA2BN"}
+{"version":3,"file":"RoutingControl.d.ts","sourceRoot":"","sources":["../../../src/ol/controls/RoutingControl.js"],"names":[],"mappings":";AAiDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wDAFgB,gBAAgB;IAoH9B;;;;OAIG;IACH,oCAMC;IA5HD,0BA+GC;IAlFC,qDAAqD;IACrD,iBAAoB;IAEpB,cAAc;IACd,YAAgD;IAEhD,cAAc;IACd,SAA+B;IAE/B,cAAc;IACd,gBAAsC;IAEtC,cAAc;IACd,sBAAsD;IAEtD,cAAc;IACd,qBAAuD;IAEvD,cAAc;IACd,0BAAiE;IAEjE,cAAc;IACd,qBAA0B;IAE1B,cAAc;IACd,wBAA0B;IAE1B,cAAc;IACd,YAA4B;IAE5B,cAAc;IACd,iBAAqD;IAErD,cAAc;IACd,gBAAkB;IAElB,cAAc;IACd,iBAA0E;IAE1E,cAAc;IACd,gBAEE;IAEF,cAAc;IACd,kBAKI;IAEJ,cAAc;IACd,kBAUI;IAEJ,cAAc;IACd,iBAAmB;IAoXrB;;;;;OAKG;IACH,mBAeC;IA4CD;;;;;OAKG;IACH,oBAqBC;IArED;;;;OAIG;IACH,sBAmCC;IAxaC,cAAc;IACd,2KAA+C;IAmBjD;;;;;;;;;OASG;IACH,wGAYC;IAED;;;;OAIG;IACH,uBAFW,MAAM,QAYhB;IAED;;;OAGG;IACH,8BAFW,MAAM,MAAM,MAAM,CAAC,CAAC,QAS9B;IAED;;OAEG;IACH,cASC;IAED;;;OAGG;IACH,sBAeC;IAED;;;;;;OAMG;IACH,kBA0HC;IAED;;;;OAIG;IACH,qBAkHC;IA2DC,cAAc;IACd;;;;kBAIC;IAsCD,cAAc;IACd,uCAA+C;IAYjD;;;OAGG;IACH,gCA8BC;IA7BC;;;OAGG;IAEH,0BAoBE;IAMJ;;;OAGG;IACH,qBAOC;IAFC,cAAc;IACd,mBAAgE;IAGlE;;;OAGG;IACH,wBAEC;IAKG,cAAc;IACd,4BAEE;IAEF,cAAc;IACd,uBAGC;CA2BN"}

package/ol/controls/RoutingControl.test.d.ts

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

package/ol/controls/RoutingControl.test.d.ts.map

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

package/ol/controls/RoutingControl.test.js

@@ -0,0 +1,150 @@
+import fetch from 'jest-fetch-mock';
+import View from 'ol/View';
+import Map from 'ol/Map';
+import RoutingControl from './RoutingControl';
+import RoutingControlStation1 from './snapshots/RoutingControlStation1.json';
+import RoutingControlStation2 from './snapshots/RoutingControlStation2.json';
+import RoutingControlRouteGen5 from './snapshots/RoutingControlRouteGen5.json';
+import RoutingControlRouteGen10 from './snapshots/RoutingControlRouteGen10.json';
+import RoutingControlRouteGen30 from './snapshots/RoutingControlRouteGen30.json';
+import RoutingControlRouteGen100 from './snapshots/RoutingControlRouteGen100.json';
+import RoutingControlRouteOSM from './snapshots/RoutingControlRouteOSM.json';
+describe('RoutingControl', () => {
+    let map;
+    beforeEach(() => {
+        const target = document.createElement('div');
+        document.body.appendChild(target);
+        map = new Map({
+            target,
+            view: new View({
+                center: [0, 0],
+                zoom: 0,
+            }),
+        });
+        global.fetch = fetch;
+    });
+    afterEach(() => {
+        if (map) {
+            map.setTarget(null);
+            map = null;
+        }
+        fetch.resetMocks();
+    });
+    test('should be activate by default', () => {
+        const control = new RoutingControl();
+        expect(control.active).toBe(true);
+        expect(control.snapToClosestStation).toBe(false);
+        expect(control.useRawViaPoints).toBe(false);
+    });
+    test('launch routing and add features', (done) => {
+        fetch.mockResponseOnce(JSON.stringify(global.fetchRouteResponse));
+        const control = new RoutingControl({
+            url: 'https://foo.ch',
+            apiKey: 'foo',
+        });
+        control.attachToMap(map);
+        expect(map.getTargetElement().querySelector('#ol-toggle-routing')).toBeDefined();
+        control.viaPoints = [
+            [950476.4055933182, 6003322.253698345],
+            [950389.0813034325, 6003656.659274571],
+        ];
+        control.drawRoute(control.viaPoints).then(() => {
+            // Should use correct URL
+            expect(fetch.mock.calls[0][0]).toEqual('https://foo.ch/?key=foo&graph=osm&via=47.3739194713294%2C8.538274823394632%7C47.37595378493421%2C8.537490375951839&mot=bus&resolve-hops=false&elevation=false&coord-radius=100&coord-punish=1000');
+            // routingLayer should contain three features (2 x viapoints, 1 x route)
+            expect(control.routingLayer.olLayer.getSource().getFeatures().length).toEqual(3);
+            done();
+        });
+    });
+    test('launch routing and add features for multiple graphs', (done) => {
+        fetch.mockResponses([JSON.stringify(RoutingControlStation1), { status: 200 }], [JSON.stringify(RoutingControlStation2), { status: 200 }], [JSON.stringify(RoutingControlRouteGen5), { status: 200 }], [JSON.stringify(RoutingControlRouteGen10), { status: 200 }], [JSON.stringify(RoutingControlRouteGen30), { status: 200 }], [JSON.stringify(RoutingControlRouteGen100), { status: 200 }], [JSON.stringify(RoutingControlRouteOSM), { status: 200 }]);
+        const control = new RoutingControl({
+            url: 'https://foo.ch/',
+            stopsApiUrl: 'https://foo.ch/',
+            apiKey: 'foo',
+            graphs: [
+                ['gen5', 6, 7],
+                ['gen10', 8],
+                ['gen30', 9, 10],
+                ['gen100', 11, 13],
+                ['osm', 14, 99],
+            ],
+        });
+        control.attachToMap(map);
+        control.viaPoints = ['a4dca961d199ff76', 'e3666f03cba06b2b'];
+        control.drawRoute(control.viaPoints).then(() => {
+            // Should use correct URL
+            expect(fetch.mock.calls[0][0]).toEqual('https://foo.ch/lookup/a4dca961d199ff76?key=foo');
+            expect(fetch.mock.calls[1][0]).toEqual('https://foo.ch/lookup/e3666f03cba06b2b?key=foo');
+            expect(fetch.mock.calls[2][0]).toEqual('https://foo.ch/?key=foo&graph=gen5&via=%21a4dca961d199ff76%7C%21e3666f03cba06b2b&mot=bus&resolve-hops=false&elevation=false&coord-radius=100&coord-punish=1000');
+            expect(fetch.mock.calls[3][0]).toEqual('https://foo.ch/?key=foo&graph=gen10&via=%21a4dca961d199ff76%7C%21e3666f03cba06b2b&mot=bus&resolve-hops=false&elevation=false&coord-radius=100&coord-punish=1000');
+            expect(fetch.mock.calls[4][0]).toEqual('https://foo.ch/?key=foo&graph=gen30&via=%21a4dca961d199ff76%7C%21e3666f03cba06b2b&mot=bus&resolve-hops=false&elevation=false&coord-radius=100&coord-punish=1000');
+            expect(fetch.mock.calls[5][0]).toEqual('https://foo.ch/?key=foo&graph=gen100&via=%21a4dca961d199ff76%7C%21e3666f03cba06b2b&mot=bus&resolve-hops=false&elevation=false&coord-radius=100&coord-punish=1000');
+            expect(fetch.mock.calls[6][0]).toEqual('https://foo.ch/?key=foo&graph=osm&via=%21a4dca961d199ff76%7C%21e3666f03cba06b2b&mot=bus&resolve-hops=false&elevation=false&coord-radius=100&coord-punish=1000');
+            // routingLayer should contain seven features (2 x viapoints, 5 x route for each graph)
+            expect(control.routingLayer.olLayer.getSource().getFeatures().length).toEqual(7);
+            done();
+        });
+    });
+    test('ignores Abort Error and returns undefined', (done) => {
+        const control = new RoutingControl({
+            url: 'https://foo.ch',
+            apiKey: 'foo',
+        });
+        control.attachToMap(map);
+        control.viaPoints = [
+            [950476.4055933182, 6003322.253698345],
+            [950389.0813034325, 6003656.659274571],
+        ];
+        const error = new Error('Error');
+        error.name = 'AbortError';
+        fetch.mockRejectOnce(error);
+        return control.drawRoute().then((data) => {
+            expect(data).toEqual([undefined]);
+            done();
+        });
+    });
+    test('calls routing api with @ before the coordinates when snapToClosestStation is true', (done) => {
+        fetch.mockResponses([JSON.stringify(RoutingControlStation1), { status: 200 }], [JSON.stringify(global.fetchRouteResponse), { status: 200 }]);
+        const control = new RoutingControl({
+            apiKey: 'foo',
+            snapToClosestStation: true,
+        });
+        control.attachToMap(map);
+        expect(map.getTarget().querySelector('#ol-toggle-routing')).toBeDefined();
+        control.viaPoints = [
+            [950476.4055933182, 6003322.253698345],
+            [950389.0813034325, 6003656.659274571],
+            'e3666f03cba06b2b',
+        ];
+        control.drawRoute(control.viaPoints).then(() => {
+            const { searchParams } = new URL(fetch.mock.calls[1][0]);
+            expect(searchParams.get('via')).toBe('@47.3739194713294,8.538274823394632|@47.37595378493421,8.537490375951839|!e3666f03cba06b2b');
+            done();
+        });
+    });
+    test('calls routing api with raw via points', (done) => {
+        fetch.mockResponses([JSON.stringify(RoutingControlStation1), { status: 200 }], [JSON.stringify(RoutingControlStation2), { status: 200 }], [JSON.stringify(global.fetchRouteResponse), { status: 200 }]);
+        const control = new RoutingControl({
+            apiKey: 'foo',
+            useRawViaPoints: true,
+        });
+        control.attachToMap(map);
+        expect(map.getTarget().querySelector('#ol-toggle-routing')).toBeDefined();
+        control.viaPoints = [
+            '46.2,7.1',
+            '@46.2,7.1',
+            '@46.2,7$1',
+            'station name$2',
+            'station name@46.2,7',
+            'stationname@46.2,7.7$3',
+            '!stationid',
+            [950389, 6003656],
+        ];
+        control.drawRoute(control.viaPoints).then(() => {
+            const params = new URL(fetch.mock.calls[2][0]).searchParams;
+            expect(params.get('via')).toBe('46.2,7.1|@46.2,7.1|@46.2,7$1|station name$2|station name@46.2,7|stationname@46.2,7.7$3|!stationid|47.375949774398805,8.537489645590679');
+            done();
+        });
+    });
+});

package/ol/controls/StopFinderControl.test.d.ts

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

package/ol/controls/StopFinderControl.test.d.ts.map

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

package/ol/controls/StopFinderControl.test.js

@@ -0,0 +1,49 @@
+import fetch from 'jest-fetch-mock';
+import View from 'ol/View';
+import Map from 'ol/Map';
+import StopFinderControl from './StopFinderControl';
+describe('StopFinderControl', () => {
+    let map;
+    beforeEach(() => {
+        const target = document.createElement('div');
+        document.body.appendChild(target);
+        map = new Map({
+            target,
+            view: new View({
+                center: [0, 0],
+                zoom: 0,
+            }),
+        });
+        global.fetch = fetch;
+    });
+    afterEach(() => {
+        if (map) {
+            map.setTarget(null);
+            map = null;
+        }
+        fetch.resetMocks();
+    });
+    test('should be activate by default', () => {
+        const control = new StopFinderControl();
+        expect(control.active).toBe(true);
+    });
+    test('launch a search and display results', (done) => {
+        fetch.mockResponseOnce(JSON.stringify(global.stopsSearchResponse));
+        const control = new StopFinderControl({
+            url: 'https://foo.ch',
+            apiKey: 'foo',
+            apiParams: {
+                limit: 10,
+                foo: 'bar',
+            },
+        });
+        control.attachToMap(map);
+        expect(control.element).toBeDefined();
+        control.search('foo').then(() => {
+            // Correct url
+            expect(fetch.mock.calls[0][0]).toEqual('https://foo.ch/?key=foo&limit=10&foo=bar&q=foo');
+            expect(control.element.querySelector('div').querySelector('div').innerHTML).toBe('Bern');
+            done();
+        });
+    });
+});

package/ol/index.d.ts

@@ -1,3 +1,4 @@
+export * from "../api";
 export * from "../common";
 export * from "./controls";
 export * from "./layers";

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

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

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

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

package/ol/layers/Layer.test.js

@@ -0,0 +1,196 @@
+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 VectorLayer from 'ol/layer/Vector';
+import VectorSource from 'ol/source/Vector';
+import Map from 'ol/Map';
+import Group from 'ol/layer/Group';
+import Layer from './Layer';
+let olLayer;
+let map;
+describe('Layer', () => {
+    beforeEach(() => {
+        map = new Map({});
+        olLayer = new VectorLayer({ source: new VectorSource() });
+    });
+    test('should initialize.', () => {
+        const layer = new Layer({ name: 'Layer', olLayer });
+        expect(layer).toBeInstanceOf(Layer);
+    });
+    test('should be visible by default.', () => {
+        const layer = new Layer({ name: 'Layer', olLayer });
+        expect(layer.visible).toBe(true);
+    });
+    test('should be invisible if defined.', () => {
+        const layer = new Layer({ name: 'Layer', visible: false, olLayer });
+        expect(layer.visible).toBe(false);
+    });
+    test('should be invisible if set.', () => {
+        const layer = new Layer({ name: 'Layer', olLayer });
+        layer.visible = false;
+        expect(layer.visible).toBe(false);
+    });
+    test('should visibility stay unchanged', () => {
+        const layer = new Layer({ name: 'Layer', visible: false, olLayer });
+        layer.visible = false;
+        expect(layer.visible).toBe(false);
+    });
+    test('should return its name.', () => {
+        const layer = new Layer({ name: 'Layer', visible: false, olLayer });
+        expect(layer.name).toEqual('Layer');
+    });
+    test('should call terminate on initialization.', () => {
+        const layer = new Layer({ name: 'Layer', olLayer });
+        const spy = jest.spyOn(layer, 'detachFromMap');
+        layer.attachToMap();
+        expect(spy).toHaveBeenCalledTimes(1);
+    });
+    test('should remove the layer when we call terminate.', () => {
+        const layer = new Layer({ name: 'Layer', olLayer });
+        const spy = jest.spyOn(layer, 'detachFromMap');
+        layer.attachToMap(map);
+        expect(spy).toHaveBeenCalledTimes(1);
+        layer.detachFromMap(map);
+        expect(spy).toHaveBeenCalledTimes(2);
+    });
+    test('should manage copyrights as string.', () => {
+        const spy = jest.spyOn(VectorSource.prototype, 'setAttributions');
+        const layer = new Layer({ name: 'Layer', copyrights: 'foo', olLayer });
+        layer.attachToMap(map);
+        expect(spy).toHaveBeenCalledWith(['foo']);
+    });
+    test('should manage copyrights as array.', () => {
+        const spy = jest.spyOn(VectorSource.prototype, 'setAttributions');
+        const layer = new Layer({ name: 'Layer', copyrights: ['bar'], olLayer });
+        layer.attachToMap(map);
+        expect(spy).toHaveBeenCalledWith(['bar']);
+    });
+    test('should set attributions for Group.', () => {
+        const spy = jest.spyOn(VectorSource.prototype, 'setAttributions');
+        const layer = new Layer({
+            name: 'Layer',
+            copyrights: ['bar'],
+            olLayer: new Group({ layers: [olLayer] }),
+        });
+        layer.attachToMap(map);
+        expect(spy).toHaveBeenCalledWith(['bar']);
+    });
+    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', olLayer });
+        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.dispatchEvent({ type: 'pointermove', map, coordinate: [0, 0] });
+        yield map.dispatchEvent({ type: 'singleclick', map, coordinate: [0, 0] });
+        expect(spy).toHaveBeenCalledTimes(1);
+        expect(spy2).toHaveBeenCalledTimes(1);
+        spy.mockReset();
+        spy2.mockReset();
+        layer.visible = false;
+        yield map.dispatchEvent({ type: 'pointermove', map, coordinate: [0, 0] });
+        yield map.dispatchEvent({ type: 'singleclick', map, coordinate: [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', olLayer, 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.dispatchEvent({ type: 'pointermove', map, coordinate: [0, 0] });
+        yield map.dispatchEvent({ type: 'singleclick', map, coordinate: [0, 0] });
+        expect(spy).toHaveBeenCalledTimes(0);
+        expect(spy2).toHaveBeenCalledTimes(0);
+        spy.mockReset();
+        spy2.mockReset();
+        layer.visible = true;
+        yield map.dispatchEvent({ type: 'pointermove', map, coordinate: [0, 0] });
+        yield map.dispatchEvent({ type: 'singleclick', map, coordinate: [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', olLayer, 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.dispatchEvent({
+            type: 'pointermove',
+            map,
+            coordinate: [0, 0],
+        });
+        yield map.dispatchEvent({
+            type: 'singleclick',
+            map,
+            coordinate: [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(map);
+        yield map.dispatchEvent({
+            type: 'pointermove',
+            map,
+            coordinate: [0, 0],
+        });
+        yield map.dispatchEvent({
+            type: 'singleclick',
+            map,
+            coordinate: [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'],
+            olLayer: new Group({ layers: [olLayer] }),
+        });
+        const clone = layer.clone({ name: 'clone' });
+        expect(clone).not.toBe(layer);
+        expect(clone.name).toBe('clone');
+        expect(clone).toBeInstanceOf(Layer);
+    });
+});

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

@@ -1 +1 @@
-{"version":3,"file":"MapboxLayer.d.ts","sourceRoot":"","sources":["../../../src/ol/layers/MapboxLayer.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;GAaG;AACH;IA2BE;;;OAGG;IACH,kBA0CC;IA/BC,cAAc;IACd;;;;;;;kBAOC;IAOC,cAAc;IACd,8BAA0D;IAiB9D,6CAEC;IAGD,yBAEC;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACL,WAAW,CAItB;CACF"}
+{"version":3,"file":"MapboxLayer.d.ts","sourceRoot":"","sources":["../../../src/ol/layers/MapboxLayer.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;GAaG;AACH;IA2BE;;;OAGG;IACH,kBA+CC;IApCC,cAAc;IACd;;;;;;;kBAOC;IAYC,cAAc;IACd,8BAA0D;IAiB9D,6CAEC;IAGD,yBAEC;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACL,WAAW,CAItB;CACF"}

package/ol/layers/MapboxLayer.js

@@ -64,6 +64,10 @@ export default class MapboxLayer extends mixin(Layer) {
             size: [0, 0],
         };
         super.loadMbMap();
+        if (!this.mbMap) {
+            // mbMap could ne bull if the map is not in the dom yet.
+            return;
+        }
         this.mbMap.once('load', () => {
             var _a;
             this.mbMap.resize();

package/ol/layers/MapboxLayer.test.d.ts

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

package/ol/layers/MapboxLayer.test.d.ts.map

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