@antv/l7-layers 2.9.26-alpha.0 → 2.9.26

package/lib/tile/tileFactory/base.js

@@ -0,0 +1,466 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+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 _l7Source = _interopRequireDefault(require("@antv/l7-source"));
+
+var _l7Utils = require("@antv/l7-utils");
+
+var _mask = _interopRequireDefault(require("../../mask"));
+
+var _utils = require("../utils");
+
+var _vectorLayer = _interopRequireDefault(require("./vectorLayer"));
+
+var turf = _interopRequireWildcard(require("@turf/helpers"));
+
+var _union = _interopRequireDefault(require("@turf/union"));
+
+var _polygonToLine = _interopRequireDefault(require("@turf/polygon-to-line"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var TileFactory = /*#__PURE__*/function () {
+  // 用于记录图层内事件，辅助判断图层外事件逻辑
+  function TileFactory(option) {
+    (0, _classCallCheck2.default)(this, TileFactory);
+    (0, _defineProperty2.default)(this, "outSideEventTimer", null);
+    (0, _defineProperty2.default)(this, "eventCache", {
+      click: 0,
+      mousemove: 0,
+      mouseup: 0,
+      mousedown: 0,
+      contextmenu: 0
+    });
+    this.parentLayer = option.parent;
+    this.mapService = option.mapService;
+    this.rendererService = option.rendererService;
+    var source = this.parentLayer.getSource();
+    this.zoomOffset = source.parser.zoomOffset || 0;
+    this.tilesetManager = source.tileset;
+  }
+
+  (0, _createClass2.default)(TileFactory, [{
+    key: "createTile",
+    value: function createTile(tile, initOptions) {
+      return {
+        layers: [],
+        layerIDList: []
+      };
+    }
+  }, {
+    key: "getFeatureData",
+    value: function getFeatureData(tile, initOptions) {
+      var emptyData = {
+        features: [],
+        featureId: null,
+        vectorTileLayer: null,
+        source: null
+      };
+      var sourceLayer = initOptions.sourceLayer,
+          featureId = initOptions.featureId,
+          transforms = initOptions.transforms,
+          layerType = initOptions.layerType,
+          shape = initOptions.shape;
+
+      if (!sourceLayer) {
+        return emptyData;
+      }
+
+      var vectorTileLayer = tile.data.layers[sourceLayer];
+      var features = vectorTileLayer === null || vectorTileLayer === void 0 ? void 0 : vectorTileLayer.features;
+
+      if (!(Array.isArray(features) && features.length > 0)) {
+        return emptyData;
+      } else {
+        var geofeatures = [];
+
+        if (layerType === 'LineLayer' && shape === 'simple') {
+          features.map(function (feature) {
+            if (feature.geometry.type === 'MultiPolygon') {
+              var _geofeatures;
+
+              // @ts-ignore
+              var linefeatures = (0, _polygonToLine.default)(feature).features;
+
+              (_geofeatures = geofeatures).push.apply(_geofeatures, (0, _toConsumableArray2.default)(linefeatures));
+            } else if (feature.geometry.type === 'Polygon') {
+              feature.geometry.type = 'MultiLineString';
+              geofeatures.push(feature);
+            } else {
+              geofeatures.push(feature);
+            }
+          });
+        } else {
+          geofeatures = features;
+        }
+
+        var source = new _l7Source.default({
+          type: 'FeatureCollection',
+          features: geofeatures
+        }, {
+          parser: {
+            type: 'geojson',
+            featureId: featureId
+          },
+          transforms: transforms
+        });
+        return {
+          features: geofeatures,
+          featureId: featureId,
+          vectorTileLayer: vectorTileLayer,
+          source: source
+        };
+      }
+    }
+  }, {
+    key: "createLayer",
+    value: function createLayer(tileLayerOption) {
+      var L7Layer = tileLayerOption.L7Layer,
+          tile = tileLayerOption.tile,
+          initOptions = tileLayerOption.initOptions,
+          vectorTileLayer = tileLayerOption.vectorTileLayer,
+          source = tileLayerOption.source;
+      var mask = initOptions.mask,
+          color = initOptions.color,
+          layerType = initOptions.layerType,
+          size = initOptions.size,
+          shape = initOptions.shape;
+      var FactoryTileLayer = L7Layer ? L7Layer : _vectorLayer.default;
+      var layer = new FactoryTileLayer((0, _objectSpread2.default)({
+        visible: tile.isVisible,
+        tileOrigin: vectorTileLayer === null || vectorTileLayer === void 0 ? void 0 : vectorTileLayer.l7TileOrigin,
+        coord: vectorTileLayer === null || vectorTileLayer === void 0 ? void 0 : vectorTileLayer.l7TileCoord
+      }, this.getLayerInitOption(initOptions))); // vector layer set config
+
+      if (layer.isVector) {
+        this.emitEvent([layer]);
+        layer.type = layerType;
+        layer.select(true);
+      } // set source
+
+
+      layer.source(source); // set scale
+
+      this.setScale(layer); // set scale attribute field
+
+      this.setStyleAttributeField(layer, 'shape', shape);
+      this.setStyleAttributeField(layer, 'color', color);
+      this.setStyleAttributeField(layer, 'size', size); // set mask
+
+      var layers = [layer];
+
+      if (mask && layer.isVector) {
+        var masklayer = new _mask.default().source({
+          type: 'FeatureCollection',
+          features: [tile.bboxPolygon]
+        }).shape('fill');
+        layers.push(masklayer);
+        layer.addMaskLayer(masklayer);
+      } // regist layer
+
+
+      (0, _utils.registerLayers)(this.parentLayer, layers);
+      this.layers = [layer];
+      return layer;
+    }
+  }, {
+    key: "updateStyle",
+    value: function updateStyle(styles) {
+      return '';
+    }
+  }, {
+    key: "getDefautStyleAttributeField",
+    value: function getDefautStyleAttributeField(layer, type) {
+      switch (type) {
+        case 'size':
+          return 2;
+
+        case 'color':
+          return '#fff';
+
+        case 'shape':
+          return (0, _utils.getLayerShape)(this.parentLayer.type, layer);
+
+        default:
+          return '';
+      }
+    }
+  }, {
+    key: "setStyleAttributeField",
+    value: function setStyleAttributeField(layer, type, value) {
+      if (Array.isArray(value)) {
+        // @ts-ignore
+        layer[type].apply(layer, (0, _toConsumableArray2.default)(value));
+        return;
+      }
+
+      if (typeof value === 'string') {
+        layer[type](value);
+        return;
+      }
+
+      var defaultValue = this.getDefautStyleAttributeField(layer, type);
+
+      if (!value) {
+        layer[type](defaultValue);
+        return layer;
+      }
+
+      var params = this.parseScaleValue(value, type);
+
+      if (params.length === 0) {
+        layer[type](defaultValue);
+      } else {
+        // @ts-ignore
+        layer[type].apply(layer, (0, _toConsumableArray2.default)(params));
+      }
+    }
+  }, {
+    key: "parseScaleValue",
+    value: function parseScaleValue(value, type) {
+      if (type === 'shape') {
+        if (typeof value === 'string') {
+          return [value];
+        } else if (value !== null && value !== void 0 && value.field) {
+          return [value === null || value === void 0 ? void 0 : value.field];
+        } else {
+          return [];
+        }
+      }
+
+      var _ref = value,
+          field = _ref.field,
+          values = _ref.values,
+          callback = _ref.callback;
+
+      if (field && values && Array.isArray(values)) {
+        return [field, values];
+      } else if (field && callback) {
+        return [field, callback];
+      } else if (field) {
+        return [field];
+      }
+
+      return [];
+    }
+  }, {
+    key: "getTile",
+    value: function getTile(lng, lat) {
+      var zoom = this.mapService.getZoom();
+      var z = Math.ceil(zoom) + this.zoomOffset;
+      var xy = (0, _l7Utils.osmLonLat2TileXY)(lng, lat, z);
+      var tiles = this.tilesetManager.tiles.filter(function (t) {
+        return t.key === "".concat(xy[0], ",").concat(xy[1], ",").concat(z);
+      });
+      var tile = tiles[0];
+      return tile;
+    }
+  }, {
+    key: "emitEvent",
+    value: function emitEvent(layers, isVector) {
+      var _this = this;
+
+      layers.map(function (layer) {
+        layer.once('inited', function () {
+          layer.on('click', function (e) {
+            _this.eventCache.click = 1;
+
+            if (_this.parentLayer.type === 'RasterLayer') {
+              var _e$lngLat = e.lngLat,
+                  lng = _e$lngLat.lng,
+                  lat = _e$lngLat.lat;
+
+              var tile = _this.getTile(lng, lat);
+
+              _this.getFeatureAndEmitEvent(layer, 'subLayerClick', e, isVector, tile);
+            } else {
+              _this.getFeatureAndEmitEvent(layer, 'subLayerClick', e);
+            }
+          });
+          layer.on('mousemove', function (e) {
+            _this.eventCache.mousemove = 1;
+
+            if (_this.parentLayer.type === 'RasterLayer') {
+              var _e$lngLat2 = e.lngLat,
+                  lng = _e$lngLat2.lng,
+                  lat = _e$lngLat2.lat;
+
+              var tile = _this.getTile(lng, lat);
+
+              _this.getFeatureAndEmitEvent(layer, 'subLayerMouseMove', e, isVector, tile);
+            } else {
+              _this.getFeatureAndEmitEvent(layer, 'subLayerMouseMove', e);
+            }
+          });
+          layer.on('mouseup', function (e) {
+            _this.eventCache.mouseup = 1;
+
+            _this.getFeatureAndEmitEvent(layer, 'subLayerMouseUp', e);
+          });
+          layer.on('mouseenter', function (e) {
+            if (_this.parentLayer.type === 'RasterLayer') {
+              var _e$lngLat3 = e.lngLat,
+                  lng = _e$lngLat3.lng,
+                  lat = _e$lngLat3.lat;
+
+              var tile = _this.getTile(lng, lat);
+
+              _this.getFeatureAndEmitEvent(layer, 'subLayerMouseMove', e, isVector, tile);
+            } else {
+              _this.getFeatureAndEmitEvent(layer, 'subLayerMouseEnter', e);
+            }
+          });
+          layer.on('mouseout', function (e) {
+            _this.getFeatureAndEmitEvent(layer, 'subLayerMouseOut', e);
+          });
+          layer.on('mousedown', function (e) {
+            _this.eventCache.mousedown = 1;
+
+            _this.getFeatureAndEmitEvent(layer, 'subLayerMouseDown', e);
+          });
+          layer.on('contextmenu', function (e) {
+            _this.eventCache.contextmenu = 1;
+
+            _this.getFeatureAndEmitEvent(layer, 'subLayerContextmenu', e);
+          }); // out side
+
+          layer.on('unclick', function (e) {
+            return _this.handleOutsideEvent('click', 'subLayerUnClick', layer, e);
+          });
+          layer.on('unmouseup', function (e) {
+            return _this.handleOutsideEvent('mouseup', 'subLayerUnMouseUp', layer, e);
+          });
+          layer.on('unmousedown', function (e) {
+            return _this.handleOutsideEvent('mousedown', 'subLayerUnMouseDown', layer, e);
+          });
+          layer.on('uncontextmenu', function (e) {
+            return _this.handleOutsideEvent('contextmenu', 'subLayerUnContextmenu', layer, e);
+          });
+        });
+      });
+    }
+  }, {
+    key: "getCombineFeature",
+    value: function getCombineFeature(features) {
+      var p = null;
+      var properties = features[0];
+      features.map(function (feature) {
+        var polygon = turf.polygon(feature.coordinates);
+
+        if (p === null) {
+          p = polygon;
+        }
+
+        {
+          p = (0, _union.default)(p, polygon);
+        }
+      });
+
+      if (properties) {
+        p.properties = (0, _objectSpread2.default)({}, properties);
+      }
+
+      return p;
+    }
+  }, {
+    key: "getFeatureAndEmitEvent",
+    value: function getFeatureAndEmitEvent(layer, eventName, e, isVector, tile) {
+      if (isVector === false) {
+        // raster tile get rgb
+        // e.pickedColors = readPixel(e.x, e.y, this.rendererService);
+        // raster tile origin value
+        e.value = (0, _utils.readRasterValue)(tile, this.mapService, e.x, e.y);
+      } else {
+        // VectorLayer
+        var featureId = e.featureId;
+        var features = this.getAllFeatures(featureId);
+
+        try {
+          e.feature = this.getCombineFeature(features);
+        } catch (err) {
+          console.warn('Combine Featuer Err! Return First Feature!');
+          e.feature = features[0];
+        }
+      }
+
+      this.parentLayer.emit(eventName, e);
+    }
+  }, {
+    key: "setScale",
+    value: function setScale(layer) {
+      var scaleOptions = this.parentLayer.tileLayer.scaleField;
+      var scaleKeys = Object.keys(scaleOptions);
+      scaleKeys.map(function (key) {
+        layer.scale(key, scaleOptions[key]);
+      });
+    }
+  }, {
+    key: "getAllFeatures",
+    value: function getAllFeatures(featureId) {
+      var allLayers = this.parentLayer.tileLayer.children;
+      var features = [];
+      allLayers.map(function (layer) {
+        var source = layer.getSource();
+        source.data.dataArray.map(function (feature) {
+          if (feature._id === featureId) {
+            features.push(feature);
+          }
+        });
+      });
+      return features;
+    }
+  }, {
+    key: "getLayerInitOption",
+    value: function getLayerInitOption(initOptions) {
+      var option = (0, _objectSpread2.default)({}, initOptions);
+      delete option.color;
+      delete option.shape;
+      delete option.size;
+      delete option.coords;
+      delete option.sourceLayer;
+      delete option.coords;
+      return option;
+    }
+  }, {
+    key: "handleOutsideEvent",
+    value: function handleOutsideEvent(type, emitType, layer, e) {
+      var _this2 = this;
+
+      if (this.outSideEventTimer) {
+        clearTimeout(this.outSideEventTimer);
+        this.outSideEventTimer = null;
+      }
+
+      this.outSideEventTimer = setTimeout(function () {
+        if (_this2.eventCache[type] > 0) {
+          _this2.eventCache[type] = 0;
+        } else {
+          _this2.getFeatureAndEmitEvent(layer, emitType, e);
+        }
+      }, 64);
+    }
+  }]);
+  return TileFactory;
+}();
+
+exports.default = TileFactory;

package/lib/tile/tileFactory/index.js

@@ -0,0 +1,64 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  getTileFactory: true
+};
+exports.getTileFactory = getTileFactory;
+
+var _line = _interopRequireDefault(require("./line"));
+
+var _point = _interopRequireDefault(require("./point"));
+
+var _polygon = _interopRequireDefault(require("./polygon"));
+
+var _raster = _interopRequireDefault(require("./raster"));
+
+var _rasterData = _interopRequireDefault(require("./rasterData"));
+
+var _test = _interopRequireDefault(require("./test"));
+
+var _interface = require("../interface");
+
+Object.keys(_interface).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _interface[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _interface[key];
+    }
+  });
+});
+
+function getTileFactory(tileType, parser) {
+  switch (tileType) {
+    case 'PolygonLayer':
+      return _polygon.default;
+
+    case 'LineLayer':
+      return _line.default;
+
+    case 'PointLayer':
+      return _point.default;
+
+    case 'TileDebugLayer':
+      return _test.default;
+
+    case 'RasterLayer':
+      if (parser.dataType === 'arraybuffer') {
+        return _rasterData.default;
+      } else {
+        return _raster.default;
+      }
+
+    default:
+      console.warn('Current Tile Not Exist!');
+      return _raster.default;
+  }
+}

package/lib/tile/tileFactory/line.js

@@ -0,0 +1,70 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+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 _base = _interopRequireDefault(require("./base"));
+
+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 VectorPolygonTile = /*#__PURE__*/function (_TileFactory) {
+  (0, _inherits2.default)(VectorPolygonTile, _TileFactory);
+
+  var _super = _createSuper(VectorPolygonTile);
+
+  function VectorPolygonTile(option) {
+    var _this;
+
+    (0, _classCallCheck2.default)(this, VectorPolygonTile);
+    _this = _super.call(this, option);
+    _this.parentLayer = option.parent;
+    return _this;
+  }
+
+  (0, _createClass2.default)(VectorPolygonTile, [{
+    key: "createTile",
+    value: function createTile(tile, initOptions) {
+      var _this$getFeatureData = this.getFeatureData(tile, initOptions),
+          features = _this$getFeatureData.features,
+          vectorTileLayer = _this$getFeatureData.vectorTileLayer,
+          source = _this$getFeatureData.source;
+
+      if (features.length === 0) {
+        return {
+          layers: [],
+          layerIDList: []
+        };
+      }
+
+      var layer = this.createLayer({
+        tile: tile,
+        initOptions: initOptions,
+        vectorTileLayer: vectorTileLayer,
+        source: source
+      });
+      return {
+        layers: [layer],
+        layerIDList: [layer.id]
+      };
+    }
+  }]);
+  return VectorPolygonTile;
+}(_base.default);
+
+exports.default = VectorPolygonTile;

package/lib/tile/tileFactory/point.js

@@ -0,0 +1,70 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+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 _base = _interopRequireDefault(require("./base"));
+
+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 VectorPolygonTile = /*#__PURE__*/function (_TileFactory) {
+  (0, _inherits2.default)(VectorPolygonTile, _TileFactory);
+
+  var _super = _createSuper(VectorPolygonTile);
+
+  function VectorPolygonTile(option) {
+    var _this;
+
+    (0, _classCallCheck2.default)(this, VectorPolygonTile);
+    _this = _super.call(this, option);
+    _this.parentLayer = option.parent;
+    return _this;
+  }
+
+  (0, _createClass2.default)(VectorPolygonTile, [{
+    key: "createTile",
+    value: function createTile(tile, initOptions) {
+      var _this$getFeatureData = this.getFeatureData(tile, initOptions),
+          features = _this$getFeatureData.features,
+          vectorTileLayer = _this$getFeatureData.vectorTileLayer,
+          source = _this$getFeatureData.source;
+
+      if (features.length === 0) {
+        return {
+          layers: [],
+          layerIDList: []
+        };
+      }
+
+      var layer = this.createLayer({
+        tile: tile,
+        initOptions: initOptions,
+        vectorTileLayer: vectorTileLayer,
+        source: source
+      });
+      return {
+        layers: [layer],
+        layerIDList: [layer.id]
+      };
+    }
+  }]);
+  return VectorPolygonTile;
+}(_base.default);
+
+exports.default = VectorPolygonTile;