mobility-toolbox-js 2.0.0-beta.30 → 2.0.0-beta.34

package/mapbox/layers/RealtimeLayer.js

@@ -1,185 +1,312 @@
-import { fromLonLat } from "ol/proj";
-import { unByKey } from "ol/Observable";
-import { getWidth, getHeight } from "ol/extent";
-import transformRotate from "@turf/transform-rotate";
-import { point } from "@turf/helpers";
-import mixin from "../../common/mixins/RealtimeLayerMixin";
-import Layer from "./Layer";
-import { getSourceCoordinates, getMercatorResolution } from "../utils";
-class RealtimeLayer extends mixin(Layer) {
-  constructor(options = {}) {
-    super({
-      ...options
-    });
-    this.onLoad = this.onLoad.bind(this);
-    this.onMove = this.onMove.bind(this);
-    this.onMoveEnd = this.onMoveEnd.bind(this);
-    this.onZoomEnd = this.onZoomEnd.bind(this);
-    this.onVisibilityChange = this.onVisibilityChange.bind(this);
-  }
-  attachToMap(map, beforeId) {
-    if (!map) {
-      return;
-    }
-    const canvas = map.getCanvas();
-    super.attachToMap(map, {
-      width: canvas.width / this.pixelRatio,
-      height: canvas.height / this.pixelRatio
-    });
-    this.source = {
-      type: "canvas",
-      canvas: this.canvas,
-      coordinates: getSourceCoordinates(map, this.pixelRatio),
-      animate: true,
-      attribution: this.copyrights && this.copyrights.join(", ")
-    };
-    this.beforeId = beforeId;
-    this.layer = {
-      id: this.key,
-      type: "raster",
-      source: this.key,
-      layout: {
-        visibility: this.visible ? "visible" : "none"
-      },
-      paint: {
-        "raster-opacity": 1,
-        "raster-fade-duration": 0,
-        "raster-resampling": "nearest"
-      }
-    };
-    if (map.isStyleLoaded()) {
-      this.onLoad();
-    }
-    this.map.on("load", this.onLoad);
-    this.listeners = [this.on("change:visible", this.onVisibilityChange)];
-  }
-  detachFromMap() {
-    if (this.map) {
-      this.map.off("load", this.onLoad);
-      this.listeners.forEach((listener) => {
-        unByKey(listener);
-      });
-      if (this.map.getLayer(this.key)) {
-        this.map.removeLayer(this.key);
-      }
-      if (this.map.getSource(this.key)) {
-        this.map.removeSource(this.key);
-      }
-    }
-    super.detachFromMap();
-  }
-  start() {
-    super.start();
-    this.map.on("move", this.onMove);
-    this.map.on("moveend", this.onMoveEnd);
-    this.map.on("zoomend", this.onZoomEnd);
-  }
-  stop() {
-    super.stop();
-    if (this.map) {
-      this.map.off("move", this.onMove);
-      this.map.off("moveend", this.onMoveEnd);
-      this.map.off("zoomend", this.onZoomEnd);
-    }
-  }
-  onLoad() {
-    if (!this.map.getSource(this.key)) {
-      this.map.addSource(this.key, this.source);
-    }
-    if (!this.map.getLayer(this.key)) {
-      this.map.addLayer(this.layer, this.beforeId);
-    }
-  }
-  onUserMoveCallback(evt) {
-    super.onUserMoveCallback({
-      coordinate: fromLonLat(evt.lngLat.toArray()),
-      ...evt
-    });
-  }
-  renderTrajectories(noInterpolate) {
-    if (!this.map) {
-      return;
-    }
-    const { width, height } = this.map.getCanvas();
-    const center = this.map.getCenter();
-    const leftBottom = this.map.unproject({
-      x: 0,
-      y: height / this.pixelRatio
-    });
-    const rightTop = this.map.unproject({ x: width / this.pixelRatio, y: 0 });
-    const coord0 = transformRotate(point([leftBottom.lng, leftBottom.lat]), -this.map.getBearing(), {
-      pivot: [center.lng, center.lat]
-    }).geometry.coordinates;
-    const coord1 = transformRotate(point([rightTop.lng, rightTop.lat]), -this.map.getBearing(), {
-      pivot: [center.lng, center.lat]
-    }).geometry.coordinates;
-    const bounds = [...fromLonLat(coord0), ...fromLonLat(coord1)];
-    const xResolution = getWidth(bounds) / (width / this.pixelRatio);
-    const yResolution = getHeight(bounds) / (height / this.pixelRatio);
-    const res = Math.max(xResolution, yResolution);
-    const viewState = {
-      size: [width / this.pixelRatio, height / this.pixelRatio],
-      center: fromLonLat([center.lng, center.lat]),
-      extent: bounds,
-      resolution: res,
-      zoom: this.map.getZoom(),
-      rotation: -(this.map.getBearing() * Math.PI) / 180,
-      pixelRatio: this.pixelRatio
-    };
-    super.renderTrajectories(viewState, noInterpolate);
-  }
-  getRefreshTimeInMs() {
-    return super.getRefreshTimeInMs(this.map.getZoom());
-  }
-  getFeatureInfoAtCoordinate(coordinate, options = {}) {
-    const resolution = getMercatorResolution(this.map);
-    return super.getFeatureInfoAtCoordinate(coordinate, {
-      resolution,
-      ...options
-    });
-  }
-  onVisibilityChange() {
-    if (this.visible && !this.map.getLayer(this.key)) {
-      this.map.addLayer(this.layer, this.beforeId);
-    } else if (this.map.getLayer(this.key)) {
-      this.map.removeLayer(this.key);
-    }
-  }
-  purgeTrajectory(trajectory, extent, zoom) {
-    return super.purgeTrajectory(trajectory, extent || this.getMercatorExtent(), zoom || Math.floor(this.map.getZoom() + 1));
-  }
-  setBbox(extent, zoom) {
-    let newExtent = extent;
-    let newZoom = zoom;
-    if (!newExtent && this.isUpdateBboxOnMoveEnd) {
-      newExtent = extent || this.getMercatorExtent();
-      newZoom = Math.floor(this.getOlZoom());
-    }
-    super.setBbox(newExtent, newZoom);
-  }
-  onMove() {
-    this.renderTrajectories();
-  }
-  renderTrajectoriesInternal(viewState, noInterpolate) {
-    const render = super.renderTrajectoriesInternal(viewState, noInterpolate);
-    if (render) {
-      const extent = getSourceCoordinates(this.map, this.pixelRatio);
-      const source = this.map.getSource(this.key);
-      if (source) {
-        source.setCoordinates(extent);
-      }
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
     }
-    return render;
-  }
-  onMoveEnd() {
-    this.renderTrajectories();
-    if (this.visible && this.isUpdateBboxOnMoveEnd) {
-      this.setBbox();
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var proj_1 = require("ol/proj");
+var Observable_1 = require("ol/Observable");
+var extent_1 = require("ol/extent");
+var transform_rotate_1 = require("@turf/transform-rotate");
+var helpers_1 = require("@turf/helpers");
+var RealtimeLayerMixin_1 = require("../../common/mixins/RealtimeLayerMixin");
+var Layer_1 = require("./Layer");
+var utils_1 = require("../utils");
+/**
+ * Responsible for loading and display data from a Realtime service.
+ *
+ * @example
+ * import { RealtimeLayer } from 'mobility-toolbox-js/mapbox';
+ *
+ * const layer = new RealtimeLayer({
+ *   url: [yourUrl],
+ *   apiKey: [yourApiKey],
+ * });
+ *
+ *
+ * @see <a href="/api/class/src/api/RealtimeAPI%20js~RealtimeAPI%20html">RealtimeAPI</a>
+ *
+ * @extends {Layer}
+ * @implements {RealtimeLayerInterface}
+ */
+var RealtimeLayer = /** @class */ (function (_super) {
+    __extends(RealtimeLayer, _super);
+    function RealtimeLayer(options) {
+        if (options === void 0) { options = {}; }
+        var _this = _super.call(this, __assign({}, options)) || this;
+        /** @ignore */
+        _this.onLoad = _this.onLoad.bind(_this);
+        /** @ignore */
+        _this.onMove = _this.onMove.bind(_this);
+        /** @ignore */
+        _this.onMoveEnd = _this.onMoveEnd.bind(_this);
+        /** @ignore */
+        _this.onZoomEnd = _this.onZoomEnd.bind(_this);
+        /** @ignore */
+        _this.onVisibilityChange = _this.onVisibilityChange.bind(_this);
+        return _this;
     }
-  }
-  onFeatureHover(features, layer, coordinate) {
-    super.onFeatureHover(features, layer, coordinate);
-    this.map.getCanvasContainer().style.cursor = features.length ? "pointer" : "auto";
-  }
-}
-export default RealtimeLayer;
+    /**
+     * Initialize the layer.
+     *
+     * @param {mapboxgl.Map} map A [mapbox Map](https://docs.mapbox.com/mapbox-gl-js/api/map/).
+     * @param {string} beforeId Layer's id before which we want to add the new layer.
+     * @override
+     */
+    RealtimeLayer.prototype.attachToMap = function (map, beforeId) {
+        if (!map) {
+            return;
+        }
+        var canvas = map.getCanvas();
+        _super.prototype.attachToMap.call(this, map, {
+            width: canvas.width / this.pixelRatio,
+            height: canvas.height / this.pixelRatio,
+        });
+        this.source = {
+            type: 'canvas',
+            canvas: this.canvas,
+            coordinates: (0, utils_1.getSourceCoordinates)(map, this.pixelRatio),
+            // Set to true if the canvas source is animated. If the canvas is static, animate should be set to false to improve performance.
+            animate: true,
+            attribution: this.copyrights && this.copyrights.join(', '),
+        };
+        this.beforeId = beforeId;
+        this.layer = {
+            id: this.key,
+            type: 'raster',
+            source: this.key,
+            layout: {
+                visibility: this.visible ? 'visible' : 'none',
+            },
+            paint: {
+                'raster-opacity': 1,
+                'raster-fade-duration': 0,
+                'raster-resampling': 'nearest', // important otherwise it looks blurry
+            },
+        };
+        if (map.isStyleLoaded()) {
+            this.onLoad();
+        }
+        this.map.on('load', this.onLoad);
+        this.listeners = [this.on('change:visible', this.onVisibilityChange)];
+    };
+    /**
+     * Remove listeners from the Mapbox Map.
+     */
+    RealtimeLayer.prototype.detachFromMap = function () {
+        if (this.map) {
+            this.map.off('load', this.onLoad);
+            this.listeners.forEach(function (listener) {
+                (0, Observable_1.unByKey)(listener);
+            });
+            if (this.map.style && this.map.getLayer(this.key)) {
+                this.map.removeLayer(this.key);
+            }
+            if (this.map.style && this.map.getSource(this.key)) {
+                this.map.removeSource(this.key);
+            }
+        }
+        _super.prototype.detachFromMap.call(this);
+    };
+    /**
+     * Start updating vehicles position.
+     *
+     * @listens {mapboxgl.map.event:zoomend} Listen to zoom end event.
+     * @listens {mapboxgl.map.event:mousemove} Listen to mousemove end.
+     * @override
+     */
+    RealtimeLayer.prototype.start = function () {
+        _super.prototype.start.call(this);
+        this.map.on('move', this.onMove);
+        this.map.on('moveend', this.onMoveEnd);
+        this.map.on('zoomend', this.onZoomEnd);
+    };
+    /**
+     * Stop updating vehicles position, and unlisten events.
+     *
+     * @override
+     */
+    RealtimeLayer.prototype.stop = function () {
+        _super.prototype.stop.call(this);
+        if (this.map) {
+            this.map.off('move', this.onMove);
+            this.map.off('moveend', this.onMoveEnd);
+            this.map.off('zoomend', this.onZoomEnd);
+        }
+    };
+    RealtimeLayer.prototype.onLoad = function () {
+        if (!this.map.getSource(this.key)) {
+            this.map.addSource(this.key, this.source);
+        }
+        if (!this.map.getLayer(this.key)) {
+            this.map.addLayer(this.layer, this.beforeId);
+        }
+    };
+    /**
+     * Function triggered when the user moves the cursor over the map.
+     * @override
+     */
+    RealtimeLayer.prototype.onUserMoveCallback = function (evt) {
+        _super.prototype.onUserMoveCallback.call(this, __assign({ coordinate: (0, proj_1.fromLonLat)(evt.lngLat.toArray()) }, evt));
+    };
+    /**
+     * Render the trajectories using current map's size, resolution and rotation.
+     * @param {boolean} noInterpolate if true, renders the vehicles without interpolating theirs positions.
+     * @overrides
+     */
+    RealtimeLayer.prototype.renderTrajectories = function (noInterpolate) {
+        if (!this.map) {
+            return;
+        }
+        var _a = this.map.getCanvas(), width = _a.width, height = _a.height;
+        var center = this.map.getCenter();
+        // We use turf here to have good transform.
+        var leftBottom = this.map.unproject({
+            x: 0,
+            y: height / this.pixelRatio,
+        }); // southWest
+        var rightTop = this.map.unproject({ x: width / this.pixelRatio, y: 0 }); // north east
+        var coord0 = (0, transform_rotate_1.default)((0, helpers_1.point)([leftBottom.lng, leftBottom.lat]), -this.map.getBearing(), {
+            pivot: [center.lng, center.lat],
+        }).geometry.coordinates;
+        var coord1 = (0, transform_rotate_1.default)((0, helpers_1.point)([rightTop.lng, rightTop.lat]), -this.map.getBearing(), {
+            pivot: [center.lng, center.lat],
+        }).geometry.coordinates;
+        var bounds = __spreadArray(__spreadArray([], (0, proj_1.fromLonLat)(coord0), true), (0, proj_1.fromLonLat)(coord1), true);
+        var xResolution = (0, extent_1.getWidth)(bounds) / (width / this.pixelRatio);
+        var yResolution = (0, extent_1.getHeight)(bounds) / (height / this.pixelRatio);
+        var res = Math.max(xResolution, yResolution);
+        // Coordinate of trajectories are in mercator so we have to pass the proper resolution and center in mercator.
+        var viewState = {
+            size: [width / this.pixelRatio, height / this.pixelRatio],
+            center: (0, proj_1.fromLonLat)([center.lng, center.lat]),
+            extent: bounds,
+            resolution: res,
+            zoom: this.map.getZoom(),
+            rotation: -(this.map.getBearing() * Math.PI) / 180,
+            pixelRatio: this.pixelRatio,
+        };
+        _super.prototype.renderTrajectories.call(this, viewState, noInterpolate);
+    };
+    /**
+     * Return the delay in ms before the next rendering.
+     */
+    RealtimeLayer.prototype.getRefreshTimeInMs = function () {
+        return _super.prototype.getRefreshTimeInMs.call(this, this.map.getZoom());
+    };
+    RealtimeLayer.prototype.getFeatureInfoAtCoordinate = function (coordinate, options) {
+        if (options === void 0) { options = {}; }
+        var resolution = (0, utils_1.getMercatorResolution)(this.map);
+        return _super.prototype.getFeatureInfoAtCoordinate.call(this, coordinate, __assign({ resolution: resolution }, options));
+    };
+    RealtimeLayer.prototype.onVisibilityChange = function () {
+        if (this.visible && !this.map.getLayer(this.key)) {
+            this.map.addLayer(this.layer, this.beforeId);
+        }
+        else if (this.map.getLayer(this.key)) {
+            this.map.removeLayer(this.key);
+        }
+        // We can't use setLayoutProperty it triggers an error probably a bug in mapbox
+        // this.map.setLayoutProperty(
+        //   this.key,
+        //   'visibilty',
+        //   this.visible ? 'visible' : 'none',
+        // );
+    };
+    /**
+     * Remove the trajectory form the list if necessary.
+     *
+     * @private
+     */
+    RealtimeLayer.prototype.purgeTrajectory = function (trajectory, extent, zoom) {
+        return _super.prototype.purgeTrajectory.call(this, trajectory, extent || this.getMercatorExtent(), zoom || Math.floor(this.map.getZoom() + 1));
+    };
+    /**
+     * Send the current bbox to the websocket
+     */
+    RealtimeLayer.prototype.setBbox = function (extent, zoom) {
+        var newExtent = extent;
+        var newZoom = zoom;
+        if (!newExtent && this.isUpdateBboxOnMoveEnd) {
+            newExtent = extent || this.getMercatorExtent();
+            newZoom = Math.floor(this.getOlZoom());
+        }
+        _super.prototype.setBbox.call(this, newExtent, newZoom);
+    };
+    /**
+     * Callback on 'move' event.
+     *
+     * @private
+     */
+    RealtimeLayer.prototype.onMove = function () {
+        this.renderTrajectories();
+    };
+    RealtimeLayer.prototype.renderTrajectoriesInternal = function (viewState, noInterpolate) {
+        var render = _super.prototype.renderTrajectoriesInternal.call(this, viewState, noInterpolate);
+        if (render && this.map.style) {
+            var extent = (0, utils_1.getSourceCoordinates)(this.map, this.pixelRatio);
+            var source = this.map.getSource(this.key);
+            if (source) {
+                source.setCoordinates(extent);
+            }
+        }
+        return render;
+    };
+    /**
+     * Send the new BBOX to the websocket.
+     *
+     * @private
+     * @override
+     */
+    RealtimeLayer.prototype.onMoveEnd = function () {
+        this.renderTrajectories();
+        if (this.visible && this.isUpdateBboxOnMoveEnd) {
+            this.setBbox();
+        }
+    };
+    /**
+     * Update the cursor style when hovering a vehicle.
+     *
+     * @private
+     * @override
+     */
+    RealtimeLayer.prototype.onFeatureHover = function (features, layer, coordinate) {
+        _super.prototype.onFeatureHover.call(this, features, layer, coordinate);
+        this.map.getCanvasContainer().style.cursor = features.length
+            ? 'pointer'
+            : 'auto';
+    };
+    return RealtimeLayer;
+}((0, RealtimeLayerMixin_1.default)(Layer_1.default)));
+exports.default = RealtimeLayer;

package/mapbox/layers/index.d.ts

@@ -0,0 +1,3 @@
+export { default as Layer } from "./Layer";
+export { default as RealtimeLayer } from "./RealtimeLayer";
+//# sourceMappingURL=index.d.ts.map

package/mapbox/layers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/mapbox/layers/index.js"],"names":[],"mappings":""}

package/mapbox/layers/index.js

@@ -1,2 +1,7 @@
-export { default as Layer } from "./Layer";
-export { default as RealtimeLayer } from "./RealtimeLayer";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RealtimeLayer = exports.Layer = void 0;
+var Layer_1 = require("./Layer");
+Object.defineProperty(exports, "Layer", { enumerable: true, get: function () { return Layer_1.default; } });
+var RealtimeLayer_1 = require("./RealtimeLayer");
+Object.defineProperty(exports, "RealtimeLayer", { enumerable: true, get: function () { return RealtimeLayer_1.default; } });

package/mapbox/utils.d.ts

@@ -0,0 +1,8 @@
+export function getMercatorResolution(map: mapboxgl.Map): number;
+export function getSourceCoordinates(map: mapboxgl.Map, pixelRatio: any): any[][];
+declare namespace _default {
+    export { getMercatorResolution };
+    export { getSourceCoordinates };
+}
+export default _default;
+//# sourceMappingURL=utils.d.ts.map

package/mapbox/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/mapbox/utils.js"],"names":[],"mappings":"AAQO,iEASN;AAOM,kFAgBN"}

package/mapbox/utils.js

@@ -1,32 +1,57 @@
-import { getWidth, getHeight } from "ol/extent";
-import { fromLonLat } from "ol/proj";
-export const getMercatorResolution = (map) => {
-  const bounds = map.getBounds().toArray();
-  const a = fromLonLat(bounds[0]);
-  const b = fromLonLat(bounds[1]);
-  const extent = [...a, ...b];
-  const { width, height } = map.getCanvas();
-  const xResolution = getWidth(extent) / width;
-  const yResolution = getHeight(extent) / height;
-  return Math.max(xResolution, yResolution);
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
 };
-export const getSourceCoordinates = (map, pixelRatio) => {
-  const { width, height } = map.getCanvas();
-  const leftTop = map.unproject({ x: 0, y: 0 });
-  const leftBottom = map.unproject({ x: 0, y: height / pixelRatio });
-  const rightBottom = map.unproject({
-    x: width / pixelRatio,
-    y: height / pixelRatio
-  });
-  const rightTop = map.unproject({ x: width / pixelRatio, y: 0 });
-  return [
-    [leftTop.lng, leftTop.lat],
-    [rightTop.lng, rightTop.lat],
-    [rightBottom.lng, rightBottom.lat],
-    [leftBottom.lng, leftBottom.lat]
-  ];
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSourceCoordinates = exports.getMercatorResolution = void 0;
+var extent_1 = require("ol/extent");
+var proj_1 = require("ol/proj");
+/**
+ * Get the current resolution of a Mapbox map.
+ * @param {mapboxgl.Map} map A map object.
+ * @private
+ */
+var getMercatorResolution = function (map) {
+    var bounds = map.getBounds().toArray();
+    var a = (0, proj_1.fromLonLat)(bounds[0]);
+    var b = (0, proj_1.fromLonLat)(bounds[1]);
+    var extent = __spreadArray(__spreadArray([], a, true), b, true);
+    var _a = map.getCanvas(), width = _a.width, height = _a.height;
+    var xResolution = (0, extent_1.getWidth)(extent) / width;
+    var yResolution = (0, extent_1.getHeight)(extent) / height;
+    return Math.max(xResolution, yResolution);
 };
-export default {
-  getMercatorResolution,
-  getSourceCoordinates
+exports.getMercatorResolution = getMercatorResolution;
+/**
+ * Get the canvas source coordinates of the current map's extent.
+ * @param {mapboxgl.Map} map A map object.
+ * @private
+ */
+var getSourceCoordinates = function (map, pixelRatio) {
+    // Requesting getBounds is not enough when we rotate the map, so we request manually each corner.
+    var _a = map.getCanvas(), width = _a.width, height = _a.height;
+    var leftTop = map.unproject({ x: 0, y: 0 });
+    var leftBottom = map.unproject({ x: 0, y: height / pixelRatio }); // southWest
+    var rightBottom = map.unproject({
+        x: width / pixelRatio,
+        y: height / pixelRatio,
+    });
+    var rightTop = map.unproject({ x: width / pixelRatio, y: 0 }); // north east
+    return [
+        [leftTop.lng, leftTop.lat],
+        [rightTop.lng, rightTop.lat],
+        [rightBottom.lng, rightBottom.lat],
+        [leftBottom.lng, leftBottom.lat],
+    ];
+};
+exports.getSourceCoordinates = getSourceCoordinates;
+exports.default = {
+    getMercatorResolution: exports.getMercatorResolution,
+    getSourceCoordinates: exports.getSourceCoordinates,
 };