@evergis/react 3.1.2 → 3.1.4

package/dist/react.esm.js

@@ -1,17 +1,269 @@
-import { isEmpty, isNil } from 'lodash-es';
+import React, { Component, useCallback, useEffect, createContext, useRef, useState, useContext, useMemo } from 'react';
+import styled from 'styled-components';
+import MapGL, { Source, Layer as Layer$1 } from 'react-map-gl/mapbox';
 import { GeometryType } from '@evergis/api';
-import { polygon, multiLineString, multiPoint, point, bbox, toWgs84, lineString, toMercator } from '@turf/turf';
-import { useContext, useMemo, createContext, useCallback, useEffect, useRef, useState, useLayoutEffect } from 'react';
-import 'styled-components';
-import 'react-map-gl/mapbox';
+import { isEmpty } from 'lodash-es';
+import { polygon, multiLineString, multiPoint, point, bbox } from '@turf/turf';
 import '@mapbox/mapbox-gl-draw/dist/mapbox-gl-draw.css';
-import 'find-and';
-import { isValid, toDate, format, parseJSON, parseISO } from 'date-fns';
-import { stringify } from 'wkt';
 import MapboxDraw from '@mapbox/mapbox-gl-draw';
 import { HubConnectionBuilder, LogLevel } from '@microsoft/signalr';
+import { isValid, toDate, format, parseJSON, parseISO } from 'date-fns';
 import 'mapbox-gl/dist/mapbox-gl.css';
 
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  return Constructor;
+}
+
+function _extends() {
+  _extends = Object.assign || function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+
+    return target;
+  };
+
+  return _extends.apply(this, arguments);
+}
+
+function _inherits(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function");
+  }
+
+  subClass.prototype = Object.create(superClass && superClass.prototype, {
+    constructor: {
+      value: subClass,
+      writable: true,
+      configurable: true
+    }
+  });
+  if (superClass) _setPrototypeOf(subClass, superClass);
+}
+
+function _getPrototypeOf(o) {
+  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+    return o.__proto__ || Object.getPrototypeOf(o);
+  };
+  return _getPrototypeOf(o);
+}
+
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+
+  return _setPrototypeOf(o, p);
+}
+
+function _objectWithoutPropertiesLoose(source, excluded) {
+  if (source == null) return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key, i;
+
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0) continue;
+    target[key] = source[key];
+  }
+
+  return target;
+}
+
+function _assertThisInitialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+
+  return self;
+}
+
+function _possibleConstructorReturn(self, call) {
+  if (call && (typeof call === "object" || typeof call === "function")) {
+    return call;
+  }
+
+  return _assertThisInitialized(self);
+}
+
+function _taggedTemplateLiteralLoose(strings, raw) {
+  if (!raw) {
+    raw = strings.slice(0);
+  }
+
+  strings.raw = raw;
+  return strings;
+}
+
+var _templateObject;
+const ErrorBoundaryContainer = /*#__PURE__*/styled.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;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+
+    try {
+      return !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+    } catch (e) {
+      return false;
+    }
+  }
+
+  derived = _getPrototypeOf(derived);
+  return _possibleConstructorReturn(_this, isNativeReflectConstruct() ? Reflect.construct(derived, args || [], _getPrototypeOf(_this).constructor) : derived.apply(_this, args));
+}
+let ErrorBoundary = /*#__PURE__*/function (_Component) {
+  function ErrorBoundary() {
+    var _this2;
+
+    _classCallCheck(this, ErrorBoundary);
+
+    _this2 = _callSuper(this, ErrorBoundary, arguments);
+    _this2.state = {
+      hasError: false
+    };
+    return _this2;
+  }
+
+  _inherits(ErrorBoundary, _Component);
+
+  return _createClass(ErrorBoundary, [{
+    key: "componentDidCatch",
+    value: function componentDidCatch(error) {
+      // eslint-disable-next-line no-console
+      console.error(error);
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      const {
+        children,
+        errorContents
+      } = this.props;
+      const {
+        hasError
+      } = this.state;
+      return !hasError ? React.createElement(React.Fragment, null, children) : React.createElement(ErrorBoundaryContainer, null, errorContents);
+    }
+  }], [{
+    key: "getDerivedStateFromError",
+    value: function getDerivedStateFromError() {
+      return {
+        hasError: true
+      };
+    }
+  }]);
+}(Component);
+
+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 RasterLayer = (_ref) => {
+  let {
+    layer,
+    tileUrl,
+    visible,
+    beforeId
+  } = _ref;
+
+  if (!layer) {
+    return null;
+  }
+
+  return React.createElement(Source, {
+    id: layer.name,
+    type: "raster",
+    tiles: [tileUrl]
+  }, React.createElement(Layer$1, {
+    id: layer.name,
+    type: "raster",
+    "source-layer": "default",
+    beforeId: beforeId,
+    layout: {
+      visibility: visible ? "visible" : "none"
+    }
+  }));
+};
+
+const getClientStyleItemPrefixSuffix = (geometryType, type) => {
+  switch (geometryType) {
+    case GeometryType.Point:
+      return ["point-layer-", ""];
+
+    case GeometryType.Polyline:
+      return ["polyline-layer-", ""];
+
+    case 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 findAttributeInExpression = expression => {
   if (Array.isArray(expression) && expression.length === 2 && expression[0] === "get") {
     return [expression[1]];
@@ -81,222 +333,175 @@ const convertSpToTurfFeature = geometry => {
   }
 };
 
-function _extends() {
-  _extends = Object.assign || function (target) {
-    for (var i = 1; i < arguments.length; i++) {
-      var source = arguments[i];
-
-      for (var key in source) {
-        if (Object.prototype.hasOwnProperty.call(source, key)) {
-          target[key] = source[key];
-        }
-      }
-    }
+const VectorLayer = (_ref) => {
+  var _layer$configuration;
 
-    return target;
-  };
-
-  return _extends.apply(this, arguments);
-}
-
-const useMapContext = () => {
-  return useContext(MapContext);
-};
-
-const useCurrentSelectedFeature = () => {
-  const {
-    selectFeatures
-  } = useMapContext();
-  return 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 MapContext = /*#__PURE__*/createContext({});
-
-var BaseMapTheme;
-
-(function (BaseMapTheme) {
-  BaseMapTheme["Light"] = "light";
-  BaseMapTheme["Dark"] = "dark";
-})(BaseMapTheme || (BaseMapTheme = {}));
-
-var GeometrySelectionTypes;
-
-(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";
-})(GeometrySelectionTypes || (GeometrySelectionTypes = {}));
-
-var GeometrySelectionToolTypes;
-
-(function (GeometrySelectionToolTypes) {
-  GeometrySelectionToolTypes["Replace"] = "Replace";
-  GeometrySelectionToolTypes["Unite"] = "Unite";
-  GeometrySelectionToolTypes["Crop"] = "Crop";
-  GeometrySelectionToolTypes["Edit"] = "Edit";
-})(GeometrySelectionToolTypes || (GeometrySelectionToolTypes = {}));
-
-var GeometrySelectionZoneTypes;
-
-(function (GeometrySelectionZoneTypes) {
-  GeometrySelectionZoneTypes["Walking"] = "Walking";
-  GeometrySelectionZoneTypes["Car"] = "Car";
-})(GeometrySelectionZoneTypes || (GeometrySelectionZoneTypes = {}));
-
-var GeometrySelectionRouteTypes;
-
-(function (GeometrySelectionRouteTypes) {
-  GeometrySelectionRouteTypes["Walking"] = "Walking";
-  GeometrySelectionRouteTypes["Car"] = "Car";
-})(GeometrySelectionRouteTypes || (GeometrySelectionRouteTypes = {}));
-
-var GeometryEditorMode;
-
-(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";
-})(GeometryEditorMode || (GeometryEditorMode = {}));
-
-const useGeometryEditor = () => {
-  const {
-    geometryEditor,
-    setGeometryEditor
-  } = useMapContext();
-  const update = useCallback(newState => {
-    setGeometryEditor(prevState => _extends({}, prevState, newState));
-  }, [setGeometryEditor]);
-  return [geometryEditor, update];
-};
-
-const useEditingFeature = () => {
-  const [{
-    layerName,
-    active,
-    mode
-  }] = useGeometryEditor();
-  const currentSelectedFeature = useCurrentSelectedFeature();
-  return useMemo(() => {
-    return active && (mode === GeometryEditorMode.Edit && layerName === (currentSelectedFeature == null ? void 0 : currentSelectedFeature.layer) || mode === GeometryEditorMode.Create);
-  }, [active, currentSelectedFeature, layerName, mode]);
-};
-
-const useGeometrySelection = () => {
+  let {
+    layer,
+    tileUrl,
+    visible,
+    beforeId,
+    getLayerTempStyle,
+    onMount = () => null
+  } = _ref;
+  const clientStyle = layer == null || (_layer$configuration = layer.configuration) == null ? void 0 : _layer$configuration.clientStyle;
   const {
-    geometrySelection,
-    setGeometrySelection
-  } = useMapContext();
-  const updateGeometrySelection = useCallback(newState => {
-    setGeometrySelection(prevState => _extends({}, prevState, newState));
-  }, [setGeometrySelection]);
-  return [geometrySelection, updateGeometrySelection];
-};
-
-const NO_CONTENT_VALUE = "—";
-var DateFormat;
-
-(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";
-})(DateFormat || (DateFormat = {}));
-
-const stringDateParsers = [parseJSON, parseISO, rawDate => new Date(rawDate)];
-const getDate = rawDate => {
-  if (!rawDate) return null;
+    idAttribute,
+    geometryType
+  } = layer.layerDefinition || {};
+  const renderLayerByGeometryType = useCallback(() => {
+    var _getLayerTempStyle, _getLayerTempStyle2, _getLayerTempStyle3, _getLayerTempStyle4, _getLayerTempStyle5, _getLayerTempStyle6, _getLayerTempStyle7, _getLayerTempStyle8, _getLayerTempStyle9, _getLayerTempStyle10, _getLayerTempStyle11, _getLayerTempStyle12, _getLayerTempStyle13, _getLayerTempStyle14;
+
+    const visibility = visible ? "visible" : "none";
+
+    switch (geometryType) {
+      case GeometryType.Point:
+        return React.createElement(Layer$1, {
+          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)
+        });
 
-  if (typeof rawDate === "string") {
-    for (const parser of stringDateParsers) {
-      const date = parser(rawDate);
+      case GeometryType.Polygon:
+        return [React.createElement(Layer$1, {
+          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.createElement(Layer$1, {
+          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.createElement(Layer$1, {
+          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 GeometryType.Polyline:
+        return React.createElement(Layer$1, {
+          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)
+        });
 
-      if (isValid(date)) {
-        return toDate(date);
-      }
+      default:
+        return null;
     }
+  }, [geometryType, layer, beforeId, getLayerTempStyle, visible]);
+  const renderClientStyle = 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.createElement(Layer$1, {
+        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]);
+  useEffect(onMount, [layer.name]); // eslint-disable-line
 
+  if (!layer) {
     return null;
   }
 
-  const parsedDate = toDate(rawDate);
-  return isValid(parsedDate) ? parsedDate : null;
+  return React.createElement(Source, {
+    promoteId: idAttribute,
+    id: layer.name,
+    type: "vector",
+    tiles: [tileUrl]
+  }, clientStyle != null && clientStyle.items ? renderClientStyle() : renderLayerByGeometryType());
 };
-const formatDate = function formatDate(date, _temp) {
-  let {
-    dateFormat = DateFormat.ClientDefaultFormat,
-    defaultValue = NO_CONTENT_VALUE
-  } = _temp === void 0 ? {} : _temp;
-  const dateValue = date ? getDate(date) : null;
 
-  if (isValid(dateValue)) {
-    return format(dateValue, dateFormat);
-  }
-
-  return defaultValue.toString();
-};
+const Layer = (_ref) => {
+  let {
+    layer,
+    layerType,
+    visible,
+    beforeId,
+    tileUrl,
+    onMount = () => null
+  } = _ref;
+  useEffect(onMount, [layer.name]); // eslint-disable-line
 
-const geometryToWkt = function geometryToWkt(features) {
-  if (features === void 0) {
-    features = [];
+  if (!layer) {
+    return null;
   }
 
-  if (features.length === 0) {
-    return "";
+  if (layerType === "RasterTileLayer") {
+    return React.createElement(RasterLayer, {
+      layer: layer,
+      tileUrl: tileUrl,
+      visible: visible,
+      beforeId: beforeId,
+      onMount: onMount
+    });
   }
 
-  return stringify(features[0]);
-};
-
-const isNumeric = number => !isNaN(parseFloat(number)) && isFinite(number);
-
-function isObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-const useEwktGeometry = () => {
-  const [{
-    history,
-    type
-  }] = useGeometrySelection();
-  return useMemo(() => {
-    var _history$zones$histor, _history$zones$histor2;
-
-    if (history.step === -1) {
-      return "";
-    }
-
-    return type === GeometrySelectionTypes.Zones ? !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 React.createElement(VectorLayer, {
+    layer: layer,
+    tileUrl: tileUrl,
+    visible: visible,
+    beforeId: beforeId,
+    onMount: onMount
+  });
 };
 
-const useGeometrySelectionBuffer = () => {
-  const [{
-    settings: {
-      bufferRadius,
-      bufferMultiplier
-    },
-    isBuffer
-  }] = useGeometrySelection();
-  return useMemo(() => {
-    if (!isBuffer || !bufferRadius) {
-      return undefined;
-    }
-
-    return Number((+bufferRadius || 0) * +bufferMultiplier).toFixed(2);
-  }, [isBuffer, bufferRadius, bufferMultiplier]);
-};
+var _templateObject$1;
+const MapWrapper = /*#__PURE__*/styled.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 customModes = MapboxDraw.modes;
 const StaticMode = {};
@@ -413,6 +618,122 @@ const customStyles = [{
   }
 }];
 
+const MapContext = /*#__PURE__*/createContext({});
+
+const MapProvider = (_ref) => {
+  let {
+    basemapItems,
+    defaultBasemap,
+    children
+  } = _ref;
+  const map = useRef();
+  const draw = useRef();
+  const [loaded, setLoaded] = useState(false);
+  const [basemapName, setBasemapName] = useState(defaultBasemap);
+  return React.createElement(MapContext.Provider, {
+    value: {
+      map,
+      draw,
+      loaded,
+      setLoaded,
+      basemapItems,
+      basemapName,
+      setBasemapName,
+      defaultBasemap
+    }
+  }, children);
+};
+
+var BaseMapTheme;
+
+(function (BaseMapTheme) {
+  BaseMapTheme["Light"] = "light";
+  BaseMapTheme["Dark"] = "dark";
+})(BaseMapTheme || (BaseMapTheme = {}));
+
+const ServerNotificationsContext = /*#__PURE__*/createContext({});
+
+const useServerNotifications = (url, initialized) => {
+  const hubConnection = useRef(null);
+  const [connection, setConnection] = useState(null);
+  useEffect(() => {
+    if (!initialized) {
+      return;
+    }
+
+    hubConnection.current = new HubConnectionBuilder().withUrl(url, {
+      withCredentials: true
+    }).configureLogging(LogLevel.Information).build();
+    hubConnection.current.start().then(() => console.info("Серверные нотификации подключены")).catch(err => console.info("Ошибка:", err)).finally(() => setConnection(hubConnection.current));
+  }, [initialized]); // eslint-disable-line
+
+  useEffect(() => {
+    if (!connection || connection.state !== "Connected") {
+      return;
+    }
+
+    connection.invoke("SubscribeNotifications", []).then(() => console.info("Подписка `SubscribeNotifications` оформлена")).catch(err => console.info("Ошибка подписки `SubscribeNotifications`:", err));
+  }, [connection]);
+  return connection;
+};
+
+const ServerNotificationsProvider = (_ref) => {
+  let {
+    url,
+    initialized,
+    children
+  } = _ref;
+  const connection = useServerNotifications(url, initialized);
+  const addSubscription = 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 = 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 = 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.createElement(ServerNotificationsContext.Provider, {
+    value: {
+      connection,
+      addSubscription,
+      updateSubscription,
+      unsubscribeById
+    }
+  }, children);
+};
+
+const useMapContext = () => {
+  return useContext(MapContext);
+};
+
 const draw = /*#__PURE__*/new MapboxDraw({
   displayControlsDefault: false,
   styles: customStyles,
@@ -460,124 +781,6 @@ const useRedrawLayer = () => {
   }, [map]);
 };
 
-const useSelectedFeatures = () => {
-  var _selectFeatures$featu;
-
-  const {
-    selectFeatures,
-    setSelectedFeatures
-  } = useMapContext();
-  const updatSelectedFeatures = useCallback(features => {
-    setSelectedFeatures(features);
-  }, [setSelectedFeatures]);
-  return [(_selectFeatures$featu = selectFeatures.features) != null ? _selectFeatures$featu : {}, updatSelectedFeatures];
-};
-
-const useSelectFeaturesCount = () => {
-  const {
-    selectFeatures
-  } = useMapContext();
-  return 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 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 = useCallback(state => {
-    setSelectFeaturesGeometryMasking(state);
-  }, [setSelectFeaturesGeometryMasking]);
-  return [selectFeatures.geometryMasking, update];
-};
-
-const useSelectFeaturesInitialized = () => {
-  const {
-    selectFeatures,
-    setSelectFeaturesInitialized
-  } = useMapContext();
-  const update = useCallback(state => {
-    setSelectFeaturesInitialized(state);
-  }, [setSelectFeaturesInitialized]);
-  return [selectFeatures.initialized, update];
-};
-
-const useSelectFeaturesLayerName = () => {
-  const {
-    selectFeatures,
-    setSelectFeaturesLayerName
-  } = useMapContext();
-  const update = useCallback(name => {
-    setSelectFeaturesLayerName(name);
-  }, [setSelectFeaturesLayerName]);
-  return [selectFeatures.layerName, update];
-};
-
-const useSelectFeaturesPagination = () => {
-  const {
-    setNextFeature,
-    setPrevFeature
-  } = useMapContext();
-  const onNext = useCallback(() => {
-    setNextFeature();
-  }, [setNextFeature]);
-  const onPrev = useCallback(() => {
-    setPrevFeature();
-  }, [setPrevFeature]);
-  return {
-    onNext,
-    onPrev
-  };
-};
-
-const useSelectFeaturesStatisticsActive = () => {
-  const {
-    selectFeatures,
-    setSelectFeaturesStatisticsActive
-  } = useMapContext();
-  const update = useCallback(state => {
-    setSelectFeaturesStatisticsActive(state);
-  }, [setSelectFeaturesStatisticsActive]);
-  return [selectFeatures.statisticsActive, update];
-};
-
-const useSelectFeaturesTotalCounts = () => {
-  var _selectFeatures$total;
-
-  const {
-    selectFeatures,
-    setSelectedFeaturesTotalCounts
-  } = useMapContext();
-  const update = useCallback(totalCounts => {
-    setSelectedFeaturesTotalCounts(totalCounts);
-  }, [setSelectedFeaturesTotalCounts]);
-  return [(_selectFeatures$total = selectFeatures.totalCounts) != null ? _selectFeatures$total : {}, update];
-};
-
-const useUpdateCurrentFeature = () => {
-  const {
-    updateCurrentFeature
-  } = useMapContext();
-  return useCallback(values => {
-    updateCurrentFeature(values);
-  }, [updateCurrentFeature]);
-};
-
 const useZoomToFeatures = () => {
   const {
     map
@@ -597,24 +800,6 @@ const useZoomToFeatures = () => {
   }, [map]);
 };
 
-const DEFAULT_PADDING = 50;
-const useZoomToLayer = () => {
-  const {
-    map
-  } = useMapContext();
-  return 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
@@ -634,153 +819,80 @@ const useZoomToPoint = () => {
   }, [map]);
 };
 
-const useServerNotifications = (url, initialized) => {
-  const hubConnection = useRef(null);
-  const [connection, setConnection] = useState(null);
-  useEffect(() => {
-    if (!initialized) {
-      return;
-    }
-
-    hubConnection.current = new HubConnectionBuilder().withUrl(url, {
-      withCredentials: true
-    }).configureLogging(LogLevel.Information).build();
-    hubConnection.current.start().then(() => console.info("Серверные нотификации подключены")).catch(err => console.info("Ошибка:", err)).finally(() => setConnection(hubConnection.current));
-  }, [initialized]); // eslint-disable-line
-
-  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__*/createContext({});
-
 const useServerNotificationsContext = () => {
   return useContext(ServerNotificationsContext);
 };
 
-var VerticalPosition;
-
-(function (VerticalPosition) {
-  VerticalPosition["Top"] = "top";
-  VerticalPosition["Bottom"] = "bottom";
-})(VerticalPosition || (VerticalPosition = {}));
-
-var HorizontalPosition;
+const NO_CONTENT_VALUE = "—";
+var DateFormat;
 
-(function (HorizontalPosition) {
-  HorizontalPosition["Left"] = "left";
-  HorizontalPosition["Right"] = "right";
-})(HorizontalPosition || (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";
+})(DateFormat || (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 = useRef();
-  const verticalHandleRef = useRef();
-  const horizontalHandleRef = useRef();
-  const updateSizes = useCallback((width, height) => {
-    var _horizontalHandleRef$, _verticalHandleRef$cu;
+const stringDateParsers = [parseJSON, 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 (isValid(date)) {
+        return 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 = toDate(rawDate);
+  return isValid(parsedDate) ? parsedDate : null;
+};
+const formatDate = function formatDate(date, _temp) {
+  let {
+    dateFormat = 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 (isValid(dateValue)) {
+    return format(dateValue, dateFormat);
+  }
 
-    if (horizontal) {
-      requestAnimationFrame(() => {
-        if (!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 (!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 = 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 === HorizontalPosition.Right;
-    const reverseVertical = handleVerticalPosition === 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 = useCallback(() => {
-    const onPointerUp = () => {
-      document.body.style.userSelect = "initial";
-      document.body.removeEventListener("pointermove", onPointerMove);
-
-      if (!isNil(containerRef.current)) {
-        onResizeEnd == null || onResizeEnd(containerRef.current.offsetWidth, containerRef.current.offsetHeight);
-      }
-    };
+    timeId = window.setTimeout(() => {
+      callback(...args);
+    }, delay);
+  };
+};
 
-    if (!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);
+}
 
-  useLayoutEffect(() => {
-    if (useResize && !isNil(containerRef.current)) {
-      updateSizes(containerRef.current.offsetWidth, containerRef.current.offsetHeight);
-    }
-  }, [updateSizes, useResize]);
-  return {
-    containerRef,
-    verticalHandleRef,
-    horizontalHandleRef,
-    onPointerDown
-  };
+const useDebouncedCallback = interval => {
+  return useMemo(() => debounce(cb => {
+    cb();
+  }, interval), [interval]);
 };
 
 const useToggle = initial => {
@@ -789,47 +901,46 @@ const useToggle = initial => {
   return [state, toggle, setState];
 };
 
-const drawModeToGeometrySelectionType = mode => {
-  switch (mode) {
-    case "draw_point":
-      return GeometrySelectionTypes.Point;
-
-    case "draw_polygon":
-      return GeometrySelectionTypes.Polygon;
-
-    case "draw_line_string":
-      return GeometrySelectionTypes.Line;
-
-    default:
-      return GeometrySelectionTypes.Point;
-  }
+const DEBOUNCE_DELAY = 144;
+const useWindowResize = (callback, delay) => {
+  const debounceCallback = useMemo(() => {
+    return callback ? debounce(callback, delay || DEBOUNCE_DELAY) : undefined;
+  }, [callback, delay]);
+  useEffect(() => {
+    debounceCallback && window.addEventListener("resize", debounceCallback);
+    return () => debounceCallback && window.removeEventListener("resize", debounceCallback);
+  }, [debounceCallback]);
 };
 
-const getGeometrySelectionTurfFeature = (coordinates, selectionType, toWgs) => {
-  if (toWgs) {
-    switch (selectionType) {
-      case GeometrySelectionTypes.Point:
-        return toWgs84(point(coordinates));
-
-      case GeometrySelectionTypes.Polygon:
-        return toWgs84(polygon(coordinates));
+const _excluded = ["zIndex", "lowerSiblings", "upperSiblings", "drawTriggerDeps", "onError", "children"];
+const Map = (_ref) => {
+  let {
+    zIndex,
+    lowerSiblings,
+    upperSiblings,
+    onError,
+    children
+  } = _ref,
+      rest = _objectWithoutPropertiesLoose(_ref, _excluded);
 
-      case GeometrySelectionTypes.Line:
-        return toWgs84(lineString(coordinates));
+  const {
+    map,
+    setLoaded
+  } = useMapContext();
+  return React.createElement(MapWrapper, {
+    "$zIndex": zIndex
+  }, lowerSiblings, React.createElement(MapGL, Object.assign({}, rest, {
+    renderWorldCopies: true,
+    antialias: true,
+    doubleClickZoom: false,
+    cursor: "default",
+    onLoad: e => {
+      map.current = e.target;
+      map.current.on("error", onError);
+      setLoaded(true);
     }
-  }
-
-  switch (selectionType) {
-    case GeometrySelectionTypes.Point:
-      return toMercator(point(coordinates));
-
-    case GeometrySelectionTypes.Polygon:
-      return toMercator(polygon(coordinates));
-
-    case GeometrySelectionTypes.Line:
-      return toMercator(lineString(coordinates));
-  }
+  }), children), upperSiblings);
 };
 
-export { DateFormat, HorizontalPosition, NO_CONTENT_VALUE, VerticalPosition, convertSpToTurfFeature, drawModeToGeometrySelectionType, findAttributeInExpression, formatDate, geometryToWkt, getActualExtrusionHeight, getDate, getGeometrySelectionTurfFeature, isNumeric, isObject, parseClientStyle, useCurrentSelectedFeature, useEditingFeature, useEwktGeometry, useGeometryEditor, useGeometrySelection, useGeometrySelectionBuffer, useMapContext, useMapDraw, useRedrawLayer, useResizer, useSelectFeaturesCount, useSelectFeaturesCurrentIndex, useSelectFeaturesGeometryMasking, useSelectFeaturesInitialized, useSelectFeaturesLayerName, useSelectFeaturesPagination, useSelectFeaturesStatisticsActive, useSelectFeaturesTotalCounts, useSelectedFeatures, useServerNotifications, useServerNotificationsContext, useToggle, useUpdateCurrentFeature, useZoomToFeatures, useZoomToLayer, useZoomToPoint };
+export { BaseMapTheme, DEFAULT_CIRCLE_PAINT, DEFAULT_FILL_EXTRUSION_PAINT, DEFAULT_FILL_PAINT, DEFAULT_LINE_PAINT, DateFormat, ErrorBoundary, Layer, Map, MapContext, MapProvider, NO_CONTENT_VALUE, ServerNotificationsContext, ServerNotificationsProvider, convertSpToTurfFeature, debounce, findAttributeInExpression, formatDate, getActualExtrusionHeight, getDate, isNumeric, isObject, parseClientStyle, useDebouncedCallback, useMapContext, useMapDraw, useRedrawLayer, useServerNotificationsContext, useToggle, useWindowResize, useZoomToFeatures, useZoomToPoint };
 //# sourceMappingURL=react.esm.js.map