@antv/l7-layers 2.20.20 → 2.21.1

package/es/canvas/index.d.ts

@@ -1,13 +1,18 @@
-import type { ILayer } from '@antv/l7-core';
 import BaseLayer from '../core/BaseLayer';
-import type { ICanvasLayerStyleOptions } from '../core/interface';
-import type { CanvasModelType } from './models/index';
-export default class CanvasLayer extends BaseLayer<ICanvasLayerStyleOptions> {
+import type { ICanvasLayerOptions } from '../core/interface';
+import type { CanvasModelType } from './models';
+import { CanvasModel } from './models';
+export default class CanvasLayer extends BaseLayer<ICanvasLayerOptions> {
     type: string;
-    forceRender: boolean;
+    layerModel: CanvasModel;
+    protected getDefaultConfig(): Partial<ICanvasLayerOptions>;
     buildModels(): Promise<void>;
-    hide(): ILayer;
-    renderModels(): this;
-    protected getDefaultConfig(): {};
     getModelType(): CanvasModelType;
+    draw(draw: ICanvasLayerOptions['draw']): this;
+    getLayerConfig(): any;
+    render(): this;
+    getCanvas(): HTMLCanvasElement | null;
+    show(): this;
+    hide(): this;
+    destroy(): void;
 }

package/es/canvas/index.js

@@ -1,7 +1,9 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
 import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
 import _createClass from "@babel/runtime/helpers/esm/createClass";
 import _assertThisInitialized from "@babel/runtime/helpers/esm/assertThisInitialized";
+import _get from "@babel/runtime/helpers/esm/get";
 import _inherits from "@babel/runtime/helpers/esm/inherits";
 import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
 import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
@@ -9,8 +11,9 @@ import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
 import _regeneratorRuntime from "@babel/runtime/regenerator";
 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 type { ILayerConfig } from '@antv/l7-core';
 import BaseLayer from "../core/BaseLayer";
-import CanvasModels from "./models/index";
+import { CanvasModel } from "./models";
 var CanvasLayer = /*#__PURE__*/function (_BaseLayer) {
   _inherits(CanvasLayer, _BaseLayer);
   var _super = _createSuper(CanvasLayer);
@@ -22,22 +25,28 @@ var CanvasLayer = /*#__PURE__*/function (_BaseLayer) {
     }
     _this = _super.call.apply(_super, [this].concat(args));
     _defineProperty(_assertThisInitialized(_this), "type", 'CanvasLayer');
-    _defineProperty(_assertThisInitialized(_this), "forceRender", true);
     return _this;
   }
   _createClass(CanvasLayer, [{
+    key: "getDefaultConfig",
+    value: function getDefaultConfig() {
+      return {
+        zIndex: 3,
+        contextType: 'canvas2d',
+        trigger: 'change'
+      };
+    }
+  }, {
     key: "buildModels",
     value: function () {
       var _buildModels = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
-        var modelType;
         return _regeneratorRuntime.wrap(function _callee$(_context) {
           while (1) switch (_context.prev = _context.next) {
             case 0:
-              modelType = this.getModelType();
-              this.layerModel = new CanvasModels[modelType](this);
-              _context.next = 4;
+              this.layerModel = new CanvasModel(this);
+              _context.next = 3;
               return this.initLayerModels();
-            case 4:
+            case 3:
             case "end":
               return _context.stop();
           }
@@ -49,46 +58,64 @@ var CanvasLayer = /*#__PURE__*/function (_BaseLayer) {
       return buildModels;
     }()
   }, {
-    key: "hide",
-    value: function hide() {
-      // 清除画布
-      if (this.layerModel.clearCanvas) {
-        this.layerModel.clearCanvas();
-      }
+    key: "getModelType",
+    value: function getModelType() {
+      return this.getLayerConfig().contextType || 'canvas2d';
+    }
+  }, {
+    key: "draw",
+    value: function draw(_draw) {
       this.updateLayerConfig({
-        visible: false
+        draw: _draw
       });
-      this.reRender();
+      this.render();
       return this;
     }
   }, {
-    key: "renderModels",
-    value: function renderModels() {
-      var _this$layerModel,
-        _this2 = this;
-      if (this !== null && this !== void 0 && (_this$layerModel = this.layerModel) !== null && _this$layerModel !== void 0 && _this$layerModel.renderUpdate) {
-        this.layerModel.renderUpdate();
+    key: "getLayerConfig",
+    value: function getLayerConfig() {
+      var config = _objectSpread(_objectSpread({}, this.getDefaultConfig()), _get(_getPrototypeOf(CanvasLayer.prototype), "getLayerConfig", this).call(this));
+      if (config.zIndex < 3) {
+        config.zIndex = 3;
       }
-      this.models.forEach(function (model) {
-        model.draw({
-          uniforms: _this2.layerModel.getUninforms()
-        }, false);
-      });
+      return config;
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$layerModel;
+      (_this$layerModel = this.layerModel) === null || _this$layerModel === void 0 || _this$layerModel.renderCanvas();
       return this;
     }
   }, {
-    key: "getDefaultConfig",
-    value: function getDefaultConfig() {
-      var type = this.getModelType();
-      var defaultConfig = {
-        canvas: {}
-      };
-      return defaultConfig[type];
+    key: "getCanvas",
+    value: function getCanvas() {
+      var _this$layerModel2;
+      return (_this$layerModel2 = this.layerModel) === null || _this$layerModel2 === void 0 ? void 0 : _this$layerModel2.canvas;
     }
   }, {
-    key: "getModelType",
-    value: function getModelType() {
-      return 'canvas';
+    key: "show",
+    value: function show() {
+      var canvas = this.getCanvas();
+      if (canvas) {
+        canvas.style.display = 'unset';
+      }
+      return this;
+    }
+  }, {
+    key: "hide",
+    value: function hide() {
+      var canvas = this.getCanvas();
+      if (canvas) {
+        canvas.style.display = 'none';
+      }
+      return this;
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      this.layerModel.removeCanvas();
+      _get(_getPrototypeOf(CanvasLayer.prototype), "destroy", this).call(this);
     }
   }]);
   return CanvasLayer;

package/es/canvas/models/canvas.d.ts

@@ -1,18 +1,23 @@
 import BaseModel from '../../core/BaseModel';
-import { CanvasUpdateType } from '../../core/interface';
-export default class CanvaModel extends BaseModel {
-    protected updateMode: CanvasUpdateType;
-    protected canvas: HTMLCanvasElement;
-    protected ctx: CanvasRenderingContext2D;
-    protected prevSize: [number, number];
-    renderUpdate: () => void;
-    unBindListener: () => void;
-    bindListener: () => void;
-    clearModels(): void;
+import { type ICanvasLayerOptions } from '../../core/interface';
+export declare class CanvasModel extends BaseModel {
+    canvas: HTMLCanvasElement | null;
+    ctx: any;
+    ctxType: string;
+    viewportSize: [number, number];
+    get layerConfig(): ICanvasLayerOptions;
     initModels(): Promise<never[]>;
-    initCanvas(): void;
-    clearCanvas: () => void;
+    initCanvas: () => void;
+    resetViewportSize: () => void;
+    resetCanvasSize: () => void;
     renderCanvas: () => void;
-    buildModels(): Promise<never[]>;
-    protected registerBuiltinAttributes(): void;
+    removeCanvas: () => void;
+    onMapResize: () => void;
+    bindListeners(): void;
+    unbindListeners(): void;
+    lngLatToContainer: (lngLat: [number, number]) => {
+        x: number;
+        y: number;
+    };
+    registerBuiltinAttributes(): void;
 }

package/es/canvas/models/canvas.js

@@ -12,120 +12,131 @@ function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflec
 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 BaseModel from "../../core/BaseModel";
 import { CanvasUpdateType } from "../../core/interface";
-var CanvaModel = /*#__PURE__*/function (_BaseModel) {
-  _inherits(CanvaModel, _BaseModel);
-  var _super = _createSuper(CanvaModel);
-  function CanvaModel() {
+import { CanvasContextTypeMap } from "./constants";
+export var CanvasModel = /*#__PURE__*/function (_BaseModel) {
+  _inherits(CanvasModel, _BaseModel);
+  var _super = _createSuper(CanvasModel);
+  function CanvasModel() {
     var _this;
-    _classCallCheck(this, CanvaModel);
+    _classCallCheck(this, CanvasModel);
     for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
       args[_key] = arguments[_key];
     }
     _this = _super.call.apply(_super, [this].concat(args));
-    _defineProperty(_assertThisInitialized(_this), "updateMode", CanvasUpdateType.ALWAYS);
-    _defineProperty(_assertThisInitialized(_this), "renderUpdate", function () {
-      var _ref = _this.layer.getLayerConfig(),
-        _ref$zIndex = _ref.zIndex,
-        zIndex = _ref$zIndex === void 0 ? 10 : _ref$zIndex,
-        _ref$update = _ref.update,
-        update = _ref$update === void 0 ? CanvasUpdateType.ALWAYS : _ref$update,
-        _ref$animateOption = _ref.animateOption,
-        animateOption = _ref$animateOption === void 0 ? {
-          enable: false,
-          duration: 20
-        } : _ref$animateOption;
-      if (+_this.canvas.style.zIndex === zIndex) {
-        _this.canvas.style.zIndex = zIndex + '';
-      }
-      if (_this.updateMode !== update) {
-        _this.updateMode = update;
-        _this.unBindListener();
-        _this.bindListener();
-      }
-      if (_this.updateMode === CanvasUpdateType.ALWAYS && animateOption.enable) {
-        _this.renderCanvas();
+    _defineProperty(_assertThisInitialized(_this), "canvas", null);
+    _defineProperty(_assertThisInitialized(_this), "initCanvas", function () {
+      var _this$mapService$getC, _this$mapService$getC2, _this$mapService, _this$mapService$getM, _this$mapService2;
+      var _this$layerConfig = _this.layerConfig,
+        zIndex = _this$layerConfig.zIndex,
+        getContext = _this$layerConfig.getContext;
+      var canvas = document.createElement('canvas');
+      var modelType = _this.layer.getModelType();
+      _this.canvas = canvas;
+      canvas.classList.add('l7-canvas-layer');
+      canvas.style.position = 'absolute';
+      canvas.style.top = '0';
+      canvas.style.left = '0';
+      canvas.style.zIndex = String(zIndex);
+      _this.resetCanvasSize();
+      var container = (_this$mapService$getC = (_this$mapService$getC2 = (_this$mapService = _this.mapService).getCanvasOverlays) === null || _this$mapService$getC2 === void 0 ? void 0 : _this$mapService$getC2.call(_this$mapService)) !== null && _this$mapService$getC !== void 0 ? _this$mapService$getC : (_this$mapService$getM = (_this$mapService2 = _this.mapService).getMapCanvasContainer) === null || _this$mapService$getM === void 0 ? void 0 : _this$mapService$getM.call(_this$mapService2);
+      container === null || container === void 0 || container.appendChild(canvas);
+      _this.ctx = getContext ? getContext(canvas) : canvas.getContext(CanvasContextTypeMap[modelType]);
+      if (!_this.ctx) {
+        console.error('Failed to get rendering context for canvas');
       }
+      _this.bindListeners();
     });
-    _defineProperty(_assertThisInitialized(_this), "unBindListener", function () {
-      _this.mapService.off('mapchange', _this.renderCanvas);
-      _this.mapService.off('zoomstart', _this.clearCanvas);
-      _this.mapService.off('zoomend', _this.renderCanvas);
-      _this.mapService.off('movestart', _this.clearCanvas);
-      _this.mapService.off('moveend', _this.renderCanvas);
-    });
-    _defineProperty(_assertThisInitialized(_this), "bindListener", function () {
-      if (_this.updateMode === CanvasUpdateType.ALWAYS) {
-        _this.mapService.on('mapchange', _this.renderCanvas);
-      } else {
-        _this.mapService.on('zoomstart', _this.clearCanvas);
-        _this.mapService.on('zoomend', _this.renderCanvas);
-        _this.mapService.on('movestart', _this.clearCanvas);
-        _this.mapService.on('moveend', _this.renderCanvas);
-      }
+    _defineProperty(_assertThisInitialized(_this), "resetViewportSize", function () {
+      var _this$rendererService = _this.rendererService.getViewportSize(),
+        viewWidth = _this$rendererService.width,
+        viewHeight = _this$rendererService.height;
+      _this.viewportSize = [viewWidth, viewHeight];
     });
-    _defineProperty(_assertThisInitialized(_this), "clearCanvas", function () {
-      if (_this.ctx) {
-        var _this$rendererService = _this.rendererService.getViewportSize(),
-          w = _this$rendererService.width,
-          h = _this$rendererService.height;
-        _this.ctx.clearRect(0, 0, w, h);
+    _defineProperty(_assertThisInitialized(_this), "resetCanvasSize", function () {
+      var canvas = _this.canvas;
+      if (!canvas) {
+        return;
       }
+      _this.resetViewportSize();
+      var _this$mapService$getS = _this.mapService.getSize(),
+        _this$mapService$getS2 = _slicedToArray(_this$mapService$getS, 2),
+        width = _this$mapService$getS2[0],
+        height = _this$mapService$getS2[1];
+      var _this$viewportSize = _slicedToArray(_this.viewportSize, 2),
+        viewWidth = _this$viewportSize[0],
+        viewHeight = _this$viewportSize[1];
+      canvas.width = viewWidth;
+      canvas.height = viewHeight;
+      canvas.style.width = width + 'px';
+      canvas.style.height = height + 'px';
     });
     _defineProperty(_assertThisInitialized(_this), "renderCanvas", function () {
-      var _this$rendererService2 = _this.rendererService.getViewportSize(),
-        viewWidth = _this$rendererService2.width,
-        viewHeight = _this$rendererService2.height;
-      if (_this.prevSize[0] !== viewWidth || _this.prevSize[1] !== viewHeight) {
-        _this.prevSize = [viewWidth, viewHeight];
-        var size = _this.mapService.getSize();
-        var _size = _slicedToArray(size, 2),
-          width = _size[0],
-          height = _size[1];
-        _this.canvas.width = viewWidth;
-        _this.canvas.height = viewHeight;
-        _this.canvas.style.width = width + 'px';
-        _this.canvas.style.height = height + 'px';
+      var _ref;
+      if (!_this.canvas) {
+        _this.initCanvas();
       }
-      var _ref2 = _this.layer.getLayerConfig(),
-        drawingOnCanvas = _ref2.drawingOnCanvas;
-      if (_this.ctx) {
-        drawingOnCanvas({
-          canvas: _this.canvas,
-          ctx: _this.ctx,
-          mapService: _this.mapService,
-          size: [viewWidth, viewHeight]
-        });
+      var _this$layerConfig2 = _this.layerConfig,
+        draw = _this$layerConfig2.draw,
+        drawingOnCanvas = _this$layerConfig2.drawingOnCanvas;
+      var _this$viewportSize2 = _slicedToArray(_this.viewportSize, 2),
+        width = _this$viewportSize2[0],
+        height = _this$viewportSize2[1];
+      var bounds = _this.mapService.getBounds();
+      (_ref = draw !== null && draw !== void 0 ? draw : drawingOnCanvas) === null || _ref === void 0 || _ref({
+        canvas: _this.canvas,
+        ctx: _this.ctx,
+        container: {
+          width: width,
+          height: height,
+          bounds: bounds
+        },
+        size: [width, height],
+        utils: {
+          lngLatToContainer: _this.lngLatToContainer
+        },
+        mapService: _this.mapService
+      });
+    });
+    _defineProperty(_assertThisInitialized(_this), "removeCanvas", function () {
+      if (_this.canvas) {
+        var _this$canvas$parentEl;
+        (_this$canvas$parentEl = _this.canvas.parentElement) === null || _this$canvas$parentEl === void 0 || _this$canvas$parentEl.removeChild(_this.canvas);
+        _this.canvas = null;
       }
+      _this.unbindListeners();
+    });
+    _defineProperty(_assertThisInitialized(_this), "onMapResize", function () {
+      requestAnimationFrame(function () {
+        _this.resetCanvasSize();
+        _this.renderCanvas();
+      });
+    });
+    _defineProperty(_assertThisInitialized(_this), "lngLatToContainer", function (lngLat) {
+      var _this$mapService$lngL = _this.mapService.lngLatToContainer(lngLat),
+        x = _this$mapService$lngL.x,
+        y = _this$mapService$lngL.y;
+      return {
+        x: x * window.devicePixelRatio,
+        y: y * window.devicePixelRatio
+      };
     });
     return _this;
   }
-  _createClass(CanvaModel, [{
-    key: "clearModels",
-    value: function clearModels() {
-      if (this.canvas) {
-        var _this$mapService$getC;
-        (_this$mapService$getC = this.mapService.getContainer()) === null || _this$mapService$getC === void 0 || _this$mapService$getC.removeChild(this.canvas);
-        // @ts-ignore
-        this.canvas = null;
-      }
-      this.unBindListener();
+  _createClass(CanvasModel, [{
+    key: "layerConfig",
+    get: function get() {
+      return this.layer.getLayerConfig();
     }
   }, {
     key: "initModels",
     value: function () {
       var _initModels = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
-        var _ref3, _ref3$update, update;
         return _regeneratorRuntime.wrap(function _callee$(_context) {
           while (1) switch (_context.prev = _context.next) {
             case 0:
-              _ref3 = this.layer.getLayerConfig(), _ref3$update = _ref3.update, update = _ref3$update === void 0 ? CanvasUpdateType.ALWAYS : _ref3$update;
-              this.updateMode = update;
-              this.initCanvas();
               this.renderCanvas();
-              this.bindListener();
-              this.mapService.getContainer();
               return _context.abrupt("return", []);
-            case 7:
+            case 2:
             case "end":
               return _context.stop();
           }
@@ -137,59 +148,34 @@ var CanvaModel = /*#__PURE__*/function (_BaseModel) {
       return initModels;
     }()
   }, {
-    key: "initCanvas",
-    value: function initCanvas() {
-      var _this$mapService$getC2;
-      var _ref4 = this.layer.getLayerConfig(),
-        zIndex = _ref4.zIndex;
-      var size = this.mapService.getSize();
-      var _size2 = _slicedToArray(size, 2),
-        width = _size2[0],
-        height = _size2[1];
-      var _this$rendererService3 = this.rendererService.getViewportSize(),
-        viewWidth = _this$rendererService3.width,
-        viewHeight = _this$rendererService3.height;
-      this.prevSize = [viewWidth, viewHeight];
-      var canvas = document.createElement('canvas');
-      this.canvas = canvas;
-      canvas.width = viewWidth;
-      canvas.height = viewHeight;
-      canvas.style.pointerEvents = 'none';
-      canvas.style.width = width + 'px';
-      canvas.style.height = height + 'px';
-      canvas.style.position = 'absolute';
-      canvas.style.top = '0';
-      canvas.style.left = '0';
-      canvas.style.zIndex = zIndex + '';
-      (_this$mapService$getC2 = this.mapService.getContainer()) === null || _this$mapService$getC2 === void 0 || _this$mapService$getC2.appendChild(canvas);
-      var ctx = canvas.getContext('2d');
-      this.ctx = ctx;
+    key: "bindListeners",
+    value: function bindListeners() {
+      this.mapService.on('resize', this.onMapResize);
+      var _this$layerConfig3 = this.layerConfig,
+        trigger = _this$layerConfig3.trigger,
+        update = _this$layerConfig3.update;
+      if (update === CanvasUpdateType.ALWAYS || trigger === 'change') {
+        this.mapService.on('mapchange', this.renderCanvas);
+      } else {
+        this.mapService.on('zoomstart', this.removeCanvas);
+        this.mapService.on('zoomend', this.renderCanvas);
+        this.mapService.on('movestart', this.removeCanvas);
+        this.mapService.on('moveend', this.renderCanvas);
+      }
     }
   }, {
-    key: "buildModels",
-    value: function () {
-      var _buildModels = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
-        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
-          while (1) switch (_context2.prev = _context2.next) {
-            case 0:
-              return _context2.abrupt("return", this.initModels());
-            case 1:
-            case "end":
-              return _context2.stop();
-          }
-        }, _callee2, this);
-      }));
-      function buildModels() {
-        return _buildModels.apply(this, arguments);
-      }
-      return buildModels;
-    }()
+    key: "unbindListeners",
+    value: function unbindListeners() {
+      this.mapService.off('resize', this.onMapResize);
+      this.mapService.off('mapchange', this.renderCanvas);
+      this.mapService.off('zoomstart', this.removeCanvas);
+      this.mapService.off('zoomend', this.renderCanvas);
+      this.mapService.off('movestart', this.removeCanvas);
+      this.mapService.off('moveend', this.renderCanvas);
+    }
   }, {
     key: "registerBuiltinAttributes",
-    value: function registerBuiltinAttributes() {
-      return;
-    }
+    value: function registerBuiltinAttributes() {}
   }]);
-  return CanvaModel;
-}(BaseModel);
-export { CanvaModel as default };
+  return CanvasModel;
+}(BaseModel);

package/es/canvas/models/constants.d.ts

@@ -0,0 +1,2 @@
+export type CanvasModelType = 'canvas2d' | 'webgl' | 'webgl2' | 'webgpu';
+export declare const CanvasContextTypeMap: Record<CanvasModelType, string>;

package/es/canvas/models/constants.js

@@ -0,0 +1,6 @@
+export var CanvasContextTypeMap = {
+  canvas2d: '2d',
+  webgl: 'webgl',
+  webgl2: 'webgl2',
+  webgpu: 'webgpu'
+};

package/es/canvas/models/index.d.ts

@@ -1,5 +1,2 @@
-export type CanvasModelType = 'canvas';
-declare const CanvasModels: {
-    [key in CanvasModelType]: any;
-};
-export default CanvasModels;
+export * from './canvas';
+export * from './constants';

package/es/canvas/models/index.js

@@ -1,5 +1,2 @@
-import CanvasModel from "./canvas";
-var CanvasModels = {
-  canvas: CanvasModel
-};
-export default CanvasModels;
+export * from "./canvas";
+export * from "./constants";

package/es/core/BaseLayer.d.ts

@@ -1,9 +1,8 @@
 import { AsyncSeriesBailHook, AsyncWaterfallHook, SyncBailHook, SyncHook } from '@antv/async-hook';
-import type { IActiveOption, IAnimateOption, IAttributeAndElements, IBuffer, ICameraService, ICoordinateSystemService, IDataState, IDebugService, IEncodeFeature, IFontService, IGlobalConfigService, IIconService, IInteractionService, ILayer, ILayerAttributesOption, ILayerConfig, ILayerModel, ILayerModelInitializationOptions, ILayerPickService, ILayerPlugin, ILayerService, ILegend, IMapService, IModel, IModelInitializationOptions, IMultiPassRenderer, IParseDataItem, IPass, IPickingService, IPostProcessingPass, IRenderOptions, IRendererService, IScale, IScaleOptions, IShaderModuleService, ISourceCFG, IStyleAttributeService, IStyleAttributeUpdateOptions, ITextureService, LayerEventType, LegendItems, StyleAttributeField, StyleAttributeOption, Triangulation } from '@antv/l7-core';
+import type { IActiveOption, IAnimateOption, IAttributeAndElements, IBuffer, IDataState, IEncodeFeature, IGlobalConfigService, ILayer, ILayerAttributesOption, ILayerConfig, ILayerModel, ILayerModelInitializationOptions, ILayerPickService, ILayerPlugin, ILegend, IModel, IModelInitializationOptions, IMultiPassRenderer, IParseDataItem, IPostProcessingPass, IRenderOptions, IScale, IScaleOptions, ISourceCFG, IStyleAttributeService, IStyleAttributeUpdateOptions, ITextureService, L7Container, LayerEventType, LegendItems, StyleAttributeField, StyleAttributeOption, Triangulation } from '@antv/l7-core';
 import { BlendType } from '@antv/l7-core';
-import Source from '@antv/l7-source';
+import type Source from '@antv/l7-source';
 import { EventEmitter } from 'eventemitter3';
-import type { Container } from 'inversify';
 export default class BaseLayer<ChildLayerStyleOptions = {}> extends EventEmitter<LayerEventType> implements ILayer {
     id: string;
     name: string;
@@ -59,31 +58,30 @@ export default class BaseLayer<ChildLayerStyleOptions = {}> extends EventEmitter
         field: any;
         values: any;
     };
-    sceneContainer: Container | undefined;
     tileLayer: any | undefined;
     layerChildren: ILayer[];
     masks: ILayer[];
     protected readonly configService: IGlobalConfigService;
-    protected shaderModuleService: IShaderModuleService;
-    protected cameraService: ICameraService;
-    protected coordinateService: ICoordinateSystemService;
-    protected iconService: IIconService;
-    protected fontService: IFontService;
-    protected pickingService: IPickingService;
-    protected rendererService: IRendererService;
-    protected layerService: ILayerService;
-    protected debugService: IDebugService;
-    protected interactionService: IInteractionService;
-    protected mapService: IMapService;
+    protected get shaderModuleService(): import("@antv/l7-core").IShaderModuleService;
+    protected get cameraService(): import("@antv/l7-core").ICameraService;
+    protected get coordinateService(): import("@antv/l7-core").ICoordinateSystemService;
+    protected get iconService(): import("@antv/l7-core").IIconService;
+    protected get fontService(): import("@antv/l7-core").IFontService;
+    protected get pickingService(): import("@antv/l7-core").IPickingService;
+    protected get rendererService(): import("@antv/l7-core").IRendererService;
+    protected get layerService(): import("@antv/l7-core").ILayerService;
+    protected get debugService(): import("@antv/l7-core").IDebugService;
+    protected get interactionService(): import("@antv/l7-core/es/services/interaction/InteractionService").default;
+    protected get mapService(): import("@antv/l7-core").IMapService<{}>;
     styleAttributeService: IStyleAttributeService;
     protected layerSource: Source;
     postProcessingPassFactory: (name: string) => IPostProcessingPass<unknown>;
-    normalPassFactory: (name: string) => IPass<unknown>;
+    get normalPassFactory(): (name: string) => import("@antv/l7-core").IPass<unknown>;
     protected animateOptions: IAnimateOption;
     /**
      * 图层容器
      */
-    protected container: Container;
+    container: L7Container;
     private encodedData;
     private currentPickId;
     protected rawConfig: Partial<ILayerConfig & ChildLayerStyleOptions>;
@@ -130,8 +128,8 @@ export default class BaseLayer<ChildLayerStyleOptions = {}> extends EventEmitter
      *  -> SceneContainer 1.*
      *   -> LayerContainer 1.*
      */
-    setContainer(container: Container, sceneContainer: Container): void;
-    getContainer(): Container;
+    setContainer(container: L7Container): void;
+    getContainer(): L7Container;
     addPlugin(plugin: ILayerPlugin): ILayer;
     init(): Promise<void>;
     log(logType: string, step?: string): void;
@@ -151,6 +149,7 @@ export default class BaseLayer<ChildLayerStyleOptions = {}> extends EventEmitter
     animate(options: IAnimateOption | boolean): this;
     source(data: any, options?: ISourceCFG): ILayer;
     setData(data: any, options?: ISourceCFG): this;
+    private dataUpdatelog;
     style(options: Partial<ChildLayerStyleOptions> & Partial<ILayerConfig>): ILayer;
     private encodeStyle;
     scale(field: string | number | IScaleOptions, cfg?: IScale): this;