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

package/es/handler/touch/touch_zoom.js

@@ -0,0 +1,67 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _get from "@babel/runtime/helpers/get";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(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
+import TwoTouchHandler from "./two_touch";
+var ZOOM_THRESHOLD = 0.1;
+
+function getZoomDelta(distance, lastDistance) {
+  return Math.log(distance / lastDistance) / Math.LN2;
+}
+
+var TouchZoomHandler = /*#__PURE__*/function (_TwoTouchHandler) {
+  _inherits(TouchZoomHandler, _TwoTouchHandler);
+
+  var _super = _createSuper(TouchZoomHandler);
+
+  function TouchZoomHandler() {
+    _classCallCheck(this, TouchZoomHandler);
+
+    return _super.apply(this, arguments);
+  }
+
+  _createClass(TouchZoomHandler, [{
+    key: "reset",
+    value: function reset() {
+      _get(_getPrototypeOf(TouchZoomHandler.prototype), "reset", this).call(this); //@ts-ignore
+
+
+      delete this.distance; //@ts-ignore
+
+      delete this.startDistance;
+    }
+  }, {
+    key: "start",
+    value: function start(points) {
+      this.startDistance = this.distance = points[0].dist(points[1]);
+    }
+  }, {
+    key: "move",
+    value: function move(points, pinchAround) {
+      var 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: pinchAround
+      };
+    }
+  }]);
+
+  return TouchZoomHandler;
+}(TwoTouchHandler);
+
+export { TouchZoomHandler as default };

package/es/handler/touch/two_touch.d.ts

@@ -0,0 +1,23 @@
+import Point from '../../geo/point';
+export default class TwoTouchHandler {
+    protected enabled: boolean;
+    protected active: boolean;
+    protected firstTwoTouches: [number, number];
+    protected vector: Point;
+    protected startVector: Point;
+    protected aroundCenter: boolean;
+    constructor();
+    reset(): void;
+    start(points: [Point, Point]): void;
+    move(points: [Point, Point], pinchAround: Point | null, e: TouchEvent): void;
+    touchstart(e: TouchEvent, points: Point[], mapTouches: Touch[]): void;
+    touchmove(e: TouchEvent, points: Point[], mapTouches: Touch[]): void;
+    touchend(e: TouchEvent, points: Point[], mapTouches: Touch[]): void;
+    touchcancel(): void;
+    enable(options?: {
+        around?: 'center';
+    }): void;
+    disable(): void;
+    isEnabled(): boolean;
+    isActive(): boolean;
+}

package/es/handler/touch/two_touch.js

@@ -0,0 +1,134 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+// @ts-ignore
+import DOM from "../../utils/dom";
+
+var TwoTouchHandler = /*#__PURE__*/function () {
+  function TwoTouchHandler() {
+    _classCallCheck(this, TwoTouchHandler);
+
+    this.reset();
+  }
+
+  _createClass(TwoTouchHandler, [{
+    key: "reset",
+    value: function reset() {
+      this.active = false; //@ts-ignore
+
+      delete this.firstTwoTouches;
+    }
+  }, {
+    key: "start",
+    value: function start(points) {
+      return;
+    } // eslint-disable-line
+
+  }, {
+    key: "move",
+    value: function move(points, pinchAround, e) {
+      return;
+    } // eslint-disable-line
+
+  }, {
+    key: "touchstart",
+    value: function touchstart(e, points, mapTouches) {
+      // console.log(e.target, e.targetTouches.length ? e.targetTouches[0].target : null);
+      // log('touchstart', points, e.target.innerHTML, e.targetTouches.length ? e.targetTouches[0].target.innerHTML: undefined);
+      if (this.firstTwoTouches || mapTouches.length < 2) {
+        return;
+      }
+
+      this.firstTwoTouches = [mapTouches[0].identifier, mapTouches[1].identifier]; // implemented by child classes
+
+      this.start([points[0], points[1]]);
+    }
+  }, {
+    key: "touchmove",
+    value: function touchmove(e, points, mapTouches) {
+      if (!this.firstTwoTouches) {
+        return;
+      }
+
+      e.preventDefault();
+
+      var _this$firstTwoTouches = _slicedToArray(this.firstTwoTouches, 2),
+          idA = _this$firstTwoTouches[0],
+          idB = _this$firstTwoTouches[1];
+
+      var a = getTouchById(mapTouches, points, idA);
+      var b = getTouchById(mapTouches, points, idB);
+
+      if (!a || !b) {
+        return;
+      }
+
+      var pinchAround = this.aroundCenter ? null : a.add(b).div(2); // implemented by child classes
+
+      return this.move([a, b], pinchAround, e);
+    }
+  }, {
+    key: "touchend",
+    value: function touchend(e, points, mapTouches) {
+      if (!this.firstTwoTouches) {
+        return;
+      }
+
+      var _this$firstTwoTouches2 = _slicedToArray(this.firstTwoTouches, 2),
+          idA = _this$firstTwoTouches2[0],
+          idB = _this$firstTwoTouches2[1];
+
+      var a = getTouchById(mapTouches, points, idA);
+      var b = getTouchById(mapTouches, points, idB);
+
+      if (a && b) {
+        return;
+      }
+
+      if (this.active) {
+        DOM.suppressClick();
+      }
+
+      this.reset();
+    }
+  }, {
+    key: "touchcancel",
+    value: function touchcancel() {
+      this.reset();
+    }
+  }, {
+    key: "enable",
+    value: function enable(options) {
+      this.enabled = true;
+      this.aroundCenter = !!options && options.around === 'center';
+    }
+  }, {
+    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 TwoTouchHandler;
+}();
+
+export { TwoTouchHandler as default };
+
+function getTouchById(mapTouches, points, identifier) {
+  for (var i = 0; i < mapTouches.length; i++) {
+    if (mapTouches[i].identifier === identifier) {
+      return points[i];
+    }
+  }
+}

package/es/hash.d.ts

@@ -0,0 +1,14 @@
+import { Map } from './map';
+declare class Hash {
+    private map;
+    private updateHash;
+    private hashName?;
+    constructor(hashName?: string);
+    addTo(map: Map): this;
+    remove(): this;
+    onHashChange: () => boolean;
+    private getCurrentHash;
+    private getHashString;
+    private updateHashUnthrottled;
+}
+export default Hash;

package/es/hash.js

@@ -0,0 +1,156 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+// @ts-ignore
+// tslint:disable-next-line:no-submodule-imports
+import { $window } from '@antv/l7-utils';
+import { throttle } from 'lodash';
+
+/*
+ * Adds the map's position to its page's location hash.
+ * Passed as an option to the map object.
+ *
+ * @returns {Hash} `this`
+ */
+var Hash = /*#__PURE__*/function () {
+  function Hash(hashName) {
+    var _this = this;
+
+    _classCallCheck(this, Hash);
+
+    _defineProperty(this, "onHashChange", function () {
+      var loc = _this.getCurrentHash();
+
+      if (loc.length >= 3 && !loc.some(function (v) {
+        return isNaN(+v);
+      })) {
+        var 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: bearing,
+          pitch: +(loc[4] || 0)
+        });
+
+        return true;
+      }
+
+      return false;
+    });
+
+    _defineProperty(this, "getCurrentHash", function () {
+      // Get the current hash from location, stripped from its number sign
+      var hash = window.location.hash.replace('#', '');
+
+      if (_this.hashName) {
+        // Split the parameter-styled hash into parts and find the value we need
+        var keyval;
+        hash.split('&').map(function (part) {
+          return part.split('=');
+        }).forEach(function (part) {
+          if (part[0] === _this.hashName) {
+            keyval = part;
+          }
+        });
+        return (keyval ? keyval[1] || '' : '').split('/');
+      }
+
+      return hash.split('/');
+    });
+
+    _defineProperty(this, "updateHashUnthrottled", function () {
+      var hash = _this.getHashString();
+
+      try {
+        window.history.replaceState(window.history.state, '', hash);
+      } catch (SecurityError) {// IE11 does not allow this if the page is within an iframe created
+        // with iframe.contentWindow.document.write(...).
+        // https://github.com/mapbox/mapbox-gl-js/issues/7410
+      }
+    });
+
+    this.hashName = hashName && encodeURIComponent(hashName); // Mobile Safari doesn't allow updating the hash more than 100 times per 30 seconds.
+
+    this.updateHash = throttle(this.updateHashUnthrottled, 30 * 1000 / 100);
+  }
+
+  _createClass(Hash, [{
+    key: "addTo",
+    value: function addTo(map) {
+      this.map = map;
+      $window.addEventListener('hashchange', this.onHashChange, false);
+      this.map.on('moveend', this.updateHash);
+      return this;
+    }
+  }, {
+    key: "remove",
+    value: function remove() {
+      $window.removeEventListener('hashchange', this.onHashChange, false);
+      this.map.off('moveend', this.updateHash); // clearTimeout(this.updateHash());
+      // @ts-ignore
+
+      delete this.map;
+      return this;
+    }
+  }, {
+    key: "getHashString",
+    value: function getHashString(mapFeedback) {
+      var center = this.map.getCenter();
+      var zoom = Math.round(this.map.getZoom() * 100) / 100; // derived from equation: 512px * 2^z / 360 / 10^d < 0.5px
+
+      var precision = Math.ceil((zoom * Math.LN2 + Math.log(512 / 360 / 0.5)) / Math.LN10);
+      var m = Math.pow(10, precision);
+      var lng = Math.round(center.lng * m) / m;
+      var lat = Math.round(center.lat * m) / m;
+      var bearing = this.map.getBearing();
+      var pitch = this.map.getPitch();
+      var hash = '';
+
+      if (mapFeedback) {
+        // new map feedback site has some constraints that don't allow
+        // us to use the same hash format as we do for the Map hash option.
+        hash += "/".concat(lng, "/").concat(lat, "/").concat(zoom);
+      } else {
+        hash += "".concat(zoom, "/").concat(lat, "/").concat(lng);
+      }
+
+      if (bearing || pitch) {
+        hash += "/".concat(Math.round(bearing * 10) / 10);
+      }
+
+      if (pitch) {
+        hash += "/".concat(Math.round(pitch));
+      }
+
+      if (this.hashName) {
+        var hashName = this.hashName;
+        var found = false;
+        var parts = window.location.hash.slice(1).split('&').map(function (part) {
+          var key = part.split('=')[0];
+
+          if (key === hashName) {
+            found = true;
+            return "".concat(key, "=").concat(hash);
+          }
+
+          return part;
+        }).filter(function (a) {
+          return a;
+        });
+
+        if (!found) {
+          parts.push("".concat(hashName, "=").concat(hash));
+        }
+
+        return "#".concat(parts.join('&'));
+      }
+
+      return "#".concat(hash);
+    }
+  }]);
+
+  return Hash;
+}();
+
+export default Hash;

package/es/index.d.ts

@@ -0,0 +1,3 @@
+export * from './map';
+export * from './earthmap';
+export * from './interface';

package/es/index.js

@@ -0,0 +1,3 @@
+export * from "./map";
+export * from "./earthmap";
+export * from "./interface";

package/es/interface.d.ts

@@ -0,0 +1,34 @@
+import { LngLatBoundsLike } from './geo/lng_lat_bounds';
+export interface IMapOptions {
+    hash: boolean;
+    style?: any;
+    container?: HTMLElement | string;
+    canvas?: HTMLCanvasElement;
+    center: [number, number];
+    zoom: number;
+    bearing: number;
+    pitch: number;
+    interactive: boolean;
+    scrollZoom: boolean;
+    bounds?: LngLatBoundsLike;
+    maxBounds?: LngLatBoundsLike;
+    fitBoundsOptions?: any;
+    minZoom: number;
+    maxZoom: number;
+    minPitch: number;
+    maxPitch: number;
+    boxZoom: boolean;
+    dragRotate: boolean;
+    dragPan: boolean;
+    keyboard: boolean;
+    doubleClickZoom: boolean;
+    touchZoomRotate: boolean;
+    touchPitch: boolean;
+    trackResize: boolean;
+    renderWorldCopies: boolean;
+    bearingSnap: number;
+    clickTolerance: number;
+    pitchWithRotate: boolean;
+    pitchEnabled: boolean;
+    rotateEnabled: boolean;
+}

package/es/interface.js

@@ -0,0 +1 @@
+export {};

package/es/map.d.ts

@@ -0,0 +1,70 @@
+import Camera from './camera';
+import './css/l7.css';
+import LngLat, { LngLatLike } from './geo/lng_lat';
+import LngLatBounds, { LngLatBoundsLike } from './geo/lng_lat_bounds';
+import Point, { PointLike } from './geo/point';
+import BoxZoomHandler from './handler/box_zoom';
+import HandlerManager from './handler/handler_manager';
+import KeyboardHandler from './handler/keyboard';
+import ScrollZoomHandler from './handler/scroll_zoom';
+import DoubleClickZoomHandler from './handler/shim/dblclick_zoom';
+import DragPanHandler from './handler/shim/drag_pan';
+import DragRotateHandler from './handler/shim/drag_rotate';
+import TouchZoomRotateHandler from './handler/shim/touch_zoom_rotate';
+import { TouchPitchHandler } from './handler/touch';
+import { IMapOptions } from './interface';
+import { TaskID } from './utils/task_queue';
+declare type CallBack = (_: number) => void;
+export declare class Map extends Camera {
+    doubleClickZoom: DoubleClickZoomHandler;
+    dragRotate: DragRotateHandler;
+    dragPan: DragPanHandler;
+    touchZoomRotate: TouchZoomRotateHandler;
+    scrollZoom: ScrollZoomHandler;
+    keyboard: KeyboardHandler;
+    touchPitch: TouchPitchHandler;
+    boxZoom: BoxZoomHandler;
+    handlers: HandlerManager;
+    private container;
+    private canvas;
+    private canvasContainer;
+    private renderTaskQueue;
+    private frame;
+    private trackResize;
+    private hash;
+    constructor(options: Partial<IMapOptions>);
+    resize(eventData?: any): this;
+    getContainer(): HTMLElement;
+    getCanvas(): HTMLCanvasElement;
+    getCanvasContainer(): HTMLElement;
+    project(lngLat: LngLatLike): Point;
+    unproject(point: PointLike): LngLat;
+    getBounds(): LngLatBounds;
+    getMaxBounds(): LngLatBounds | null;
+    setMaxBounds(bounds: LngLatBoundsLike): void;
+    setStyle(style: any): void;
+    setMinZoom(minZoom?: number): this;
+    getMinZoom(): number;
+    setMaxZoom(maxZoom?: number): this;
+    getMaxZoom(): number;
+    setMinPitch(minPitch?: number): this;
+    getMinPitch(): number;
+    setMaxPitch(maxPitch?: number): this;
+    getMaxPitch(): number;
+    getRenderWorldCopies(): boolean;
+    setRenderWorldCopies(renderWorldCopies?: boolean): void;
+    remove(): void;
+    requestRenderFrame(cb: CallBack): TaskID;
+    cancelRenderFrame(id: TaskID): void;
+    triggerRepaint(): void;
+    update(time?: number): void;
+    private initContainer;
+    /**
+     * 小程序环境构建容器
+     */
+    private initMiniContainer;
+    private containerDimensions;
+    private onWindowOnline;
+    private onWindowResize;
+}
+export {};