@antv/l7-layers 2.9.32-alpha.3 → 2.9.32-alpha.4

package/es/raster/shaders/raster_2d_frag.glsl

@@ -0,0 +1,64 @@
+precision mediump float;
+uniform float u_opacity: 1.0;
+uniform sampler2D u_texture;
+uniform sampler2D u_colorTexture;
+uniform float u_min;
+uniform float u_max;
+uniform vec2 u_domain;
+uniform float u_noDataValue;
+uniform bool u_clampLow: true;
+uniform bool u_clampHigh: true;
+varying vec2 v_texCoord;
+
+
+
+// float getBlurIndusty() {
+//   vec2 u_ViewportSize = vec2(1024);
+
+//     float vW = 2.0/u_ViewportSize.x;
+//     float vH = 2.0/u_ViewportSize.y;
+//     vec2 vUv = v_texCoord;
+//     float i11 = texture2D( u_texture, vec2( vUv.x - 1.0 * vW, vUv.y + 1.0 * vH) ).r;
+//     float i12 = texture2D( u_texture, vec2( vUv.x - 0.0 * vW, vUv.y + 1.0 * vH) ).r;
+//     float i13 = texture2D( u_texture, vec2( vUv.x + 1.0 * vW, vUv.y + 1.0 * vH) ).r;
+
+//     float i21 = texture2D( u_texture, vec2( vUv.x - 1.0 * vW, vUv.y) ).r;
+//     float i22 = texture2D( u_texture, vec2( vUv.x , vUv.y) ).r;
+//     float i23 = texture2D( u_texture, vec2( vUv.x + 1.0 * vW, vUv.y) ).r;
+
+//     float i31 = texture2D( u_texture, vec2( vUv.x - 1.0 * vW, vUv.y-1.0*vH) ).r;
+//     float i32 = texture2D( u_texture, vec2( vUv.x - 0.0 * vW, vUv.y-1.0*vH) ).r;
+//     float i33 = texture2D( u_texture, vec2( vUv.x + 1.0 * vW, vUv.y-1.0*vH) ).r;
+
+//     return(
+//         i11 + 
+//         i12 + 
+//         i13 + 
+//         i21 + 
+//         i21 + 
+//         i22 + 
+//         i23 + 
+//         i31 + 
+//         i32 + 
+//         i33
+//         )/9.0;
+// }
+
+void main() {
+
+  float value = texture2D(u_texture,vec2(v_texCoord.x,v_texCoord.y)).r;
+
+  // float value = getBlurIndusty();
+
+
+  if (value == u_noDataValue)
+    gl_FragColor = vec4(0.0, 0, 0, 0.0);
+  else if ((!u_clampLow && value < u_domain[0]) || (!u_clampHigh && value > u_domain[1]))
+    gl_FragColor = vec4(0, 0, 0, 0);
+  else {
+    float normalisedValue =(value - u_domain[0]) / (u_domain[1] -u_domain[0]);
+    vec4 color = texture2D(u_colorTexture,vec2(normalisedValue, 0));
+    gl_FragColor = color;
+    gl_FragColor.a =  gl_FragColor.a * u_opacity ;
+  }
+}

package/es/raster/shaders/raster_2d_vert.glsl

@@ -0,0 +1,17 @@
+precision highp float;
+uniform mat4 u_ModelMatrix;
+uniform mat4 u_Mvp;
+attribute vec3 a_Position;
+attribute vec2 a_Uv;
+varying vec2 v_texCoord;
+#pragma include "projection"
+void main() {
+   v_texCoord = a_Uv;
+   vec4 project_pos = project_position(vec4(a_Position, 1.0));
+
+   if(u_CoordinateSystem == COORDINATE_SYSTEM_P20_2) { // gaode2.x
+      gl_Position = u_Mvp * (vec4(project_pos.xy,0., 1.0));
+   } else {
+      gl_Position = project_common_position_to_clipspace(vec4(project_pos.xy,0., 1.0));
+   }
+}

package/es/raster/shaders/raster_frag.glsl

@@ -0,0 +1,9 @@
+varying vec4 v_color;
+uniform float u_opacity: 1.0;
+#define PI 3.141592653589793
+
+void main() {
+   gl_FragColor = v_color;
+   gl_FragColor.a *= u_opacity;
+
+}

package/es/raster/shaders/raster_vert.glsl

@@ -0,0 +1,44 @@
+precision highp float;
+attribute vec3 a_Position;
+uniform mat4 u_ModelMatrix;
+uniform mat4 u_Mvp;
+uniform vec4 u_extent;
+uniform sampler2D u_texture;
+uniform sampler2D u_colorTexture;
+uniform float u_min;
+uniform float u_max;
+uniform float u_width;
+uniform float u_height;
+uniform float u_heightRatio;
+
+varying vec2 v_texCoord;
+varying vec4 v_color;
+
+#pragma include "projection"
+void main() {
+  vec2 uv = a_Position.xy / vec2(u_width, u_height);
+  vec2 minxy =  project_position(vec4(u_extent.xy, 0, 1.0)).xy;
+  vec2 maxxy =  project_position(vec4(u_extent.zw, 0, 1.0)).xy;
+  float value = texture2D(u_texture, vec2(uv.x,1.0 - uv.y)).x;
+  vec2 step = (maxxy - minxy) / vec2(u_width, u_height);
+  vec2 pos = minxy + vec2(a_Position.x, a_Position.y ) * step;
+  //  v_texCoord = a_Uv;
+  value = clamp(value,u_min,u_max);
+  float value1 =  (value - u_min) / (u_max -u_min);
+  vec4 color = texture2D(u_colorTexture,vec2(intensity, 0));
+
+  // if(uv.x > 1.0 || uv.y > 1.0) {
+  //   v_color = vec4(0.);
+  // }
+
+  //  vec2 range = u_extent.zw - u_extent.xy;
+  //  vec4 project_pos = project_position(vec4(pos, 0, 1.0));
+  //  gl_Position = project_common_position_to_clipspace(vec4(pos.xy, project_scale(value) * u_heightRatio, 1.0));
+
+  if(u_CoordinateSystem == COORDINATE_SYSTEM_P20_2) { // gaode2.x
+    gl_Position = u_Mvp * (vec4(pos.xy, project_scale(value) * u_heightRatio, 1.0));
+  } else {
+    gl_Position = project_common_position_to_clipspace(vec4(pos.xy, project_scale(value) * u_heightRatio, 1.0));
+  }
+
+}

package/es/shader/minify_frag.glsl

@@ -0,0 +1,7 @@
+uniform float u_opacity : 1.0;
+uniform vec4 u_color;
+
+void main() {
+  gl_FragColor = u_color;
+  gl_FragColor.a *= u_opacity;
+}

package/es/shader/minify_picking_frag.glsl

@@ -0,0 +1,10 @@
+uniform float u_opacity : 1.0;
+varying vec4 v_color;
+
+#pragma include "picking"
+
+void main() {
+  gl_FragColor = v_color;
+  gl_FragColor.a *= u_opacity;
+  gl_FragColor = filterColor(gl_FragColor);
+}

package/es/tile/interface.d.ts

@@ -0,0 +1,29 @@
+import { ILayer, IMapService, IRendererService, IScaleValue, ISource, ISubLayerInitOptions, ScaleAttributeType } from '@antv/l7-core';
+import { Tile } from '@antv/l7-utils';
+export declare type Timeout = any;
+export declare type CacheEvent = 'click' | 'mousemove' | 'mouseup' | 'mousedown' | 'contextmenu';
+export interface ITileFactoryOptions {
+    parent: ILayer;
+    mapService: IMapService;
+    rendererService: IRendererService;
+}
+export interface ITileStyles {
+    [key: string]: any;
+}
+export interface ILayerTileConfig {
+    L7Layer?: any;
+    tile: Tile;
+    initOptions: ISubLayerInitOptions;
+    vectorTileLayer?: any;
+    source: ISource;
+    needListen?: boolean;
+}
+export interface ITileFactory {
+    createTile(tile: Tile, initOptions: ISubLayerInitOptions): {
+        layers: ILayer[];
+        layerIDList: string[];
+    };
+    createLayer(option: ILayerTileConfig): ILayer;
+    updateStyle(styles: ITileStyles): string;
+    setStyleAttributeField(layer: ILayer, type: ScaleAttributeType, value: IScaleValue): void;
+}

package/es/tile/interface.js

@@ -0,0 +1 @@
+export {};

package/es/tile/manager/baseMapTileLayerManager.d.ts

@@ -0,0 +1,7 @@
+import { ILayer, IMapService, IRendererService, IBaseTileLayerManager } from '@antv/l7-core';
+import { TileManager } from './baseTileManager';
+export declare class BaseMapTileLayerManager extends TileManager implements IBaseTileLayerManager {
+    constructor(parent: ILayer, mapService: IMapService, rendererService: IRendererService);
+    render(): void;
+    private setSubLayerInitOption;
+}

package/es/tile/manager/baseMapTileLayerManager.js

@@ -0,0 +1,119 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(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; } }
+
+import { TileManager } from "./baseTileManager";
+import { getLayerShape, getMaskValue } from "../utils";
+export var BaseMapTileLayerManager = /*#__PURE__*/function (_TileManager) {
+  _inherits(BaseMapTileLayerManager, _TileManager);
+
+  var _super = _createSuper(BaseMapTileLayerManager);
+
+  // only support vector layer
+  function BaseMapTileLayerManager(parent, mapService, rendererService) {
+    var _this;
+
+    _classCallCheck(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;
+  }
+
+  _createClass(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 = 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: getMaskValue(this.parent.type, mask),
+        stroke: stroke,
+        strokeWidth: strokeWidth,
+        strokeOpacity: strokeOpacity,
+        // worker
+        workerEnabled: workerEnabled
+      };
+    }
+  }]);
+
+  return BaseMapTileLayerManager;
+}(TileManager);

package/es/tile/manager/baseTileManager.d.ts

@@ -0,0 +1,27 @@
+import { ILayer, IRendererService, IMapService, ISubLayerInitOptions } from '@antv/l7-core';
+import { Tile } from '@antv/l7-utils';
+import { ITileFactory } from '../tileFactory';
+export declare class TileManager {
+    sourceLayer: string;
+    parent: ILayer;
+    children: ILayer[];
+    mapService: IMapService;
+    rendererService: IRendererService;
+    protected tileFactory: ITileFactory;
+    protected initOptions: ISubLayerInitOptions;
+    createTile(tile: Tile): {
+        layers: ILayer[];
+        layerIDList: string[];
+    };
+    addChild(layer: ILayer): void;
+    addChilds(layers: ILayer[]): void;
+    removeChilds(layerIDList: string[], refresh?: boolean): void;
+    removeChild(layer: ILayer): void;
+    getChilds(layerIDList: string[]): ILayer[];
+    getChild(layerID: string): ILayer;
+    clearChild(): void;
+    hasChild(layer: ILayer): boolean;
+    initTileFactory(): void;
+    getSourceLayer(parentParserType: string, sourceLayer: string | undefined): string | undefined;
+    destroy(): void;
+}

package/es/tile/manager/baseTileManager.js

@@ -0,0 +1,107 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import { getTileFactory } from "../tileFactory";
+export var TileManager = /*#__PURE__*/function () {
+  function TileManager() {
+    _classCallCheck(this, TileManager);
+  }
+
+  _createClass(TileManager, [{
+    key: "createTile",
+    value: function createTile(tile) {
+      return this.tileFactory.createTile(tile, this.initOptions);
+    }
+  }, {
+    key: "addChild",
+    value: function addChild(layer) {
+      this.children.push(layer);
+    }
+  }, {
+    key: "addChilds",
+    value: function addChilds(layers) {
+      var _this$children;
+
+      (_this$children = this.children).push.apply(_this$children, _toConsumableArray(layers));
+    }
+  }, {
+    key: "removeChilds",
+    value: function removeChilds(layerIDList) {
+      var refresh = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+      var remveLayerList = [];
+      var cacheLayerList = [];
+      this.children.filter(function (child) {
+        layerIDList.includes(child.id) ? remveLayerList.push(child) : cacheLayerList.push(child);
+      });
+      remveLayerList.map(function (layer) {
+        return layer.destroy(refresh);
+      });
+      this.children = cacheLayerList;
+    }
+  }, {
+    key: "removeChild",
+    value: function removeChild(layer) {
+      var layerIndex = this.children.indexOf(layer);
+
+      if (layerIndex > -1) {
+        this.children.splice(layerIndex, 1);
+      }
+
+      layer.destroy();
+    }
+  }, {
+    key: "getChilds",
+    value: function getChilds(layerIDList) {
+      return this.children.filter(function (child) {
+        return layerIDList.includes(child.id);
+      });
+    }
+  }, {
+    key: "getChild",
+    value: function getChild(layerID) {
+      return this.children.filter(function (child) {
+        return child.id === layerID;
+      })[0];
+    }
+  }, {
+    key: "clearChild",
+    value: function clearChild() {
+      this.children.forEach(function (layer) {
+        layer.destroy();
+      });
+      this.children.slice(0, this.children.length);
+    }
+  }, {
+    key: "hasChild",
+    value: function hasChild(layer) {
+      return this.children.includes(layer);
+    }
+  }, {
+    key: "initTileFactory",
+    value: function initTileFactory() {
+      var source = this.parent.getSource();
+      var TileFactory = getTileFactory(this.parent.type, source.parser);
+      this.tileFactory = new TileFactory({
+        parent: this.parent,
+        mapService: this.mapService,
+        rendererService: this.rendererService
+      });
+    }
+  }, {
+    key: "getSourceLayer",
+    value: function getSourceLayer(parentParserType, sourceLayer) {
+      if (parentParserType === 'geojsonvt') {
+        return 'geojsonvt';
+      } else if (parentParserType === 'testTile') {
+        return 'testTile';
+      } else {
+        return sourceLayer;
+      }
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {}
+  }]);
+
+  return TileManager;
+}();

package/es/tile/manager/tileConfigManager.d.ts

@@ -0,0 +1,17 @@
+import { ILayer, IScaleValue } from '@antv/l7-core';
+import EventEmitter from 'eventemitter3';
+export interface ITileConfigManager {
+    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 {
+    cacheConfig: Map<string, any>;
+    checkConfigList: string[];
+    constructor();
+    setConfig(key: string, value: any): void;
+    removeConfig(key: string): void;
+    checkConfig(layer: ILayer): void;
+    getAttributeScale(layer: ILayer, name: string): IScaleValue;
+}

package/es/tile/manager/tileConfigManager.js

@@ -0,0 +1,121 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(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; } }
+
+import EventEmitter from 'eventemitter3';
+import { isEqual } from 'lodash';
+
+var TileConfigManager = /*#__PURE__*/function (_EventEmitter) {
+  _inherits(TileConfigManager, _EventEmitter);
+
+  var _super = _createSuper(TileConfigManager);
+
+  function TileConfigManager() {
+    var _this;
+
+    _classCallCheck(this, TileConfigManager);
+
+    _this = _super.call(this);
+
+    _defineProperty(_assertThisInitialized(_this), "checkConfigList", []);
+
+    _this.cacheConfig = new Map();
+    return _this;
+  }
+
+  _createClass(TileConfigManager, [{
+    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 (!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 TileConfigManager;
+}(EventEmitter);
+
+export { TileConfigManager as default };

package/es/tile/manager/tileLayerManager.d.ts

@@ -0,0 +1,15 @@
+import { IInteractionTarget, ILayer, IMapService, IPickingService, IRendererService, ITileLayerManager, ITilePickManager, ITransform } from '@antv/l7-core';
+import { TileManager } from './baseTileManager';
+import { ITileConfigManager } from './tileConfigManager';
+export declare class TileLayerManager extends TileManager implements ITileLayerManager {
+    tilePickManager: ITilePickManager;
+    tileConfigManager: ITileConfigManager;
+    private transforms;
+    constructor(parent: ILayer, mapService: IMapService, rendererService: IRendererService, pickingService: IPickingService, transforms: ITransform[]);
+    render(): void;
+    pickLayers(target: IInteractionTarget): boolean;
+    private setSubLayerInitOption;
+    private setConfigListener;
+    private updateStyle;
+    destroy(): void;
+}