@antv/l7-map 2.9.33 → 2.9.35

package/lib/handler/scroll_zoom.js

@@ -1,74 +1,100 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/handler/scroll_zoom.ts
-var scroll_zoom_exports = {};
-__export(scroll_zoom_exports, {
-  default: () => scroll_zoom_default
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
 });
-module.exports = __toCommonJS(scroll_zoom_exports);
-var import_lng_lat = __toESM(require("../geo/lng_lat"));
-var import_util = require("../util");
-var import_dom = __toESM(require("../utils/dom"));
-var wheelZoomDelta = 4.000244140625;
+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 _lng_lat = _interopRequireDefault(require("../geo/lng_lat"));
+
+var _util = require("../util");
+
+var _dom = _interopRequireDefault(require("../utils/dom"));
+
+// @ts-ignore
+// deltaY value for mouse scroll wheel identification
+var 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;
+var 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;
-var ScrollZoomHandler = class {
-  constructor(map, handler) {
-    this.onScrollFrame = () => {
-      if (!this.frameId) {
+/**
+ * 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
+
+  /**
+   * @private
+   */
+  function ScrollZoomHandler(map, handler) {
+    var _this = this;
+
+    (0, _classCallCheck2.default)(this, ScrollZoomHandler);
+    (0, _defineProperty2.default)(this, "onScrollFrame", function () {
+      if (!_this.frameId) {
         return;
       }
-      this.frameId = null;
-      if (!this.isActive()) {
+
+      _this.frameId = null;
+
+      if (!_this.isActive()) {
         return;
       }
-      const tr = this.map.transform;
-      if (this.delta !== 0) {
-        const zoomRate = this.type === "wheel" && Math.abs(this.delta) > wheelZoomDelta ? this.wheelZoomRate : this.defaultZoomRate;
-        let scale = maxScalePerFrame / (1 + Math.exp(-Math.abs(this.delta * zoomRate)));
-        if (this.delta < 0 && scale !== 0) {
+
+      var 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) {
+        // 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; // Scale by sigmoid of scroll wheel delta.
+
+        var scale = maxScalePerFrame / (1 + Math.exp(-Math.abs(_this.delta * zoomRate)));
+
+        if (_this.delta < 0 && scale !== 0) {
           scale = 1 / 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.type === "wheel") {
-          this.startZoom = tr.zoom;
-          this.easing = this.smoothOutEasing(200);
+
+        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))); // 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);
         }
-        this.delta = 0;
+
+        _this.delta = 0;
       }
-      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(((0, import_util.now)() - this.lastWheelEventTime) / 200, 1);
-        const k = easing(t);
-        zoom = (0, import_util.interpolate)(startZoom, targetZoom, k);
+
+      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(((0, _util.now)() - _this.lastWheelEventTime) / 200, 1);
+        var k = easing(t);
+        zoom = (0, _util.interpolate)(startZoom, targetZoom, k);
+
         if (t < 1) {
-          if (!this.frameId) {
-            this.frameId = true;
+          if (!_this.frameId) {
+            _this.frameId = true;
           }
         } else {
           finished = true;
@@ -77,24 +103,32 @@ var ScrollZoomHandler = class {
         zoom = targetZoom;
         finished = true;
       }
-      this.active = true;
+
+      _this.active = true;
+
       if (finished) {
-        this.active = false;
-        this.finishTimeout = setTimeout(() => {
-          this.zooming = false;
-          this.handler.triggerRenderFrame();
-          delete this.targetZoom;
-          delete this.finishTimeout;
+        _this.active = false; // @ts-ignore
+
+        _this.finishTimeout = setTimeout(function () {
+          _this.zooming = false;
+
+          _this.handler.triggerRenderFrame(); // @ts-ignore
+
+
+          delete _this.targetZoom; // @ts-ignore
+
+          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;
     this.el = map.getCanvasContainer();
     this.handler = handler;
@@ -102,124 +136,232 @@ var ScrollZoomHandler = class {
     this.defaultZoomRate = defaultZoomRate;
     this.wheelZoomRate = wheelZoomRate;
   }
-  setZoomRate(zoomRate) {
-    this.defaultZoomRate = zoomRate;
-  }
-  setWheelZoomRate(zoomRate) {
-    this.wheelZoomRate = zoomRate;
-  }
-  isEnabled() {
-    return !!this.enabled;
-  }
-  isActive() {
-    return !!this.active || this.finishTimeout !== void 0;
-  }
-  isZooming() {
-    return !!this.zooming;
-  }
-  enable(options) {
-    if (this.isEnabled()) {
-      return;
+  /**
+   * Set the zoom rate of a trackpad
+   * @param {number} [zoomRate=1/100] The rate used to scale trackpad movement to a zoom value.
+   * @example
+   * // Speed up trackpad zoom
+   * map.scrollZoom.setZoomRate(1/25);
+   */
+
+
+  (0, _createClass2.default)(ScrollZoomHandler, [{
+    key: "setZoomRate",
+    value: function setZoomRate(zoomRate) {
+      this.defaultZoomRate = zoomRate;
     }
-    this.enabled = true;
-    this.aroundCenter = options && options.around === "center";
-  }
-  disable() {
-    if (!this.isEnabled()) {
-      return;
+    /**
+     * 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;
     }
-    this.enabled = false;
-  }
-  wheel(e) {
-    if (!this.isEnabled()) {
-      return;
+    /**
+     * 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;
     }
-    let value = e.deltaMode === window.WheelEvent.DOM_DELTA_LINE ? e.deltaY * 40 : e.deltaY;
-    const nowTime = (0, import_util.now)();
-    const timeDelta = nowTime - (this.lastWheelEventTime || 0);
-    this.lastWheelEventTime = nowTime;
-    if (value !== 0 && value % wheelZoomDelta === 0) {
-      this.type = "wheel";
-    } else if (value !== 0 && Math.abs(value) < 4) {
-      this.type = "trackpad";
-    } else if (timeDelta > 400) {
-      this.type = null;
-      this.lastValue = value;
-      this.timeout = setTimeout(this.onTimeout, 40, e);
-    } else if (!this.type) {
-      this.type = Math.abs(timeDelta * value) < 200 ? "trackpad" : "wheel";
-      if (this.timeout) {
-        clearTimeout(this.timeout);
-        this.timeout = null;
-        value += this.lastValue;
-      }
+    /*
+     * 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;
     }
-    if (e.shiftKey && value) {
-      value = value / 4;
+  }, {
+    key: "isZooming",
+    value: function isZooming() {
+      return !!this.zooming;
     }
-    if (this.type) {
-      this.lastWheelEvent = e;
-      this.delta -= value;
-      if (!this.active) {
-        this.start(e);
+    /**
+     * 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';
     }
-    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);
+    /**
+     * Disables the "scroll to zoom" interaction.
+     *
+     * @example
+     *   map.scrollZoom.disable();
+     */
+
+  }, {
+    key: "disable",
+    value: function disable() {
+      if (!this.isEnabled()) {
+        return;
+      }
+
+      this.enabled = false;
     }
-  }
-  start(e) {
-    if (!this.delta) {
-      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 = (0, _util.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; // 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;
+        }
+      } // 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();
     }
-    if (this.frameId) {
-      this.frameId = null;
+  }, {
+    key: "renderFrame",
+    value: function renderFrame() {
+      return this.onScrollFrame();
     }
-    this.active = true;
-    if (!this.isZooming()) {
-      this.zooming = true;
+  }, {
+    key: "reset",
+    value: function reset() {
+      this.active = false;
     }
-    if (this.finishTimeout) {
-      clearTimeout(this.finishTimeout);
-      delete this.finishTimeout;
+  }, {
+    key: "onTimeout",
+    value: function onTimeout(initialEvent) {
+      this.type = 'wheel';
+      this.delta -= this.lastValue;
+
+      if (!this.active && this.start) {
+        this.start(initialEvent);
+      }
     }
-    const pos = import_dom.default.mousePos(this.el, e);
-    this.around = import_lng_lat.default.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();
+  }, {
+    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.default.mousePos(this.el, e);
+
+      this.around = _lng_lat.default.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 = import_util.ease;
-    if (this.prevEase) {
-      const preEase = this.prevEase;
-      const t = ((0, import_util.now)() - preEase.start) / preEase.duration;
-      const speed = preEase.easing(t + 0.01) - preEase.easing(t);
-      const x = 0.27 / Math.sqrt(speed * speed + 1e-4) * 0.01;
-      const y = Math.sqrt(0.27 * 0.27 - x * x);
-      easing = (0, import_util.bezier)(x, y, 0.25, 1);
+  }, {
+    key: "smoothOutEasing",
+    value: function smoothOutEasing(duration) {
+      var easing = _util.ease;
+
+      if (this.prevEase) {
+        var preEase = this.prevEase;
+        var t = ((0, _util.now)() - preEase.start) / preEase.duration;
+        var 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 = (0, _util.bezier)(x, y, 0.25, 1);
+      }
+
+      this.prevEase = {
+        start: (0, _util.now)(),
+        duration: duration,
+        easing: easing
+      };
+      return easing;
     }
-    this.prevEase = {
-      start: (0, import_util.now)(),
-      duration,
-      easing
-    };
-    return easing;
-  }
-};
-var scroll_zoom_default = ScrollZoomHandler;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {});
+  }]);
+  return ScrollZoomHandler;
+}();
+
+var _default = ScrollZoomHandler;
+exports.default = _default;

package/lib/handler/shim/dblclick_zoom.js

@@ -1,46 +1,80 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/handler/shim/dblclick_zoom.ts
-var dblclick_zoom_exports = {};
-__export(dblclick_zoom_exports, {
-  default: () => DoubleClickZoomHandler
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
 });
-module.exports = __toCommonJS(dblclick_zoom_exports);
-var DoubleClickZoomHandler = class {
-  constructor(clickZoom, TapZoom) {
+exports.default = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+/**
+ * The `DoubleClickZoomHandler` allows the user to zoom the map at a point by
+ * double clicking or double tapping.
+ */
+var DoubleClickZoomHandler = /*#__PURE__*/function () {
+  /**
+   * @private
+   */
+  function DoubleClickZoomHandler(clickZoom, TapZoom) {
+    (0, _classCallCheck2.default)(this, DoubleClickZoomHandler);
     this.clickZoom = clickZoom;
     this.tapZoom = TapZoom;
   }
-  enable() {
-    this.clickZoom.enable();
-    this.tapZoom.enable();
-  }
-  disable() {
-    this.clickZoom.disable();
-    this.tapZoom.disable();
-  }
-  isEnabled() {
-    return this.clickZoom.isEnabled() && this.tapZoom.isEnabled();
-  }
-  isActive() {
-    return this.clickZoom.isActive() || this.tapZoom.isActive();
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {});
+  /**
+   * Enables the "double click to zoom" interaction.
+   *
+   * @example
+   * map.doubleClickZoom.enable();
+   */
+
+
+  (0, _createClass2.default)(DoubleClickZoomHandler, [{
+    key: "enable",
+    value: function 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();
+    }
+    /**
+     * 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 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;
+}();
+
+exports.default = DoubleClickZoomHandler;