@map-colonies/react-components 3.7.4 → 3.10.0

package/dist/cesium-map/terrain-providers/custom/dummy-quantized-mesh-tile.d.ts

@@ -0,0 +1,3 @@
+export declare const dummyTile: Uint8Array;
+declare const _default: ArrayBufferLike;
+export default _default;

package/dist/cesium-map/terrain-providers/custom/dummy-quantized-mesh-tile.js

@@ -0,0 +1,245 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dummyTile = void 0;
+/* eslint-disable @typescript-eslint/no-magic-numbers */
+exports.dummyTile = new Uint8Array([
+    172,
+    223,
+    96,
+    7,
+    210,
+    166,
+    80,
+    193,
+    62,
+    133,
+    0,
+    92,
+    97,
+    125,
+    81,
+    193,
+    175,
+    204,
+    114,
+    156,
+    24,
+    171,
+    39,
+    65,
+    215,
+    131,
+    189,
+    193,
+    92,
+    143,
+    98,
+    193,
+    172,
+    223,
+    224,
+    55,
+    148,
+    164,
+    80,
+    193,
+    62,
+    133,
+    128,
+    115,
+    254,
+    122,
+    81,
+    193,
+    175,
+    204,
+    114,
+    40,
+    74,
+    169,
+    39,
+    65,
+    199,
+    225,
+    33,
+    1,
+    165,
+    221,
+    10,
+    65,
+    165,
+    248,
+    77,
+    38,
+    221,
+    233,
+    229,
+    191,
+    118,
+    168,
+    124,
+    106,
+    57,
+    4,
+    231,
+    191,
+    208,
+    126,
+    103,
+    119,
+    149,
+    64,
+    191,
+    63,
+    9,
+    0,
+    0,
+    0,
+    254,
+    127,
+    253,
+    127,
+    254,
+    127,
+    253,
+    127,
+    0,
+    0,
+    254,
+    255,
+    255,
+    127,
+    0,
+    128,
+    0,
+    0,
+    254,
+    127,
+    253,
+    127,
+    0,
+    0,
+    254,
+    127,
+    0,
+    128,
+    0,
+    0,
+    0,
+    0,
+    253,
+    255,
+    254,
+    127,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    8,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    2,
+    0,
+    3,
+    0,
+    0,
+    0,
+    4,
+    0,
+    0,
+    0,
+    2,
+    0,
+    5,
+    0,
+    0,
+    0,
+    0,
+    0,
+    7,
+    0,
+    0,
+    0,
+    0,
+    0,
+    2,
+    0,
+    9,
+    0,
+    7,
+    0,
+    4,
+    0,
+    9,
+    0,
+    1,
+    0,
+    5,
+    0,
+    9,
+    0,
+    3,
+    0,
+    3,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    3,
+    0,
+    3,
+    0,
+    0,
+    0,
+    1,
+    0,
+    7,
+    0,
+    2,
+    0,
+    3,
+    0,
+    0,
+    0,
+    7,
+    0,
+    5,
+    0,
+    8,
+    0,
+    3,
+    0,
+    0,
+    0,
+    4,
+    0,
+    5,
+    0,
+    6,
+    0,
+]);
+exports.default = exports.dummyTile.buffer;

package/dist/cesium-map/terrain-providers/custom/quantized-mesh-decoder.d.ts

@@ -0,0 +1,9 @@
+import { IDecodedTile } from './quantized-mesh-terrain-provider';
+export declare const DECODING_STEPS: {
+    header: number;
+    vertices: number;
+    triangleIndices: number;
+    edgeIndices: number;
+    extensions: number;
+};
+export declare const decode: (data: ArrayBufferLike) => IDecodedTile;

package/dist/cesium-map/terrain-providers/custom/quantized-mesh-decoder.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decode = exports.DECODING_STEPS = void 0;
+var LITTLE_ENDIAN = true;
+var MAX_VERTEX_COUNT = 65536;
+exports.DECODING_STEPS = {
+    header: 0,
+    vertices: 1,
+    triangleIndices: 2,
+    edgeIndices: 3,
+    extensions: 4,
+};
+var QUANTIZED_MESH_HEADER = {
+    centerX: Float64Array.BYTES_PER_ELEMENT,
+    centerY: Float64Array.BYTES_PER_ELEMENT,
+    centerZ: Float64Array.BYTES_PER_ELEMENT,
+    minHeight: Float32Array.BYTES_PER_ELEMENT,
+    maxHeight: Float32Array.BYTES_PER_ELEMENT,
+    boundingSphereCenterX: Float64Array.BYTES_PER_ELEMENT,
+    boundingSphereCenterY: Float64Array.BYTES_PER_ELEMENT,
+    boundingSphereCenterZ: Float64Array.BYTES_PER_ELEMENT,
+    boundingSphereRadius: Float64Array.BYTES_PER_ELEMENT,
+    horizonOcclusionPointX: Float64Array.BYTES_PER_ELEMENT,
+    horizonOcclusionPointY: Float64Array.BYTES_PER_ELEMENT,
+    horizonOcclusionPointZ: Float64Array.BYTES_PER_ELEMENT,
+};
+var decodeZigZag = function (value) {
+    return (value >> 1) ^ -(value & 1);
+};
+var decodeIndex = function (buffer, position, indicesCount, bytesPerIndex, encoded) {
+    var indices;
+    if (bytesPerIndex === 2) {
+        indices = new Uint16Array(buffer, position, indicesCount);
+    }
+    else {
+        indices = new Uint32Array(buffer, position, indicesCount);
+    }
+    if (!encoded) {
+        return indices;
+    }
+    var highest = 0;
+    for (var i = 0; i < indices.length; ++i) {
+        var code = indices[i];
+        indices[i] = highest - code;
+        if (code === 0) {
+            ++highest;
+        }
+    }
+    return indices;
+};
+var convertFromTypedArrayToNumbersArray = function (array) {
+    var numbersArray = [];
+    for (var i = 0; i < array.length; ++i) {
+        numbersArray.push(array[i]);
+    }
+    return numbersArray;
+};
+var decode = function (data) {
+    var maxDecodingStep = exports.DECODING_STEPS.extensions;
+    var view = new DataView(data);
+    var header = {};
+    var position = 0;
+    // Decode Header
+    Object.keys(QUANTIZED_MESH_HEADER).forEach(function (key, bytesCount) {
+        // @ts-ignore
+        // eslint-disable-next-line
+        header[key] =
+            bytesCount === 8
+                ? view.getFloat64(position, LITTLE_ENDIAN)
+                : view.getFloat32(position, LITTLE_ENDIAN);
+        position += bytesCount;
+    });
+    var headerEndPosition = position;
+    // if (maxDecodingStep < DECODING_STEPS.vertices) {
+    //   return { header };
+    // }
+    // Decode Vertex Data
+    position = headerEndPosition;
+    var vertexCount = view.getUint32(position, LITTLE_ENDIAN);
+    var vertexData = new Uint16Array(vertexCount * 3);
+    position += Uint32Array.BYTES_PER_ELEMENT;
+    var bytesPerArrayElement = Uint16Array.BYTES_PER_ELEMENT;
+    var elementArrayLength = vertexCount * bytesPerArrayElement;
+    var uArrayStartPosition = position;
+    var vArrayStartPosition = uArrayStartPosition + elementArrayLength;
+    var heightArrayStartPosition = vArrayStartPosition + elementArrayLength;
+    var u = 0;
+    var v = 0;
+    var height = 0;
+    for (var i = 0; i < vertexCount; i++) {
+        u += decodeZigZag(view.getUint16(uArrayStartPosition + bytesPerArrayElement * i, LITTLE_ENDIAN));
+        v += decodeZigZag(view.getUint16(vArrayStartPosition + bytesPerArrayElement * i, LITTLE_ENDIAN));
+        height += decodeZigZag(view.getUint16(heightArrayStartPosition + bytesPerArrayElement * i, LITTLE_ENDIAN));
+        vertexData[i] = u;
+        vertexData[i + vertexCount] = v;
+        vertexData[i + vertexCount * 2] = height;
+    }
+    position += elementArrayLength * 3;
+    var vertexDataEndPosition = position;
+    // if (maxDecodingStep < DECODING_STEPS.triangleIndices) {
+    //   return { header, vertexData };
+    // }
+    // Decode Triangle Indices
+    position = vertexDataEndPosition;
+    vertexCount = vertexData.length / 3;
+    var bytesPerIndex = vertexCount > MAX_VERTEX_COUNT
+        ? Uint32Array.BYTES_PER_ELEMENT
+        : Uint16Array.BYTES_PER_ELEMENT;
+    if (position % bytesPerIndex !== 0) {
+        position += bytesPerIndex - (position % bytesPerIndex);
+    }
+    var triangleCount = view.getUint32(position, LITTLE_ENDIAN);
+    position += Uint32Array.BYTES_PER_ELEMENT;
+    var triangleIndicesCount = triangleCount * 3;
+    var triangleIndices = decodeIndex(view.buffer, position, triangleIndicesCount, bytesPerIndex, true);
+    position += triangleIndicesCount * bytesPerIndex;
+    var triangleIndicesEndPosition = position;
+    // if (maxDecodingStep < DECODING_STEPS.edgeIndices) {
+    //   return { header, vertexData, triangleIndices };
+    // }
+    // Decode Edge Indices
+    position = triangleIndicesEndPosition;
+    vertexCount = vertexData.length / 3;
+    // bytesPerIndex = vertexCount > MAX_VERTEX_COUNT
+    //   ? Uint32Array.BYTES_PER_ELEMENT
+    //   : Uint16Array.BYTES_PER_ELEMENT;
+    var westVertexCount = view.getUint32(position, LITTLE_ENDIAN);
+    position += Uint32Array.BYTES_PER_ELEMENT;
+    var westIndices = convertFromTypedArrayToNumbersArray(decodeIndex(view.buffer, position, westVertexCount, bytesPerIndex, false));
+    position += westVertexCount * bytesPerIndex;
+    var southVertexCount = view.getUint32(position, LITTLE_ENDIAN);
+    position += Uint32Array.BYTES_PER_ELEMENT;
+    var southIndices = convertFromTypedArrayToNumbersArray(decodeIndex(view.buffer, position, southVertexCount, bytesPerIndex, false));
+    position += southVertexCount * bytesPerIndex;
+    var eastVertexCount = view.getUint32(position, LITTLE_ENDIAN);
+    position += Uint32Array.BYTES_PER_ELEMENT;
+    var eastIndices = convertFromTypedArrayToNumbersArray(decodeIndex(view.buffer, position, eastVertexCount, bytesPerIndex, false));
+    position += eastVertexCount * bytesPerIndex;
+    var northVertexCount = view.getUint32(position, LITTLE_ENDIAN);
+    position += Uint32Array.BYTES_PER_ELEMENT;
+    var northIndices = convertFromTypedArrayToNumbersArray(decodeIndex(view.buffer, position, northVertexCount, bytesPerIndex, false));
+    position += northVertexCount * bytesPerIndex;
+    var edgeIndicesEndPosition = position;
+    if (maxDecodingStep < exports.DECODING_STEPS.extensions) {
+        return {
+            header: header,
+            vertexData: vertexData,
+            triangleIndices: triangleIndices,
+            westIndices: westIndices,
+            northIndices: northIndices,
+            eastIndices: eastIndices,
+            southIndices: southIndices,
+        };
+    }
+    // Decode Extensions
+    var extensions = {};
+    if (view.byteLength > edgeIndicesEndPosition) {
+        position = edgeIndicesEndPosition;
+        while (position < view.byteLength) {
+            var extensionId = view.getUint8(position);
+            position += Uint8Array.BYTES_PER_ELEMENT;
+            var extensionLength = view.getUint32(position, true);
+            position += Uint32Array.BYTES_PER_ELEMENT;
+            var extensionView = new DataView(view.buffer, position, extensionLength);
+            switch (extensionId) {
+                case 1: {
+                    extensions.vertexNormals = new Uint8Array(extensionView.buffer, extensionView.byteOffset, extensionView.byteLength);
+                    break;
+                }
+                case 2: {
+                    extensions.waterMask = extensionView.buffer.slice(extensionView.byteOffset, extensionView.byteOffset + extensionView.byteLength);
+                    break;
+                }
+                case 4: {
+                    var jsonLength = extensionView.getUint32(0, LITTLE_ENDIAN);
+                    var jsonString = '';
+                    for (var i = 0; i < jsonLength; ++i) {
+                        jsonString += String.fromCharCode(extensionView.getUint8(Uint32Array.BYTES_PER_ELEMENT + i));
+                    }
+                    // eslint-disable-next-line
+                    extensions.metadata = JSON.parse(jsonString);
+                    break;
+                }
+                default: {
+                    console.warn("Unknown extension with id " + extensionId);
+                }
+            }
+            position += extensionLength;
+        }
+    }
+    return {
+        header: header,
+        vertexData: vertexData,
+        triangleIndices: triangleIndices,
+        westIndices: westIndices,
+        northIndices: northIndices,
+        eastIndices: eastIndices,
+        southIndices: southIndices,
+        extensions: extensions,
+    };
+};
+exports.decode = decode;

package/dist/cesium-map/terrain-providers/custom/quantized-mesh-terrain-provider.d.ts

@@ -0,0 +1,50 @@
+import { QuantizedMeshTerrainData, TilingScheme } from 'cesium';
+export interface IDecodedTileHeader {
+    centerX: number;
+    centerY: number;
+    centerZ: number;
+    minHeight: number;
+    maxHeight: number;
+    boundingSphereCenterX: number;
+    boundingSphereCenterY: number;
+    boundingSphereCenterZ: number;
+    boundingSphereRadius: number;
+    horizonOcclusionPointX: number;
+    horizonOcclusionPointY: number;
+    horizonOcclusionPointZ: number;
+}
+export interface IExtensions {
+    vertexNormals?: Uint8Array;
+    waterMask?: ArrayBufferLike;
+    metadata?: unknown;
+}
+export interface IDecodedTile {
+    header: IDecodedTileHeader;
+    vertexData: Uint16Array;
+    triangleIndices: Uint16Array | Uint32Array;
+    westIndices: number[];
+    northIndices: number[];
+    eastIndices: number[];
+    southIndices: number[];
+    extensions?: IExtensions;
+}
+export default class QuantizedMeshTerrainProvider {
+    tilingScheme: TilingScheme;
+    ready: boolean;
+    readyPromise: Promise<boolean>;
+    private readonly dummyTile;
+    private readonly getUrl;
+    private readonly credits;
+    constructor(options: {
+        getUrl?: (x: number, y: number, level: number) => string;
+        credit?: string;
+        tilingScheme?: TilingScheme;
+    });
+    requestTileGeometry(x: number, y: number, level: number): Promise<void | QuantizedMeshTerrainData> | undefined;
+    getTileDataAvailable(x: number, y: number, level: number): boolean;
+    getLevelMaximumGeometricError(level: number): number;
+    private generateDummyTileHeader;
+    private createQuantizedMeshData;
+    private generateDummyTile;
+    private decodeResponse;
+}

package/dist/cesium-map/terrain-providers/custom/quantized-mesh-terrain-provider.js

@@ -0,0 +1,136 @@
+"use strict";
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-magic-numbers */
+var cesium_1 = require("cesium");
+var quantized_mesh_decoder_1 = __importDefault(require("@here/quantized-mesh-decoder"));
+var dummy_quantized_mesh_tile_1 = __importDefault(require("./dummy-quantized-mesh-tile"));
+var TILE_IMAGE_WIDTH = 65;
+var QuantizedMeshTerrainProvider /*extends TerrainProvider*/ = /** @class */ (function () {
+    function QuantizedMeshTerrainProvider(options) {
+        var _a;
+        // super();
+        this.ready = false;
+        this.dummyTile = quantized_mesh_decoder_1.default(dummy_quantized_mesh_tile_1.default);
+        this.tilingScheme = (_a = options.tilingScheme) !== null && _a !== void 0 ? _a : new cesium_1.WebMercatorTilingScheme();
+        if (options.getUrl === undefined) {
+            throw new Error('getUrl option is missing');
+        }
+        if (options.credit !== undefined) {
+            this.credits = [new cesium_1.Credit(options.credit)];
+        }
+        this.getUrl = options.getUrl;
+        this.readyPromise = Promise.resolve(true);
+        this.ready = true;
+    }
+    QuantizedMeshTerrainProvider.prototype.requestTileGeometry = function (x, y, level) {
+        var _this = this;
+        var url = this.getUrl(x, y, level);
+        return window
+            .fetch(url)
+            .then(function (res) {
+            if (res.status !== 200) {
+                return _this.generateDummyTile(x, y, level);
+            }
+            return _this.decodeResponse(res, x, y, level);
+        })
+            .then(function (decodedTile) {
+            return _this.createQuantizedMeshData(decodedTile, x, y, level);
+        })
+            .catch(function (err) {
+            console.error(err);
+        });
+    };
+    QuantizedMeshTerrainProvider.prototype.getTileDataAvailable = function (x, y, level) {
+        return true;
+    };
+    QuantizedMeshTerrainProvider.prototype.getLevelMaximumGeometricError = function (level) {
+        var levelZeroMaximumGeometricError = cesium_1.TerrainProvider.getEstimatedLevelZeroGeometricErrorForAHeightmap(this.tilingScheme.ellipsoid, TILE_IMAGE_WIDTH, this.tilingScheme.getNumberOfXTilesAtLevel(0));
+        return levelZeroMaximumGeometricError / (1 << level);
+    };
+    QuantizedMeshTerrainProvider.prototype.generateDummyTileHeader = function (x, y, level) {
+        var tileRect = this.tilingScheme.tileXYToRectangle(x, y, level);
+        var tileNativeRect = this.tilingScheme.tileXYToNativeRectangle(x, y, level);
+        var tileCenter = cesium_1.Cartographic.toCartesian(cesium_1.Rectangle.center(tileRect));
+        var horizonOcclusionPoint = cesium_1.Ellipsoid.WGS84.transformPositionToScaledSpace(tileCenter);
+        return {
+            centerX: tileCenter.x,
+            centerY: tileCenter.y,
+            centerZ: tileCenter.z,
+            minHeight: 0,
+            maxHeight: 0,
+            boundingSphereCenterX: tileCenter.x,
+            boundingSphereCenterY: tileCenter.y,
+            boundingSphereCenterZ: tileCenter.z,
+            boundingSphereRadius: tileNativeRect.height,
+            horizonOcclusionPointX: horizonOcclusionPoint.x,
+            horizonOcclusionPointY: horizonOcclusionPoint.y,
+            horizonOcclusionPointZ: horizonOcclusionPoint.z,
+        };
+    };
+    QuantizedMeshTerrainProvider.prototype.createQuantizedMeshData = function (decodedTile, x, y, level) {
+        var tileRect = this.tilingScheme.tileXYToRectangle(x, y, level);
+        var boundingSphereCenter = new cesium_1.Cartesian3(decodedTile.header.boundingSphereCenterX, decodedTile.header.boundingSphereCenterY, decodedTile.header.boundingSphereCenterZ);
+        var boundingSphere = new cesium_1.BoundingSphere(boundingSphereCenter, decodedTile.header.boundingSphereRadius);
+        var horizonOcclusionPoint = new cesium_1.Cartesian3(decodedTile.header.horizonOcclusionPointX, decodedTile.header.horizonOcclusionPointY, decodedTile.header.horizonOcclusionPointZ);
+        var orientedBoundingBox;
+        if (tileRect.width < cesium_1.Math.PI_OVER_TWO + cesium_1.Math.EPSILON5) {
+            orientedBoundingBox = cesium_1.OrientedBoundingBox.fromRectangle(tileRect, decodedTile.header.minHeight, decodedTile.header.maxHeight);
+        }
+        return new cesium_1.QuantizedMeshTerrainData({
+            minimumHeight: decodedTile.header.minHeight,
+            maximumHeight: decodedTile.header.maxHeight,
+            quantizedVertices: decodedTile.vertexData,
+            indices: decodedTile.triangleIndices,
+            boundingSphere: boundingSphere,
+            orientedBoundingBox: orientedBoundingBox,
+            horizonOcclusionPoint: horizonOcclusionPoint,
+            westIndices: decodedTile.westIndices,
+            southIndices: decodedTile.southIndices,
+            eastIndices: decodedTile.eastIndices,
+            northIndices: decodedTile.northIndices,
+            westSkirtHeight: 100,
+            southSkirtHeight: 100,
+            eastSkirtHeight: 100,
+            northSkirtHeight: 100,
+            childTileMask: 15,
+            credits: this.credits,
+        });
+    };
+    QuantizedMeshTerrainProvider.prototype.generateDummyTile = function (x, y, level) {
+        return __assign(__assign({}, this.dummyTile), this.generateDummyTileHeader(x, y, level));
+    };
+    QuantizedMeshTerrainProvider.prototype.decodeResponse = function (res, x, y, level) {
+        var _this = this;
+        return res
+            .arrayBuffer()
+            .then(function (buffer) {
+            return quantized_mesh_decoder_1.default(buffer);
+        })
+            .catch(function (err) {
+            console.error("Decoding failed on tile " + _this.getUrl(x, y, level));
+            console.error(err);
+            return _this.generateDummyTile(x, y, level);
+        });
+    };
+    return QuantizedMeshTerrainProvider;
+}());
+exports.default = QuantizedMeshTerrainProvider;

package/dist/cesium-map/tools/cesium/primitives-conversions.cesium.d.ts

@@ -1,3 +1,2 @@
 import { Rectangle, Cartesian3 } from 'cesium';
 export declare const rectangleToPositions: (positions: Rectangle) => Cartesian3[];
-//# sourceMappingURL=primitives-conversions.cesium.d.ts.map

package/dist/cesium-map/tools/cesium/primitives-conversions.cesium.js

@@ -1,20 +1,33 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
 var __importStar = (this && this.__importStar) || function (mod) {
     if (mod && mod.__esModule) return mod;
     var result = {};
-    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
-    result["default"] = mod;
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
     return result;
 };
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.rectangleToPositions = void 0;
 var cesium_1 = require("cesium");
 var turf = __importStar(require("@turf/helpers"));
 var bbox_1 = __importDefault(require("@turf/bbox"));
 var bbox_polygon_1 = __importDefault(require("@turf/bbox-polygon"));
-exports.rectangleToPositions = function (positions) {
+var rectangleToPositions = function (positions) {
     var line = turf.lineString([
         [positions.west, positions.south],
         [positions.east, positions.north],
@@ -22,4 +35,4 @@ exports.rectangleToPositions = function (positions) {
     var polygon = bbox_polygon_1.default(bbox_1.default(line));
     return polygon.geometry.coordinates[0].map(function (coord) { return cesium_1.Cartesian3.fromRadiansArray(coord)[0]; });
 };
-//# sourceMappingURL=primitives-conversions.cesium.js.map
+exports.rectangleToPositions = rectangleToPositions;

package/dist/cesium-map/tools/coordinates-tracker.tool.d.ts

@@ -5,4 +5,3 @@ export interface RCoordinatesTrackerToolProps {
     projection?: Proj;
 }
 export declare const CoordinatesTrackerTool: React.FC<RCoordinatesTrackerToolProps>;
-//# sourceMappingURL=coordinates-tracker.tool.d.ts.map