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

package/es/plugins/DataMappingPlugin.js

@@ -0,0 +1,345 @@
+import _objectSpread from "@babel/runtime/helpers/objectSpread2";
+import _initializerDefineProperty from "@babel/runtime/helpers/initializerDefineProperty";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _applyDecoratedDescriptor from "@babel/runtime/helpers/applyDecoratedDescriptor";
+import _initializerWarningHelper from "@babel/runtime/helpers/initializerWarningHelper";
+
+var _dec, _dec2, _dec3, _dec4, _class, _class2, _descriptor, _descriptor2, _descriptor3;
+
+import { TYPES } from '@antv/l7-core';
+import { Version } from '@antv/l7-maps';
+import { isColor, normalize, rgb2arr } from '@antv/l7-utils';
+import { inject, injectable } from 'inversify';
+import { cloneDeep } from 'lodash';
+import 'reflect-metadata';
+var DataMappingPlugin = (_dec = injectable(), _dec2 = inject(TYPES.IGlobalConfigService), _dec3 = inject(TYPES.IMapService), _dec4 = inject(TYPES.IFontService), _dec(_class = (_class2 = /*#__PURE__*/function () {
+  function DataMappingPlugin() {
+    _classCallCheck(this, DataMappingPlugin);
+
+    _initializerDefineProperty(this, "configService", _descriptor, this);
+
+    _initializerDefineProperty(this, "mapService", _descriptor2, this);
+
+    _initializerDefineProperty(this, "fontService", _descriptor3, this);
+  }
+
+  _createClass(DataMappingPlugin, [{
+    key: "apply",
+    value: function apply(layer, _ref) {
+      var _this = this;
+
+      var styleAttributeService = _ref.styleAttributeService;
+      layer.hooks.init.tap('DataMappingPlugin', function () {
+        // 初始化重新生成 map
+        var source = layer.getSource();
+
+        if (source.inited) {
+          _this.generateMaping(layer, {
+            styleAttributeService: styleAttributeService
+          });
+        } else {
+          source.once('sourceUpdate', function () {
+            _this.generateMaping(layer, {
+              styleAttributeService: styleAttributeService
+            });
+          });
+        } // this.generateMaping(layer, { styleAttributeService });
+
+      });
+      layer.hooks.beforeRenderData.tap('DataMappingPlugin', function () {
+        layer.dataState.dataMappingNeedUpdate = false;
+        var source = layer.getSource();
+
+        if (source.inited) {
+          _this.generateMaping(layer, {
+            styleAttributeService: styleAttributeService
+          });
+        } else {
+          source.once('sourceUpdate', function () {
+            _this.generateMaping(layer, {
+              styleAttributeService: styleAttributeService
+            });
+          });
+        } // this.generateMaping(layer, { styleAttributeService });
+
+
+        return true;
+      }); // remapping before render
+
+      layer.hooks.beforeRender.tap('DataMappingPlugin', function () {
+        var source = layer.getSource();
+
+        if (layer.layerModelNeedUpdate || !source || !source.inited) {
+          return;
+        }
+
+        var bottomColor = layer.getBottomColor();
+        var attributes = styleAttributeService.getLayerStyleAttributes() || [];
+        var filter = styleAttributeService.getLayerStyleAttribute('filter');
+        var dataArray = source.data.dataArray;
+        var attributesToRemapping = attributes.filter(function (attribute) {
+          return attribute.needRemapping;
+        } // 如果filter变化
+        );
+        var filterData = dataArray; // 数据过滤完 再执行数据映射
+
+        if (filter !== null && filter !== void 0 && filter.needRemapping && filter !== null && filter !== void 0 && filter.scale) {
+          filterData = dataArray.filter(function (record) {
+            return _this.applyAttributeMapping(filter, record, bottomColor)[0];
+          });
+        }
+
+        if (attributesToRemapping.length) {
+          // 过滤数据
+          if (filter !== null && filter !== void 0 && filter.needRemapping) {
+            layer.setEncodedData(_this.mapping(layer, attributes, filterData, undefined, bottomColor));
+            filter.needRemapping = false;
+          } else {
+            layer.setEncodedData(_this.mapping(layer, attributesToRemapping, filterData, layer.getEncodedData(), bottomColor));
+          } // 处理文本更新
+
+
+          layer.emit('remapping', null);
+        }
+      });
+    }
+  }, {
+    key: "generateMaping",
+    value: function generateMaping(layer, _ref2) {
+      var _this2 = this;
+
+      var styleAttributeService = _ref2.styleAttributeService;
+      var bottomColor = layer.getBottomColor();
+      var attributes = styleAttributeService.getLayerStyleAttributes() || [];
+      var filter = styleAttributeService.getLayerStyleAttribute('filter');
+      var dataArray = layer.getSource().data.dataArray;
+      var filterData = dataArray; // 数据过滤完 再执行数据映射
+
+      if (filter !== null && filter !== void 0 && filter.scale) {
+        filterData = dataArray.filter(function (record) {
+          return _this2.applyAttributeMapping(filter, record, bottomColor)[0];
+        });
+      }
+
+      layer.setEncodedData(this.mapping(layer, attributes, filterData, undefined, bottomColor)); // 对外暴露事件
+
+      layer.emit('dataUpdate', null);
+    }
+  }, {
+    key: "getArrowPoints",
+    value: function getArrowPoints(p1, p2) {
+      var dir = [p2[0] - p1[0], p2[1] - p1[1]];
+      var normalizeDir = normalize(dir);
+      var arrowPoint = [p1[0] + normalizeDir[0] * 0.0001, p1[1] + normalizeDir[1] * 0.0001];
+      return arrowPoint;
+    }
+  }, {
+    key: "mapping",
+    value: function mapping(layer, attributes, data, predata, minimumColor) {
+      var _this3 = this;
+
+      var _ref3 = layer.getLayerConfig(),
+          _ref3$arrow = _ref3.arrow,
+          arrow = _ref3$arrow === void 0 ? {
+        enable: false
+      } : _ref3$arrow;
+
+      var mappedData = data.map(function (record, i) {
+        var preRecord = predata ? predata[i] : {};
+
+        var encodeRecord = _objectSpread({
+          id: record._id,
+          coordinates: record.coordinates
+        }, preRecord);
+
+        attributes.filter(function (attribute) {
+          return attribute.scale !== undefined;
+        }).forEach(function (attribute) {
+          // console.log('record', record)
+          var values = _this3.applyAttributeMapping(attribute, record, minimumColor); // console.log('values', values)
+
+
+          attribute.needRemapping = false; // TODO: 支持每个属性配置 postprocess
+
+          if (attribute.name === 'color') {
+            // console.log('attribute', attribute)
+            values = values.map(function (c) {
+              return rgb2arr(c);
+            });
+          } // @ts-ignore
+
+
+          encodeRecord[attribute.name] = Array.isArray(values) && values.length === 1 ? values[0] : values; // 增加对 layer/text/iconfont unicode 映射的解析
+
+          if (attribute.name === 'shape') {
+            encodeRecord.shape = _this3.fontService.getIconFontKey(encodeRecord[attribute.name]);
+          }
+        });
+
+        if (arrow.enable && (encodeRecord.shape === 'line' || encodeRecord.shape === 'halfLine')) {
+          // 只有在线图层且支持配置箭头的时候进行插入顶点的处理
+          var coords = encodeRecord.coordinates;
+
+          var arrowPoint = _this3.getArrowPoints(coords[0], coords[1]);
+
+          encodeRecord.coordinates.splice(1, 0, arrowPoint, arrowPoint);
+        }
+
+        return encodeRecord;
+      }); // console.log('mappedData', mappedData)
+      // 调整数据兼容 Amap2.0
+
+      this.adjustData2Amap2Coordinates(mappedData, layer); // 调整数据兼容 SimpleCoordinates
+
+      this.adjustData2SimpleCoordinates(mappedData);
+      return mappedData;
+    }
+  }, {
+    key: "adjustData2Amap2Coordinates",
+    value: function adjustData2Amap2Coordinates(mappedData, layer) {
+      var _this4 = this;
+
+      // 根据地图的类型判断是否需要对点位数据进行处理, 若是高德2.0则需要对坐标进行相对偏移
+      if (mappedData.length > 0 && this.mapService.version === Version['GAODE2.x']) {
+        var layerCenter = this.getLayerCenter(layer);
+
+        if (typeof mappedData[0].coordinates[0] === 'number') {
+          // 单个的点数据
+          // @ts-ignore
+          mappedData // TODO: 避免经纬度被重复计算导致坐标位置偏移
+          .filter(function (d) {
+            return !d.originCoordinates;
+          }).map(function (d) {
+            d.version = Version['GAODE2.x']; // @ts-ignore
+
+            d.originCoordinates = cloneDeep(d.coordinates); // 为了兼容高德1.x 需要保存一份原始的经纬度坐标数据（许多上层逻辑依赖经纬度数据）
+            // @ts-ignore
+            // d.coordinates = this.mapService.lngLatToCoord(d.coordinates);
+
+            d.coordinates = _this4.mapService.lngLatToCoordByLayer(d.coordinates, layerCenter);
+          });
+        } else {
+          // 连续的线、面数据
+          // @ts-ignore
+          mappedData // TODO: 避免经纬度被重复计算导致坐标位置偏移
+          .filter(function (d) {
+            return !d.originCoordinates;
+          }).map(function (d) {
+            d.version = Version['GAODE2.x']; // @ts-ignore
+
+            d.originCoordinates = cloneDeep(d.coordinates); // 为了兼容高德1.x 需要保存一份原始的经纬度坐标数据（许多上层逻辑依赖经纬度数据）
+            // @ts-ignore
+            // d.coordinates = this.mapService.lngLatToCoords(d.coordinates);
+
+            d.coordinates = _this4.mapService.lngLatToCoordsByLayer(d.coordinates, layerCenter);
+          });
+        }
+      }
+    }
+  }, {
+    key: "getLayerCenter",
+    value: function getLayerCenter(layer) {
+      var source = layer.getSource();
+      return source.center;
+    }
+  }, {
+    key: "adjustData2SimpleCoordinates",
+    value: function adjustData2SimpleCoordinates(mappedData) {
+      var _this5 = this;
+
+      if (mappedData.length > 0 && this.mapService.version === Version.SIMPLE) {
+        mappedData.map(function (d) {
+          if (!d.simpleCoordinate) {
+            d.coordinates = _this5.unProjectCoordinates(d.coordinates);
+            d.simpleCoordinate = true;
+          }
+        });
+      }
+    }
+  }, {
+    key: "unProjectCoordinates",
+    value: function unProjectCoordinates(coordinates) {
+      var _this6 = this;
+
+      if (typeof coordinates[0] === 'number') {
+        return this.mapService.simpleMapCoord.unproject(coordinates);
+      }
+
+      if (coordinates[0] && coordinates[0][0] instanceof Array) {
+        // @ts-ignore
+        var coords = [];
+        coordinates.map(function (coord) {
+          // @ts-ignore
+          var c1 = [];
+          coord.map(function (co) {
+            c1.push(_this6.mapService.simpleMapCoord.unproject(co));
+          }); // @ts-ignore
+
+          coords.push(c1);
+        }); // @ts-ignore
+
+        return coords;
+      } else {
+        // @ts-ignore
+        var _coords = []; // @ts-ignore
+
+        coordinates.map(function (coord) {
+          _coords.push(_this6.mapService.simpleMapCoord.unproject(coord));
+        }); // @ts-ignore
+
+        return _coords;
+      }
+    }
+  }, {
+    key: "applyAttributeMapping",
+    value: function applyAttributeMapping(attribute, record, minimumColor) {
+      var _attribute$scale;
+
+      if (!attribute.scale) {
+        return [];
+      }
+
+      var scalers = (attribute === null || attribute === void 0 ? void 0 : (_attribute$scale = attribute.scale) === null || _attribute$scale === void 0 ? void 0 : _attribute$scale.scalers) || [];
+      var params = [];
+      scalers.forEach(function (_ref4) {
+        var _attribute$scale2;
+
+        var field = _ref4.field;
+
+        if (record.hasOwnProperty(field) || ((_attribute$scale2 = attribute.scale) === null || _attribute$scale2 === void 0 ? void 0 : _attribute$scale2.type) === 'variable') {
+          // TODO:多字段，常量
+          params.push(record[field]);
+        }
+      }); // console.log('params', params)
+      // console.log('attribute', attribute)
+
+      var mappingResult = attribute.mapping ? attribute.mapping(params) : [];
+
+      if (attribute.name === 'color' && !isColor(mappingResult[0])) {
+        return [minimumColor];
+      }
+
+      return mappingResult; // return attribute.mapping ? attribute.mapping(params) : [];
+    }
+  }]);
+
+  return DataMappingPlugin;
+}(), (_descriptor = _applyDecoratedDescriptor(_class2.prototype, "configService", [_dec2], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+}), _descriptor2 = _applyDecoratedDescriptor(_class2.prototype, "mapService", [_dec3], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+}), _descriptor3 = _applyDecoratedDescriptor(_class2.prototype, "fontService", [_dec4], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+})), _class2)) || _class);
+export { DataMappingPlugin as default };

package/es/plugins/DataSourcePlugin.d.ts

@@ -0,0 +1,7 @@
+import { ILayer, ILayerPlugin, IMapService } from '@antv/l7-core';
+import 'reflect-metadata';
+export default class DataSourcePlugin implements ILayerPlugin {
+    protected mapService: IMapService;
+    apply(layer: ILayer): void;
+    private updateClusterData;
+}

package/es/plugins/DataSourcePlugin.js

@@ -0,0 +1,89 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+
+var _dec, _class;
+
+import { TYPES } from '@antv/l7-core';
+import Source, { DEFAULT_DATA, DEFAULT_PARSER, DEFAULT_SOURCE } from '@antv/l7-source';
+import { injectable } from 'inversify';
+import 'reflect-metadata';
+var DataSourcePlugin = (_dec = injectable(), _dec(_class = /*#__PURE__*/function () {
+  function DataSourcePlugin() {
+    _classCallCheck(this, DataSourcePlugin);
+  }
+
+  _createClass(DataSourcePlugin, [{
+    key: "apply",
+    value: function apply(layer) {
+      var _this = this;
+
+      this.mapService = layer.getContainer().get(TYPES.IMapService);
+      layer.hooks.init.tap('DataSourcePlugin', function () {
+        var source = layer.getSource();
+
+        if (!source) {
+          // TODO: 允许用户不使用 layer 的 source 方法，在这里传入一个默认的替换的默认数据
+          var defaultSourceConfig = DEFAULT_SOURCE[layer.type] || {
+            data: DEFAULT_DATA,
+            options: DEFAULT_PARSER
+          };
+
+          var _ref = layer.sourceOption || defaultSourceConfig,
+              data = _ref.data,
+              options = _ref.options;
+
+          source = new Source(data, options);
+          layer.setSource(source);
+        }
+
+        if (source.inited) {
+          _this.updateClusterData(layer);
+        } else {
+          source.once('sourceUpdate', function () {
+            _this.updateClusterData(layer); // TODO: layer.hooks.init.call();
+
+          });
+        } // this.updateClusterData(layer);
+
+      }); // 检测数据是否需要更新
+
+      layer.hooks.beforeRenderData.tap('DataSourcePlugin', function () {
+        var neeUpdateCluster = _this.updateClusterData(layer);
+
+        var dataSourceNeedUpdate = layer.dataState.dataSourceNeedUpdate;
+        layer.dataState.dataSourceNeedUpdate = false;
+        return neeUpdateCluster || dataSourceNeedUpdate;
+      });
+    }
+  }, {
+    key: "updateClusterData",
+    value: function updateClusterData(layer) {
+      var source = layer.getSource();
+      var cluster = source.cluster;
+      var _source$clusterOption = source.clusterOptions.zoom,
+          zoom = _source$clusterOption === void 0 ? 0 : _source$clusterOption;
+      var newZoom = this.mapService.getZoom() - 1;
+      var dataSourceNeedUpdate = layer.dataState.dataSourceNeedUpdate;
+
+      if (cluster && dataSourceNeedUpdate) {
+        // 数据发生更新
+        source.updateClusterData(Math.floor(newZoom));
+      } // 如果 dataSource 有更新，跳过 zoom 的判断，直接更新一次
+
+
+      if (cluster && Math.abs(layer.clusterZoom - newZoom) >= 1) {
+        if (zoom !== Math.floor(newZoom)) {
+          source.updateClusterData(Math.floor(newZoom));
+        }
+
+        layer.clusterZoom = newZoom;
+        return true;
+      }
+
+      return false;
+    }
+  }]);
+
+  return DataSourcePlugin;
+}()) || _class);
+export { DataSourcePlugin as default };

package/es/plugins/FeatureScalePlugin.d.ts

@@ -0,0 +1,25 @@
+import { ILayer, ILayerPlugin, IStyleAttributeService } from '@antv/l7-core';
+import 'reflect-metadata';
+/**
+ * 根据 Source 原始数据为指定字段创建 Scale，保存在 StyleAttribute 上，供下游插件使用
+ */
+export default class FeatureScalePlugin implements ILayerPlugin {
+    private readonly configService;
+    private scaleCache;
+    private scaleOptions;
+    apply(layer: ILayer, { styleAttributeService, }: {
+        styleAttributeService: IStyleAttributeService;
+    }): void;
+    private isNumber;
+    private caculateScalesForAttributes;
+    /**
+     * @example
+     * 'w*h' => ['w', 'h']
+     * 'w' => ['w']
+     */
+    private parseFields;
+    private createScale;
+    private getDefaultType;
+    private createScaleConfig;
+    private createDefaultScale;
+}