@antv/l7-map 2.18.2 → 2.18.3

package/es/handler/keyboard.js

@@ -0,0 +1,143 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+var defaultOptions = {
+  panStep: 100,
+  bearingStep: 15,
+  pitchStep: 10
+};
+
+/**
+ * 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.
+ */
+var KeyboardHandler = /*#__PURE__*/function () {
+  /**
+   * @private
+   */
+  function KeyboardHandler() {
+    _classCallCheck(this, KeyboardHandler);
+    var stepOptions = defaultOptions;
+    this.panStep = stepOptions.panStep;
+    this.bearingStep = stepOptions.bearingStep;
+    this.pitchStep = stepOptions.pitchStep;
+  }
+  _createClass(KeyboardHandler, [{
+    key: "reset",
+    value: function reset() {
+      this.active = false;
+    }
+  }, {
+    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
+          });
+        }
+      };
+    }
+  }, {
+    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;
+    }
+  }]);
+  return KeyboardHandler;
+}();
+function easeOut(t) {
+  return t * (2 - t);
+}
+export default KeyboardHandler;

package/es/handler/map_event.d.ts

@@ -0,0 +1,29 @@
+import { EarthMap } from '../earthmap';
+import Point from '../geo/point';
+import { 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/es/handler/map_event.js

@@ -0,0 +1,125 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+// @ts-ignore
+
+import { MapMouseEvent, MapTouchEvent, MapWheelEvent } from "./events";
+var MapEventHandler = /*#__PURE__*/function () {
+  function MapEventHandler(map, options) {
+    _classCallCheck(this, MapEventHandler);
+    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;
+    }
+  }, {
+    key: "disable",
+    value: function disable() {
+      return false;
+    }
+  }]);
+  return MapEventHandler;
+}();
+export { MapEventHandler as default };

package/es/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, MouseRotateHandler, MousePitchHandler };

package/es/handler/mouse/index.js

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

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

@@ -0,0 +1,22 @@
+import 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;
+}

package/es/handler/mouse/mouse_handler.js

@@ -0,0 +1,118 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+// @ts-ignore
+
+import DOM from "../../utils/dom";
+import { buttonStillPressed } from "./util";
+var MouseHandler = /*#__PURE__*/function () {
+  function MouseHandler(options) {
+    _classCallCheck(this, MouseHandler);
+    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;
+    }
+  }, {
+    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;
+    }
+  }, {
+    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);
+    }
+  }, {
+    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();
+      }
+      this.reset();
+    }
+  }, {
+    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;
+    }
+
+    // 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
+  }, {
+    key: "move",
+    value: function move(lastPoint, point) {
+      // eslint-disable-line
+      return; // implemented by child
+    }
+  }]);
+  return MouseHandler;
+}();
+export { MouseHandler as default };

package/es/handler/mouse/mousepan_handler.d.ts

@@ -0,0 +1,10 @@
+import Point from '../../geo/point';
+import MouseHandler from './mouse_handler';
+export default class MousePanHandler extends MouseHandler {
+    mousedown(e: MouseEvent, point: Point): void;
+    move(lastPoint: Point, point: Point): {
+        around: Point;
+        panDelta: Point;
+    };
+    protected correctButton(e: MouseEvent, button: number): boolean;
+}

package/es/handler/mouse/mousepan_handler.js

@@ -0,0 +1,44 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+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";
+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
+
+import MouseHandler from "./mouse_handler";
+import { LEFT_BUTTON } from "./util";
+var MousePanHandler = /*#__PURE__*/function (_MouseHandler) {
+  _inherits(MousePanHandler, _MouseHandler);
+  var _super = _createSuper(MousePanHandler);
+  function MousePanHandler() {
+    _classCallCheck(this, MousePanHandler);
+    return _super.apply(this, arguments);
+  }
+  _createClass(MousePanHandler, [{
+    key: "mousedown",
+    value: function mousedown(e, point) {
+      _get(_getPrototypeOf(MousePanHandler.prototype), "mousedown", this).call(this, e, point);
+      if (this.lastPoint) {
+        this.active = true;
+      }
+    }
+  }, {
+    key: "move",
+    value: function move(lastPoint, point) {
+      return {
+        around: point,
+        panDelta: point.sub(lastPoint)
+      };
+    }
+  }, {
+    key: "correctButton",
+    value: function correctButton(e, button) {
+      return button === LEFT_BUTTON && !e.ctrlKey;
+    }
+  }]);
+  return MousePanHandler;
+}(MouseHandler);
+export { MousePanHandler as default };

package/es/handler/mouse/mousepitch_hander.d.ts

@@ -0,0 +1,9 @@
+import Point from '../../geo/point';
+import MouseHandler from './mouse_handler';
+export default class MousePitchHandler extends MouseHandler {
+    correctButton(e: MouseEvent, button: number): boolean;
+    move(lastPoint: Point, point: Point): {
+        pitchDelta: number;
+    } | undefined;
+    contextmenu(e: MouseEvent): void;
+}

package/es/handler/mouse/mousepitch_hander.js

@@ -0,0 +1,46 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+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
+
+import MouseHandler from "./mouse_handler";
+import { LEFT_BUTTON, RIGHT_BUTTON } from "./util";
+var MousePitchHandler = /*#__PURE__*/function (_MouseHandler) {
+  _inherits(MousePitchHandler, _MouseHandler);
+  var _super = _createSuper(MousePitchHandler);
+  function MousePitchHandler() {
+    _classCallCheck(this, MousePitchHandler);
+    return _super.apply(this, arguments);
+  }
+  _createClass(MousePitchHandler, [{
+    key: "correctButton",
+    value: function correctButton(e, button) {
+      return button === LEFT_BUTTON && e.ctrlKey || button === RIGHT_BUTTON;
+    }
+  }, {
+    key: "move",
+    value: function move(lastPoint, point) {
+      var degreesPerPixelMoved = -0.5;
+      var pitchDelta = (point.y - lastPoint.y) * degreesPerPixelMoved;
+      if (pitchDelta) {
+        this.active = true;
+        return {
+          pitchDelta: pitchDelta
+        };
+      }
+    }
+  }, {
+    key: "contextmenu",
+    value: function contextmenu(e) {
+      // prevent browser context menu when necessary; we don't allow it with rotation
+      // because we can't discern rotation gesture start from contextmenu on Mac
+      e.preventDefault();
+    }
+  }]);
+  return MousePitchHandler;
+}(MouseHandler);
+export { MousePitchHandler as default };

package/es/handler/mouse/mouserotate_hander.d.ts

@@ -0,0 +1,9 @@
+import Point from '../../geo/point';
+import MouseHandler from './mouse_handler';
+export default class MouseRotateHandler extends MouseHandler {
+    contextmenu(e: MouseEvent): void;
+    protected correctButton(e: MouseEvent, button: number): boolean;
+    protected move(lastPoint: Point, point: Point): {
+        bearingDelta: number;
+    } | undefined;
+}

package/es/handler/mouse/mouserotate_hander.js

@@ -0,0 +1,46 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+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
+
+import MouseHandler from "./mouse_handler";
+import { LEFT_BUTTON, RIGHT_BUTTON } from "./util";
+var MouseRotateHandler = /*#__PURE__*/function (_MouseHandler) {
+  _inherits(MouseRotateHandler, _MouseHandler);
+  var _super = _createSuper(MouseRotateHandler);
+  function MouseRotateHandler() {
+    _classCallCheck(this, MouseRotateHandler);
+    return _super.apply(this, arguments);
+  }
+  _createClass(MouseRotateHandler, [{
+    key: "contextmenu",
+    value: function contextmenu(e) {
+      // prevent browser context menu when necessary; we don't allow it with rotation
+      // because we can't discern rotation gesture start from contextmenu on Mac
+      e.preventDefault();
+    }
+  }, {
+    key: "correctButton",
+    value: function correctButton(e, button) {
+      return button === LEFT_BUTTON && e.ctrlKey || button === RIGHT_BUTTON;
+    }
+  }, {
+    key: "move",
+    value: function move(lastPoint, point) {
+      var degreesPerPixelMoved = 0.8;
+      var bearingDelta = (point.x - lastPoint.x) * degreesPerPixelMoved;
+      if (bearingDelta) {
+        this.active = true;
+        return {
+          bearingDelta: bearingDelta
+        };
+      }
+    }
+  }]);
+  return MouseRotateHandler;
+}(MouseHandler);
+export { MouseRotateHandler as default };

package/es/handler/mouse/util.d.ts

@@ -0,0 +1,6 @@
+export declare const LEFT_BUTTON = 0;
+export declare const RIGHT_BUTTON = 2;
+export declare const BUTTONS_FLAGS: {
+    [key: number]: number;
+};
+export declare function buttonStillPressed(e: MouseEvent, button: 1 | 2): boolean;

package/es/handler/mouse/util.js

@@ -0,0 +1,11 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+var _BUTTONS_FLAGS;
+export var LEFT_BUTTON = 0;
+export var RIGHT_BUTTON = 2;
+
+// the values for each button in MouseEvent.buttons
+export var BUTTONS_FLAGS = (_BUTTONS_FLAGS = {}, _defineProperty(_BUTTONS_FLAGS, LEFT_BUTTON, 1), _defineProperty(_BUTTONS_FLAGS, RIGHT_BUTTON, 2), _BUTTONS_FLAGS);
+export function buttonStillPressed(e, button) {
+  var flag = BUTTONS_FLAGS[button];
+  return e.buttons === undefined || (e.buttons & flag) !== flag;
+}