@antv/l7-layers 2.21.1 → 2.21.3

package/es/canvas/index.js

@@ -1,123 +1,70 @@
 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";
 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 { CanvasModel } from "./models";
-var CanvasLayer = /*#__PURE__*/function (_BaseLayer) {
-  _inherits(CanvasLayer, _BaseLayer);
-  var _super = _createSuper(CanvasLayer);
-  function CanvasLayer() {
-    var _this;
-    _classCallCheck(this, CanvasLayer);
-    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), "type", 'CanvasLayer');
-    return _this;
+export default class CanvasLayer extends BaseLayer {
+  constructor(...args) {
+    super(...args);
+    _defineProperty(this, "type", 'CanvasLayer');
   }
-  _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() {
-        return _regeneratorRuntime.wrap(function _callee$(_context) {
-          while (1) switch (_context.prev = _context.next) {
-            case 0:
-              this.layerModel = new CanvasModel(this);
-              _context.next = 3;
-              return this.initLayerModels();
-            case 3:
-            case "end":
-              return _context.stop();
-          }
-        }, _callee, this);
-      }));
-      function buildModels() {
-        return _buildModels.apply(this, arguments);
-      }
-      return buildModels;
-    }()
-  }, {
-    key: "getModelType",
-    value: function getModelType() {
-      return this.getLayerConfig().contextType || 'canvas2d';
-    }
-  }, {
-    key: "draw",
-    value: function draw(_draw) {
-      this.updateLayerConfig({
-        draw: _draw
-      });
-      this.render();
-      return this;
-    }
-  }, {
-    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;
-      }
-      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: "getCanvas",
-    value: function getCanvas() {
-      var _this$layerModel2;
-      return (_this$layerModel2 = this.layerModel) === null || _this$layerModel2 === void 0 ? void 0 : _this$layerModel2.canvas;
-    }
-  }, {
-    key: "show",
-    value: function show() {
-      var canvas = this.getCanvas();
-      if (canvas) {
-        canvas.style.display = 'unset';
-      }
-      return this;
+  getDefaultConfig() {
+    return {
+      zIndex: 3,
+      contextType: 'canvas2d',
+      trigger: 'change'
+    };
+  }
+  buildModels() {
+    var _this = this;
+    return _asyncToGenerator(function* () {
+      _this.layerModel = new CanvasModel(_this);
+      yield _this.initLayerModels();
+    })();
+  }
+  getModelType() {
+    return this.getLayerConfig().contextType || 'canvas2d';
+  }
+  draw(draw) {
+    this.updateLayerConfig({
+      draw
+    });
+    this.render();
+    return this;
+  }
+  getLayerConfig() {
+    const config = _objectSpread(_objectSpread({}, this.getDefaultConfig()), super.getLayerConfig());
+    if (config.zIndex < 3) {
+      config.zIndex = 3;
     }
-  }, {
-    key: "hide",
-    value: function hide() {
-      var canvas = this.getCanvas();
-      if (canvas) {
-        canvas.style.display = 'none';
-      }
-      return this;
+    return config;
+  }
+  render() {
+    var _this$layerModel;
+    (_this$layerModel = this.layerModel) === null || _this$layerModel === void 0 || _this$layerModel.renderCanvas();
+    return this;
+  }
+  getCanvas() {
+    var _this$layerModel2;
+    return (_this$layerModel2 = this.layerModel) === null || _this$layerModel2 === void 0 ? void 0 : _this$layerModel2.canvas;
+  }
+  show() {
+    const canvas = this.getCanvas();
+    if (canvas) {
+      canvas.style.display = 'unset';
     }
-  }, {
-    key: "destroy",
-    value: function destroy() {
-      this.layerModel.removeCanvas();
-      _get(_getPrototypeOf(CanvasLayer.prototype), "destroy", this).call(this);
+    return this;
+  }
+  hide() {
+    const canvas = this.getCanvas();
+    if (canvas) {
+      canvas.style.display = 'none';
     }
-  }]);
-  return CanvasLayer;
-}(BaseLayer);
-export { CanvasLayer as default };
+    return this;
+  }
+  destroy() {
+    this.layerModel.removeCanvas();
+    super.destroy();
+  }
+}

package/es/canvas/models/canvas.js

@@ -1,181 +1,141 @@
 import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-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 _inherits from "@babel/runtime/helpers/esm/inherits";
-import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
-import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
 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 BaseModel from "../../core/BaseModel";
 import { CanvasUpdateType } from "../../core/interface";
 import { CanvasContextTypeMap } from "./constants";
-export var CanvasModel = /*#__PURE__*/function (_BaseModel) {
-  _inherits(CanvasModel, _BaseModel);
-  var _super = _createSuper(CanvasModel);
-  function CanvasModel() {
-    var _this;
-    _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), "canvas", null);
-    _defineProperty(_assertThisInitialized(_this), "initCanvas", function () {
+export class CanvasModel extends BaseModel {
+  constructor(...args) {
+    super(...args);
+    _defineProperty(this, "canvas", null);
+    _defineProperty(this, "ctx", void 0);
+    _defineProperty(this, "ctxType", void 0);
+    _defineProperty(this, "viewportSize", void 0);
+    _defineProperty(this, "initCanvas", () => {
       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;
+      const {
+        zIndex,
+        getContext
+      } = this.layerConfig;
+      const canvas = document.createElement('canvas');
+      const 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);
+      this.resetCanvasSize();
+      const 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) {
+      this.ctx = getContext ? getContext(canvas) : canvas.getContext(CanvasContextTypeMap[modelType]);
+      if (!this.ctx) {
         console.error('Failed to get rendering context for canvas');
       }
-      _this.bindListeners();
+      this.bindListeners();
     });
-    _defineProperty(_assertThisInitialized(_this), "resetViewportSize", function () {
-      var _this$rendererService = _this.rendererService.getViewportSize(),
-        viewWidth = _this$rendererService.width,
-        viewHeight = _this$rendererService.height;
-      _this.viewportSize = [viewWidth, viewHeight];
+    _defineProperty(this, "resetViewportSize", () => {
+      const {
+        width: viewWidth,
+        height: viewHeight
+      } = this.rendererService.getViewportSize();
+      this.viewportSize = [viewWidth, viewHeight];
     });
-    _defineProperty(_assertThisInitialized(_this), "resetCanvasSize", function () {
-      var canvas = _this.canvas;
+    _defineProperty(this, "resetCanvasSize", () => {
+      const 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];
+      this.resetViewportSize();
+      const [width, height] = this.mapService.getSize();
+      const [viewWidth, viewHeight] = this.viewportSize;
       canvas.width = viewWidth;
       canvas.height = viewHeight;
       canvas.style.width = width + 'px';
       canvas.style.height = height + 'px';
     });
-    _defineProperty(_assertThisInitialized(_this), "renderCanvas", function () {
+    _defineProperty(this, "renderCanvas", () => {
       var _ref;
-      if (!_this.canvas) {
-        _this.initCanvas();
+      if (!this.canvas) {
+        this.initCanvas();
       }
-      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();
+      const {
+        draw,
+        drawingOnCanvas
+      } = this.layerConfig;
+      const [width, height] = this.viewportSize;
+      const bounds = this.mapService.getBounds();
       (_ref = draw !== null && draw !== void 0 ? draw : drawingOnCanvas) === null || _ref === void 0 || _ref({
-        canvas: _this.canvas,
-        ctx: _this.ctx,
+        canvas: this.canvas,
+        ctx: this.ctx,
         container: {
-          width: width,
-          height: height,
-          bounds: bounds
+          width,
+          height,
+          bounds
         },
         size: [width, height],
         utils: {
-          lngLatToContainer: _this.lngLatToContainer
+          lngLatToContainer: this.lngLatToContainer
         },
-        mapService: _this.mapService
+        mapService: this.mapService
       });
     });
-    _defineProperty(_assertThisInitialized(_this), "removeCanvas", function () {
-      if (_this.canvas) {
+    _defineProperty(this, "removeCanvas", () => {
+      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$canvas$parentEl = this.canvas.parentElement) === null || _this$canvas$parentEl === void 0 || _this$canvas$parentEl.removeChild(this.canvas);
+        this.canvas = null;
       }
-      _this.unbindListeners();
+      this.unbindListeners();
     });
-    _defineProperty(_assertThisInitialized(_this), "onMapResize", function () {
-      requestAnimationFrame(function () {
-        _this.resetCanvasSize();
-        _this.renderCanvas();
+    _defineProperty(this, "onMapResize", () => {
+      requestAnimationFrame(() => {
+        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;
+    _defineProperty(this, "lngLatToContainer", lngLat => {
+      const {
+        x,
+        y
+      } = this.mapService.lngLatToContainer(lngLat);
       return {
         x: x * window.devicePixelRatio,
         y: y * window.devicePixelRatio
       };
     });
-    return _this;
   }
-  _createClass(CanvasModel, [{
-    key: "layerConfig",
-    get: function get() {
-      return this.layer.getLayerConfig();
-    }
-  }, {
-    key: "initModels",
-    value: function () {
-      var _initModels = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
-        return _regeneratorRuntime.wrap(function _callee$(_context) {
-          while (1) switch (_context.prev = _context.next) {
-            case 0:
-              this.renderCanvas();
-              return _context.abrupt("return", []);
-            case 2:
-            case "end":
-              return _context.stop();
-          }
-        }, _callee, this);
-      }));
-      function initModels() {
-        return _initModels.apply(this, arguments);
-      }
-      return initModels;
-    }()
-  }, {
-    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: "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);
+  get layerConfig() {
+    return this.layer.getLayerConfig();
+  }
+  initModels() {
+    var _this = this;
+    return _asyncToGenerator(function* () {
+      _this.renderCanvas();
+      return [];
+    })();
+  }
+  bindListeners() {
+    this.mapService.on('resize', this.onMapResize);
+    const {
+      trigger,
+      update
+    } = this.layerConfig;
+    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: "registerBuiltinAttributes",
-    value: function registerBuiltinAttributes() {}
-  }]);
-  return CanvasModel;
-}(BaseModel);
+  }
+  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);
+  }
+  registerBuiltinAttributes() {}
+}

package/es/canvas/models/constants.js

@@ -1,4 +1,4 @@
-export var CanvasContextTypeMap = {
+export const CanvasContextTypeMap = {
   canvas2d: '2d',
   webgl: 'webgl',
   webgl2: 'webgl2',

package/es/citybuliding/building.js

@@ -1,63 +1,25 @@
 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 _inherits from "@babel/runtime/helpers/esm/inherits";
-import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
-import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
 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 BaseLayer from "../core/BaseLayer";
 import CityBuildModel from "./models/build";
-var CityBuildingLayer = /*#__PURE__*/function (_BaseLayer) {
-  _inherits(CityBuildingLayer, _BaseLayer);
-  var _super = _createSuper(CityBuildingLayer);
-  function CityBuildingLayer() {
-    var _this;
-    _classCallCheck(this, CityBuildingLayer);
-    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), "type", 'CityBuildingLayer');
-    return _this;
+export default class CityBuildingLayer extends BaseLayer {
+  constructor(...args) {
+    super(...args);
+    _defineProperty(this, "type", 'CityBuildingLayer');
   }
-  _createClass(CityBuildingLayer, [{
-    key: "buildModels",
-    value: function () {
-      var _buildModels = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
-        return _regeneratorRuntime.wrap(function _callee$(_context) {
-          while (1) switch (_context.prev = _context.next) {
-            case 0:
-              this.layerModel = new CityBuildModel(this);
-              _context.next = 3;
-              return this.initLayerModels();
-            case 3:
-            case "end":
-              return _context.stop();
-          }
-        }, _callee, this);
-      }));
-      function buildModels() {
-        return _buildModels.apply(this, arguments);
-      }
-      return buildModels;
-    }()
-  }, {
-    key: "setLight",
-    value: function setLight(t) {
-      this.updateLayerConfig({
-        time: t
-      });
-    }
-  }, {
-    key: "getModelType",
-    value: function getModelType() {
-      return 'citybuilding';
-    }
-  }]);
-  return CityBuildingLayer;
-}(BaseLayer);
-export { CityBuildingLayer as default };
+  buildModels() {
+    var _this = this;
+    return _asyncToGenerator(function* () {
+      _this.layerModel = new CityBuildModel(_this);
+      yield _this.initLayerModels();
+    })();
+  }
+  setLight(t) {
+    this.updateLayerConfig({
+      time: t
+    });
+  }
+  getModelType() {
+    return 'citybuilding';
+  }
+}