@antv/l7-map 2.17.10 → 2.17.12

package/es/handler/blockable_map_event.js

@@ -1,18 +1,20 @@
 import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
 import _createClass from "@babel/runtime/helpers/esm/createClass";
 // @ts-ignore
-
 import { MapMouseEvent } from "./events";
+
 var BlockableMapEventHandler = /*#__PURE__*/function () {
   function BlockableMapEventHandler(map) {
     _classCallCheck(this, BlockableMapEventHandler);
+
     this.map = map;
   }
+
   _createClass(BlockableMapEventHandler, [{
     key: "reset",
     value: function reset() {
-      this.delayContextMenu = false;
-      // @ts-ignore
+      this.delayContextMenu = false; // @ts-ignore
+
       delete this.contextMenuEvent;
     }
   }, {
@@ -30,9 +32,10 @@ var BlockableMapEventHandler = /*#__PURE__*/function () {
     key: "mouseup",
     value: function mouseup() {
       this.delayContextMenu = false;
+
       if (this.contextMenuEvent) {
-        this.map.emit('contextmenu', new MapMouseEvent('contextmenu', this.map, this.contextMenuEvent));
-        // @ts-ignore
+        this.map.emit('contextmenu', new MapMouseEvent('contextmenu', this.map, this.contextMenuEvent)); // @ts-ignore
+
         delete this.contextMenuEvent;
       }
     }
@@ -45,9 +48,9 @@ var BlockableMapEventHandler = /*#__PURE__*/function () {
       } else {
         // Windows: contextmenu fired on mouseup, so fire event now
         this.map.emit(e.type, new MapMouseEvent(e.type, this.map, e));
-      }
+      } // prevent browser context menu when necessary
+
 
-      // prevent browser context menu when necessary
       if (this.map.listeners('contextmenu')) {
         e.preventDefault();
       }
@@ -73,6 +76,8 @@ var BlockableMapEventHandler = /*#__PURE__*/function () {
       return false;
     }
   }]);
+
   return BlockableMapEventHandler;
 }();
+
 export { BlockableMapEventHandler as default };

package/es/handler/box_zoom.js

@@ -1,75 +1,78 @@
 import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
 import _createClass from "@babel/runtime/helpers/esm/createClass";
 // @ts-ignore
-
 import DOM from "../utils/dom";
 import { Event } from "./events/event";
-
 /**
  * The `BoxZoomHandler` allows the user to zoom the map to fit within a bounding box.
  * The bounding box is defined by clicking and holding `shift` while dragging the cursor.
  */
+
 var BoxZoomHandler = /*#__PURE__*/function () {
   /**
    * @private
    */
   function BoxZoomHandler(map, options) {
     _classCallCheck(this, BoxZoomHandler);
+
     this.map = map;
     this.el = map.getCanvasContainer();
     this.container = map.getContainer();
     this.clickTolerance = options.clickTolerance || 1;
   }
-
   /**
    * Returns a Boolean indicating whether the "box zoom" interaction is enabled.
    *
    * @returns {boolean} `true` if the "box zoom" interaction is enabled.
    */
+
+
   _createClass(BoxZoomHandler, [{
     key: "isEnabled",
     value: function isEnabled() {
       return !!this.enabled;
     }
-
     /**
      * Returns a Boolean indicating whether the "box zoom" interaction is active, i.e. currently being used.
      *
      * @returns {boolean} `true` if the "box zoom" interaction is active.
      */
+
   }, {
     key: "isActive",
     value: function isActive() {
       return !!this.active;
     }
-
     /**
      * Enables the "box zoom" interaction.
      *
      * @example
      *   map.boxZoom.enable();
      */
+
   }, {
     key: "enable",
     value: function enable() {
       if (this.isEnabled()) {
         return;
       }
+
       this.enabled = true;
     }
-
     /**
      * Disables the "box zoom" interaction.
      *
      * @example
      *   map.boxZoom.disable();
      */
+
   }, {
     key: "disable",
     value: function disable() {
       if (!this.isEnabled()) {
         return;
       }
+
       this.enabled = false;
     }
   }, {
@@ -78,9 +81,11 @@ var BoxZoomHandler = /*#__PURE__*/function () {
       if (!this.isEnabled()) {
         return;
       }
+
       if (!(e.shiftKey && e.button === 0)) {
         return;
       }
+
       DOM.disableDrag();
       this.startPos = this.lastPos = point;
       this.active = true;
@@ -91,22 +96,28 @@ var BoxZoomHandler = /*#__PURE__*/function () {
       if (!this.active) {
         return;
       }
+
       var pos = point;
+
       if (this.lastPos.equals(pos) || !this.box && pos.dist(this.startPos) < this.clickTolerance) {
         return;
       }
+
       var p0 = this.startPos;
       this.lastPos = pos;
+
       if (!this.box) {
         this.box = DOM.create('div', 'l7-boxzoom', this.container);
         this.container.classList.add('l7-crosshair');
         this.fireEvent('boxzoomstart', e);
       }
+
       var minX = Math.min(p0.x, pos.x);
       var maxX = Math.max(p0.x, pos.x);
       var minY = Math.min(p0.y, pos.y);
       var maxY = Math.max(p0.y, pos.y);
       DOM.setTransform(this.box, "translate(".concat(minX, "px,").concat(minY, "px)"));
+
       if (this.box) {
         this.box.style.width = "".concat(maxX - minX, "px");
         this.box.style.height = "".concat(maxY - minY, "px");
@@ -116,16 +127,20 @@ var BoxZoomHandler = /*#__PURE__*/function () {
     key: "mouseupWindow",
     value: function mouseupWindow(e, point) {
       var _this = this;
+
       if (!this.active) {
         return;
       }
+
       if (e.button !== 0) {
         return;
       }
+
       var p0 = this.startPos;
       var p1 = point;
       this.reset();
       DOM.suppressClick();
+
       if (p0.x === p1.x && p0.y === p1.y) {
         this.fireEvent('boxzoomcancel', e);
       } else {
@@ -147,6 +162,7 @@ var BoxZoomHandler = /*#__PURE__*/function () {
       if (!this.active) {
         return;
       }
+
       if (e.keyCode === 27) {
         this.reset();
         this.fireEvent('boxzoomcancel', e);
@@ -157,14 +173,16 @@ var BoxZoomHandler = /*#__PURE__*/function () {
     value: function reset() {
       this.active = false;
       this.container.classList.remove('l7-crosshair');
+
       if (this.box) {
         DOM.remove(this.box);
         this.box = null;
       }
-      DOM.enableDrag();
-      // @ts-ignore
-      delete this.startPos;
-      // @ts-ignore
+
+      DOM.enableDrag(); // @ts-ignore
+
+      delete this.startPos; // @ts-ignore
+
       delete this.lastPos;
     }
   }, {
@@ -175,6 +193,8 @@ var BoxZoomHandler = /*#__PURE__*/function () {
       }));
     }
   }]);
+
   return BoxZoomHandler;
 }();
+
 export default BoxZoomHandler;

package/es/handler/click_zoom.js

@@ -1,11 +1,14 @@
 import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
 import _createClass from "@babel/runtime/helpers/esm/createClass";
+
 // @ts-ignore
 var ClickZoomHandler = /*#__PURE__*/function () {
   function ClickZoomHandler() {
     _classCallCheck(this, ClickZoomHandler);
+
     this.reset();
   }
+
   _createClass(ClickZoomHandler, [{
     key: "reset",
     value: function reset() {
@@ -49,6 +52,8 @@ var ClickZoomHandler = /*#__PURE__*/function () {
       return this.active;
     }
   }]);
+
   return ClickZoomHandler;
 }();
+
 export { ClickZoomHandler as default };

package/es/handler/events/event.js

@@ -4,7 +4,9 @@ import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
 import merge from 'lodash/merge';
 export var Event = /*#__PURE__*/_createClass(function Event(type) {
   var data = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
   _classCallCheck(this, Event);
+
   merge(this, data);
   this.type = type;
 });

package/es/handler/events/map_mouse_event.js

@@ -3,16 +3,22 @@ import _createClass from "@babel/runtime/helpers/esm/createClass";
 import _inherits from "@babel/runtime/helpers/esm/inherits";
 import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
 import _getPrototypeOf from "@babel/runtime/helpers/esm/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; } }
+
 // @ts-ignore
 // tslint:disable-next-line:no-submodule-imports
 import merge from 'lodash/merge';
 import DOM from "../../utils/dom";
 import { Event } from "./event";
+
 var MapMouseEvent = /*#__PURE__*/function (_Event) {
   _inherits(MapMouseEvent, _Event);
+
   var _super = _createSuper(MapMouseEvent);
+
   /**
    * `true` if `preventDefault` has been called.
    * @private
@@ -39,8 +45,11 @@ var MapMouseEvent = /*#__PURE__*/function (_Event) {
    */
   function MapMouseEvent(type, map, originalEvent) {
     var _this;
+
     var data = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+
     _classCallCheck(this, MapMouseEvent);
+
     var point = DOM.mousePos(map.getCanvasContainer(), originalEvent);
     var lngLat = map.unproject(point);
     _this = _super.call(this, type, merge({
@@ -52,12 +61,15 @@ var MapMouseEvent = /*#__PURE__*/function (_Event) {
     _this.target = map;
     return _this;
   }
+
   _createClass(MapMouseEvent, [{
     key: "preventDefault",
     value: function preventDefault() {
       this.defaultPrevented = true;
     }
   }]);
+
   return MapMouseEvent;
 }(Event);
+
 export { MapMouseEvent as default };

package/es/handler/events/map_touch_event.js

@@ -3,16 +3,21 @@ import _createClass from "@babel/runtime/helpers/esm/createClass";
 import _inherits from "@babel/runtime/helpers/esm/inherits";
 import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
 import _getPrototypeOf from "@babel/runtime/helpers/esm/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; } }
-// @ts-ignore
 
+// @ts-ignore
 import Point from "../../geo/point";
 import DOM from "../../utils/dom";
 import { Event } from "./event";
+
 var MapTouchEvent = /*#__PURE__*/function (_Event) {
   _inherits(MapTouchEvent, _Event);
+
   var _super = _createSuper(MapTouchEvent);
+
   /**
    * The event type.
    */
@@ -54,7 +59,9 @@ var MapTouchEvent = /*#__PURE__*/function (_Event) {
    */
   function MapTouchEvent(type, map, originalEvent) {
     var _this;
+
     _classCallCheck(this, MapTouchEvent);
+
     var touches = type === 'touchend' ? originalEvent.changedTouches : originalEvent.touches;
     var points = DOM.touchPos(map.getCanvasContainer(), touches);
     var lngLats = points.map(function (t) {
@@ -74,7 +81,6 @@ var MapTouchEvent = /*#__PURE__*/function (_Event) {
     _this.defaultPrevented = false;
     return _this;
   }
-
   /**
    * Prevents subsequent default processing of the event by the map.
    *
@@ -84,12 +90,16 @@ var MapTouchEvent = /*#__PURE__*/function (_Event) {
    *   * On `touchstart` events, the behavior of {@link TouchZoomRotateHandler}
    *
    */
+
+
   _createClass(MapTouchEvent, [{
     key: "preventDefault",
     value: function preventDefault() {
       this.defaultPrevented = true;
     }
   }]);
+
   return MapTouchEvent;
 }(Event);
+
 export { MapTouchEvent as default };

package/es/handler/events/map_wheel_event.js

@@ -3,12 +3,18 @@ import _createClass from "@babel/runtime/helpers/esm/createClass";
 import _inherits from "@babel/runtime/helpers/esm/inherits";
 import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
 import _getPrototypeOf from "@babel/runtime/helpers/esm/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 { Event } from "./event";
+
 var MapWheelEvent = /*#__PURE__*/function (_Event) {
   _inherits(MapWheelEvent, _Event);
+
   var _super = _createSuper(MapWheelEvent);
+
   /**
    * The event type.
    */
@@ -26,25 +32,30 @@ var MapWheelEvent = /*#__PURE__*/function (_Event) {
    */
   function MapWheelEvent(type, map, originalEvent) {
     var _this;
+
     _classCallCheck(this, MapWheelEvent);
+
     _this = _super.call(this, type, {
       originalEvent: originalEvent
     });
     _this.defaultPrevented = false;
     return _this;
   }
-
   /**
    * Prevents subsequent default processing of the event by the map.
    *
    * Calling this method will prevent the the behavior of {@link ScrollZoomHandler}.
    */
+
+
   _createClass(MapWheelEvent, [{
     key: "preventDefault",
     value: function preventDefault() {
       this.defaultPrevented = true;
     }
   }]);
+
   return MapWheelEvent;
 }(Event);
+
 export { MapWheelEvent as default };

package/es/handler/events/render_event.js

@@ -5,22 +5,35 @@ 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";
+
 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 { Event } from "./event";
+
 var RenderFrameEvent = /*#__PURE__*/function (_Event) {
   _inherits(RenderFrameEvent, _Event);
+
   var _super = _createSuper(RenderFrameEvent);
+
   function RenderFrameEvent() {
     var _this;
+
     _classCallCheck(this, RenderFrameEvent);
+
     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", 'renderFrame');
+
     return _this;
   }
+
   return _createClass(RenderFrameEvent);
 }(Event);
+
 export { RenderFrameEvent as default };

package/es/handler/handler_inertia.js

@@ -1,12 +1,15 @@
 import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
 import _createClass from "@babel/runtime/helpers/esm/createClass";
+
 function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
 function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
 // @ts-ignore
-import Point from "../geo/point";
+import Point from "../geo/point"; // tslint:disable-next-line:no-submodule-imports
 
-// tslint:disable-next-line:no-submodule-imports
 import merge from 'lodash/merge';
 import { bezier, clamp, now } from "../util";
 var defaultInertiaOptions = {
@@ -29,12 +32,15 @@ var defaultPitchInertiaOptions = merge({
   deceleration: 1000,
   maxSpeed: 90
 }, defaultInertiaOptions);
+
 var HandlerInertia = /*#__PURE__*/function () {
   function HandlerInertia(map) {
     _classCallCheck(this, HandlerInertia);
+
     this.map = map;
     this.clear();
   }
+
   _createClass(HandlerInertia, [{
     key: "clear",
     value: function clear() {
@@ -64,9 +70,11 @@ var HandlerInertia = /*#__PURE__*/function () {
     key: "onMoveEnd",
     value: function onMoveEnd(panInertiaOptions) {
       this.drainInertiaBuffer();
+
       if (this.inertiaBuffer.length < 2) {
         return;
       }
+
       var deltas = {
         zoom: 0,
         bearing: 0,
@@ -75,20 +83,25 @@ var HandlerInertia = /*#__PURE__*/function () {
         pinchAround: undefined,
         around: undefined
       };
+
       var _iterator = _createForOfIteratorHelper(this.inertiaBuffer),
-        _step;
+          _step;
+
       try {
         for (_iterator.s(); !(_step = _iterator.n()).done;) {
           var settings = _step.value.settings;
           deltas.zoom += settings.zoomDelta || 0;
           deltas.bearing += settings.bearingDelta || 0;
           deltas.pitch += settings.pitchDelta || 0;
+
           if (settings.panDelta) {
             deltas.pan._add(settings.panDelta);
           }
+
           if (settings.around) {
             deltas.around = settings.around;
           }
+
           if (settings.pinchAround) {
             deltas.pinchAround = settings.pinchAround;
           }
@@ -98,54 +111,69 @@ var HandlerInertia = /*#__PURE__*/function () {
       } finally {
         _iterator.f();
       }
+
       var lastEntry = this.inertiaBuffer[this.inertiaBuffer.length - 1];
       var duration = lastEntry.time - this.inertiaBuffer[0].time;
       var easeOptions = {};
+
       if (deltas.pan.mag()) {
         var result = calculateEasing(deltas.pan.mag(), duration, merge({}, defaultPanInertiaOptions, panInertiaOptions || {}));
         easeOptions.offset = deltas.pan.mult(result.amount / deltas.pan.mag());
         easeOptions.center = this.map.transform.center;
         extendDuration(easeOptions, result);
       }
+
       if (deltas.zoom) {
         var _result = calculateEasing(deltas.zoom, duration, defaultZoomInertiaOptions);
+
         easeOptions.zoom = this.map.transform.zoom + _result.amount;
         extendDuration(easeOptions, _result);
       }
+
       if (deltas.bearing) {
         var _result2 = calculateEasing(deltas.bearing, duration, defaultBearingInertiaOptions);
+
         easeOptions.bearing = this.map.transform.bearing + clamp(_result2.amount, -179, 179);
         extendDuration(easeOptions, _result2);
       }
+
       if (deltas.pitch) {
         var _result3 = calculateEasing(deltas.pitch, duration, defaultPitchInertiaOptions);
+
         easeOptions.pitch = this.map.transform.pitch + _result3.amount;
         extendDuration(easeOptions, _result3);
       }
+
       if (easeOptions.zoom || easeOptions.bearing) {
         var last = deltas.pinchAround === undefined ? deltas.around : deltas.pinchAround;
         easeOptions.around = last ? this.map.unproject(last) : this.map.getCenter();
       }
+
       this.clear();
       return merge(easeOptions, {
         noMoveStart: true
       });
     }
   }]);
+
   return HandlerInertia;
 }(); // Unfortunately zoom, bearing, etc can't have different durations and easings so
 // we need to choose one. We use the longest duration and it's corresponding easing.
+
+
 export { HandlerInertia as default };
+
 function extendDuration(easeOptions, result) {
   if (!easeOptions.duration || easeOptions.duration < result.duration) {
     easeOptions.duration = result.duration;
     easeOptions.easing = result.easing;
   }
 }
+
 function calculateEasing(amount, inertiaDuration, inertiaOptions) {
   var maxSpeed = inertiaOptions.maxSpeed,
-    linearity = inertiaOptions.linearity,
-    deceleration = inertiaOptions.deceleration;
+      linearity = inertiaOptions.linearity,
+      deceleration = inertiaOptions.deceleration;
   var speed = clamp(amount * linearity / (inertiaDuration / 1000), -maxSpeed, maxSpeed);
   var duration = Math.abs(speed) / (deceleration * linearity);
   return {