@m4l/gclick 0.0.2

package/components/maps/components/GpsMap/subcomponents/LayersContainer/subcomponents/MyLayer/index.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.js";
+import { R as RenderByEachFeatureComponent, M as MemonizedRenderByEachFeatureComponent } from "./subcomponents/RenderByEachFeatureComponent/index.js";
+import { T as TIME_DOUBLE_CLICK } from "../../../../constants.js";
+import { u as useMapStore } from "../../../../hooks/useMapStore/index.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 clusterMarker = a.propagatedFrom;
+        if (clusterMarker && clusterMarker 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 = (markerCluster) => {
+      const childCount = markerCluster.getChildCount();
+      let c = " marker-cluster-";
+      if (childCount < 10) {
+        c += "small";
+      } else if (childCount < 100) {
+        c += "medium";
+      } else {
+        c += "large";
+      }
+      const MyDivIcon = new L__default.DivIcon({
+        html: "<div><span>" + childCount + "</span></div>",
+        className: "marker-cluster" + c,
+        iconSize: new L__default.Point(40, 40)
+      });
+      return MyDivIcon;
+    };
+    if (!cluster) {
+      return /* @__PURE__ */ jsx(LayerGroup, { children: featureIdOrCollection.map((featureId) => {
+        return /* @__PURE__ */ jsx(
+          MemonizedRenderByEachFeatureComponent,
+          {
+            renderFeature,
+            id: featureId,
+            layerId
+          },
+          `k_${layerId}_${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_${layerId}_${featureId}`
+            );
+          })
+        }
+      );
+    }
+  }
+};
+export {
+  MyLayer as M
+};

package/components/maps/components/GpsMap/subcomponents/LayersContainer/subcomponents/MyLayer/subcomponents/MarkerClusterGroup/index.d.ts

@@ -0,0 +1,9 @@
+import { default as L } from 'leaflet';
+import { MarkerClusterGroupProps } from './types';
+/**
+ * MarkerClusterGroup, es un componente funcional que enmascara el comportamiento que
+ * leaflet.markercluster tiene, no aporta lógica adicional, solo es un wrapper para que funcione
+ * en React. Utilizando createPathComponent de @react-leaflet/core.
+ * @returns ForwardRefExoticComponent (significa que es un componente que ha sido envuelto con React.forwardRef.).
+ */
+export declare const MarkerClusterGroup: import('react').ForwardRefExoticComponent<L.MarkerClusterGroupOptions & import('@react-leaflet/core').PathProps & import('./types').PropsWithChildren & import('react').RefAttributes<MarkerClusterGroupProps>>;

package/components/maps/components/GpsMap/subcomponents/LayersContainer/subcomponents/MyLayer/subcomponents/MarkerClusterGroup/index.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/GpsMap/subcomponents/LayersContainer/subcomponents/MyLayer/subcomponents/MarkerClusterGroup/types.d.ts

@@ -0,0 +1,11 @@
+import { PathProps } from '@react-leaflet/core';
+import { FeatureGroup, LeafletEventHandlerFn, MarkerClusterGroupOptions } from 'leaflet';
+import { ReactNode } from 'react';
+export interface MarkerClusterGroupProps extends FeatureGroup, MarkerClusterGroupOptions {
+    onClustering?: LeafletEventHandlerFn;
+    onCluster?: LeafletEventHandlerFn;
+}
+export declare type PropsWithChildren = {
+    children?: ReactNode;
+};
+export type PathWithChildrenProps = MarkerClusterGroupOptions & PathProps & PropsWithChildren;

package/components/maps/components/GpsMap/subcomponents/LayersContainer/subcomponents/MyLayer/subcomponents/RenderByEachFeatureComponent/index.d.ts

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+import { RenderByEachFeatureProps } from './types';
+/**
+ * "RenderByEachFeatureComponent": Es un wrapper de renderFeature,
+ * Se realizó con el fin de que no haya re-renderizado de los features,
+ * Sin este wrapper cada vez que se actualiza LeafletLayer, se re-renderiza todos lo features.
+ * @param param0
+ * @returns
+ */
+export declare const RenderByEachFeatureComponent: React.FC<RenderByEachFeatureProps>;
+export declare const MemonizedRenderByEachFeatureComponent: React.NamedExoticComponent<RenderByEachFeatureProps>;

package/components/maps/components/GpsMap/subcomponents/LayersContainer/subcomponents/MyLayer/subcomponents/RenderByEachFeatureComponent/index.js

@@ -0,0 +1,13 @@
+import React from "react";
+const RenderByEachFeatureComponent = ({
+  renderFeature,
+  ...props
+}) => {
+  const feature = renderFeature(props);
+  return feature ?? null;
+};
+const MemonizedRenderByEachFeatureComponent = React.memo(RenderByEachFeatureComponent);
+export {
+  MemonizedRenderByEachFeatureComponent as M,
+  RenderByEachFeatureComponent as R
+};

package/components/maps/components/GpsMap/subcomponents/LayersContainer/subcomponents/MyLayer/subcomponents/RenderByEachFeatureComponent/types.d.ts

@@ -0,0 +1,5 @@
+import { ReactNode } from 'react';
+import { RendePropFeatureArgs } from '../../../../../../contexts/MapContext/types';
+export type RenderByEachFeatureProps = {
+    renderFeature: (props: RendePropFeatureArgs) => ReactNode;
+} & RendePropFeatureArgs;

package/components/maps/components/GpsMap/subcomponents/LayersContainer/subcomponents/MyLayer/types.d.ts

@@ -0,0 +1,2 @@
+import { LayerStore } from '../../../../contexts/MapContext/types';
+export type LayerProps = Pick<LayerStore, 'layerId'>;

package/components/maps/components/GpsMap/subcomponents/TileLayers/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Componente encargado de renderizar las diferentes tipos de mapas, de acuerdo
+ * al mapa seleccionado en el store
+ * @returns
+ */
+export declare function TileLayers(): import("react/jsx-runtime").JSX.Element;

package/components/maps/components/GpsMap/subcomponents/TileLayers/index.js

@@ -0,0 +1,27 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { T as TileLayerOthers } from "./subcomponents/TileLayerOthers/index.js";
+import { T as TileLayerGoogle } from "./subcomponents/TileLayerGoogle/index.js";
+import React, { useEffect } from "react";
+import { useMap } from "react-leaflet";
+function TileLayers() {
+  const map = useMap();
+  useEffect(() => {
+    const handleResize = () => {
+      map.invalidateSize();
+    };
+    const resizeObserver = new ResizeObserver((_entries) => {
+      handleResize();
+    });
+    resizeObserver.observe(map.getContainer());
+    return () => {
+      resizeObserver.unobserve(map.getContainer());
+    };
+  }, [map]);
+  return /* @__PURE__ */ jsxs(React.Fragment, { children: [
+    /* @__PURE__ */ jsx(TileLayerOthers, {}),
+    /* @__PURE__ */ jsx(TileLayerGoogle, {})
+  ] });
+}
+export {
+  TileLayers as T
+};

package/components/maps/components/GpsMap/subcomponents/TileLayers/subcomponents/TileLayerGoogle/index.d.ts

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

package/components/maps/components/GpsMap/subcomponents/TileLayers/subcomponents/TileLayerGoogle/index.js

@@ -0,0 +1,100 @@
+import React from "react";
+import { useMap } from "react-leaflet";
+import L__default from "leaflet";
+import { u as useMapStore } from "../../../../hooks/useMapStore/index.js";
+import { shallow } from "zustand/shallow";
+import { Loader } from "@googlemaps/js-api-loader";
+function TileLayerGoogle() {
+  const map = useMap();
+  const mutantRefLayer = React.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.googleMapsApiKey, state.googleMapVersion],
+    shallow
+  );
+  React.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.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.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.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/GpsMap/subcomponents/TileLayers/subcomponents/TileLayerOthers/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * "OtherSourceMapsLayer" componente encargado de renderizar la capa de mapa seleccionado.
+ * Este componente no renderiza, las capas de google.
+ * @returns null
+ */
+export declare const TileLayerOthers: () => null;

package/components/maps/components/GpsMap/subcomponents/TileLayers/subcomponents/TileLayerOthers/index.js

@@ -0,0 +1,35 @@
+import { useMap } from "react-leaflet";
+import { shallow } from "zustand/shallow";
+import { u as useMapStore } from "../../../../hooks/useMapStore/index.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/GpsMap/types.d.ts

@@ -0,0 +1,56 @@
+import { OverridesStyleRules } from '@mui/material/styles/overrides';
+import { LatLngExpression } from 'leaflet';
+import { Theme } from '@mui/material/styles';
+import { MapSlots } from './slots/slots';
+import { COMPONET_KEY_COMPONENT } from './constants';
+import { ReactNode } from 'react';
+export type Localization = {
+    /**
+     *  "lat" Posición en del eje "Y" en grados.
+     */
+    lat: number;
+    /**
+     *  "lng" Posición en del eje "X" en grados.
+     */
+    lng: number;
+};
+export type Point = {
+    /**
+     *  "x" Posición en del eje "X" en pixeles.
+     */
+    x: number;
+    /**
+     *  "y" Posición en del eje "Y" en pixeles.
+     */
+    y: number;
+};
+export interface MapProps {
+    /**
+     * "center" posición inicial del mapa.
+     */
+    center?: LatLngExpression | undefined;
+    /**
+     * "initialZoom" Zoom inicial del mapa. Por defecto es 16
+     */
+    initalZoom?: number;
+    /**
+     * "maxZoom" Max Zoom global, por defecto es 22, sin embargo cada TileLayer coloca su propio maxZoom.
+     */
+    maxZoom?: number;
+    /**
+     * "tools" Componente que gestiona la herramienta de guardian GPS, geocercas, puntos de interes, etc.
+     */
+    tools?: ((props?: any) => JSX.Element) | ReactNode;
+}
+export type MapSlotsType = keyof typeof MapSlots;
+export type MapOwnerState = {
+    /**
+     *  "isMobile" cuando el navegador está corriendo en dispositivo móvil
+     */
+    isMobile?: boolean;
+    /**
+     * "hidden" permite definir si la ventana está oculta o no. Por defecto es "false
+     */
+    hidden?: boolean;
+};
+export type MapStyles = Partial<OverridesStyleRules<MapSlotsType, typeof COMPONET_KEY_COMPONENT, Theme> | undefined> | undefined;

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

@@ -0,0 +1,4 @@
+/**
+ * TODO: Documentar
+ */
+export declare function GpsMapTools(): import("react/jsx-runtime").JSX.Element | null;

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

@@ -0,0 +1,10 @@
+import { jsx } from "react/jsx-runtime";
+import { useModuleSkeleton } from "@m4l/core";
+import { T as TabsGpsTools } from "./subcomponents/TabsGpsTools/index.js";
+function GpsMapTools() {
+  const isSkeleton = useModuleSkeleton();
+  return isSkeleton ? null : /* @__PURE__ */ jsx(TabsGpsTools, {});
+}
+export {
+  GpsMapTools as G
+};

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

@@ -0,0 +1,7 @@
+import { GpsToolsClasses } from './types';
+export declare const gpsToolsClasses: GpsToolsClasses;
+/**
+ * TODO: Documentar
+ */
+export declare const useUtilityClasses: () => Record<"gpsToolsGeofencesList" | "gpsToolsGeofencesAddEdit" | "gpsToolsGeofencesAddEditContent" | "gpsToolsGeofencesAddEditDrawFinishContainer" | "toolGeofencesAddEditGeneral" | "toolGeofencesAddEditStyle" | "GpsToolsRoot" | "GpsToolsTabContent" | "GpsToolsTab", string>;
+export type Classes = ReturnType<typeof useUtilityClasses>;

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

@@ -0,0 +1,21 @@
+import { generateUtilityClasses } from "@mui/material";
+import "@mui/base";
+import { C as COMPONENT_CLASS_NAME } from "../constants.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/GpsMapTools/classes/types.d.ts

@@ -0,0 +1,14 @@
+export interface GpsToolsClasses {
+    gpsToolsRoot: string;
+    gpsToolsTab: string;
+    gpsToolsTabContent: string;
+    gpsToolsGeofencesList: string;
+    gpsToolsGeofencesAddEdit: string;
+    gpsToolsGeofencesAddEditContent: string;
+    gpsToolsGeofencesAddEditDrawFinishContainer: string;
+    toolGeofencesAddEditGeneral: string;
+    toolGeofencesAddEditStyle: string;
+    visible: string;
+    hidden: string;
+}
+export type GpsToolsClassesKey = keyof GpsToolsClasses;

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

@@ -0,0 +1,8 @@
+import { StyleOpacity, StyleDashArray, StyleWheight } from './types';
+export declare const COMPONENT_TEST_ID = "M4LGpsMapTools";
+export declare const COMPONENT_CLASS_NAME = "M4LGpsMapTools";
+export declare const COOKIE_MAP_GEO_FILTER = "filter_map_geo";
+export declare const COMPONENT_MAP_TOOLS_ID = "gps_tools";
+export declare const STYLE_OPACITIES: StyleOpacity[];
+export declare const STYLE_WHEIGHTS: StyleWheight[];
+export declare const STYLE_PATTERNS: StyleDashArray[];

package/components/maps/components/GpsMapTools/constants.js

@@ -0,0 +1,71 @@
+const COMPONENT_CLASS_NAME = "M4LGpsMapTools";
+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/GpsMapTools/contexts/GpsMapToolsContext/index.d.ts

@@ -0,0 +1,21 @@
+import { GpsMapToolsProviderProps } from './types';
+declare const GpsMapToolsContext: import('react').Context<(Omit<Omit<import('zustand').StoreApi<import('./types').GpsMapToolsStateWithActions>, "setState"> & {
+    setState<A extends string | {
+        type: unknown;
+    }>(partial: import('./types').GpsMapToolsStateWithActions | Partial<import('./types').GpsMapToolsStateWithActions> | ((state: import('./types').GpsMapToolsStateWithActions) => import('./types').GpsMapToolsStateWithActions | Partial<import('./types').GpsMapToolsStateWithActions>), replace?: boolean | undefined, action?: A | undefined): void;
+}, "setState"> & {
+    setState(nextStateOrUpdater: import('./types').GpsMapToolsStateWithActions | Partial<import('./types').GpsMapToolsStateWithActions> | ((state: import('immer/dist/internal').WritableDraft<import('./types').GpsMapToolsStateWithActions>) => void), shouldReplace?: boolean | undefined, action?: string | {
+        type: unknown;
+    } | undefined): void;
+}) | null>;
+/**
+ * Provedor del contexto de los mapas
+ * Expone el store (MapStore) encargado de gestionar la creación, modificación y borrado de capas.
+ * @param props
+ * @returns
+ */
+/**
+ * TODO: Documentar
+ */
+declare function GpsMapToolsProvider(props: GpsMapToolsProviderProps): import("react/jsx-runtime").JSX.Element;
+export { GpsMapToolsProvider, GpsMapToolsContext };