@map-colonies/react-components 3.8.1 → 3.10.2

package/dist/cesium-map/layers/imagery.layer.js

@@ -0,0 +1,64 @@
+"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 __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 (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CesiumImageryLayer = void 0;
+var react_1 = __importStar(require("react"));
+var resium_1 = require("resium");
+var map_1 = require("../map");
+var CesiumImageryLayer = function (props) {
+    // eslint-disable-next-line
+    var meta = props.meta, restProps = __rest(props, ["meta"]);
+    var mapViewer = map_1.useCesiumMap();
+    react_1.useLayoutEffect(function () {
+        var _a;
+        (_a = mapViewer.layersManager) === null || _a === void 0 ? void 0 : _a.addMetaToLayer(meta, function (layer, idx) {
+            if (meta !== undefined) {
+                // eslint-disable-next-line
+                return layer._imageryProvider._resource._url === meta.url;
+            }
+            return false;
+        });
+    }, [meta, mapViewer]);
+    return react_1.default.createElement(resium_1.ImageryLayer, __assign({}, restProps));
+};
+exports.CesiumImageryLayer = CesiumImageryLayer;

package/dist/cesium-map/layers/index.d.ts

@@ -0,0 +1,7 @@
+export * from './3d.tileset';
+export * from './geojson.layer';
+export * from './imagery.layer';
+export * from './wms.layer';
+export * from './wmts.layer';
+export * from './xyz.layer';
+export * from './osm.layer';

package/dist/cesium-map/layers/index.js

@@ -0,0 +1,19 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./3d.tileset"), exports);
+__exportStar(require("./geojson.layer"), exports);
+__exportStar(require("./imagery.layer"), exports);
+__exportStar(require("./wms.layer"), exports);
+__exportStar(require("./wmts.layer"), exports);
+__exportStar(require("./xyz.layer"), exports);
+__exportStar(require("./osm.layer"), exports);

package/dist/cesium-map/layers/osm.layer.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { OpenStreetMapImageryProvider } from 'cesium';
+import { RCesiumImageryLayerProps } from './imagery.layer';
+export interface RCesiumOSMLayerOptions extends OpenStreetMapImageryProvider.ConstructorOptions {
+}
+export interface RCesiumOSMLayerProps extends Partial<RCesiumImageryLayerProps> {
+    options: RCesiumOSMLayerOptions;
+}
+export declare const CesiumOSMLayer: React.FC<RCesiumOSMLayerProps>;

package/dist/cesium-map/layers/osm.layer.js

@@ -0,0 +1,36 @@
+"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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CesiumOSMLayer = void 0;
+var react_1 = __importDefault(require("react"));
+var cesium_1 = require("cesium");
+var imagery_layer_1 = require("./imagery.layer");
+var CesiumOSMLayer = function (props) {
+    var options = props.options, restProps = __rest(props, ["options"]);
+    return (react_1.default.createElement(imagery_layer_1.CesiumImageryLayer, __assign({}, restProps, { imageryProvider: new cesium_1.OpenStreetMapImageryProvider(options) })));
+};
+exports.CesiumOSMLayer = CesiumOSMLayer;

package/dist/cesium-map/layers/wms.layer.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { WebMapServiceImageryProvider } from 'cesium';
+import { RCesiumImageryLayerProps } from './imagery.layer';
+export interface RCesiumWMSLayerOptions extends WebMapServiceImageryProvider.ConstructorOptions {
+}
+export interface RCesiumWMSLayerProps extends Partial<RCesiumImageryLayerProps> {
+    options: RCesiumWMSLayerOptions;
+}
+export declare const CesiumWMSLayer: React.FC<RCesiumWMSLayerProps>;

package/dist/cesium-map/layers/wms.layer.js

@@ -0,0 +1,36 @@
+"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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CesiumWMSLayer = void 0;
+var react_1 = __importDefault(require("react"));
+var cesium_1 = require("cesium");
+var imagery_layer_1 = require("./imagery.layer");
+var CesiumWMSLayer = function (props) {
+    var options = props.options, restProps = __rest(props, ["options"]);
+    return (react_1.default.createElement(imagery_layer_1.CesiumImageryLayer, __assign({}, restProps, { imageryProvider: new cesium_1.WebMapServiceImageryProvider(options) })));
+};
+exports.CesiumWMSLayer = CesiumWMSLayer;

package/dist/cesium-map/layers/wmts.layer.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { WebMapTileServiceImageryProvider } from 'cesium';
+import { RCesiumImageryLayerProps } from './imagery.layer';
+export interface RCesiumWMTSLayerOptions extends WebMapTileServiceImageryProvider.ConstructorOptions {
+}
+export interface RCesiumWMTSLayerProps extends Partial<RCesiumImageryLayerProps> {
+    options: RCesiumWMTSLayerOptions;
+}
+export declare const CesiumWMTSLayer: React.FC<RCesiumWMTSLayerProps>;

package/dist/cesium-map/layers/wmts.layer.js

@@ -0,0 +1,36 @@
+"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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CesiumWMTSLayer = void 0;
+var react_1 = __importDefault(require("react"));
+var cesium_1 = require("cesium");
+var imagery_layer_1 = require("./imagery.layer");
+var CesiumWMTSLayer = function (props) {
+    var options = props.options, restProps = __rest(props, ["options"]);
+    return (react_1.default.createElement(imagery_layer_1.CesiumImageryLayer, __assign({}, restProps, { imageryProvider: new cesium_1.WebMapTileServiceImageryProvider(options) })));
+};
+exports.CesiumWMTSLayer = CesiumWMTSLayer;

package/dist/cesium-map/layers/xyz.layer.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { UrlTemplateImageryProvider } from 'cesium';
+import { RCesiumImageryLayerProps } from './imagery.layer';
+export interface RCesiumXYZLayerOptions extends UrlTemplateImageryProvider.ConstructorOptions {
+}
+export interface RCesiumXYZLayerProps extends Partial<RCesiumImageryLayerProps> {
+    options: UrlTemplateImageryProvider.ConstructorOptions;
+}
+export declare const CesiumXYZLayer: React.FC<RCesiumXYZLayerProps>;

package/dist/cesium-map/layers/xyz.layer.js

@@ -0,0 +1,36 @@
+"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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CesiumXYZLayer = void 0;
+var react_1 = __importDefault(require("react"));
+var cesium_1 = require("cesium");
+var imagery_layer_1 = require("./imagery.layer");
+var CesiumXYZLayer = function (props) {
+    var options = props.options, restProps = __rest(props, ["options"]);
+    return (react_1.default.createElement(imagery_layer_1.CesiumImageryLayer, __assign({}, restProps, { imageryProvider: new cesium_1.UrlTemplateImageryProvider(options) })));
+};
+exports.CesiumXYZLayer = CesiumXYZLayer;

package/dist/cesium-map/layers-manager.d.ts

@@ -0,0 +1,47 @@
+import { ImageryLayer } from 'cesium';
+import { RCesiumOSMLayerOptions, RCesiumWMSLayerOptions, RCesiumWMTSLayerOptions, RCesiumXYZLayerOptions } from './layers';
+import { CesiumViewer } from './map';
+import { IBaseMap } from './settings/settings';
+export interface ICesiumImageryLayer extends InstanceType<typeof ImageryLayer> {
+    meta?: Record<string, unknown>;
+}
+export declare type LayerType = 'OSM_LAYER' | 'WMTS_LAYER' | 'WMS_LAYER' | 'XYZ_LAYER';
+export interface IRasterLayer {
+    id: string;
+    type: LayerType;
+    opacity: number;
+    zIndex: number;
+    show?: boolean;
+    options: RCesiumOSMLayerOptions | RCesiumWMSLayerOptions | RCesiumWMTSLayerOptions | RCesiumXYZLayerOptions;
+    details?: Record<string, unknown>;
+}
+export interface IVectorLayer {
+    id: string;
+    opacity: number;
+    zIndex: number;
+    url: string;
+}
+declare class LayerManager {
+    mapViewer: CesiumViewer;
+    private readonly layers;
+    constructor(mapViewer: CesiumViewer);
+    addMetaToLayer(meta: any, layerPredicate: (layer: ImageryLayer, idx: number) => boolean): void;
+    setBaseMapLayers(baseMap: IBaseMap): void;
+    addRasterLayer(layer: IRasterLayer, index: number, parentId: string): void;
+    removeLayer(layerId: string): void;
+    removeBaseMapLayers(): void;
+    removeNotBaseMapLayers(): void;
+    raise(layerId: string, positions?: number): void;
+    lower(layerId: string, positions?: number): void;
+    raiseToTop(layerId: string): void;
+    lowerToBottom(layerId: string): void;
+    length(): number;
+    show(layerId: string, isShow: boolean): void;
+    showAllNotBase(isShow: boolean): void;
+    get(layerId: string): ICesiumImageryLayer | undefined;
+    findLayerByPOI(x: number, y: number): ICesiumImageryLayer[] | undefined;
+    private getBaseLayersCount;
+    private findLayerById;
+    private updateLayersOrder;
+}
+export default LayerManager;

package/dist/cesium-map/layers-manager.js

@@ -0,0 +1,228 @@
+"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-unsafe-member-access */
+var cesium_1 = require("cesium");
+var lodash_1 = require("lodash");
+var boolean_point_in_polygon_1 = __importDefault(require("@turf/boolean-point-in-polygon"));
+var point_geojson_1 = require("./tools/geojson/point.geojson");
+var INC = 1;
+var DEC = -1;
+var LayerManager = /** @class */ (function () {
+    function LayerManager(mapViewer) {
+        this.mapViewer = mapViewer;
+        // eslint-disable-next-line
+        this.layers = this.mapViewer.imageryLayers._layers;
+    }
+    /* eslint-disable */
+    LayerManager.prototype.addMetaToLayer = function (meta, layerPredicate) {
+        var layer = this.layers.find(layerPredicate);
+        if (layer) {
+            layer.meta = meta;
+        }
+    };
+    /* eslint-enable */
+    LayerManager.prototype.setBaseMapLayers = function (baseMap) {
+        var _this = this;
+        var sortedBaseMapLayers = baseMap.baseRasteLayers.sort(function (layer1, layer2) { return layer1.zIndex - layer2.zIndex; });
+        sortedBaseMapLayers.forEach(function (layer, idx) {
+            _this.addRasterLayer(layer, idx, baseMap.id);
+        });
+    };
+    LayerManager.prototype.addRasterLayer = function (layer, index, parentId) {
+        var cesiumLayer;
+        switch (layer.type) {
+            case 'XYZ_LAYER':
+                cesiumLayer = this.mapViewer.imageryLayers.addImageryProvider(new cesium_1.UrlTemplateImageryProvider(layer.options), index);
+                break;
+            case 'WMS_LAYER':
+                cesiumLayer = this.mapViewer.imageryLayers.addImageryProvider(new cesium_1.WebMapServiceImageryProvider(layer.options), index);
+                break;
+            case 'WMTS_LAYER':
+                cesiumLayer = this.mapViewer.imageryLayers.addImageryProvider(new cesium_1.WebMapTileServiceImageryProvider(layer.options), index);
+                break;
+            case 'OSM_LAYER':
+                break;
+        }
+        if (cesiumLayer) {
+            cesiumLayer.alpha = layer.opacity;
+            cesiumLayer.meta = __assign({ parentBasetMapId: parentId }, layer);
+            if (layer.show !== undefined) {
+                cesiumLayer.show = layer.show;
+            }
+        }
+    };
+    LayerManager.prototype.removeLayer = function (layerId) {
+        var layer = this.findLayerById(layerId);
+        if (layer) {
+            this.mapViewer.imageryLayers.remove(layer, true);
+        }
+    };
+    LayerManager.prototype.removeBaseMapLayers = function () {
+        var _this = this;
+        var layerToDelete = this.layers.filter(function (layer) {
+            var parentId = lodash_1.get(layer.meta, 'parentBasetMapId');
+            return parentId ? true : false;
+        });
+        layerToDelete.forEach(function (layer) {
+            _this.mapViewer.imageryLayers.remove(layer, true);
+        });
+        // TODO: remove vector layers
+    };
+    // Remove all non base layers
+    LayerManager.prototype.removeNotBaseMapLayers = function () {
+        var _this = this;
+        var layerToDelete = this.layers.filter(function (layer) {
+            var parentId = lodash_1.get(layer.meta, 'parentBasetMapId');
+            return parentId ? false : true;
+        });
+        layerToDelete.forEach(function (layer) {
+            _this.mapViewer.imageryLayers.remove(layer, true);
+        });
+        // TODO: remove vector layers
+    };
+    LayerManager.prototype.raise = function (layerId, positions) {
+        if (positions === void 0) { positions = 1; }
+        var layer = this.findLayerById(layerId);
+        var order = (layer === null || layer === void 0 ? void 0 : layer.meta).zIndex;
+        if (layer) {
+            for (var position = 0; position < positions; position++) {
+                this.mapViewer.imageryLayers.raise(layer);
+            }
+        }
+        this.updateLayersOrder(layerId, order, order + positions);
+    };
+    LayerManager.prototype.lower = function (layerId, positions) {
+        if (positions === void 0) { positions = 1; }
+        var layer = this.findLayerById(layerId);
+        var order = (layer === null || layer === void 0 ? void 0 : layer.meta).zIndex;
+        var lowerLimit = this.getBaseLayersCount();
+        var layerIdx = this.mapViewer.imageryLayers.indexOf(layer);
+        if (layerIdx - positions <= lowerLimit) {
+            positions = layerIdx - lowerLimit;
+        }
+        if (layer) {
+            for (var position = 0; position < positions; position++) {
+                this.mapViewer.imageryLayers.lower(layer);
+            }
+        }
+        this.updateLayersOrder(layerId, order, order - positions);
+    };
+    LayerManager.prototype.raiseToTop = function (layerId) {
+        var layer = this.findLayerById(layerId);
+        var order = (layer === null || layer === void 0 ? void 0 : layer.meta).zIndex;
+        if (layer) {
+            this.mapViewer.imageryLayers.raiseToTop(layer);
+        }
+        this.updateLayersOrder(layerId, order, this.mapViewer.imageryLayers.length - this.getBaseLayersCount() - 1);
+    };
+    LayerManager.prototype.lowerToBottom = function (layerId) {
+        var layer = this.findLayerById(layerId);
+        // const order = (layer?.meta as Record<string, unknown>).zIndex as number;
+        var lowerLimit = this.getBaseLayersCount();
+        var layerIdx = this.mapViewer.imageryLayers.indexOf(layer);
+        this.lower(layerId, layerIdx - lowerLimit);
+        // if (layer) {
+        //   this.mapViewer.imageryLayers.lowerToBottom(layer);
+        // }
+        // this.updateLayersOrder(layerId, order, 0);
+    };
+    LayerManager.prototype.length = function () {
+        return this.mapViewer.imageryLayers.length;
+    };
+    LayerManager.prototype.show = function (layerId, isShow) {
+        var layer = this.get(layerId);
+        if (layer !== undefined) {
+            layer.show = isShow;
+        }
+    };
+    LayerManager.prototype.showAllNotBase = function (isShow) {
+        var _this = this;
+        var nonBaseLayers = this.layers.filter(function (layer) {
+            var parentId = lodash_1.get(layer.meta, 'parentBasetMapId');
+            return parentId ? false : true;
+        });
+        nonBaseLayers.forEach(function (layer) {
+            var _a;
+            _this.show((_a = layer.meta) === null || _a === void 0 ? void 0 : _a.id, isShow);
+        });
+    };
+    LayerManager.prototype.get = function (layerId) {
+        var layerInt = this.findLayerById(layerId);
+        var layerIdx = this.mapViewer.imageryLayers.indexOf(layerInt);
+        return layerIdx ? this.mapViewer.imageryLayers.get(layerIdx) : undefined;
+    };
+    LayerManager.prototype.findLayerByPOI = function (x, y) {
+        var position = point_geojson_1.pointToGeoJSON(this.mapViewer, x, y);
+        var nonBaseLayers = this.layers.filter(function (layer) {
+            var parentId = lodash_1.get(layer.meta, 'parentBasetMapId');
+            return parentId ? false : true;
+        });
+        var selectedVisibleLayers = nonBaseLayers.filter(function (layer) {
+            var layerFootprint = lodash_1.get(layer.meta, 'details.footprint');
+            if (layerFootprint !== undefined) {
+                var isInLayer = boolean_point_in_polygon_1.default(position.geometry, {
+                    type: 'Feature',
+                    properties: {},
+                    geometry: layerFootprint,
+                });
+                return isInLayer && layer.show;
+            }
+            else {
+                console.warn('CesiumImageryLayer has no defined footprint', layer.meta);
+                return false;
+            }
+        });
+        return selectedVisibleLayers.sort(function (layer1, layer2) {
+            var _a, _b;
+            // @ts-ignore
+            return ((_a = layer2.meta) === null || _a === void 0 ? void 0 : _a.zIndex) - ((_b = layer1.meta) === null || _b === void 0 ? void 0 : _b.zIndex);
+        });
+    };
+    LayerManager.prototype.getBaseLayersCount = function () {
+        var baseLayers = this.layers.filter(function (layer) {
+            var parentId = lodash_1.get(layer.meta, 'parentBasetMapId');
+            return parentId ? true : false;
+        });
+        return baseLayers.length;
+    };
+    LayerManager.prototype.findLayerById = function (layerId) {
+        return this.layers.find(function (layer) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            return layer.meta !== undefined ? layer.meta.id === layerId : false;
+        });
+    };
+    LayerManager.prototype.updateLayersOrder = function (id, from, to) {
+        var move = from > to ? INC : DEC;
+        var min = from < to ? from : to;
+        var max = from < to ? to : from;
+        this.layers.forEach(function (layer) {
+            var _a;
+            var parentId = lodash_1.get(layer.meta, 'parentBasetMapId');
+            if (!parentId) {
+                var layerOrder = (_a = layer.meta) === null || _a === void 0 ? void 0 : _a.zIndex;
+                layer.meta.zIndex =
+                    layerOrder >= min && layerOrder <= max && layerOrder !== from
+                        ? layerOrder + move
+                        : layerOrder === from
+                            ? to
+                            : layerOrder;
+            }
+        });
+    };
+    return LayerManager;
+}());
+exports.default = LayerManager;

package/dist/cesium-map/map.css

@@ -0,0 +1,54 @@
+.cesium-widget-credits {
+  display: none !important;
+}
+
+.cesium-viewer-fullscreenContainer {
+  bottom: 8px;
+  right: 8px;
+  left: unset;
+}
+
+body[dir='rtl'] .cesium-viewer-fullscreenContainer {
+  left: 8px;
+  right: unset;
+}
+
+body[dir='rtl'] .cesium-viewer-toolbar {
+  left: 5px;
+  right: unset;
+}
+
+.cesium-button.cesium-fullscreenButton {
+  border-radius: 14%;
+}
+
+.toolsContainer {
+  color: var(--mdc-theme-on-surface);
+  display: flex;
+  gap: 8px;
+  z-index: 2000;
+  position: absolute;
+  bottom: 12px;
+  right: 40px;
+  opacity: 0.7;
+}
+
+body[dir='rtl'] .toolsContainer {
+  left: 40px;
+  right: unset;
+}
+
+.sideToolsContainer {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  z-index: 2000;
+  position: absolute;
+  top: 12px;
+  right: 40px;
+}
+
+body[dir='rtl'] .sideToolsContainer {
+  left: 40px;
+  right: unset;
+}

package/dist/cesium-map/map.d.ts

@@ -0,0 +1,46 @@
+import React from 'react';
+import { ViewerProps } from 'resium/dist/types/src/Viewer/Viewer';
+import { Viewer as CesiumViewerCls, TerrainProvider } from 'cesium';
+import { Proj } from '../utils/projections';
+import { IBaseMaps } from './settings/settings';
+import LayerManager from './layers-manager';
+import { CesiumSceneModeEnum } from './map.types';
+import './map.css';
+export declare class CesiumViewer extends CesiumViewerCls {
+    layersManager?: LayerManager;
+    constructor(container: string | Element, options?: CesiumViewerCls.ConstructorOptions);
+}
+export interface IContextMenuData {
+    data: Record<string, unknown>[];
+    position: {
+        x: number;
+        y: number;
+    };
+    style?: Record<string, string>;
+    size?: {
+        height: number;
+        width: number;
+    };
+    handleClose: () => void;
+}
+export interface CesiumMapProps extends ViewerProps {
+    showMousePosition?: boolean;
+    showScale?: boolean;
+    projection?: Proj;
+    center?: [number, number];
+    zoom?: number;
+    locale?: {
+        [key: string]: string;
+    };
+    sceneModes?: CesiumSceneModeEnum[];
+    baseMaps?: IBaseMaps;
+    terrainProvider?: TerrainProvider;
+    imageryContextMenu?: React.ReactElement<IContextMenuData>;
+    imageryContextMenuSize?: {
+        height: number;
+        width: number;
+        dynamicHeightIncrement?: number;
+    };
+}
+export declare const useCesiumMap: () => CesiumViewer;
+export declare const CesiumMap: React.FC<CesiumMapProps>;