@antv/l7-map 2.21.1 → 2.21.2

package/es/handler/scroll_zoom.js

@@ -1,5 +1,3 @@
-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
 
@@ -7,74 +5,94 @@ import LngLat from "../geo/lng_lat";
 import { bezier, ease, interpolate, now } from "../util";
 import DOM from "../utils/dom";
 // deltaY value for mouse scroll wheel identification
-var wheelZoomDelta = 4.000244140625;
+const wheelZoomDelta = 4.000244140625;
 
 // These magic numbers control the rate of zoom. Trackpad events fire at a greater
 // frequency than mouse scroll wheel, so reduce the zoom rate per wheel tick
-var defaultZoomRate = 1 / 100;
-var wheelZoomRate = 1 / 450;
+const defaultZoomRate = 1 / 100;
+const wheelZoomRate = 1 / 450;
 
 // upper bound on how much we scale the map in any single render frame; this
 // is used to limit zoom rate in the case of very fast scrolling
-var maxScalePerFrame = 2;
+const maxScalePerFrame = 2;
 
 /**
  * The `ScrollZoomHandler` allows the user to zoom the map by scrolling.
  */
-var ScrollZoomHandler = /*#__PURE__*/function () {
-  // used for delayed-handling of a single wheel movement
-  // used to delay final '{move,zoom}end' events
-
+class ScrollZoomHandler {
   /**
    * @private
    */
-  function ScrollZoomHandler(map, handler) {
-    var _this = this;
-    _classCallCheck(this, ScrollZoomHandler);
-    _defineProperty(this, "onScrollFrame", function () {
-      if (!_this.frameId) {
+  constructor(map, handler) {
+    _defineProperty(this, "map", void 0);
+    _defineProperty(this, "el", void 0);
+    _defineProperty(this, "enabled", void 0);
+    _defineProperty(this, "active", void 0);
+    _defineProperty(this, "zooming", void 0);
+    _defineProperty(this, "aroundCenter", void 0);
+    _defineProperty(this, "around", void 0);
+    _defineProperty(this, "aroundPoint", void 0);
+    _defineProperty(this, "type", void 0);
+    _defineProperty(this, "lastValue", void 0);
+    _defineProperty(this, "timeout", void 0);
+    // used for delayed-handling of a single wheel movement
+    _defineProperty(this, "finishTimeout", void 0);
+    // used to delay final '{move,zoom}end' events
+    _defineProperty(this, "lastWheelEvent", void 0);
+    _defineProperty(this, "lastWheelEventTime", void 0);
+    _defineProperty(this, "startZoom", void 0);
+    _defineProperty(this, "targetZoom", void 0);
+    _defineProperty(this, "delta", void 0);
+    _defineProperty(this, "easing", void 0);
+    _defineProperty(this, "prevEase", void 0);
+    _defineProperty(this, "frameId", void 0);
+    _defineProperty(this, "handler", void 0);
+    _defineProperty(this, "defaultZoomRate", void 0);
+    _defineProperty(this, "wheelZoomRate", void 0);
+    _defineProperty(this, "onScrollFrame", () => {
+      if (!this.frameId) {
         return;
       }
-      _this.frameId = null;
-      if (!_this.isActive()) {
+      this.frameId = null;
+      if (!this.isActive()) {
         return;
       }
-      var tr = _this.map.transform;
+      const tr = this.map.transform;
 
       // if we've had scroll events since the last render frame, consume the
       // accumulated delta, and update the target zoom level accordingly
-      if (_this.delta !== 0) {
+      if (this.delta !== 0) {
         // For trackpad events and single mouse wheel ticks, use the default zoom rate
-        var zoomRate = _this.type === 'wheel' && Math.abs(_this.delta) > wheelZoomDelta ? _this.wheelZoomRate : _this.defaultZoomRate;
+        const zoomRate = this.type === 'wheel' && Math.abs(this.delta) > wheelZoomDelta ? this.wheelZoomRate : this.defaultZoomRate;
         // Scale by sigmoid of scroll wheel delta.
-        var scale = maxScalePerFrame / (1 + Math.exp(-Math.abs(_this.delta * zoomRate)));
-        if (_this.delta < 0 && scale !== 0) {
+        let scale = maxScalePerFrame / (1 + Math.exp(-Math.abs(this.delta * zoomRate)));
+        if (this.delta < 0 && scale !== 0) {
           scale = 1 / scale;
         }
-        var fromScale = typeof _this.targetZoom === 'number' ? tr.zoomScale(_this.targetZoom) : tr.scale;
-        _this.targetZoom = Math.min(tr.maxZoom, Math.max(tr.minZoom, tr.scaleZoom(fromScale * scale)));
+        const fromScale = typeof this.targetZoom === 'number' ? tr.zoomScale(this.targetZoom) : tr.scale;
+        this.targetZoom = Math.min(tr.maxZoom, Math.max(tr.minZoom, tr.scaleZoom(fromScale * scale)));
 
         // if this is a mouse wheel, refresh the starting zoom and easing
         // function we're using to smooth out the zooming between wheel
         // events
-        if (_this.type === 'wheel') {
-          _this.startZoom = tr.zoom;
-          _this.easing = _this.smoothOutEasing(200);
+        if (this.type === 'wheel') {
+          this.startZoom = tr.zoom;
+          this.easing = this.smoothOutEasing(200);
         }
-        _this.delta = 0;
+        this.delta = 0;
       }
-      var targetZoom = typeof _this.targetZoom === 'number' ? _this.targetZoom : tr.zoom;
-      var startZoom = _this.startZoom;
-      var easing = _this.easing;
-      var finished = false;
-      var zoom;
-      if (_this.type === 'wheel' && startZoom && easing) {
-        var t = Math.min((now() - _this.lastWheelEventTime) / 200, 1);
-        var k = easing(t);
+      const targetZoom = typeof this.targetZoom === 'number' ? this.targetZoom : tr.zoom;
+      const startZoom = this.startZoom;
+      const easing = this.easing;
+      let finished = false;
+      let zoom;
+      if (this.type === 'wheel' && startZoom && easing) {
+        const t = Math.min((now() - this.lastWheelEventTime) / 200, 1);
+        const k = easing(t);
         zoom = interpolate(startZoom, targetZoom, k);
         if (t < 1) {
-          if (!_this.frameId) {
-            _this.frameId = true;
+          if (!this.frameId) {
+            this.frameId = true;
           }
         } else {
           finished = true;
@@ -83,25 +101,25 @@ var ScrollZoomHandler = /*#__PURE__*/function () {
         zoom = targetZoom;
         finished = true;
       }
-      _this.active = true;
+      this.active = true;
       if (finished) {
-        _this.active = false;
+        this.active = false;
         // @ts-ignore
-        _this.finishTimeout = setTimeout(function () {
-          _this.zooming = false;
-          _this.handler.triggerRenderFrame();
+        this.finishTimeout = setTimeout(() => {
+          this.zooming = false;
+          this.handler.triggerRenderFrame();
           // @ts-ignore
-          delete _this.targetZoom;
+          delete this.targetZoom;
           // @ts-ignore
-          delete _this.finishTimeout;
+          delete this.finishTimeout;
         }, 200);
       }
       return {
         noInertia: true,
         needsRenderFrame: !finished,
         zoomDelta: zoom - tr.zoom,
-        around: _this.aroundPoint,
-        originalEvent: _this.lastWheelEvent
+        around: this.aroundPoint,
+        originalEvent: this.lastWheelEvent
       };
     });
     this.map = map;
@@ -119,207 +137,179 @@ var ScrollZoomHandler = /*#__PURE__*/function () {
    * // Speed up trackpad zoom
    * map.scrollZoom.setZoomRate(1/25);
    */
-  _createClass(ScrollZoomHandler, [{
-    key: "setZoomRate",
-    value: function setZoomRate(zoomRate) {
-      this.defaultZoomRate = zoomRate;
-    }
+  setZoomRate(zoomRate) {
+    this.defaultZoomRate = zoomRate;
+  }
 
-    /**
-     * Set the zoom rate of a mouse wheel
-     * @param {number} [wheelZoomRate=1/450] The rate used to scale mouse wheel movement to a zoom value.
-     * @example
-     * // Slow down zoom of mouse wheel
-     * map.scrollZoom.setWheelZoomRate(1/600);
-     */
-  }, {
-    key: "setWheelZoomRate",
-    value: function setWheelZoomRate(zoomRate) {
-      this.wheelZoomRate = zoomRate;
-    }
+  /**
+   * Set the zoom rate of a mouse wheel
+   * @param {number} [wheelZoomRate=1/450] The rate used to scale mouse wheel movement to a zoom value.
+   * @example
+   * // Slow down zoom of mouse wheel
+   * map.scrollZoom.setWheelZoomRate(1/600);
+   */
+  setWheelZoomRate(zoomRate) {
+    this.wheelZoomRate = zoomRate;
+  }
 
-    /**
-     * Returns a Boolean indicating whether the "scroll to zoom" interaction is enabled.
-     *
-     * @returns {boolean} `true` if the "scroll to zoom" interaction is enabled.
-     */
-  }, {
-    key: "isEnabled",
-    value: function isEnabled() {
-      return !!this.enabled;
-    }
+  /**
+   * Returns a Boolean indicating whether the "scroll to zoom" interaction is enabled.
+   *
+   * @returns {boolean} `true` if the "scroll to zoom" interaction is enabled.
+   */
+  isEnabled() {
+    return !!this.enabled;
+  }
 
-    /*
-     * Active state is turned on and off with every scroll wheel event and is set back to false before the map
-     * render is called, so _active is not a good candidate for determining if a scroll zoom animation is in
-     * progress.
-     */
-  }, {
-    key: "isActive",
-    value: function isActive() {
-      return !!this.active || this.finishTimeout !== undefined;
-    }
-  }, {
-    key: "isZooming",
-    value: function isZooming() {
-      return !!this.zooming;
-    }
+  /*
+   * Active state is turned on and off with every scroll wheel event and is set back to false before the map
+   * render is called, so _active is not a good candidate for determining if a scroll zoom animation is in
+   * progress.
+   */
+  isActive() {
+    return !!this.active || this.finishTimeout !== undefined;
+  }
+  isZooming() {
+    return !!this.zooming;
+  }
 
-    /**
-     * Enables the "scroll to zoom" interaction.
-     *
-     * @param {Object} [options] Options object.
-     * @param {string} [options.around] If "center" is passed, map will zoom around center of map
-     *
-     * @example
-     *   map.scrollZoom.enable();
-     * @example
-     *  map.scrollZoom.enable({ around: 'center' })
-     */
-  }, {
-    key: "enable",
-    value: function enable(options) {
-      if (this.isEnabled()) {
-        return;
-      }
-      this.enabled = true;
-      this.aroundCenter = options && options.around === 'center';
+  /**
+   * Enables the "scroll to zoom" interaction.
+   *
+   * @param {Object} [options] Options object.
+   * @param {string} [options.around] If "center" is passed, map will zoom around center of map
+   *
+   * @example
+   *   map.scrollZoom.enable();
+   * @example
+   *  map.scrollZoom.enable({ around: 'center' })
+   */
+  enable(options) {
+    if (this.isEnabled()) {
+      return;
     }
+    this.enabled = true;
+    this.aroundCenter = options && options.around === 'center';
+  }
 
-    /**
-     * Disables the "scroll to zoom" interaction.
-     *
-     * @example
-     *   map.scrollZoom.disable();
-     */
-  }, {
-    key: "disable",
-    value: function disable() {
-      if (!this.isEnabled()) {
-        return;
-      }
-      this.enabled = false;
+  /**
+   * Disables the "scroll to zoom" interaction.
+   *
+   * @example
+   *   map.scrollZoom.disable();
+   */
+  disable() {
+    if (!this.isEnabled()) {
+      return;
     }
-  }, {
-    key: "wheel",
-    value: function wheel(e) {
-      if (!this.isEnabled()) {
-        return;
-      }
-      // Remove `any` cast when https://github.com/facebook/flow/issues/4879 is fixed.
-      var value = e.deltaMode === window.WheelEvent.DOM_DELTA_LINE ? e.deltaY * 40 : e.deltaY;
-      var nowTime = now();
-      var timeDelta = nowTime - (this.lastWheelEventTime || 0);
-      this.lastWheelEventTime = nowTime;
-      if (value !== 0 && value % wheelZoomDelta === 0) {
-        // This one is definitely a mouse wheel event.
-        this.type = 'wheel';
-      } else if (value !== 0 && Math.abs(value) < 4) {
-        // This one is definitely a trackpad event because it is so small.
-        this.type = 'trackpad';
-      } else if (timeDelta > 400) {
-        // This is likely a new scroll action.
-        this.type = null;
-        this.lastValue = value;
+    this.enabled = false;
+  }
+  wheel(e) {
+    if (!this.isEnabled()) {
+      return;
+    }
+    // Remove `any` cast when https://github.com/facebook/flow/issues/4879 is fixed.
+    let value = e.deltaMode === window.WheelEvent.DOM_DELTA_LINE ? e.deltaY * 40 : e.deltaY;
+    const nowTime = now();
+    const timeDelta = nowTime - (this.lastWheelEventTime || 0);
+    this.lastWheelEventTime = nowTime;
+    if (value !== 0 && value % wheelZoomDelta === 0) {
+      // This one is definitely a mouse wheel event.
+      this.type = 'wheel';
+    } else if (value !== 0 && Math.abs(value) < 4) {
+      // This one is definitely a trackpad event because it is so small.
+      this.type = 'trackpad';
+    } else if (timeDelta > 400) {
+      // This is likely a new scroll action.
+      this.type = null;
+      this.lastValue = value;
 
-        // Start a timeout in case this was a singular event, and dely it by up to 40ms.
-        // @ts-ignore
-        this.timeout = setTimeout(this.onTimeout, 40, e);
-      } else if (!this.type) {
-        // This is a repeating event, but we don't know the type of event just yet.
-        // If the delta per time is small, we assume it's a fast trackpad; otherwise we switch into wheel mode.
-        this.type = Math.abs(timeDelta * value) < 200 ? 'trackpad' : 'wheel';
+      // Start a timeout in case this was a singular event, and dely it by up to 40ms.
+      // @ts-ignore
+      this.timeout = setTimeout(this.onTimeout, 40, e);
+    } else if (!this.type) {
+      // This is a repeating event, but we don't know the type of event just yet.
+      // If the delta per time is small, we assume it's a fast trackpad; otherwise we switch into wheel mode.
+      this.type = Math.abs(timeDelta * value) < 200 ? 'trackpad' : 'wheel';
 
-        // Make sure our delayed event isn't fired again, because we accumulate
-        // the previous event (which was less than 40ms ago) into this event.
-        if (this.timeout) {
-          clearTimeout(this.timeout);
-          this.timeout = null;
-          value += this.lastValue;
-        }
+      // Make sure our delayed event isn't fired again, because we accumulate
+      // the previous event (which was less than 40ms ago) into this event.
+      if (this.timeout) {
+        clearTimeout(this.timeout);
+        this.timeout = null;
+        value += this.lastValue;
       }
+    }
 
-      // Slow down zoom if shift key is held for more precise zooming
-      if (e.shiftKey && value) {
-        value = value / 4;
-      }
-      // Only fire the callback if we actually know what type of scrolling device the user uses.
-      if (this.type) {
-        this.lastWheelEvent = e;
-        this.delta -= value;
-        if (!this.active) {
-          this.start(e);
-        }
+    // Slow down zoom if shift key is held for more precise zooming
+    if (e.shiftKey && value) {
+      value = value / 4;
+    }
+    // Only fire the callback if we actually know what type of scrolling device the user uses.
+    if (this.type) {
+      this.lastWheelEvent = e;
+      this.delta -= value;
+      if (!this.active) {
+        this.start(e);
       }
-      e.preventDefault();
     }
-  }, {
-    key: "renderFrame",
-    value: function renderFrame() {
-      return this.onScrollFrame();
+    e.preventDefault();
+  }
+  renderFrame() {
+    return this.onScrollFrame();
+  }
+  reset() {
+    this.active = false;
+  }
+  onTimeout(initialEvent) {
+    this.type = 'wheel';
+    this.delta -= this.lastValue;
+    if (!this.active && this.start) {
+      this.start(initialEvent);
     }
-  }, {
-    key: "reset",
-    value: function reset() {
-      this.active = false;
+  }
+  start(e) {
+    if (!this.delta) {
+      return;
     }
-  }, {
-    key: "onTimeout",
-    value: function onTimeout(initialEvent) {
-      this.type = 'wheel';
-      this.delta -= this.lastValue;
-      if (!this.active && this.start) {
-        this.start(initialEvent);
-      }
+    if (this.frameId) {
+      this.frameId = null;
     }
-  }, {
-    key: "start",
-    value: function start(e) {
-      if (!this.delta) {
-        return;
-      }
-      if (this.frameId) {
-        this.frameId = null;
-      }
-      this.active = true;
-      if (!this.isZooming()) {
-        this.zooming = true;
-      }
-      if (this.finishTimeout) {
-        clearTimeout(this.finishTimeout);
-        // @ts-ignore
-        delete this.finishTimeout;
-      }
-      var pos = DOM.mousePos(this.el, e);
-      this.around = LngLat.convert(this.aroundCenter ? this.map.getCenter() : this.map.unproject(pos));
-      this.aroundPoint = this.map.transform.locationPoint(this.around);
-      if (!this.frameId) {
-        this.frameId = true;
-        this.handler.triggerRenderFrame();
-      }
+    this.active = true;
+    if (!this.isZooming()) {
+      this.zooming = true;
+    }
+    if (this.finishTimeout) {
+      clearTimeout(this.finishTimeout);
+      // @ts-ignore
+      delete this.finishTimeout;
     }
-  }, {
-    key: "smoothOutEasing",
-    value: function smoothOutEasing(duration) {
-      var easing = ease;
-      if (this.prevEase) {
-        var preEase = this.prevEase;
-        var t = (now() - preEase.start) / preEase.duration;
-        var speed = preEase.easing(t + 0.01) - preEase.easing(t);
+    const pos = DOM.mousePos(this.el, e);
+    this.around = LngLat.convert(this.aroundCenter ? this.map.getCenter() : this.map.unproject(pos));
+    this.aroundPoint = this.map.transform.locationPoint(this.around);
+    if (!this.frameId) {
+      this.frameId = true;
+      this.handler.triggerRenderFrame();
+    }
+  }
+  smoothOutEasing(duration) {
+    let easing = ease;
+    if (this.prevEase) {
+      const preEase = this.prevEase;
+      const t = (now() - preEase.start) / preEase.duration;
+      const speed = preEase.easing(t + 0.01) - preEase.easing(t);
 
-        // Quick hack to make new bezier that is continuous with last
-        var x = 0.27 / Math.sqrt(speed * speed + 0.0001) * 0.01;
-        var y = Math.sqrt(0.27 * 0.27 - x * x);
-        easing = bezier(x, y, 0.25, 1);
-      }
-      this.prevEase = {
-        start: now(),
-        duration: duration,
-        easing: easing
-      };
-      return easing;
+      // Quick hack to make new bezier that is continuous with last
+      const x = 0.27 / Math.sqrt(speed * speed + 0.0001) * 0.01;
+      const y = Math.sqrt(0.27 * 0.27 - x * x);
+      easing = bezier(x, y, 0.25, 1);
     }
-  }]);
-  return ScrollZoomHandler;
-}();
+    this.prevEase = {
+      start: now(),
+      duration,
+      easing
+    };
+    return easing;
+  }
+}
 export default ScrollZoomHandler;

package/es/handler/shim/dblclick_zoom.js

@@ -1,15 +1,15 @@
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
-import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
 /**
  * The `DoubleClickZoomHandler` allows the user to zoom the map at a point by
  * double clicking or double tapping.
  */
-var DoubleClickZoomHandler = /*#__PURE__*/function () {
+export default class DoubleClickZoomHandler {
   /**
    * @private
    */
-  function DoubleClickZoomHandler(clickZoom, TapZoom) {
-    _classCallCheck(this, DoubleClickZoomHandler);
+  constructor(clickZoom, TapZoom) {
+    _defineProperty(this, "clickZoom", void 0);
+    _defineProperty(this, "tapZoom", void 0);
     this.clickZoom = clickZoom;
     this.tapZoom = TapZoom;
   }
@@ -20,48 +20,37 @@ var DoubleClickZoomHandler = /*#__PURE__*/function () {
    * @example
    * map.doubleClickZoom.enable();
    */
-  _createClass(DoubleClickZoomHandler, [{
-    key: "enable",
-    value: function enable() {
-      this.clickZoom.enable();
-      this.tapZoom.enable();
-    }
+  enable() {
+    this.clickZoom.enable();
+    this.tapZoom.enable();
+  }
 
-    /**
-     * Disables the "double click to zoom" interaction.
-     *
-     * @example
-     * map.doubleClickZoom.disable();
-     */
-  }, {
-    key: "disable",
-    value: function disable() {
-      this.clickZoom.disable();
-      this.tapZoom.disable();
-    }
+  /**
+   * Disables the "double click to zoom" interaction.
+   *
+   * @example
+   * map.doubleClickZoom.disable();
+   */
+  disable() {
+    this.clickZoom.disable();
+    this.tapZoom.disable();
+  }
 
-    /**
-     * Returns a Boolean indicating whether the "double click to zoom" interaction is enabled.
-     *
-     * @returns {boolean} `true` if the "double click to zoom" interaction is enabled.
-     */
-  }, {
-    key: "isEnabled",
-    value: function isEnabled() {
-      return this.clickZoom.isEnabled() && this.tapZoom.isEnabled();
-    }
+  /**
+   * Returns a Boolean indicating whether the "double click to zoom" interaction is enabled.
+   *
+   * @returns {boolean} `true` if the "double click to zoom" interaction is enabled.
+   */
+  isEnabled() {
+    return this.clickZoom.isEnabled() && this.tapZoom.isEnabled();
+  }
 
-    /**
-     * Returns a Boolean indicating whether the "double click to zoom" interaction is active, i.e. currently being used.
-     *
-     * @returns {boolean} `true` if the "double click to zoom" interaction is active.
-     */
-  }, {
-    key: "isActive",
-    value: function isActive() {
-      return this.clickZoom.isActive() || this.tapZoom.isActive();
-    }
-  }]);
-  return DoubleClickZoomHandler;
-}();
-export { DoubleClickZoomHandler as default };
+  /**
+   * Returns a Boolean indicating whether the "double click to zoom" interaction is active, i.e. currently being used.
+   *
+   * @returns {boolean} `true` if the "double click to zoom" interaction is active.
+   */
+  isActive() {
+    return this.clickZoom.isActive() || this.tapZoom.isActive();
+  }
+}