@m4l/components 3.1.7 → 3.1.8

package/components/maps/components/GpsTools/index-5MXlhIEt.js

@@ -1,1948 +0,0 @@
-import { jsx, jsxs, Fragment } from "react/jsx-runtime";
-import { useEnvironment, useModuleDictionary, useHostTools, useNetwork, useModulePrivileges, usePaginate, useModuleSkeleton } from "@m4l/core";
-import { useState, useMemo, useCallback, useRef, useEffect, createContext, useContext } from "react";
-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 { au as RHFormProviderStyled, av as StackGeofenceListRoot, aw as DivTabGpsToolsRoot } from "../../../../styles/index-DKj6m8SL.js";
-import { D as DynamicFilter } from "../../../DynamicFilter/index-DZiJc9h7.js";
-import { C as ColumnIconFormatter } from "../../../DataGrid/formatters/index-CrZXPa0e.js";
-import { C as ColumnDateFormatter } from "../../../DataGrid/formatters/ColumnDateFormatter/index-CKg8CJ6A.js";
-import { useResponsiveDesktop, useFirstRender } from "@m4l/graphics";
-import { useFormContext, useWatch, useFormState } from "react-hook-form";
-import { H as HelperError } from "../../../hook-form/HelperError/index-BVnmUazV.js";
-import { u as useModal } from "../../../../hooks/useModal/index-BJSQOX3U.js";
-import { u as usePopupsStore } from "../../../popups/PopupsProvider/index-DhSxmtfJ.js";
-import { createStore, useStore } from "zustand";
-import { devtools } from "zustand/middleware";
-import { immer } from "zustand/middleware/immer";
-import { enableMapSet } from "immer";
-import { A as ActionFormIntro } from "../../../CommonActions/components/ActionFormIntro/index-7KKtcUra.js";
-import { W as WindowConfirm } from "../../../modal/WindowConfirm-u6vAMFo7.js";
-import { A as Actions } from "../../../CommonActions/components/Actions/index-CuG1pnXW.js";
-import { B as Button } from "../../../mui_extended/Button/index-CGfZbaea.js";
-import { useMap } from "react-leaflet";
-import * as L from "leaflet";
-import { u as useFormReadyForUpdate } from "../../../../hooks/useFormReadyForUpdate/index-B3HygFCM.js";
-import { u as useTab } from "../../../../hooks/useTab/index-B_GEQFOP.js";
-import { generateUtilityClasses } from "@mui/material";
-import "@mui/base";
-import { P as PaperForm } from "../../../PaperForm/index-DwgAfjci.js";
-import { R as RHFAutocomplete } from "../../../hook-form/RHFAutocomplete/index-BtPL16HR.js";
-import { R as RHFTextField } from "../../../hook-form/RHFTextField/index-B6ufruSB.js";
-import { S as Stack } from "../../../mui_extended/Stack/index-DzEeCYfp.js";
-import { I as IconButton } from "../../../mui_extended/IconButton/index-CusYFjie.js";
-import { P as PropertyValue } from "../../../PropertyValue/index-Bh-Jnrte.js";
-import { R as RHFColorPicker } from "../../../hook-form/RHFColorPicker/index-Cxxb5Wa_.js";
-import { T as Tabs, a as Tab, b as TabContent, c as TabProvider } from "../../../mui_extended/Tab/index-Bu3dPidV.js";
-import { I as Icon } from "../../../Icon/index-C89MAkeH.js";
-import * as Yup from "yup";
-import { u as useFormAddEdit } from "../../../../hooks/useFormAddEdit/index-D9oSjUn1.js";
-import { u as useMapStore, C as CommonFeatureRender, G as GPS_TOOLS_POPUP_ID } from "../Map/index-2Lx5ARXa.js";
-import { D as DataGrid } from "../../../DataGrid/index-BZ-lbmuU.js";
-const COMPONENT_CLASS_NAME = "M4LMapGpsTools";
-const COMPONENT_MAP_TOOLS_ID = "gps_tools";
-const STYLE_OPACITIES = [
-  {
-    value: 0,
-    label: "0%"
-  },
-  {
-    value: 0.1,
-    label: "10%"
-  },
-  {
-    value: 0.2,
-    label: "20%"
-  },
-  {
-    value: 0.3,
-    label: "30%"
-  },
-  {
-    value: 0.4,
-    label: "40%"
-  },
-  {
-    value: 0.5,
-    label: "50%"
-  },
-  {
-    value: 1,
-    label: "100%"
-  }
-];
-const STYLE_WHEIGHTS = [
-  {
-    value: 0,
-    label: "0px"
-  },
-  {
-    value: 1,
-    label: "1px"
-  },
-  {
-    value: 2,
-    label: "2px"
-  },
-  {
-    value: 3,
-    label: "3px"
-  },
-  {
-    value: 4,
-    label: "4px"
-  }
-];
-const STYLE_PATTERNS = [
-  {
-    value: "",
-    label: "------"
-  },
-  {
-    value: "4 1 2",
-    label: "-- - - --"
-  }
-];
-const gpsToolsClasses = generateUtilityClasses(COMPONENT_CLASS_NAME, [
-  /* elements */
-  "gpsToolsRoot",
-  "gpsToolsTab",
-  "gpsToolsTabContent",
-  "gpsToolsGeofencesList",
-  "gpsToolsGeofencesAddEdit",
-  "gpsToolsGeofencesAddEditContent",
-  "gpsToolsGeofencesAddEditDrawFinishContainer",
-  "toolGeofencesAddEditGeneral",
-  "toolGeofencesAddEditStyle",
-  /* states or variants of elements */
-  "visible",
-  "hidden"
-]);
-const MAP_GPSTOOLS_DICCTIONARY = {
-  /**
-   * GPSTools
-   */
-  LABEL_GPSTOOLS_NAME: "label_gpstools_name",
-  /** Common */
-  /** GeofenceList */
-  ACTION_GEOFENCE_ADD: "action_geofence_add",
-  ACTION_GEOFENCE_EDIT: "action_geofence_edit",
-  // Row Actions
-  ROW_ACTION_GEO_EDIT: "row_action_geo_edit",
-  ROW_ACTION_GEO_ENABLE: "row_action_geo_enable",
-  ROW_ACTION_GEO_DISABLE: "row_action_geo_disable",
-  ROW_ACTION_GEO_DELETE: "row_action_geo_delete",
-  /** GeofenceAddEdit */
-  LABEL_TAB_GEO: "label_tab_geo",
-  TAB_GENERAL_CONFIG_TOOLTIP: "tab_general_config_tooltip",
-  PAPER_GENERAL: "paper_general",
-  LABEL_ID: "label_id",
-  LABEL_NAME: "label_name",
-  LABEL_GEOMETRY_TYPE: "label_geometry_type",
-  LABEL_GEOMETRY_CIRCLE: "label_geometry_circle",
-  LABEL_GEOMETRY_RECTANGLE: "label_geometry_rectangle",
-  LABEL_GEOMETRY_POLYGON: "label_geometry_polygon",
-  LABEL_DRAW: "label_draw",
-  LABEL_FINISH: "label_finish",
-  PAPER_CONFIG: "paper_config",
-  LABEL_ALIAS: "label_alias",
-  LABEL_CUSTOMER_ID: "label_customer_id",
-  LABEL_TIME_MIN_IN_SECONDS: "label_time_min_in_seconds",
-  LABEL_TIME_MIN_OUT_SECONDS: "label_time_min_out_seconds",
-  TAB_STYLE_CONFIG_TOOLTIP: "tab_style_tooltip",
-  PAPER_STROKE: "paper_stroke",
-  LABEL_COLOR: "label_color",
-  LABEL_OPACITY: "label_opacity",
-  LABEL_WEIGHT: "label_weight",
-  LABEL_DASH_ARRAY: "label_dash_array",
-  LABEL_DASH_OFFSET: "label_dash_offset",
-  PAPER_FILL: "paper_fill",
-  LABEL_RADIUS: "label_radius",
-  LABEL_LAT: "label_lat",
-  LABEL_LON: "label_lon",
-  LABEL_PLACE_MARKER: "label_place_marker",
-  LABEL_FIRST_VERTEX: "label_first_vertex",
-  LABEL_CONTINUE_LINE: "label_continue_line",
-  LABEL_FINISH_LINE: "label_finish_line",
-  LABEL_FINISH_POLY: "label_finish_poly",
-  LABEL_FINISH_RECT: "label_finish_rect",
-  LABEL_START_CIRCLE: "label_start_circle",
-  LABEL_FINISH_CIRCLE: "label_finish_circle",
-  LABEL_PLACE_CIRCLE_MARKER: "label_place_circle_marker",
-  VALIDATION_GEOMETRY_REQUIRED: "validation_geometry_required",
-  VALIDATION_FIELD_REQUIRED: "validation_field_required",
-  VALIDATION_FIELD_TYPE_NUMBER_ERROR: "validation_field_type_number_error",
-  VALIDATION_FIELD_MIN_NUMBER_ERROR: "validation_field_min_number_error",
-  LABEL_VIEW_TRANSIT_FEATURES: "label_view_crossing_features",
-  LABEL_VIEW_INTERNAL_FEATURES: "label_view_internal_features",
-  LABEL_CREATED_AT: "label_created_at",
-  LABEL_UPDATED_AT: "label_updated_at",
-  MODAL_DELETE_GEO_TITLE: "modal_delete_geo_title",
-  MODAL_DELETE_GEO_MESSAGE: "modal_delete_geo_message",
-  MODAL_DISABLE_GEO_TITLE: "modal_disable_geo_title",
-  MODAL_DISABLE_MESSAGE: "modal_disable_geo_message",
-  ACTION_CANCEL: "action_cancel"
-};
-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"
-};
-function Filter(props) {
-  const { refresh, setBackendQueryParams } = props;
-  const { host_static_assets, environment_assets } = useEnvironment();
-  const [initialFilter] = useState(() => {
-    return [];
-  });
-  const onChangeFilter = (_initialFilters, rawFilters) => {
-    setBackendQueryParams({
-      f: rawFilters
-    });
-    refresh();
-  };
-  return /* @__PURE__ */ jsx(
-    DynamicFilter,
-    {
-      withAllField: true,
-      onChangeFilters: onChangeFilter,
-      fields: [
-        {
-          name: "id",
-          dictionaryId: MAP_GPSTOOLS_DICCTIONARY.LABEL_ID,
-          type: "number",
-          multiple: true,
-          presence: "optional",
-          urlIcon: `${host_static_assets}/${environment_assets}/components/${COMPONENT_MAP_TOOLS_ID}/assets/icons/${MAP_GPSTOOLS_ICONS.GEOFENCE_ID}`
-        },
-        {
-          name: "name",
-          dictionaryId: MAP_GPSTOOLS_DICCTIONARY.LABEL_NAME,
-          type: "string",
-          multiple: true,
-          presence: "optional",
-          urlIcon: `${host_static_assets}/${environment_assets}/components/${COMPONENT_MAP_TOOLS_ID}/assets/icons/${MAP_GPSTOOLS_ICONS.GEOFENCE_NAME}`
-        }
-      ],
-      initialAppliedFilters: initialFilter
-    }
-  );
-}
-function useColumns(_props) {
-  const { getLabel } = useModuleDictionary();
-  const { host_static_assets, environment_assets } = useEnvironment();
-  const columns = useMemo(
-    () => [
-      {
-        key: "id",
-        name: getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_ID),
-        type: "number",
-        width: 40,
-        visible: false
-      },
-      {
-        key: "geometry",
-        name: "",
-        type: "string",
-        formatter: ColumnIconFormatter({
-          getIconUrl: (formatterRowProps) => {
-            const { row } = formatterRowProps;
-            let iconUrl;
-            if (row.type.id === "gt_polygon") {
-              iconUrl = MAP_GPSTOOLS_ICONS.GEOFENCE_TYPE_POLYGON;
-            } else if (row.type.id === "gt_circle") {
-              iconUrl = MAP_GPSTOOLS_ICONS.GEOFENCE_TYPE_CIRCLE;
-            } else {
-              iconUrl = MAP_GPSTOOLS_ICONS.GEOFENCE_TYPE_RECTANGLE;
-            }
-            return {
-              iconUrl: `${host_static_assets}/${environment_assets}/frontend/components/map_gpstools/assets/icons/${iconUrl}`
-            };
-          }
-        }),
-        width: 30,
-        minWidth: 25
-      },
-      {
-        key: "name",
-        name: getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_NAME),
-        type: "string",
-        width: 220
-      },
-      // {
-      //     key: 'checkedCrossingFeatures',
-      //     name: getLabel(DICCTIONARY.LABEL_VIEW_TRANSIT_FEATURES),
-      //     width: 32,
-      //     type: 'boolean',
-      //     // frozen: true,
-      //     // isDraggable: false,
-      //     formatter: ColumnSetCheckFormatter({
-      //         field: 'CrossingFeatures',
-      //         rowKeyGetter,
-      //         useHook,
-      //     }),
-      //     cellClass: 'rdg-cell-align-center',
-      // },
-      // {
-      //     key: 'checkedInternalFeatures',
-      //     name: getLabel(DICCTIONARY.LABEL_VIEW_INTERNAL_FEATURES),
-      //     width: 32,
-      //     type: 'boolean',
-      //     // isDraggable: false,
-      //     // frozen: true,
-      //     formatter: ColumnSetCheckFormatter({
-      //         field: 'InternalFeatures',
-      //         rowKeyGetter,
-      //         useHook,
-      //     }),
-      //     cellClass: 'rdg-cell-align-center',
-      // },
-      {
-        key: "created_at",
-        name: getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_CREATED_AT),
-        type: "date",
-        formatter: ColumnDateFormatter({
-          presentationType: "datetime",
-          fieldValue: "row.created_at"
-        }),
-        visible: false
-      },
-      {
-        key: "updated_at",
-        name: getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_UPDATED_AT),
-        type: "date",
-        formatter: ColumnDateFormatter({
-          presentationType: "datetime",
-          fieldValue: "row.updated_at"
-        }),
-        visible: false
-      }
-    ],
-    [getLabel]
-  );
-  return { columns };
-}
-function MyActions(props) {
-  const { geofenceId } = props;
-  const { control } = useFormContext();
-  const { getLabel } = useModuleDictionary();
-  const { openModal } = useModal();
-  const inEdition = useWatch({
-    control,
-    name: "inEdition"
-  });
-  const { isDirty } = useFormState({
-    control
-  });
-  const { closePopup, showPopup } = usePopupsStore((state) => state.popupsActions);
-  const { addCheckedGeofence } = useGpsToolsStore((state) => state.geofenceActions);
-  const onClickCancelLocal = useCallback(() => {
-    if (isDirty) {
-      openModal({
-        window: /* @__PURE__ */ jsx(
-          WindowConfirm,
-          {
-            variant: "warning",
-            title: getLabel("common_actions.confirm_quit_title"),
-            msg: getLabel("common_actions.confirm_quit_msg"),
-            onClickIntro: onConfirmQuit
-          }
-        ),
-        variant: "warning"
-      });
-    } else {
-      onConfirmQuit();
-    }
-  }, [getLabel, isDirty, openModal]);
-  const onConfirmQuit = () => {
-    closePopup("geofencesAddEdit");
-    if (geofenceId !== void 0) {
-      addCheckedGeofence(geofenceId);
-    }
-    showPopup("gpsTools");
-  };
-  return /* @__PURE__ */ jsxs(Actions, { children: [
-    /* @__PURE__ */ jsx(HelperError, { name: "geometry" }),
-    /* @__PURE__ */ jsx(Button, { onClick: onClickCancelLocal, disabled: inEdition, children: getLabel(MAP_GPSTOOLS_DICCTIONARY.ACTION_CANCEL) }),
-    /* @__PURE__ */ jsx(ActionFormIntro, { disabled: inEdition })
-  ] });
-}
-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
-  }
-};
-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 (error) {
-    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;
-};
-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 };
-}
-function useSumbitErrorsFocus() {
-  const {
-    setFocus,
-    formState: { isSubmitted, errors }
-  } = useFormContext();
-  const { handleChange } = useTab();
-  useEffect(() => {
-    if (isSubmitted) {
-      const firstError = Object.keys(errors).reduce((field, a) => {
-        const fieldKey = field;
-        return errors[fieldKey] ? fieldKey : a;
-      }, null);
-      if (firstError) {
-        const found = [
-          "name",
-          "geometry",
-          "geofenceType",
-          "timeMinInSeconds",
-          "timeMinOutSeconds"
-        ].some((field) => field.includes(firstError));
-        if (found) {
-          handleChange(null, "general");
-        }
-        if (firstError) {
-          setFocus(firstError);
-        }
-      }
-    }
-  }, [isSubmitted, errors]);
-}
-function GeneralData() {
-  const { getLabel } = useModuleDictionary();
-  const { host_static_assets, environment_assets } = useEnvironment();
-  const { inEdition, handleDraw, handleFinish, geometrTypeIdCached } = useDrawing();
-  useSumbitErrorsFocus();
-  const urlIcon = `${host_static_assets}/${environment_assets}/frontend/components/map_gpstools/assets/icons/${MAP_GPSTOOLS_ICONS.GENERAL}`;
-  const geofencesTypes = useMemo(() => {
-    return [
-      {
-        id: "gt_circle",
-        name: getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_GEOMETRY_CIRCLE),
-        url: `${host_static_assets}/${environment_assets}/frontend/components/map_gpstools/assets/icons/${MAP_GPSTOOLS_ICONS.GEOFENCE_TYPE_CIRCLE}`
-      },
-      {
-        id: "gt_polygon",
-        name: getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_GEOMETRY_POLYGON),
-        url: `${host_static_assets}/${environment_assets}/frontend/components/map_gpstools/assets/icons/${MAP_GPSTOOLS_ICONS.GEOFENCE_TYPE_POLYGON}`
-      },
-      {
-        id: "gt_rectangle",
-        name: getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_GEOMETRY_RECTANGLE),
-        url: `${host_static_assets}/${environment_assets}/frontend/components/map_gpstools/assets/icons/${MAP_GPSTOOLS_ICONS.GEOFENCE_TYPE_RECTANGLE}`
-      }
-    ];
-  }, [getLabel]);
-  return /* @__PURE__ */ jsxs(PaperForm, { urlIcon, title: getLabel(MAP_GPSTOOLS_DICCTIONARY.PAPER_GENERAL), children: [
-    /* @__PURE__ */ jsx(
-      RHFTextField,
-      {
-        name: "name",
-        disabled: false,
-        type: "text",
-        label: getLabel(`${MAP_GPSTOOLS_DICCTIONARY.LABEL_NAME}`)
-      }
-    ),
-    /* @__PURE__ */ jsxs(Stack, { direction: "column", spacing: 1, alignItems: "center", children: [
-      /* @__PURE__ */ jsxs(Stack, { direction: "row", spacing: 1, alignItems: "center", children: [
-        /* @__PURE__ */ jsx(
-          RHFAutocomplete,
-          {
-            type: "image",
-            name: "geofenceType",
-            autoComplete: "off",
-            options: geofencesTypes,
-            getOptionLabel: (option) => option.name,
-            isOptionEqualToValue: (option, value) => option.id === value.id,
-            getOptionUrlImage: (option) => option.url,
-            label: getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_GEOMETRY_TYPE)
-          }
-        ),
-        /* @__PURE__ */ jsxs(
-          Stack,
-          {
-            className: gpsToolsClasses.gpsToolsGeofencesAddEditDrawFinishContainer,
-            direction: "row",
-            gap: 1,
-            alignItems: "center",
-            children: [
-              /* @__PURE__ */ jsx(
-                IconButton,
-                {
-                  src: `${host_static_assets}/${environment_assets}/frontend/components/map_gpstools/assets/icons/${MAP_GPSTOOLS_ICONS.GEOFENCE_DRAW}`,
-                  variant: "primary",
-                  onClick: handleDraw,
-                  disabled: inEdition || !geometrTypeIdCached,
-                  tooltip: getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_DRAW)
-                }
-              ),
-              /* @__PURE__ */ jsx(
-                IconButton,
-                {
-                  src: `${host_static_assets}/${environment_assets}/frontend/components/map_gpstools/assets/icons/${MAP_GPSTOOLS_ICONS.GEOFENCE_FINISH}`,
-                  variant: "primary",
-                  onClick: handleFinish,
-                  disabled: !inEdition,
-                  tooltip: getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_FINISH)
-                }
-              )
-            ]
-          }
-        )
-      ] }),
-      geometrTypeIdCached && geometrTypeIdCached === "gt_circle" && // <HelperText variant='info' message={'undefined'} />
-      /* @__PURE__ */ jsxs(Stack, { direction: "row", spacing: 1, alignItems: "center", children: [
-        /* @__PURE__ */ jsx(
-          RHFTextField,
-          {
-            name: "properties.radius",
-            label: getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_RADIUS),
-            autoComplete: "off",
-            skeletonWidth: "70%",
-            skeletonHeight: "18px",
-            disabled: true,
-            size: "small"
-          }
-        ),
-        /* @__PURE__ */ jsx(
-          RHFTextField,
-          {
-            name: "lat",
-            label: getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_LAT),
-            autoComplete: "off",
-            skeletonWidth: "70%",
-            skeletonHeight: "18px",
-            disabled: true,
-            size: "small"
-          }
-        ),
-        /* @__PURE__ */ jsx(
-          RHFTextField,
-          {
-            name: "lng",
-            label: getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_LON),
-            autoComplete: "off",
-            skeletonWidth: "70%",
-            skeletonHeight: "18px",
-            disabled: true,
-            size: "small"
-          }
-        )
-      ] })
-    ] })
-  ] });
-}
-function ConfigData() {
-  const { getLabel } = useModuleDictionary();
-  const { host_static_assets, environment_assets } = useEnvironment();
-  const urlIcon = `${host_static_assets}/${environment_assets}/frontend/components/map_gpstools/assets/icons/${MAP_GPSTOOLS_ICONS.CONFIG}`;
-  return /* @__PURE__ */ jsxs(PaperForm, { urlIcon, title: getLabel(MAP_GPSTOOLS_DICCTIONARY.PAPER_CONFIG), children: [
-    /* @__PURE__ */ jsx(
-      RHFTextField,
-      {
-        name: "alias",
-        disabled: false,
-        type: "text",
-        label: getLabel(`${MAP_GPSTOOLS_DICCTIONARY.LABEL_ALIAS}`)
-      }
-    ),
-    /* @__PURE__ */ jsx(
-      RHFTextField,
-      {
-        name: "customerId",
-        disabled: false,
-        type: "text",
-        label: getLabel(`${MAP_GPSTOOLS_DICCTIONARY.LABEL_CUSTOMER_ID}`)
-      }
-    ),
-    /* @__PURE__ */ jsx(
-      RHFTextField,
-      {
-        name: "timeMinInSeconds",
-        disabled: false,
-        type: "number",
-        label: getLabel(`${MAP_GPSTOOLS_DICCTIONARY.LABEL_TIME_MIN_IN_SECONDS}`)
-      }
-    ),
-    /* @__PURE__ */ jsx(
-      RHFTextField,
-      {
-        name: "timeMinOutSeconds",
-        disabled: false,
-        type: "number",
-        label: getLabel(`${MAP_GPSTOOLS_DICCTIONARY.LABEL_TIME_MIN_OUT_SECONDS}`)
-      }
-    )
-  ] });
-}
-function FillData() {
-  const { getLabel } = useModuleDictionary();
-  const { host_static_assets, environment_assets } = useEnvironment();
-  const urlIcon = `${host_static_assets}/${environment_assets}/frontend/components/map_gpstools/assets/icons/${MAP_GPSTOOLS_ICONS.FILL}`;
-  return /* @__PURE__ */ jsxs(PaperForm, { urlIcon, title: getLabel(MAP_GPSTOOLS_DICCTIONARY.PAPER_FILL), children: [
-    /* @__PURE__ */ jsx(
-      PropertyValue,
-      {
-        property: getLabel(`${MAP_GPSTOOLS_DICCTIONARY.LABEL_COLOR}`),
-        isForm: true,
-        propertyWidth: 150,
-        value: /* @__PURE__ */ jsx(RHFColorPicker, { name: "properties.fillColor" })
-      },
-      "properties.fillColor"
-    ),
-    /* @__PURE__ */ jsx(
-      PropertyValue,
-      {
-        property: getLabel(`${MAP_GPSTOOLS_DICCTIONARY.LABEL_OPACITY}`),
-        isForm: true,
-        propertyWidth: 150,
-        value: /* @__PURE__ */ jsx(
-          RHFAutocomplete,
-          {
-            type: "text",
-            name: "properties.fillOpacity",
-            autoComplete: "off",
-            options: STYLE_OPACITIES,
-            getOptionLabel: (option) => option.label,
-            isOptionEqualToValue: (option, value) => option.value === value.value
-          }
-        )
-      },
-      "properties.fillOpacity"
-    )
-  ] });
-}
-function StrokeData() {
-  const { getLabel } = useModuleDictionary();
-  const { host_static_assets, environment_assets } = useEnvironment();
-  const urlIcon = `${host_static_assets}/${environment_assets}/frontend/components/map_gpstools/assets/icons/${MAP_GPSTOOLS_ICONS.STROKE}`;
-  return /* @__PURE__ */ jsxs(PaperForm, { urlIcon, title: getLabel(MAP_GPSTOOLS_DICCTIONARY.PAPER_STROKE), children: [
-    /* @__PURE__ */ jsx(
-      PropertyValue,
-      {
-        property: getLabel(`${MAP_GPSTOOLS_DICCTIONARY.LABEL_COLOR}`),
-        isForm: true,
-        propertyWidth: 150,
-        value: /* @__PURE__ */ jsx(RHFColorPicker, { name: "properties.strokeColor" })
-      },
-      "properties.strokeColor"
-    ),
-    /* @__PURE__ */ jsx(
-      PropertyValue,
-      {
-        property: getLabel(`${MAP_GPSTOOLS_DICCTIONARY.LABEL_OPACITY}`),
-        isForm: true,
-        propertyWidth: 150,
-        value: /* @__PURE__ */ jsx(
-          RHFAutocomplete,
-          {
-            type: "text",
-            name: "properties.strokeOpacity",
-            autoComplete: "off",
-            options: STYLE_OPACITIES,
-            getOptionLabel: (option) => option.label,
-            isOptionEqualToValue: (option, value) => option.value === value.value
-          }
-        )
-      },
-      "properties.strokeOpacity"
-    ),
-    /* @__PURE__ */ jsx(
-      PropertyValue,
-      {
-        property: getLabel(`${MAP_GPSTOOLS_DICCTIONARY.LABEL_WEIGHT}`),
-        isForm: true,
-        propertyWidth: 150,
-        value: /* @__PURE__ */ jsx(
-          RHFAutocomplete,
-          {
-            type: "text",
-            name: "properties.strokeWeight",
-            autoComplete: "off",
-            options: STYLE_WHEIGHTS,
-            getOptionLabel: (option) => option.label,
-            isOptionEqualToValue: (option, value) => option.value === value.value
-          }
-        )
-      },
-      "properties.strokeWeight"
-    ),
-    /* @__PURE__ */ jsx(
-      PropertyValue,
-      {
-        property: getLabel(`${MAP_GPSTOOLS_DICCTIONARY.LABEL_DASH_ARRAY}`),
-        isForm: true,
-        propertyWidth: 150,
-        value: /* @__PURE__ */ jsx(
-          RHFAutocomplete,
-          {
-            type: "text",
-            name: "properties.strokeDashArray",
-            autoComplete: "off",
-            options: STYLE_PATTERNS,
-            getOptionLabel: (option) => option.label,
-            isOptionEqualToValue: (option, value) => option.value === value.value
-          }
-        )
-      },
-      "properties.strokeDashArray"
-    )
-  ] });
-}
-function StyleData() {
-  return /* @__PURE__ */ jsxs(Fragment, { children: [
-    /* @__PURE__ */ jsx(StrokeData, {}),
-    /* @__PURE__ */ jsx(FillData, {})
-  ] });
-}
-function MyTabs() {
-  const { getLabel } = useModuleDictionary();
-  const { host_static_assets, environment_assets } = useEnvironment();
-  const { currentTab, handleChange } = useTab();
-  const geofenceAddEditTabs = useMemo(() => {
-    return [
-      {
-        id: "general",
-        iconUrl: `${host_static_assets}/${environment_assets}/frontend/components/map_gpstools/assets/icons/${MAP_GPSTOOLS_ICONS.DATA}`,
-        component: /* @__PURE__ */ jsxs(Fragment, { children: [
-          /* @__PURE__ */ jsx(GeneralData, {}),
-          /* @__PURE__ */ jsx(ConfigData, {})
-        ] }),
-        label: getLabel(MAP_GPSTOOLS_DICCTIONARY.TAB_GENERAL_CONFIG_TOOLTIP),
-        className: gpsToolsClasses.toolGeofencesAddEditGeneral
-      },
-      {
-        id: "style",
-        iconUrl: `${host_static_assets}/${environment_assets}/frontend/components/map_gpstools/assets/icons/${MAP_GPSTOOLS_ICONS.STYLE}`,
-        component: /* @__PURE__ */ jsx(StyleData, {}),
-        label: getLabel(MAP_GPSTOOLS_DICCTIONARY.TAB_STYLE_CONFIG_TOOLTIP),
-        className: gpsToolsClasses.toolGeofencesAddEditStyle
-      }
-    ];
-  }, [getLabel]);
-  return /* @__PURE__ */ jsxs("div", { className: gpsToolsClasses.gpsToolsGeofencesAddEditContent, children: [
-    /* @__PURE__ */ jsx(
-      Tabs,
-      {
-        value: currentTab,
-        scrollButtons: "auto",
-        variant: "scrollable",
-        allowScrollButtonsMobile: true,
-        onChange: (_e, newValue) => handleChange(_e, newValue),
-        children: geofenceAddEditTabs.map((tab) => /* @__PURE__ */ jsx(
-          Tab,
-          {
-            value: tab.id,
-            icon: /* @__PURE__ */ jsx(Icon, { src: tab.iconUrl }),
-            label: "",
-            SKTWidth: "100px",
-            SKTHeight: "14px"
-          },
-          tab.id
-        ))
-      }
-    ),
-    geofenceAddEditTabs.map((tab) => {
-      const isMatched = tab.id === currentTab;
-      return /* @__PURE__ */ jsx(
-        TabContent,
-        {
-          className: clsx(
-            gpsToolsClasses.gpsToolsTabContent,
-            tab.className,
-            isMatched ? gpsToolsClasses.visible : gpsToolsClasses.hidden
-          ),
-          children: tab.component
-        },
-        tab.id
-      );
-    })
-  ] });
-}
-function GeneralDataValidation(getLabel) {
-  return {
-    name: Yup.string().required(getLabel(MAP_GPSTOOLS_DICCTIONARY.VALIDATION_FIELD_REQUIRED)),
-    geometry: Yup.object().nullable().required(getLabel(MAP_GPSTOOLS_DICCTIONARY.VALIDATION_GEOMETRY_REQUIRED)),
-    geofenceType: Yup.object().nullable().required(getLabel(MAP_GPSTOOLS_DICCTIONARY.VALIDATION_FIELD_REQUIRED))
-  };
-}
-function ConfigDataValidation(getLabel) {
-  return {
-    timeMinInSeconds: Yup.number().nullable().required(getLabel(MAP_GPSTOOLS_DICCTIONARY.VALIDATION_FIELD_REQUIRED)).typeError(getLabel(MAP_GPSTOOLS_DICCTIONARY.VALIDATION_FIELD_TYPE_NUMBER_ERROR)).min(0, getLabel(MAP_GPSTOOLS_DICCTIONARY.VALIDATION_FIELD_MIN_NUMBER_ERROR)),
-    timeMinOutSeconds: Yup.number().nullable().required(getLabel(MAP_GPSTOOLS_DICCTIONARY.VALIDATION_FIELD_REQUIRED)).typeError(getLabel(MAP_GPSTOOLS_DICCTIONARY.VALIDATION_FIELD_TYPE_NUMBER_ERROR)).min(0, getLabel(MAP_GPSTOOLS_DICCTIONARY.VALIDATION_FIELD_MIN_NUMBER_ERROR))
-  };
-}
-function useValidation() {
-  const { getLabel } = useModuleDictionary();
-  const validationSchema = useMemo(
-    () => Yup.object().shape({
-      ...GeneralDataValidation(getLabel),
-      ...ConfigDataValidation(getLabel)
-    }),
-    [getLabel]
-  );
-  return { validationSchema };
-}
-const ENDPOINT_GEOFENCE_GET = "geofences";
-const ENDPOINT_GEOFENCE_NEW_EDIT = "geofences";
-var GeofencesFeaturesLayers = /* @__PURE__ */ ((GeofencesFeaturesLayers2) => {
-  GeofencesFeaturesLayers2["LAYER_GEOFENCES"] = "geofences";
-  GeofencesFeaturesLayers2["LAYER_GEOFENCES_TRANSIT_FEATURES"] = "geofencesCrossingFeatures";
-  GeofencesFeaturesLayers2["LAYER_GEOFENCES_INTERNAL_FEATURES"] = "geofencesInternalFeatures";
-  return GeofencesFeaturesLayers2;
-})(GeofencesFeaturesLayers || {});
-const getSummitData = (values, geofenceId) => {
-  const newEditObj = {
-    name: values.name,
-    typeId: values.geofenceType.id,
-    geometry: values.geometry,
-    properties: {
-      subType: values.properties.subType,
-      strokeColor: values.properties.fillColor,
-      strokeOpacity: values.properties.strokeOpacity.value,
-      strokeWeight: values.properties.strokeWeight.value,
-      strokeDashArray: values.properties.strokeDashArray.value,
-      fillColor: values.properties.fillColor,
-      fillOpacity: values.properties.fillOpacity.value
-    },
-    timeMinInSeconds: values.timeMinInSeconds,
-    timeMinOutSeconds: values.timeMinOutSeconds,
-    alias: values.alias,
-    customerId: values.customerId,
-    ...geofenceId ? { geofenceId } : {}
-  };
-  if (values.geofenceType.id === "gt_circle") {
-    newEditObj.properties.radius = values.properties.radius;
-  }
-  return newEditObj;
-};
-function useSubmit(props) {
-  const { objectId, fullRefresh } = props;
-  const { toast } = useHostTools();
-  const { networkOperation } = useNetwork();
-  const { closePopup, showPopup } = usePopupsStore((state) => state.popupsActions);
-  const { addCheckedGeofence } = useGpsToolsStore((state) => state.geofenceActions, shallow);
-  const onSubmit = async (data) => {
-    await networkOperation({
-      method: objectId ? "PUT" : "POST",
-      endPoint: `${ENDPOINT_GEOFENCE_NEW_EDIT}${objectId ? `/${objectId}` : ""}`,
-      data: getSummitData(data, objectId),
-      toastError: true,
-      toastSuccess: false,
-      bodyToSnakeCase: true,
-      isRemote: false
-    }).then((response) => {
-      toast({ title: response.message }, { type: "success" });
-      closePopup("geofencesAddEdit");
-      showPopup("gpsTools");
-      if (objectId !== void 0) {
-        addCheckedGeofence(objectId);
-      }
-      if (fullRefresh) {
-        fullRefresh();
-      }
-    }).catch(() => {
-    });
-  };
-  return { onSubmit };
-}
-function GeofenceAddEdit(props) {
-  const { geofenceId } = props;
-  const [finalInitalValues, omitCallEnpoint] = useGpsToolsStore((state) => {
-    if (geofenceId === void 0) {
-      return [initialValues, false];
-    }
-    const geofence = state.geofenceState.hashGeofences[geofenceId];
-    if (geofence?.geometry) {
-      const emulateResponse = {
-        data: {
-          type: geofence.type,
-          name: geofence.name,
-          id: geofence.id,
-          active: false,
-          geometry: geofence.geometry,
-          properties: geofence.properties,
-          countCrossingFeatures: geofence.countCrossingFeatures,
-          countInternalFeatures: geofence.countInternalFeatures,
-          createdAt: geofence.createdAt,
-          updatedAt: geofence.updatedAt,
-          timeMinInSeconds: geofence.timeMinInSeconds,
-          timeMinOutSeconds: geofence.timeMinOutSeconds,
-          alias: geofence.alias,
-          customerId: geofence.customerId
-        }
-      };
-      return [formatDataEnpoint(emulateResponse), true];
-    } else {
-      return [initialValues, false];
-    }
-  });
-  const { formValues, statusLoad } = useFormAddEdit({
-    objectId: geofenceId,
-    formatDataEnpoint,
-    initialValues: finalInitalValues,
-    endPoint: ENDPOINT_GEOFENCE_GET,
-    isRemote: false,
-    omitCallEnpoint
-  });
-  const { validationSchema } = useValidation();
-  const { onSubmit } = useSubmit({ objectId: geofenceId });
-  return /* @__PURE__ */ jsx(
-    RHFormProviderStyled,
-    {
-      statusLoad,
-      onSubmit,
-      values: formValues,
-      validationSchema,
-      className: gpsToolsClasses.gpsToolsGeofencesAddEdit,
-      children: /* @__PURE__ */ jsxs(Stack, { direction: "column", gap: "8px", children: [
-        /* @__PURE__ */ jsx(TabProvider, { initialValue: "general", children: /* @__PURE__ */ jsx(MyTabs, {}) }),
-        /* @__PURE__ */ jsx(MyActions, { ...props })
-      ] })
-    }
-  );
-}
-function useRowActionsGetter(props) {
-  const { fullRefresh } = props;
-  const { networkOperation } = useNetwork();
-  const { openModal, closeModal } = useModal();
-  const { getLabel } = useModuleDictionary();
-  const { hasPrivilege } = useModulePrivileges();
-  const { host_static_assets, environment_assets } = useEnvironment();
-  const { hidePopup, addPopup } = usePopupsStore((state) => state.popupsActions, shallow);
-  const { removeCheckedGeofence } = useGpsToolsStore((state) => state.geofenceActions, shallow);
-  const { toast } = useHostTools();
-  const isDesktop = useResponsiveDesktop();
-  const [urlIconEdit] = useState(
-    `${host_static_assets}/${environment_assets}/frontend/components/map_gpstools/assets/icons/${MAP_GPSTOOLS_ICONS.GEOFENCE_EDIT}`
-  );
-  const [urlIconDelete] = useState(
-    `${host_static_assets}/${environment_assets}/frontend/components/map_gpstools/assets/icons/${MAP_GPSTOOLS_ICONS.GEOFENCE_DELETE}`
-  );
-  const goEdit = (objectId, name) => {
-    hidePopup("gpsTools");
-    addPopup({
-      popupId: "geofencesAddEdit",
-      title: getLabel(MAP_GPSTOOLS_DICCTIONARY.ACTION_GEOFENCE_EDIT),
-      editionInfo: `${getLabel(MAP_GPSTOOLS_DICCTIONARY.LABEL_ID)}:${objectId} - ${name} `,
-      componentProps: { fullRefresh, geofenceId: objectId },
-      functionComponent: GeofenceAddEdit,
-      //   onMouseDown,
-      defaultPosition: {
-        vertical: { top: 50, bottom: 50 },
-        horizontal: { right: 50, width: 380 }
-        // left:490,top:50,width:360, height:420},
-        // bounds:{top:5, left:5, right:-5, bottom:-5}
-      },
-      iconUrl: urlIconEdit
-    });
-    removeCheckedGeofence(objectId);
-  };
-  const onDelete = useCallback(
-    (row) => {
-      openModal({
-        window: /* @__PURE__ */ jsx(
-          WindowConfirm,
-          {
-            title: getLabel(MAP_GPSTOOLS_DICCTIONARY.MODAL_DELETE_GEO_TITLE),
-            msg: getLabel(MAP_GPSTOOLS_DICCTIONARY.MODAL_DELETE_GEO_MESSAGE),
-            onClickIntro: () => onConfirmDelete(row)
-          }
-        ),
-        variant: "delete",
-        initialWidth: 300,
-        initialHeigth: 350
-      });
-    },
-    [getLabel]
-  );
-  const onConfirmDelete = useCallback((row) => {
-    networkOperation({
-      method: "DELETE",
-      endPoint: `geofences/${row.id}`
-    }).then((response) => {
-      toast({ title: response.message }, { type: "success" });
-      fullRefresh();
-    });
-    closeModal();
-  }, []);
-  const rowActionsGetter = useCallback(
-    (row) => {
-      const conditionalItems = [];
-      conditionalItems.push({
-        urlIcon: urlIconEdit,
-        dictionaryId: MAP_GPSTOOLS_DICCTIONARY.ROW_ACTION_GEO_EDIT,
-        onClick: () => {
-          goEdit(row.id, row.name);
-        },
-        // Solo se habilita si intenta editarse a él mismo, o si tiene permisos pero está en un nivel superior al usuario a editar
-        // disabled: !(itsMe || (hasPrivilege(PRIVILEGE_EDIT) && (loggedUserType > row.user_type.id)))
-        disabled: !row.authUserOptions.edit
-      });
-      conditionalItems.push({
-        urlIcon: urlIconDelete,
-        dictionaryId: MAP_GPSTOOLS_DICCTIONARY.ROW_ACTION_GEO_DELETE,
-        onClick: () => {
-          onDelete(row);
-        },
-        variant: "delete",
-        // Solo se habilita si intenta editarse a él mismo, o si tiene permisos pero está en un nivel superior al usuario a editar
-        // disabled: !(itsMe || (hasPrivilege(PRIVILEGE_EDIT) && (loggedUserType > row.user_type.id)))
-        disabled: !row.authUserOptions.edit
-      });
-      return conditionalItems;
-    },
-    [hasPrivilege, goEdit, onDelete, urlIconDelete, urlIconEdit, isDesktop]
-  );
-  return { rowActionsGetter };
-}
-function useCheckedGeofences() {
-  const layersIds = useMapStore((state) => state.layersIds, shallow);
-  const [checkedGeofences, hashGeofences] = useGpsToolsStore(
-    (state) => [state.geofenceState.checkedGeofences, state.geofenceState.hashGeofences],
-    shallow
-  );
-  const { setCheckedGeofences, updatePartialGeofence } = useGpsToolsStore(
-    (state) => state.geofenceActions,
-    shallow
-  );
-  const { setFeatureData, removeFeature, getFeatureIds } = useMapStore(
-    (state) => state.mapActions,
-    shallow
-  );
-  const { networkOperation } = useNetwork();
-  useEffect(() => {
-    if (!layersIds.includes(GeofencesFeaturesLayers.LAYER_GEOFENCES)) {
-      return;
-    }
-    const mapFeatureIds = getFeatureIds(GeofencesFeaturesLayers.LAYER_GEOFENCES);
-    checkedGeofences.forEach((chkRow) => {
-      const geofence = hashGeofences[chkRow];
-      if (!geofence) {
-        return;
-      }
-      if (!mapFeatureIds.includes(chkRow) || !geofence.hasRenderizedGeofence) {
-        if (!geofence.geometry) {
-          networkOperation({
-            method: "GET",
-            endPoint: `geofences/${geofence.id}`,
-            isRemote: false,
-            responseToCamelCase: true
-          }).then((response) => {
-            const geoLoaded = {
-              geometry: response.data.geometry,
-              name: response.data.name,
-              properties: response.data.properties,
-              countCrossingFeatures: response.data.countCrossingFeatures,
-              hasRenderizedGeofence: false
-            };
-            if (geoLoaded.geometry) {
-              if (checkedGeofences.has(geofence.id)) {
-                setFeatureData("geofences", chkRow, geoLoaded.geometry, geoLoaded.properties, {
-                  label: geoLoaded.name,
-                  labelColor: geoLoaded.properties?.color
-                });
-                geoLoaded.hasRenderizedGeofence = true;
-              }
-            }
-            updatePartialGeofence(geofence.id, geoLoaded);
-          });
-        } else {
-          setFeatureData(
-            GeofencesFeaturesLayers.LAYER_GEOFENCES,
-            chkRow,
-            geofence.geometry,
-            geofence.properties,
-            { label: geofence.name }
-          );
-          updatePartialGeofence(geofence.id, { hasRenderizedGeofence: true });
-        }
-      }
-    });
-    mapFeatureIds.forEach((mapFeatureId) => {
-      if (!checkedGeofences.has(Number(mapFeatureId))) {
-        removeFeature(GeofencesFeaturesLayers.LAYER_GEOFENCES, mapFeatureId);
-      }
-    });
-    return () => {
-    };
-  }, [checkedGeofences, layersIds]);
-  return {
-    checkedGeofences,
-    setCheckedGeofences
-  };
-}
-function useCheckedFeatures(layerId, featuresType, endpoint) {
-  const layersIds = useMapStore((state) => state.layersIds, shallow);
-  const [checkedFeatures, setCheckedFeatures, hashGeofences] = useGpsToolsStore((state) => {
-    return featuresType === "CrossingFeatures" ? [
-      state.geofenceState.checkedCrossingFeatures,
-      state.geofenceActions.setCheckedCrossingFeatures,
-      state.geofenceState.hashGeofences
-    ] : [
-      state.geofenceState.checkedInternalFeatures,
-      state.geofenceActions.setCheckedInternalFeatures,
-      state.geofenceState.hashGeofences
-    ];
-  }, shallow);
-  const { setFeatureData, removeFeature, getFeatureIds } = useMapStore(
-    (state) => state.mapActions,
-    shallow
-  );
-  const { networkOperation } = useNetwork();
-  useEffect(() => {
-    if (!layersIds.includes(layerId)) {
-      return;
-    }
-    const mapFeatureIds = getFeatureIds(layerId);
-    checkedFeatures.forEach((chkRow) => {
-      const geofence = hashGeofences[chkRow];
-      if (!geofence) {
-        return;
-      }
-      if (!mapFeatureIds.find((fId) => fId.toString().includes(`geo_${geofence.id}_fid`)) || !geofence[`hasRenderized${featuresType}`]) {
-        const currentGeofenceLoadedFeatures = geofence[`loaded${featuresType}`];
-        if (!currentGeofenceLoadedFeatures) {
-          networkOperation({
-            method: "GET",
-            endPoint: `geofences/${geofence.id}/${endpoint}`,
-            isRemote: false,
-            responseToCamelCase: true
-          }).then((response) => {
-            geofence[`loaded${featuresType}`] = response.data;
-            const newGeofenceLoadedFeatures = geofence[`loaded${featuresType}`];
-            if (newGeofenceLoadedFeatures && Array.isArray(geofence[`loaded${featuresType}`])) {
-              if (checkedFeatures.has(geofence.id)) {
-                newGeofenceLoadedFeatures.forEach((feature) => {
-                  setFeatureData(
-                    layerId,
-                    `geo_${geofence.id}_fid_${feature.id}`,
-                    feature.geometry,
-                    feature.properties
-                  );
-                });
-                geofence[`hasRenderized${featuresType}`] = true;
-              }
-            }
-          }).catch(() => {
-          });
-        } else {
-          currentGeofenceLoadedFeatures.forEach((feature) => {
-            setFeatureData(
-              layerId,
-              `geo_${geofence.id}_fid_${feature.id}`,
-              feature.geometry,
-              feature.properties
-            );
-          });
-          geofence[`hasRenderized${featuresType}`] = true;
-        }
-      }
-    });
-    mapFeatureIds.forEach((mapFeatureId) => {
-      const featureId = Number(mapFeatureId.toString().split("_")[1]);
-      if (!checkedFeatures.has(featureId)) {
-        removeFeature(layerId, mapFeatureId);
-      }
-    });
-    return () => {
-    };
-  }, [checkedFeatures, layersIds]);
-  return [checkedFeatures, setCheckedFeatures];
-}
-function useMaster() {
-  const { getLabel } = useModuleDictionary();
-  const { host_static_assets, environment_assets } = useEnvironment();
-  const { hidePopup, addPopup } = usePopupsStore((state) => state.popupsActions, shallow);
-  const goToAdd = () => {
-    hidePopup("gpsTools");
-    addPopup({
-      popupId: "geofencesAddEdit",
-      title: getLabel(MAP_GPSTOOLS_DICCTIONARY.ACTION_GEOFENCE_ADD),
-      functionComponent: () => /* @__PURE__ */ jsx(GeofenceAddEdit, {}),
-      //   onMouseDown,
-      defaultPosition: {
-        vertical: { top: 50, bottom: 50 },
-        horizontal: { right: 50, width: 380 }
-        // left:490,top:50,width:360, height:420},
-        // bounds:{top:5, left:5, right:-5, bottom:-5}
-      },
-      iconUrl: `${host_static_assets}/${environment_assets}/frontend/components/map_gpstools/assets/icons/${MAP_GPSTOOLS_ICONS.GEOFENCE_ADD}`
-    });
-  };
-  const [checkedGeofences, hashGeofences, initialRows] = useGpsToolsStore(
-    (state) => [
-      state.geofenceState.checkedGeofences,
-      state.geofenceState.hashGeofences,
-      state.geofenceState.rows
-    ],
-    shallow
-  );
-  const { setCheckedGeofences, addGeofence, updatePartialGeofence, updateRows } = useGpsToolsStore(
-    (state) => state.geofenceActions,
-    shallow
-  );
-  useCheckedGeofences();
-  const [checkedCrossingFeatures, setCheckedCrossingFeatures] = useCheckedFeatures(
-    GeofencesFeaturesLayers.LAYER_GEOFENCES_TRANSIT_FEATURES,
-    "CrossingFeatures",
-    "crossing_features"
-  );
-  const [checkedInternalFeatures, setCheckedInternalFeatures] = useCheckedFeatures(
-    GeofencesFeaturesLayers.LAYER_GEOFENCES_INTERNAL_FEATURES,
-    "InternalFeatures",
-    "internal_features"
-  );
-  const rowKeyGetter = useCallback((row) => row.id, []);
-  const [selectedRows, setSelectedRows] = useState(/* @__PURE__ */ new Set());
-  const [backendQueryParams, setBackendQueryParams] = useState({});
-  const { columns } = useColumns();
-  const { pagerState, rows, onPageChange, onRowsPerPageChange, Refresh, setRows } = usePaginate({
-    endPoint: "geofences",
-    fireOnChangeParms: false,
-    fireOnFirstLoad: false,
-    queryParams: backendQueryParams,
-    isRemote: false,
-    responseToCamelCase: true,
-    initialRows
-  });
-  const onSelectedRowsChange = (newRowsSelectSet) => {
-    setSelectedRows(newRowsSelectSet);
-  };
-  const fullRefresh = useCallback((_id) => {
-    Refresh();
-  }, []);
-  useEffect(() => {
-    const newCheckedGeofences = new Set(checkedGeofences);
-    const newCheckedCrossingFeatures = new Set(checkedCrossingFeatures);
-    const newCheckedInternalFeatures = new Set(checkedInternalFeatures);
-    let updatedCheckedGeofences = false;
-    let updatedCheckedCrossingFeatures = false;
-    let updatedCheckedInternalFeatures = false;
-    newCheckedGeofences.forEach((chkRow) => {
-      if (rows.findIndex((row) => row.id === chkRow) === -1) {
-        newCheckedGeofences.delete(chkRow);
-      }
-    });
-    newCheckedCrossingFeatures.forEach((chkTF) => {
-      if (rows.findIndex((row) => row.id === chkTF) === -1) {
-        newCheckedCrossingFeatures.delete(chkTF);
-      }
-    });
-    newCheckedInternalFeatures.forEach((chkIF) => {
-      if (rows.findIndex((row) => row.id === chkIF) === -1) {
-        newCheckedInternalFeatures.delete(chkIF);
-      }
-    });
-    rows.forEach((row) => {
-      let hasGeo = hashGeofences[row.id];
-      if (!hasGeo) {
-        hasGeo = {
-          ...row,
-          hasRenderizedGeofence: false,
-          loadedCrossingFeatures: null,
-          loadedInternalFeatures: null,
-          hasRenderizedCrossingFeatures: false,
-          hasRenderizedInternalFeatures: false,
-          createdAt: row.createdAt
-        };
-        addGeofence(row.id, hasGeo);
-        return;
-      }
-      if (row.updatedAt && row.updatedAt !== hasGeo.updatedAt) {
-        updatePartialGeofence(row.id, {
-          updatedAt: row.updatedAt,
-          geometry: null,
-          hasRenderizedGeofence: false,
-          hasRenderizedCrossingFeatures: false,
-          hasRenderizedInternalFeatures: false,
-          loadedCrossingFeatures: null,
-          loadedInternalFeatures: null
-        });
-        updatedCheckedGeofences = true;
-        updatedCheckedCrossingFeatures = true;
-        updatedCheckedInternalFeatures = true;
-      }
-    });
-    if (newCheckedGeofences.size !== checkedGeofences.size || updatedCheckedGeofences) {
-      setCheckedGeofences(newCheckedGeofences);
-    }
-    if (newCheckedCrossingFeatures.size !== checkedCrossingFeatures.size || updatedCheckedCrossingFeatures) {
-      setCheckedCrossingFeatures(newCheckedCrossingFeatures);
-    }
-    if (newCheckedInternalFeatures.size !== checkedInternalFeatures.size || updatedCheckedInternalFeatures) {
-      setCheckedInternalFeatures(newCheckedInternalFeatures);
-    }
-    onSelectedRowsChange(selectedRows);
-    updateRows(rows);
-  }, [rows]);
-  const { rowActionsGetter } = useRowActionsGetter({ fullRefresh });
-  return {
-    rowKeyGetter,
-    columns,
-    refresh: Refresh,
-    setBackendQueryParams,
-    pagerState,
-    rows,
-    onPageChange,
-    onRowsPerPageChange,
-    rowActionsGetter,
-    selectedRows,
-    onSelectedRowsChange,
-    checkedRows: checkedGeofences,
-    onCheckedRowsChange: setCheckedGeofences,
-    setRows,
-    goToAdd
-  };
-}
-function GeofencesList() {
-  const { getLabel } = useModuleDictionary();
-  const {
-    refresh,
-    setBackendQueryParams,
-    columns,
-    rows,
-    rowActionsGetter,
-    selectedRows,
-    onSelectedRowsChange,
-    pagerState,
-    onPageChange,
-    onRowsPerPageChange,
-    checkedRows,
-    onCheckedRowsChange,
-    setRows,
-    rowKeyGetter,
-    goToAdd
-  } = useMaster();
-  return /* @__PURE__ */ jsxs(
-    StackGeofenceListRoot,
-    {
-      direction: "column",
-      gap: "8px",
-      className: gpsToolsClasses.gpsToolsGeofencesList,
-      children: [
-        /* @__PURE__ */ jsx(Filter, { refresh, setBackendQueryParams }),
-        /* @__PURE__ */ jsx(
-          DataGrid,
-          {
-            id: "geofences",
-            columns,
-            rows,
-            onRowsChange: setRows,
-            checkedRows,
-            onCheckedRowsChange,
-            rowActionsGetter,
-            rowKeyGetter,
-            selectedRows,
-            onSelectedRowsChange,
-            withActions: true,
-            actionsProps: {
-              withPager: true,
-              withLocalFilters: true,
-              pagerOptions: {
-                records: rows.length,
-                totalRecords: pagerState.totalRecords,
-                rowsPerPageOptions: [1, 2, 3, 4, 5, 10, 25],
-                page: pagerState.page,
-                rowsPerPage: pagerState.rowsPerPage,
-                onPageChange,
-                onRowsPerPageChange
-              }
-            }
-          },
-          "list"
-        ),
-        /* @__PURE__ */ jsx(Actions, { children: /* @__PURE__ */ jsx(Button, { onClick: () => goToAdd(), children: getLabel(MAP_GPSTOOLS_DICCTIONARY.ACTION_GEOFENCE_ADD) }) })
-      ]
-    }
-  );
-}
-enableMapSet();
-const createGpsToolsStore = (initProps) => {
-  const startProps = {
-    currentTabGpsTool: "geofences",
-    geofenceState: {
-      // currentGeofenceTool: 'list',
-      rows: [],
-      checkedGeofences: /* @__PURE__ */ new Set(),
-      checkedCrossingFeatures: /* @__PURE__ */ new Set(),
-      checkedInternalFeatures: /* @__PURE__ */ new Set(),
-      hashGeofences: {}
-    },
-    ...initProps
-  };
-  return createStore(
-    devtools(
-      immer((set, _get) => ({
-        ...startProps,
-        gpsToolsActions: {
-          init: () => {
-            set((state) => {
-              state.ownerState.status = "ready";
-            });
-          },
-          setGpsToolsState: (status) => {
-            set((state) => {
-              state.ownerState.status = status;
-            });
-          },
-          setHandlerGetLabel: (newHandler) => {
-            set((state) => {
-              state.getLabel = newHandler;
-            });
-          },
-          setExternalState: (newExternalState) => {
-            set((state) => {
-              state.ownerState = { ...state.ownerState, ...newExternalState };
-            });
-          },
-          setCurrentTabTool: (newTabTool) => {
-            set((state) => {
-              state.currentTabGpsTool = newTabTool;
-            });
-          }
-        },
-        geofenceActions: {
-          // goToAddEdit: (geofenceId?: GeofenceId) => {
-          //     set(state => {
-          //         state.geofenceState.currentGeofenceTool = 'add_edit';
-          //         state.geofenceState.geofenceId = geofenceId;
-          //     });
-          // },
-          // goToList: (geofenceId?: GeofenceId) => {
-          //     set(state => {
-          //         state.geofenceState.currentGeofenceTool = 'list';
-          //         state.geofenceState.geofenceId = geofenceId;
-          //     });
-          // },
-          addGeofence: (geofenceId, geofence) => {
-            set((state) => {
-              state.geofenceState.hashGeofences[geofenceId] = geofence;
-            });
-          },
-          updatePartialGeofence: (geofenceId, geofence) => {
-            set((state) => {
-              state.geofenceState.hashGeofences[geofenceId] = {
-                ...state.geofenceState.hashGeofences[geofenceId],
-                ...geofence
-              };
-            });
-          },
-          updateRows: (newRows) => {
-            set((state) => {
-              state.geofenceState.rows = newRows;
-            });
-          },
-          addCheckedGeofence: (geofenceId) => {
-            set((state) => {
-              state.geofenceState.checkedGeofences.add(geofenceId);
-              state.geofenceState.checkedGeofences = new Set(state.geofenceState.checkedGeofences);
-            });
-          },
-          removeCheckedGeofence: (geofenceId) => {
-            set((state) => {
-              state.geofenceState.checkedGeofences.delete(geofenceId);
-              state.geofenceState.checkedGeofences = new Set(state.geofenceState.checkedGeofences);
-            });
-          },
-          setCheckedGeofences: (newGeofences) => {
-            set((state) => {
-              state.geofenceState.checkedGeofences = new Set(newGeofences);
-            });
-          },
-          setCheckedCrossingFeatures: (newFeatures) => {
-            set((state) => {
-              state.geofenceState.checkedCrossingFeatures = new Set(newFeatures);
-            });
-          },
-          setCheckedInternalFeatures: (newFeatures) => {
-            set((state) => {
-              state.geofenceState.checkedInternalFeatures = new Set(newFeatures);
-            });
-          }
-        }
-      })),
-      { name: `Map Tools Store` }
-    )
-  );
-};
-const GpsToolsContext = createContext(null);
-function GpsToolsProvider(props) {
-  const { children } = props;
-  const { getLabel } = useModuleDictionary();
-  const isDesktop = useResponsiveDesktop();
-  const isSkeleton = useModuleSkeleton();
-  const isFirstRender = useFirstRender([getLabel]);
-  const mapStoreRef = useRef();
-  if (!mapStoreRef.current) {
-    mapStoreRef.current = createGpsToolsStore({
-      getLabel,
-      ownerState: {
-        status: "init",
-        isMobile: !isDesktop,
-        isSkeleton,
-        focus: false
-      }
-    });
-  }
-  const { setHandlerGetLabel, setExternalState } = useStore(
-    mapStoreRef.current,
-    (state) => state.gpsToolsActions,
-    shallow
-  );
-  useEffect(() => {
-    if (!isFirstRender) {
-      setHandlerGetLabel(getLabel);
-    }
-  }, [getLabel]);
-  useEffect(() => {
-    if (isFirstRender) {
-      return;
-    }
-    setExternalState({ isMobile: !isDesktop, isSkeleton });
-  }, [isDesktop, isSkeleton]);
-  return /* @__PURE__ */ jsx(GpsToolsContext.Provider, { value: mapStoreRef.current, children });
-}
-function useGpsToolsStore(selector, equalityFn) {
-  const context = useContext(GpsToolsContext);
-  if (!context) throw new Error("useGpsToolsStore context must be use inside GpsToolsContext");
-  return useStore(context, selector, equalityFn);
-}
-function useLayers() {
-  const { addLayer, removeLayer } = useMapStore((state) => state.mapActions, shallow);
-  const { init } = useGpsToolsStore((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);
-    };
-  }, []);
-}
-function TabsGpsTools() {
-  const { getLabel } = useModuleDictionary();
-  const { host_static_assets, environment_assets } = useEnvironment();
-  const status = useGpsToolsStore((state) => state.ownerState.status, shallow);
-  const currentTabTool = useGpsToolsStore((state) => state.currentTabGpsTool, shallow);
-  const { setCurrentTabTool } = useGpsToolsStore((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),
-            SKTWidth: "100px",
-            SKTHeight: "14px"
-          },
-          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
-      );
-    })
-  ] });
-}
-function MapGpsTools() {
-  const isSkeleton = useModuleSkeleton();
-  return !isSkeleton && /* @__PURE__ */ jsx(TabsGpsTools, {});
-}
-export {
-  GpsToolsProvider as G,
-  MapGpsTools as M,
-  gpsToolsClasses as g,
-  useGpsToolsStore as u
-};