@antv/l7-layers 2.10.2 → 2.10.4

package/lib/tile/manager/mapLayerManager.js

@@ -0,0 +1,134 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BaseMapTileLayerManager = 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 = require("./base");
+
+var _utils = require("../utils");
+
+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 BaseMapTileLayerManager = /*#__PURE__*/function (_Base) {
+  (0, _inherits2.default)(BaseMapTileLayerManager, _Base);
+
+  var _super = _createSuper(BaseMapTileLayerManager);
+
+  // only support vector layer
+  function BaseMapTileLayerManager(parent, mapService, rendererService) {
+    var _this;
+
+    (0, _classCallCheck2.default)(this, BaseMapTileLayerManager);
+    _this = _super.call(this);
+    _this.parent = parent;
+    _this.children = parent.layerChildren;
+    _this.mapService = mapService;
+    _this.rendererService = rendererService;
+
+    _this.setSubLayerInitOption();
+
+    _this.initTileFactory();
+
+    return _this;
+  }
+
+  (0, _createClass2.default)(BaseMapTileLayerManager, [{
+    key: "render",
+    value: function render() {
+      var _this2 = this;
+
+      this.children.filter(function (layer) {
+        return layer.inited;
+      }).filter(function (layer) {
+        return layer.isVisible();
+      }).map(function (layer) {
+        layer.hooks.beforeRenderData.call();
+        layer.hooks.beforeRender.call();
+
+        if (layer.masks.length > 0) {
+          // 清除上一次的模版缓存
+          _this2.rendererService.clear({
+            stencil: 0,
+            depth: 1,
+            framebuffer: null
+          });
+
+          layer.masks.map(function (m) {
+            m.hooks.beforeRenderData.call();
+            m.hooks.beforeRender.call();
+            m.render();
+            m.hooks.afterRender.call();
+          });
+        }
+
+        layer.render();
+        layer.hooks.afterRender.call();
+      });
+    }
+  }, {
+    key: "setSubLayerInitOption",
+    value: function setSubLayerInitOption() {
+      var _colorAttribute$scale, _sizeAttribute$scale;
+
+      var _ref = this.parent.getLayerConfig(),
+          _ref$zIndex = _ref.zIndex,
+          zIndex = _ref$zIndex === void 0 ? 0 : _ref$zIndex,
+          _ref$opacity = _ref.opacity,
+          opacity = _ref$opacity === void 0 ? 1 : _ref$opacity,
+          _ref$mask = _ref.mask,
+          mask = _ref$mask === void 0 ? false : _ref$mask,
+          _ref$stroke = _ref.stroke,
+          stroke = _ref$stroke === void 0 ? '#fff' : _ref$stroke,
+          _ref$strokeWidth = _ref.strokeWidth,
+          strokeWidth = _ref$strokeWidth === void 0 ? 0 : _ref$strokeWidth,
+          _ref$strokeOpacity = _ref.strokeOpacity,
+          strokeOpacity = _ref$strokeOpacity === void 0 ? 1 : _ref$strokeOpacity,
+          _ref$workerEnabled = _ref.workerEnabled,
+          workerEnabled = _ref$workerEnabled === void 0 ? false : _ref$workerEnabled,
+          sourceLayer = _ref.sourceLayer;
+
+      var source = this.parent.getSource();
+      var parentParserType = source.getParserType();
+      var colorAttribute = this.parent.getAttribute('color');
+      var basemapColor = (colorAttribute === null || colorAttribute === void 0 ? void 0 : (_colorAttribute$scale = colorAttribute.scale) === null || _colorAttribute$scale === void 0 ? void 0 : _colorAttribute$scale.field) || '#fff';
+      var sizeAttribute = this.parent.getAttribute('size');
+      var basemapSize = (sizeAttribute === null || sizeAttribute === void 0 ? void 0 : (_sizeAttribute$scale = sizeAttribute.scale) === null || _sizeAttribute$scale === void 0 ? void 0 : _sizeAttribute$scale.field) || 1;
+      var layerShape = (0, _utils.getLayerShape)(this.parent.type, this.parent);
+      this.initOptions = {
+        usage: 'basemap',
+        layerType: this.parent.type,
+        shape: layerShape,
+        zIndex: zIndex,
+        opacity: opacity,
+        sourceLayer: this.getSourceLayer(parentParserType, sourceLayer),
+        basemapColor: basemapColor,
+        basemapSize: basemapSize,
+        mask: (0, _utils.getMaskValue)(this.parent.type, mask),
+        stroke: stroke,
+        strokeWidth: strokeWidth,
+        strokeOpacity: strokeOpacity,
+        // worker
+        workerEnabled: workerEnabled
+      };
+    }
+  }]);
+  return BaseMapTileLayerManager;
+}(_base.Base);
+
+exports.BaseMapTileLayerManager = BaseMapTileLayerManager;

package/lib/tile/models/tileModel.js

@@ -0,0 +1,94 @@
+"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 _BaseModel2 = _interopRequireDefault(require("../../core/BaseModel"));
+
+var _TileLayer = require("../tileLayer/TileLayer");
+
+var _MapTileLayer = require("../tileLayer/MapTileLayer");
+
+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 TileModel = /*#__PURE__*/function (_BaseModel) {
+  (0, _inherits2.default)(TileModel, _BaseModel);
+
+  var _super = _createSuper(TileModel);
+
+  function TileModel() {
+    (0, _classCallCheck2.default)(this, TileModel);
+    return _super.apply(this, arguments);
+  }
+
+  (0, _createClass2.default)(TileModel, [{
+    key: "getUninforms",
+    value: function getUninforms() {
+      return {};
+    }
+  }, {
+    key: "getTileLayer",
+    value: function getTileLayer(usage) {
+      switch (usage) {
+        case 'basemap':
+          return _MapTileLayer.MapTileLayer;
+
+        default:
+          return _TileLayer.TileLayer;
+      }
+    }
+  }, {
+    key: "initModels",
+    value: function initModels() {
+      var source = this.layer.getSource();
+
+      var _this$layer$getLayerC = this.layer.getLayerConfig(),
+          usage = _this$layer$getLayerC.usage;
+
+      if (source !== null && source !== void 0 && source.data.isTile && !this.layer.tileLayer) {
+        var tileLayer = this.getTileLayer(usage);
+        this.layer.tileLayer = new tileLayer({
+          parent: this.layer,
+          rendererService: this.rendererService,
+          mapService: this.mapService,
+          layerService: this.layerService,
+          pickingService: this.pickingService,
+          transforms: source.transforms
+        });
+      }
+
+      return this.buildModels();
+    }
+  }, {
+    key: "clearModels",
+    value: function clearModels() {}
+  }, {
+    key: "buildModels",
+    value: function buildModels() {
+      return [];
+    }
+  }, {
+    key: "registerBuiltinAttributes",
+    value: function registerBuiltinAttributes() {//
+    }
+  }]);
+  return TileModel;
+}(_BaseModel2.default);
+
+exports.default = TileModel;

package/lib/tile/render/TileRenderService.js

@@ -0,0 +1,78 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TileRenderService = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+/**
+ * 主要用于瓦片图层队列的渲染
+ */
+var TileRenderService = /*#__PURE__*/function () {
+  function TileRenderService(rendererService) {
+    (0, _classCallCheck2.default)(this, TileRenderService);
+    this.rendererService = rendererService;
+  }
+
+  (0, _createClass2.default)(TileRenderService, [{
+    key: "render",
+    value: function render(layers) {
+      var _this = this;
+
+      layers.filter(function (layer) {
+        return layer.inited;
+      }).filter(function (layer) {
+        return layer.isVisible();
+      }).map(function (layer) {
+        layer.hooks.beforeRenderData.call();
+        layer.hooks.beforeRender.call();
+
+        if (layer.masks.length > 0) {
+          // 清除上一次的模版缓存
+          _this.rendererService.clear({
+            stencil: 0,
+            depth: 1,
+            framebuffer: null
+          });
+
+          layer.masks.map(function (m) {
+            m.hooks.beforeRenderData.call();
+            m.hooks.beforeRender.call();
+            m.render();
+            m.hooks.afterRender.call();
+          });
+        }
+
+        layer.render();
+        layer.hooks.afterRender.call();
+      });
+    }
+  }, {
+    key: "renderMask",
+    value: function renderMask(layer) {
+      if (layer.inited && layer.isVisible() && layer.masks.length > 0) {
+        layer.hooks.beforeRender.call();
+        this.rendererService.clear({
+          stencil: 0,
+          depth: 1,
+          framebuffer: null
+        });
+        layer.masks.map(function (m) {
+          m.hooks.beforeRender.call();
+          m.render();
+          m.hooks.afterRender.call();
+        });
+        layer.hooks.afterRender.call();
+      }
+    }
+  }]);
+  return TileRenderService;
+}();
+
+exports.TileRenderService = TileRenderService;

package/lib/tile/style/TileStyleService.js

@@ -0,0 +1,133 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TileStyleService = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
+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 _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _eventemitter = _interopRequireDefault(require("eventemitter3"));
+
+var _lodash = require("lodash");
+
+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 TileStyleService = /*#__PURE__*/function (_EventEmitter) {
+  (0, _inherits2.default)(TileStyleService, _EventEmitter);
+
+  var _super = _createSuper(TileStyleService);
+
+  function TileStyleService() {
+    var _this;
+
+    (0, _classCallCheck2.default)(this, TileStyleService);
+    _this = _super.call(this);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "checkConfigList", []);
+    _this.cacheConfig = new Map();
+    return _this;
+  }
+
+  (0, _createClass2.default)(TileStyleService, [{
+    key: "setConfig",
+    value: function setConfig(key, value) {
+      if (!this.checkConfigList.includes(key)) {
+        this.checkConfigList.push(key);
+      }
+
+      this.cacheConfig.set(key, value);
+    }
+  }, {
+    key: "removeConfig",
+    value: function removeConfig(key) {
+      var configIndex = this.checkConfigList.indexOf(key);
+
+      if (configIndex > -1) {
+        this.cacheConfig.delete(key);
+        this.checkConfigList.splice(configIndex, 1);
+      }
+    }
+  }, {
+    key: "checkConfig",
+    value: function checkConfig(layer) {
+      var _this2 = this;
+
+      if (!layer.inited) {
+        return;
+      }
+
+      var layerConfig = layer.getLayerConfig();
+      var updateConfigs = [];
+      this.checkConfigList.map(function (key) {
+        var cacheConfig = _this2.cacheConfig.get(key);
+
+        var currentConfig;
+
+        if (['color', 'size', 'shape'].includes(key)) {
+          var _layer$getAttribute;
+
+          currentConfig = (_layer$getAttribute = layer.getAttribute(key)) === null || _layer$getAttribute === void 0 ? void 0 : _layer$getAttribute.scale;
+        } else {
+          if (!(key in layerConfig)) {
+            return;
+          } // @ts-ignore
+
+
+          currentConfig = layerConfig[key];
+        }
+
+        if (!(0, _lodash.isEqual)(cacheConfig, currentConfig)) {
+          updateConfigs.push(key);
+
+          _this2.setConfig(key, currentConfig);
+        }
+      });
+
+      if (updateConfigs.length > 0) {
+        console.warn('tile config cache update!', updateConfigs);
+        this.emit('updateConfig', updateConfigs);
+      }
+    }
+  }, {
+    key: "getAttributeScale",
+    value: function getAttributeScale(layer, name) {
+      var attribute = layer.getAttribute(name);
+      var scaleValue = {
+        field: undefined,
+        values: undefined,
+        callback: undefined
+      };
+
+      if (attribute && attribute.scale) {
+        var _attribute$scale = attribute.scale,
+            field = _attribute$scale.field,
+            values = _attribute$scale.values,
+            callback = _attribute$scale.callback;
+        scaleValue.field = field;
+        scaleValue.values = values;
+        scaleValue.callback = callback;
+      }
+
+      return scaleValue;
+    }
+  }]);
+  return TileStyleService;
+}(_eventemitter.default);
+
+exports.TileStyleService = TileStyleService;

package/lib/tile/style/constants.js

@@ -3,13 +3,24 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.ProxyFuncs = void 0;
-// TileLayer 需要代理的子图层的方法
-// 一般都是在 BaseLayer 上的方法
-var ProxyFuncs = [
+exports.styles = exports.Attributes = void 0;
+
 /**
- * 1. 需要作用到所属子图层才会生效的方法
- * 2. 不需要主动重新创建 model 的方法
+ * 瓦片图层的样式
  */
-'shape', 'color', 'size', 'style', 'animate', 'filter', 'rotate', 'scale', 'setBlend', 'setSelect', 'setActive'];
-exports.ProxyFuncs = ProxyFuncs;
+var Attributes = ['size', 'color', 'shape'];
+exports.Attributes = Attributes;
+var common = ['opacity', 'zIndex'];
+var rasterLayer = ['mask', 'rampColors', 'domain', 'clampHigh', 'clampLow', 'pixelConstant', 'pixelConstantR', 'pixelConstantG', 'pixelConstantB', 'pixelConstantRGB'].concat(common);
+var pointLayer = ['stroke', 'strokeWidth', 'strokeOpacity', 'color', 'shape', 'size'].concat(common);
+var lineLayer = ['stroke', 'strokeWidth', 'strokeOpacity', 'color', 'shape', 'size'].concat(common);
+var polygonLayer = ['color', 'shape'].concat(common);
+var styles = {
+  'PointLayer': pointLayer,
+  'LineLayer': lineLayer,
+  'PolygonLayer': polygonLayer,
+  'RasterLayer': rasterLayer,
+  'MaskLayer': [],
+  'TileDebugLayer': []
+};
+exports.styles = styles;

package/lib/tile/style/utils.js

@@ -5,10 +5,37 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.getDefaultStyleAttributeField = getDefaultStyleAttributeField;
+exports.getLayerShape = getLayerShape;
+exports.parseScaleValue = parseScaleValue;
+exports.setScale = setScale;
+exports.setStyleAttributeField = setStyleAttributeField;
 exports.updateLayersConfig = updateLayersConfig;
+exports.updateTexture = updateTexture;
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
+var _l7Utils = require("@antv/l7-utils");
+
+function updateTexture(config, layers, rendererService) {
+  var createTexture2D = rendererService.createTexture2D;
+  var imageData = (0, _l7Utils.generateColorRamp)(config);
+  var texture = createTexture2D({
+    data: imageData.data,
+    width: imageData.width,
+    height: imageData.height,
+    flipY: false
+  });
+  layers.map(function (layer) {
+    layer.updateLayerConfig({
+      colorTexture: texture
+    });
+  });
+  return texture;
+}
+
 function updateLayersConfig(layers, key, value) {
   layers.map(function (layer) {
     if (key === 'mask') {
@@ -20,4 +47,117 @@ function updateLayersConfig(layers, key, value) {
       layer.updateLayerConfig((0, _defineProperty2.default)({}, key, value));
     }
   });
+}
+
+function setStyleAttributeField(layer, parent, style, value) {
+  if (Array.isArray(value)) {
+    // @ts-ignore
+    layer[style].apply(layer, (0, _toConsumableArray2.default)(value));
+    return;
+  }
+
+  if (typeof value === 'string') {
+    layer[style](value);
+    return;
+  }
+
+  var defaultValue = getDefaultStyleAttributeField(layer, parent.type, style);
+
+  if (!value) {
+    layer[style](defaultValue);
+    return layer;
+  }
+
+  var params = parseScaleValue(value, style);
+
+  if (params.length === 0) {
+    layer[style](defaultValue);
+  } else {
+    // @ts-ignore
+    layer[style].apply(layer, (0, _toConsumableArray2.default)(params));
+  }
+}
+
+function getDefaultStyleAttributeField(layer, type, style) {
+  switch (style) {
+    case 'size':
+      return 1;
+
+    case 'color':
+      return '#fff';
+
+    case 'shape':
+      return getLayerShape(type, layer);
+
+    default:
+      return '';
+  }
+}
+
+function getLayerShape(layerType, layer) {
+  var _layerShape$scale;
+
+  var layerShape = layer.getAttribute('shape');
+
+  if (layerShape && (_layerShape$scale = layerShape.scale) !== null && _layerShape$scale !== void 0 && _layerShape$scale.field) {
+    var _layerShape$scale2;
+
+    if (((_layerShape$scale2 = layerShape.scale) === null || _layerShape$scale2 === void 0 ? void 0 : _layerShape$scale2.values) === 'text') {
+      return [layerShape.scale.field, layerShape.scale.values];
+    }
+
+    return layerShape.scale.field;
+  }
+
+  switch (layerType) {
+    case 'PolygonLayer':
+      return 'fill';
+
+    case 'LineLayer':
+      return 'tileline';
+
+    case 'PointLayer':
+      return 'circle';
+
+    case 'RasterLayer':
+      return 'image';
+
+    default:
+      return '';
+  }
+}
+
+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 [];
+}
+
+function setScale(layer, parent) {
+  var scaleOptions = parent.tileLayer.scaleField;
+  var scaleKeys = Object.keys(scaleOptions);
+  scaleKeys.map(function (key) {
+    layer.scale(key, scaleOptions[key]);
+  });
 }