@antv/l7-layers 2.25.7 → 2.25.10

package/es/plugins/DataMappingPlugin.js

@@ -0,0 +1,226 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import { IDebugLog, ILayerStage } from '@antv/l7-core';
+import { normalize, rgb2arr } from '@antv/l7-utils';
+export default class DataMappingPlugin {
+  constructor() {
+    _defineProperty(this, "mapService", void 0);
+    _defineProperty(this, "fontService", void 0);
+  }
+  apply(layer, {
+    styleAttributeService,
+    mapService,
+    fontService
+  }) {
+    var _this = this;
+    this.mapService = mapService;
+    this.fontService = fontService;
+    layer.hooks.init.tapPromise('DataMappingPlugin', /*#__PURE__*/_asyncToGenerator(function* () {
+      layer.log(IDebugLog.MappingStart, ILayerStage.INIT);
+      // 初始化重新生成 map
+      _this.generateMaping(layer, {
+        styleAttributeService
+      });
+      layer.log(IDebugLog.MappingEnd, ILayerStage.INIT);
+    }));
+    layer.hooks.beforeRenderData.tapPromise('DataMappingPlugin', /*#__PURE__*/function () {
+      var _ref2 = _asyncToGenerator(function* (flag) {
+        if (!flag) {
+          return flag;
+        }
+        layer.dataState.dataMappingNeedUpdate = false;
+        layer.log(IDebugLog.MappingStart, ILayerStage.UPDATE);
+        const mappingResult = _this.generateMaping(layer, {
+          styleAttributeService
+        });
+        layer.log(IDebugLog.MappingEnd, ILayerStage.UPDATE);
+        return mappingResult;
+      });
+      return function (_x) {
+        return _ref2.apply(this, arguments);
+      };
+    }());
+
+    // remapping before render
+    layer.hooks.beforeRender.tap('DataMappingPlugin', () => {
+      const source = layer.getSource();
+      if (layer.layerModelNeedUpdate || !source || !source.inited) {
+        return;
+      }
+      const attributes = styleAttributeService.getLayerStyleAttributes() || [];
+      const filter = styleAttributeService.getLayerStyleAttribute('filter');
+      const {
+        dataArray
+      } = source.data;
+      // TODO 数据为空的情况
+      if (Array.isArray(dataArray) && dataArray.length === 0) {
+        return;
+      }
+      const attributesToRemapping = attributes.filter(attribute => attribute.needRemapping // 如果filter变化
+      );
+      let filterData = dataArray;
+      // 数据过滤完 再执行数据映射
+      if (filter !== null && filter !== void 0 && filter.needRemapping && filter !== null && filter !== void 0 && filter.scale) {
+        filterData = dataArray.filter(record => {
+          return this.applyAttributeMapping(filter, record)[0];
+        });
+      }
+      if (attributesToRemapping.length) {
+        // 过滤数据
+        const encodeData = this.mapping(layer, attributesToRemapping, filterData, layer.getEncodedData() // TODO 优化
+        );
+        layer.setEncodedData(encodeData);
+      }
+
+      // 处理文本更新，更新文字形状
+      // layer.emit('remapping', null);
+    });
+  }
+  generateMaping(layer, {
+    styleAttributeService
+  }) {
+    const attributes = styleAttributeService.getLayerStyleAttributes() || [];
+    const filter = styleAttributeService.getLayerStyleAttribute('filter');
+    const {
+      dataArray
+    } = layer.getSource().data;
+
+    // 优化：合并过滤和准备阶段为单次遍历
+    const usedAttributes = attributes.filter(attribute => attribute.scale !== undefined).filter(attribute => attribute.name !== 'filter');
+    const hasFilter = filter === null || filter === void 0 ? void 0 : filter.scale;
+
+    // 第一阶段：过滤原始数据（需要在 processData 之前）
+    let filterData = [];
+    if (hasFilter) {
+      for (let i = 0; i < dataArray.length; i++) {
+        const record = dataArray[i];
+        const filterResult = this.applyAttributeMapping(filter, record);
+        if (filterResult[0]) {
+          filterData.push(record);
+        }
+      }
+    } else {
+      filterData = dataArray;
+    }
+
+    // Tip: layer 对数据做处理（需要处理原始数据格式）
+    // 数据处理 在数据进行 mapping 生成 encodeData 之前对数据进行处理
+    const processedFilterData = layer.processData(filterData);
+
+    // 第二阶段：数据映射
+    const encodeData = this.mapping(layer, usedAttributes, processedFilterData, undefined);
+
+    // 重置属性状态
+    attributes.forEach(attribute => {
+      attribute.needRemapping = false;
+    });
+
+    // 调整数据兼容 SimpleCoordinates
+    this.adjustData2SimpleCoordinates(encodeData);
+    layer.setEncodedData(encodeData);
+
+    // 对外暴露事件
+    layer.emit('dataUpdate', null);
+    return true;
+  }
+  mapping(layer, attributes, data, predata) {
+    const usedAttributes = attributes.filter(attribute => attribute.scale !== undefined).filter(attribute => attribute.name !== 'filter');
+    const mappedData = data.map((record, i) => {
+      const preRecord = predata ? predata[i] : {};
+      const encodeRecord = _objectSpread({
+        id: record._id,
+        coordinates: record.coordinates
+      }, preRecord);
+      usedAttributes.forEach(attribute => {
+        let values = this.applyAttributeMapping(attribute, record);
+        // TODO: 支持每个属性配置 postprocess}
+        if (attribute.name === 'color' || attribute.name === 'stroke') {
+          values = values.map(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 = this.fontService.getIconFontKey(encodeRecord[attribute.name]);
+        }
+      });
+      return encodeRecord;
+    });
+    attributes.forEach(attribute => {
+      attribute.needRemapping = false;
+    });
+
+    // 调整数据兼容 SimpleCoordinates
+    this.adjustData2SimpleCoordinates(mappedData);
+    return mappedData;
+  }
+  adjustData2SimpleCoordinates(mappedData) {
+    if (mappedData.length > 0 && this.mapService.version === 'SIMPLE') {
+      mappedData.map(d => {
+        if (!d.simpleCoordinate) {
+          d.coordinates = this.unProjectCoordinates(d.coordinates);
+          d.simpleCoordinate = true;
+        }
+      });
+    }
+  }
+  unProjectCoordinates(coordinates) {
+    if (typeof coordinates[0] === 'number') {
+      return this.mapService.simpleMapCoord.unproject(coordinates);
+    }
+    if (coordinates[0] && coordinates[0][0] instanceof Array) {
+      // @ts-ignore
+      const coords = [];
+      coordinates.map(coord => {
+        // @ts-ignore
+        const c1 = [];
+        coord.map(co => {
+          c1.push(this.mapService.simpleMapCoord.unproject(co));
+        });
+        // @ts-ignore
+        coords.push(c1);
+      });
+      // @ts-ignore
+      return coords;
+    } else {
+      // @ts-ignore
+      const coords = [];
+      // @ts-ignore
+      coordinates.map(coord => {
+        coords.push(this.mapService.simpleMapCoord.unproject(coord));
+      });
+      // @ts-ignore
+      return coords;
+    }
+  }
+  applyAttributeMapping(attribute, record) {
+    var _attribute$scale;
+    if (!attribute.scale) {
+      return [];
+    }
+    const scalers = (attribute === null || attribute === void 0 || (_attribute$scale = attribute.scale) === null || _attribute$scale === void 0 ? void 0 : _attribute$scale.scalers) || [];
+    const params = [];
+    scalers.forEach(({
+      field
+    }) => {
+      var _attribute$scale2;
+      if (record.hasOwnProperty(field) || ((_attribute$scale2 = attribute.scale) === null || _attribute$scale2 === void 0 ? void 0 : _attribute$scale2.type) === 'variable') {
+        // TODO:多字段，常量
+        params.push(record[field]);
+      }
+    });
+    const mappingResult = attribute.mapping ? attribute.mapping(params) : [];
+    return mappingResult;
+    // return attribute.mapping ? attribute.mapping(params) : [];
+  }
+  getArrowPoints(p1, p2) {
+    const dir = [p2[0] - p1[0], p2[1] - p1[1]];
+    const normalizeDir = normalize(dir);
+    const arrowPoint = [p1[0] + normalizeDir[0] * 0.0001, p1[1] + normalizeDir[1] * 0.0001];
+    return arrowPoint;
+  }
+}

package/es/plugins/DataSourcePlugin.d.ts

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

package/es/plugins/DataSourcePlugin.js

@@ -0,0 +1,75 @@
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import { IDebugLog, ILayerStage } from '@antv/l7-core';
+import Source from '@antv/l7-source';
+export default class DataSourcePlugin {
+  constructor() {
+    _defineProperty(this, "mapService", void 0);
+  }
+  apply(layer) {
+    var _this = this;
+    this.mapService = layer.getContainer().mapService;
+    layer.hooks.init.tapPromise('DataSourcePlugin', /*#__PURE__*/_asyncToGenerator(function* () {
+      layer.log(IDebugLog.SourceInitStart, ILayerStage.INIT);
+      let source = layer.getSource();
+      if (!source) {
+        // Tip: 用户没有传入 source 的时候使用图层的默认数据
+        const {
+          data,
+          options
+        } = layer.sourceOption || layer.defaultSourceConfig;
+        source = new Source(data, options);
+        layer.setSource(source);
+      }
+      if (source.inited) {
+        _this.updateClusterData(layer);
+        layer.log(IDebugLog.SourceInitEnd, ILayerStage.INIT);
+      } else {
+        yield new Promise(resolve => {
+          source.on('update', e => {
+            if (e.type === 'inited') {
+              _this.updateClusterData(layer);
+              layer.log(IDebugLog.SourceInitEnd, ILayerStage.INIT);
+            }
+            resolve(null);
+          });
+        });
+      }
+    }));
+
+    // 检测数据是否需要更新
+    layer.hooks.beforeRenderData.tapPromise('DataSourcePlugin', /*#__PURE__*/_asyncToGenerator(function* () {
+      const neeUpdateCluster = _this.updateClusterData(layer);
+      const dataSourceNeedUpdate = layer.dataState.dataSourceNeedUpdate;
+      layer.dataState.dataSourceNeedUpdate = false;
+      const needScale = neeUpdateCluster || dataSourceNeedUpdate;
+      return needScale;
+    }));
+  }
+  updateClusterData(layer) {
+    // Tip: 矢量瓦片不需要进行聚合操作
+    if (layer.isTileLayer || layer.tileLayer || !layer.getSource()) {
+      return false;
+    }
+    const source = layer.getSource();
+    const cluster = source.cluster;
+    const {
+      zoom = 0
+    } = source.clusterOptions;
+    const newZoom = this.mapService.getZoom() - 1;
+    const 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;
+  }
+}

package/es/plugins/FeatureScalePlugin.d.ts

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

package/es/plugins/FeatureScalePlugin.js

@@ -0,0 +1,295 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import { IDebugLog, ILayerStage, ScaleTypes, StyleScaleType } from '@antv/l7-core';
+import { interpolateRgbBasis, lodashUtil } from '@antv/l7-utils';
+import identity from "../utils/identityScale";
+import { scaleDiverging, scaleLinear, scaleLog, scaleOrdinal, scalePow, scaleQuantile, scaleQuantize, scaleSequential, scaleThreshold, scaleTime } from "../utils/scale";
+const {
+  isNil,
+  isString,
+  uniq,
+  extent
+} = lodashUtil;
+const dateRegex = /^(?:(?!0000)[0-9]{4}([-/.]+)(?:(?:0?[1-9]|1[0-2])\1(?:0?[1-9]|1[0-9]|2[0-8])|(?:0?[13-9]|1[0-2])\1(?:29|30)|(?:0?[13578]|1[02])\1(?:31))|(?:[0-9]{2}(?:0[48]|[2468][048]|[13579][26])|(?:0[48]|[2468][048]|[13579][26])00)([-/.]?)0?2\2(?:29))(\s+([01]|([01][0-9]|2[0-3])):([0-9]|[0-5][0-9]):([0-9]|[0-5][0-9]))?$/;
+const scaleMap = {
+  [ScaleTypes.LINEAR]: scaleLinear,
+  [ScaleTypes.POWER]: scalePow,
+  [ScaleTypes.LOG]: scaleLog,
+  [ScaleTypes.IDENTITY]: identity,
+  [ScaleTypes.SEQUENTIAL]: scaleSequential,
+  [ScaleTypes.TIME]: scaleTime,
+  [ScaleTypes.QUANTILE]: scaleQuantile,
+  [ScaleTypes.QUANTIZE]: scaleQuantize,
+  [ScaleTypes.THRESHOLD]: scaleThreshold,
+  [ScaleTypes.CAT]: scaleOrdinal,
+  [ScaleTypes.DIVERGING]: scaleDiverging
+};
+/**
+ * 根据 Source 原始数据为指定字段创建 Scale，保存在 StyleAttribute 上，供下游插件使用
+ */
+export default class FeatureScalePlugin {
+  constructor() {
+    _defineProperty(this, "scaleOptions", {});
+  }
+  apply(layer, {
+    styleAttributeService
+  }) {
+    var _this = this;
+    layer.hooks.init.tapPromise('FeatureScalePlugin', /*#__PURE__*/_asyncToGenerator(function* () {
+      var _layer$getSource;
+      layer.log(IDebugLog.ScaleInitStart, ILayerStage.INIT);
+      _this.scaleOptions = layer.getScaleOptions();
+      const attributes = styleAttributeService.getLayerStyleAttributes();
+      const dataArray = (_layer$getSource = layer.getSource()) === null || _layer$getSource === void 0 ? void 0 : _layer$getSource.data.dataArray;
+      if (Array.isArray(dataArray) && dataArray.length === 0) {
+        return;
+      } else {
+        _this.caculateScalesForAttributes(attributes || [], dataArray);
+      }
+      layer.log(IDebugLog.ScaleInitEnd, ILayerStage.INIT);
+    }));
+
+    // 检测数据是否需要更新
+    layer.hooks.beforeRenderData.tapPromise('FeatureScalePlugin', /*#__PURE__*/function () {
+      var _ref2 = _asyncToGenerator(function* (flag) {
+        if (!flag) {
+          return flag;
+        }
+        layer.log(IDebugLog.ScaleInitStart, ILayerStage.UPDATE);
+        _this.scaleOptions = layer.getScaleOptions();
+        const attributes = styleAttributeService.getLayerStyleAttributes();
+        const dataArray = layer.getSource().data.dataArray;
+        if (Array.isArray(dataArray) && dataArray.length === 0) {
+          return true;
+        }
+        _this.caculateScalesForAttributes(attributes || [], dataArray);
+        layer.log(IDebugLog.ScaleInitEnd, ILayerStage.UPDATE);
+        layer.layerModelNeedUpdate = true;
+        return true;
+      });
+      return function (_x) {
+        return _ref2.apply(this, arguments);
+      };
+    }());
+    layer.hooks.beforeRender.tap('FeatureScalePlugin', () => {
+      if (layer.layerModelNeedUpdate) {
+        return;
+      }
+      this.scaleOptions = layer.getScaleOptions();
+      const attributes = styleAttributeService.getLayerStyleAttributes();
+      const dataArray = layer.getSource().data.dataArray;
+      if (Array.isArray(dataArray) && dataArray.length === 0) {
+        return;
+      }
+      if (attributes) {
+        const attributesToRescale = attributes.filter(attribute => attribute.needRescale);
+        if (attributesToRescale.length) {
+          this.caculateScalesForAttributes(attributesToRescale, dataArray);
+        }
+      }
+    });
+  }
+  isNumber(n) {
+    return !isNaN(parseFloat(n)) && isFinite(n);
+  }
+  caculateScalesForAttributes(attributes, dataArray) {
+    attributes.forEach(attribute => {
+      if (attribute.scale) {
+        // 创建Scale
+        const attributeScale = attribute.scale;
+        const fieldValue = attribute.scale.field;
+        attributeScale.names = this.parseFields(isNil(fieldValue) ? [] : fieldValue);
+        const scales = [];
+        // 为每个字段创建 Scale
+        attributeScale.names.forEach(field => {
+          var _attribute$scale;
+          scales.push(this.createScale(field, attribute.name, (_attribute$scale = attribute.scale) === null || _attribute$scale === void 0 ? void 0 : _attribute$scale.values, dataArray));
+        });
+
+        // 为scales 设置值区间 Range
+        if (scales.some(scale => scale.type === StyleScaleType.VARIABLE)) {
+          attributeScale.type = StyleScaleType.VARIABLE;
+          scales.forEach(scale => {
+            // 如果设置了回调, 这不需要设置range
+            if (!attributeScale.callback && attributeScale.values !== 'text') {
+              var _scale$option;
+              switch ((_scale$option = scale.option) === null || _scale$option === void 0 ? void 0 : _scale$option.type) {
+                case ScaleTypes.LOG:
+                case ScaleTypes.LINEAR:
+                case ScaleTypes.POWER:
+                  if (attributeScale.values && attributeScale.values.length > 2) {
+                    const tick = scale.scale.ticks(attributeScale.values.length);
+                    scale.scale.domain(tick);
+                  }
+                  attributeScale.values ? scale.scale.range(attributeScale.values) : scale.scale.range(scale.option.domain);
+                  break;
+                case ScaleTypes.QUANTILE:
+                case ScaleTypes.QUANTIZE:
+                case ScaleTypes.THRESHOLD:
+                  scale.scale.range(attributeScale.values); //
+                  break;
+                case ScaleTypes.IDENTITY:
+                  // 不做处理xe
+                  break;
+                case ScaleTypes.CAT:
+                  attributeScale.values ? scale.scale.range(attributeScale.values) : scale.scale.range(scale.option.domain);
+                  break;
+                case ScaleTypes.DIVERGING:
+                case ScaleTypes.SEQUENTIAL:
+                  scale.scale.interpolator(
+                  // @ts-ignore
+                  interpolateRgbBasis(attributeScale.values));
+                  break;
+              }
+            }
+            if (attributeScale.values === 'text') {
+              var _scale$option2;
+              scale.scale.range((_scale$option2 = scale.option) === null || _scale$option2 === void 0 ? void 0 : _scale$option2.domain);
+            }
+          });
+        } else {
+          // 设置attribute 常量值 常量直接在value取值
+          attributeScale.type = StyleScaleType.CONSTANT;
+          attributeScale.defaultValues = scales.map((scale, index) => {
+            return scale.scale(attributeScale.names[index]);
+          });
+        }
+        attributeScale.scalers = scales.map(scale => {
+          return {
+            field: scale.field,
+            func: scale.scale,
+            option: scale.option
+          };
+        });
+        attribute.needRescale = false;
+      }
+    });
+  }
+
+  /**
+   * @example
+   * 'w*h' => ['w', 'h']
+   * 'w' => ['w']
+   */
+  parseFields(field) {
+    if (Array.isArray(field)) {
+      return field;
+    }
+    if (isString(field)) {
+      return field.split('*');
+    }
+    return [field];
+  }
+  createScale(field, name, values, data) {
+    var _this$scaleOptions$na, _find;
+    // scale 支持根据视觉通道和字段
+    const scaleOption = this.scaleOptions[name] && ((_this$scaleOptions$na = this.scaleOptions[name]) === null || _this$scaleOptions$na === void 0 ? void 0 : _this$scaleOptions$na.field) === field ? this.scaleOptions[name] // TODO  zi
+    : this.scaleOptions[field];
+    const styleScale = {
+      field,
+      scale: undefined,
+      type: StyleScaleType.VARIABLE,
+      option: scaleOption
+    };
+    if (!data || !data.length) {
+      if (scaleOption && scaleOption.type) {
+        styleScale.scale = this.createDefaultScale(scaleOption);
+      } else {
+        styleScale.scale = scaleOrdinal([field]);
+        styleScale.type = StyleScaleType.CONSTANT;
+      }
+      return styleScale;
+    }
+    const firstValue = (_find = data.find(d => !isNil(d[field]))) === null || _find === void 0 ? void 0 : _find[field];
+    // 常量 Scale
+    if (this.isNumber(field) || isNil(firstValue) && !scaleOption) {
+      styleScale.scale = scaleOrdinal([field]);
+      styleScale.type = StyleScaleType.CONSTANT;
+    } else {
+      // 根据数据类型判断 默认等分位，时间，和枚举类型
+      let type = scaleOption && scaleOption.type || this.getDefaultType(firstValue);
+      if (values === 'text') {
+        // text 为内置变 如果是文本则为cat
+        type = ScaleTypes.CAT;
+      }
+      if (values === undefined) {
+        type = ScaleTypes.IDENTITY;
+      }
+      if (name === 'color' && Array.isArray(values) && values.length && values.every(value => isString(value)) && (type === ScaleTypes.LINEAR || type === ScaleTypes.POWER || type === ScaleTypes.LOG)) {
+        // Color ramps should use interpolated scales to avoid numeric-only ranges.
+        type = ScaleTypes.SEQUENTIAL;
+      }
+      const cfg = this.createScaleConfig(type, field, scaleOption, data);
+      styleScale.scale = this.createDefaultScale(cfg);
+      styleScale.option = cfg;
+    }
+    return styleScale;
+  }
+  getDefaultType(firstValue) {
+    let type = ScaleTypes.LINEAR;
+    if (typeof firstValue === 'string') {
+      type = dateRegex.test(firstValue) ? ScaleTypes.TIME : ScaleTypes.CAT;
+    }
+    return type;
+  }
+  // 生成Scale 默认配置
+  createScaleConfig(type, field, scaleOption, data) {
+    const cfg = _objectSpread(_objectSpread({}, scaleOption), {}, {
+      type
+    });
+    if (cfg !== null && cfg !== void 0 && cfg.domain) return cfg;
+
+    // quantile domain 需要根据ID 进行去重
+    let values = [];
+    if (type === ScaleTypes.QUANTILE) {
+      // 根据 obejct 属性 _id 进行去重
+      const idMap = new Map();
+      data === null || data === void 0 || data.forEach(obj => {
+        idMap.set(obj._id, obj[field]);
+      });
+      values = Array.from(idMap.values());
+    } else {
+      values = (data === null || data === void 0 ? void 0 : data.map(item => item[field])) || [];
+    }
+    if (type === ScaleTypes.CAT || type === ScaleTypes.IDENTITY) {
+      cfg.domain = uniq(values);
+    } else if (type === ScaleTypes.QUANTILE) {
+      cfg.domain = values;
+    } else if (type === ScaleTypes.DIVERGING) {
+      const minMax = extent(values);
+      const neutral = (scaleOption === null || scaleOption === void 0 ? void 0 : scaleOption.neutral) !== undefined ? scaleOption === null || scaleOption === void 0 ? void 0 : scaleOption.neutral : (minMax[0] + minMax[1]) / 2;
+      cfg.domain = [minMax[0], neutral, minMax[1]];
+    } else {
+      // linear/Power/log
+      cfg.domain = extent(values);
+    }
+    return cfg;
+  }
+
+  // 创建Scale 实例
+  createDefaultScale({
+    type,
+    domain,
+    unknown,
+    clamp,
+    nice
+  }) {
+    // @ts-ignore
+    const scale = scaleMap[type]();
+    if (domain && scale.domain) {
+      scale.domain(domain);
+    }
+    if (unknown) {
+      scale.unknown(unknown);
+    }
+    if (clamp !== undefined && scale.clamp) {
+      scale.clamp(clamp);
+    }
+    if (nice !== undefined && scale.nice) {
+      scale.nice(nice);
+    }
+    // TODO 其他属性支持
+    return scale;
+  }
+}

package/es/plugins/LayerAnimateStylePlugin.d.ts

@@ -0,0 +1,4 @@
+import type { ILayer, ILayerPlugin } from '@antv/l7-core';
+export default class LayerAnimateStylePlugin implements ILayerPlugin {
+    apply(layer: ILayer): void;
+}

package/es/plugins/LayerAnimateStylePlugin.js

@@ -0,0 +1,14 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+export default class LayerAnimateStylePlugin {
+  apply(layer) {
+    layer.hooks.beforeRender.tap('LayerAnimateStylePlugin', () => {
+      // @ts-ignore
+      const animateStatus = layer.animateStatus;
+      if (animateStatus) {
+        layer.models.forEach(model => {
+          model.addUniforms(_objectSpread({}, layer.layerModel.getAnimateUniforms()));
+        });
+      }
+    });
+  }
+}

package/es/plugins/LayerMaskPlugin.d.ts

@@ -0,0 +1,7 @@
+import type { ILayer, ILayerPlugin } from '@antv/l7-core';
+/**
+ * 更新图层样式，初始图层相关配置
+ */
+export default class LayerStylePlugin implements ILayerPlugin {
+    apply(layer: ILayer): void;
+}

package/es/plugins/LayerMaskPlugin.js

@@ -0,0 +1,19 @@
+/**
+ * 更新图层样式，初始图层相关配置
+ */
+export default class LayerStylePlugin {
+  apply(layer) {
+    layer.hooks.afterInit.tap('LayerMaskPlugin', () => {
+      const {
+        maskLayers,
+        enableMask
+      } = layer.getLayerConfig();
+      // mask 初始化
+      if (!layer.tileLayer && maskLayers && maskLayers.length > 0) {
+        layer.updateLayerConfig({
+          mask: enableMask
+        });
+      }
+    });
+  }
+}

package/es/plugins/LayerModelPlugin.d.ts

@@ -0,0 +1,10 @@
+import type { ILayer, ILayerPlugin } from '@antv/l7-core';
+/**
+ * Layer Model 初始化，更新，销毁
+ */
+export default class LayerModelPlugin implements ILayerPlugin {
+    private build;
+    initLayerModel(layer: ILayer): Promise<void>;
+    prepareLayerModel(layer: ILayer): Promise<void>;
+    apply(layer: ILayer): void;
+}