@m4l/components 3.1.9 → 4.0.0

package/components/maps/components/Map/subcomponents/LayersContainer/subcomponents/MyLayer/index-CfurUH1f.js

@@ -0,0 +1,132 @@
+import { jsx } from "react/jsx-runtime";
+import { useRef, useEffect } from "react";
+import { useMap, LayerGroup } from "react-leaflet";
+import L__default from "leaflet";
+import { shallow } from "zustand/shallow";
+import { M as MarkerClusterGroup } from "./subcomponents/MarkerClusterGroup/index-DbEbhjX5.js";
+import { R as RenderByEachFeatureComponent, M as MemonizedRenderByEachFeatureComponent } from "./subcomponents/RenderByEachFeatureComponent/index-uX_7GNKr.js";
+import { T as TIME_DOUBLE_CLICK } from "../../../../constants-B0E5r9Iy.js";
+import { u as useMapStore } from "../../../../hooks/useMapStore/index-Dvztupfk.js";
+const MyLayer = (props) => {
+  const { layerId } = props;
+  const map = useMap();
+  const popupRef = useRef(null);
+  const lefaletLayerRef = useRef({
+    clickTimeout: null,
+    clickCount: 0,
+    handleClickSetted: false
+  });
+  const featureIdOrCollection = useMapStore((state) => {
+    const geoJsonObject = state.hashLayers[layerId]?.geoJsonObject;
+    if (geoJsonObject && geoJsonObject.object.type === "Feature") {
+      return geoJsonObject.object.id;
+    } else if (geoJsonObject && geoJsonObject.object.type === "FeatureCollection") {
+      return geoJsonObject && geoJsonObject.object.features.map((feature) => feature.id);
+    }
+  }, shallow);
+  const renderFeature = useMapStore((state) => state.hashLayers[layerId]?.renderFeature, shallow);
+  const [visible, cluster = false] = useMapStore(
+    (state) => [state.hashLayers[layerId]?.visible, state.hashLayers[layerId]?.cluster],
+    shallow
+  );
+  const markerClusterGroupRef = useRef(null);
+  const handleClick = (a) => {
+    lefaletLayerRef.current.clickCount++;
+    if (lefaletLayerRef.current.clickCount === 1) {
+      lefaletLayerRef.current.clickTimeout = setTimeout(() => {
+        const cluster2 = a.propagatedFrom;
+        if (cluster2 && cluster2 instanceof L__default.MarkerCluster) ;
+        if (!popupRef.current) {
+          popupRef.current = L__default.popup().setLatLng(a.sourceTarget._cLatLng).setContent("Hello, World!");
+          map.addLayer(popupRef.current);
+        } else {
+          popupRef.current.openOn(map);
+        }
+        lefaletLayerRef.current.clickCount = 0;
+      }, TIME_DOUBLE_CLICK);
+    } else if (lefaletLayerRef.current.clickCount === 2) {
+      if (lefaletLayerRef.current?.clickTimeout) {
+        clearTimeout(lefaletLayerRef.current.clickTimeout);
+      }
+      lefaletLayerRef.current.clickCount = 0;
+    }
+  };
+  useEffect(() => {
+    if (markerClusterGroupRef.current) {
+      markerClusterGroupRef.current.on("clusterclick", handleClick);
+    }
+  }, [markerClusterGroupRef.current]);
+  if (!featureIdOrCollection || !renderFeature) {
+    return null;
+  }
+  if (visible === false) {
+    return null;
+  }
+  const isFeaturCollection = Array.isArray(featureIdOrCollection);
+  if (!isFeaturCollection) {
+    return /* @__PURE__ */ jsx(
+      RenderByEachFeatureComponent,
+      {
+        renderFeature,
+        id: featureIdOrCollection,
+        layerId
+      }
+    );
+  } else {
+    const createClusterCustomIcon = (cluster2) => {
+      const childCount = cluster2.getChildCount();
+      let c = " marker-cluster-";
+      if (childCount < 10) {
+        c += "small";
+      } else if (childCount < 100) {
+        c += "medium";
+      } else {
+        c += "large";
+      }
+      const DivIcon2 = new L__default.DivIcon({
+        html: "<div><span>" + childCount + "</span></div>",
+        className: "marker-cluster" + c,
+        iconSize: new L__default.Point(40, 40)
+      });
+      return DivIcon2;
+    };
+    if (!cluster) {
+      return /* @__PURE__ */ jsx(LayerGroup, { children: featureIdOrCollection.map((featureId) => {
+        return /* @__PURE__ */ jsx(
+          MemonizedRenderByEachFeatureComponent,
+          {
+            renderFeature,
+            id: featureId,
+            layerId
+          },
+          `k_${featureId}`
+        );
+      }) });
+    } else {
+      return /* @__PURE__ */ jsx(
+        MarkerClusterGroup,
+        {
+          disableClusteringAtZoom: 18,
+          showCoverageOnHover: false,
+          zoomToBoundsOnClick: false,
+          spiderfyOnMaxZoom: false,
+          iconCreateFunction: createClusterCustomIcon,
+          children: featureIdOrCollection.map((featureId) => {
+            return /* @__PURE__ */ jsx(
+              MemonizedRenderByEachFeatureComponent,
+              {
+                renderFeature,
+                id: featureId,
+                layerId
+              },
+              `k_${featureId}`
+            );
+          })
+        }
+      );
+    }
+  }
+};
+export {
+  MyLayer as M
+};

package/components/maps/components/Map/subcomponents/LayersContainer/subcomponents/MyLayer/subcomponents/MarkerClusterGroup/index-DbEbhjX5.js

@@ -0,0 +1,24 @@
+import { createPathComponent } from "@react-leaflet/core";
+import L__default from "leaflet";
+import "leaflet.markercluster";
+const MarkerClusterGroup = createPathComponent(({ children: _c, ...props }, ctx) => {
+  const clusterProps = {};
+  const clusterEvents = {};
+  Object.entries(props).forEach(([propName, prop]) => {
+    if (propName !== void 0 && prop !== "") {
+      propName.startsWith("on") ? clusterEvents[propName] = prop : clusterProps[propName] = prop;
+    }
+  });
+  const markerClusterGroup = new L__default.MarkerClusterGroup(clusterProps);
+  Object.entries(clusterEvents).forEach(([eventAsProp, callback]) => {
+    const clusterEvent = `cluster${eventAsProp.substring(2).toLowerCase()}`;
+    markerClusterGroup.on(clusterEvent, callback);
+  });
+  return {
+    instance: markerClusterGroup,
+    context: { ...ctx, layerContainer: markerClusterGroup }
+  };
+});
+export {
+  MarkerClusterGroup as M
+};

package/components/maps/components/Map/subcomponents/LayersContainer/subcomponents/MyLayer/subcomponents/RenderByEachFeatureComponent/index-uX_7GNKr.js

@@ -0,0 +1,14 @@
+import { jsx, Fragment } from "react/jsx-runtime";
+import React__default from "react";
+const RenderByEachFeatureComponent = ({
+  renderFeature,
+  ...props
+}) => {
+  const feature = renderFeature(props);
+  return feature ? /* @__PURE__ */ jsx(Fragment, { children: feature }) : null;
+};
+const MemonizedRenderByEachFeatureComponent = React__default.memo(RenderByEachFeatureComponent);
+export {
+  MemonizedRenderByEachFeatureComponent as M,
+  RenderByEachFeatureComponent as R
+};

package/components/maps/components/Map/subcomponents/TileLayers/index-3luovNVA.js

@@ -0,0 +1,13 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { T as TileLayerOthers } from "./subcomponents/TileLayerOthers/index-COI8fu28.js";
+import { T as TileLayerGoogle } from "./subcomponents/TileLayerGoogle/index-CwwgLmb1.js";
+import React__default from "react";
+function TileLayers() {
+  return /* @__PURE__ */ jsxs(React__default.Fragment, { children: [
+    /* @__PURE__ */ jsx(TileLayerOthers, {}),
+    /* @__PURE__ */ jsx(TileLayerGoogle, {})
+  ] });
+}
+export {
+  TileLayers as T
+};

package/components/maps/components/Map/subcomponents/TileLayers/subcomponents/TileLayerGoogle/index-CwwgLmb1.js

@@ -0,0 +1,100 @@
+import React__default from "react";
+import { useMap } from "react-leaflet";
+import L__default from "leaflet";
+import { u as useMapStore } from "../../../../hooks/useMapStore/index-Dvztupfk.js";
+import { shallow } from "zustand/shallow";
+import { Loader } from "@googlemaps/js-api-loader";
+function TileLayerGoogle() {
+  const map = useMap();
+  const mutantRefLayer = React__default.useRef(null);
+  const { options, sourceType, mapTypeTile } = useMapStore(
+    (state) => state.hashMapSources[state.currentMapSourceId],
+    shallow
+  );
+  const roadOptions = useMapStore(
+    (state) => state.hashMapSources[state.currentMapSourceId].roadSelectedOptions,
+    shallow
+  );
+  const [googleApiKey, googleMapVersion] = useMapStore(
+    (state) => [state.googleApiKey, state.googleMapVersion],
+    shallow
+  );
+  React__default.useEffect(() => {
+    if (sourceType !== "Google") {
+      return;
+    }
+    let googleMutantLayer;
+    const loader = new Loader({
+      apiKey: googleApiKey,
+      version: googleMapVersion
+    });
+    loader.importLibrary("maps").then(() => {
+      googleMutantLayer = L__default.gridLayer.googleMutant({
+        type: mapTypeTile,
+        // map type, can be 'roadmap', 'satellite', etc.
+        maxZoom: 20,
+        // styles: [
+        //   // Google Maps styles array, can be generated here: https://mapstyle.withgoogle.coxm/
+        // ],
+        ...options
+      });
+      mutantRefLayer.current = googleMutantLayer;
+      if (roadOptions.trafficLayer) {
+        googleMutantLayer.addGoogleLayer("TrafficLayer");
+      }
+      if (roadOptions.transitLayer) {
+        googleMutantLayer.addGoogleLayer("TransitLayer");
+      }
+      if (roadOptions.bicyclingLayer) {
+        googleMutantLayer.addGoogleLayer("BicyclingLayer");
+      }
+      map.addLayer(googleMutantLayer);
+    });
+    return () => {
+      if (googleMutantLayer) {
+        map.removeLayer(googleMutantLayer);
+        mutantRefLayer.current = null;
+      }
+    };
+  }, [map, sourceType, mapTypeTile]);
+  React__default.useEffect(() => {
+    if (sourceType !== "Google") {
+      return;
+    }
+    if (mutantRefLayer.current && roadOptions) {
+      if (roadOptions.trafficLayer) {
+        mutantRefLayer.current.addGoogleLayer("TrafficLayer");
+      } else if (roadOptions.trafficLayer === false) {
+        mutantRefLayer.current.removeGoogleLayer("TrafficLayer");
+      }
+    }
+  }, [roadOptions.trafficLayer]);
+  React__default.useEffect(() => {
+    if (sourceType !== "Google") {
+      return;
+    }
+    if (mutantRefLayer.current && roadOptions) {
+      if (roadOptions.transitLayer) {
+        mutantRefLayer.current.addGoogleLayer("TransitLayer");
+      } else if (roadOptions.transitLayer === false) {
+        mutantRefLayer.current.removeGoogleLayer("TransitLayer");
+      }
+    }
+  }, [roadOptions.transitLayer]);
+  React__default.useEffect(() => {
+    if (sourceType !== "Google") {
+      return;
+    }
+    if (mutantRefLayer.current && roadOptions) {
+      if (roadOptions.bicyclingLayer) {
+        mutantRefLayer.current.addGoogleLayer("BicyclingLayer");
+      } else if (roadOptions.bicyclingLayer === false) {
+        mutantRefLayer.current.removeGoogleLayer("BicyclingLayer");
+      }
+    }
+  }, [roadOptions.bicyclingLayer]);
+  return null;
+}
+export {
+  TileLayerGoogle as T
+};

package/components/maps/components/Map/subcomponents/TileLayers/subcomponents/TileLayerOthers/index-COI8fu28.js

@@ -0,0 +1,35 @@
+import { useMap } from "react-leaflet";
+import { shallow } from "zustand/shallow";
+import { u as useMapStore } from "../../../../hooks/useMapStore/index-Dvztupfk.js";
+import { useEffect } from "react";
+import L__default from "leaflet";
+const TileLayerOthers = () => {
+  const map = useMap();
+  const { urlTemplate, dictionaryId, options, getTileUrl, sourceType } = useMapStore(
+    (state) => state.hashMapSources[state.currentMapSourceId],
+    shallow
+  );
+  useEffect(() => {
+    let layer;
+    if (sourceType === "Google") {
+      return;
+    }
+    layer = L__default.tileLayer(urlTemplate, options);
+    if (getTileUrl) {
+      layer.getTileUrl = getTileUrl;
+    }
+    map.addLayer(layer);
+    if (options && options.maxZoom) {
+      map.setMaxZoom(options.maxZoom);
+    }
+    return () => {
+      if (layer) {
+        map.removeLayer(layer);
+      }
+    };
+  }, [dictionaryId, urlTemplate, options, getTileUrl, sourceType]);
+  return null;
+};
+export {
+  TileLayerOthers as T
+};

package/components/maps/components/MapGpsTools/MapGpsTools-pEe1ocS-.js

@@ -0,0 +1,10 @@
+import { jsx } from "react/jsx-runtime";
+import { useModuleSkeleton } from "@m4l/core";
+import { T as TabsGpsTools } from "./subcomponents/TabsGpsTools/index-CnYHbA2S.js";
+function MapGpsTools() {
+  const isSkeleton = useModuleSkeleton();
+  return !isSkeleton && /* @__PURE__ */ jsx(TabsGpsTools, {});
+}
+export {
+  MapGpsTools as M
+};

package/components/maps/components/MapGpsTools/classes/index-oE5Q9Oa0.js

@@ -0,0 +1,21 @@
+import { generateUtilityClasses } from "@mui/material";
+import "@mui/base";
+import { C as COMPONENT_CLASS_NAME } from "../constants-BtQVGkL6.js";
+const gpsToolsClasses = generateUtilityClasses(COMPONENT_CLASS_NAME, [
+  /* elements */
+  "gpsToolsRoot",
+  "gpsToolsTab",
+  "gpsToolsTabContent",
+  "gpsToolsGeofencesList",
+  "gpsToolsGeofencesAddEdit",
+  "gpsToolsGeofencesAddEditContent",
+  "gpsToolsGeofencesAddEditDrawFinishContainer",
+  "toolGeofencesAddEditGeneral",
+  "toolGeofencesAddEditStyle",
+  /* states or variants of elements */
+  "visible",
+  "hidden"
+]);
+export {
+  gpsToolsClasses as g
+};

package/components/maps/components/MapGpsTools/constants-BtQVGkL6.js

@@ -0,0 +1,71 @@
+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: "-- - - --"
+  }
+];
+export {
+  COMPONENT_CLASS_NAME as C,
+  STYLE_OPACITIES as S,
+  STYLE_WHEIGHTS as a,
+  STYLE_PATTERNS as b,
+  COMPONENT_MAP_TOOLS_ID as c
+};

package/components/maps/components/MapGpsTools/contexts/GpsToolsContext/index-0Z4JP4xL.js

@@ -0,0 +1,48 @@
+import { jsx } from "react/jsx-runtime";
+import { createContext, useRef, useEffect } from "react";
+import { useStore } from "zustand";
+import { shallow } from "zustand/shallow";
+import { useResponsiveDesktop, useFirstRender } from "@m4l/graphics";
+import { useModuleDictionary, useModuleSkeleton } from "@m4l/core";
+import { c as createGpsToolsStore } from "./store-B7tH76Xi.js";
+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 });
+}
+export {
+  GpsToolsContext as G,
+  GpsToolsProvider as a
+};

package/components/maps/components/MapGpsTools/contexts/GpsToolsContext/store-B7tH76Xi.js

@@ -0,0 +1,116 @@
+import { createStore } from "zustand";
+import { devtools } from "zustand/middleware";
+import { immer } from "zustand/middleware/immer";
+import { enableMapSet } from "immer";
+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` }
+    )
+  );
+};
+export {
+  createGpsToolsStore as c
+};

package/components/maps/components/MapGpsTools/dictionary-BZWDA1RN.js

@@ -0,0 +1,68 @@
+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"
+};
+export {
+  MAP_GPSTOOLS_DICCTIONARY as M
+};

package/components/maps/components/MapGpsTools/hooks/useGpsToolsStore/index-BCw7XNS9.js

@@ -0,0 +1,11 @@
+import { useContext } from "react";
+import { useStore } from "zustand";
+import { G as GpsToolsContext } from "../../contexts/GpsToolsContext/index-0Z4JP4xL.js";
+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);
+}
+export {
+  useGpsToolsStore as u
+};