@antv/l7-layers 2.9.36 → 2.9.37-alpha.1

package/es/tile/render/TileRenderService.js

@@ -0,0 +1,68 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+
+/**
+ * 主要用于瓦片图层队列的渲染
+ */
+export var TileRenderService = /*#__PURE__*/function () {
+  function TileRenderService(rendererService) {
+    _classCallCheck(this, TileRenderService);
+
+    this.rendererService = rendererService;
+  }
+
+  _createClass(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;
+}();

package/es/tile/{manager/tileConfigManager.d.ts → style/TileStyleService.d.ts}

@@ -1,12 +1,12 @@
 import { ILayer, IScaleValue } from '@antv/l7-core';
 import EventEmitter from 'eventemitter3';
-export interface ITileConfigManager {
+export interface ITileStyleService {
     setConfig(key: string, value: any): void;
     checkConfig(layer: ILayer): void;
     on(event: string, fn: (...args: any[]) => void): void;
     getAttributeScale(layer: ILayer, name: string): IScaleValue;
 }
-export default class TileConfigManager extends EventEmitter {
+export declare class TileStyleService extends EventEmitter {
     cacheConfig: Map<string, any>;
     checkConfigList: string[];
     constructor();

package/es/tile/{manager/tileConfigManager.js → style/TileStyleService.js}

@@ -12,16 +12,15 @@ function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Re
 
 import EventEmitter from 'eventemitter3';
 import { isEqual } from 'lodash';
+export var TileStyleService = /*#__PURE__*/function (_EventEmitter) {
+  _inherits(TileStyleService, _EventEmitter);
 
-var TileConfigManager = /*#__PURE__*/function (_EventEmitter) {
-  _inherits(TileConfigManager, _EventEmitter);
+  var _super = _createSuper(TileStyleService);
 
-  var _super = _createSuper(TileConfigManager);
-
-  function TileConfigManager() {
+  function TileStyleService() {
     var _this;
 
-    _classCallCheck(this, TileConfigManager);
+    _classCallCheck(this, TileStyleService);
 
     _this = _super.call(this);
 
@@ -31,7 +30,7 @@ var TileConfigManager = /*#__PURE__*/function (_EventEmitter) {
     return _this;
   }
 
-  _createClass(TileConfigManager, [{
+  _createClass(TileStyleService, [{
     key: "setConfig",
     value: function setConfig(key, value) {
       if (!this.checkConfigList.includes(key)) {
@@ -115,7 +114,5 @@ var TileConfigManager = /*#__PURE__*/function (_EventEmitter) {
     }
   }]);
 
-  return TileConfigManager;
-}(EventEmitter);
-
-export { TileConfigManager as default };
+  return TileStyleService;
+}(EventEmitter);

package/es/tile/style/constants.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 瓦片图层的样式
+ */
+export declare const Attributes: string[];
+export declare type IStyles = 'PointLayer' | 'LineLayer' | 'PolygonLayer' | 'RasterLayer' | 'MaskLayer' | 'TileDebugLayer';
+export declare const styles: {
+    PointLayer: string[];
+    LineLayer: string[];
+    PolygonLayer: string[];
+    RasterLayer: string[];
+    MaskLayer: never[];
+    TileDebugLayer: never[];
+};

package/es/tile/style/constants.js

@@ -0,0 +1,17 @@
+/**
+ * 瓦片图层的样式
+ */
+export var Attributes = ['size', 'color', 'shape'];
+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);
+export var styles = {
+  'PointLayer': pointLayer,
+  'LineLayer': lineLayer,
+  'PolygonLayer': polygonLayer,
+  'RasterLayer': rasterLayer,
+  'MaskLayer': [],
+  'TileDebugLayer': []
+};

package/es/tile/style/utils.d.ts

@@ -0,0 +1,9 @@
+import { ILayer, IRendererService, ScaleAttributeType, IScaleValue } from '@antv/l7-core';
+import { IColorRamp } from '@antv/l7-utils';
+export declare function updateTexture(config: IColorRamp, layers: ILayer[], rendererService: IRendererService): import("@antv/l7-core").ITexture2D;
+export declare function updateLayersConfig(layers: ILayer[], key: string, value: any): void;
+export declare function setStyleAttributeField(layer: ILayer, parent: ILayer, style: ScaleAttributeType, value: IScaleValue | undefined | string | string[]): ILayer | undefined;
+export declare function getDefaultStyleAttributeField(layer: ILayer, type: string, style: string): string | string[] | 1;
+export declare function getLayerShape(layerType: string, layer: ILayer): string | string[];
+export declare function parseScaleValue(value: IScaleValue | string, type: string): (string | number | any[])[] | (import("@antv/l7-core").StyleAttributeField | ((...args: any[]) => [] | undefined))[];
+export declare function setScale(layer: ILayer, parent: ILayer): void;

package/es/tile/style/utils.js

@@ -0,0 +1,139 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { generateColorRamp } from '@antv/l7-utils';
+export function updateTexture(config, layers, rendererService) {
+  var createTexture2D = rendererService.createTexture2D;
+  var imageData = 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;
+}
+export function updateLayersConfig(layers, key, value) {
+  layers.map(function (layer) {
+    if (key === 'mask') {
+      // Tip: 栅格瓦片生效、设置全局的 mask、瓦片被全局的 mask 影响
+      layer.style({
+        mask: value
+      });
+    } else {
+      layer.updateLayerConfig(_defineProperty({}, key, value));
+    }
+  });
+}
+export function setStyleAttributeField(layer, parent, style, value) {
+  if (Array.isArray(value)) {
+    // @ts-ignore
+    layer[style].apply(layer, _toConsumableArray(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, _toConsumableArray(params));
+  }
+}
+export function getDefaultStyleAttributeField(layer, type, style) {
+  switch (style) {
+    case 'size':
+      return 1;
+
+    case 'color':
+      return '#fff';
+
+    case 'shape':
+      return getLayerShape(type, layer);
+
+    default:
+      return '';
+  }
+}
+export 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 '';
+  }
+}
+export 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 [];
+}
+export function setScale(layer, parent) {
+  var scaleOptions = parent.tileLayer.scaleField;
+  var scaleKeys = Object.keys(scaleOptions);
+  scaleKeys.map(function (key) {
+    layer.scale(key, scaleOptions[key]);
+  });
+}

package/es/tile/tileFactory/base.d.ts

@@ -1,4 +1,4 @@
-import { ILayer, IMapService, IParseDataItem, IRendererService, IScaleValue, ISubLayerInitOptions, ScaleAttributeType } from '@antv/l7-core';
+import { ILayer, IMapService, IParseDataItem, IRendererService, ISubLayerInitOptions } from '@antv/l7-core';
 import Source from '@antv/l7-source';
 import { Tile, TilesetManager } from '@antv/l7-utils';
 import { ILayerTileConfig, ITileFactory, ITileFactoryOptions, ITileStyles, Timeout } from '../interface';
@@ -30,14 +30,15 @@ export default class TileFactory implements ITileFactory {
     };
     createLayer(tileLayerOption: ILayerTileConfig): any;
     updateStyle(styles: ITileStyles): string;
-    getDefaultStyleAttributeField(layer: ILayer, type: string): string | string[] | 1;
-    setStyleAttributeField(layer: ILayer, type: ScaleAttributeType, value: IScaleValue | undefined | string | string[]): ILayer | undefined;
-    protected parseScaleValue(value: IScaleValue | string, type: string): (string | number | unknown[])[] | (import("@antv/l7-core").StyleAttributeField | ((...args: any[]) => [] | undefined))[];
     protected getTile(lng: number, lat: number): Tile;
-    protected emitEvent(layers: ILayer[], isVector?: boolean): void;
+    private bindVectorEvent;
+    private readRasterTile;
+    private bindRasterEvent;
+    private bindCommonEvent;
+    protected emitEvent(layers: ILayer[]): void;
+    protected emitRasterEvent(layers: ILayer[]): void;
     protected getCombineFeature(features: IParseDataItem[]): any;
-    protected getFeatureAndEmitEvent(layer: ILayer, eventName: string, e: any, isVector?: boolean, tile?: any): void;
-    private setScale;
+    protected getFeatureAndEmitEvent(eventName: string, e: any): void;
     private getAllFeatures;
     private getLayerInitOption;
     private handleOutsideEvent;