@antv/l7-layers 2.21.1 → 2.21.2

package/es/tile/tile/Tile.js

@@ -1,247 +1,166 @@
 import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
-import _createClass from "@babel/runtime/helpers/esm/createClass";
-import _assertThisInitialized from "@babel/runtime/helpers/esm/assertThisInitialized";
-import _inherits from "@babel/runtime/helpers/esm/inherits";
-import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
-import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
 import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import _regeneratorRuntime from "@babel/runtime/regenerator";
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 import { createLayerContainer } from '@antv/l7-core';
 import { EventEmitter } from 'eventemitter3';
 import PolygonLayer from "../../polygon";
 import { isNeedMask } from "./util";
-var Tile = /*#__PURE__*/function (_EventEmitter) {
-  _inherits(Tile, _EventEmitter);
-  var _super = _createSuper(Tile);
-  function Tile(sourceTile, parent) {
-    var _this;
-    _classCallCheck(this, Tile);
-    _this = _super.call(this);
-    _defineProperty(_assertThisInitialized(_this), "visible", true);
-    _defineProperty(_assertThisInitialized(_this), "layers", []);
-    _defineProperty(_assertThisInitialized(_this), "isLoaded", false);
-    _defineProperty(_assertThisInitialized(_this), "tileMaskLayers", []);
-    _this.parent = parent;
-    _this.sourceTile = sourceTile;
-    _this.x = sourceTile.x;
-    _this.y = sourceTile.y;
-    _this.z = sourceTile.z;
-    _this.key = "".concat(_this.x, "_").concat(_this.y, "_").concat(_this.z);
-    return _this;
+export default class Tile extends EventEmitter {
+  constructor(sourceTile, parent) {
+    super();
+    _defineProperty(this, "x", void 0);
+    _defineProperty(this, "y", void 0);
+    _defineProperty(this, "z", void 0);
+    _defineProperty(this, "key", void 0);
+    _defineProperty(this, "parent", void 0);
+    _defineProperty(this, "sourceTile", void 0);
+    _defineProperty(this, "visible", true);
+    _defineProperty(this, "layers", []);
+    _defineProperty(this, "isLoaded", false);
+    _defineProperty(this, "tileMaskLayers", []);
+    _defineProperty(this, "tileMask", void 0);
+    this.parent = parent;
+    this.sourceTile = sourceTile;
+    this.x = sourceTile.x;
+    this.y = sourceTile.y;
+    this.z = sourceTile.z;
+    this.key = `${this.x}_${this.y}_${this.z}`;
+  }
+  getLayers() {
+    return this.layers;
   }
-  _createClass(Tile, [{
-    key: "getLayers",
-    value: function getLayers() {
-      return this.layers;
-    }
 
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  }, {
-    key: "styleUpdate",
-    value: function styleUpdate() {
-      return;
-    }
-  }, {
-    key: "lnglatInBounds",
-    value: function lnglatInBounds(lnglat) {
-      var _this$sourceTile$boun = _slicedToArray(this.sourceTile.bounds, 4),
-        minLng = _this$sourceTile$boun[0],
-        minLat = _this$sourceTile$boun[1],
-        maxLng = _this$sourceTile$boun[2],
-        maxLat = _this$sourceTile$boun[3];
-      var lng = lnglat.lng,
-        lat = lnglat.lat;
-      return lng >= minLng && lng <= maxLng && lat >= minLat && lat <= maxLat;
-    }
-  }, {
-    key: "getLayerOptions",
-    value: function getLayerOptions() {
-      var _options$maskLayers;
-      var options = this.parent.getLayerConfig();
-      return _objectSpread(_objectSpread({}, options), {}, {
-        textAllowOverlap: true,
-        // 文本允许重叠
-        autoFit: false,
-        maskLayers: this.getMaskLayer(),
-        tileMask: isNeedMask(this.parent.type),
-        mask: options.mask || ((_options$maskLayers = options.maskLayers) === null || _options$maskLayers === void 0 ? void 0 : _options$maskLayers.length) !== 0 && options.enableMask
-      });
-    }
-    // 获取Mask 图层
-  }, {
-    key: "getMaskLayer",
-    value: function getMaskLayer() {
-      var _this2 = this;
-      var _this$parent$getLayer = this.parent.getLayerConfig(),
-        maskLayers = _this$parent$getLayer.maskLayers;
-      var layers = [];
-      maskLayers === null || maskLayers === void 0 || maskLayers.forEach(function (layer) {
-        if (!layer.tileLayer) {
-          // 非瓦片图层返回图层本身，瓦片图层返回对应的行列号图层
-          layers.push(layer);
-          return layer;
-        }
-        var tileLayer = layer.tileLayer;
-        var tile = tileLayer.getTile(_this2.sourceTile.key);
-        var l = tile === null || tile === void 0 ? void 0 : tile.getLayers()[0];
-        if (l) {
-          layers.push(l);
-        }
-      });
-      return layers;
-    }
-  }, {
-    key: "addTileMask",
-    value: function () {
-      var _addTileMask = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
-        var mask, container, mainLayer;
-        return _regeneratorRuntime.wrap(function _callee$(_context) {
-          while (1) switch (_context.prev = _context.next) {
-            case 0:
-              mask = new PolygonLayer({
-                name: 'mask',
-                visible: true,
-                enablePicking: false
-              }).source({
-                type: 'FeatureCollection',
-                features: [this.sourceTile.bboxPolygon]
-              }, {
-                parser: {
-                  type: 'geojson',
-                  featureId: 'id'
-                }
-              }).shape('fill').color('#0f0').style({
-                opacity: 0.5
-              });
-              container = createLayerContainer(this.parent.container);
-              mask.setContainer(container);
-              _context.next = 5;
-              return mask.init();
-            case 5:
-              this.tileMask = mask;
-              mainLayer = this.getMainLayer();
-              if (mainLayer !== undefined) {
-                mainLayer.tileMask = mask;
-              }
-              return _context.abrupt("return", mask);
-            case 9:
-            case "end":
-              return _context.stop();
-          }
-        }, _callee, this);
-      }));
-      function addTileMask() {
-        return _addTileMask.apply(this, arguments);
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  styleUpdate(...arg) {
+    return;
+  }
+  lnglatInBounds(lnglat) {
+    const [minLng, minLat, maxLng, maxLat] = this.sourceTile.bounds;
+    const {
+      lng,
+      lat
+    } = lnglat;
+    return lng >= minLng && lng <= maxLng && lat >= minLat && lat <= maxLat;
+  }
+  getLayerOptions() {
+    var _options$maskLayers;
+    const options = this.parent.getLayerConfig();
+    return _objectSpread(_objectSpread({}, options), {}, {
+      textAllowOverlap: true,
+      // 文本允许重叠
+      autoFit: false,
+      maskLayers: this.getMaskLayer(),
+      tileMask: isNeedMask(this.parent.type),
+      mask: options.mask || ((_options$maskLayers = options.maskLayers) === null || _options$maskLayers === void 0 ? void 0 : _options$maskLayers.length) !== 0 && options.enableMask
+    });
+  }
+  // 获取Mask 图层
+  getMaskLayer() {
+    const {
+      maskLayers
+    } = this.parent.getLayerConfig();
+    const layers = [];
+    maskLayers === null || maskLayers === void 0 || maskLayers.forEach(layer => {
+      if (!layer.tileLayer) {
+        // 非瓦片图层返回图层本身，瓦片图层返回对应的行列号图层
+        layers.push(layer);
+        return layer;
       }
-      return addTileMask;
-    }() // 全局 Mask
-  }, {
-    key: "addMask",
-    value: function () {
-      var _addMask = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(layer, mask) {
-        var container;
-        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
-          while (1) switch (_context2.prev = _context2.next) {
-            case 0:
-              container = createLayerContainer(this.parent.container);
-              mask.setContainer(container);
-              _context2.next = 4;
-              return mask.init();
-            case 4:
-              layer.addMask(mask);
-              this.tileMaskLayers.push(mask);
-            case 6:
-            case "end":
-              return _context2.stop();
-          }
-        }, _callee2, this);
-      }));
-      function addMask(_x, _x2) {
-        return _addMask.apply(this, arguments);
+      const tileLayer = layer.tileLayer;
+      const tile = tileLayer.getTile(this.sourceTile.key);
+      const l = tile === null || tile === void 0 ? void 0 : tile.getLayers()[0];
+      if (l) {
+        layers.push(l);
       }
-      return addMask;
-    }()
-  }, {
-    key: "addLayer",
-    value: function () {
-      var _addLayer = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(layer) {
-        var container;
-        return _regeneratorRuntime.wrap(function _callee3$(_context3) {
-          while (1) switch (_context3.prev = _context3.next) {
-            case 0:
-              // set flag
-              layer.isTileLayer = true;
-              container = createLayerContainer(this.parent.container);
-              layer.setContainer(container);
-              this.layers.push(layer);
-              _context3.next = 6;
-              return layer.init();
-            case 6:
-            case "end":
-              return _context3.stop();
-          }
-        }, _callee3, this);
-      }));
-      function addLayer(_x3) {
-        return _addLayer.apply(this, arguments);
+    });
+    return layers;
+  }
+  addTileMask() {
+    var _this = this;
+    return _asyncToGenerator(function* () {
+      const mask = new PolygonLayer({
+        name: 'mask',
+        visible: true,
+        enablePicking: false
+      }).source({
+        type: 'FeatureCollection',
+        features: [_this.sourceTile.bboxPolygon]
+      }, {
+        parser: {
+          type: 'geojson',
+          featureId: 'id'
+        }
+      }).shape('fill').color('#0f0').style({
+        opacity: 0.5
+      });
+      const container = createLayerContainer(_this.parent.container);
+      mask.setContainer(container);
+      yield mask.init();
+      _this.tileMask = mask;
+      const mainLayer = _this.getMainLayer();
+      if (mainLayer !== undefined) {
+        mainLayer.tileMask = mask;
       }
-      return addLayer;
-    }()
-  }, {
-    key: "updateVisible",
-    value: function updateVisible(value) {
-      this.visible = value;
-      this.updateOptions('visible', value);
-    }
-  }, {
-    key: "updateOptions",
-    value: function updateOptions(key, value) {
-      this.layers.forEach(function (l) {
-        l.updateLayerConfig(_defineProperty({}, key, value));
+      return mask;
+    })();
+  }
+  // 全局 Mask
+  addMask(layer, mask) {
+    var _this2 = this;
+    return _asyncToGenerator(function* () {
+      const container = createLayerContainer(_this2.parent.container);
+      mask.setContainer(container);
+      yield mask.init();
+      layer.addMask(mask);
+      _this2.tileMaskLayers.push(mask);
+    })();
+  }
+  addLayer(layer) {
+    var _this3 = this;
+    return _asyncToGenerator(function* () {
+      // set flag
+      layer.isTileLayer = true;
+      const container = createLayerContainer(_this3.parent.container);
+      layer.setContainer(container);
+      _this3.layers.push(layer);
+      yield layer.init();
+    })();
+  }
+  updateVisible(value) {
+    this.visible = value;
+    this.updateOptions('visible', value);
+  }
+  updateOptions(key, value) {
+    this.layers.forEach(l => {
+      l.updateLayerConfig({
+        [key]: value
       });
-    }
+    });
+  }
 
-    /**
-     * 一个 Tile 可能有多个 layer，但是在发生拾取、点击事件的时候只有一个生效
-     */
-  }, {
-    key: "getMainLayer",
-    value: function getMainLayer() {
-      return this.layers[0];
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  }, {
-    key: "getFeatures",
-    value: function getFeatures(sourceLayer) {
-      return [];
-    }
+  /**
+   * 一个 Tile 可能有多个 layer，但是在发生拾取、点击事件的时候只有一个生效
+   */
+  getMainLayer() {
+    return this.layers[0];
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  getFeatures(sourceLayer) {
+    return [];
+  }
 
-    /**
-     * 在一个 Tile 中可能存在一个相同 ID 的 feature
-     * @param id
-     * @returns
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  }, {
-    key: "getFeatureById",
-    value: function getFeatureById(id) {
-      return [];
-    }
-  }, {
-    key: "destroy",
-    value: function destroy() {
-      var _this$tileMask;
-      (_this$tileMask = this.tileMask) === null || _this$tileMask === void 0 || _this$tileMask.destroy();
-      this.layers.forEach(function (layer) {
-        return layer.destroy();
-      });
-    }
-  }]);
-  return Tile;
-}(EventEmitter);
-export { Tile as default };
+  /**
+   * 在一个 Tile 中可能存在一个相同 ID 的 feature
+   * @param id
+   * @returns
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  getFeatureById(id) {
+    return [];
+  }
+  destroy() {
+    var _this$tileMask;
+    (_this$tileMask = this.tileMask) === null || _this$tileMask === void 0 || _this$tileMask.destroy();
+    this.layers.forEach(layer => layer.destroy());
+  }
+}

package/es/tile/tile/VectorTile.js

@@ -1,134 +1,87 @@
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
 import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
-import _createClass from "@babel/runtime/helpers/esm/createClass";
-import _inherits from "@babel/runtime/helpers/esm/inherits";
-import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
-import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
-import _regeneratorRuntime from "@babel/runtime/regenerator";
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 import Tile from "./Tile";
 import { getTileLayer } from "./util";
-var VectorTile = /*#__PURE__*/function (_Tile) {
-  _inherits(VectorTile, _Tile);
-  var _super = _createSuper(VectorTile);
-  function VectorTile() {
-    _classCallCheck(this, VectorTile);
-    return _super.apply(this, arguments);
-  }
-  _createClass(VectorTile, [{
-    key: "initTileLayer",
-    value: function () {
-      var _initTileLayer = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
-        var attributes, layerOptions, vectorLayer, sourceOptions, layer;
-        return _regeneratorRuntime.wrap(function _callee$(_context) {
-          while (1) switch (_context.prev = _context.next) {
-            case 0:
-              attributes = this.parent.getLayerAttributeConfig();
-              layerOptions = this.getLayerOptions();
-              vectorLayer = getTileLayer(this.parent.type);
-              sourceOptions = this.getSourceOption();
-              if (sourceOptions) {
-                _context.next = 8;
-                break;
-              }
-              this.isLoaded = true;
-              this.emit('loaded');
-              return _context.abrupt("return");
-            case 8:
-              layer = new vectorLayer(_objectSpread({}, layerOptions)).source(sourceOptions.data, sourceOptions.options); // 初始化数据映射
-              Object.keys(attributes).forEach(function (type) {
-                var _attributes$attr, _attributes$attr2;
-                var attr = type;
-                // @ts-ignore
-                layer[attr]((_attributes$attr = attributes[attr]) === null || _attributes$attr === void 0 ? void 0 : _attributes$attr.field, (_attributes$attr2 = attributes[attr]) === null || _attributes$attr2 === void 0 ? void 0 : _attributes$attr2.values);
-              });
-              _context.next = 12;
-              return this.addLayer(layer);
-            case 12:
-              if (!layerOptions.tileMask) {
-                _context.next = 15;
-                break;
-              }
-              _context.next = 15;
-              return this.addTileMask();
-            case 15:
-              this.setLayerMinMaxZoom(layer);
-              this.isLoaded = true;
-              this.emit('loaded');
-            case 18:
-            case "end":
-              return _context.stop();
-          }
-        }, _callee, this);
-      }));
-      function initTileLayer() {
-        return _initTileLayer.apply(this, arguments);
+export default class VectorTile extends Tile {
+  initTileLayer() {
+    var _this = this;
+    return _asyncToGenerator(function* () {
+      const attributes = _this.parent.getLayerAttributeConfig();
+      const layerOptions = _this.getLayerOptions();
+      const vectorLayer = getTileLayer(_this.parent.type);
+      const sourceOptions = _this.getSourceOption();
+      if (!sourceOptions) {
+        _this.isLoaded = true;
+        _this.emit('loaded');
+        return;
+      }
+      const layer = new vectorLayer(_objectSpread({}, layerOptions)).source(sourceOptions.data, sourceOptions.options);
+
+      // 初始化数据映射
+      Object.keys(attributes).forEach(type => {
+        var _attributes$attr, _attributes$attr2;
+        const attr = type;
+        // @ts-ignore
+        layer[attr]((_attributes$attr = attributes[attr]) === null || _attributes$attr === void 0 ? void 0 : _attributes$attr.field, (_attributes$attr2 = attributes[attr]) === null || _attributes$attr2 === void 0 ? void 0 : _attributes$attr2.values);
+      });
+      yield _this.addLayer(layer);
+      if (layerOptions.tileMask) {
+        // 瓦片数据裁剪
+        yield _this.addTileMask();
       }
-      return initTileLayer;
-    }()
-  }, {
-    key: "getSourceOption",
-    value: function getSourceOption() {
-      var rawSource = this.parent.getSource();
-      var _this$parent$getLayer = this.parent.getLayerConfig(),
-        _this$parent$getLayer2 = _this$parent$getLayer.sourceLayer,
-        sourceLayer = _this$parent$getLayer2 === void 0 ? 'defaultLayer' : _this$parent$getLayer2,
-        _this$parent$getLayer3 = _this$parent$getLayer.featureId,
-        featureId = _this$parent$getLayer3 === void 0 ? 'id' : _this$parent$getLayer3;
-      var features = this.getFeatures(sourceLayer);
-      return {
-        data: {
-          type: 'FeatureCollection',
-          features: features
+      _this.setLayerMinMaxZoom(layer);
+      _this.isLoaded = true;
+      _this.emit('loaded');
+    })();
+  }
+  getSourceOption() {
+    const rawSource = this.parent.getSource();
+    const {
+      sourceLayer = 'defaultLayer',
+      featureId = 'id'
+    } = this.parent.getLayerConfig();
+    const features = this.getFeatures(sourceLayer);
+    return {
+      data: {
+        type: 'FeatureCollection',
+        features
+      },
+      options: {
+        parser: {
+          type: 'geojson',
+          featureId
         },
-        options: {
-          parser: {
-            type: 'geojson',
-            featureId: featureId
-          },
-          transforms: rawSource.transforms
-        }
-      };
-    }
-  }, {
-    key: "setLayerMinMaxZoom",
-    value: function setLayerMinMaxZoom(layer) {
-      // 文本图层设置，可见范围
-      if (layer.getModelType() === 'text') {
-        layer.updateLayerConfig({
-          maxZoom: this.z + 1,
-          minZoom: this.z - 1
-        });
+        transforms: rawSource.transforms
       }
+    };
+  }
+  setLayerMinMaxZoom(layer) {
+    // 文本图层设置，可见范围
+    if (layer.getModelType() === 'text') {
+      layer.updateLayerConfig({
+        maxZoom: this.z + 1,
+        minZoom: this.z - 1
+      });
     }
-    // 获取瓦片数据
-  }, {
-    key: "getFeatures",
-    value: function getFeatures(sourceLayer) {
-      var source = this.sourceTile.data;
-      return source.getTileData(sourceLayer);
-    }
+  }
+  // 获取瓦片数据
 
-    /**
-     * 在一个 Tile 中可能存在一个相同 ID 的 feature
-     * @param id
-     * @returns
-     */
-  }, {
-    key: "getFeatureById",
-    value: function getFeatureById(id) {
-      var layer = this.getMainLayer();
-      if (!layer) {
-        return [];
-      }
-      var res = layer.getSource().data.dataArray.filter(function (d) {
-        return d._id === id;
-      });
-      return res;
+  getFeatures(sourceLayer) {
+    const source = this.sourceTile.data;
+    return source.getTileData(sourceLayer);
+  }
+
+  /**
+   * 在一个 Tile 中可能存在一个相同 ID 的 feature
+   * @param id
+   * @returns
+   */
+  getFeatureById(id) {
+    const layer = this.getMainLayer();
+    if (!layer) {
+      return [];
     }
-  }]);
-  return VectorTile;
-}(Tile);
-export { VectorTile as default };
+    const res = layer.getSource().data.dataArray.filter(d => d._id === id);
+    return res;
+  }
+}

package/es/tile/tile/index.js

@@ -7,7 +7,7 @@ import RasterTerrainRGBTile from "./RasterTerrainRGBTile";
 import RasterTile from "./RasterTile";
 import VectorTile from "./VectorTile";
 export function getTileFactory(layer) {
-  var tileType = layer.type;
+  const tileType = layer.type;
   switch (tileType) {
     case 'PolygonLayer':
       return VectorTile;
@@ -20,7 +20,9 @@ export function getTileFactory(layer) {
     case 'MaskLayer':
       return MaskLayer;
     case 'RasterLayer':
-      var dataType = layer.getSource().parser.dataType;
+      const {
+        dataType
+      } = layer.getSource().parser;
       switch (dataType) {
         case RasterTileType.RGB:
         case RasterTileType.CUSTOMRGB:

package/es/tile/utils/constants.js

@@ -1,6 +1,6 @@
 // TileLayer 需要代理的子图层的方法
 // 一般都是在 BaseLayer 上的方法
-export var ProxyFuncs = [
+export const ProxyFuncs = [
 /**
  * 1. 需要作用到所属子图层才会生效的方法
  * 2. 不需要主动重新创建 model 的方法

package/es/tile/utils/utils.js

@@ -1,4 +1,4 @@
-export var tileVectorParser = ['mvt', 'geojsonvt', 'testTile'];
+export const tileVectorParser = ['mvt', 'geojsonvt', 'testTile'];
 
 /**
  * 判断当前图层是否是瓦片图层
@@ -6,6 +6,6 @@ export var tileVectorParser = ['mvt', 'geojsonvt', 'testTile'];
  * @returns
  */
 export function isTileGroup(layer) {
-  var source = layer.getSource();
+  const source = layer.getSource();
   return tileVectorParser.includes(source.parser.type);
 }