@antv/l7-map 2.21.1 → 2.21.3

package/es/handler/handler_util.js

@@ -1,8 +1,8 @@
 // @ts-ignore
 
 export function indexTouches(touches, points) {
-  var obj = {};
-  for (var i = 0; i < touches.length; i++) {
+  const obj = {};
+  for (let i = 0; i < touches.length; i++) {
     obj[touches[i].identifier] = points[i];
   }
   return obj;

package/es/handler/keyboard.js

@@ -1,6 +1,5 @@
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
-import _createClass from "@babel/runtime/helpers/esm/createClass";
-var defaultOptions = {
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+const defaultOptions = {
   panStep: 100,
   bearingStep: 15,
   pitchStep: 10
@@ -20,123 +19,112 @@ var defaultOptions = {
  * - `Shift+⇡`: Increase the pitch by 10 degrees.
  * - `Shift+⇣`: Decrease the pitch by 10 degrees.
  */
-var KeyboardHandler = /*#__PURE__*/function () {
+class KeyboardHandler {
   /**
    * @private
    */
-  function KeyboardHandler() {
-    _classCallCheck(this, KeyboardHandler);
-    var stepOptions = defaultOptions;
+  constructor() {
+    _defineProperty(this, "enabled", void 0);
+    _defineProperty(this, "active", void 0);
+    _defineProperty(this, "panStep", void 0);
+    _defineProperty(this, "bearingStep", void 0);
+    _defineProperty(this, "pitchStep", void 0);
+    const stepOptions = defaultOptions;
     this.panStep = stepOptions.panStep;
     this.bearingStep = stepOptions.bearingStep;
     this.pitchStep = stepOptions.pitchStep;
   }
-  _createClass(KeyboardHandler, [{
-    key: "reset",
-    value: function reset() {
-      this.active = false;
+  reset() {
+    this.active = false;
+  }
+  keydown(e) {
+    if (e.altKey || e.ctrlKey || e.metaKey) {
+      return;
     }
-  }, {
-    key: "keydown",
-    value: function keydown(e) {
-      var _this = this;
-      if (e.altKey || e.ctrlKey || e.metaKey) {
-        return;
-      }
-      var zoomDir = 0;
-      var bearingDir = 0;
-      var pitchDir = 0;
-      var xDir = 0;
-      var yDir = 0;
-      switch (e.keyCode) {
-        case 61:
-        case 107:
-        case 171:
-        case 187:
-          zoomDir = 1;
-          break;
-        case 189:
-        case 109:
-        case 173:
-          zoomDir = -1;
-          break;
-        case 37:
-          if (e.shiftKey) {
-            bearingDir = -1;
-          } else {
-            e.preventDefault();
-            xDir = -1;
-          }
-          break;
-        case 39:
-          if (e.shiftKey) {
-            bearingDir = 1;
-          } else {
-            e.preventDefault();
-            xDir = 1;
-          }
-          break;
-        case 38:
-          if (e.shiftKey) {
-            pitchDir = 1;
-          } else {
-            e.preventDefault();
-            yDir = -1;
-          }
-          break;
-        case 40:
-          if (e.shiftKey) {
-            pitchDir = -1;
-          } else {
-            e.preventDefault();
-            yDir = 1;
-          }
-          break;
-        default:
-          return;
-      }
-      return {
-        cameraAnimation: function cameraAnimation(map) {
-          var zoom = map.getZoom();
-          map.easeTo({
-            duration: 300,
-            easeId: 'keyboardHandler',
-            easing: easeOut,
-            zoom: zoomDir ? Math.round(zoom) + zoomDir * (e.shiftKey ? 2 : 1) : zoom,
-            bearing: map.getBearing() + bearingDir * _this.bearingStep,
-            pitch: map.getPitch() + pitchDir * _this.pitchStep,
-            offset: [-xDir * _this.panStep, -yDir * _this.panStep],
-            center: map.getCenter()
-          }, {
-            originalEvent: e
-          });
+    let zoomDir = 0;
+    let bearingDir = 0;
+    let pitchDir = 0;
+    let xDir = 0;
+    let yDir = 0;
+    switch (e.keyCode) {
+      case 61:
+      case 107:
+      case 171:
+      case 187:
+        zoomDir = 1;
+        break;
+      case 189:
+      case 109:
+      case 173:
+        zoomDir = -1;
+        break;
+      case 37:
+        if (e.shiftKey) {
+          bearingDir = -1;
+        } else {
+          e.preventDefault();
+          xDir = -1;
         }
-      };
-    }
-  }, {
-    key: "enable",
-    value: function enable() {
-      this.enabled = true;
-    }
-  }, {
-    key: "disable",
-    value: function disable() {
-      this.enabled = false;
-      this.reset();
-    }
-  }, {
-    key: "isEnabled",
-    value: function isEnabled() {
-      return this.enabled;
-    }
-  }, {
-    key: "isActive",
-    value: function isActive() {
-      return this.active;
+        break;
+      case 39:
+        if (e.shiftKey) {
+          bearingDir = 1;
+        } else {
+          e.preventDefault();
+          xDir = 1;
+        }
+        break;
+      case 38:
+        if (e.shiftKey) {
+          pitchDir = 1;
+        } else {
+          e.preventDefault();
+          yDir = -1;
+        }
+        break;
+      case 40:
+        if (e.shiftKey) {
+          pitchDir = -1;
+        } else {
+          e.preventDefault();
+          yDir = 1;
+        }
+        break;
+      default:
+        return;
     }
-  }]);
-  return KeyboardHandler;
-}();
+    return {
+      cameraAnimation: map => {
+        const zoom = map.getZoom();
+        map.easeTo({
+          duration: 300,
+          easeId: 'keyboardHandler',
+          easing: easeOut,
+          zoom: zoomDir ? Math.round(zoom) + zoomDir * (e.shiftKey ? 2 : 1) : zoom,
+          bearing: map.getBearing() + bearingDir * this.bearingStep,
+          pitch: map.getPitch() + pitchDir * this.pitchStep,
+          offset: [-xDir * this.panStep, -yDir * this.panStep],
+          center: map.getCenter()
+        }, {
+          originalEvent: e
+        });
+      }
+    };
+  }
+  enable() {
+    this.enabled = true;
+  }
+  disable() {
+    this.enabled = false;
+    this.reset();
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  isActive() {
+    return this.active;
+  }
+}
 function easeOut(t) {
   return t * (2 - t);
 }

package/es/handler/map_event.js

@@ -1,125 +1,89 @@
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
-import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
 // @ts-ignore
 
 import { MapMouseEvent, MapTouchEvent, MapWheelEvent } from "./events";
-var MapEventHandler = /*#__PURE__*/function () {
-  function MapEventHandler(map, options) {
-    _classCallCheck(this, MapEventHandler);
+export default class MapEventHandler {
+  constructor(map, options) {
+    _defineProperty(this, "mousedownPos", void 0);
+    _defineProperty(this, "clickTolerance", void 0);
+    _defineProperty(this, "map", void 0);
     this.map = map;
     this.clickTolerance = options.clickTolerance;
   }
-  _createClass(MapEventHandler, [{
-    key: "reset",
-    value: function reset() {
-      // @ts-ignore
-      delete this.mousedownPos;
-    }
-  }, {
-    key: "wheel",
-    value: function wheel(e) {
-      // If mapEvent.preventDefault() is called by the user, prevent handlers such as:
-      // - ScrollZoom
-      return this.firePreventable(new MapWheelEvent(e.type, this.map, e));
-    }
-  }, {
-    key: "mousedown",
-    value: function mousedown(e, point) {
-      this.mousedownPos = point;
-      // If mapEvent.preventDefault() is called by the user, prevent handlers such as:
-      // - MousePan
-      // - MouseRotate
-      // - MousePitch
-      // - DblclickHandler
-      return this.firePreventable(new MapMouseEvent(e.type, this.map, e));
-    }
-  }, {
-    key: "mouseup",
-    value: function mouseup(e) {
-      this.map.emit(e.type, new MapMouseEvent(e.type, this.map, e));
-    }
-  }, {
-    key: "click",
-    value: function click(e, point) {
-      if (this.mousedownPos && this.mousedownPos.dist(point) >= this.clickTolerance) {
-        return;
-      }
-      this.map.emit(e.type, new MapMouseEvent(e.type, this.map, e));
-    }
-  }, {
-    key: "dblclick",
-    value: function dblclick(e) {
-      // If mapEvent.preventDefault() is called by the user, prevent handlers such as:
-      // - DblClickZoom
-      return this.firePreventable(new MapMouseEvent(e.type, this.map, e));
-    }
-  }, {
-    key: "mouseover",
-    value: function mouseover(e) {
-      this.map.emit(e.type, new MapMouseEvent(e.type, this.map, e));
-    }
-  }, {
-    key: "mouseout",
-    value: function mouseout(e) {
-      this.map.emit(e.type, new MapMouseEvent(e.type, this.map, e));
-    }
-  }, {
-    key: "touchstart",
-    value: function touchstart(e) {
-      // If mapEvent.preventDefault() is called by the user, prevent handlers such as:
-      // - TouchPan
-      // - TouchZoom
-      // - TouchRotate
-      // - TouchPitch
-      // - TapZoom
-      // - SwipeZoom
-      return this.firePreventable(new MapTouchEvent(e.type, this.map, e));
-    }
-  }, {
-    key: "touchmove",
-    value: function touchmove(e) {
-      this.map.emit(e.type, new MapTouchEvent(e.type, this.map, e));
-    }
-  }, {
-    key: "touchend",
-    value: function touchend(e) {
-      this.map.emit(e.type, new MapTouchEvent(e.type, this.map, e));
-    }
-  }, {
-    key: "touchcancel",
-    value: function touchcancel(e) {
-      this.map.emit(e.type, new MapTouchEvent(e.type, this.map, e));
-    }
-  }, {
-    key: "firePreventable",
-    value: function firePreventable(mapEvent) {
-      this.map.emit(mapEvent.type, mapEvent);
-      if (mapEvent.defaultPrevented) {
-        // returning an object marks the handler as active and resets other handlers
-        return {};
-      }
-    }
-  }, {
-    key: "isEnabled",
-    value: function isEnabled() {
-      return true;
-    }
-  }, {
-    key: "isActive",
-    value: function isActive() {
-      return false;
-    }
-  }, {
-    key: "enable",
-    value: function enable() {
-      return false;
+  reset() {
+    // @ts-ignore
+    delete this.mousedownPos;
+  }
+  wheel(e) {
+    // If mapEvent.preventDefault() is called by the user, prevent handlers such as:
+    // - ScrollZoom
+    return this.firePreventable(new MapWheelEvent(e.type, this.map, e));
+  }
+  mousedown(e, point) {
+    this.mousedownPos = point;
+    // If mapEvent.preventDefault() is called by the user, prevent handlers such as:
+    // - MousePan
+    // - MouseRotate
+    // - MousePitch
+    // - DblclickHandler
+    return this.firePreventable(new MapMouseEvent(e.type, this.map, e));
+  }
+  mouseup(e) {
+    this.map.emit(e.type, new MapMouseEvent(e.type, this.map, e));
+  }
+  click(e, point) {
+    if (this.mousedownPos && this.mousedownPos.dist(point) >= this.clickTolerance) {
+      return;
     }
-  }, {
-    key: "disable",
-    value: function disable() {
-      return false;
+    this.map.emit(e.type, new MapMouseEvent(e.type, this.map, e));
+  }
+  dblclick(e) {
+    // If mapEvent.preventDefault() is called by the user, prevent handlers such as:
+    // - DblClickZoom
+    return this.firePreventable(new MapMouseEvent(e.type, this.map, e));
+  }
+  mouseover(e) {
+    this.map.emit(e.type, new MapMouseEvent(e.type, this.map, e));
+  }
+  mouseout(e) {
+    this.map.emit(e.type, new MapMouseEvent(e.type, this.map, e));
+  }
+  touchstart(e) {
+    // If mapEvent.preventDefault() is called by the user, prevent handlers such as:
+    // - TouchPan
+    // - TouchZoom
+    // - TouchRotate
+    // - TouchPitch
+    // - TapZoom
+    // - SwipeZoom
+    return this.firePreventable(new MapTouchEvent(e.type, this.map, e));
+  }
+  touchmove(e) {
+    this.map.emit(e.type, new MapTouchEvent(e.type, this.map, e));
+  }
+  touchend(e) {
+    this.map.emit(e.type, new MapTouchEvent(e.type, this.map, e));
+  }
+  touchcancel(e) {
+    this.map.emit(e.type, new MapTouchEvent(e.type, this.map, e));
+  }
+  firePreventable(mapEvent) {
+    this.map.emit(mapEvent.type, mapEvent);
+    if (mapEvent.defaultPrevented) {
+      // returning an object marks the handler as active and resets other handlers
+      return {};
     }
-  }]);
-  return MapEventHandler;
-}();
-export { MapEventHandler as default };
+  }
+  isEnabled() {
+    return true;
+  }
+  isActive() {
+    return false;
+  }
+  enable() {
+    return false;
+  }
+  disable() {
+    return false;
+  }
+}

package/es/handler/mouse/mouse_handler.js

@@ -1,118 +1,99 @@
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
-import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
 // @ts-ignore
 
 import DOM from "../../utils/dom";
 import { buttonStillPressed } from "./util";
-var MouseHandler = /*#__PURE__*/function () {
-  function MouseHandler(options) {
-    _classCallCheck(this, MouseHandler);
+export default class MouseHandler {
+  constructor(options) {
+    _defineProperty(this, "enabled", void 0);
+    _defineProperty(this, "active", void 0);
+    _defineProperty(this, "lastPoint", void 0);
+    _defineProperty(this, "eventButton", void 0);
+    _defineProperty(this, "moved", void 0);
+    _defineProperty(this, "clickTolerance", void 0);
     this.reset();
     this.clickTolerance = options.clickTolerance || 1;
   }
-  _createClass(MouseHandler, [{
-    key: "reset",
-    value: function reset() {
-      this.active = false;
-      this.moved = false;
-      // @ts-ignore
-      delete this.lastPoint;
-      // @ts-ignore
-      delete this.eventButton;
+  reset() {
+    this.active = false;
+    this.moved = false;
+    // @ts-ignore
+    delete this.lastPoint;
+    // @ts-ignore
+    delete this.eventButton;
+  }
+  mousedown(e, point) {
+    if (this.lastPoint) {
+      return;
     }
-  }, {
-    key: "mousedown",
-    value: function mousedown(e, point) {
-      if (this.lastPoint) {
-        return;
-      }
-      var eventButton = DOM.mouseButton(e);
-      if (!this.correctButton(e, eventButton)) {
-        return;
-      }
-      this.lastPoint = point;
-      this.eventButton = eventButton;
+    const eventButton = DOM.mouseButton(e);
+    if (!this.correctButton(e, eventButton)) {
+      return;
     }
-  }, {
-    key: "mousemoveWindow",
-    value: function mousemoveWindow(e, point) {
-      var lastPoint = this.lastPoint;
-      if (!lastPoint) {
-        return;
-      }
-      e.preventDefault();
-      if (buttonStillPressed(e, this.eventButton)) {
-        // Some browsers don't fire a `mouseup` when the mouseup occurs outside
-        // the window or iframe:
-        // https://github.com/mapbox/mapbox-gl-js/issues/4622
-        //
-        // If the button is no longer pressed during this `mousemove` it may have
-        // been released outside of the window or iframe.
-        this.reset();
-        return;
-      }
-      if (!this.moved && point.dist(lastPoint) < this.clickTolerance) {
-        return;
-      }
-      this.moved = true;
-      this.lastPoint = point;
-
-      // implemented by child class
-      return this.move(lastPoint, point);
+    this.lastPoint = point;
+    this.eventButton = eventButton;
+  }
+  mousemoveWindow(e, point) {
+    const lastPoint = this.lastPoint;
+    if (!lastPoint) {
+      return;
     }
-  }, {
-    key: "mouseupWindow",
-    value: function mouseupWindow(e) {
-      if (!this.lastPoint) {
-        return;
-      }
-      var eventButton = DOM.mouseButton(e);
-      if (eventButton !== this.eventButton) {
-        return;
-      }
-      if (this.moved) {
-        DOM.suppressClick();
-      }
+    e.preventDefault();
+    if (buttonStillPressed(e, this.eventButton)) {
+      // Some browsers don't fire a `mouseup` when the mouseup occurs outside
+      // the window or iframe:
+      // https://github.com/mapbox/mapbox-gl-js/issues/4622
+      //
+      // If the button is no longer pressed during this `mousemove` it may have
+      // been released outside of the window or iframe.
       this.reset();
+      return;
     }
-  }, {
-    key: "enable",
-    value: function enable() {
-      this.enabled = true;
+    if (!this.moved && point.dist(lastPoint) < this.clickTolerance) {
+      return;
     }
-  }, {
-    key: "disable",
-    value: function disable() {
-      this.enabled = false;
-      this.reset();
+    this.moved = true;
+    this.lastPoint = point;
+
+    // implemented by child class
+    return this.move(lastPoint, point);
+  }
+  mouseupWindow(e) {
+    if (!this.lastPoint) {
+      return;
     }
-  }, {
-    key: "isEnabled",
-    value: function isEnabled() {
-      return this.enabled;
+    const eventButton = DOM.mouseButton(e);
+    if (eventButton !== this.eventButton) {
+      return;
     }
-  }, {
-    key: "isActive",
-    value: function isActive() {
-      return this.active;
+    if (this.moved) {
+      DOM.suppressClick();
     }
+    this.reset();
+  }
+  enable() {
+    this.enabled = true;
+  }
+  disable() {
+    this.enabled = false;
+    this.reset();
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  isActive() {
+    return this.active;
+  }
 
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  }, {
-    key: "correctButton",
-    value: function correctButton(e, button) {
-      // eslint-disable-line
-      return false; // implemented by child
-    }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  correctButton(e, button) {
+    // eslint-disable-line
+    return false; // implemented by child
+  }
 
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  }, {
-    key: "move",
-    value: function move(lastPoint, point) {
-      // eslint-disable-line
-      return; // implemented by child
-    }
-  }]);
-  return MouseHandler;
-}();
-export { MouseHandler as default };
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  move(lastPoint, point) {
+    // eslint-disable-line
+    return; // implemented by child
+  }
+}