@m4l/gclick 0.0.2

package/components/maps/components/GpsMapTools/contexts/GpsMapToolsContext/index.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 createGpsMapToolsStore } from "./store.js";
+const GpsMapToolsContext = createContext(null);
+function GpsMapToolsProvider(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 = createGpsMapToolsStore({
+      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(GpsMapToolsContext.Provider, { value: mapStoreRef.current, children });
+}
+export {
+  GpsMapToolsContext as G,
+  GpsMapToolsProvider as a
+};

package/components/maps/components/GpsMapTools/contexts/GpsMapToolsContext/store.d.ts

@@ -0,0 +1,19 @@
+import { GpsMapToolsStateWithActions, InitialGpsMapToolsStoreProps } from './types';
+/**
+ * Crea el Store, por defecto inicia en estado 'init'
+ * @param initProps propiedades iniciales del store
+ * @returns
+ */
+/**
+ * TODO: Documentar
+ */
+export declare const createGpsMapToolsStore: (initProps: InitialGpsMapToolsStoreProps) => Omit<Omit<import('zustand').StoreApi<GpsMapToolsStateWithActions>, "setState"> & {
+    setState<A extends string | {
+        type: unknown;
+    }>(partial: GpsMapToolsStateWithActions | Partial<GpsMapToolsStateWithActions> | ((state: GpsMapToolsStateWithActions) => GpsMapToolsStateWithActions | Partial<GpsMapToolsStateWithActions>), replace?: boolean | undefined, action?: A | undefined): void;
+}, "setState"> & {
+    setState(nextStateOrUpdater: GpsMapToolsStateWithActions | Partial<GpsMapToolsStateWithActions> | ((state: import('immer/dist/internal').WritableDraft<GpsMapToolsStateWithActions>) => void), shouldReplace?: boolean | undefined, action?: string | {
+        type: unknown;
+    } | undefined): void;
+};
+export type GpsMapToolsStore = ReturnType<typeof createGpsMapToolsStore>;

package/components/maps/components/GpsMapTools/contexts/GpsMapToolsContext/store.js

@@ -0,0 +1,155 @@
+import { createStore } from "zustand";
+import { devtools } from "zustand/middleware";
+import { immer } from "zustand/middleware/immer";
+import { enableMapSet } from "immer";
+enableMapSet();
+const createGpsMapToolsStore = (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: {
+          /**
+           * TODO: Documentar
+           */
+          init: () => {
+            set((state) => {
+              state.ownerState.status = "ready";
+            });
+          },
+          /**
+           * TODO: Documentar
+           */
+          setGpsToolsState: (status) => {
+            set((state) => {
+              state.ownerState.status = status;
+            });
+          },
+          /**
+           * TODO: Documentar
+           */
+          setHandlerGetLabel: (newHandler) => {
+            set((state) => {
+              state.getLabel = newHandler;
+            });
+          },
+          /**
+           * TODO: Documentar
+           */
+          setExternalState: (newExternalState) => {
+            set((state) => {
+              state.ownerState = { ...state.ownerState, ...newExternalState };
+            });
+          },
+          /**
+           * TODO: Documentar
+           */
+          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;
+          //     });
+          // },
+          /**
+           * TODO: Documentar
+           */
+          addGeofence: (geofenceId, geofence) => {
+            set((state) => {
+              state.geofenceState.hashGeofences[geofenceId] = geofence;
+            });
+          },
+          /**
+           * TODO: Documentar
+           */
+          updatePartialGeofence: (geofenceId, geofence) => {
+            set((state) => {
+              state.geofenceState.hashGeofences[geofenceId] = {
+                ...state.geofenceState.hashGeofences[geofenceId],
+                ...geofence
+              };
+            });
+          },
+          /**
+           * TODO: Documentar
+           */
+          updateRows: (newRows) => {
+            set((state) => {
+              state.geofenceState.rows = newRows;
+            });
+          },
+          /**
+           * TODO: Documentar
+           */
+          addCheckedGeofence: (geofenceId) => {
+            set((state) => {
+              state.geofenceState.checkedGeofences.add(geofenceId);
+              state.geofenceState.checkedGeofences = new Set(state.geofenceState.checkedGeofences);
+            });
+          },
+          /**
+           * TODO: Documentar
+           */
+          removeCheckedGeofence: (geofenceId) => {
+            set((state) => {
+              state.geofenceState.checkedGeofences.delete(geofenceId);
+              state.geofenceState.checkedGeofences = new Set(state.geofenceState.checkedGeofences);
+            });
+          },
+          /**
+           * TODO: Documentar
+           */
+          setCheckedGeofences: (newGeofences) => {
+            set((state) => {
+              state.geofenceState.checkedGeofences = new Set(newGeofences);
+            });
+          },
+          /**
+           * TODO: Documentar
+           */
+          setCheckedCrossingFeatures: (newFeatures) => {
+            set((state) => {
+              state.geofenceState.checkedCrossingFeatures = new Set(newFeatures);
+            });
+          },
+          /**
+           * TODO: Documentar
+           */
+          setCheckedInternalFeatures: (newFeatures) => {
+            set((state) => {
+              state.geofenceState.checkedInternalFeatures = new Set(newFeatures);
+            });
+          }
+        }
+      })),
+      { name: `Map Tools Store` }
+    )
+  );
+};
+export {
+  createGpsMapToolsStore as c
+};

package/components/maps/components/GpsMapTools/contexts/GpsMapToolsContext/types.d.ts

@@ -0,0 +1,160 @@
+import { GetLabelType } from '@m4l/core';
+import { ReactNode } from 'react';
+import { FeatureId } from '../../../GpsMap';
+import { CrossingFeature, GeofenceListModel, InternalFeature } from '../../subcomponents/TabsGpsTools/subcomponents/model';
+export type GpsToolsStatus = 'init' | 'ready';
+export type CurrentTabGpsTool = 'geofences' | 'pois';
+export interface GeofenceFeature extends Pick<GeofenceListModel, 'id' | 'name' | 'type' | 'geometry' | 'properties' | 'createdAt' | 'updatedAt' | 'countCrossingFeatures' | 'countInternalFeatures' | 'timeMinInSeconds' | 'timeMinOutSeconds' | 'alias' | 'customerId'> {
+    hasRenderizedGeofence: boolean;
+    /**
+     * "renderizedCrossingFeatures" indica si está renderizado los features de cruce
+     */
+    hasRenderizedCrossingFeatures: boolean;
+    /**
+     * "loadedCrossingFeatures" features cargados, mas no necesariamente visibles (incremental)
+     */
+    loadedCrossingFeatures: CrossingFeature[] | null;
+    /**
+     * "loadedInternalFeatures" features internos cargados, mas no necesariamente visibles (incremental)
+     */
+    loadedInternalFeatures: InternalFeature[] | null;
+    /**
+     * "renderizedInternalFeatures" indica si está renderizado los features internos
+     */
+    hasRenderizedInternalFeatures: boolean;
+}
+export type OwnerState = {
+    status: GpsToolsStatus;
+    /**
+     *  "isMobile" cuando el navegador está en modo celular
+     */
+    isMobile: boolean;
+    /**
+     *  "isSkeleton" indica si el componente está en skeleton.
+     */
+    isSkeleton: boolean;
+    /**
+     * focus: Estado de selección asignado por el usuario.
+     *
+     */
+    focus: boolean;
+};
+/**
+ * Estados que se actulizan por fuera del store, a través de hooks
+ */
+export type ExternalOwnerState = Pick<OwnerState, 'isMobile' | 'isSkeleton'>;
+export type CurrentGeofenceTool = 'list' | 'add_edit';
+/**
+ * Tipo de dato del Id de la geocerca
+ */
+export interface GeofenceState {
+    rows: GeofenceListModel[];
+    /**
+     * "checkedGeofences" indica las geocercas visibles en el mapa
+     */
+    checkedGeofences: ReadonlySet<GeofenceId>;
+    /**
+     * "hashGeofences" Almacena las geocercas que se han cargado alguna vez, no necesariamente visibles
+     */
+    hashGeofences: Record<FeatureId, GeofenceFeature>;
+    /**
+     * "checkedCrossingFeatures" indica los crossing features visibles en el mapa
+     */
+    checkedCrossingFeatures: ReadonlySet<GeofenceId>;
+    /**
+     * "checkedInternalFeatures" indica los features internos visibles en el mapa
+     */
+    checkedInternalFeatures: ReadonlySet<GeofenceId>;
+}
+/**
+ * Tipo de dato del Id de la geocerca
+ */
+export type GeofenceId = number;
+/**
+ * Interface que define el estado del componente (variables y funciones )
+ */
+export interface GpsMapToolsState {
+    ownerState: OwnerState;
+    /**
+     * "currentTabTool" indica la pestaña actual en uso
+     */
+    currentTabGpsTool: CurrentTabGpsTool;
+    /**
+     * "geofenceState" manejo del estado lo relacionado con geocercas
+     */
+    geofenceState: GeofenceState;
+    /**
+     *  "getLabel" funcion que usará para traducir las etiquetas de diccionario
+     */
+    getLabel: GetLabelType;
+}
+export interface GpsMapToolsStateWithActions extends GpsMapToolsState {
+    gpsToolsActions: {
+        /**
+         * @description
+         */
+        init(): void;
+        /**
+         * Cambia el estado del las herramientas de gps
+         */
+        setGpsToolsState: (state: GpsToolsStatus) => void;
+        /**
+         * Actualiza la variable de estado "getLabel"
+         * @param newHandler handle o función que va a traducir las etiquetas, esto es necesario debido que getLabel de useModuleDictionary
+         * cambia por el useCallback, cuando el diccionario se carga.
+         * @returns void
+         */
+        setHandlerGetLabel: (newHandler: GetLabelType) => void;
+        /**
+         * Modifica los estados que se actualizan externamente al Store
+         * @param newIsMobile
+         * @returns
+         */
+        setExternalState: (newExternalState: ExternalOwnerState) => void;
+        /**
+         * Modifica los estados que se actualizan externamente al Store
+         * @param newIsMobile
+         * @returns
+         */
+        setCurrentTabTool: (newTabTool: CurrentTabGpsTool) => void;
+    };
+    geofenceActions: {
+        /**
+         * Agrega una geocerca al store
+         */
+        addGeofence: (geofenceId: GeofenceId, geofence: GeofenceFeature) => void;
+        /**
+         * Actualizar parcialmente una geocerca
+         */
+        updatePartialGeofence: (geofenceId: GeofenceId, geofence: Partial<GeofenceFeature>) => void;
+        /**
+         * Actualizar la filas que son mostradas en el grid de geocercas
+         */
+        updateRows: (newRows: GeofenceListModel[]) => void;
+        /**
+         * Agrega una geocerca del set de chequeo
+         */
+        addCheckedGeofence: (geofenceId: GeofenceId) => void;
+        /**
+         * Cambia el set de chequeo de las geocercas
+         */
+        setCheckedGeofences: (newGeofences: ReadonlySet<GeofenceId>) => void;
+        /**
+         * Remueve una geocerca del set de chequeo
+         */
+        removeCheckedGeofence: (geofenceId: GeofenceId) => void;
+        /**
+         * Cambia el set de chequeo de los crossing features
+         */
+        setCheckedCrossingFeatures: (newFeatures: ReadonlySet<GeofenceId>) => void;
+        /**
+         * Cambia el set de chequeo de los internal features
+         */
+        setCheckedInternalFeatures: (newFeatures: ReadonlySet<GeofenceId>) => void;
+    };
+}
+export type DefaultGpsMapToolsStoreProps = Omit<GpsMapToolsState, 'currentLayer'>;
+export type InitialGpsMapToolsStoreProps = Pick<GpsMapToolsState, 'getLabel' | 'ownerState'> & Partial<DefaultGpsMapToolsStoreProps>;
+export interface GpsMapToolsProviderProps {
+    children: ReactNode;
+}

package/components/maps/components/GpsMapTools/dictionary.d.ts

@@ -0,0 +1,62 @@
+export declare const MAPGPSTOOLS_DICTIONARY_ID = "gps_tools";
+/**
+ * TODO: Documentar
+ */
+export declare function getGpsMapToolsComponentsDictionary(): string[];
+export declare const MAP_GPSTOOLS_DICCTIONARY: {
+    /** Common */
+    /** GeofenceList */
+    readonly MODULE_NAME_GEOFENCE_ADD: "module_name_geofence_add";
+    readonly MODULE_NAME_GEOFENCE_EDIT: "module_name_geofence_edit";
+    readonly ROW_ACTION_GEO_EDIT: "row_action_geo_edit";
+    readonly ROW_ACTION_GEO_DELETE: "row_action_geo_delete";
+    /** GeofenceAddEdit */
+    readonly LABEL_TAB_GEO: "label_tab_geo";
+    readonly TAB_GENERAL_CONFIG_TOOLTIP: "tab_general_config_tooltip";
+    readonly PAPER_GENERAL: "paper_general";
+    readonly LABEL_ID: "label_id";
+    readonly LABEL_NAME: "label_name";
+    readonly LABEL_ALIAS: "label_alias";
+    readonly LABEL_CUSTOMER_ID: "label_customer_id";
+    readonly LABEL_GEOMETRY_TYPE: "label_geometry_type";
+    readonly LABEL_GEOMETRY_CIRCLE: "label_geometry_circle";
+    readonly LABEL_GEOMETRY_RECTANGLE: "label_geometry_rectangle";
+    readonly LABEL_GEOMETRY_POLYGON: "label_geometry_polygon";
+    readonly LABEL_DRAW: "label_draw";
+    readonly LABEL_FINISH: "label_finish";
+    readonly PAPER_CONFIG: "paper_config";
+    readonly LABEL_TIME_MIN_IN_SECONDS: "label_time_min_in_seconds";
+    readonly LABEL_TIME_MIN_OUT_SECONDS: "label_time_min_out_seconds";
+    readonly TAB_STYLE_CONFIG_TOOLTIP: "tab_style_tooltip";
+    readonly PAPER_STROKE: "paper_stroke";
+    readonly LABEL_COLOR: "label_color";
+    readonly LABEL_OPACITY: "label_opacity";
+    readonly LABEL_WEIGHT: "label_weight";
+    readonly LABEL_DASH_ARRAY: "label_dash_array";
+    readonly PAPER_FILL: "paper_fill";
+    readonly LABEL_RADIUS: "label_radius";
+    readonly LABEL_LAT: "label_lat";
+    readonly LABEL_LON: "label_lon";
+    readonly LABEL_PLACE_MARKER: "label_place_marker";
+    readonly LABEL_FIRST_VERTEX: "label_first_vertex";
+    readonly LABEL_CONTINUE_LINE: "label_continue_line";
+    readonly LABEL_FINISH_LINE: "label_finish_line";
+    readonly LABEL_FINISH_POLY: "label_finish_poly";
+    readonly LABEL_FINISH_RECT: "label_finish_rect";
+    readonly LABEL_START_CIRCLE: "label_start_circle";
+    readonly LABEL_FINISH_CIRCLE: "label_finish_circle";
+    readonly LABEL_PLACE_CIRCLE_MARKER: "label_place_circle_marker";
+    readonly VALIDATION_GEOMETRY_REQUIRED: "validation_geometry_required";
+    readonly VALIDATION_FIELD_REQUIRED: "validation_field_required";
+    readonly VALIDATION_FIELD_TYPE_NUMBER_ERROR: "validation_field_type_number_error";
+    readonly VALIDATION_FIELD_MIN_NUMBER_ERROR: "validation_field_min_number_error";
+    readonly LABEL_VIEW_TRANSIT_FEATURES: "label_view_crossing_features";
+    readonly LABEL_VIEW_INTERNAL_FEATURES: "label_view_internal_features";
+    readonly LABEL_CREATED_AT: "label_created_at";
+    readonly LABEL_UPDATED_AT: "label_updated_at";
+    readonly MODAL_DELETE_GEO_TITLE: "modal_delete_geo_title";
+    readonly MODAL_DELETE_GEO_MESSAGE: "modal_delete_geo_message";
+    readonly MODAL_DISABLE_GEO_TITLE: "modal_disable_geo_title";
+    readonly MODAL_DISABLE_MESSAGE: "modal_disable_geo_message";
+    readonly ACTION_CANCEL: "action_cancel";
+};

package/components/maps/components/GpsMapTools/dictionary.js

@@ -0,0 +1,66 @@
+import { getDataGridComponentsDictionary, getRHFAutocompleteComponentsDictionary, getDynamicFilterComponentsDictionary } from "@m4l/components";
+const MAPGPSTOOLS_DICTIONARY_ID = "gps_tools";
+function getGpsMapToolsComponentsDictionary() {
+  return [MAPGPSTOOLS_DICTIONARY_ID].concat(
+    getDataGridComponentsDictionary().concat(getRHFAutocompleteComponentsDictionary()).concat(getDynamicFilterComponentsDictionary())
+  );
+}
+const MAP_GPSTOOLS_DICCTIONARY = {
+  /** Common */
+  /** GeofenceList */
+  MODULE_NAME_GEOFENCE_ADD: "module_name_geofence_add",
+  MODULE_NAME_GEOFENCE_EDIT: "module_name_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_ALIAS: "label_alias",
+  LABEL_CUSTOMER_ID: "label_customer_id",
+  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_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",
+  PAPER_FILL: "paper_fill",
+  LABEL_RADIUS: "label_radius",
+  LABEL_LAT: "label_lat",
+  LABEL_LON: "label_lon",
+  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_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",
+  ACTION_CANCEL: "action_cancel"
+};
+export {
+  MAP_GPSTOOLS_DICCTIONARY as M,
+  getGpsMapToolsComponentsDictionary as g
+};

package/components/maps/components/GpsMapTools/hooks/useGpsMapToolsStore/index.d.ts

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

package/components/maps/components/GpsMapTools/hooks/useGpsMapToolsStore/index.js

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

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

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

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

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

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

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

package/components/maps/components/GpsMapTools/icons.js

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

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

@@ -0,0 +1,4 @@
+export { GpsMapTools } from './GpsMapTools';
+export { GpsMapToolsProvider } from './contexts/GpsMapToolsContext';
+export { getGpsMapToolsComponentsDictionary as getGpsMapToolsComponentsDictionary } from './dictionary';
+export { useGpsMapToolsStore } from './hooks/useGpsMapToolsStore';

package/components/maps/components/GpsMapTools/index.js

@@ -0,0 +1 @@
+

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

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

package/components/maps/components/GpsMapTools/styles.js

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