@antv/l7-layers 2.10.1 → 2.10.3

package/lib/tile/tileFactory/Tile.js

@@ -0,0 +1,210 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _l7Core = require("@antv/l7-core");
+
+var Tile = /*#__PURE__*/function () {
+  function Tile(sourceTile, parent) {
+    (0, _classCallCheck2.default)(this, Tile);
+    (0, _defineProperty2.default)(this, "visible", true);
+    (0, _defineProperty2.default)(this, "layers", []);
+    (0, _defineProperty2.default)(this, "isLoaded", false);
+    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);
+  }
+
+  (0, _createClass2.default)(Tile, [{
+    key: "getLayers",
+    value: function getLayers() {
+      return this.layers;
+    } // eslint-disable-next-line @typescript-eslint/no-unused-vars
+
+  }, {
+    key: "styleUpdate",
+    value: function styleUpdate() {}
+  }, {
+    key: "lnglatInBounds",
+    value: function lnglatInBounds(lnglat) {
+      var _this$sourceTile$boun = (0, _slicedToArray2.default)(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: "addMask",
+    value: function () {
+      var _addMask = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(layer, mask) {
+        var container;
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                container = (0, _l7Core.createLayerContainer)(this.parent.sceneContainer);
+                mask.setContainer(container, this.parent.sceneContainer);
+                _context.next = 4;
+                return mask.init();
+
+              case 4:
+                layer.addMaskLayer(mask);
+
+              case 5:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function addMask(_x, _x2) {
+        return _addMask.apply(this, arguments);
+      }
+
+      return addMask;
+    }()
+  }, {
+    key: "addLayer",
+    value: function () {
+      var _addLayer = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(layer) {
+        var container;
+        return _regenerator.default.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                // set flag
+                layer.isTileLayer = true;
+                container = (0, _l7Core.createLayerContainer)(this.parent.sceneContainer);
+                layer.setContainer(container, this.parent.sceneContainer);
+                this.layers.push(layer);
+                _context2.next = 6;
+                return layer.init();
+
+              case 6:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
+
+      function addLayer(_x3) {
+        return _addLayer.apply(this, arguments);
+      }
+
+      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((0, _defineProperty2.default)({}, key, value));
+      });
+    }
+    /**
+     * 一个 Tile 可能有多个 layer，但是在发生拾取、点击事件的时候只有一个生效
+     */
+
+  }, {
+    key: "getMainLayer",
+    value: function getMainLayer() {
+      return this.layers[0];
+    }
+  }, {
+    key: "getFeatures",
+    value: function getFeatures(sourceLayer) {
+      var _this$sourceTile$data, _this$sourceTile$data2;
+
+      if (!sourceLayer || !((_this$sourceTile$data = this.sourceTile.data) !== null && _this$sourceTile$data !== void 0 && _this$sourceTile$data.layers[sourceLayer])) {
+        return [];
+      }
+
+      var vectorTile = (_this$sourceTile$data2 = this.sourceTile.data) === null || _this$sourceTile$data2 === void 0 ? void 0 : _this$sourceTile$data2.layers[sourceLayer];
+
+      if (Array.isArray(vectorTile.features)) {
+        // 数据不需要被解析 geojson-vt 类型
+        return vectorTile.features;
+      }
+
+      var _this$sourceTile = this.sourceTile,
+          x = _this$sourceTile.x,
+          y = _this$sourceTile.y,
+          z = _this$sourceTile.z;
+      var features = [];
+
+      for (var i = 0; i < vectorTile.length; i++) {
+        var vectorTileFeature = vectorTile.feature(i);
+        var feature = vectorTileFeature.toGeoJSON(x, y, z);
+        features.push((0, _objectSpread2.default)((0, _objectSpread2.default)({}, feature), {}, {
+          properties: (0, _objectSpread2.default)({
+            id: feature.id
+          }, feature.properties)
+        }));
+      }
+
+      return features;
+    }
+    /**
+     * 在一个 Tile 中可能存在一个相同 ID 的 feature
+     * @param id 
+     * @returns 
+     */
+
+  }, {
+    key: "getFeatureById",
+    value: function getFeatureById(id) {
+      var layer = this.getMainLayer();
+
+      if (!layer) {
+        return [];
+      }
+
+      return layer.getSource().data.dataArray.filter(function (d) {
+        return d._id === id;
+      });
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      this.layers.forEach(function (layer) {
+        return layer.destroy();
+      });
+    }
+  }]);
+  return Tile;
+}();
+
+exports.default = Tile;

package/lib/tile/tileFactory/VectorTile.js

@@ -0,0 +1,167 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _Tile2 = _interopRequireDefault(require("./Tile"));
+
+var _util = require("./util");
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(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; } }
+
+var VectorTile = /*#__PURE__*/function (_Tile) {
+  (0, _inherits2.default)(VectorTile, _Tile);
+
+  var _super = _createSuper(VectorTile);
+
+  function VectorTile() {
+    (0, _classCallCheck2.default)(this, VectorTile);
+    return _super.apply(this, arguments);
+  }
+
+  (0, _createClass2.default)(VectorTile, [{
+    key: "initTileLayer",
+    value: function () {
+      var _initTileLayer = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee() {
+        var attributes, layerOptions, vectorLayer, maskLayer, sourceOptions, layer, mask;
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                attributes = this.parent.getLayerAttributeConfig();
+                layerOptions = this.parent.getLayerConfig();
+                vectorLayer = (0, _util.getTileLayer)(this.parent.type);
+                maskLayer = (0, _util.getMaskLayer)(this.parent.type);
+                layerOptions.mask = !!maskLayer;
+                sourceOptions = this.getSourceOption();
+
+                if (sourceOptions) {
+                  _context.next = 9;
+                  break;
+                }
+
+                this.isLoaded = true;
+                return _context.abrupt("return");
+
+              case 9:
+                layer = new vectorLayer((0, _objectSpread2.default)({}, 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);
+                });
+
+                if (!maskLayer) {
+                  _context.next = 15;
+                  break;
+                }
+
+                mask = new maskLayer({
+                  layerType: "MaskLayer"
+                }).source({
+                  type: 'FeatureCollection',
+                  features: [this.sourceTile.bboxPolygon]
+                }, {
+                  parser: {
+                    type: 'geojson'
+                  }
+                }); // .style({
+                //   opacity: 1
+                // });
+
+                _context.next = 15;
+                return this.addMask(layer, mask);
+
+              case 15:
+                _context.next = 17;
+                return this.addLayer(layer);
+
+              case 17:
+                this.setLayerMinMaxZoom(layer);
+                this.isLoaded = true;
+
+              case 19:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function initTileLayer() {
+        return _initTileLayer.apply(this, arguments);
+      }
+
+      return initTileLayer;
+    }() // Todo 校验数据有效性
+
+  }, {
+    key: "beforeInit",
+    value: function beforeInit() {}
+  }, {
+    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
+        },
+        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
+        });
+      }
+    }
+  }]);
+  return VectorTile;
+}(_Tile2.default);
+
+exports.default = VectorTile;

package/lib/tile/tileFactory/index.js

@@ -10,21 +10,17 @@ var _exportNames = {
 };
 exports.getTileFactory = getTileFactory;
 
-var _l7Source = require("@antv/l7-source");
+var _VectorTile = _interopRequireDefault(require("./VectorTile"));
 
-var _line = _interopRequireDefault(require("./line"));
+var _DebugTile = _interopRequireDefault(require("./DebugTile"));
 
-var _point = _interopRequireDefault(require("./point"));
+var _ImageTile = _interopRequireDefault(require("./ImageTile"));
 
-var _polygon = _interopRequireDefault(require("./polygon"));
+var _RasterTile = _interopRequireDefault(require("./RasterTile"));
 
-var _mask = _interopRequireDefault(require("./mask"));
+var _RasterRGBTile = _interopRequireDefault(require("./RasterRGBTile"));
 
-var _raster = _interopRequireDefault(require("./raster"));
-
-var _rasterData = _interopRequireDefault(require("./rasterData"));
-
-var _test = _interopRequireDefault(require("./test"));
+var _MaskTile = _interopRequireDefault(require("./MaskTile"));
 
 var _interface = require("../interface");
 
@@ -40,32 +36,54 @@ Object.keys(_interface).forEach(function (key) {
   });
 });
 
-function getTileFactory(tileType, parser) {
+var _Tile = require("./Tile");
+
+Object.keys(_Tile).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _Tile[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _Tile[key];
+    }
+  });
+});
+
+function getTileFactory(layer) {
+  var tileType = layer.type;
+
   switch (tileType) {
     case 'PolygonLayer':
-      return _polygon.default;
+      return _VectorTile.default;
 
     case 'LineLayer':
-      return _line.default;
+      return _VectorTile.default;
 
     case 'PointLayer':
-      return _point.default;
-
-    case 'MaskLayer':
-      return _mask.default;
+      return _VectorTile.default;
 
     case 'TileDebugLayer':
-      return _test.default;
+      return _DebugTile.default;
+
+    case 'MaskLayer':
+      return _MaskTile.default;
 
     case 'RasterLayer':
-      if (_l7Source.rasterDataTypes.includes(parser.dataType)) {
-        return _rasterData.default;
-      } else {
-        return _raster.default;
+      var dataType = layer.getSource().parser.dataType;
+
+      switch (dataType) {
+        case 'rgb':
+          return _RasterRGBTile.default;
+
+        case 'arraybuffer':
+          return _RasterTile.default;
+
+        default:
+          return _ImageTile.default;
       }
 
     default:
-      console.warn('Current Tile Not Exist!');
-      return _raster.default;
+      return _VectorTile.default;
   }
 }

package/lib/tile/tileFactory/layers/{rasterDataLayer.js → RasterDataLayer.js}

@@ -7,6 +7,10 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 
 var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
@@ -52,32 +56,42 @@ var RasterTiffLayer = /*#__PURE__*/function (_BaseLayer) {
 
   (0, _createClass2.default)(RasterTiffLayer, [{
     key: "buildModels",
-    value: function buildModels() {
-      var _this2 = this;
-
-      var model = this.getModelType();
-      this.layerModel = new model(this);
-      this.layerModel.initModels(function (models) {
-        _this2.dispatchModelLoad(models);
-      });
-    }
-  }, {
-    key: "rebuildModels",
-    value: function rebuildModels() {
-      var _this3 = this;
+    value: function () {
+      var _buildModels = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee() {
+        var model;
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                model = this.getModel();
+                this.layerModel = new model(this);
+                _context.next = 4;
+                return this.initLayerModels();
+
+              case 4:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function buildModels() {
+        return _buildModels.apply(this, arguments);
+      }
 
-      this.layerModel.buildModels(function (models) {
-        _this3.dispatchModelLoad(models);
-      });
+      return buildModels;
+    }()
+  }, {
+    key: "getModel",
+    value: function getModel() {
+      var type = this.getModelType();
+      return type === 'rasterRgb' ? _rasterRgb.default : _rasterTile.default;
     }
   }, {
     key: "getModelType",
     value: function getModelType() {
-      if (this.layerSource.parser.type === 'rasterRgb') {
-        return _rasterRgb.default;
-      } else {
-        return _rasterTile.default;
-      }
+      return this.layerSource.parser.type === 'rasterRgb' ? 'rasterRgb' : 'raster';
     }
   }, {
     key: "getDefaultConfig",

package/lib/tile/tileFactory/layers/{tileTest.js → TileDebugLayer.js}

@@ -7,6 +7,10 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 
 var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
@@ -23,8 +27,6 @@ var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/de
 
 var _BaseLayer2 = _interopRequireDefault(require("../../../core/BaseLayer"));
 
-var _tileModel = _interopRequireDefault(require("../../models/tileModel"));
-
 function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(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; } }
@@ -45,12 +47,12 @@ var TileDebugLayer = /*#__PURE__*/function (_BaseLayer) {
 
     _this = _super.call.apply(_super, [this].concat(args));
     (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "type", 'TileDebugLayer');
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "zIndex", 10000);
     (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "defaultSourceConfig", {
       data: [],
       options: {
         parser: {
-          type: 'testTile',
-          cancelExtent: true
+          type: 'testTile'
         }
       }
     });
@@ -59,14 +61,25 @@ var TileDebugLayer = /*#__PURE__*/function (_BaseLayer) {
 
   (0, _createClass2.default)(TileDebugLayer, [{
     key: "buildModels",
-    value: function buildModels() {
-      var _this2 = this;
+    value: function () {
+      var _buildModels = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee() {
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee);
+      }));
+
+      function buildModels() {
+        return _buildModels.apply(this, arguments);
+      }
 
-      this.layerModel = new _tileModel.default(this);
-      this.layerModel.initModels(function (models) {
-        _this2.dispatchModelLoad(models);
-      });
-    }
+      return buildModels;
+    }()
   }]);
   return TileDebugLayer;
 }(_BaseLayer2.default);

package/lib/tile/tileFactory/util.js

@@ -0,0 +1,48 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getMaskLayer = getMaskLayer;
+exports.getTileLayer = getTileLayer;
+
+var _index = _interopRequireDefault(require("../../point/index"));
+
+var _line = _interopRequireDefault(require("../../line"));
+
+var _polygon = _interopRequireDefault(require("../../polygon"));
+
+var _mask = _interopRequireDefault(require("../../mask"));
+
+function getTileLayer(type) {
+  if (type === 'PolygonLayer') {
+    return _polygon.default;
+  }
+
+  if (type === 'LineLayer') {
+    return _line.default;
+  }
+
+  if (type === 'PointLayer') {
+    return _index.default;
+  }
+
+  return _index.default;
+}
+
+function getMaskLayer(type) {
+  switch (type) {
+    case 'PolygonLayer':
+    case 'LineLayer':
+      return _mask.default;
+
+    case 'PointLayer':
+    case 'RasterLayer':
+      return undefined;
+
+    default:
+      return undefined;
+  }
+}