@antv/l7-layers 2.21.1 → 2.21.2

package/es/tile/service/TilePickService.js

@@ -1,177 +1,120 @@
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 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 _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import _regeneratorRuntime from "@babel/runtime/regenerator";
 import { decodePickingColor, encodePickingColor } from '@antv/l7-utils';
 import { TileSourceService } from "./TileSourceService";
-var SELECT = 'select';
-var ACTIVE = 'active';
-export var TilePickService = /*#__PURE__*/function () {
-  function TilePickService(_ref) {
-    var layerService = _ref.layerService,
-      tileLayerService = _ref.tileLayerService,
-      parent = _ref.parent;
-    _classCallCheck(this, TilePickService);
+const SELECT = 'select';
+const ACTIVE = 'active';
+export class TilePickService {
+  constructor({
+    layerService,
+    tileLayerService,
+    parent
+  }) {
+    _defineProperty(this, "layerService", void 0);
+    _defineProperty(this, "tileLayerService", void 0);
+    _defineProperty(this, "tileSourceService", void 0);
+    _defineProperty(this, "parent", void 0);
     _defineProperty(this, "tilePickID", new Map());
     this.layerService = layerService;
     this.tileLayerService = tileLayerService;
     this.parent = parent;
     this.tileSourceService = new TileSourceService();
   }
-  _createClass(TilePickService, [{
-    key: "pickRender",
-    value: function pickRender(target) {
-      // 一个 TileLayer 有多个 Tile，但是会同时触发事件的只有一个 Tile
-      var tile = this.tileLayerService.getVisibleTileBylngLat(target.lngLat);
-      if (tile) {
-        // TODO 多图层拾取
-        var pickLayer = tile.getMainLayer();
-        pickLayer === null || pickLayer === void 0 || pickLayer.layerPickService.pickRender(target);
-      }
-    }
-  }, {
-    key: "pick",
-    value: function () {
-      var _pick = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(layer, target) {
-        var container, pickingService, tile, pickLayer;
-        return _regeneratorRuntime.wrap(function _callee$(_context) {
-          while (1) switch (_context.prev = _context.next) {
-            case 0:
-              container = this.parent.getContainer();
-              pickingService = container.pickingService;
-              if (!(layer.type === 'RasterLayer')) {
-                _context.next = 8;
-                break;
-              }
-              tile = this.tileLayerService.getVisibleTileBylngLat(target.lngLat);
-              if (!(tile && tile.getMainLayer() !== undefined)) {
-                _context.next = 7;
-                break;
-              }
-              pickLayer = tile.getMainLayer();
-              return _context.abrupt("return", pickLayer.layerPickService.pickRasterLayer(pickLayer, target, this.parent));
-            case 7:
-              return _context.abrupt("return", false);
-            case 8:
-              this.pickRender(target);
-              return _context.abrupt("return", pickingService.pickFromPickingFBO(layer, target));
-            case 10:
-            case "end":
-              return _context.stop();
-          }
-        }, _callee, this);
-      }));
-      function pick(_x, _x2) {
-        return _pick.apply(this, arguments);
-      }
-      return pick;
-    }()
-  }, {
-    key: "selectFeature",
-    value: function selectFeature(pickedColors) {
-      // @ts-ignore
-      var _pickedColors = _slicedToArray(pickedColors, 3),
-        r = _pickedColors[0],
-        g = _pickedColors[1],
-        b = _pickedColors[2];
-      var id = this.color2PickId(r, g, b);
-      this.tilePickID.set(SELECT, id);
-      this.updateHighLight(r, g, b, SELECT);
-    }
-  }, {
-    key: "highlightPickedFeature",
-    value: function highlightPickedFeature(pickedColors) {
-      // @ts-ignore
-      var _pickedColors2 = _slicedToArray(pickedColors, 3),
-        r = _pickedColors2[0],
-        g = _pickedColors2[1],
-        b = _pickedColors2[2];
-      var id = this.color2PickId(r, g, b);
-      this.tilePickID.set(ACTIVE, id);
-      this.updateHighLight(r, g, b, ACTIVE);
+  pickRender(target) {
+    // 一个 TileLayer 有多个 Tile，但是会同时触发事件的只有一个 Tile
+    const tile = this.tileLayerService.getVisibleTileBylngLat(target.lngLat);
+    if (tile) {
+      // TODO 多图层拾取
+      const pickLayer = tile.getMainLayer();
+      pickLayer === null || pickLayer === void 0 || pickLayer.layerPickService.pickRender(target);
     }
-  }, {
-    key: "updateHighLight",
-    value: function updateHighLight(r, g, b, type) {
-      this.tileLayerService.tiles.map(function (tile) {
-        var layer = tile.getMainLayer();
-        switch (type) {
-          case SELECT:
-            layer === null || layer === void 0 || layer.hooks.beforeSelect.call([r, g, b]);
-            break;
-          case ACTIVE:
-            layer === null || layer === void 0 || layer.hooks.beforeHighlight.call([r, g, b]);
-            break;
+  }
+  pick(layer, target) {
+    var _this = this;
+    return _asyncToGenerator(function* () {
+      const container = _this.parent.getContainer();
+      const pickingService = container.pickingService;
+      if (layer.type === 'RasterLayer') {
+        const tile = _this.tileLayerService.getVisibleTileBylngLat(target.lngLat);
+        if (tile && tile.getMainLayer() !== undefined) {
+          const pickLayer = tile.getMainLayer();
+          return pickLayer.layerPickService.pickRasterLayer(pickLayer, target, _this.parent);
         }
-      });
-    }
-  }, {
-    key: "setPickState",
-    value: function setPickState() {
-      var selectColor = this.tilePickID.get(SELECT);
-      var activeColor = this.tilePickID.get(ACTIVE);
-      if (selectColor) {
-        var _this$pickId2Color = this.pickId2Color(selectColor),
-          _this$pickId2Color2 = _slicedToArray(_this$pickId2Color, 3),
-          r = _this$pickId2Color2[0],
-          g = _this$pickId2Color2[1],
-          b = _this$pickId2Color2[2];
-        this.updateHighLight(r, g, b, SELECT);
-        return;
+        return false;
       }
-      if (activeColor) {
-        var _this$pickId2Color3 = this.pickId2Color(activeColor),
-          _this$pickId2Color4 = _slicedToArray(_this$pickId2Color3, 3),
-          _r = _this$pickId2Color4[0],
-          _g = _this$pickId2Color4[1],
-          _b = _this$pickId2Color4[2];
-        this.updateHighLight(_r, _g, _b, ACTIVE);
-        return;
+      _this.pickRender(target);
+      return pickingService.pickFromPickingFBO(layer, target);
+    })();
+  }
+  selectFeature(pickedColors) {
+    // @ts-ignore
+    const [r, g, b] = pickedColors;
+    const id = this.color2PickId(r, g, b);
+    this.tilePickID.set(SELECT, id);
+    this.updateHighLight(r, g, b, SELECT);
+  }
+  highlightPickedFeature(pickedColors) {
+    // @ts-ignore
+    const [r, g, b] = pickedColors;
+    const id = this.color2PickId(r, g, b);
+    this.tilePickID.set(ACTIVE, id);
+    this.updateHighLight(r, g, b, ACTIVE);
+  }
+  updateHighLight(r, g, b, type) {
+    this.tileLayerService.tiles.map(tile => {
+      const layer = tile.getMainLayer();
+      switch (type) {
+        case SELECT:
+          layer === null || layer === void 0 || layer.hooks.beforeSelect.call([r, g, b]);
+          break;
+        case ACTIVE:
+          layer === null || layer === void 0 || layer.hooks.beforeHighlight.call([r, g, b]);
+          break;
       }
+    });
+  }
+  setPickState() {
+    const selectColor = this.tilePickID.get(SELECT);
+    const activeColor = this.tilePickID.get(ACTIVE);
+    if (selectColor) {
+      const [r, g, b] = this.pickId2Color(selectColor);
+      this.updateHighLight(r, g, b, SELECT);
+      return;
     }
-  }, {
-    key: "color2PickId",
-    value: function color2PickId(r, g, b) {
-      return decodePickingColor(new Uint8Array([r, g, b]));
-    }
-  }, {
-    key: "pickId2Color",
-    value: function pickId2Color(str) {
-      return encodePickingColor(str);
+    if (activeColor) {
+      const [r, g, b] = this.pickId2Color(activeColor);
+      this.updateHighLight(r, g, b, ACTIVE);
+      return;
     }
+  }
+  color2PickId(r, g, b) {
+    return decodePickingColor(new Uint8Array([r, g, b]));
+  }
+  pickId2Color(str) {
+    return encodePickingColor(str);
+  }
 
-    /** 从瓦片中根据数据 */
-  }, {
-    key: "getFeatureById",
-    value: function getFeatureById(pickedFeatureIdx) {
-      // 提取当前可见瓦片
-      var tiles = this.tileLayerService.getTiles().filter(function (tile) {
-        return tile.visible;
-      });
-      // 提取当前可见瓦片中匹配 ID 的 feature 列表
-      var features = [];
-      tiles.forEach(function (tile) {
-        features.push.apply(features, _toConsumableArray(tile.getFeatureById(pickedFeatureIdx)));
-      });
+  /** 从瓦片中根据数据 */
+  getFeatureById(pickedFeatureIdx) {
+    // 提取当前可见瓦片
+    const tiles = this.tileLayerService.getTiles().filter(tile => tile.visible);
+    // 提取当前可见瓦片中匹配 ID 的 feature 列表
+    const features = [];
+    tiles.forEach(tile => {
+      features.push(...tile.getFeatureById(pickedFeatureIdx));
+    });
 
-      // 将 feature 列表合并后返回
-      // 统一返回成 polygon 的格式 点、线、面可以通用
+    // 将 feature 列表合并后返回
+    // 统一返回成 polygon 的格式 点、线、面可以通用
 
-      // const data = this.tileSourceService.getCombineFeature(features);
+    // const data = this.tileSourceService.getCombineFeature(features);
 
-      return features;
-    }
+    return features;
+  }
 
-    // Tip: for interface define
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  }, {
-    key: "pickRasterLayer",
-    value: function pickRasterLayer() {
-      return false;
-    }
-  }]);
-  return TilePickService;
-}();
+  // Tip: for interface define
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  pickRasterLayer() {
+    return false;
+  }
+}

package/es/tile/service/TileSourceService.js

@@ -1,35 +1,26 @@
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
-import _createClass from "@babel/runtime/helpers/esm/createClass";
 import * as turf from '@turf/helpers';
 import union from '@turf/union';
 
 /**
  * 专门处理 Tile 数据相关
  */
-export var TileSourceService = /*#__PURE__*/function () {
-  function TileSourceService() {
-    _classCallCheck(this, TileSourceService);
-  }
-  _createClass(TileSourceService, [{
-    key: "getCombineFeature",
-    value: function getCombineFeature(features) {
-      var p = null;
-      var properties = features[0];
-      features.map(function (feature) {
-        var polygon = turf.polygon(feature.coordinates);
-        // tslint:disable-next-line: prefer-conditional-expression
-        if (p === null) {
-          p = polygon;
-        } else {
-          p = union(p, polygon);
-        }
-      });
-      if (properties) {
-        p.properties = _objectSpread({}, properties);
+export class TileSourceService {
+  getCombineFeature(features) {
+    let p = null;
+    const properties = features[0];
+    features.map(feature => {
+      const polygon = turf.polygon(feature.coordinates);
+      // tslint:disable-next-line: prefer-conditional-expression
+      if (p === null) {
+        p = polygon;
+      } else {
+        p = union(p, polygon);
       }
-      return p;
+    });
+    if (properties) {
+      p.properties = _objectSpread({}, properties);
     }
-  }]);
-  return TileSourceService;
-}();
+    return p;
+  }
+}

package/es/tile/tile/DebugTile.js

@@ -1,84 +1,47 @@
 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 LineLayer from "../../line";
 import PointLayer from "../../point";
 import Tile from "./Tile";
-var DebugTile = /*#__PURE__*/function (_Tile) {
-  _inherits(DebugTile, _Tile);
-  var _super = _createSuper(DebugTile);
-  function DebugTile() {
-    _classCallCheck(this, DebugTile);
-    return _super.apply(this, arguments);
+export default class DebugTile extends Tile {
+  initTileLayer() {
+    var _this = this;
+    return _asyncToGenerator(function* () {
+      const sourceOptions = _this.getSourceOption();
+      const pointData = sourceOptions.data.features[0].properties;
+      const lineLayer = new LineLayer().source(sourceOptions.data, sourceOptions.options).size(1).shape('line').color('red');
+      const pointLayer = new PointLayer({
+        minZoom: _this.z - 1,
+        maxZoom: _this.z + 1,
+        textAllowOverlap: true
+      }).source([pointData], {
+        parser: {
+          type: 'json',
+          x: 'x',
+          y: 'y'
+        }
+      }).size(20).color('red').shape(_this.key).style({
+        stroke: '#fff',
+        strokeWidth: 2
+      });
+      yield _this.addLayer(lineLayer);
+      yield _this.addLayer(pointLayer);
+      _this.isLoaded = true;
+    })();
   }
-  _createClass(DebugTile, [{
-    key: "initTileLayer",
-    value: function () {
-      var _initTileLayer = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
-        var sourceOptions, pointData, lineLayer, pointLayer;
-        return _regeneratorRuntime.wrap(function _callee$(_context) {
-          while (1) switch (_context.prev = _context.next) {
-            case 0:
-              sourceOptions = this.getSourceOption();
-              pointData = sourceOptions.data.features[0].properties;
-              lineLayer = new LineLayer().source(sourceOptions.data, sourceOptions.options).size(1).shape('line').color('red');
-              pointLayer = new PointLayer({
-                minZoom: this.z - 1,
-                maxZoom: this.z + 1,
-                textAllowOverlap: true
-              }).source([pointData], {
-                parser: {
-                  type: 'json',
-                  x: 'x',
-                  y: 'y'
-                }
-              }).size(20).color('red').shape(this.key).style({
-                stroke: '#fff',
-                strokeWidth: 2
-              });
-              _context.next = 6;
-              return this.addLayer(lineLayer);
-            case 6:
-              _context.next = 8;
-              return this.addLayer(pointLayer);
-            case 8:
-              this.isLoaded = true;
-            case 9:
-            case "end":
-              return _context.stop();
-          }
-        }, _callee, this);
-      }));
-      function initTileLayer() {
-        return _initTileLayer.apply(this, arguments);
-      }
-      return initTileLayer;
-    }()
-  }, {
-    key: "getSourceOption",
-    value: function getSourceOption() {
-      var rawSource = this.parent.getSource();
-      var features = this.sourceTile.data.layers.testTile.features;
-      return {
-        data: {
-          type: 'FeatureCollection',
-          features: features
+  getSourceOption() {
+    const rawSource = this.parent.getSource();
+    const features = this.sourceTile.data.layers.testTile.features;
+    return {
+      data: {
+        type: 'FeatureCollection',
+        features
+      },
+      options: {
+        parser: {
+          type: 'geojson'
         },
-        options: {
-          parser: {
-            type: 'geojson'
-          },
-          transforms: rawSource.transforms
-        }
-      };
-    }
-  }]);
-  return DebugTile;
-}(Tile);
-export { DebugTile as default };
+        transforms: rawSource.transforms
+      }
+    };
+  }
+}

package/es/tile/tile/ImageTile.js

@@ -1,72 +1,39 @@
 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 ImageLayer from "../../image";
 import Tile from "./Tile";
-var ImageTile = /*#__PURE__*/function (_Tile) {
-  _inherits(ImageTile, _Tile);
-  var _super = _createSuper(ImageTile);
-  function ImageTile() {
-    _classCallCheck(this, ImageTile);
-    return _super.apply(this, arguments);
+export default class ImageTile extends Tile {
+  initTileLayer() {
+    var _this = this;
+    return _asyncToGenerator(function* () {
+      const attributes = _this.parent.getLayerAttributeConfig();
+      const layerOptions = _this.getLayerOptions();
+      const sourceOptions = _this.getSourceOption();
+      const layer = new ImageLayer(_objectSpread({}, layerOptions)).source(sourceOptions.data, sourceOptions.options);
+
+      // 初始化数据映射
+      // tslint:disable-next-line: no-unused-expression
+      attributes && 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);
+      _this.isLoaded = true;
+    })();
   }
-  _createClass(ImageTile, [{
-    key: "initTileLayer",
-    value: function () {
-      var _initTileLayer = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
-        var attributes, layerOptions, sourceOptions, layer;
-        return _regeneratorRuntime.wrap(function _callee$(_context) {
-          while (1) switch (_context.prev = _context.next) {
-            case 0:
-              attributes = this.parent.getLayerAttributeConfig();
-              layerOptions = this.getLayerOptions();
-              sourceOptions = this.getSourceOption();
-              layer = new ImageLayer(_objectSpread({}, layerOptions)).source(sourceOptions.data, sourceOptions.options); // 初始化数据映射
-              // tslint:disable-next-line: no-unused-expression
-              attributes && 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 = 7;
-              return this.addLayer(layer);
-            case 7:
-              this.isLoaded = true;
-            case 8:
-            case "end":
-              return _context.stop();
-          }
-        }, _callee, this);
-      }));
-      function initTileLayer() {
-        return _initTileLayer.apply(this, arguments);
+  getSourceOption() {
+    const rawSource = this.parent.getSource();
+    return {
+      data: this.sourceTile.data,
+      options: {
+        parser: {
+          type: 'image',
+          extent: this.sourceTile.bounds
+        },
+        transforms: rawSource.transforms
       }
-      return initTileLayer;
-    }()
-  }, {
-    key: "getSourceOption",
-    value: function getSourceOption() {
-      var rawSource = this.parent.getSource();
-      return {
-        data: this.sourceTile.data,
-        options: {
-          parser: {
-            type: 'image',
-            extent: this.sourceTile.bounds
-          },
-          transforms: rawSource.transforms
-        }
-      };
-    }
-  }]);
-  return ImageTile;
-}(Tile);
-export { ImageTile as default };
+    };
+  }
+}