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

package/lib/handler/touch/touch_pan.js

@@ -0,0 +1,110 @@
+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/touch_pan.ts
+var touch_pan_exports = {};
+__export(touch_pan_exports, {
+  default: () => TouchPanHandler
+});
+module.exports = __toCommonJS(touch_pan_exports);
+var import_point = __toESM(require("../../geo/point"));
+var import_handler_util = require("../handler_util");
+var TouchPanHandler = class {
+  constructor(options) {
+    this.minTouches = 1;
+    this.clickTolerance = options.clickTolerance || 1;
+    this.reset();
+  }
+  reset() {
+    this.active = false;
+    this.touches = {};
+    this.sum = new import_point.default(0, 0);
+  }
+  touchstart(e, points, mapTouches) {
+    return this.calculateTransform(e, points, mapTouches);
+  }
+  touchmove(e, points, mapTouches) {
+    if (!this.active) {
+      return;
+    }
+    e.preventDefault();
+    return this.calculateTransform(e, points, mapTouches);
+  }
+  touchend(e, points, mapTouches) {
+    this.calculateTransform(e, points, mapTouches);
+    if (this.active && mapTouches.length < this.minTouches) {
+      this.reset();
+    }
+  }
+  touchcancel() {
+    this.reset();
+  }
+  enable() {
+    this.enabled = true;
+  }
+  disable() {
+    this.enabled = false;
+    this.reset();
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  isActive() {
+    return this.active;
+  }
+  calculateTransform(e, points, mapTouches) {
+    if (mapTouches.length > 0) {
+      this.active = true;
+    }
+    const touches = (0, import_handler_util.indexTouches)(mapTouches, points);
+    const touchPointSum = new import_point.default(0, 0);
+    const touchDeltaSum = new import_point.default(0, 0);
+    let touchDeltaCount = 0;
+    for (const identifier in touches) {
+      if (touches[identifier]) {
+        const point = touches[identifier];
+        const prevPoint = this.touches[identifier];
+        if (prevPoint) {
+          touchPointSum._add(point);
+          touchDeltaSum._add(point.sub(prevPoint));
+          touchDeltaCount++;
+          touches[identifier] = point;
+        }
+      }
+    }
+    this.touches = touches;
+    if (touchDeltaCount < this.minTouches || !touchDeltaSum.mag()) {
+      return;
+    }
+    const panDelta = touchDeltaSum.div(touchDeltaCount);
+    this.sum._add(panDelta);
+    if (this.sum.mag() < this.clickTolerance) {
+      return;
+    }
+    const around = touchPointSum.div(touchDeltaCount);
+    return {
+      around,
+      panDelta
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/lib/handler/touch/touch_pitch.js

@@ -0,0 +1,86 @@
+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/touch_pitch.ts
+var touch_pitch_exports = {};
+__export(touch_pitch_exports, {
+  default: () => TouchPitchHandler
+});
+module.exports = __toCommonJS(touch_pitch_exports);
+var import_two_touch = __toESM(require("./two_touch"));
+function isVertical(vector) {
+  return Math.abs(vector.y) > Math.abs(vector.x);
+}
+var ALLOWED_SINGLE_TOUCH_TIME = 100;
+var TouchPitchHandler = class extends import_two_touch.default {
+  reset() {
+    super.reset();
+    this.valid = void 0;
+    delete this.firstMove;
+    delete this.lastPoints;
+  }
+  start(points) {
+    this.lastPoints = points;
+    if (isVertical(points[0].sub(points[1]))) {
+      this.valid = false;
+    }
+  }
+  move(points, center, e) {
+    const vectorA = points[0].sub(this.lastPoints[0]);
+    const vectorB = points[1].sub(this.lastPoints[1]);
+    this.valid = this.gestureBeginsVertically(vectorA, vectorB, e.timeStamp);
+    if (!this.valid) {
+      return;
+    }
+    this.lastPoints = points;
+    this.active = true;
+    const yDeltaAverage = (vectorA.y + vectorB.y) / 2;
+    const degreesPerPixelMoved = -0.5;
+    return {
+      pitchDelta: yDeltaAverage * degreesPerPixelMoved
+    };
+  }
+  gestureBeginsVertically(vectorA, vectorB, timeStamp) {
+    if (this.valid !== void 0) {
+      return this.valid;
+    }
+    const threshold = 2;
+    const movedA = vectorA.mag() >= threshold;
+    const movedB = vectorB.mag() >= threshold;
+    if (!movedA && !movedB) {
+      return;
+    }
+    if (!movedA || !movedB) {
+      if (this.firstMove === void 0) {
+        this.firstMove = timeStamp;
+      }
+      if (timeStamp - this.firstMove < ALLOWED_SINGLE_TOUCH_TIME) {
+        return void 0;
+      } else {
+        return false;
+      }
+    }
+    const isSameDirection = vectorA.y > 0 === vectorB.y > 0;
+    return isVertical(vectorA) && isVertical(vectorB) && isSameDirection;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/lib/handler/touch/touch_rotate.js

@@ -0,0 +1,65 @@
+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/touch_rotate.ts
+var touch_rotate_exports = {};
+__export(touch_rotate_exports, {
+  default: () => TouchRotateHandler
+});
+module.exports = __toCommonJS(touch_rotate_exports);
+var import_two_touch = __toESM(require("./two_touch"));
+var ROTATION_THRESHOLD = 25;
+function getBearingDelta(a, b) {
+  return a.angleWith(b) * 180 / Math.PI;
+}
+var TouchRotateHandler = class extends import_two_touch.default {
+  reset() {
+    super.reset();
+    delete this.minDiameter;
+    delete this.startVector;
+    delete this.vector;
+  }
+  start(points) {
+    this.startVector = this.vector = points[0].sub(points[1]);
+    this.minDiameter = points[0].dist(points[1]);
+  }
+  move(points, pinchAround) {
+    const lastVector = this.vector;
+    this.vector = points[0].sub(points[1]);
+    if (!this.active && this.isBelowThreshold(this.vector)) {
+      return;
+    }
+    this.active = true;
+    return {
+      bearingDelta: getBearingDelta(this.vector, lastVector),
+      pinchAround
+    };
+  }
+  isBelowThreshold(vector) {
+    this.minDiameter = Math.min(this.minDiameter, vector.mag());
+    const circumference = Math.PI * this.minDiameter;
+    const threshold = ROTATION_THRESHOLD / circumference * 360;
+    const bearingDeltaSinceStart = getBearingDelta(vector, this.startVector);
+    return Math.abs(bearingDeltaSinceStart) < threshold;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/lib/handler/touch/touch_zoom.js

@@ -0,0 +1,56 @@
+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/touch_zoom.ts
+var touch_zoom_exports = {};
+__export(touch_zoom_exports, {
+  default: () => TouchZoomHandler
+});
+module.exports = __toCommonJS(touch_zoom_exports);
+var import_two_touch = __toESM(require("./two_touch"));
+var ZOOM_THRESHOLD = 0.1;
+function getZoomDelta(distance, lastDistance) {
+  return Math.log(distance / lastDistance) / Math.LN2;
+}
+var TouchZoomHandler = class extends import_two_touch.default {
+  reset() {
+    super.reset();
+    delete this.distance;
+    delete this.startDistance;
+  }
+  start(points) {
+    this.startDistance = this.distance = points[0].dist(points[1]);
+  }
+  move(points, pinchAround) {
+    const lastDistance = this.distance;
+    this.distance = points[0].dist(points[1]);
+    if (!this.active && Math.abs(getZoomDelta(this.distance, this.startDistance)) < ZOOM_THRESHOLD) {
+      return;
+    }
+    this.active = true;
+    return {
+      zoomDelta: getZoomDelta(this.distance, lastDistance),
+      pinchAround
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/lib/handler/touch/two_touch.js

@@ -0,0 +1,105 @@
+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/two_touch.ts
+var two_touch_exports = {};
+__export(two_touch_exports, {
+  default: () => TwoTouchHandler
+});
+module.exports = __toCommonJS(two_touch_exports);
+var import_dom = __toESM(require("../../utils/dom"));
+var TwoTouchHandler = class {
+  constructor() {
+    this.reset();
+  }
+  reset() {
+    this.active = false;
+    delete this.firstTwoTouches;
+  }
+  start(points) {
+    return;
+  }
+  move(points, pinchAround, e) {
+    return;
+  }
+  touchstart(e, points, mapTouches) {
+    if (this.firstTwoTouches || mapTouches.length < 2) {
+      return;
+    }
+    this.firstTwoTouches = [mapTouches[0].identifier, mapTouches[1].identifier];
+    this.start([points[0], points[1]]);
+  }
+  touchmove(e, points, mapTouches) {
+    if (!this.firstTwoTouches) {
+      return;
+    }
+    e.preventDefault();
+    const [idA, idB] = this.firstTwoTouches;
+    const a = getTouchById(mapTouches, points, idA);
+    const b = getTouchById(mapTouches, points, idB);
+    if (!a || !b) {
+      return;
+    }
+    const pinchAround = this.aroundCenter ? null : a.add(b).div(2);
+    return this.move([a, b], pinchAround, e);
+  }
+  touchend(e, points, mapTouches) {
+    if (!this.firstTwoTouches) {
+      return;
+    }
+    const [idA, idB] = this.firstTwoTouches;
+    const a = getTouchById(mapTouches, points, idA);
+    const b = getTouchById(mapTouches, points, idB);
+    if (a && b) {
+      return;
+    }
+    if (this.active) {
+      import_dom.default.suppressClick();
+    }
+    this.reset();
+  }
+  touchcancel() {
+    this.reset();
+  }
+  enable(options) {
+    this.enabled = true;
+    this.aroundCenter = !!options && options.around === "center";
+  }
+  disable() {
+    this.enabled = false;
+    this.reset();
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  isActive() {
+    return this.active;
+  }
+};
+function getTouchById(mapTouches, points, identifier) {
+  for (let i = 0; i < mapTouches.length; i++) {
+    if (mapTouches[i].identifier === identifier) {
+      return points[i];
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/lib/hash.js

@@ -0,0 +1,120 @@
+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/hash.ts
+var hash_exports = {};
+__export(hash_exports, {
+  default: () => hash_default
+});
+module.exports = __toCommonJS(hash_exports);
+var import_l7_utils = require("@antv/l7-utils");
+var import_lodash = require("lodash");
+var Hash = class {
+  constructor(hashName) {
+    this.onHashChange = () => {
+      const loc = this.getCurrentHash();
+      if (loc.length >= 3 && !loc.some((v) => isNaN(+v))) {
+        const bearing = this.map.dragRotate.isEnabled() && this.map.touchZoomRotate.isEnabled() ? +(loc[3] || 0) : this.map.getBearing();
+        this.map.jumpTo({
+          center: [+loc[2], +loc[1]],
+          zoom: +loc[0],
+          bearing,
+          pitch: +(loc[4] || 0)
+        });
+        return true;
+      }
+      return false;
+    };
+    this.getCurrentHash = () => {
+      const hash = window.location.hash.replace("#", "");
+      if (this.hashName) {
+        let keyval;
+        hash.split("&").map((part) => part.split("=")).forEach((part) => {
+          if (part[0] === this.hashName) {
+            keyval = part;
+          }
+        });
+        return (keyval ? keyval[1] || "" : "").split("/");
+      }
+      return hash.split("/");
+    };
+    this.updateHashUnthrottled = () => {
+      const hash = this.getHashString();
+      try {
+        window.history.replaceState(window.history.state, "", hash);
+      } catch (SecurityError) {
+      }
+    };
+    this.hashName = hashName && encodeURIComponent(hashName);
+    this.updateHash = (0, import_lodash.throttle)(this.updateHashUnthrottled, 30 * 1e3 / 100);
+  }
+  addTo(map) {
+    this.map = map;
+    import_l7_utils.$window.addEventListener("hashchange", this.onHashChange, false);
+    this.map.on("moveend", this.updateHash);
+    return this;
+  }
+  remove() {
+    import_l7_utils.$window.removeEventListener("hashchange", this.onHashChange, false);
+    this.map.off("moveend", this.updateHash);
+    delete this.map;
+    return this;
+  }
+  getHashString(mapFeedback) {
+    const center = this.map.getCenter();
+    const zoom = Math.round(this.map.getZoom() * 100) / 100;
+    const precision = Math.ceil((zoom * Math.LN2 + Math.log(512 / 360 / 0.5)) / Math.LN10);
+    const m = Math.pow(10, precision);
+    const lng = Math.round(center.lng * m) / m;
+    const lat = Math.round(center.lat * m) / m;
+    const bearing = this.map.getBearing();
+    const pitch = this.map.getPitch();
+    let hash = "";
+    if (mapFeedback) {
+      hash += `/${lng}/${lat}/${zoom}`;
+    } else {
+      hash += `${zoom}/${lat}/${lng}`;
+    }
+    if (bearing || pitch) {
+      hash += `/${Math.round(bearing * 10) / 10}`;
+    }
+    if (pitch) {
+      hash += `/${Math.round(pitch)}`;
+    }
+    if (this.hashName) {
+      const hashName = this.hashName;
+      let found = false;
+      const parts = window.location.hash.slice(1).split("&").map((part) => {
+        const key = part.split("=")[0];
+        if (key === hashName) {
+          found = true;
+          return `${key}=${hash}`;
+        }
+        return part;
+      }).filter((a) => a);
+      if (!found) {
+        parts.push(`${hashName}=${hash}`);
+      }
+      return `#${parts.join("&")}`;
+    }
+    return `#${hash}`;
+  }
+};
+var hash_default = Hash;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/lib/index.js

@@ -0,0 +1,21 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("./map"), module.exports);
+__reExport(src_exports, require("./earthmap"), module.exports);
+__reExport(src_exports, require("./interface"), module.exports);

package/lib/interface.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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/interface.ts
+var interface_exports = {};
+module.exports = __toCommonJS(interface_exports);