@antv/l7-map 2.18.2 → 2.18.3

package/lib/handler/keyboard.js

@@ -0,0 +1,151 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+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 = {
+  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() {
+    (0, _classCallCheck2.default)(this, KeyboardHandler);
+    var 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;
+    }
+  }, {
+    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);
+}
+var _default = KeyboardHandler;
+exports.default = _default;

package/lib/handler/map_event.js

@@ -0,0 +1,131 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+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 _events = require("./events");
+// @ts-ignore
+var MapEventHandler = /*#__PURE__*/function () {
+  function MapEventHandler(map, options) {
+    (0, _classCallCheck2.default)(this, MapEventHandler);
+    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;
+    }
+  }, {
+    key: "disable",
+    value: function disable() {
+      return false;
+    }
+  }]);
+  return MapEventHandler;
+}();
+exports.default = MapEventHandler;

package/lib/handler/mouse/index.js

@@ -0,0 +1,27 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "MousePanHandler", {
+  enumerable: true,
+  get: function get() {
+    return _mousepan_handler.default;
+  }
+});
+Object.defineProperty(exports, "MousePitchHandler", {
+  enumerable: true,
+  get: function get() {
+    return _mouserotate_hander.default;
+  }
+});
+Object.defineProperty(exports, "MouseRotateHandler", {
+  enumerable: true,
+  get: function get() {
+    return _mousepitch_hander.default;
+  }
+});
+var _mousepan_handler = _interopRequireDefault(require("./mousepan_handler"));
+var _mousepitch_hander = _interopRequireDefault(require("./mousepitch_hander"));
+var _mouserotate_hander = _interopRequireDefault(require("./mouserotate_hander"));

package/lib/handler/mouse/mouse_handler.js

@@ -0,0 +1,124 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+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 _dom = _interopRequireDefault(require("../../utils/dom"));
+var _util = require("./util");
+// @ts-ignore
+var MouseHandler = /*#__PURE__*/function () {
+  function MouseHandler(options) {
+    (0, _classCallCheck2.default)(this, MouseHandler);
+    this.reset();
+    this.clickTolerance = options.clickTolerance || 1;
+  }
+  (0, _createClass2.default)(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.default.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 ((0, _util.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.default.mouseButton(e);
+      if (eventButton !== this.eventButton) {
+        return;
+      }
+      if (this.moved) {
+        _dom.default.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;
+}();
+exports.default = MouseHandler;

package/lib/handler/mouse/mousepan_handler.js

@@ -0,0 +1,49 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+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 _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _mouse_handler = _interopRequireDefault(require("./mouse_handler"));
+var _util = require("./util");
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(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
+var MousePanHandler = /*#__PURE__*/function (_MouseHandler) {
+  (0, _inherits2.default)(MousePanHandler, _MouseHandler);
+  var _super = _createSuper(MousePanHandler);
+  function MousePanHandler() {
+    (0, _classCallCheck2.default)(this, MousePanHandler);
+    return _super.apply(this, arguments);
+  }
+  (0, _createClass2.default)(MousePanHandler, [{
+    key: "mousedown",
+    value: function mousedown(e, point) {
+      (0, _get2.default)((0, _getPrototypeOf2.default)(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 === _util.LEFT_BUTTON && !e.ctrlKey;
+    }
+  }]);
+  return MousePanHandler;
+}(_mouse_handler.default);
+exports.default = MousePanHandler;

package/lib/handler/mouse/mousepitch_hander.js

@@ -0,0 +1,51 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+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 _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _mouse_handler = _interopRequireDefault(require("./mouse_handler"));
+var _util = require("./util");
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(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
+var MousePitchHandler = /*#__PURE__*/function (_MouseHandler) {
+  (0, _inherits2.default)(MousePitchHandler, _MouseHandler);
+  var _super = _createSuper(MousePitchHandler);
+  function MousePitchHandler() {
+    (0, _classCallCheck2.default)(this, MousePitchHandler);
+    return _super.apply(this, arguments);
+  }
+  (0, _createClass2.default)(MousePitchHandler, [{
+    key: "correctButton",
+    value: function correctButton(e, button) {
+      return button === _util.LEFT_BUTTON && e.ctrlKey || button === _util.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;
+}(_mouse_handler.default);
+exports.default = MousePitchHandler;

package/lib/handler/mouse/mouserotate_hander.js

@@ -0,0 +1,51 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+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 _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _mouse_handler = _interopRequireDefault(require("./mouse_handler"));
+var _util = require("./util");
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(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
+var MouseRotateHandler = /*#__PURE__*/function (_MouseHandler) {
+  (0, _inherits2.default)(MouseRotateHandler, _MouseHandler);
+  var _super = _createSuper(MouseRotateHandler);
+  function MouseRotateHandler() {
+    (0, _classCallCheck2.default)(this, MouseRotateHandler);
+    return _super.apply(this, arguments);
+  }
+  (0, _createClass2.default)(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 === _util.LEFT_BUTTON && e.ctrlKey || button === _util.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;
+}(_mouse_handler.default);
+exports.default = MouseRotateHandler;

package/lib/handler/mouse/util.js

@@ -0,0 +1,22 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RIGHT_BUTTON = exports.LEFT_BUTTON = exports.BUTTONS_FLAGS = void 0;
+exports.buttonStillPressed = buttonStillPressed;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _BUTTONS_FLAGS;
+var LEFT_BUTTON = 0;
+exports.LEFT_BUTTON = LEFT_BUTTON;
+var RIGHT_BUTTON = 2;
+
+// the values for each button in MouseEvent.buttons
+exports.RIGHT_BUTTON = RIGHT_BUTTON;
+var BUTTONS_FLAGS = (_BUTTONS_FLAGS = {}, (0, _defineProperty2.default)(_BUTTONS_FLAGS, LEFT_BUTTON, 1), (0, _defineProperty2.default)(_BUTTONS_FLAGS, RIGHT_BUTTON, 2), _BUTTONS_FLAGS);
+exports.BUTTONS_FLAGS = BUTTONS_FLAGS;
+function buttonStillPressed(e, button) {
+  var flag = BUTTONS_FLAGS[button];
+  return e.buttons === undefined || (e.buttons & flag) !== flag;
+}