@evergis/react 3.1.0 → 3.1.2

package/dist/react.esm.js

@@ -1,4 +1,208 @@
+import { isEmpty, isNil } from 'lodash-es';
+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 '@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 'mapbox-gl/dist/mapbox-gl.css';
+
+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;
+    }
+
+    if (curr[0] === "get") {
+      return [...new Set([...acc, curr[1]])];
+    }
+
+    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 || isEmpty(curr.paint)) {
+      return acc;
+    }
+
+    return (_Object$entries = Object.entries(curr.paint)) == null ? void 0 : _Object$entries.reduce((paintAcc, _ref) => {
+      let [, value] = _ref;
+
+      if (!Array.isArray(value)) {
+        return paintAcc;
+      }
+
+      return [...new Set([...paintAcc, ...findAttributeInExpression(value)])];
+    }, []);
+  }, []);
+};
+
+const convertSpToTurfFeature = geometry => {
+  if (!geometry) {
+    return;
+  }
+
+  switch (geometry.type) {
+    case GeometryType.Point:
+      return point(geometry.coordinates);
+
+    case GeometryType.Multipoint:
+      return multiPoint(geometry.coordinates);
+
+    case GeometryType.Polyline:
+      return multiLineString(geometry.coordinates);
+
+    case GeometryType.Polygon:
+    case GeometryType.Envelope:
+      return polygon(geometry.coordinates);
+  }
+};
+
+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);
+}
+
+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 = () => {
+  const {
+    geometrySelection,
+    setGeometrySelection
+  } = useMapContext();
+  const updateGeometrySelection = useCallback(newState => {
+    setGeometrySelection(prevState => _extends({}, prevState, newState));
+  }, [setGeometrySelection]);
+  return [geometrySelection, updateGeometrySelection];
+};
 
 const NO_CONTENT_VALUE = "—";
 var DateFormat;
@@ -43,11 +247,589 @@ const formatDate = function formatDate(date, _temp) {
   return defaultValue.toString();
 };
 
+const geometryToWkt = function geometryToWkt(features) {
+  if (features === void 0) {
+    features = [];
+  }
+
+  if (features.length === 0) {
+    return "";
+  }
+
+  return stringify(features[0]);
+};
+
 const isNumeric = number => !isNaN(parseFloat(number)) && isFinite(number);
 
 function isObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
-export { DateFormat, NO_CONTENT_VALUE, formatDate, getDate, isNumeric, isObject };
+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]);
+};
+
+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]);
+};
+
+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",
+  type: "circle",
+  filter: ["all", ["==", "$type", "Point"], ["==", "meta", "feature"], ["==", "active", "false"]],
+  paint: {
+    "circle-radius": 5,
+    "circle-color": "#D20C0C",
+    "circle-stroke-color": "#FFFFFF",
+    "circle-stroke-width": 3,
+    "circle-stroke-opacity": 0.3
+  }
+}, {
+  id: "highlight-active-points",
+  type: "circle",
+  filter: ["all", ["==", "$type", "Point"], ["==", "meta", "feature"], ["==", "active", "true"]],
+  paint: {
+    "circle-radius": 3,
+    "circle-color": "#fbb03b",
+    "circle-stroke-color": "#FFFFFF",
+    "circle-stroke-width": 1,
+    "circle-stroke-opacity": 0.3
+  }
+}, {
+  id: "gl-draw-polygon-fill-static",
+  type: "fill",
+  filter: ["all", ["==", "$type", "Polygon"]],
+  paint: {
+    "fill-color": "#D20C0C",
+    "fill-outline-color": "#D20C0C",
+    "fill-opacity": 0.1
+  }
+}, {
+  id: "gl-draw-line",
+  type: "line",
+  filter: ["all", ["==", "$type", "LineString"]],
+  layout: {
+    "line-cap": "round",
+    "line-join": "round"
+  },
+  paint: {
+    "line-color": "#D20C0C",
+    "line-dasharray": [0.2, 2],
+    "line-width": 2
+  }
+}, {
+  id: "gl-draw-polygon-fill",
+  type: "fill",
+  filter: ["all", ["==", "$type", "Polygon"]],
+  paint: {
+    "fill-color": "#D20C0C",
+    "fill-outline-color": "#D20C0C",
+    "fill-opacity": 0.1
+  }
+}, {
+  id: "gl-draw-polygon-midpoint",
+  type: "circle",
+  filter: ["all", ["==", "$type", "Point"], ["==", "meta", "midpoint"]],
+  paint: {
+    "circle-radius": 3,
+    "circle-color": "#fbb03b",
+    "circle-stroke-color": "#FFFFFF",
+    "circle-stroke-width": 1,
+    "circle-stroke-opacity": 0.3
+  }
+}, {
+  id: "gl-draw-polygon-stroke-active",
+  type: "line",
+  filter: ["all", ["==", "$type", "Polygon"]],
+  layout: {
+    "line-cap": "round",
+    "line-join": "round"
+  },
+  paint: {
+    "line-color": "#D20C0C",
+    "line-dasharray": [0.2, 2],
+    "line-width": 2
+  }
+}, {
+  id: "gl-draw-polygon-and-line-vertex-active",
+  type: "circle",
+  filter: ["all", ["==", "meta", "vertex"], ["==", "$type", "Point"]],
+  paint: {
+    "circle-radius": 3,
+    "circle-color": "#D20C0C",
+    "circle-stroke-color": "#FFFFFF",
+    "circle-stroke-width": 3,
+    "circle-stroke-opacity": 0.3
+  }
+}];
+
+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 {
+    map,
+    draw: drawContext,
+    loaded,
+    basemapName
+  } = useMapContext();
+  useEffect(() => {
+    if (!loaded || !map.current) {
+      return;
+    }
+
+    drawContext.current = draw;
+    map.current.addControl(drawContext.current);
+  }, [loaded]); // eslint-disable-line
+
+  useEffect(() => {
+    if (map.current && map.current.hasControl(drawContext.current)) {
+      map.current.removeControl(drawContext.current);
+      map.current.addControl(drawContext.current);
+    }
+  }, [basemapName, ...triggerDeps]); // eslint-disable-line
+};
+
+const useRedrawLayer = () => {
+  const {
+    map
+  } = useMapContext();
+  return useCallback(layerName => {
+    const layerTileSource = map.current.getSource(layerName);
+    layerTileSource.setTiles(layerTileSource.tiles);
+  }, [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
+  } = useMapContext();
+  return useCallback((features, padding) => {
+    if (!features) {
+      return;
+    }
+
+    const currentFeatureCenter = bbox({
+      type: "FeatureCollection",
+      features: features.map(feature => convertSpToTurfFeature(feature.geometry))
+    });
+    map.current.fitBounds(currentFeatureCenter, {
+      padding: padding != null ? padding : 150
+    });
+  }, [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
+  } = useMapContext();
+  return useCallback((options, callback) => {
+    if (map.current) {
+      if (callback) {
+        map.current.once("moveend", () => {
+          callback();
+        });
+      }
+
+      map.current.flyTo(options);
+    } else {
+      callback == null || callback();
+    }
+  }, [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;
+
+(function (HorizontalPosition) {
+  HorizontalPosition["Left"] = "left";
+  HorizontalPosition["Right"] = "right";
+})(HorizontalPosition || (HorizontalPosition = {}));
+
+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;
+
+    let newWidth = width;
+    let newHeight = height;
+
+    if (horizontal && newWidth < minWidth) {
+      newWidth = minWidth;
+    }
+
+    if (horizontal && newWidth > Math.min(window.innerWidth - ((_horizontalHandleRef$ = horizontalHandleRef.current) == null ? void 0 : _horizontalHandleRef$.clientWidth), maxWidth)) {
+      newWidth = maxWidth;
+    }
+
+    if (vertical && newHeight < minHeight) {
+      newHeight = minHeight;
+    }
+
+    if (vertical && newHeight > Math.min(window.innerHeight - ((_verticalHandleRef$cu = verticalHandleRef.current) == null ? void 0 : _verticalHandleRef$cu.clientHeight), maxHeight)) {
+      newHeight = maxHeight;
+    }
+
+    if (horizontal) {
+      requestAnimationFrame(() => {
+        if (!isNil(containerRef.current)) {
+          containerRef.current.style.width = newWidth + "px";
+        }
+      });
+    }
+
+    if (vertical) {
+      requestAnimationFrame(() => {
+        if (!isNil(containerRef.current)) {
+          containerRef.current.style.height = newHeight + "px";
+        }
+      });
+    }
+
+    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);
+      }
+    };
+
+    if (!isNil(containerRef.current)) {
+      onResizeStart == null || onResizeStart(containerRef.current.offsetWidth, containerRef.current.offsetHeight);
+    }
+
+    document.body.addEventListener("pointermove", onPointerMove);
+    document.body.addEventListener("pointerup", onPointerUp, {
+      once: true
+    });
+  }, [onPointerMove]); // eslint-disable-line
+
+  useLayoutEffect(() => {
+    if (useResize && !isNil(containerRef.current)) {
+      updateSizes(containerRef.current.offsetWidth, containerRef.current.offsetHeight);
+    }
+  }, [updateSizes, useResize]);
+  return {
+    containerRef,
+    verticalHandleRef,
+    horizontalHandleRef,
+    onPointerDown
+  };
+};
+
+const useToggle = initial => {
+  const [state, setState] = useState(initial !== undefined ? initial : false);
+  const toggle = useCallback(() => setState(!state), [state]);
+  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 getGeometrySelectionTurfFeature = (coordinates, selectionType, toWgs) => {
+  if (toWgs) {
+    switch (selectionType) {
+      case GeometrySelectionTypes.Point:
+        return toWgs84(point(coordinates));
+
+      case GeometrySelectionTypes.Polygon:
+        return toWgs84(polygon(coordinates));
+
+      case GeometrySelectionTypes.Line:
+        return toWgs84(lineString(coordinates));
+    }
+  }
+
+  switch (selectionType) {
+    case GeometrySelectionTypes.Point:
+      return toMercator(point(coordinates));
+
+    case GeometrySelectionTypes.Polygon:
+      return toMercator(polygon(coordinates));
+
+    case GeometrySelectionTypes.Line:
+      return toMercator(lineString(coordinates));
+  }
+};
+
+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 };
 //# sourceMappingURL=react.esm.js.map