@antv/l7-map 2.21.0 → 2.21.2

package/lib/hash.js

@@ -5,50 +5,47 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 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 _l7Utils = require("@antv/l7-utils");
 // @ts-ignore
 // tslint:disable-next-line:no-submodule-imports
 
-var throttle = _l7Utils.lodashUtil.throttle;
+const {
+  throttle
+} = _l7Utils.lodashUtil;
 /*
  * 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;
-    (0, _classCallCheck2.default)(this, Hash);
-    (0, _defineProperty2.default)(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({
+class Hash {
+  constructor(hashName) {
+    (0, _defineProperty2.default)(this, "map", void 0);
+    (0, _defineProperty2.default)(this, "updateHash", void 0);
+    (0, _defineProperty2.default)(this, "hashName", void 0);
+    (0, _defineProperty2.default)(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: bearing,
+          bearing,
           pitch: +(loc[4] || 0)
         });
         return true;
       }
       return false;
     });
-    (0, _defineProperty2.default)(this, "getCurrentHash", function () {
+    (0, _defineProperty2.default)(this, "getCurrentHash", () => {
       // Get the current hash from location, stripped from its number sign
-      var hash = window.location.hash.replace('#', '');
-      if (_this.hashName) {
+      const 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) {
+        let keyval;
+        hash.split('&').map(part => part.split('=')).forEach(part => {
+          if (part[0] === this.hashName) {
             keyval = part;
           }
         });
@@ -56,8 +53,8 @@ var Hash = /*#__PURE__*/function () {
       }
       return hash.split('/');
     });
-    (0, _defineProperty2.default)(this, "updateHashUnthrottled", function () {
-      var hash = _this.getHashString();
+    (0, _defineProperty2.default)(this, "updateHashUnthrottled", () => {
+      const hash = this.getHashString();
       try {
         window.history.replaceState(window.history.state, '', hash);
       } catch (SecurityError) {
@@ -71,72 +68,62 @@ var Hash = /*#__PURE__*/function () {
     // Mobile Safari doesn't allow updating the hash more than 100 times per 30 seconds.
     this.updateHash = throttle(this.updateHashUnthrottled, 30 * 1000 / 100);
   }
-  (0, _createClass2.default)(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());
+  addTo(map) {
+    this.map = map;
+    window.addEventListener('hashchange', this.onHashChange, false);
+    this.map.on('moveend', this.updateHash);
+    return this;
+  }
+  remove() {
+    window.removeEventListener('hashchange', this.onHashChange, false);
+    this.map.off('moveend', this.updateHash);
+    // clearTimeout(this.updateHash());
 
-      // @ts-ignore
-      delete this.map;
-      return this;
+    // @ts-ignore
+    delete this.map;
+    return this;
+  }
+  getHashString(mapFeedback) {
+    const center = this.map.getCenter();
+    const zoom = Math.round(this.map.getZoom() * 100) / 100;
+    // derived from equation: 512px * 2^z / 360 / 10^d < 0.5px
+    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) {
+      // 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 += `/${lng}/${lat}/${zoom}`;
+    } else {
+      hash += `${zoom}/${lat}/${lng}`;
     }
-  }, {
-    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));
+    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 "#".concat(parts.join('&'));
+        return part;
+      }).filter(a => a);
+      if (!found) {
+        parts.push(`${hashName}=${hash}`);
       }
-      return "#".concat(hash);
+      return `#${parts.join('&')}`;
     }
-  }]);
-  return Hash;
-}();
+    return `#${hash}`;
+  }
+}
 var _default = exports.default = Hash;

package/lib/index.d.ts

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

package/lib/index.js

@@ -9,7 +9,7 @@ Object.keys(_earthmap).forEach(function (key) {
   if (key in exports && exports[key] === _earthmap[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
-    get: function get() {
+    get: function () {
       return _earthmap[key];
     }
   });
@@ -20,7 +20,7 @@ Object.keys(_mercator).forEach(function (key) {
   if (key in exports && exports[key] === _mercator[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
-    get: function get() {
+    get: function () {
       return _mercator[key];
     }
   });
@@ -31,7 +31,7 @@ Object.keys(_interface).forEach(function (key) {
   if (key in exports && exports[key] === _interface[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
-    get: function get() {
+    get: function () {
       return _interface[key];
     }
   });
@@ -42,7 +42,7 @@ Object.keys(_map).forEach(function (key) {
   if (key in exports && exports[key] === _map[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
-    get: function get() {
+    get: function () {
       return _map[key];
     }
   });

package/lib/interface.d.ts

@@ -0,0 +1,34 @@
+import type { 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/lib/map.d.ts

@@ -0,0 +1,70 @@
+import Camera from './camera';
+import './css/l7.css';
+import type { LngLatLike } from './geo/lng_lat';
+import LngLat from './geo/lng_lat';
+import type { LngLatBoundsLike } from './geo/lng_lat_bounds';
+import LngLatBounds from './geo/lng_lat_bounds';
+import type { PointLike } from './geo/point';
+import Point from './geo/point';
+import type BoxZoomHandler from './handler/box_zoom';
+import HandlerManager from './handler/handler_manager';
+import type KeyboardHandler from './handler/keyboard';
+import type ScrollZoomHandler from './handler/scroll_zoom';
+import type DoubleClickZoomHandler from './handler/shim/dblclick_zoom';
+import type DragPanHandler from './handler/shim/drag_pan';
+import type DragRotateHandler from './handler/shim/drag_rotate';
+import type TouchZoomRotateHandler from './handler/shim/touch_zoom_rotate';
+import type { TouchPitchHandler } from './handler/touch';
+import type { IMapOptions } from './interface';
+import type { TaskID } from './utils/task_queue';
+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;
+    getCanvasOverlays(): 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 containerDimensions;
+    private onWindowOnline;
+    private onWindowResize;
+}
+export {};