@antv/l7-map 2.18.2 → 2.18.3

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,134 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+// @ts-ignore
+// tslint:disable-next-line:no-submodule-imports
+import { lodashUtil } from '@antv/l7-utils';
+var throttle = lodashUtil.throttle;
+/*
+ * 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,4 @@
+export * from './earthmap';
+export * from './geo/mercator';
+export * from './interface';
+export * from './map';

package/es/index.js

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

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';
+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 {};

package/es/map.js

@@ -0,0 +1,387 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _assertThisInitialized from "@babel/runtime/helpers/esm/assertThisInitialized";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+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; } }
+import { DOM, lodashUtil } from '@antv/l7-utils';
+import Camera from "./camera";
+function loadStyles(css, doc) {
+  var isMiniAli = typeof my !== 'undefined' && !!my && typeof my.showToast === 'function' && my.isFRM !== true;
+  var isWeChatMiniProgram = typeof wx !== 'undefined' && wx !== null && (typeof wx.request !== 'undefined' || typeof wx.miniProgram !== 'undefined');
+  if (isMiniAli || isWeChatMiniProgram) {
+    return;
+  }
+  if (!doc) doc = document;
+  if (!doc) {
+    return;
+  }
+  var head = doc.head || doc.getElementsByTagName('head')[0];
+  if (!head) {
+    head = doc.createElement('head');
+    var body = doc.body || doc.getElementsByTagName('body')[0];
+    if (body) {
+      body.parentNode.insertBefore(head, body);
+    } else {
+      doc.documentElement.appendChild(head);
+    }
+  }
+  var style = doc.createElement('style');
+  style.type = 'text/css';
+  if (style.styleSheet) {
+    style.styleSheet.cssText = css;
+  } else {
+    style.appendChild(doc.createTextNode(css));
+  }
+  head.appendChild(style);
+  return style;
+}
+loadStyles(".l7-map {\n  font: 12px/20px 'Helvetica Neue', Arial, Helvetica, sans-serif;\n  overflow: hidden;\n  position: relative;\n  -webkit-tap-highlight-color: rgba(0, 0, 0, 0);\n}\n\n.l7-canvas {\n  position: absolute;\n  left: 0;\n  top: 0;\n}\n\n.l7-map:-webkit-full-screen {\n  width: 100%;\n  height: 100%;\n}\n\n.l7-canary {\n  background-color: salmon;\n}\n\n.l7-canvas-container.l7-interactive,\n.l7-ctrl-group button.l7-ctrl-compass {\n  cursor: -webkit-grab;\n  cursor: grab;\n  -moz-user-select: none;\n  -webkit-user-select: none;\n  -ms-user-select: none;\n  user-select: none;\n}\n\n.l7-canvas-container.l7-interactive.l7-track-pointer {\n  cursor: pointer;\n}\n\n.l7-canvas-container.l7-interactive:active,\n.l7-ctrl-group button.l7-ctrl-compass:active {\n  cursor: -webkit-grabbing;\n  cursor: grabbing;\n}\n\n.l7-canvas-container.l7-touch-zoom-rotate,\n.l7-canvas-container.l7-touch-zoom-rotate .l7-canvas {\n  -ms-touch-action: pan-x pan-y;\n      touch-action: pan-x pan-y;\n}\n\n.l7-canvas-container.l7-touch-drag-pan,\n.l7-canvas-container.l7-touch-drag-pan .l7-canvas {\n  -ms-touch-action: pinch-zoom;\n      touch-action: pinch-zoom;\n}\n\n.l7-canvas-container.l7-touch-zoom-rotate.l7-touch-drag-pan,\n.l7-canvas-container.l7-touch-zoom-rotate.l7-touch-drag-pan .l7-canvas {\n  -ms-touch-action: none;\n      touch-action: none;\n}\n\n.l7-ctrl-top-left,\n.l7-ctrl-top-right,\n.l7-ctrl-bottom-left,\n.l7-ctrl-bottom-right { position: absolute; pointer-events: none; z-index: 2; }\n.l7-ctrl-top-left     { top: 0; left: 0; }\n.l7-ctrl-top-right    { top: 0; right: 0; }\n.l7-ctrl-bottom-left  { bottom: 0; left: 0; }\n.l7-ctrl-bottom-right { right: 0; bottom: 0; }\n\n.l7-ctrl {\n  clear: both;\n  pointer-events: auto;\n\n  /* workaround for a Safari bug https://github.com/mapbox/mapbox-gl-js/issues/8185 */\n  -webkit-transform: translate(0, 0);\n          transform: translate(0, 0);\n}\n.l7-ctrl-top-left .l7-ctrl     { margin: 10px 0 0 10px; float: left; }\n.l7-ctrl-top-right .l7-ctrl    { margin: 10px 10px 0 0; float: right; }\n.l7-ctrl-bottom-left .l7-ctrl  { margin: 0 0 10px 10px; float: left; }\n.l7-ctrl-bottom-right .l7-ctrl { margin: 0 10px 10px 0; float: right; }\n\n\n.l7-crosshair,\n.l7-crosshair .l7-interactive,\n.l7-crosshair .l7-interactive:active {\n    cursor: crosshair;\n}\n\n.l7-boxzoom {\n    position: absolute;\n    top: 0;\n    left: 0;\n    width: 0;\n    height: 0;\n    background: #fff;\n    border: 2px dotted #202020;\n    opacity: 0.5;\n    z-index: 10;\n}\n");
+import LngLat from "./geo/lng_lat";
+import LngLatBounds from "./geo/lng_lat_bounds";
+// @ts-ignore
+import Point from "./geo/point";
+import HandlerManager from "./handler/handler_manager";
+import Hash from "./hash";
+import { renderframe } from "./util";
+import { PerformanceUtils } from "./utils/performance";
+import TaskQueue from "./utils/task_queue";
+var defaultMinZoom = -2;
+var defaultMaxZoom = 22;
+var merge = lodashUtil.merge;
+// the default values, but also the valid range
+var defaultMinPitch = 0;
+var defaultMaxPitch = 60;
+var DefaultOptions = {
+  hash: false,
+  zoom: -1,
+  center: [112, 32],
+  pitch: 0,
+  bearing: 0,
+  interactive: true,
+  minZoom: defaultMinZoom,
+  maxZoom: defaultMaxZoom,
+  minPitch: defaultMinPitch,
+  maxPitch: defaultMaxPitch,
+  scrollZoom: true,
+  boxZoom: true,
+  dragRotate: true,
+  dragPan: true,
+  keyboard: true,
+  doubleClickZoom: true,
+  touchZoomRotate: true,
+  touchPitch: true,
+  bearingSnap: 7,
+  clickTolerance: 3,
+  pitchWithRotate: true,
+  trackResize: true,
+  renderWorldCopies: true,
+  pitchEnabled: true,
+  rotateEnabled: true
+};
+export var Map = /*#__PURE__*/function (_Camera) {
+  _inherits(Map, _Camera);
+  var _super = _createSuper(Map);
+  function Map(options) {
+    var _this;
+    _classCallCheck(this, Map);
+    _this = _super.call(this, merge({}, DefaultOptions, options));
+    _defineProperty(_assertThisInitialized(_this), "renderTaskQueue", new TaskQueue());
+    _defineProperty(_assertThisInitialized(_this), "trackResize", true);
+    _defineProperty(_assertThisInitialized(_this), "onWindowOnline", function () {
+      _this.update();
+    });
+    _defineProperty(_assertThisInitialized(_this), "onWindowResize", function (event) {
+      if (_this.trackResize) {
+        _this.resize({
+          originalEvent: event
+        }).update();
+      }
+    });
+    _this.initContainer();
+    _this.resize();
+    _this.handlers = new HandlerManager(_assertThisInitialized(_this), _this.options);
+    if (typeof window !== 'undefined') {
+      window.addEventListener('online', _this.onWindowOnline, false);
+      window.addEventListener('resize', _this.onWindowResize, false);
+      window.addEventListener('orientationchange', _this.onWindowResize, false);
+    }
+    var hashName = typeof options.hash === 'string' && options.hash || undefined;
+    if (options.hash) {
+      _this.hash = new Hash(hashName).addTo(_assertThisInitialized(_this));
+    }
+
+    // don't set position from options if set through hash
+    if (!_this.hash || !_this.hash.onHashChange()) {
+      _this.jumpTo({
+        center: options.center,
+        zoom: options.zoom,
+        bearing: options.bearing,
+        pitch: options.pitch
+      });
+      if (options.bounds) {
+        _this.resize();
+        _this.fitBounds(options.bounds, merge({}, options.fitBoundsOptions, {
+          duration: 0
+        }));
+      }
+    }
+    return _this;
+  }
+  _createClass(Map, [{
+    key: "resize",
+    value: function resize(eventData) {
+      var _this$containerDimens = this.containerDimensions(),
+        _this$containerDimens2 = _slicedToArray(_this$containerDimens, 2),
+        width = _this$containerDimens2[0],
+        height = _this$containerDimens2[1];
+      this.transform.resize(width, height);
+      // 小程序环境不需要执行后续动作
+      var fireMoving = !this.moving;
+      if (fireMoving) {
+        this.stop();
+        this.emit('movestart', new window.Event('movestart', eventData));
+        this.emit('move', new window.Event('move', eventData));
+      }
+      this.emit('resize', new window.Event('resize', eventData));
+      if (fireMoving) {
+        this.emit('moveend', new window.Event('moveend', eventData));
+      }
+      return this;
+    }
+  }, {
+    key: "getContainer",
+    value: function getContainer() {
+      return this.container;
+    }
+  }, {
+    key: "getCanvas",
+    value: function getCanvas() {
+      return this.canvas;
+    }
+  }, {
+    key: "getCanvasContainer",
+    value: function getCanvasContainer() {
+      return this.canvasContainer;
+    }
+  }, {
+    key: "project",
+    value: function project(lngLat) {
+      return this.transform.locationPoint(LngLat.convert(lngLat));
+    }
+  }, {
+    key: "unproject",
+    value: function unproject(point) {
+      return this.transform.pointLocation(Point.convert(point));
+    }
+  }, {
+    key: "getBounds",
+    value: function getBounds() {
+      return this.transform.getBounds();
+    }
+  }, {
+    key: "getMaxBounds",
+    value: function getMaxBounds() {
+      return this.transform.getMaxBounds();
+    }
+  }, {
+    key: "setMaxBounds",
+    value: function setMaxBounds(bounds) {
+      this.transform.setMaxBounds(LngLatBounds.convert(bounds));
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  }, {
+    key: "setStyle",
+    value: function setStyle(style) {
+      return;
+    }
+  }, {
+    key: "setMinZoom",
+    value: function setMinZoom(minZoom) {
+      minZoom = minZoom === null || minZoom === undefined ? defaultMinZoom : minZoom;
+      if (minZoom >= defaultMinZoom && minZoom <= this.transform.maxZoom) {
+        this.transform.minZoom = minZoom;
+        if (this.getZoom() < minZoom) {
+          this.setZoom(minZoom);
+        }
+        return this;
+      } else {
+        throw new Error("minZoom must be between ".concat(defaultMinZoom, " and the current maxZoom, inclusive"));
+      }
+    }
+  }, {
+    key: "getMinZoom",
+    value: function getMinZoom() {
+      return this.transform.minZoom;
+    }
+  }, {
+    key: "setMaxZoom",
+    value: function setMaxZoom(maxZoom) {
+      maxZoom = maxZoom === null || maxZoom === undefined ? defaultMaxZoom : maxZoom;
+      if (maxZoom >= this.transform.minZoom) {
+        this.transform.maxZoom = maxZoom;
+        if (this.getZoom() > maxZoom) {
+          this.setZoom(maxZoom);
+        }
+        return this;
+      } else {
+        throw new Error('maxZoom must be greater than the current minZoom');
+      }
+    }
+  }, {
+    key: "getMaxZoom",
+    value: function getMaxZoom() {
+      return this.transform.maxZoom;
+    }
+  }, {
+    key: "setMinPitch",
+    value: function setMinPitch(minPitch) {
+      minPitch = minPitch === null || minPitch === undefined ? defaultMinPitch : minPitch;
+      if (minPitch < defaultMinPitch) {
+        throw new Error("minPitch must be greater than or equal to ".concat(defaultMinPitch));
+      }
+      if (minPitch >= defaultMinPitch && minPitch <= this.transform.maxPitch) {
+        this.transform.minPitch = minPitch;
+        if (this.getPitch() < minPitch) {
+          this.setPitch(minPitch);
+        }
+        return this;
+      } else {
+        throw new Error("minPitch must be between ".concat(defaultMinPitch, " and the current maxPitch, inclusive"));
+      }
+    }
+  }, {
+    key: "getMinPitch",
+    value: function getMinPitch() {
+      return this.transform.minPitch;
+    }
+  }, {
+    key: "setMaxPitch",
+    value: function setMaxPitch(maxPitch) {
+      maxPitch = maxPitch === null || maxPitch === undefined ? defaultMaxPitch : maxPitch;
+      if (maxPitch > defaultMaxPitch) {
+        throw new Error("maxPitch must be less than or equal to ".concat(defaultMaxPitch));
+      }
+      if (maxPitch >= this.transform.minPitch) {
+        this.transform.maxPitch = maxPitch;
+        if (this.getPitch() > maxPitch) {
+          this.setPitch(maxPitch);
+        }
+        return this;
+      } else {
+        throw new Error('maxPitch must be greater than the current minPitch');
+      }
+    }
+  }, {
+    key: "getMaxPitch",
+    value: function getMaxPitch() {
+      return this.transform.maxPitch;
+    }
+  }, {
+    key: "getRenderWorldCopies",
+    value: function getRenderWorldCopies() {
+      return this.transform.renderWorldCopies;
+    }
+  }, {
+    key: "setRenderWorldCopies",
+    value: function setRenderWorldCopies(renderWorldCopies) {
+      this.transform.renderWorldCopies = !!renderWorldCopies;
+    }
+  }, {
+    key: "remove",
+    value: function remove() {
+      this.container.removeChild(this.canvasContainer);
+      // @ts-ignore
+      this.canvasContainer = null;
+      if (this.frame) {
+        this.frame.cancel();
+        this.frame = null;
+      }
+      this.renderTaskQueue.clear();
+    }
+  }, {
+    key: "requestRenderFrame",
+    value: function requestRenderFrame(cb) {
+      this.update();
+      return this.renderTaskQueue.add(cb);
+    }
+  }, {
+    key: "cancelRenderFrame",
+    value: function cancelRenderFrame(id) {
+      return this.renderTaskQueue.remove(id);
+    }
+  }, {
+    key: "triggerRepaint",
+    value: function triggerRepaint() {
+      var _this2 = this;
+      if (!this.frame) {
+        this.frame = renderframe(function (paintStartTimeStamp) {
+          PerformanceUtils.frame(paintStartTimeStamp);
+          _this2.frame = null;
+          _this2.update(paintStartTimeStamp);
+        });
+      }
+    }
+  }, {
+    key: "update",
+    value: function update(time) {
+      var _this3 = this;
+      if (!this.frame) {
+        this.frame = renderframe(function (paintStartTimeStamp) {
+          PerformanceUtils.frame(paintStartTimeStamp);
+          _this3.frame = null;
+          _this3.renderTaskQueue.run(time);
+        });
+      }
+    }
+  }, {
+    key: "initContainer",
+    value: function initContainer() {
+      if (typeof this.options.container === 'string') {
+        this.container = window.document.getElementById(this.options.container);
+        if (!this.container) {
+          throw new Error("Container '".concat(this.options.container, "' not found."));
+        }
+      } else if (this.options.container instanceof HTMLElement) {
+        this.container = this.options.container;
+      } else {
+        throw new Error("Invalid type: 'container' must be a String or HTMLElement.");
+      }
+      var container = this.container;
+      container.classList.add('l7-map');
+      var canvasContainer = this.canvasContainer = DOM.create('div', 'l7-canvas-container', container);
+      if (this.options.interactive) {
+        canvasContainer.classList.add('l7-interactive');
+      }
+    }
+
+    /**
+     * 小程序环境构建容器
+     */
+  }, {
+    key: "initMiniContainer",
+    value: function initMiniContainer() {
+      this.container = this.options.canvas;
+      this.canvasContainer = this.container;
+    }
+  }, {
+    key: "containerDimensions",
+    value: function containerDimensions() {
+      var width = 0;
+      var height = 0;
+      if (this.container) {
+        width = this.container.clientWidth;
+        height = this.container.clientHeight;
+        width = width === 0 ? 400 : width;
+        height = height === 0 ? 300 : height;
+      }
+      return [width, height];
+    }
+  }]);
+  return Map;
+}(Camera);

package/es/util.d.ts

@@ -0,0 +1,25 @@
+export interface ICancelable {
+    cancel: () => void;
+}
+export declare function wrap(n: number, min: number, max: number): number;
+export declare function clamp(n: number, min: number, max: number): number;
+export declare function interpolate(a: number, b: number, t: number): number;
+export declare function bezier(p1x: number, p1y: number, p2x: number, p2y: number): (t: number) => number;
+export declare const ease: (t: number) => number;
+export declare function prefersReducedMotion(): boolean;
+export declare function pick(src: {
+    [key: string]: any;
+}, properties: string[]): {
+    [key: string]: any;
+};
+export declare const now: () => number;
+export declare const raf: ((callback: FrameRequestCallback) => number) & typeof requestAnimationFrame;
+export declare const cancel: ((handle: number) => void) & typeof cancelAnimationFrame;
+export declare function renderframe(fn: (paintStartTimestamp: number) => void): ICancelable;
+export declare function extend(dest: {
+    [key: string]: any;
+}, ...sources: Array<Partial<{
+    [key: string]: any;
+}>>): {
+    [key: string]: any;
+};