@antv/l7-map 2.9.32-alpha.2 → 2.9.33

package/lib/handler/shim/drag_pan.js

@@ -0,0 +1,55 @@
+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/drag_pan.ts
+var drag_pan_exports = {};
+__export(drag_pan_exports, {
+  default: () => DragPanHandler
+});
+module.exports = __toCommonJS(drag_pan_exports);
+var import_l7_utils = require("@antv/l7-utils");
+var DragPanHandler = class {
+  constructor(el, mousePan, touchPan) {
+    this.el = el;
+    this.mousePan = mousePan;
+    this.touchPan = touchPan;
+  }
+  enable(options) {
+    this.inertiaOptions = options || {};
+    this.mousePan.enable();
+    this.touchPan.enable();
+    if (!import_l7_utils.isMini) {
+      this.el.classList.add("l7-touch-drag-pan");
+    }
+  }
+  disable() {
+    this.mousePan.disable();
+    this.touchPan.disable();
+    if (!import_l7_utils.isMini) {
+      this.el.classList.remove("l7-touch-drag-pan");
+    }
+  }
+  isEnabled() {
+    return this.mousePan.isEnabled() && this.touchPan.isEnabled();
+  }
+  isActive() {
+    return this.mousePan.isActive() || this.touchPan.isActive();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/lib/handler/shim/drag_rotate.js

@@ -0,0 +1,49 @@
+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/drag_rotate.ts
+var drag_rotate_exports = {};
+__export(drag_rotate_exports, {
+  default: () => DragRotateHandler
+});
+module.exports = __toCommonJS(drag_rotate_exports);
+var DragRotateHandler = class {
+  constructor(options, mouseRotate, mousePitch) {
+    this.pitchWithRotate = options.pitchWithRotate;
+    this.mouseRotate = mouseRotate;
+    this.mousePitch = mousePitch;
+  }
+  enable() {
+    this.mouseRotate.enable();
+    if (this.pitchWithRotate) {
+      this.mousePitch.enable();
+    }
+  }
+  disable() {
+    this.mouseRotate.disable();
+    this.mousePitch.disable();
+  }
+  isEnabled() {
+    return this.mouseRotate.isEnabled() && (!this.pitchWithRotate || this.mousePitch.isEnabled());
+  }
+  isActive() {
+    return this.mouseRotate.isActive() || this.mousePitch.isActive();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/lib/handler/shim/touch_zoom_rotate.js

@@ -0,0 +1,71 @@
+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/touch_zoom_rotate.ts
+var touch_zoom_rotate_exports = {};
+__export(touch_zoom_rotate_exports, {
+  default: () => TouchZoomRotateHandler
+});
+module.exports = __toCommonJS(touch_zoom_rotate_exports);
+var import_l7_utils = require("@antv/l7-utils");
+var TouchZoomRotateHandler = class {
+  constructor(el, touchZoom, touchRotate, tapDragZoom) {
+    this.el = el;
+    this.touchZoom = touchZoom;
+    this.touchRotate = touchRotate;
+    this.tapDragZoom = tapDragZoom;
+    this.rotationDisabled = false;
+    this.enabled = true;
+  }
+  enable(options) {
+    this.touchZoom.enable(options);
+    if (!this.rotationDisabled) {
+      this.touchRotate.enable(options);
+    }
+    this.tapDragZoom.enable();
+    if (!import_l7_utils.isMini) {
+      this.el.classList.add("l7-touch-zoom-rotate");
+    }
+  }
+  disable() {
+    this.touchZoom.disable();
+    this.touchRotate.disable();
+    this.tapDragZoom.disable();
+    if (!import_l7_utils.isMini) {
+      this.el.classList.remove("l7-touch-zoom-rotate");
+    }
+  }
+  isEnabled() {
+    return this.touchZoom.isEnabled() && (this.rotationDisabled || this.touchRotate.isEnabled()) && this.tapDragZoom.isEnabled();
+  }
+  isActive() {
+    return this.touchZoom.isActive() || this.touchRotate.isActive() || this.tapDragZoom.isActive();
+  }
+  disableRotation() {
+    this.rotationDisabled = true;
+    this.touchRotate.disable();
+  }
+  enableRotation() {
+    this.rotationDisabled = false;
+    if (this.touchZoom.isEnabled()) {
+      this.touchRotate.enable();
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/lib/handler/tap/single_tap_recognizer.js

@@ -0,0 +1,102 @@
+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/tap/single_tap_recognizer.ts
+var single_tap_recognizer_exports = {};
+__export(single_tap_recognizer_exports, {
+  MAX_DIST: () => MAX_DIST,
+  MAX_TAP_INTERVAL: () => MAX_TAP_INTERVAL,
+  MAX_TOUCH_TIME: () => MAX_TOUCH_TIME,
+  default: () => SingleTapRecognizer
+});
+module.exports = __toCommonJS(single_tap_recognizer_exports);
+var import_point = __toESM(require("../../geo/point"));
+var import_handler_util = require("../handler_util");
+function getCentroid(points) {
+  const sum = new import_point.default(0, 0);
+  for (const point of points) {
+    sum._add(point);
+  }
+  return sum.div(points.length);
+}
+var MAX_TAP_INTERVAL = 500;
+var MAX_TOUCH_TIME = 500;
+var MAX_DIST = 30;
+var SingleTapRecognizer = class {
+  constructor(options) {
+    this.reset();
+    this.numTouches = options.numTouches;
+  }
+  reset() {
+    delete this.centroid;
+    delete this.startTime;
+    delete this.touches;
+    this.aborted = false;
+  }
+  touchstart(e, points, mapTouches) {
+    if (this.centroid || mapTouches.length > this.numTouches) {
+      this.aborted = true;
+    }
+    if (this.aborted) {
+      return;
+    }
+    if (this.startTime === void 0) {
+      this.startTime = e.timeStamp;
+    }
+    if (mapTouches.length === this.numTouches) {
+      this.centroid = getCentroid(points);
+      this.touches = (0, import_handler_util.indexTouches)(mapTouches, points);
+    }
+  }
+  touchmove(e, points, mapTouches) {
+    if (this.aborted || !this.centroid) {
+      return;
+    }
+    const newTouches = (0, import_handler_util.indexTouches)(mapTouches, points);
+    for (const id in this.touches) {
+      if (this.touches[id]) {
+        const prevPos = this.touches[id];
+        const pos = newTouches[id];
+        if (!pos || pos.dist(prevPos) > MAX_DIST) {
+          this.aborted = true;
+        }
+      }
+    }
+  }
+  touchend(e, points, mapTouches) {
+    if (!this.centroid || e.timeStamp - this.startTime > MAX_TOUCH_TIME) {
+      this.aborted = true;
+    }
+    if (mapTouches.length === 0) {
+      const centroid = !this.aborted && this.centroid;
+      this.reset();
+      if (centroid) {
+        return centroid;
+      }
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MAX_DIST,
+  MAX_TAP_INTERVAL,
+  MAX_TOUCH_TIME
+});

package/lib/handler/tap/tap_drag_zoom.js

@@ -0,0 +1,106 @@
+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/tap/tap_drag_zoom.ts
+var tap_drag_zoom_exports = {};
+__export(tap_drag_zoom_exports, {
+  default: () => TapDragZoomHandler
+});
+module.exports = __toCommonJS(tap_drag_zoom_exports);
+var import_single_tap_recognizer = require("./single_tap_recognizer");
+var import_tap_recognizer = __toESM(require("./tap_recognizer"));
+var TapDragZoomHandler = class {
+  constructor() {
+    this.tap = new import_tap_recognizer.default({
+      numTouches: 1,
+      numTaps: 1
+    });
+    this.reset();
+  }
+  reset() {
+    this.active = false;
+    delete this.swipePoint;
+    delete this.swipeTouch;
+    delete this.tapTime;
+    this.tap.reset();
+  }
+  touchstart(e, points, mapTouches) {
+    if (this.swipePoint) {
+      return;
+    }
+    if (this.tapTime && e.timeStamp - this.tapTime > import_single_tap_recognizer.MAX_TAP_INTERVAL) {
+      this.reset();
+    }
+    if (!this.tapTime) {
+      this.tap.touchstart(e, points, mapTouches);
+    } else if (mapTouches.length > 0) {
+      this.swipePoint = points[0];
+      this.swipeTouch = mapTouches[0].identifier;
+    }
+  }
+  touchmove(e, points, mapTouches) {
+    if (!this.tapTime) {
+      this.tap.touchmove(e, points, mapTouches);
+    } else if (this.swipePoint) {
+      if (mapTouches[0].identifier !== this.swipeTouch) {
+        return;
+      }
+      const newSwipePoint = points[0];
+      const dist = newSwipePoint.y - this.swipePoint.y;
+      this.swipePoint = newSwipePoint;
+      e.preventDefault();
+      this.active = true;
+      return {
+        zoomDelta: dist / 128
+      };
+    }
+  }
+  touchend(e, points, mapTouches) {
+    if (!this.tapTime) {
+      const point = this.tap.touchend(e, points, mapTouches);
+      if (point) {
+        this.tapTime = e.timeStamp;
+      }
+    } else if (this.swipePoint) {
+      if (mapTouches.length === 0) {
+        this.reset();
+      }
+    }
+  }
+  touchcancel() {
+    this.reset();
+  }
+  enable() {
+    this.enabled = true;
+  }
+  disable() {
+    this.enabled = false;
+    this.reset();
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  isActive() {
+    return this.active;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/lib/handler/tap/tap_recognizer.js

@@ -0,0 +1,66 @@
+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/tap/tap_recognizer.ts
+var tap_recognizer_exports = {};
+__export(tap_recognizer_exports, {
+  default: () => TapRecognizer
+});
+module.exports = __toCommonJS(tap_recognizer_exports);
+var import_single_tap_recognizer = __toESM(require("./single_tap_recognizer"));
+var TapRecognizer = class {
+  constructor(options) {
+    this.singleTap = new import_single_tap_recognizer.default(options);
+    this.numTaps = options.numTaps;
+    this.reset();
+  }
+  reset() {
+    this.lastTime = Infinity;
+    delete this.lastTap;
+    this.count = 0;
+    this.singleTap.reset();
+  }
+  touchstart(e, points, mapTouches) {
+    this.singleTap.touchstart(e, points, mapTouches);
+  }
+  touchmove(e, points, mapTouches) {
+    this.singleTap.touchmove(e, points, mapTouches);
+  }
+  touchend(e, points, mapTouches) {
+    const tap = this.singleTap.touchend(e, points, mapTouches);
+    if (tap) {
+      const soonEnough = e.timeStamp - this.lastTime < import_single_tap_recognizer.MAX_TAP_INTERVAL;
+      const closeEnough = !this.lastTap || this.lastTap.dist(tap) < import_single_tap_recognizer.MAX_DIST;
+      if (!soonEnough || !closeEnough) {
+        this.reset();
+      }
+      this.count++;
+      this.lastTime = e.timeStamp;
+      this.lastTap = tap;
+      if (this.count === this.numTaps) {
+        this.reset();
+        return tap;
+      }
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/lib/handler/tap/tap_zoom.js

@@ -0,0 +1,99 @@
+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/tap/tap_zoom.ts
+var tap_zoom_exports = {};
+__export(tap_zoom_exports, {
+  default: () => TapZoomHandler
+});
+module.exports = __toCommonJS(tap_zoom_exports);
+var import_tap_recognizer = __toESM(require("./tap_recognizer"));
+var TapZoomHandler = class {
+  constructor() {
+    this.zoomIn = new import_tap_recognizer.default({
+      numTouches: 1,
+      numTaps: 2
+    });
+    this.zoomOut = new import_tap_recognizer.default({
+      numTouches: 2,
+      numTaps: 1
+    });
+    this.reset();
+  }
+  reset() {
+    this.active = false;
+    this.zoomIn.reset();
+    this.zoomOut.reset();
+  }
+  touchstart(e, points, mapTouches) {
+    this.zoomIn.touchstart(e, points, mapTouches);
+    this.zoomOut.touchstart(e, points, mapTouches);
+  }
+  touchmove(e, points, mapTouches) {
+    this.zoomIn.touchmove(e, points, mapTouches);
+    this.zoomOut.touchmove(e, points, mapTouches);
+  }
+  touchend(e, points, mapTouches) {
+    const zoomInPoint = this.zoomIn.touchend(e, points, mapTouches);
+    const zoomOutPoint = this.zoomOut.touchend(e, points, mapTouches);
+    if (zoomInPoint) {
+      this.active = true;
+      e.preventDefault();
+      setTimeout(() => this.reset(), 0);
+      return {
+        cameraAnimation: (map) => map.easeTo({
+          duration: 300,
+          zoom: map.getZoom() + 1,
+          around: map.unproject(zoomInPoint)
+        }, { originalEvent: e })
+      };
+    } else if (zoomOutPoint) {
+      this.active = true;
+      e.preventDefault();
+      setTimeout(() => this.reset(), 0);
+      return {
+        cameraAnimation: (map) => map.easeTo({
+          duration: 300,
+          zoom: map.getZoom() - 1,
+          around: map.unproject(zoomOutPoint)
+        }, { originalEvent: e })
+      };
+    }
+  }
+  touchcancel() {
+    this.reset();
+  }
+  enable() {
+    this.enabled = true;
+  }
+  disable() {
+    this.enabled = false;
+    this.reset();
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  isActive() {
+    return this.active;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/lib/handler/touch/index.js

@@ -0,0 +1,41 @@
+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/touch/index.ts
+var touch_exports = {};
+__export(touch_exports, {
+  TouchPanHandler: () => import_touch_pan.default,
+  TouchPitchHandler: () => import_touch_pitch.default,
+  TouchRotateHandler: () => import_touch_rotate.default,
+  TouchZoomHandler: () => import_touch_zoom.default
+});
+module.exports = __toCommonJS(touch_exports);
+var import_touch_pan = __toESM(require("./touch_pan"));
+var import_touch_pitch = __toESM(require("./touch_pitch"));
+var import_touch_rotate = __toESM(require("./touch_rotate"));
+var import_touch_zoom = __toESM(require("./touch_zoom"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TouchPanHandler,
+  TouchPitchHandler,
+  TouchRotateHandler,
+  TouchZoomHandler
+});