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

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

@@ -21,14 +21,14 @@ export default class MapboxLayer extends Layer {
     /** @ignore */
     renderState: {
         center: any[];
-        zoom: any;
-        rotation: any;
-        visible: any;
-        opacity: any;
+        zoom: null;
+        rotation: null;
+        visible: null;
+        opacity: null;
         size: number[];
-    };
+    } | undefined;
     /** @ignore */
-    copyrights: any[];
+    copyrights: any[] | undefined;
     getOlLayerRender(): (frameState: any) => any;
     getMapboxMapClass(): any;
     /**
@@ -36,7 +36,7 @@ export default class MapboxLayer extends Layer {
      * @param {Object} newOptions Options to override
      * @return {MapboxLayer} A MapboxLayer
      */
-    clone(newOptions: any): MapboxLayer;
+    clone(newOptions: Object): MapboxLayer;
 }
 import Layer from "./Layer";
 //# sourceMappingURL=MapboxLayer.d.ts.map

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;;;;;;;MAOC;IAOC,cAAc;IACd,kBAA0D;IAiB9D,6CAEC;IAGD,yBAEC;IAED;;;;OAIG;IACH,wBAFY,WAAW,CAItB;CACF"}
+{"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"}

package/ol/layers/MapboxLayer.js

@@ -1,36 +1,8 @@
-"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 });
 /* eslint-disable no-underscore-dangle */
-var mapbox_gl_1 = require("mapbox-gl");
-var Layer_1 = require("./Layer");
-var MapboxLayerMixin_1 = require("../../common/mixins/MapboxLayerMixin");
-var utils_1 = require("../../common/utils");
+import { Map } from 'mapbox-gl';
+import Layer from './Layer';
+import mixin from '../../common/mixins/MapboxLayerMixin';
+import { getMapboxMapCopyrights, getMapboxRender } from '../../common/utils';
 /**
  * A class representing Mapboxlayer to display on BasicMap
  *
@@ -45,25 +17,20 @@ var utils_1 = require("../../common/utils");
  * @classproperty {ol/Map~Map} map - The map where the layer is displayed.
  * @extends {Layer}
  */
-var MapboxLayer = /** @class */ (function (_super) {
-    __extends(MapboxLayer, _super);
-    function MapboxLayer() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
+export default class MapboxLayer extends mixin(Layer) {
     /**
      * Initialize the layer and listen to feature clicks.
      * @param {ol/Map~Map} map
      */
-    MapboxLayer.prototype.attachToMap = function (map) {
-        var _this = this;
-        _super.prototype.attachToMap.call(this, map);
+    attachToMap(map) {
+        super.attachToMap(map);
         if (!this.map || this.mbMap) {
             return;
         }
-        this.olListenersKeys.push(this.map.on('change:size', function () {
+        this.olListenersKeys.push(this.map.on('change:size', () => {
             try {
-                if (_this.mbMap) {
-                    _this.mbMap.resize();
+                if (this.mbMap) {
+                    this.mbMap.resize();
                 }
             }
             catch (err) {
@@ -72,16 +39,15 @@ var MapboxLayer = /** @class */ (function (_super) {
                 console.warn(err);
             }
         }));
-    };
+    }
     /**
      * Create the mapbox map.
      * @private
      */
-    MapboxLayer.prototype.loadMbMap = function () {
-        var _this = this;
+    loadMbMap() {
         // If the map hasn't been resized, the center could be [NaN,NaN].
         // We set default good value for the mapbox map, to avoid the app crashes.
-        var _a = this.map.getView().getCenter(), x = _a[0], y = _a[1];
+        let [x, y] = this.map.getView().getCenter();
         if (!x || !y) {
             x = 0;
             y = 0;
@@ -97,15 +63,15 @@ var MapboxLayer = /** @class */ (function (_super) {
             opacity: null,
             size: [0, 0],
         };
-        _super.prototype.loadMbMap.call(this);
-        this.mbMap.once('load', function () {
+        super.loadMbMap();
+        this.mbMap.once('load', () => {
             var _a;
-            _this.mbMap.resize();
+            this.mbMap.resize();
             /** @ignore */
-            _this.copyrights = (0, utils_1.getMapboxMapCopyrights)(_this.mbMap) || [];
-            (_a = _this.olLayer.getSource()) === null || _a === void 0 ? void 0 : _a.setAttributions(_this.copyrights);
+            this.copyrights = getMapboxMapCopyrights(this.mbMap) || [];
+            (_a = this.olLayer.getSource()) === null || _a === void 0 ? void 0 : _a.setAttributions(this.copyrights);
         });
-        var mapboxCanvas = this.mbMap.getCanvas();
+        const mapboxCanvas = this.mbMap.getCanvas();
         if (mapboxCanvas) {
             if (this.options.tabIndex) {
                 mapboxCanvas.setAttribute('tabindex', this.options.tabIndex);
@@ -116,22 +82,20 @@ var MapboxLayer = /** @class */ (function (_super) {
                 mapboxCanvas.removeAttribute('tabindex');
             }
         }
-    };
-    MapboxLayer.prototype.getOlLayerRender = function () {
-        return (0, utils_1.getMapboxRender)(this);
-    };
+    }
+    getOlLayerRender() {
+        return getMapboxRender(this);
+    }
     // eslint-disable-next-line class-methods-use-this
-    MapboxLayer.prototype.getMapboxMapClass = function () {
-        return mapbox_gl_1.Map;
-    };
+    getMapboxMapClass() {
+        return Map;
+    }
     /**
      * Create a copy of the MapboxLayer.
      * @param {Object} newOptions Options to override
      * @return {MapboxLayer} A MapboxLayer
      */
-    MapboxLayer.prototype.clone = function (newOptions) {
-        return new MapboxLayer(__assign(__assign({}, this.options), newOptions));
-    };
-    return MapboxLayer;
-}((0, MapboxLayerMixin_1.default)(Layer_1.default)));
-exports.default = MapboxLayer;
+    clone(newOptions) {
+        return new MapboxLayer(Object.assign(Object.assign({}, this.options), newOptions));
+    }
+}

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":""}

package/ol/layers/MapboxLayer.test.js

@@ -0,0 +1,164 @@
+import OlMap from 'ol/Map';
+import View from 'ol/View';
+import gllib from 'mapbox-gl';
+import MapboxLayer from './MapboxLayer';
+let layer;
+let map;
+let consoleOutput;
+const styleUrl = 'http://foo.com/styles';
+describe('MapboxLayer', () => {
+    describe('without apiKey', () => {
+        beforeEach(() => {
+            // Mock console statement
+            consoleOutput = [];
+            // eslint-disable-next-line no-console
+            console.error = (message) => consoleOutput.push(message);
+            layer = new MapboxLayer({
+                name: 'Layer',
+                url: styleUrl,
+            });
+            map = new OlMap({
+                target: document.createElement('div'),
+                view: new View({ center: [0, 0] }),
+            });
+        });
+        test('should be instanced.', () => {
+            expect(layer).toBeInstanceOf(MapboxLayer);
+            expect(layer.styleUrl).toBe(styleUrl);
+        });
+        test('should not initalized mapbox map.', () => {
+            layer.attachToMap();
+            expect(layer.mbMap).toBe();
+        });
+        test('should initalized mapbox map and warn the user if there is no api key defined.', () => {
+            layer.attachToMap(map);
+            expect(layer.mbMap).toBeInstanceOf(gllib.Map);
+            expect(consoleOutput[0]).toBe('No apiKey defined for mapbox layer with style url to http://foo.com/styles');
+        });
+        test('should called terminate on initalization.', () => {
+            const spy = jest.spyOn(layer, 'detachFromMap');
+            layer.attachToMap();
+            expect(spy).toHaveBeenCalledTimes(1);
+        });
+        test('should clone', () => {
+            const clone = layer.clone({ name: 'clone' });
+            expect(clone).not.toBe(layer);
+            expect(clone.name).toBe('clone');
+            expect(clone).toBeInstanceOf(MapboxLayer);
+        });
+    });
+    describe('with apiKey', () => {
+        beforeEach(() => {
+            layer = new MapboxLayer({
+                name: 'Layer',
+                url: styleUrl,
+                apiKey: 'apiKey',
+            });
+            map = new OlMap({
+                target: document.createElement('div'),
+                view: new View({ center: [0, 0] }),
+            });
+        });
+        test('should be instanced with apiKey.', () => {
+            expect(layer).toBeInstanceOf(MapboxLayer);
+            expect(layer.styleUrl).toBe(styleUrl);
+        });
+        test('should not initalized mapbox map.', () => {
+            layer.attachToMap();
+            expect(layer.mbMap).toBe();
+        });
+        test("should initalized mapbox map, with 'apiKey' prop", () => {
+            const layer1 = new MapboxLayer({
+                name: 'Layer',
+                url: styleUrl,
+                apiKey: 'apiKeyVal',
+            });
+            layer1.attachToMap(map);
+            expect(layer1.mbMap.options.style).toBe('http://foo.com/styles?key=apiKeyVal');
+        });
+        test("should initalized mapbox map, with 'apiKeyName' prop", () => {
+            const layer1 = new MapboxLayer({
+                name: 'Layer',
+                url: styleUrl,
+                apiKey: 'test',
+                apiKeyName: 'apiKey',
+            });
+            layer1.attachToMap(map);
+            expect(layer1.mbMap.options.style).toBe('http://foo.com/styles?apiKey=test');
+        });
+    });
+    describe('#getFeatureInfoAtCoordinate()', () => {
+        let layer1;
+        beforeEach(() => {
+            layer1 = new MapboxLayer({
+                name: 'Layer',
+                url: styleUrl,
+                apiKey: 'test',
+                apiKeyName: 'apiKey',
+            });
+            layer1.attachToMap(map);
+            layer1.mbMap.isStyleLoaded = jest.fn(() => true);
+            layer1.mbMap.getSource = jest.fn(() => true);
+        });
+        afterEach(() => {
+            layer1.mbMap.getSource.mockRestore();
+            layer1.mbMap.isStyleLoaded.mockRestore();
+        });
+        test('should set the mapboxFeature as a property', (done) => {
+            const mapboxFeature = {
+                id: '2',
+                type: 'Feature',
+                properties: {
+                    foo: 'bar',
+                },
+                source: 'barr',
+                sourceLayer: 'fooo',
+            };
+            layer1.mbMap.project = jest.fn((coord) => ({ x: coord[0], y: coord[1] }));
+            layer1.mbMap.queryRenderedFeatures = jest.fn(() => [mapboxFeature]);
+            layer1.getFeatureInfoAtCoordinate([0, 0], {}).then((featureInfo) => {
+                expect(featureInfo.features[0].get('mapboxFeature')).toBe(mapboxFeature);
+                done();
+            });
+            layer1.mbMap.project.mockRestore();
+            layer1.mbMap.queryRenderedFeatures.mockRestore();
+        });
+        describe('should use hitTolerance property', () => {
+            beforeEach(() => {
+                layer1.mbMap.project = jest.fn((coord) => ({
+                    x: coord[0],
+                    y: coord[1],
+                }));
+            });
+            afterEach(() => {
+                layer1.mbMap.project.mockRestore();
+                layer1.mbMap.queryRenderedFeatures.mockRestore();
+            });
+            test('when hitTolerance is not set', (done) => {
+                layer1.mbMap.queryRenderedFeatures = jest.fn((pixelBounds) => {
+                    // Use default hoitTolerance
+                    expect(pixelBounds).toEqual([
+                        { x: -5, y: -5 },
+                        { x: 5, y: 5 },
+                    ]);
+                    done();
+                    return [];
+                });
+                layer1.getFeatureInfoAtCoordinate([0, 0], {});
+            });
+            test('when hitTolerance is set to 10', (done) => {
+                layer1.hitTolerance = 10;
+                layer1.mbMap.queryRenderedFeatures = jest.fn((pixelBounds) => {
+                    // Use default hoitTolerance
+                    expect(pixelBounds).toEqual([
+                        { x: -10, y: -10 },
+                        { x: 10, y: 10 },
+                    ]);
+                    done();
+                    return [];
+                });
+                layer1.getFeatureInfoAtCoordinate([0, 0], {});
+            });
+        });
+    });
+});

package/ol/layers/MapboxStyleLayer.d.ts

@@ -26,8 +26,8 @@ declare class MapboxStyleLayer extends Layer {
      * @param {Function} [options.styleLayersFilter] Filter function to decide which style layer to display.
      */
     constructor(options?: {
-        mapboxLayer?: MapboxLayer;
-        styleLayersFilter?: Function;
+        mapboxLayer?: any;
+        styleLayersFilter?: Function | undefined;
     });
     /**
      * MapboxLayer provided for the style Layer.
@@ -140,7 +140,7 @@ declare class MapboxStyleLayer extends Layer {
      * @param {Object} newOptions Options to override.
      * @return {MapboxStyleLayer} A MapboxStyleLayer.
      */
-    clone(newOptions: any): MapboxStyleLayer;
+    clone(newOptions: Object): MapboxStyleLayer;
 }
 import Layer from "./Layer";
 //# sourceMappingURL=MapboxStyleLayer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"MapboxStyleLayer.d.ts","sourceRoot":"","sources":["../../../src/ol/layers/MapboxStyleLayer.js"],"names":[],"mappings":";AAGA;;;;;;;;;;;;;;;;;GAiBG;AACH;IACE;;;;;;OAMG;IACH;QAHiC,WAAW;QACd,iBAAiB;OA4F9C;IAvFC;;;;OAIG;IACH,oBAAsC;IAEtC;;OAEG;IACH,kBAAqB;IAErB;;;;OAIG;IACH,0BAAkD;IAElD;;;;;OAKG;IACH,iBAAgC;IAEhC;;;;OAIG;IACH,0BAAoE;IAEpE;;;;OAIG;IACH,kCAAkE;IAElE;;;;OAIG;IACH,4BAA6B;IAE7B;;;;OAIG;IACH,yBAA0B;IAE1B;;;;OAIG;IACH,oBACyE;IAiG3E,cAAc;IACd,uBAcC;IAiBD;;;OAGG;IACH,eAaC;IAtIG,eAAe;IACf,0BAMC;IAgEL;;;;OAIG;IACH,gDAOC;IAmBD,cAAc;IACd,0BAYC;IAqBD;;;;OAIG;IACH,6CAFY,QAAQ,WAAW,CAAC,CAiC/B;IAED;;;OAGG;IACH,yCAYC;IAED;;;;;OAKG;IACH,sBA8BC;IAED;;;;OAIG;IACH,eAIC;IAED;;;;OAIG;IACH,kBAeC;IAED;;;;OAIG;IAEH,8BA8BC;IAED;;;;OAIG;IACH,wBAFY,gBAAgB,CAI3B;CACF"}
+{"version":3,"file":"MapboxStyleLayer.d.ts","sourceRoot":"","sources":["../../../src/ol/layers/MapboxStyleLayer.js"],"names":[],"mappings":";AAGA;;;;;;;;;;;;;;;;;GAiBG;AACH;IACE;;;;;;OAMG;IACH;QAHiC,WAAW;QACd,iBAAiB;OA4F9C;IAvFC;;;;OAIG;IACH,oBAAsC;IAEtC;;OAEG;IACH,kBAAqB;IAErB;;;;OAIG;IACH,0BAAkD;IAElD;;;;;OAKG;IACH,iBAAgC;IAEhC;;;;OAIG;IACH,0BAAoE;IAEpE;;;;OAIG;IACH,kCAAkE;IAElE;;;;OAIG;IACH,4BAA6B;IAE7B;;;;OAIG;IACH,yBAA0B;IAE1B;;;;OAIG;IACH,oBACyE;IAiG3E,cAAc;IACd,uBAcC;IAiBD;;;OAGG;IACH,eAaC;IAtIG,eAAe;IACf,0BAMC;IAgEL;;;;OAIG;IACH,gDAOC;IAmBD,cAAc;IACd,0BAYC;IAqBD;;;;OAIG;IACH,6CAFY,QAAQ,WAAW,CAAC,CAiC/B;IAED;;;OAGG;IACH,yCAYC;IAED;;;;;OAKG;IACH,sBA8BC;IAED;;;;OAIG;IACH,eAIC;IAED;;;;OAIG;IACH,kBAeC;IAED;;;;OAIG;IAEH,8BA8BC;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACL,gBAAgB,CAI3B;CACF"}