@evergis/react 3.1.3 → 3.1.5

package/dist/react.cjs.development.js

@@ -6,19 +6,16 @@ function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'defau
 
 var React = require('react');
 var React__default = _interopDefault(React);
-var styled = require('styled-components');
-var styled__default = _interopDefault(styled);
 var MapGL = require('react-map-gl/mapbox');
 var MapGL__default = _interopDefault(MapGL);
-require('@mapbox/mapbox-gl-draw/dist/mapbox-gl-draw.css');
-var findAnd = require('find-and');
+var api = require('@evergis/api');
 var lodash = require('lodash');
-var dateFns = require('date-fns');
-var wkt = require('wkt');
-var MapboxDraw = _interopDefault(require('@mapbox/mapbox-gl-draw'));
 var turf = require('@turf/turf');
-var api = require('@evergis/api');
+require('@mapbox/mapbox-gl-draw/dist/mapbox-gl-draw.css');
+var styled = _interopDefault(require('styled-components'));
+var MapboxDraw = _interopDefault(require('@mapbox/mapbox-gl-draw'));
 var signalr = require('@microsoft/signalr');
+var dateFns = require('date-fns');
 require('mapbox-gl/dist/mapbox-gl.css');
 
 function _classCallCheck(instance, Constructor) {
@@ -132,9 +129,6 @@ function _taggedTemplateLiteralLoose(strings, raw) {
   return strings;
 }
 
-var _templateObject;
-const ErrorBoundaryContainer = /*#__PURE__*/styled__default.div(_templateObject || (_templateObject = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  display: flex;\n  align-items: center;\n  justify-content: center;\n  height: 100vh;\n"])));
-
 function _callSuper(_this, derived, args) {
   function isNativeReflectConstruct() {
     if (typeof Reflect === "undefined" || !Reflect.construct) return false;
@@ -182,7 +176,7 @@ let ErrorBoundary = /*#__PURE__*/function (_Component) {
       const {
         hasError
       } = this.state;
-      return !hasError ? React__default.createElement(React__default.Fragment, null, children) : React__default.createElement(ErrorBoundaryContainer, null, errorContents);
+      return !hasError ? React__default.createElement(React__default.Fragment, null, children) : React__default.createElement(React__default.Fragment, null, errorContents);
     }
   }], [{
     key: "getDerivedStateFromError",
@@ -194,424 +188,346 @@ let ErrorBoundary = /*#__PURE__*/function (_Component) {
   }]);
 }(React.Component);
 
-var _templateObject$1;
-const MapWrapper = /*#__PURE__*/styled__default.div(_templateObject$1 || (_templateObject$1 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  position: relative;\n  width: 100%;\n  height: 100%;\n  box-sizing: border-box;\n  z-index: ", ";\n\n  .mapbox-gl-draw_trash {\n    display: none;\n  }\n\n  .mapboxgl-ctrl-logo {\n    display: none;\n  }\n\n  .mapboxgl-ctrl.mapboxgl-ctrl-attrib {\n    display: none;\n  }\n\n  .mapboxgl-ctrl-geocoder.mapboxgl-ctrl {\n    width: 350px;\n  }\n"])), (_ref) => {
-  let {
-    $zIndex
-  } = _ref;
-  return $zIndex != null ? $zIndex : 1;
-});
-
-const useMapContext = () => {
-  return React.useContext(MapContext);
-};
-
-const useCurrentSelectedFeature = () => {
-  const {
-    selectFeatures
-  } = useMapContext();
-  return React.useMemo(() => {
-    var _selectFeatures$featu;
-
-    return (_selectFeatures$featu = selectFeatures.features) == null || (_selectFeatures$featu = _selectFeatures$featu[selectFeatures.layerName]) == null ? void 0 : _selectFeatures$featu.find(item => item.id === selectFeatures.currentId);
-  }, [selectFeatures]);
+const DEFAULT_COLOR = "#00ffff";
+const DEFAULT_OPACITY = 0.5;
+const DEFAULT_SIZE = 4;
+const DEFAULT_LINE_WIDTH = 1;
+const DEFAULT_CIRCLE_PAINT = {
+  "circle-radius": DEFAULT_SIZE,
+  "circle-color": DEFAULT_COLOR,
+  "circle-opacity": DEFAULT_OPACITY,
+  "circle-stroke-width": 0,
+  "circle-stroke-color": DEFAULT_COLOR,
+  "circle-stroke-opacity": DEFAULT_OPACITY
 };
-
-const MapContext = /*#__PURE__*/React.createContext({});
-
-(function (BaseMapTheme) {
-  BaseMapTheme["Light"] = "light";
-  BaseMapTheme["Dark"] = "dark";
-})(exports.BaseMapTheme || (exports.BaseMapTheme = {}));
-
-(function (GeometrySelectionTypes) {
-  GeometrySelectionTypes["Point"] = "select_point";
-  GeometrySelectionTypes["Line"] = "select_line";
-  GeometrySelectionTypes["Circle"] = "select_circle";
-  GeometrySelectionTypes["Rect"] = "select_rect";
-  GeometrySelectionTypes["Polygon"] = "select_polygon";
-  GeometrySelectionTypes["Zones"] = "zones_selection";
-  GeometrySelectionTypes["Coordinates"] = "xy";
-  GeometrySelectionTypes["Route"] = "selection_route";
-})(exports.GeometrySelectionTypes || (exports.GeometrySelectionTypes = {}));
-
-(function (GeometrySelectionToolTypes) {
-  GeometrySelectionToolTypes["Replace"] = "Replace";
-  GeometrySelectionToolTypes["Unite"] = "Unite";
-  GeometrySelectionToolTypes["Crop"] = "Crop";
-  GeometrySelectionToolTypes["Edit"] = "Edit";
-})(exports.GeometrySelectionToolTypes || (exports.GeometrySelectionToolTypes = {}));
-
-(function (GeometrySelectionZoneTypes) {
-  GeometrySelectionZoneTypes["Walking"] = "Walking";
-  GeometrySelectionZoneTypes["Car"] = "Car";
-})(exports.GeometrySelectionZoneTypes || (exports.GeometrySelectionZoneTypes = {}));
-
-(function (GeometrySelectionRouteTypes) {
-  GeometrySelectionRouteTypes["Walking"] = "Walking";
-  GeometrySelectionRouteTypes["Car"] = "Car";
-})(exports.GeometrySelectionRouteTypes || (exports.GeometrySelectionRouteTypes = {}));
-
-(function (GeometryEditorMode) {
-  GeometryEditorMode[GeometryEditorMode["Create"] = 0] = "Create";
-  GeometryEditorMode[GeometryEditorMode["Edit"] = 1] = "Edit";
-  GeometryEditorMode[GeometryEditorMode["Transform"] = 2] = "Transform";
-  GeometryEditorMode[GeometryEditorMode["Expand"] = 3] = "Expand";
-  GeometryEditorMode[GeometryEditorMode["Unite"] = 4] = "Unite";
-  GeometryEditorMode[GeometryEditorMode["Subtract"] = 5] = "Subtract";
-})(exports.GeometryEditorMode || (exports.GeometryEditorMode = {}));
-
-const initialGeometrySelection = {
-  active: true,
-  loading: false,
-  type: exports.GeometrySelectionTypes.Point,
-  currentTool: exports.GeometrySelectionToolTypes.Replace,
-  history: {
-    features: [],
-    zones: [],
-    step: -1
-  },
-  editHistory: {
-    features: [],
-    step: -1
-  },
-  isBuffer: false,
-  settings: {
-    zoneDuration: 60,
-    zoneType: exports.GeometrySelectionZoneTypes.Walking,
-    routeType: exports.GeometrySelectionRouteTypes.Walking,
-    bufferRadius: "",
-    bufferMultiplier: "1",
-    bufferInclude: true,
-    selectOutside: false
-  }
+const DEFAULT_FILL_PAINT = {
+  "fill-color": DEFAULT_COLOR,
+  "fill-opacity": DEFAULT_OPACITY
 };
-const initialGeometryEditor = {
-  active: false
+const DEFAULT_FILL_EXTRUSION_PAINT = {
+  "fill-extrusion-base": 0,
+  "fill-extrusion-vertical-gradient": true,
+  "fill-extrusion-color": DEFAULT_COLOR,
+  "fill-extrusion-opacity": DEFAULT_OPACITY,
+  "fill-extrusion-height": 0
 };
-const initialSelectFeatures = {
-  initialized: false,
-  layerName: undefined,
-  currentId: null,
-  selectionOffset: 0,
-  features: {},
-  totalCounts: {},
-  statisticsActive: false,
-  geometryMasking: false
+const DEFAULT_LINE_PAINT = {
+  "line-color": DEFAULT_COLOR,
+  "line-width": DEFAULT_LINE_WIDTH,
+  "line-opacity": DEFAULT_OPACITY
 };
-const MapProvider = (_ref) => {
+
+const RasterLayer = (_ref) => {
   let {
-    basemapItems,
-    defaultBasemap,
-    children
+    layer,
+    tileUrl,
+    visible,
+    beforeId
   } = _ref;
-  const map = React.useRef();
-  const draw = React.useRef();
-  const [loaded, setLoaded] = React.useState(false);
-  const [basemapName, setBasemapName] = React.useState(defaultBasemap);
-  const [globeProjection, setGlobeProjection] = React.useState(false);
-  const [geometrySelection, setGeometrySelection] = React.useState(initialGeometrySelection);
-  const [geometryEditor, setGeometryEditor] = React.useState(initialGeometryEditor);
-  const [selectFeatures, setSelectFeatures] = React.useState(initialSelectFeatures);
-  const resetGeometrySelection = React.useCallback(() => {
-    setGeometrySelection(initialGeometrySelection);
-  }, []);
-  const resetGeometryEditor = React.useCallback(() => {
-    setGeometryEditor(initialGeometryEditor);
-  }, []);
-  const setNextFeature = React.useCallback(() => {
-    setSelectFeatures(state => {
-      var _features$layerName, _features$layerName2, _features$layerName3;
-
-      const {
-        layerName,
-        features,
-        currentId
-      } = state;
-      const currentIndex = features == null || (_features$layerName = features[layerName]) == null ? void 0 : _features$layerName.findIndex(item => item.id === currentId);
-
-      if (currentIndex === (features == null || (_features$layerName2 = features[layerName]) == null ? void 0 : _features$layerName2.length) - 1) {
-        return state;
-      }
-
-      const nextId = features == null || (_features$layerName3 = features[layerName]) == null || (_features$layerName3 = _features$layerName3[currentIndex + 1]) == null ? void 0 : _features$layerName3.id;
-      return _extends({}, state, {
-        currentId: nextId
-      });
-    });
-  }, []);
-  const setPrevFeature = React.useCallback(() => {
-    setSelectFeatures(state => {
-      var _features$layerName4, _features$layerName5;
 
-      const {
-        layerName,
-        features,
-        currentId
-      } = state;
-      const currentIndex = features == null || (_features$layerName4 = features[layerName]) == null ? void 0 : _features$layerName4.findIndex(item => item.id === currentId);
-
-      if (currentIndex === 0) {
-        return state;
-      }
+  if (!layer) {
+    return null;
+  }
 
-      const prevId = features == null || (_features$layerName5 = features[layerName]) == null || (_features$layerName5 = _features$layerName5[currentIndex - 1]) == null ? void 0 : _features$layerName5.id;
-      return _extends({}, state, {
-        currentId: prevId
-      });
-    });
-  }, []);
-  const setSelectedFeatures = React.useCallback((payload, currentId, offset) => {
-    setSelectFeatures(state => {
-      var _features$firstNotNul;
-
-      const features = payload != null ? payload : {};
-      const firstNotNullLayerName = Object.keys(features).find(key => features[key].length > 0);
-      const featureIdsToSelect = (_features$firstNotNul = features[firstNotNullLayerName]) == null ? void 0 : _features$firstNotNul.map((_ref2) => {
-        let {
-          id
-        } = _ref2;
-        return id;
-      });
-      return _extends({}, state, {
-        features,
-        layerName: firstNotNullLayerName,
-        currentId: currentId != null ? currentId : featureIdsToSelect == null ? void 0 : featureIdsToSelect[0],
-        selectionOffset: offset
-      });
-    });
-  }, []);
-  const setSelectedFeaturesTotalCounts = React.useCallback(payload => {
-    setSelectFeatures(state => _extends({}, state, {
-      totalCounts: payload
-    }));
-  }, []);
-  const setSelectFeaturesInitialized = React.useCallback(payload => {
-    setSelectFeatures(state => _extends({}, state, {
-      initialized: payload
-    }));
-  }, []);
-  const setSelectFeaturesLayerName = React.useCallback(payload => {
-    setSelectFeatures(state => {
-      var _state$features;
-
-      return _extends({}, state, {
-        layerName: payload,
-        currentId: (_state$features = state.features) == null || (_state$features = _state$features[payload]) == null || (_state$features = _state$features[0]) == null ? void 0 : _state$features.id,
-        selectionOffset: 0
-      });
-    });
-  }, []);
-  const setSelectFeaturesStatisticsActive = React.useCallback(payload => {
-    setSelectFeatures(state => _extends({}, state, {
-      statisticsActive: payload
-    }));
-  }, []);
-  const setSelectFeaturesGeometryMasking = React.useCallback(payload => {
-    setSelectFeatures(state => _extends({}, state, {
-      geometryMasking: payload
-    }));
-  }, []);
-  const updateCurrentFeature = React.useCallback(payload => {
-    setSelectFeatures(state => {
-      var _state$features$state, _state$features2;
-
-      return _extends({}, state, {
-        features: _extends({}, state.features, {
-          [state.layerName]: findAnd.changeProps((_state$features$state = (_state$features2 = state.features) == null ? void 0 : _state$features2[state.layerName]) != null ? _state$features$state : [], {
-            id: state.currentId
-          }, payload)
-        })
-      });
-    });
-  }, []);
-  const resetSelectedFeatures = React.useCallback(() => {
-    setSelectFeatures(initialSelectFeatures);
-  }, []);
-  return React__default.createElement(MapContext.Provider, {
-    value: {
-      map,
-      draw,
-      loaded,
-      setLoaded,
-      basemapItems,
-      basemapName,
-      setBasemapName,
-      defaultBasemap,
-      globeProjection,
-      setGlobeProjection,
-      geometrySelection,
-      setGeometrySelection,
-      resetGeometrySelection,
-      geometryEditor,
-      setGeometryEditor,
-      resetGeometryEditor,
-      selectFeatures,
-      setNextFeature,
-      setPrevFeature,
-      setSelectedFeatures,
-      setSelectedFeaturesTotalCounts,
-      setSelectFeaturesInitialized,
-      setSelectFeaturesLayerName,
-      setSelectFeaturesStatisticsActive,
-      setSelectFeaturesGeometryMasking,
-      updateCurrentFeature,
-      resetSelectedFeatures
+  return React__default.createElement(MapGL.Source, {
+    id: layer.name,
+    type: "raster",
+    tiles: [tileUrl]
+  }, React__default.createElement(MapGL.Layer, {
+    id: layer.name,
+    type: "raster",
+    "source-layer": "default",
+    beforeId: beforeId,
+    layout: {
+      visibility: visible ? "visible" : "none"
     }
-  }, children);
-};
-
-const useGeometryEditor = () => {
-  const {
-    geometryEditor,
-    setGeometryEditor
-  } = useMapContext();
-  const update = React.useCallback(newState => {
-    setGeometryEditor(prevState => _extends({}, prevState, newState));
-  }, [setGeometryEditor]);
-  return [geometryEditor, update];
-};
-
-const useEditingFeature = () => {
-  const [{
-    layerName,
-    active,
-    mode
-  }] = useGeometryEditor();
-  const currentSelectedFeature = useCurrentSelectedFeature();
-  return React.useMemo(() => {
-    return active && (mode === exports.GeometryEditorMode.Edit && layerName === (currentSelectedFeature == null ? void 0 : currentSelectedFeature.layer) || mode === exports.GeometryEditorMode.Create);
-  }, [active, currentSelectedFeature, layerName, mode]);
-};
-
-const useGeometrySelection = () => {
-  const {
-    geometrySelection,
-    setGeometrySelection
-  } = useMapContext();
-  const updateGeometrySelection = React.useCallback(newState => {
-    setGeometrySelection(prevState => _extends({}, prevState, newState));
-  }, [setGeometrySelection]);
-  return [geometrySelection, updateGeometrySelection];
+  }));
 };
 
-const NO_CONTENT_VALUE = "—";
+const getClientStyleItemPrefixSuffix = (geometryType, type) => {
+  switch (geometryType) {
+    case api.GeometryType.Point:
+      return ["point-layer-", ""];
 
-(function (DateFormat) {
-  DateFormat["ClientDefaultFormat"] = "dd.MM.yyyy HH:mm";
-  DateFormat["DateTime"] = "dd.MM.yyyy HH:mm:ss";
-  DateFormat["UTC"] = "yyyy-MM-dd'T'HH:mm:ss.sssxxx";
-  DateFormat["AxisTooltip"] = "d MMMM yyyy";
-})(exports.DateFormat || (exports.DateFormat = {}));
+    case api.GeometryType.Polyline:
+      return ["polyline-layer-", ""];
 
-const stringDateParsers = [dateFns.parseJSON, dateFns.parseISO, rawDate => new Date(rawDate)];
-const getDate = rawDate => {
-  if (!rawDate) return null;
+    case api.GeometryType.Polygon:
+      switch (type) {
+        case "line":
+          return ["polygon-stroke-layer-", "-stroke"];
 
-  if (typeof rawDate === "string") {
-    for (const parser of stringDateParsers) {
-      const date = parser(rawDate);
+        case "fill-extrusion":
+          return ["polygon-extrusion-layer-", "-extrusion"];
 
-      if (dateFns.isValid(date)) {
-        return dateFns.toDate(date);
+        default:
+          return ["polygon-layer-", ""];
       }
-    }
 
-    return null;
+    default:
+      return ["", ""];
   }
-
-  const parsedDate = dateFns.toDate(rawDate);
-  return dateFns.isValid(parsedDate) ? parsedDate : null;
 };
-const formatDate = function formatDate(date, _temp) {
-  let {
-    dateFormat = exports.DateFormat.ClientDefaultFormat,
-    defaultValue = NO_CONTENT_VALUE
-  } = _temp === void 0 ? {} : _temp;
-  const dateValue = date ? getDate(date) : null;
 
-  if (dateFns.isValid(dateValue)) {
-    return dateFns.format(dateValue, dateFormat);
+const findAttributeInExpression = expression => {
+  if (Array.isArray(expression) && expression.length === 2 && expression[0] === "get") {
+    return [expression[1]];
   }
 
-  return defaultValue.toString();
-};
+  return expression.reduce((acc, curr) => {
+    if (!Array.isArray(curr)) {
+      return acc;
+    }
 
-const geometryToWkt = function geometryToWkt(features) {
-  if (features === void 0) {
-    features = [];
-  }
+    if (curr[0] === "get") {
+      return [...new Set([...acc, curr[1]])];
+    }
 
-  if (features.length === 0) {
-    return "";
-  }
+    return [...new Set([...acc, ...findAttributeInExpression(curr)])];
+  }, []);
+};
 
-  return wkt.stringify(features[0]);
+const getActualExtrusionHeight = paint => {
+  return Array.isArray(paint == null ? void 0 : paint["fill-extrusion-height"]) && (paint == null ? void 0 : paint["fill-extrusion-height"][0]) === "+" ? paint == null ? void 0 : paint["fill-extrusion-height"][1] : paint == null ? void 0 : paint["fill-extrusion-height"];
 };
 
-const isNumeric = number => !isNaN(parseFloat(number)) && isFinite(number);
+const parseClientStyle = style => {
+  var _style$items;
 
-function isObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
+  if (!style) {
+    return [];
+  }
 
-const useEwktGeometry = () => {
-  const [{
-    history,
-    type
-  }] = useGeometrySelection();
-  return React.useMemo(() => {
-    var _history$zones$histor, _history$zones$histor2;
+  return style == null || (_style$items = style.items) == null ? void 0 : _style$items.reduce((acc, curr) => {
+    var _Object$entries;
 
-    if (history.step === -1) {
-      return "";
+    if (!curr.paint || lodash.isEmpty(curr.paint)) {
+      return acc;
     }
 
-    return type === exports.GeometrySelectionTypes.Zones ? !lodash.isEmpty((_history$zones$histor = history.zones[history.step]) == null ? void 0 : _history$zones$histor[0]) ? "SRID=3857;" + geometryToWkt((_history$zones$histor2 = history.zones[history.step]) == null ? void 0 : _history$zones$histor2[0]) : "SRID=3857;" + geometryToWkt(history.features[history.step]) : "SRID=3857;" + geometryToWkt(history.features[history.step]);
-  }, [history.features, history.step, history.zones, type]);
-};
+    return (_Object$entries = Object.entries(curr.paint)) == null ? void 0 : _Object$entries.reduce((paintAcc, _ref) => {
+      let [, value] = _ref;
 
-const useGeometrySelectionBuffer = () => {
-  const [{
-    settings: {
-      bufferRadius,
-      bufferMultiplier
-    },
-    isBuffer
-  }] = useGeometrySelection();
-  return React.useMemo(() => {
-    if (!isBuffer || !bufferRadius) {
-      return undefined;
-    }
+      if (!Array.isArray(value)) {
+        return paintAcc;
+      }
 
-    return Number((+bufferRadius || 0) * +bufferMultiplier).toFixed(2);
-  }, [isBuffer, bufferRadius, bufferMultiplier]);
+      return [...new Set([...paintAcc, ...findAttributeInExpression(value)])];
+    }, []);
+  }, []);
 };
 
-const customModes = MapboxDraw.modes;
-const StaticMode = {};
+const convertSpToTurfFeature = geometry => {
+  if (!geometry) {
+    return;
+  }
 
-StaticMode.onSetup = function () {
-  this.setActionableState(undefined);
-  return {};
-};
+  switch (geometry.type) {
+    case api.GeometryType.Point:
+      return turf.point(geometry.coordinates);
 
-StaticMode.toDisplayFeatures = function (state, geojson, display) {
-  display(geojson);
-};
+    case api.GeometryType.Multipoint:
+      return turf.multiPoint(geometry.coordinates);
 
-customModes.static = StaticMode;
+    case api.GeometryType.Polyline:
+      return turf.multiLineString(geometry.coordinates);
 
-const customStyles = [{
-  id: "gl-draw-point",
-  type: "circle",
-  filter: ["all", ["==", "$type", "Point"]],
-  paint: {
-    "circle-radius": 5,
-    "circle-color": "#D20C0C",
-    "circle-stroke-color": "#FFFFFF",
-    "circle-stroke-width": 3,
-    "circle-stroke-opacity": 0.3
+    case api.GeometryType.Polygon:
+    case api.GeometryType.Envelope:
+      return turf.polygon(geometry.coordinates);
+  }
+};
+
+const VectorLayer = (_ref) => {
+  var _layer$configuration;
+
+  let {
+    layer,
+    tileUrl,
+    visible,
+    beforeId,
+    getLayerTempStyle
+  } = _ref;
+  const clientStyle = layer == null || (_layer$configuration = layer.configuration) == null ? void 0 : _layer$configuration.clientStyle;
+  const {
+    idAttribute,
+    geometryType
+  } = layer.layerDefinition || {};
+  const renderLayerByGeometryType = React.useCallback(() => {
+    var _getLayerTempStyle, _getLayerTempStyle2, _getLayerTempStyle3, _getLayerTempStyle4, _getLayerTempStyle5, _getLayerTempStyle6, _getLayerTempStyle7, _getLayerTempStyle8, _getLayerTempStyle9, _getLayerTempStyle10, _getLayerTempStyle11, _getLayerTempStyle12, _getLayerTempStyle13, _getLayerTempStyle14;
+
+    const visibility = visible ? "visible" : "none";
+
+    switch (geometryType) {
+      case api.GeometryType.Point:
+        return React__default.createElement(MapGL.Layer, {
+          id: layer.name,
+          type: "circle",
+          "source-layer": "default",
+          beforeId: beforeId,
+          layout: _extends({}, getLayerTempStyle == null || (_getLayerTempStyle = getLayerTempStyle(layer.name, "circle")) == null ? void 0 : _getLayerTempStyle.layout, {
+            visibility
+          }),
+          paint: _extends({}, DEFAULT_CIRCLE_PAINT, getLayerTempStyle == null || (_getLayerTempStyle2 = getLayerTempStyle(layer.name, "circle")) == null ? void 0 : _getLayerTempStyle2.paint)
+        });
+
+      case api.GeometryType.Polygon:
+        return [React__default.createElement(MapGL.Layer, {
+          key: "polygon-layer-" + layer.name,
+          id: layer.name,
+          type: "fill",
+          "source-layer": "default",
+          beforeId: beforeId,
+          layout: _extends({}, getLayerTempStyle == null || (_getLayerTempStyle3 = getLayerTempStyle(layer.name, "fill")) == null ? void 0 : _getLayerTempStyle3.layout, {
+            visibility: visible && (getLayerTempStyle == null || (_getLayerTempStyle4 = getLayerTempStyle(layer.name, "fill-extrusion")) == null || (_getLayerTempStyle4 = _getLayerTempStyle4.settings) == null || (_getLayerTempStyle4 = _getLayerTempStyle4.fill) == null ? void 0 : _getLayerTempStyle4.showBottomSurface) !== false && Boolean(getActualExtrusionHeight(_extends({}, DEFAULT_FILL_EXTRUSION_PAINT, getLayerTempStyle == null || (_getLayerTempStyle5 = getLayerTempStyle(layer.name, "fill-extrusion")) == null ? void 0 : _getLayerTempStyle5.paint))) ? "visible" : "none"
+          }),
+          paint: _extends({}, DEFAULT_FILL_PAINT, getLayerTempStyle == null || (_getLayerTempStyle6 = getLayerTempStyle(layer.name, "fill")) == null ? void 0 : _getLayerTempStyle6.paint)
+        }), React__default.createElement(MapGL.Layer, {
+          key: "polygon-stroke-layer-" + layer.name,
+          id: layer.name + "-stroke",
+          type: "line",
+          "source-layer": "default",
+          beforeId: beforeId,
+          layout: _extends({}, getLayerTempStyle == null || (_getLayerTempStyle7 = getLayerTempStyle(layer.name, "line")) == null ? void 0 : _getLayerTempStyle7.layout, {
+            visibility: visible && (getLayerTempStyle == null || (_getLayerTempStyle8 = getLayerTempStyle(layer.name, "fill-extrusion")) == null || (_getLayerTempStyle8 = _getLayerTempStyle8.settings) == null || (_getLayerTempStyle8 = _getLayerTempStyle8.fill) == null ? void 0 : _getLayerTempStyle8.showBottomSurface) !== false && Boolean(getActualExtrusionHeight(_extends({}, DEFAULT_FILL_EXTRUSION_PAINT, getLayerTempStyle == null || (_getLayerTempStyle9 = getLayerTempStyle(layer.name, "fill-extrusion")) == null ? void 0 : _getLayerTempStyle9.paint))) ? "visible" : "none"
+          }),
+          paint: _extends({}, DEFAULT_LINE_PAINT, getLayerTempStyle == null || (_getLayerTempStyle10 = getLayerTempStyle(layer.name, "line")) == null ? void 0 : _getLayerTempStyle10.paint)
+        }), React__default.createElement(MapGL.Layer, {
+          key: "polygon-extrusion-layer-" + layer.name,
+          id: layer.name + "-extrusion",
+          type: "fill-extrusion",
+          "source-layer": "default",
+          beforeId: beforeId,
+          minzoom: 0,
+          maxzoom: 23,
+          layout: _extends({}, getLayerTempStyle == null || (_getLayerTempStyle11 = getLayerTempStyle(layer.name, "fill-extrusion")) == null ? void 0 : _getLayerTempStyle11.layout, {
+            visibility
+          }),
+          paint: _extends({}, DEFAULT_FILL_EXTRUSION_PAINT, getLayerTempStyle == null || (_getLayerTempStyle12 = getLayerTempStyle(layer.name, "fill-extrusion")) == null ? void 0 : _getLayerTempStyle12.paint)
+        })];
+
+      case api.GeometryType.Polyline:
+        return React__default.createElement(MapGL.Layer, {
+          id: layer.name,
+          type: "line",
+          "source-layer": "default",
+          beforeId: beforeId,
+          layout: _extends({}, getLayerTempStyle == null || (_getLayerTempStyle13 = getLayerTempStyle(layer.name, "line")) == null ? void 0 : _getLayerTempStyle13.layout, {
+            visibility
+          }),
+          paint: _extends({}, DEFAULT_LINE_PAINT, getLayerTempStyle == null || (_getLayerTempStyle14 = getLayerTempStyle(layer.name, "line")) == null ? void 0 : _getLayerTempStyle14.paint)
+        });
+
+      default:
+        return null;
+    }
+  }, [geometryType, layer, beforeId, visible, getLayerTempStyle == null ? void 0 : getLayerTempStyle(layer.name, "circle"), getLayerTempStyle == null ? void 0 : getLayerTempStyle(layer.name, "fill"), getLayerTempStyle == null ? void 0 : getLayerTempStyle(layer.name, "fill-extrusion"), getLayerTempStyle == null ? void 0 : getLayerTempStyle(layer.name, "line")]);
+  const renderClientStyle = React.useCallback(() => {
+    return clientStyle.items.map(mockItem => {
+      var _clientStyle$items, _getLayerTempStyle15, _getLayerTempStyle16, _currentSettings$fill, _currentSettings$fill2, _clientStyle$minzoom, _clientStyle$maxzoom, _getLayerTempStyle17, _getLayerTempStyle18;
+
+      const prefixSuffix = getClientStyleItemPrefixSuffix(geometryType, mockItem.type);
+      const isExtrusionItem = mockItem.type === "fill-extrusion";
+      const isPolygonPart = clientStyle.items.some(item => item.type === "fill-extrusion") && (mockItem.type === "fill" || mockItem.type === "line");
+      const fillExtrusionPaint = isPolygonPart || isExtrusionItem ? _extends({}, (_clientStyle$items = clientStyle.items) == null || (_clientStyle$items = _clientStyle$items.find(item => item.type === "fill-extrusion")) == null ? void 0 : _clientStyle$items.paint, getLayerTempStyle == null || (_getLayerTempStyle15 = getLayerTempStyle(layer.name, "fill-extrusion")) == null ? void 0 : _getLayerTempStyle15.paint) : undefined;
+
+      const currentSettings = _extends({}, clientStyle == null ? void 0 : clientStyle.settings, getLayerTempStyle == null || (_getLayerTempStyle16 = getLayerTempStyle(layer.name, mockItem.type)) == null ? void 0 : _getLayerTempStyle16.settings);
+
+      const processedExtrusionHeight = getActualExtrusionHeight(fillExtrusionPaint);
+      const hasExtrusion = Boolean(processedExtrusionHeight);
+      const visibility = visible && (isExtrusionItem && hasExtrusion || !isPolygonPart && !isExtrusionItem || isPolygonPart && (!hasExtrusion || ((_currentSettings$fill = currentSettings == null || (_currentSettings$fill2 = currentSettings.fill) == null ? void 0 : _currentSettings$fill2.showBottomSurface) != null ? _currentSettings$fill : true))) ? "visible" : "none";
+      return React__default.createElement(MapGL.Layer, {
+        key: "" + prefixSuffix[0] + layer.name,
+        id: "" + layer.name + prefixSuffix[1],
+        type: mockItem.type,
+        "source-layer": "default",
+        beforeId: beforeId,
+        minzoom: (_clientStyle$minzoom = clientStyle == null ? void 0 : clientStyle.minzoom) != null ? _clientStyle$minzoom : 0,
+        maxzoom: (_clientStyle$maxzoom = clientStyle == null ? void 0 : clientStyle.maxzoom) != null ? _clientStyle$maxzoom : 23,
+        layout: _extends({}, mockItem.layout, getLayerTempStyle == null || (_getLayerTempStyle17 = getLayerTempStyle(layer.name, mockItem.type)) == null ? void 0 : _getLayerTempStyle17.layout, {
+          visibility
+        }),
+        paint: _extends({}, mockItem.paint, getLayerTempStyle == null || (_getLayerTempStyle18 = getLayerTempStyle(layer.name, mockItem.type)) == null ? void 0 : _getLayerTempStyle18.paint)
+      });
+    });
+  }, [beforeId, clientStyle, geometryType, layer.name, visible, getLayerTempStyle == null ? void 0 : getLayerTempStyle(layer.name, "circle"), getLayerTempStyle == null ? void 0 : getLayerTempStyle(layer.name, "fill"), getLayerTempStyle == null ? void 0 : getLayerTempStyle(layer.name, "fill-extrusion"), getLayerTempStyle == null ? void 0 : getLayerTempStyle(layer.name, "line")]);
+
+  if (!layer) {
+    return null;
+  }
+
+  return React__default.createElement(MapGL.Source, {
+    promoteId: idAttribute,
+    id: layer.name,
+    type: "vector",
+    tiles: [tileUrl]
+  }, clientStyle != null && clientStyle.items ? renderClientStyle() : renderLayerByGeometryType());
+};
+
+const Layer = (_ref) => {
+  let {
+    layer,
+    layerType,
+    visible,
+    beforeId,
+    tileUrl,
+    onMount = () => null
+  } = _ref;
+  React.useEffect(onMount, []); // eslint-disable-line
+
+  if (!layer) {
+    return null;
+  }
+
+  if (layerType === "RasterTileLayer") {
+    return React__default.createElement(RasterLayer, {
+      layer: layer,
+      tileUrl: tileUrl,
+      visible: visible,
+      beforeId: beforeId
+    });
+  }
+
+  return React__default.createElement(VectorLayer, {
+    layer: layer,
+    tileUrl: tileUrl,
+    visible: visible,
+    beforeId: beforeId
+  });
+};
+
+var _templateObject;
+const MapWrapper = /*#__PURE__*/styled.div(_templateObject || (_templateObject = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  position: relative;\n  width: 100%;\n  height: 100%;\n  box-sizing: border-box;\n  z-index: ", ";\n\n  .mapbox-gl-draw_trash {\n    display: none;\n  }\n\n  .mapboxgl-ctrl-logo {\n    display: none;\n  }\n\n  .mapboxgl-ctrl.mapboxgl-ctrl-attrib {\n    display: none;\n  }\n\n  .mapboxgl-ctrl-geocoder.mapboxgl-ctrl {\n    width: 350px;\n  }\n"])), (_ref) => {
+  let {
+    $zIndex
+  } = _ref;
+  return $zIndex != null ? $zIndex : 1;
+});
+
+const customModes = MapboxDraw.modes;
+const StaticMode = {};
+
+StaticMode.onSetup = function () {
+  this.setActionableState(undefined);
+  return {};
+};
+
+StaticMode.toDisplayFeatures = function (state, geojson, display) {
+  display(geojson);
+};
+
+customModes.static = StaticMode;
+
+const customStyles = [{
+  id: "gl-draw-point",
+  type: "circle",
+  filter: ["all", ["==", "$type", "Point"]],
+  paint: {
+    "circle-radius": 5,
+    "circle-color": "#D20C0C",
+    "circle-stroke-color": "#FFFFFF",
+    "circle-stroke-width": 3,
+    "circle-stroke-opacity": 0.3
   }
 }, {
   id: "highlight-inactive-points",
@@ -703,280 +619,165 @@ const customStyles = [{
   }
 }];
 
-const draw = /*#__PURE__*/new MapboxDraw({
-  displayControlsDefault: false,
-  styles: customStyles,
-  modes: customModes,
-  defaultMode: "draw_point",
-  controls: {
-    trash: true
-  }
-});
-const useMapDraw = function useMapDraw(triggerDeps) {
-  if (triggerDeps === void 0) {
-    triggerDeps = [];
-  }
+const MapContext = /*#__PURE__*/React.createContext({});
 
-  const {
-    map,
-    draw: drawContext,
-    loaded,
-    basemapName
-  } = useMapContext();
+const MapProvider = (_ref) => {
+  let {
+    basemapItems,
+    defaultBasemap,
+    children
+  } = _ref;
+  const map = React.useRef();
+  const draw = React.useRef();
+  const [loaded, setLoaded] = React.useState(false);
+  const [basemapName, setBasemapName] = React.useState(defaultBasemap);
+  return React__default.createElement(MapContext.Provider, {
+    value: {
+      map,
+      draw,
+      loaded,
+      setLoaded,
+      basemapItems,
+      basemapName,
+      setBasemapName,
+      defaultBasemap
+    }
+  }, children);
+};
+
+(function (BaseMapTheme) {
+  BaseMapTheme["Light"] = "light";
+  BaseMapTheme["Dark"] = "dark";
+})(exports.BaseMapTheme || (exports.BaseMapTheme = {}));
+
+const ServerNotificationsContext = /*#__PURE__*/React.createContext({});
+
+const useServerNotifications = (url, initialized) => {
+  const hubConnection = React.useRef(null);
+  const [connection, setConnection] = React.useState(null);
   React.useEffect(() => {
-    if (!loaded || !map.current) {
+    if (!initialized) {
       return;
     }
 
-    drawContext.current = draw;
-    map.current.addControl(drawContext.current);
-  }, [loaded]); // eslint-disable-line
+    hubConnection.current = new signalr.HubConnectionBuilder().withUrl(url, {
+      withCredentials: true
+    }).configureLogging(signalr.LogLevel.Information).build();
+    hubConnection.current.start().then(() => console.info("Серверные нотификации подключены")).catch(err => console.info("Ошибка:", err)).finally(() => setConnection(hubConnection.current));
+  }, [initialized]); // eslint-disable-line
 
   React.useEffect(() => {
-    if (map.current && map.current.hasControl(drawContext.current)) {
-      map.current.removeControl(drawContext.current);
-      map.current.addControl(drawContext.current);
+    if (!connection || connection.state !== "Connected") {
+      return;
     }
-  }, [basemapName, ...triggerDeps]); // eslint-disable-line
-};
 
-const useRedrawLayer = () => {
-  const {
-    map
-  } = useMapContext();
-  return React.useCallback(layerName => {
-    const layerTileSource = map.current.getSource(layerName);
-    layerTileSource.setTiles(layerTileSource.tiles);
-  }, [map]);
-};
-
-const useSelectedFeatures = () => {
-  var _selectFeatures$featu;
-
-  const {
-    selectFeatures,
-    setSelectedFeatures
-  } = useMapContext();
-  const updatSelectedFeatures = React.useCallback(features => {
-    setSelectedFeatures(features);
-  }, [setSelectedFeatures]);
-  return [(_selectFeatures$featu = selectFeatures.features) != null ? _selectFeatures$featu : {}, updatSelectedFeatures];
-};
-
-const useSelectFeaturesCount = () => {
-  const {
-    selectFeatures
-  } = useMapContext();
-  return React.useMemo(() => {
-    var _selectFeatures$featu, _selectFeatures$featu2;
-
-    return (_selectFeatures$featu = (_selectFeatures$featu2 = selectFeatures.features) == null || (_selectFeatures$featu2 = _selectFeatures$featu2[selectFeatures.layerName]) == null ? void 0 : _selectFeatures$featu2.length) != null ? _selectFeatures$featu : 0;
-  }, [selectFeatures]);
-};
-
-const useSelectFeaturesCurrentIndex = () => {
-  const {
-    selectFeatures
-  } = useMapContext();
-  return React.useMemo(() => {
-    var _selectFeatures$featu, _selectFeatures$featu2;
-
-    return (_selectFeatures$featu = selectFeatures.features) != null && (_selectFeatures$featu = _selectFeatures$featu[selectFeatures.layerName]) != null && _selectFeatures$featu.length ? (_selectFeatures$featu2 = selectFeatures.features) == null || (_selectFeatures$featu2 = _selectFeatures$featu2[selectFeatures.layerName]) == null ? void 0 : _selectFeatures$featu2.findIndex(feature => feature.id === selectFeatures.currentId) : -1;
-  }, [selectFeatures]);
-};
-
-const useSelectFeaturesGeometryMasking = () => {
-  const {
-    selectFeatures,
-    setSelectFeaturesGeometryMasking
-  } = useMapContext();
-  const update = React.useCallback(state => {
-    setSelectFeaturesGeometryMasking(state);
-  }, [setSelectFeaturesGeometryMasking]);
-  return [selectFeatures.geometryMasking, update];
-};
-
-const useSelectFeaturesInitialized = () => {
-  const {
-    selectFeatures,
-    setSelectFeaturesInitialized
-  } = useMapContext();
-  const update = React.useCallback(state => {
-    setSelectFeaturesInitialized(state);
-  }, [setSelectFeaturesInitialized]);
-  return [selectFeatures.initialized, update];
-};
-
-const useSelectFeaturesLayerName = () => {
-  const {
-    selectFeatures,
-    setSelectFeaturesLayerName
-  } = useMapContext();
-  const update = React.useCallback(name => {
-    setSelectFeaturesLayerName(name);
-  }, [setSelectFeaturesLayerName]);
-  return [selectFeatures.layerName, update];
-};
-
-const useSelectFeaturesPagination = () => {
-  const {
-    setNextFeature,
-    setPrevFeature
-  } = useMapContext();
-  const onNext = React.useCallback(() => {
-    setNextFeature();
-  }, [setNextFeature]);
-  const onPrev = React.useCallback(() => {
-    setPrevFeature();
-  }, [setPrevFeature]);
-  return {
-    onNext,
-    onPrev
-  };
-};
-
-const useSelectFeaturesStatisticsActive = () => {
-  const {
-    selectFeatures,
-    setSelectFeaturesStatisticsActive
-  } = useMapContext();
-  const update = React.useCallback(state => {
-    setSelectFeaturesStatisticsActive(state);
-  }, [setSelectFeaturesStatisticsActive]);
-  return [selectFeatures.statisticsActive, update];
-};
-
-const useSelectFeaturesTotalCounts = () => {
-  var _selectFeatures$total;
-
-  const {
-    selectFeatures,
-    setSelectedFeaturesTotalCounts
-  } = useMapContext();
-  const update = React.useCallback(totalCounts => {
-    setSelectedFeaturesTotalCounts(totalCounts);
-  }, [setSelectedFeaturesTotalCounts]);
-  return [(_selectFeatures$total = selectFeatures.totalCounts) != null ? _selectFeatures$total : {}, update];
-};
-
-const useUpdateCurrentFeature = () => {
-  const {
-    updateCurrentFeature
-  } = useMapContext();
-  return React.useCallback(values => {
-    updateCurrentFeature(values);
-  }, [updateCurrentFeature]);
+    connection.invoke("SubscribeNotifications", []).then(() => console.info("Подписка `SubscribeNotifications` оформлена")).catch(err => console.info("Ошибка подписки `SubscribeNotifications`:", err));
+  }, [connection]);
+  return connection;
 };
 
-const findAttributeInExpression = expression => {
-  if (Array.isArray(expression) && expression.length === 2 && expression[0] === "get") {
-    return [expression[1]];
-  }
-
-  return expression.reduce((acc, curr) => {
-    if (!Array.isArray(curr)) {
-      return acc;
+const ServerNotificationsProvider = (_ref) => {
+  let {
+    url,
+    initialized,
+    children
+  } = _ref;
+  const connection = useServerNotifications(url, initialized);
+  const addSubscription = React.useCallback(async payload => {
+    if (!connection || connection.state !== "Connected" || !payload) {
+      return;
     }
 
-    if (curr[0] === "get") {
-      return [...new Set([...acc, curr[1]])];
+    try {
+      const id = await connection.invoke("AddSubscription", payload);
+      console.info("Подписка добавлена, id:", id);
+      return id;
+    } catch (err) {
+      console.info("Ошибка добавления подписки:", err);
+      return Promise.resolve(null);
     }
-
-    return [...new Set([...acc, ...findAttributeInExpression(curr)])];
-  }, []);
-};
-
-const getActualExtrusionHeight = paint => {
-  return Array.isArray(paint == null ? void 0 : paint["fill-extrusion-height"]) && (paint == null ? void 0 : paint["fill-extrusion-height"][0]) === "+" ? paint == null ? void 0 : paint["fill-extrusion-height"][1] : paint == null ? void 0 : paint["fill-extrusion-height"];
-};
-
-const parseClientStyle = style => {
-  var _style$items;
-
-  if (!style) {
-    return [];
-  }
-
-  return style == null || (_style$items = style.items) == null ? void 0 : _style$items.reduce((acc, curr) => {
-    var _Object$entries;
-
-    if (!curr.paint || lodash.isEmpty(curr.paint)) {
-      return acc;
+  }, [connection]);
+  const updateSubscription = React.useCallback(async (id, payload) => {
+    if (!connection || connection.state !== "Connected" || !id || !payload) {
+      return;
     }
 
-    return (_Object$entries = Object.entries(curr.paint)) == null ? void 0 : _Object$entries.reduce((paintAcc, _ref) => {
-      let [, value] = _ref;
-
-      if (!Array.isArray(value)) {
-        return paintAcc;
-      }
+    try {
+      await connection.invoke("UpdateSubscription", id, payload);
+    } catch (err) {
+      console.info("\u041E\u0448\u0438\u0431\u043A\u0430 \u043E\u0431\u043D\u043E\u0432\u043B\u0435\u043D\u0438\u044F \u043F\u043E\u0434\u043F\u0438\u0441\u043A\u0438 " + id + ":", err);
+    }
+  }, [connection]);
+  const unsubscribeById = React.useCallback(async id => {
+    if (!connection || connection.state !== "Connected" || !id) {
+      return;
+    }
 
-      return [...new Set([...paintAcc, ...findAttributeInExpression(value)])];
-    }, []);
-  }, []);
+    try {
+      await connection.invoke("Unsubscribe", [id]);
+    } catch (err) {
+      console.info("\u041E\u0448\u0438\u0431\u043A\u0430 \u043E\u0442\u043F\u0438\u0441\u043A\u0438 \u043F\u043E " + id + ":", err);
+    }
+  }, [connection]);
+  return React__default.createElement(ServerNotificationsContext.Provider, {
+    value: {
+      connection,
+      addSubscription,
+      updateSubscription,
+      unsubscribeById
+    }
+  }, children);
 };
 
-const convertSpToTurfFeature = geometry => {
-  if (!geometry) {
-    return;
-  }
-
-  switch (geometry.type) {
-    case api.GeometryType.Point:
-      return turf.point(geometry.coordinates);
-
-    case api.GeometryType.Multipoint:
-      return turf.multiPoint(geometry.coordinates);
-
-    case api.GeometryType.Polyline:
-      return turf.multiLineString(geometry.coordinates);
-
-    case api.GeometryType.Polygon:
-    case api.GeometryType.Envelope:
-      return turf.polygon(geometry.coordinates);
-  }
+const useMapContext = () => {
+  return React.useContext(MapContext);
 };
 
-const drawModeToGeometrySelectionType = mode => {
-  switch (mode) {
-    case "draw_point":
-      return exports.GeometrySelectionTypes.Point;
-
-    case "draw_polygon":
-      return exports.GeometrySelectionTypes.Polygon;
-
-    case "draw_line_string":
-      return exports.GeometrySelectionTypes.Line;
-
-    default:
-      return exports.GeometrySelectionTypes.Point;
+const draw = /*#__PURE__*/new MapboxDraw({
+  displayControlsDefault: false,
+  styles: customStyles,
+  modes: customModes,
+  defaultMode: "draw_point",
+  controls: {
+    trash: true
+  }
+});
+const useMapDraw = function useMapDraw(triggerDeps) {
+  if (triggerDeps === void 0) {
+    triggerDeps = [];
   }
-};
-
-const getGeometrySelectionTurfFeature = (coordinates, selectionType, toWgs) => {
-  if (toWgs) {
-    switch (selectionType) {
-      case exports.GeometrySelectionTypes.Point:
-        return turf.toWgs84(turf.point(coordinates));
-
-      case exports.GeometrySelectionTypes.Polygon:
-        return turf.toWgs84(turf.polygon(coordinates));
 
-      case exports.GeometrySelectionTypes.Line:
-        return turf.toWgs84(turf.lineString(coordinates));
+  const {
+    map,
+    draw: drawContext,
+    loaded,
+    basemapName
+  } = useMapContext();
+  React.useEffect(() => {
+    if (!loaded || !map.current) {
+      return;
     }
-  }
 
-  switch (selectionType) {
-    case exports.GeometrySelectionTypes.Point:
-      return turf.toMercator(turf.point(coordinates));
+    drawContext.current = draw;
+    map.current.addControl(drawContext.current);
+  }, [loaded]); // eslint-disable-line
 
-    case exports.GeometrySelectionTypes.Polygon:
-      return turf.toMercator(turf.polygon(coordinates));
+  React.useEffect(() => {
+    if (map.current && map.current.hasControl(drawContext.current)) {
+      map.current.removeControl(drawContext.current);
+      map.current.addControl(drawContext.current);
+    }
+  }, [basemapName, ...triggerDeps]); // eslint-disable-line
+};
 
-    case exports.GeometrySelectionTypes.Line:
-      return turf.toMercator(turf.lineString(coordinates));
-  }
+const useRedrawLayer = () => {
+  const {
+    map
+  } = useMapContext();
+  return React.useCallback(layerName => {
+    const layerTileSource = map.current.getSource(layerName);
+    layerTileSource.setTiles(layerTileSource.tiles);
+  }, [map]);
 };
 
 const useZoomToFeatures = () => {
@@ -998,24 +799,6 @@ const useZoomToFeatures = () => {
   }, [map]);
 };
 
-const DEFAULT_PADDING = 50;
-const useZoomToLayer = () => {
-  const {
-    map
-  } = useMapContext();
-  return React.useCallback(async (bulkExtent, options) => {
-    var _options$padding;
-
-    if (!bulkExtent || !bulkExtent.overall) {
-      return;
-    }
-
-    map.current.fitBounds([...bulkExtent.overall.coordinates[0], ...bulkExtent.overall.coordinates[1]], {
-      padding: (_options$padding = options == null ? void 0 : options.padding) != null ? _options$padding : DEFAULT_PADDING
-    });
-  }, [map]);
-};
-
 const useZoomToPoint = () => {
   const {
     map
@@ -1035,149 +818,79 @@ const useZoomToPoint = () => {
   }, [map]);
 };
 
-const useServerNotifications = (url, initialized) => {
-  const hubConnection = React.useRef(null);
-  const [connection, setConnection] = React.useState(null);
-  React.useEffect(() => {
-    if (!initialized) {
-      return;
-    }
-
-    hubConnection.current = new signalr.HubConnectionBuilder().withUrl(url, {
-      withCredentials: true
-    }).configureLogging(signalr.LogLevel.Information).build();
-    hubConnection.current.start().then(() => console.info("Серверные нотификации подключены")).catch(err => console.info("Ошибка:", err)).finally(() => setConnection(hubConnection.current));
-  }, [initialized]); // eslint-disable-line
-
-  React.useEffect(() => {
-    if (!connection || connection.state !== "Connected") {
-      return;
-    }
-
-    connection.invoke("SubscribeNotifications", []).then(() => console.info("Подписка `SubscribeNotifications` оформлена")).catch(err => console.info("Ошибка подписки `SubscribeNotifications`:", err));
-  }, [connection]);
-  return connection;
-};
-
-const ServerNotificationsContext = /*#__PURE__*/React.createContext({});
-
 const useServerNotificationsContext = () => {
   return React.useContext(ServerNotificationsContext);
 };
 
-(function (VerticalPosition) {
-  VerticalPosition["Top"] = "top";
-  VerticalPosition["Bottom"] = "bottom";
-})(exports.VerticalPosition || (exports.VerticalPosition = {}));
+const NO_CONTENT_VALUE = "—";
 
-(function (HorizontalPosition) {
-  HorizontalPosition["Left"] = "left";
-  HorizontalPosition["Right"] = "right";
-})(exports.HorizontalPosition || (exports.HorizontalPosition = {}));
+(function (DateFormat) {
+  DateFormat["ClientDefaultFormat"] = "dd.MM.yyyy HH:mm";
+  DateFormat["DateTime"] = "dd.MM.yyyy HH:mm:ss";
+  DateFormat["UTC"] = "yyyy-MM-dd'T'HH:mm:ss.sssxxx";
+  DateFormat["AxisTooltip"] = "d MMMM yyyy";
+})(exports.DateFormat || (exports.DateFormat = {}));
 
-const useResizer = (_ref) => {
-  let {
-    handleVerticalPosition,
-    handleHorizontalPosition,
-    minWidth = Number.MIN_SAFE_INTEGER,
-    maxWidth = Number.MAX_SAFE_INTEGER,
-    horizontal = true,
-    minHeight = Number.MIN_SAFE_INTEGER,
-    maxHeight = Number.MAX_SAFE_INTEGER,
-    vertical = true,
-    useResize = false,
-    onResize,
-    onResizeEnd,
-    onResizeStart
-  } = _ref;
-  const containerRef = React.useRef();
-  const verticalHandleRef = React.useRef();
-  const horizontalHandleRef = React.useRef();
-  const updateSizes = React.useCallback((width, height) => {
-    var _horizontalHandleRef$, _verticalHandleRef$cu;
+const stringDateParsers = [dateFns.parseJSON, dateFns.parseISO, rawDate => new Date(rawDate)];
+const getDate = rawDate => {
+  if (!rawDate) return null;
 
-    let newWidth = width;
-    let newHeight = height;
+  if (typeof rawDate === "string") {
+    for (const parser of stringDateParsers) {
+      const date = parser(rawDate);
 
-    if (horizontal && newWidth < minWidth) {
-      newWidth = minWidth;
+      if (dateFns.isValid(date)) {
+        return dateFns.toDate(date);
+      }
     }
 
-    if (horizontal && newWidth > Math.min(window.innerWidth - ((_horizontalHandleRef$ = horizontalHandleRef.current) == null ? void 0 : _horizontalHandleRef$.clientWidth), maxWidth)) {
-      newWidth = maxWidth;
-    }
+    return null;
+  }
 
-    if (vertical && newHeight < minHeight) {
-      newHeight = minHeight;
-    }
+  const parsedDate = dateFns.toDate(rawDate);
+  return dateFns.isValid(parsedDate) ? parsedDate : null;
+};
+const formatDate = function formatDate(date, _temp) {
+  let {
+    dateFormat = exports.DateFormat.ClientDefaultFormat,
+    defaultValue = NO_CONTENT_VALUE
+  } = _temp === void 0 ? {} : _temp;
+  const dateValue = date ? getDate(date) : null;
 
-    if (vertical && newHeight > Math.min(window.innerHeight - ((_verticalHandleRef$cu = verticalHandleRef.current) == null ? void 0 : _verticalHandleRef$cu.clientHeight), maxHeight)) {
-      newHeight = maxHeight;
-    }
+  if (dateFns.isValid(dateValue)) {
+    return dateFns.format(dateValue, dateFormat);
+  }
 
-    if (horizontal) {
-      requestAnimationFrame(() => {
-        if (!lodash.isNil(containerRef.current)) {
-          containerRef.current.style.width = newWidth + "px";
-        }
-      });
+  return defaultValue.toString();
+};
+
+const debounce = (callback, delay) => {
+  let timeId;
+  return function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
     }
 
-    if (vertical) {
-      requestAnimationFrame(() => {
-        if (!lodash.isNil(containerRef.current)) {
-          containerRef.current.style.height = newHeight + "px";
-        }
-      });
+    if (timeId) {
+      window.clearTimeout(timeId);
     }
 
-    onResize == null || onResize(newWidth, newHeight);
-  }, [minWidth, maxWidth, minHeight, maxHeight, horizontal, vertical]);
-  const onPointerMove = React.useCallback(pointerMoveEvent => {
-    var _containerRef$current, _containerRef$current2, _containerRef$current3;
-
-    const {
-      x,
-      y
-    } = (_containerRef$current = containerRef.current) == null ? void 0 : _containerRef$current.getBoundingClientRect();
-    const reverseHorizontal = handleHorizontalPosition === exports.HorizontalPosition.Right;
-    const reverseVertical = handleVerticalPosition === exports.VerticalPosition.Bottom;
-    const newWidth = reverseHorizontal ? pointerMoveEvent.pageX - x : ((_containerRef$current2 = containerRef.current) == null ? void 0 : _containerRef$current2.offsetWidth) + x - pointerMoveEvent.pageX;
-    const newHeight = reverseVertical ? pointerMoveEvent.pageY - y : ((_containerRef$current3 = containerRef.current) == null ? void 0 : _containerRef$current3.offsetHeight) + y - pointerMoveEvent.pageY;
-    document.body.style.userSelect = "none";
-    updateSizes(newWidth, newHeight);
-  }, [updateSizes]);
-  const onPointerDown = React.useCallback(() => {
-    const onPointerUp = () => {
-      document.body.style.userSelect = "initial";
-      document.body.removeEventListener("pointermove", onPointerMove);
-
-      if (!lodash.isNil(containerRef.current)) {
-        onResizeEnd == null || onResizeEnd(containerRef.current.offsetWidth, containerRef.current.offsetHeight);
-      }
-    };
+    timeId = window.setTimeout(() => {
+      callback(...args);
+    }, delay);
+  };
+};
 
-    if (!lodash.isNil(containerRef.current)) {
-      onResizeStart == null || onResizeStart(containerRef.current.offsetWidth, containerRef.current.offsetHeight);
-    }
+const isNumeric = number => !isNaN(parseFloat(number)) && isFinite(number);
 
-    document.body.addEventListener("pointermove", onPointerMove);
-    document.body.addEventListener("pointerup", onPointerUp, {
-      once: true
-    });
-  }, [onPointerMove]); // eslint-disable-line
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 
-  React.useLayoutEffect(() => {
-    if (useResize && !lodash.isNil(containerRef.current)) {
-      updateSizes(containerRef.current.offsetWidth, containerRef.current.offsetHeight);
-    }
-  }, [updateSizes, useResize]);
-  return {
-    containerRef,
-    verticalHandleRef,
-    horizontalHandleRef,
-    onPointerDown
-  };
+const useDebouncedCallback = interval => {
+  return React.useMemo(() => debounce(cb => {
+    cb();
+  }, interval), [interval]);
 };
 
 const useToggle = initial => {
@@ -1186,13 +899,23 @@ const useToggle = initial => {
   return [state, toggle, setState];
 };
 
-const _excluded = ["zIndex", "lowerSiblings", "upperSiblings", "drawTriggerDeps", "onError", "children"];
+const DEBOUNCE_DELAY = 144;
+const useWindowResize = (callback, delay) => {
+  const debounceCallback = React.useMemo(() => {
+    return callback ? debounce(callback, delay || DEBOUNCE_DELAY) : undefined;
+  }, [callback, delay]);
+  React.useEffect(() => {
+    debounceCallback && window.addEventListener("resize", debounceCallback);
+    return () => debounceCallback && window.removeEventListener("resize", debounceCallback);
+  }, [debounceCallback]);
+};
+
+const _excluded = ["zIndex", "lowerSiblings", "upperSiblings", "onError", "children"];
 const Map = (_ref) => {
   let {
     zIndex,
     lowerSiblings,
     upperSiblings,
-    drawTriggerDeps,
     onError,
     children
   } = _ref,
@@ -1202,7 +925,6 @@ const Map = (_ref) => {
     map,
     setLoaded
   } = useMapContext();
-  useMapDraw(drawTriggerDeps);
   return React__default.createElement(MapWrapper, {
     "$zIndex": zIndex
   }, lowerSiblings, React__default.createElement(MapGL__default, Object.assign({}, rest, {
@@ -1218,499 +940,34 @@ const Map = (_ref) => {
   }), children), upperSiblings);
 };
 
-const BuildingsLayer = (_ref) => {
-  let {
-    beforeId,
-    transparent
-  } = _ref;
-  return React__default.createElement(MapGL.Layer, {
-    id: "mapbox-3d-buildings",
-    source: "composite",
-    "source-layer": "building",
-    filter: ["==", "extrude", "true"],
-    type: "fill-extrusion",
-    minzoom: 15,
-    beforeId: beforeId,
-    paint: {
-      "fill-extrusion-color": "#aaaaaa",
-      "fill-extrusion-height": ["interpolate", ["linear"], ["zoom"], 15, 0, 15.05, ["get", "height"]],
-      "fill-extrusion-base": ["interpolate", ["linear"], ["zoom"], 15, 0, 15.05, ["get", "min_height"]],
-      "fill-extrusion-opacity": transparent ? 0 : 0.5
-    }
-  });
-};
-
-const RasterLayer = (_ref) => {
-  let {
-    layer,
-    tileUrl,
-    visible,
-    beforeId
-  } = _ref;
-
-  if (!layer) {
-    return null;
-  }
-
-  return React__default.createElement(MapGL.Source, {
-    id: layer.name,
-    type: "raster",
-    tiles: [tileUrl]
-  }, React__default.createElement(MapGL.Layer, {
-    id: layer.name,
-    type: "raster",
-    "source-layer": "default",
-    beforeId: beforeId,
-    layout: {
-      visibility: visible ? "visible" : "none"
-    }
-  }));
-};
-
-const DEFAULT_COLOR = "#00ffff";
-const DEFAULT_OPACITY = 0.5;
-const DEFAULT_SIZE = 4;
-const DEFAULT_LINE_WIDTH = 1;
-const DEFAULT_CIRCLE_PAINT = {
-  "circle-radius": DEFAULT_SIZE,
-  "circle-color": DEFAULT_COLOR,
-  "circle-opacity": DEFAULT_OPACITY,
-  "circle-stroke-width": 0,
-  "circle-stroke-color": DEFAULT_COLOR,
-  "circle-stroke-opacity": DEFAULT_OPACITY
-};
-const DEFAULT_FILL_PAINT = {
-  "fill-color": DEFAULT_COLOR,
-  "fill-opacity": DEFAULT_OPACITY
-};
-const DEFAULT_FILL_EXTRUSION_PAINT = {
-  "fill-extrusion-base": 0,
-  "fill-extrusion-vertical-gradient": true,
-  "fill-extrusion-color": DEFAULT_COLOR,
-  "fill-extrusion-opacity": DEFAULT_OPACITY,
-  "fill-extrusion-height": 0
-};
-const DEFAULT_LINE_PAINT = {
-  "line-color": DEFAULT_COLOR,
-  "line-width": DEFAULT_LINE_WIDTH,
-  "line-opacity": DEFAULT_OPACITY
-};
-
-const getClientStyleItemPrefixSuffix = (geometryType, type) => {
-  switch (geometryType) {
-    case api.GeometryType.Point:
-      return ["point-layer-", ""];
-
-    case api.GeometryType.Polyline:
-      return ["polyline-layer-", ""];
-
-    case api.GeometryType.Polygon:
-      switch (type) {
-        case "line":
-          return ["polygon-stroke-layer-", "-stroke"];
-
-        case "fill-extrusion":
-          return ["polygon-extrusion-layer-", "-extrusion"];
-
-        default:
-          return ["polygon-layer-", ""];
-      }
-
-    default:
-      return ["", ""];
-  }
-};
-
-const VectorLayer = (_ref) => {
-  var _layer$configuration;
-
-  let {
-    layer,
-    tileUrl,
-    visible,
-    beforeId,
-    getLayerTempStyle,
-    onMount = () => null
-  } = _ref;
-  const clientStyle = layer == null || (_layer$configuration = layer.configuration) == null ? void 0 : _layer$configuration.clientStyle;
-  const {
-    idAttribute,
-    geometryType
-  } = layer.layerDefinition || {};
-  const renderLayerByGeometryType = React.useCallback(() => {
-    var _getLayerTempStyle, _getLayerTempStyle2, _getLayerTempStyle3, _getLayerTempStyle4, _getLayerTempStyle5, _getLayerTempStyle6, _getLayerTempStyle7, _getLayerTempStyle8, _getLayerTempStyle9, _getLayerTempStyle10, _getLayerTempStyle11, _getLayerTempStyle12, _getLayerTempStyle13, _getLayerTempStyle14;
-
-    const visibility = visible ? "visible" : "none";
-
-    switch (geometryType) {
-      case api.GeometryType.Point:
-        return React__default.createElement(MapGL.Layer, {
-          id: layer.name,
-          type: "circle",
-          "source-layer": "default",
-          beforeId: beforeId,
-          layout: _extends({}, getLayerTempStyle == null || (_getLayerTempStyle = getLayerTempStyle(layer.name, "circle")) == null ? void 0 : _getLayerTempStyle.layout, {
-            visibility
-          }),
-          paint: _extends({}, DEFAULT_CIRCLE_PAINT, getLayerTempStyle == null || (_getLayerTempStyle2 = getLayerTempStyle(layer.name, "circle")) == null ? void 0 : _getLayerTempStyle2.paint)
-        });
-
-      case api.GeometryType.Polygon:
-        return [React__default.createElement(MapGL.Layer, {
-          key: "polygon-layer-" + layer.name,
-          id: layer.name,
-          type: "fill",
-          "source-layer": "default",
-          beforeId: beforeId,
-          layout: _extends({}, getLayerTempStyle == null || (_getLayerTempStyle3 = getLayerTempStyle(layer.name, "fill")) == null ? void 0 : _getLayerTempStyle3.layout, {
-            visibility: visible && (getLayerTempStyle == null || (_getLayerTempStyle4 = getLayerTempStyle(layer.name, "fill-extrusion")) == null || (_getLayerTempStyle4 = _getLayerTempStyle4.settings) == null || (_getLayerTempStyle4 = _getLayerTempStyle4.fill) == null ? void 0 : _getLayerTempStyle4.showBottomSurface) !== false && Boolean(getActualExtrusionHeight(_extends({}, DEFAULT_FILL_EXTRUSION_PAINT, getLayerTempStyle == null || (_getLayerTempStyle5 = getLayerTempStyle(layer.name, "fill-extrusion")) == null ? void 0 : _getLayerTempStyle5.paint))) ? "visible" : "none"
-          }),
-          paint: _extends({}, DEFAULT_FILL_PAINT, getLayerTempStyle == null || (_getLayerTempStyle6 = getLayerTempStyle(layer.name, "fill")) == null ? void 0 : _getLayerTempStyle6.paint)
-        }), React__default.createElement(MapGL.Layer, {
-          key: "polygon-stroke-layer-" + layer.name,
-          id: layer.name + "-stroke",
-          type: "line",
-          "source-layer": "default",
-          beforeId: beforeId,
-          layout: _extends({}, getLayerTempStyle == null || (_getLayerTempStyle7 = getLayerTempStyle(layer.name, "line")) == null ? void 0 : _getLayerTempStyle7.layout, {
-            visibility: visible && (getLayerTempStyle == null || (_getLayerTempStyle8 = getLayerTempStyle(layer.name, "fill-extrusion")) == null || (_getLayerTempStyle8 = _getLayerTempStyle8.settings) == null || (_getLayerTempStyle8 = _getLayerTempStyle8.fill) == null ? void 0 : _getLayerTempStyle8.showBottomSurface) !== false && Boolean(getActualExtrusionHeight(_extends({}, DEFAULT_FILL_EXTRUSION_PAINT, getLayerTempStyle == null || (_getLayerTempStyle9 = getLayerTempStyle(layer.name, "fill-extrusion")) == null ? void 0 : _getLayerTempStyle9.paint))) ? "visible" : "none"
-          }),
-          paint: _extends({}, DEFAULT_LINE_PAINT, getLayerTempStyle == null || (_getLayerTempStyle10 = getLayerTempStyle(layer.name, "line")) == null ? void 0 : _getLayerTempStyle10.paint)
-        }), React__default.createElement(MapGL.Layer, {
-          key: "polygon-extrusion-layer-" + layer.name,
-          id: layer.name + "-extrusion",
-          type: "fill-extrusion",
-          "source-layer": "default",
-          beforeId: beforeId,
-          minzoom: 0,
-          maxzoom: 23,
-          layout: _extends({}, getLayerTempStyle == null || (_getLayerTempStyle11 = getLayerTempStyle(layer.name, "fill-extrusion")) == null ? void 0 : _getLayerTempStyle11.layout, {
-            visibility
-          }),
-          paint: _extends({}, DEFAULT_FILL_EXTRUSION_PAINT, getLayerTempStyle == null || (_getLayerTempStyle12 = getLayerTempStyle(layer.name, "fill-extrusion")) == null ? void 0 : _getLayerTempStyle12.paint)
-        })];
-
-      case api.GeometryType.Polyline:
-        return React__default.createElement(MapGL.Layer, {
-          id: layer.name,
-          type: "line",
-          "source-layer": "default",
-          beforeId: beforeId,
-          layout: _extends({}, getLayerTempStyle == null || (_getLayerTempStyle13 = getLayerTempStyle(layer.name, "line")) == null ? void 0 : _getLayerTempStyle13.layout, {
-            visibility
-          }),
-          paint: _extends({}, DEFAULT_LINE_PAINT, getLayerTempStyle == null || (_getLayerTempStyle14 = getLayerTempStyle(layer.name, "line")) == null ? void 0 : _getLayerTempStyle14.paint)
-        });
-
-      default:
-        return null;
-    }
-  }, [geometryType, layer, beforeId, getLayerTempStyle, visible]);
-  const renderClientStyle = React.useCallback(() => {
-    return clientStyle.items.map(mockItem => {
-      var _clientStyle$items, _getLayerTempStyle15, _getLayerTempStyle16, _currentSettings$fill, _currentSettings$fill2, _clientStyle$minzoom, _clientStyle$maxzoom, _getLayerTempStyle17, _getLayerTempStyle18;
-
-      const prefixSuffix = getClientStyleItemPrefixSuffix(geometryType, mockItem.type);
-      const isExtrusionItem = mockItem.type === "fill-extrusion";
-      const isPolygonPart = clientStyle.items.some(item => item.type === "fill-extrusion") && (mockItem.type === "fill" || mockItem.type === "line");
-      const fillExtrusionPaint = isPolygonPart || isExtrusionItem ? _extends({}, (_clientStyle$items = clientStyle.items) == null || (_clientStyle$items = _clientStyle$items.find(item => item.type === "fill-extrusion")) == null ? void 0 : _clientStyle$items.paint, getLayerTempStyle == null || (_getLayerTempStyle15 = getLayerTempStyle(layer.name, "fill-extrusion")) == null ? void 0 : _getLayerTempStyle15.paint) : undefined;
-
-      const currentSettings = _extends({}, clientStyle == null ? void 0 : clientStyle.settings, getLayerTempStyle == null || (_getLayerTempStyle16 = getLayerTempStyle(layer.name, mockItem.type)) == null ? void 0 : _getLayerTempStyle16.settings);
-
-      const processedExtrusionHeight = getActualExtrusionHeight(fillExtrusionPaint);
-      const hasExtrusion = Boolean(processedExtrusionHeight);
-      const visibility = visible && (isExtrusionItem && hasExtrusion || !isPolygonPart && !isExtrusionItem || isPolygonPart && (!hasExtrusion || ((_currentSettings$fill = currentSettings == null || (_currentSettings$fill2 = currentSettings.fill) == null ? void 0 : _currentSettings$fill2.showBottomSurface) != null ? _currentSettings$fill : true))) ? "visible" : "none";
-      return React__default.createElement(MapGL.Layer, {
-        key: "" + prefixSuffix[0] + layer.name,
-        id: "" + layer.name + prefixSuffix[1],
-        type: mockItem.type,
-        "source-layer": "default",
-        beforeId: beforeId,
-        minzoom: (_clientStyle$minzoom = clientStyle == null ? void 0 : clientStyle.minzoom) != null ? _clientStyle$minzoom : 0,
-        maxzoom: (_clientStyle$maxzoom = clientStyle == null ? void 0 : clientStyle.maxzoom) != null ? _clientStyle$maxzoom : 23,
-        layout: _extends({}, mockItem.layout, getLayerTempStyle == null || (_getLayerTempStyle17 = getLayerTempStyle(layer.name, mockItem.type)) == null ? void 0 : _getLayerTempStyle17.layout, {
-          visibility
-        }),
-        paint: _extends({}, mockItem.paint, getLayerTempStyle == null || (_getLayerTempStyle18 = getLayerTempStyle(layer.name, mockItem.type)) == null ? void 0 : _getLayerTempStyle18.paint)
-      });
-    });
-  }, [beforeId, clientStyle, geometryType, layer.name, visible, getLayerTempStyle]);
-  React.useEffect(onMount, [layer.name]); // eslint-disable-line
-
-  if (!layer) {
-    return null;
-  }
-
-  return React__default.createElement(MapGL.Source, {
-    promoteId: idAttribute,
-    id: layer.name,
-    type: "vector",
-    tiles: [tileUrl]
-  }, clientStyle != null && clientStyle.items ? renderClientStyle() : renderLayerByGeometryType());
-};
-
-const Layer = (_ref) => {
-  let {
-    layer,
-    layerType,
-    visible,
-    beforeId,
-    tileUrl,
-    onMount = () => null
-  } = _ref;
-  React.useEffect(onMount, [layer.name]); // eslint-disable-line
-
-  if (!layer) {
-    return null;
-  }
-
-  if (layerType === "RasterTileLayer") {
-    return React__default.createElement(RasterLayer, {
-      layer: layer,
-      tileUrl: tileUrl,
-      visible: visible,
-      beforeId: beforeId,
-      onMount: onMount
-    });
-  }
-
-  return React__default.createElement(VectorLayer, {
-    layer: layer,
-    tileUrl: tileUrl,
-    visible: visible,
-    beforeId: beforeId,
-    onMount: onMount
-  });
-};
-
-var _templateObject$2, _templateObject2, _templateObject3, _templateObject4, _templateObject5, _templateObject6, _templateObject7, _templateObject8, _templateObject9, _templateObject10, _templateObject11, _templateObject12, _templateObject13, _templateObject14, _templateObject15;
-const ResizablePanelContainer = /*#__PURE__*/styled__default.div(_templateObject$2 || (_templateObject$2 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  display: flex;\n  flex-direction: column;\n  flex-shrink: 0;\n  position: relative;\n\n  ", "\n\n  ", "\n\n  ", "\n  ", "\n  ", "\n  ", "\n  ", "\n"])), (_ref) => {
-  let {
-    horizontal,
-    vertical
-  } = _ref;
-  return horizontal && !vertical ? styled.css(_templateObject2 || (_templateObject2 = _taggedTemplateLiteralLoose(["\n          height: 100%;\n        "]))) : !horizontal && vertical ? styled.css(_templateObject3 || (_templateObject3 = _taggedTemplateLiteralLoose(["\n          width: 100%;\n        "]))) : "";
-}, (_ref2) => {
-  let {
-    horizontal,
-    vertical
-  } = _ref2;
-  return styled.css(_templateObject4 || (_templateObject4 = _taggedTemplateLiteralLoose(["\n      will-change: ", ";\n    "])), [horizontal && "width", vertical && "height"].filter(Boolean).join(","));
-}, (_ref3) => {
-  let {
-    maxHeight
-  } = _ref3;
-  return maxHeight && styled.css(_templateObject5 || (_templateObject5 = _taggedTemplateLiteralLoose(["\n      max-height: ", "px;\n    "])), maxHeight);
-}, (_ref4) => {
-  let {
-    minHeight
-  } = _ref4;
-  return minHeight && styled.css(_templateObject6 || (_templateObject6 = _taggedTemplateLiteralLoose(["\n      min-height: ", "px;\n    "])), minHeight);
-}, (_ref5) => {
-  let {
-    maxWidth
-  } = _ref5;
-  return maxWidth && styled.css(_templateObject7 || (_templateObject7 = _taggedTemplateLiteralLoose(["\n      max-width: ", "px;\n    "])), maxWidth);
-}, (_ref6) => {
-  let {
-    height
-  } = _ref6;
-  return height && styled.css(_templateObject8 || (_templateObject8 = _taggedTemplateLiteralLoose(["\n      height: ", ";\n    "])), height);
-}, (_ref7) => {
-  let {
-    width
-  } = _ref7;
-  return width && styled.css(_templateObject9 || (_templateObject9 = _taggedTemplateLiteralLoose(["\n      width: ", ";\n    "])), width);
-});
-const getHandlePositionProps = (position, palette) => {
-  switch (position) {
-    case exports.HorizontalPosition.Left:
-      return styled.css(_templateObject10 || (_templateObject10 = _taggedTemplateLiteralLoose(["\n        height: 100%;\n        border-left: 2px solid ", ";\n        top: 0;\n        left: 0;\n        cursor: ew-resize;\n      "])), palette.elementDeep);
-
-    case exports.HorizontalPosition.Right:
-      return styled.css(_templateObject11 || (_templateObject11 = _taggedTemplateLiteralLoose(["\n        height: 100%;\n        border-right: 2px solid ", ";\n        top: 0;\n        right: 0;\n        cursor: ew-resize;\n      "])), palette.elementDeep);
-
-    case exports.VerticalPosition.Top:
-      return styled.css(_templateObject12 || (_templateObject12 = _taggedTemplateLiteralLoose(["\n        width: 100%;\n        border-top: 2px solid ", ";\n        top: 0;\n        left: 0;\n        cursor: ns-resize;\n      "])), palette.elementDeep);
-
-    case exports.VerticalPosition.Bottom:
-      return styled.css(_templateObject13 || (_templateObject13 = _taggedTemplateLiteralLoose(["\n        width: 100%;\n        border-bottom: 2px solid ", ";\n        bottom: 0;\n        left: 0;\n        cursor: ns-resize;\n      "])), palette.elementDeep);
-
-    default:
-      return styled.css(_templateObject14 || (_templateObject14 = _taggedTemplateLiteralLoose(["\n        width: 100%;\n        border-top: 2px solid ", ";\n        top: 0;\n        left: 0;\n      "])), palette.elementDeep);
-  }
-};
-const PanelDragHandle = /*#__PURE__*/styled__default.div(_templateObject15 || (_templateObject15 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  position: absolute;\n  box-sizing: border-box;\n  z-index: 3;\n\n  padding: 0.25rem;\n  pointer-events: ", ";\n  transition: border-color 150ms cubic-bezier(0.2, 1, 0.6, 1);\n\n  &:hover {\n    border-color: ", ";\n  }\n\n  ", "\n"])), (_ref8) => {
-  let {
-    disabled
-  } = _ref8;
-  return disabled && "none";
-}, (_ref9) => {
-  let {
-    theme: {
-      palette
-    }
-  } = _ref9;
-  return palette.primary;
-}, (_ref10) => {
-  let {
-    position,
-    theme: {
-      palette
-    }
-  } = _ref10;
-  return getHandlePositionProps(position, palette);
-});
-
-const _excluded$1 = ["className", "handleClassName", "width", "height", "disabled", "handleVerticalPosition", "handleHorizontalPosition", "Handle", "children"];
-const ResizablePanel = (_ref) => {
-  let {
-    className,
-    handleClassName,
-    width,
-    height,
-    disabled,
-    handleVerticalPosition = exports.VerticalPosition.Top,
-    handleHorizontalPosition = exports.HorizontalPosition.Left,
-    children
-  } = _ref,
-      resizeProps = _objectWithoutPropertiesLoose(_ref, _excluded$1);
-
-  const resizerProps = React.useMemo(() => _extends({}, resizeProps, {
-    handleVerticalPosition,
-    handleHorizontalPosition
-  }), [resizeProps, handleVerticalPosition, handleHorizontalPosition]);
-  const {
-    containerRef,
-    verticalHandleRef,
-    horizontalHandleRef,
-    onPointerDown
-  } = useResizer(resizerProps);
-  const {
-    vertical,
-    horizontal
-  } = resizeProps;
-  return React__default.createElement(ResizablePanelContainer, {
-    ref: containerRef,
-    width: width,
-    height: height,
-    style: disabled ? {
-      height: "auto"
-    } : undefined,
-    className: className
-  }, vertical && React__default.createElement(PanelDragHandle, {
-    ref: verticalHandleRef,
-    position: handleVerticalPosition,
-    disabled: disabled,
-    className: handleClassName,
-    onPointerDown: onPointerDown
-  }), horizontal && React__default.createElement(PanelDragHandle, {
-    ref: horizontalHandleRef,
-    position: handleHorizontalPosition,
-    disabled: disabled,
-    className: handleClassName,
-    onPointerDown: onPointerDown
-  }), children);
-};
-
-const ServerNotificationsProvider = (_ref) => {
-  let {
-    url,
-    initialized,
-    children
-  } = _ref;
-  const connection = useServerNotifications(url, initialized);
-  const addSubscription = React.useCallback(async payload => {
-    if (!connection || connection.state !== "Connected" || !payload) {
-      return;
-    }
-
-    try {
-      const id = await connection.invoke("AddSubscription", payload);
-      console.info("Подписка добавлена, id:", id);
-      return id;
-    } catch (err) {
-      console.info("Ошибка добавления подписки:", err);
-      return Promise.resolve(null);
-    }
-  }, [connection]);
-  const updateSubscription = React.useCallback(async (id, payload) => {
-    if (!connection || connection.state !== "Connected" || !id || !payload) {
-      return;
-    }
-
-    try {
-      await connection.invoke("UpdateSubscription", id, payload);
-    } catch (err) {
-      console.info("\u041E\u0448\u0438\u0431\u043A\u0430 \u043E\u0431\u043D\u043E\u0432\u043B\u0435\u043D\u0438\u044F \u043F\u043E\u0434\u043F\u0438\u0441\u043A\u0438 " + id + ":", err);
-    }
-  }, [connection]);
-  const unsubscribeById = React.useCallback(async id => {
-    if (!connection || connection.state !== "Connected" || !id) {
-      return;
-    }
-
-    try {
-      await connection.invoke("Unsubscribe", [id]);
-    } catch (err) {
-      console.info("\u041E\u0448\u0438\u0431\u043A\u0430 \u043E\u0442\u043F\u0438\u0441\u043A\u0438 \u043F\u043E " + id + ":", err);
-    }
-  }, [connection]);
-  return React__default.createElement(ServerNotificationsContext.Provider, {
-    value: {
-      connection,
-      addSubscription,
-      updateSubscription,
-      unsubscribeById
-    }
-  }, children);
-};
-
-exports.BuildingsLayer = BuildingsLayer;
+exports.DEFAULT_CIRCLE_PAINT = DEFAULT_CIRCLE_PAINT;
+exports.DEFAULT_FILL_EXTRUSION_PAINT = DEFAULT_FILL_EXTRUSION_PAINT;
+exports.DEFAULT_FILL_PAINT = DEFAULT_FILL_PAINT;
+exports.DEFAULT_LINE_PAINT = DEFAULT_LINE_PAINT;
 exports.ErrorBoundary = ErrorBoundary;
 exports.Layer = Layer;
 exports.Map = Map;
 exports.MapContext = MapContext;
 exports.MapProvider = MapProvider;
 exports.NO_CONTENT_VALUE = NO_CONTENT_VALUE;
-exports.ResizablePanel = ResizablePanel;
 exports.ServerNotificationsContext = ServerNotificationsContext;
 exports.ServerNotificationsProvider = ServerNotificationsProvider;
 exports.convertSpToTurfFeature = convertSpToTurfFeature;
-exports.drawModeToGeometrySelectionType = drawModeToGeometrySelectionType;
+exports.debounce = debounce;
 exports.findAttributeInExpression = findAttributeInExpression;
 exports.formatDate = formatDate;
-exports.geometryToWkt = geometryToWkt;
 exports.getActualExtrusionHeight = getActualExtrusionHeight;
 exports.getDate = getDate;
-exports.getGeometrySelectionTurfFeature = getGeometrySelectionTurfFeature;
 exports.isNumeric = isNumeric;
 exports.isObject = isObject;
 exports.parseClientStyle = parseClientStyle;
-exports.useCurrentSelectedFeature = useCurrentSelectedFeature;
-exports.useEditingFeature = useEditingFeature;
-exports.useEwktGeometry = useEwktGeometry;
-exports.useGeometryEditor = useGeometryEditor;
-exports.useGeometrySelection = useGeometrySelection;
-exports.useGeometrySelectionBuffer = useGeometrySelectionBuffer;
+exports.useDebouncedCallback = useDebouncedCallback;
 exports.useMapContext = useMapContext;
 exports.useMapDraw = useMapDraw;
 exports.useRedrawLayer = useRedrawLayer;
-exports.useResizer = useResizer;
-exports.useSelectFeaturesCount = useSelectFeaturesCount;
-exports.useSelectFeaturesCurrentIndex = useSelectFeaturesCurrentIndex;
-exports.useSelectFeaturesGeometryMasking = useSelectFeaturesGeometryMasking;
-exports.useSelectFeaturesInitialized = useSelectFeaturesInitialized;
-exports.useSelectFeaturesLayerName = useSelectFeaturesLayerName;
-exports.useSelectFeaturesPagination = useSelectFeaturesPagination;
-exports.useSelectFeaturesStatisticsActive = useSelectFeaturesStatisticsActive;
-exports.useSelectFeaturesTotalCounts = useSelectFeaturesTotalCounts;
-exports.useSelectedFeatures = useSelectedFeatures;
-exports.useServerNotifications = useServerNotifications;
 exports.useServerNotificationsContext = useServerNotificationsContext;
 exports.useToggle = useToggle;
-exports.useUpdateCurrentFeature = useUpdateCurrentFeature;
+exports.useWindowResize = useWindowResize;
 exports.useZoomToFeatures = useZoomToFeatures;
-exports.useZoomToLayer = useZoomToLayer;
 exports.useZoomToPoint = useZoomToPoint;
 //# sourceMappingURL=react.cjs.development.js.map