@m4l/components 9.1.125 → 9.1.126

package/components/maps/components/MapGpsTools/hooks/useLayers/index.d.ts

@@ -1,4 +0,0 @@
-/**
- * TODO: Documentar
- */
-export declare function useLayers(): void;

package/components/maps/components/MapGpsTools/hooks/useLayers/index.js

@@ -1,57 +0,0 @@
-import { useEffect } from "react";
-import { shallow } from "zustand/shallow";
-import { u as useMapGpsToolsStore } from "../useMapGpsToolsStore/index.js";
-import { C as CommonFeatureRender } from "../../../Map/featureRenders/CommonFeatureRender/index.js";
-import { G as GeofencesFeaturesLayers } from "../../subcomponents/TabsGpsTools/subcomponents/constants.js";
-import { u as useMapStore } from "../../../Map/hooks/useMapStore/index.js";
-function useLayers() {
-  const { addLayer, removeLayer } = useMapStore((state) => state.mapActions, shallow);
-  const { init } = useMapGpsToolsStore((state) => state.gpsToolsActions, shallow);
-  useEffect(() => {
-    addLayer({
-      layerId: GeofencesFeaturesLayers.LAYER_GEOFENCES,
-      name: "Geocercas",
-      renderFeature: CommonFeatureRender,
-      geoJsonObject: {
-        object: {
-          type: "FeatureCollection",
-          features: []
-        }
-      },
-      autoFocus: false
-    });
-    addLayer({
-      layerId: GeofencesFeaturesLayers.LAYER_GEOFENCES_TRANSIT_FEATURES,
-      name: "Geometrías de tránsito",
-      renderFeature: CommonFeatureRender,
-      geoJsonObject: {
-        object: {
-          type: "FeatureCollection",
-          features: []
-        }
-      },
-      autoFocus: false
-    });
-    addLayer({
-      layerId: GeofencesFeaturesLayers.LAYER_GEOFENCES_INTERNAL_FEATURES,
-      name: "Geometrías internas",
-      renderFeature: CommonFeatureRender,
-      geoJsonObject: {
-        object: {
-          type: "FeatureCollection",
-          features: []
-        }
-      },
-      autoFocus: false
-    });
-    init();
-    return () => {
-      removeLayer(GeofencesFeaturesLayers.LAYER_GEOFENCES);
-      removeLayer(GeofencesFeaturesLayers.LAYER_GEOFENCES_INTERNAL_FEATURES);
-      removeLayer(GeofencesFeaturesLayers.LAYER_GEOFENCES_TRANSIT_FEATURES);
-    };
-  }, []);
-}
-export {
-  useLayers as u
-};

package/components/maps/components/MapGpsTools/hooks/useMapGpsToolsStore/index.d.ts

@@ -1,5 +0,0 @@
-import { MapGpsToolsStateWithActions } from '../../contexts/MapGpsToolsContext/types';
-/**
- * TODO: Documentar
- */
-export declare function useMapGpsToolsStore<T>(selector: (state: MapGpsToolsStateWithActions) => T, equalityFn?: (left: T, right: T) => boolean): T;

package/components/maps/components/MapGpsTools/hooks/useMapGpsToolsStore/index.js

@@ -1,13 +0,0 @@
-import { useContext } from "react";
-import { useStore } from "zustand";
-import { M as MapGpsToolsContext } from "../../contexts/MapGpsToolsContext/index.js";
-function useMapGpsToolsStore(selector, equalityFn) {
-  const context = useContext(MapGpsToolsContext);
-  if (!context) {
-    throw new Error("useGpsToolsStore context must be use inside GpsToolsContext");
-  }
-  return useStore(context, selector, equalityFn);
-}
-export {
-  useMapGpsToolsStore as u
-};

package/components/maps/components/MapGpsTools/icons.d.ts

@@ -1,23 +0,0 @@
-export declare const MAP_GPSTOOLS_ICONS: {
-    /**
-     * GpsTools
-     */
-    MAP_GPS_TOOLS_TOOL: string;
-    GEOFENCES: string;
-    GEOFENCE_ID: string;
-    GEOFENCE_NAME: string;
-    GEOFENCE_ADD: string;
-    GEOFENCE_EDIT: string;
-    GEOFENCE_DELETE: string;
-    GENERAL: string;
-    DATA: string;
-    STYLE: string;
-    GEOFENCE_DRAW: string;
-    GEOFENCE_FINISH: string;
-    GEOFENCE_TYPE_CIRCLE: string;
-    GEOFENCE_TYPE_RECTANGLE: string;
-    GEOFENCE_TYPE_POLYGON: string;
-    CONFIG: string;
-    STROKE: string;
-    FILL: string;
-};

package/components/maps/components/MapGpsTools/icons.js

@@ -1,26 +0,0 @@
-const MAP_GPSTOOLS_ICONS = {
-  /**
-   * GpsTools
-   */
-  MAP_GPS_TOOLS_TOOL: "cmp_map_gpstools_tool.svg",
-  GEOFENCES: "cmp_map_gpstools_geofences.svg",
-  GEOFENCE_ID: "cmp_map_gpstools_geofence_id.svg",
-  GEOFENCE_NAME: "cmp_map_gpstools_geofence_name.svg",
-  GEOFENCE_ADD: "cmp_map_gpstools_add-geofence.svg",
-  GEOFENCE_EDIT: "cmp_map_gpstools_edit-geofence.svg",
-  GEOFENCE_DELETE: "cmp_map_gpstools_delete-geofence.svg",
-  GENERAL: "cmp_map_gpstools_general.svg",
-  DATA: "cmp_map_gpstools_data.svg",
-  STYLE: "cmp_map_gpstools_style.svg",
-  GEOFENCE_DRAW: "cmp_map_gpstools_draw.svg",
-  GEOFENCE_FINISH: "cmp_map_gpstools_finish.svg",
-  GEOFENCE_TYPE_CIRCLE: "cmp_map_gpstools_circle.svg",
-  GEOFENCE_TYPE_RECTANGLE: "cmp_map_gpstools_rectangle.svg",
-  GEOFENCE_TYPE_POLYGON: "cmp_map_gpstools_polygon.svg",
-  CONFIG: "cmp_map_gpstools_config.svg",
-  STROKE: "cmp_map_gpstools_stroke.svg",
-  FILL: "cmp_map_gpstools_fill.svg"
-};
-export {
-  MAP_GPSTOOLS_ICONS as M
-};

package/components/maps/components/MapGpsTools/index.d.ts

@@ -1,4 +0,0 @@
-export { MapGpsTools } from './MapGpsTools';
-export { MapGpsToolsProvider } from './contexts/MapGpsToolsContext';
-export { getMapGpsToolsComponentsDictionary } from './dictionary';
-export { useMapGpsToolsStore } from './hooks/useMapGpsToolsStore';

package/components/maps/components/MapGpsTools/styles.d.ts

@@ -1 +0,0 @@
-export declare const DivTabGpsToolsRoot: import('@emotion/styled').StyledComponent<import('@mui/system').MUIStyledCommonProps<import('@mui/material/styles').Theme>, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

package/components/maps/components/MapGpsTools/styles.js

@@ -1,18 +0,0 @@
-import { styled } from "@mui/material/styles";
-import { g as gpsToolsClasses } from "./classes/index.js";
-const DivTabGpsToolsRoot = styled("div")`
-  .${gpsToolsClasses.gpsToolsTabContent}.${gpsToolsClasses.hidden} {
-    display: none;
-  }
-  .${gpsToolsClasses.gpsToolsGeofencesList} .M4LDataGrid-root {
-    height: unset !important;
-    flex-grow: 1;
-  }
-  .${gpsToolsClasses.toolGeofencesAddEditGeneral} {
-    flex-grow: 1;
-  }
-  ${(props) => props.theme.components?.M4LMapGpsTools?.styleOverrides}
-`;
-export {
-  DivTabGpsToolsRoot as D
-};

package/components/maps/components/MapGpsTools/subcomponents/TabsGpsTools/index.d.ts

@@ -1,9 +0,0 @@
-/**
- * Componente que renderiza las herramientas de GPS a traves de los tabs
- * Funcionalidad:
- *  - Cuando se cambia el tab, se actualiza el subtitulo del popup
- *  - Los tabs no visible se ocultan a traves de css, para que no destruyan los componentes evitando
- *    la recargar de los mismos entre cambio de pestañas.
- * @returns Tabs con las herramientas de GPS
- */
-export declare function TabsGpsTools(): import("react/jsx-runtime").JSX.Element | null;

package/components/maps/components/MapGpsTools/subcomponents/TabsGpsTools/index.js

@@ -1,88 +0,0 @@
-import { jsx, jsxs } from "react/jsx-runtime";
-import { useMemo, useEffect } from "react";
-import { useModuleDictionary, useEnvironment } from "@m4l/core";
-import "leaflet";
-import { shallow } from "zustand/shallow";
-import "@geoman-io/leaflet-geoman-free/dist/leaflet-geoman.css";
-import "@geoman-io/leaflet-geoman-free";
-import clsx from "clsx";
-import { D as DivTabGpsToolsRoot } from "../../styles.js";
-import { T as Tab } from "../../../../../mui_extended/Tab/Tab.js";
-import { G as GeofencesList } from "./subcomponents/GeofencesList/index.js";
-import { u as useLayers } from "../../hooks/useLayers/index.js";
-import { M as MAP_GPSTOOLS_DICCTIONARY } from "../../dictionary.js";
-import { g as gpsToolsClasses } from "../../classes/index.js";
-import { M as MAP_GPSTOOLS_ICONS } from "../../icons.js";
-import { G as GPS_TOOLS_POPUP_ID } from "../../../Map/constants.js";
-import { u as useMapGpsToolsStore } from "../../hooks/useMapGpsToolsStore/index.js";
-import { u as usePopupsStore } from "../../../../../popups/components/PopupsProvider/hooks/usePopupsStore/index.js";
-import { T as Tabs } from "../../../../../mui_extended/Tabs/Tabs.js";
-import { T as TabContent } from "../../../../../mui_extended/TabContent/TabContent.js";
-import { I as Icon } from "../../../../../Icon/Icon.js";
-function TabsGpsTools() {
-  const { getLabel } = useModuleDictionary();
-  const { host_static_assets, environment_assets } = useEnvironment();
-  const status = useMapGpsToolsStore((state) => state.ownerState.status, shallow);
-  const currentTabTool = useMapGpsToolsStore((state) => state.currentTabGpsTool, shallow);
-  const { setCurrentTabTool } = useMapGpsToolsStore((state) => state.gpsToolsActions, shallow);
-  const { updatePopup } = usePopupsStore((state) => state.popupsActions, shallow);
-  const toolTabs = useMemo(() => {
-    return [
-      {
-        id: "geofences",
-        iconUrl: `${host_static_assets}/${environment_assets}/frontend/components/map_gpstools/assets/icons/${MAP_GPSTOOLS_ICONS.GEOFENCES}`,
-        component: /* @__PURE__ */ jsx(GeofencesList, {}),
-        label: getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_TAB_GEO),
-        className: gpsToolsClasses.gpsToolsGeofencesList
-      }
-    ];
-  }, [getLabel]);
-  useEffect(() => {
-    updatePopup(GPS_TOOLS_POPUP_ID, {
-      subTitle: currentTabTool === "geofences" ? getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_TAB_GEO) : ""
-    });
-  }, [currentTabTool]);
-  useLayers();
-  if (status !== "ready") {
-    return null;
-  }
-  return /* @__PURE__ */ jsxs(DivTabGpsToolsRoot, { className: gpsToolsClasses.gpsToolsRoot, children: [
-    /* @__PURE__ */ jsx(
-      Tabs,
-      {
-        value: currentTabTool,
-        scrollButtons: "auto",
-        variant: "scrollable",
-        allowScrollButtonsMobile: true,
-        onChange: (_e, value) => setCurrentTabTool(value),
-        children: toolTabs.map((tab) => /* @__PURE__ */ jsx(
-          Tab,
-          {
-            value: tab.id,
-            icon: /* @__PURE__ */ jsx(Icon, { src: tab.iconUrl }),
-            className: clsx(gpsToolsClasses.gpsToolsTab, tab.className)
-          },
-          tab.id
-        ))
-      }
-    ),
-    toolTabs.map((tab) => {
-      const isMatched = tab.id === currentTabTool;
-      return /* @__PURE__ */ jsx(
-        TabContent,
-        {
-          className: clsx(
-            gpsToolsClasses.gpsToolsTabContent,
-            tab.className,
-            isMatched ? gpsToolsClasses.visible : gpsToolsClasses.hidden
-          ),
-          children: tab.component
-        },
-        tab.id
-      );
-    })
-  ] });
-}
-export {
-  TabsGpsTools as T
-};

package/components/maps/components/MapGpsTools/subcomponents/TabsGpsTools/subcomponents/GeofenceAddEdit/constants.d.ts

@@ -1,20 +0,0 @@
-import { FormAddEditValues } from './types';
-export declare const STROKE_COLOR_DEFAULT = "#aaccaa";
-export declare const STROKE_OPACITY_DEFAULT: {
-    value: number;
-    label: string;
-};
-export declare const STROKE_WHEIGTH_DEFAULT: {
-    value: number;
-    label: string;
-};
-export declare const STROKE_DASH_ARRAY_DEFAULT: {
-    value: string;
-    label: string;
-};
-export declare const FILL_COLOR_DEFAULT = "#aa3000";
-export declare const FILL_OPACITY_DEFAULT: {
-    value: number;
-    label: string;
-};
-export declare const initialValues: FormAddEditValues;

package/components/maps/components/MapGpsTools/subcomponents/TabsGpsTools/subcomponents/GeofenceAddEdit/constants.js

@@ -1,40 +0,0 @@
-const STROKE_COLOR_DEFAULT = "#aaccaa";
-const STROKE_OPACITY_DEFAULT = { value: 1, label: "100%" };
-const STROKE_WHEIGTH_DEFAULT = { value: 1, label: "1 px" };
-const STROKE_DASH_ARRAY_DEFAULT = { value: "", label: "-----" };
-const FILL_COLOR_DEFAULT = "#aa3000";
-const FILL_OPACITY_DEFAULT = { value: 0.2, label: "20%" };
-const initialValues = {
-  /** General Data */
-  name: "",
-  geofenceType: null,
-  /** Config Data */
-  alias: null,
-  customerId: null,
-  timeMinInSeconds: 5,
-  timeMinOutSeconds: 5,
-  /** de Apoyo */
-  inEdition: false,
-  geometry: null,
-  lat: null,
-  lng: null,
-  properties: {
-    radius: null,
-    /** Style Data */
-    strokeColor: STROKE_COLOR_DEFAULT,
-    strokeOpacity: STROKE_OPACITY_DEFAULT,
-    strokeWeight: STROKE_WHEIGTH_DEFAULT,
-    strokeDashArray: STROKE_DASH_ARRAY_DEFAULT,
-    fillColor: FILL_COLOR_DEFAULT,
-    fillOpacity: FILL_OPACITY_DEFAULT
-  }
-};
-export {
-  FILL_COLOR_DEFAULT as F,
-  STROKE_COLOR_DEFAULT as S,
-  STROKE_OPACITY_DEFAULT as a,
-  STROKE_WHEIGTH_DEFAULT as b,
-  STROKE_DASH_ARRAY_DEFAULT as c,
-  FILL_OPACITY_DEFAULT as d,
-  initialValues as i
-};

package/components/maps/components/MapGpsTools/subcomponents/TabsGpsTools/subcomponents/GeofenceAddEdit/helpers.d.ts

@@ -1,34 +0,0 @@
-import { GeofenceGeometry, GeofenceGetModel, GeofenceTypeId } from '../model';
-import { FormAddEditValues } from './types';
-import * as L from 'leaflet';
-/**
- * TODO: Documentar
- */
-export declare const getFormStrokeOpacityFromData: (strokeOpacity?: number) => {
-    value: number;
-    label: string;
-};
-/**
- * TODO: Documentar
- */
-export declare const getFormStrokeWeightFromData: (strokeWeight?: number) => {
-    value: number;
-    label: string;
-};
-/**
- * TODO: Documentar
- */
-export declare const getFormstrokeDashArrayFromData: (strokeDashArray?: string) => {
-    value: string;
-    label: string;
-};
-/**
- * TODO: Documentar
- */
-export declare const formatDataEnpoint: (response: {
-    data: GeofenceGetModel;
-}) => FormAddEditValues;
-/**
- * TODO: Documentar
- */
-export declare const getLayerFromGeometry: (geometry: GeofenceGeometry | null, geofenceTypeId: GeofenceTypeId | null, radius: number | null, options?: L.PolylineOptions | L.CircleOptions) => L.Circle<any> | L.Polygon<any> | null;

package/components/maps/components/MapGpsTools/subcomponents/TabsGpsTools/subcomponents/GeofenceAddEdit/helpers.js

@@ -1,77 +0,0 @@
-import { i as initialValues, S as STROKE_COLOR_DEFAULT, a as STROKE_OPACITY_DEFAULT, b as STROKE_WHEIGTH_DEFAULT, c as STROKE_DASH_ARRAY_DEFAULT, F as FILL_COLOR_DEFAULT, d as FILL_OPACITY_DEFAULT } from "./constants.js";
-import * as L from "leaflet";
-const formatDataEnpoint = (response) => {
-  try {
-    const { data } = response;
-    const obRet = {
-      ...initialValues,
-      inEdition: false,
-      name: data.name,
-      geometry: data.geometry,
-      geofenceType: { id: data.type.id, name: data.type.name, url: "" },
-      properties: {
-        strokeColor: data.properties.strokeColor || STROKE_COLOR_DEFAULT,
-        strokeOpacity: STROKE_OPACITY_DEFAULT,
-        //getFormStrokeOpacityFromData(data.properties.strokeOpacity),
-        strokeWeight: STROKE_WHEIGTH_DEFAULT,
-        //,getFormStrokeWeightFromData(data.properties.strokeWeight) ,
-        strokeDashArray: STROKE_DASH_ARRAY_DEFAULT,
-        // getFormstrokeDashArrayFromData(data.properties.strokeDashArray) ,
-        fillColor: data.properties.fillColor || FILL_COLOR_DEFAULT,
-        fillOpacity: FILL_OPACITY_DEFAULT
-        //data.properties.fillOpacity || FILL_OPACITY_DEFAULT,
-      }
-    };
-    if (obRet.geofenceType?.id === "gt_circle") {
-      if (data.properties.radius) {
-        obRet.properties.radius = data.properties.radius;
-      }
-      if (data.geometry && data.geometry.type === "Point") {
-        obRet.lng = data.geometry.coordinates[0];
-        obRet.lat = data.geometry.coordinates[1];
-      }
-    }
-    return obRet;
-  } catch (_e) {
-    return { ...initialValues };
-  }
-};
-const getLayerFromGeometry = (geometry, geofenceTypeId, radius, options) => {
-  if (geometry) {
-    if (geofenceTypeId === "gt_circle" && geometry.type === "Point") {
-      return L.circle([geometry.coordinates[1], geometry.coordinates[0]], {
-        ...options,
-        radius: radius || 0
-      });
-    } else if (geofenceTypeId === "gt_polygon" && geometry.type === "Polygon") {
-      const coordinates = geometry.coordinates.map(
-        (ring) => ring.map((position) => [position[1], position[0]])
-      );
-      return L.polygon(coordinates, options);
-    } else if (geofenceTypeId === "gt_rectangle" && geometry.type === "Polygon") {
-      const latLngs = geometry.coordinates[0].map(
-        (coord) => [coord[1], coord[0]]
-      );
-      const lats = latLngs.map((coord) => {
-        if (Array.isArray(coord)) {
-          return coord[0];
-        }
-        return 0;
-      });
-      const lngs = latLngs.map((coord) => {
-        if (Array.isArray(coord)) {
-          return coord[1];
-        }
-        return 0;
-      });
-      const southWest = [Math.min(...lats), Math.min(...lngs)];
-      const northEast = [Math.max(...lats), Math.max(...lngs)];
-      return L.rectangle([southWest, northEast], options);
-    }
-  }
-  return null;
-};
-export {
-  formatDataEnpoint as f,
-  getLayerFromGeometry as g
-};

package/components/maps/components/MapGpsTools/subcomponents/TabsGpsTools/subcomponents/GeofenceAddEdit/hooks/useDrawing.d.ts

@@ -1,14 +0,0 @@
-/**
- * hook Encargado manejar los eventos de dibujo y setear en hook forms values,
- * los datos asociados a una geocerca
- * @returns
- */
-/**
- * TODO: Documentar
- */
-export declare function useDrawing(): {
-    inEdition: boolean;
-    handleDraw: () => void;
-    handleFinish: () => void;
-    geometrTypeIdCached: "gt_polygon" | "gt_circle" | "gt_rectangle" | null;
-};

package/components/maps/components/MapGpsTools/subcomponents/TabsGpsTools/subcomponents/GeofenceAddEdit/hooks/useDrawing.js

@@ -1,216 +0,0 @@
-import { useState, useRef, useEffect, useCallback } from "react";
-import { useFormContext, useWatch } from "react-hook-form";
-import { useModuleDictionary } from "@m4l/core";
-import { useMap } from "react-leaflet";
-import { g as getLayerFromGeometry } from "../helpers.js";
-import { u as useFormReadyForUpdate } from "../../../../../../../../../hooks/useFormReadyForUpdate/index.js";
-import { M as MAP_GPSTOOLS_DICCTIONARY } from "../../../../../dictionary.js";
-function useDrawing() {
-  const { getLabel } = useModuleDictionary();
-  const readyToUpdate = useFormReadyForUpdate();
-  const map = useMap();
-  const { control, setValue } = useFormContext();
-  const fieldsWatch = useWatch({
-    control,
-    name: [
-      "geofenceType",
-      "inEdition",
-      "properties.strokeColor",
-      "properties.strokeOpacity",
-      "properties.strokeWeight",
-      "properties.strokeDashArray",
-      "properties.fillColor",
-      "properties.fillOpacity",
-      "geometry",
-      "properties.radius"
-    ]
-  });
-  const geofenceTypeId = fieldsWatch[0]?.id;
-  const inEdition = fieldsWatch[1];
-  const strokeColor = fieldsWatch[2];
-  const strokeOpacity = fieldsWatch[3].value;
-  const strokeWeight = fieldsWatch[4].value;
-  const strokeDashArray = fieldsWatch[5].value;
-  const fillColor = fieldsWatch[6];
-  const fillOpacity = fieldsWatch[7].value;
-  const geometry = fieldsWatch[8];
-  const radius = fieldsWatch[9];
-  const [drawing, setDrawing] = useState(false);
-  const currentLayer = useRef(null);
-  const [geometrTypeIdCached, setgeofenceTypeIdCached] = useState(geofenceTypeId);
-  useEffect(() => {
-    if (geometry) {
-      currentLayer.current = getLayerFromGeometry(geometry, geofenceTypeId, radius, {
-        color: strokeColor,
-        opacity: strokeOpacity,
-        weight: strokeWeight,
-        dashArray: strokeDashArray,
-        fillColor,
-        fillOpacity
-      });
-      if (currentLayer.current) {
-        map.addLayer(currentLayer.current);
-        map.fitBounds(currentLayer.current.getBounds());
-      }
-    }
-    return () => {
-      if (currentLayer.current) {
-        currentLayer.current.remove();
-      }
-    };
-  }, [map]);
-  useEffect(() => {
-    if (currentLayer.current) {
-      currentLayer.current.setStyle({
-        color: strokeColor,
-        opacity: strokeOpacity,
-        weight: strokeWeight,
-        dashArray: strokeDashArray,
-        fillColor,
-        fillOpacity
-      });
-    }
-  }, [strokeColor, strokeOpacity, strokeWeight, strokeDashArray, fillColor, fillOpacity]);
-  useEffect(() => {
-    map.pm.setLang("en", {
-      tooltips: {
-        placeMarker: void 0,
-        firstVertex: getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_FIRST_VERTEX),
-        continueLine: getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_CONTINUE_LINE),
-        finishLine: getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_FINISH_LINE),
-        finishPoly: getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_FINISH_POLY),
-        finishRect: getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_FINISH_RECT),
-        startCircle: getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_START_CIRCLE),
-        finishCircle: getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_FINISH_CIRCLE),
-        placeCircleMarker: getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_PLACE_CIRCLE_MARKER)
-      }
-    });
-  }, [map, getLabel]);
-  useEffect(() => {
-    if (map) {
-      let shape = "Circle";
-      if (geometrTypeIdCached === "gt_polygon") {
-        shape = "Polygon";
-      } else if (geometrTypeIdCached === "gt_rectangle") {
-        shape = "Rectangle";
-      }
-      if (drawing) {
-        if (!currentLayer.current) {
-          setValue("inEdition", true);
-          if (shape === "Circle") {
-            map.on("pm:drawstart", ({ workingLayer }) => {
-              workingLayer.on("pm:centerplaced", (e) => {
-                const layer = e.workingLayer;
-                layer.setStyle({
-                  color: strokeColor,
-                  opacity: strokeOpacity,
-                  weight: strokeWeight,
-                  dashArray: strokeDashArray,
-                  fillColor,
-                  fillOpacity
-                });
-                setValue("lat", Number(layer.getLatLng().lat.toFixed(8)));
-                setValue("lng", Number(layer.getLatLng().lng.toFixed(8)));
-                layer.on("pm:change", (_e) => {
-                  setValue("properties.radius", Number(layer.getRadius().toFixed(1)));
-                });
-              });
-            });
-            setValue("properties.subType", shape);
-          } else if (shape === "Polygon") {
-            map.on("pm:drawstart", ({ workingLayer }) => {
-              workingLayer.on("pm:vertexadded", (e) => {
-                const layer = e.workingLayer;
-                layer.setStyle({
-                  color: strokeColor,
-                  opacity: strokeOpacity,
-                  weight: strokeWeight,
-                  dashArray: strokeDashArray,
-                  fillColor,
-                  fillOpacity
-                });
-              });
-            });
-          }
-          map.pm.enableDraw(shape);
-          map.pm.setPathOptions({
-            color: strokeColor,
-            opacity: strokeOpacity,
-            weight: strokeWeight,
-            dashArray: strokeDashArray,
-            fillColor,
-            fillOpacity
-          });
-          map.on("pm:create", (e) => {
-            currentLayer.current = e.layer;
-            setValue("geometry", currentLayer.current.toGeoJSON()?.geometry, {
-              shouldTouch: false,
-              shouldValidate: true
-            });
-            setValue("inEdition", false);
-            setDrawing(false);
-          });
-        } else {
-          currentLayer.current.pm.enable();
-          setValue("inEdition", true);
-          currentLayer.current.on("pm:disable", (e) => {
-            currentLayer.current = e.layer;
-            setValue("geometry", currentLayer.current.toGeoJSON()?.geometry, {
-              shouldTouch: false,
-              shouldValidate: true
-            });
-            setValue("inEdition", false);
-            setDrawing(false);
-          });
-          if (shape === "Circle") {
-            currentLayer.current.on("pm:change", (e) => {
-              currentLayer.current = e.layer;
-              setValue("lat", Number(currentLayer.current.getLatLng().lat.toFixed(8)));
-              setValue("lng", Number(currentLayer.current.getLatLng().lng.toFixed(8)));
-              setValue("properties.radius", currentLayer.current.getRadius());
-              setValue("properties.radius", Number(currentLayer.current.getRadius().toFixed(1)));
-            });
-          }
-        }
-      } else {
-        map.pm.disableDraw("Polygon");
-        map.off("pm:create");
-        map.off("pm:edit");
-        map.off("pm:drawstart");
-      }
-    }
-  }, [map, drawing]);
-  const handleDraw = useCallback(() => {
-    setDrawing(true);
-  }, []);
-  const handleFinish = useCallback(() => {
-    if (currentLayer.current) {
-      currentLayer.current.pm.disable();
-      currentLayer.current.setStyle({ color: "#ff0000", fillColor: "#ff0000" });
-    }
-  }, []);
-  useEffect(() => {
-    if (!readyToUpdate) {
-      return;
-    }
-    if (geofenceTypeId) {
-      if (geofenceTypeId !== geometrTypeIdCached) {
-        setgeofenceTypeIdCached(geofenceTypeId);
-        if (geometrTypeIdCached !== "gt_circle") {
-          setValue("properties.radius", null);
-          setValue("lat", null);
-          setValue("lng", null);
-        }
-        setValue("geometry", null);
-        if (currentLayer.current) {
-          currentLayer.current.remove();
-          currentLayer.current = null;
-        }
-      }
-    }
-  }, [geofenceTypeId]);
-  return { inEdition, handleDraw, handleFinish, geometrTypeIdCached };
-}
-export {
-  useDrawing as u
-};