@antv/l7-map 2.21.0 → 2.21.2

package/lib/handler/handler_util.d.ts

@@ -0,0 +1,4 @@
+import type Point from '../geo/point';
+export declare function indexTouches(touches: Touch[], points: Point[]): {
+    [key: string]: any;
+};

package/lib/handler/handler_util.js

@@ -7,8 +7,8 @@ exports.indexTouches = indexTouches;
 // @ts-ignore
 
 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/lib/handler/keyboard.d.ts

@@ -0,0 +1,36 @@
+import type { EarthMap } from '../earthmap';
+import type { Map } from '../map';
+/**
+ * The `KeyboardHandler` allows the user to zoom, rotate, and pan the map using
+ * the following keyboard shortcuts:
+ *
+ * - `=` / `+`: Increase the zoom level by 1.
+ * - `Shift-=` / `Shift-+`: Increase the zoom level by 2.
+ * - `-`: Decrease the zoom level by 1.
+ * - `Shift--`: Decrease the zoom level by 2.
+ * - Arrow keys: Pan by 100 pixels.
+ * - `Shift+⇢`: Increase the rotation by 15 degrees.
+ * - `Shift+⇠`: Decrease the rotation by 15 degrees.
+ * - `Shift+⇡`: Increase the pitch by 10 degrees.
+ * - `Shift+⇣`: Decrease the pitch by 10 degrees.
+ */
+declare class KeyboardHandler {
+    private enabled;
+    private active;
+    private panStep;
+    private bearingStep;
+    private pitchStep;
+    /**
+     * @private
+     */
+    constructor();
+    reset(): void;
+    keydown(e: KeyboardEvent): {
+        cameraAnimation: (map: Map | EarthMap) => void;
+    } | undefined;
+    enable(): void;
+    disable(): void;
+    isEnabled(): boolean;
+    isActive(): boolean;
+}
+export default KeyboardHandler;

package/lib/handler/keyboard.js

@@ -5,9 +5,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
-var defaultOptions = {
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+const defaultOptions = {
   panStep: 100,
   bearingStep: 15,
   pitchStep: 10
@@ -27,123 +26,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() {
-    (0, _classCallCheck2.default)(this, KeyboardHandler);
-    var stepOptions = defaultOptions;
+  constructor() {
+    (0, _defineProperty2.default)(this, "enabled", void 0);
+    (0, _defineProperty2.default)(this, "active", void 0);
+    (0, _defineProperty2.default)(this, "panStep", void 0);
+    (0, _defineProperty2.default)(this, "bearingStep", void 0);
+    (0, _defineProperty2.default)(this, "pitchStep", void 0);
+    const stepOptions = defaultOptions;
     this.panStep = stepOptions.panStep;
     this.bearingStep = stepOptions.bearingStep;
     this.pitchStep = stepOptions.pitchStep;
   }
-  (0, _createClass2.default)(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/lib/handler/map_event.d.ts

@@ -0,0 +1,29 @@
+import type { EarthMap } from '../earthmap';
+import type Point from '../geo/point';
+import type { Map } from '../map';
+import { MapMouseEvent, MapTouchEvent, MapWheelEvent } from './events';
+export default class MapEventHandler {
+    private mousedownPos;
+    private clickTolerance;
+    private map;
+    constructor(map: Map | EarthMap, options: {
+        clickTolerance: number;
+    });
+    reset(): void;
+    wheel(e: WheelEvent): {} | undefined;
+    mousedown(e: MouseEvent, point: Point): {} | undefined;
+    mouseup(e: MouseEvent): void;
+    click(e: MouseEvent, point: Point): void;
+    dblclick(e: MouseEvent): {} | undefined;
+    mouseover(e: MouseEvent): void;
+    mouseout(e: MouseEvent): void;
+    touchstart(e: TouchEvent): {} | undefined;
+    touchmove(e: TouchEvent): void;
+    touchend(e: TouchEvent): void;
+    touchcancel(e: TouchEvent): void;
+    firePreventable(mapEvent: MapMouseEvent | MapTouchEvent | MapWheelEvent): {} | undefined;
+    isEnabled(): boolean;
+    isActive(): boolean;
+    enable(): boolean;
+    disable(): boolean;
+}

package/lib/handler/map_event.js

@@ -5,126 +5,93 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 var _events = require("./events");
 // @ts-ignore
-var MapEventHandler = exports.default = /*#__PURE__*/function () {
-  function MapEventHandler(map, options) {
-    (0, _classCallCheck2.default)(this, MapEventHandler);
+
+class MapEventHandler {
+  constructor(map, options) {
+    (0, _defineProperty2.default)(this, "mousedownPos", void 0);
+    (0, _defineProperty2.default)(this, "clickTolerance", void 0);
+    (0, _defineProperty2.default)(this, "map", void 0);
     this.map = map;
     this.clickTolerance = options.clickTolerance;
   }
-  (0, _createClass2.default)(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 _events.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 _events.MapMouseEvent(e.type, this.map, e));
-    }
-  }, {
-    key: "mouseup",
-    value: function mouseup(e) {
-      this.map.emit(e.type, new _events.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 _events.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 _events.MapMouseEvent(e.type, this.map, e));
-    }
-  }, {
-    key: "mouseover",
-    value: function mouseover(e) {
-      this.map.emit(e.type, new _events.MapMouseEvent(e.type, this.map, e));
-    }
-  }, {
-    key: "mouseout",
-    value: function mouseout(e) {
-      this.map.emit(e.type, new _events.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 _events.MapTouchEvent(e.type, this.map, e));
-    }
-  }, {
-    key: "touchmove",
-    value: function touchmove(e) {
-      this.map.emit(e.type, new _events.MapTouchEvent(e.type, this.map, e));
-    }
-  }, {
-    key: "touchend",
-    value: function touchend(e) {
-      this.map.emit(e.type, new _events.MapTouchEvent(e.type, this.map, e));
-    }
-  }, {
-    key: "touchcancel",
-    value: function touchcancel(e) {
-      this.map.emit(e.type, new _events.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 _events.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 _events.MapMouseEvent(e.type, this.map, e));
+  }
+  mouseup(e) {
+    this.map.emit(e.type, new _events.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 _events.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 _events.MapMouseEvent(e.type, this.map, e));
+  }
+  mouseover(e) {
+    this.map.emit(e.type, new _events.MapMouseEvent(e.type, this.map, e));
+  }
+  mouseout(e) {
+    this.map.emit(e.type, new _events.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 _events.MapTouchEvent(e.type, this.map, e));
+  }
+  touchmove(e) {
+    this.map.emit(e.type, new _events.MapTouchEvent(e.type, this.map, e));
+  }
+  touchend(e) {
+    this.map.emit(e.type, new _events.MapTouchEvent(e.type, this.map, e));
+  }
+  touchcancel(e) {
+    this.map.emit(e.type, new _events.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;
-}();
+  }
+  isEnabled() {
+    return true;
+  }
+  isActive() {
+    return false;
+  }
+  enable() {
+    return false;
+  }
+  disable() {
+    return false;
+  }
+}
+exports.default = MapEventHandler;

package/lib/handler/mouse/index.d.ts

@@ -0,0 +1,4 @@
+import MousePanHandler from './mousepan_handler';
+import MouseRotateHandler from './mousepitch_hander';
+import MousePitchHandler from './mouserotate_hander';
+export { MousePanHandler, MousePitchHandler, MouseRotateHandler };

package/lib/handler/mouse/index.js

@@ -6,19 +6,19 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "MousePanHandler", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _mousepan_handler.default;
   }
 });
 Object.defineProperty(exports, "MousePitchHandler", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _mouserotate_hander.default;
   }
 });
 Object.defineProperty(exports, "MouseRotateHandler", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _mousepitch_hander.default;
   }
 });

package/lib/handler/mouse/mouse_handler.d.ts

@@ -0,0 +1,22 @@
+import type Point from '../../geo/point';
+export default class MouseHandler {
+    protected enabled: boolean;
+    protected active: boolean;
+    protected lastPoint: Point;
+    protected eventButton: 1 | 2;
+    protected moved: boolean;
+    protected clickTolerance: number;
+    constructor(options: {
+        clickTolerance: number;
+    });
+    reset(): void;
+    mousedown(e: MouseEvent, point: Point): void;
+    mousemoveWindow(e: MouseEvent, point: Point): void;
+    mouseupWindow(e: MouseEvent): void;
+    enable(): void;
+    disable(): void;
+    isEnabled(): boolean;
+    isActive(): boolean;
+    protected correctButton(e: MouseEvent, button: number): boolean;
+    protected move(lastPoint: Point, point: Point): void;
+}