@m4l/components 0.2.1 → 0.2.2

package/components/maps/components/GpsTools/subcomponents/TabTools/subcomponents/GeofencesTool/subcomponents/GeofenceAddEdit/subcomponents/StyleData/types.d.ts

@@ -0,0 +1,10 @@
+import { Maybe } from "@m4l/core";
+import { StyleOpacity, StyleDashArray, StyleWheight } from "../../../../../../../../types";
+export interface FormStyleDataValues {
+    strokeColor?: string;
+    strokeOpacity?: Maybe<StyleOpacity>;
+    strokeWeight?: Maybe<StyleWheight>;
+    strokeDashArray?: Maybe<StyleDashArray>;
+    fillColor?: string;
+    fillOpacity?: Maybe<StyleOpacity>;
+}

package/components/maps/components/GpsTools/subcomponents/TabTools/subcomponents/GeofencesTool/subcomponents/GeofenceAddEdit/types.d.ts

@@ -0,0 +1,25 @@
+import { StyleOpacity, StyleDashArray, StyleWheight } from '../../../../../../types';
+import { GeofenceGetModel } from '../../model';
+import { FormConfigDataValues } from './subcomponents/ConfigData/types';
+import { FormGeneralDataValues } from './subcomponents/GeneralData/types';
+import { FormStyleDataValues } from './subcomponents/StyleData/types';
+export declare type ResponseGet = {
+    data: GeofenceGetModel;
+};
+export declare type FormAddEditValues = FormGeneralDataValues & FormConfigDataValues & FormStyleDataValues & {
+    inEdition: boolean;
+    lat?: number | null;
+    lng?: number | null;
+    properties: {
+        radius?: number | null;
+        strokeColor: string;
+        strokeOpacity: StyleOpacity;
+        strokeWeight: StyleWheight;
+        strokeDashArray: StyleDashArray;
+        fillColor: string;
+        fillOpacity: StyleOpacity;
+    };
+};
+export interface GeofenceAddEditProps {
+    geofenceId?: number;
+}

package/components/maps/components/GpsTools/subcomponents/TabTools/subcomponents/GeofencesTool/subcomponents/GeofencesList/index.d.ts

@@ -0,0 +1 @@
+export declare function GeofencesList(): import("react/jsx-runtime").JSX.Element;

package/components/maps/components/GpsTools/subcomponents/TabTools/subcomponents/GeofencesTool/subcomponents/GeofencesList/subcomponents/Filter/index.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+interface FilterProps {
+    refresh: () => void;
+    setBackendQueryParams: React.Dispatch<React.SetStateAction<Record<string, unknown>>>;
+}
+export declare function Filter(props: FilterProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/components/maps/components/GpsTools/subcomponents/TabTools/subcomponents/GeofencesTool/subcomponents/PolylineWithArrows/index.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { LatLngExpression } from 'leaflet';
+import { PolylineProps } from 'react-leaflet';
+interface PolylineWithArrowsProps extends PolylineProps {
+    positions: LatLngExpression[];
+    enableEdit?: boolean;
+}
+export declare const PolylineWithArrows: React.FC<PolylineWithArrowsProps>;
+export default PolylineWithArrows;

package/components/maps/components/GpsTools/subcomponents/TabTools/subcomponents/MeasureTool/constants.d.ts

@@ -0,0 +1,30 @@
+import { FormMeasureValues } from './types';
+export declare const STROKE_COLOR_DEFAULT = "#aaccaa";
+export declare const STROKE_OPACITY_DEFAULT: {
+    value: number;
+    label: string;
+};
+export declare const STROKE_WHEIGTH_DEFAULT: {
+    value: number;
+    label: string;
+};
+export declare const STROKE_DASH_ARRAY_DEFAULT: {
+    value: string;
+    label: string;
+};
+export declare const FILL_COLOR_DEFAULT = "#aa3000";
+export declare const FILL_OPACITY_DEFAULT: {
+    value: number;
+    label: string;
+};
+export declare const INITIAL_FORM_VALUES: FormMeasureValues;
+export declare const STYLE_MEASURE_OPTIONS: {
+    strokeLineColor: string;
+    strokeLineWeight: number;
+    markerHeight: number;
+    markerWidth: number;
+    labelMarkerHeight: number;
+    labelMarkerWidth: number;
+    labelMarkerAnchorY: number;
+    labelMarkerAnchorX: number;
+};

package/components/maps/components/GpsTools/subcomponents/TabTools/subcomponents/MeasureTool/hooks/useMeasure.d.ts

@@ -0,0 +1,31 @@
+import * as L from 'leaflet';
+import { MagnitudeFactorItem } from '../../../../../types';
+import { StatusEdition } from '../types';
+/**
+ * hook Encargado manejar los eventos de dibujo y setear en hook forms values,
+ * los datos asociados a una geocerca
+ * @returns
+ */
+export declare type MeasurePoint = {
+    marker: L.Marker;
+    labelMarker: L.Marker;
+    formatDistanceFromPrevious: string | undefined;
+};
+export interface RefCurrentMeasure {
+    dragging: boolean;
+    addMarker: boolean;
+    measurePoints: Array<MeasurePoint>;
+    layerLine?: L.Polyline;
+    magnitudFactor: MagnitudeFactorItem;
+}
+/**
+ * useMeasure hook se encarga de pintar las marcas y una línea que las une, para calcular la distancia o el area
+ * de ellas. En su primera versión no incluye agregar nuevas marcas entre los vertices por facilidad de implementación
+ * ya que el costo beneficio es muy alto si se coloca esa capacidad.
+ * @returns
+ */
+export declare function useMeasure(): {
+    statusEdition: StatusEdition;
+    magnitudFactor: MagnitudeFactorItem;
+    value: number;
+};

package/components/maps/components/GpsTools/subcomponents/TabTools/subcomponents/MeasureTool/hooks/useValidation.d.ts

@@ -0,0 +1,10 @@
+import * as Yup from 'yup';
+export declare function useValidation(): {
+    validationSchema: Yup.ObjectSchema<{
+        [x: string]: Yup.AnySchema<any, any, any> | import("yup/lib/Reference").default<unknown> | import("yup/lib/Lazy").default<any, any>;
+    }, import("yup/lib/object").AnyObject, import("yup/lib/object").TypeOfShape<{
+        [x: string]: Yup.AnySchema<any, any, any> | import("yup/lib/Reference").default<unknown> | import("yup/lib/Lazy").default<any, any>;
+    }>, import("yup/lib/object").AssertsShape<{
+        [x: string]: Yup.AnySchema<any, any, any> | import("yup/lib/Reference").default<unknown> | import("yup/lib/Lazy").default<any, any>;
+    }>>;
+};

package/components/maps/components/GpsTools/subcomponents/TabTools/subcomponents/MeasureTool/index.d.ts

@@ -0,0 +1 @@
+export declare function MeasureTool(): import("react/jsx-runtime").JSX.Element;

package/components/maps/components/GpsTools/subcomponents/TabTools/subcomponents/MeasureTool/subcomponents/MeasureData/index.d.ts

@@ -0,0 +1 @@
+export declare function MeasureData(): import("react/jsx-runtime").JSX.Element;

package/components/maps/components/GpsTools/subcomponents/TabTools/subcomponents/MeasureTool/subcomponents/MeasureData/types.d.ts

@@ -0,0 +1,6 @@
+import { MagnitudeFactorItem, MeasureTypeId } from "../../../../../../types";
+export interface FormGeneralDataValues {
+    measureTypeId: MeasureTypeId;
+    magnitudFactor?: MagnitudeFactorItem | null;
+    unitArea?: MagnitudeFactorItem | null;
+}

package/components/maps/components/GpsTools/subcomponents/TabTools/subcomponents/MeasureTool/subcomponents/MeasureData/validations.d.ts

@@ -0,0 +1,2 @@
+import { GetLabelType } from '@m4l/core';
+export declare function MeasureDataValidation(getLabel: GetLabelType): {};

package/components/maps/components/GpsTools/subcomponents/TabTools/subcomponents/MeasureTool/subcomponents/MyActions/index.d.ts

@@ -0,0 +1 @@
+export declare function MyActions(): import("react/jsx-runtime").JSX.Element;

package/components/maps/components/GpsTools/subcomponents/TabTools/subcomponents/MeasureTool/types.d.ts

@@ -0,0 +1,9 @@
+import { FormStatusLoad } from '../../../../../../../../contexts';
+import { FormGeneralDataValues } from './subcomponents/MeasureData/types';
+export declare type StatusEdition = 'initial' | 'draw';
+export declare type FormMeasureValues = FormGeneralDataValues & {
+    statusLoad: FormStatusLoad;
+    reInits: number;
+    statusEdition: StatusEdition;
+    value: string | null;
+};

package/components/maps/components/GpsTools/types.d.ts

@@ -0,0 +1,34 @@
+import { GeofenceTypeId } from "./subcomponents/TabTools/subcomponents/GeofencesTool/model";
+/**
+ * Por ahora solo distancia.
+ */
+export declare type MeasureTypeId = 'distance';
+export interface MeasureTypeItem {
+    id: MeasureTypeId;
+    name: string;
+}
+export interface MagnitudeFactorItem {
+    id: string;
+    name: string;
+    symbol: string;
+    factor_x0: number;
+    factor_x1: number;
+    factor_x2: number;
+}
+export interface GeofenceTypeItem {
+    id: GeofenceTypeId;
+    name: string;
+    url: string;
+}
+export interface StyleOpacity {
+    value: number;
+    label: string;
+}
+export interface StyleWheight {
+    value: number;
+    label: string;
+}
+export interface StyleDashArray {
+    value: string;
+    label: string;
+}

package/components/maps/components/Map/Map.d.ts

@@ -0,0 +1,2 @@
+import { MapProps } from './types';
+export declare function Map(props: MapProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,5 @@
+import { MapClasses } from './types';
+import { OwnerState } from '../contexts/MapContext/types';
+export declare const mapClasses: MapClasses;
+export declare const useMapUtilityClasses: (ownerState: OwnerState) => Record<"root" | "mapContainer" | "svgLayersContainer" | "svgLayer" | "svgLayerMultiPoints" | "layerMarker" | "mainToolsRoot" | "measureMarkerRoot" | "measureMarkerContainer" | "measureMarkerContainerRhomb" | "measureMarkerContainerSlot" | "measureMarkerContainerSlotNumber" | "measureLabelMarkerRoot" | "measureLabelMarkerContainer" | "measureLabelMarkerDistance" | "measureLabelMarkerRemove", string>;
+export declare type Classes = ReturnType<typeof useMapUtilityClasses>;

package/components/maps/components/Map/classes/types.d.ts

@@ -0,0 +1,19 @@
+export interface MapClasses {
+    root: string;
+    mapContainer: string;
+    svgLayersContainer: string;
+    svgLayer: string;
+    svgLayerMultiPoints: string;
+    layerMarker: string;
+    mainToolsRoot: string;
+    measureMarkerRoot: string;
+    measureMarkerContainer: string;
+    measureMarkerContainerRhomb: string;
+    measureMarkerContainerSlot: string;
+    measureMarkerContainerSlotNumber: string;
+    measureLabelMarkerRoot: string;
+    measureLabelMarkerContainer: string;
+    measureLabelMarkerDistance: string;
+    measureLabelMarkerRemove: string;
+}
+export declare type MapClassesKey = keyof MapClasses;

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

@@ -0,0 +1,10 @@
+export declare const COMPONENT_TEST_ID = "M4LMap";
+export declare const COMPONENT_CLASS_NAME = "M4LMap";
+export declare const EARTH_RADIO = 6378137;
+export declare const DN = 500;
+export declare const DE = 500;
+export declare const DLAT: number;
+export declare const THROTTLE_RENDER_MAP_TIMEOUT = 50;
+export declare const MAP_ZINDEX_DEFAULT = 0;
+export declare const MAP_ZINDEX_OVER_LAYERS = 1000;
+export declare const MAP_ZINDEX_OVER_MAP = 1100;

package/components/maps/components/Map/contexts/MapContext/MapContext.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="react" />
+import type { MapProviderProps } from './types';
+declare const MapContext: import("react").Context<(Omit<Omit<import("zustand").StoreApi<import("./types").MapStateWithActions>, "setState"> & {
+    setState<A extends string | {
+        type: unknown;
+    }>(partial: import("./types").MapStateWithActions | Partial<import("./types").MapStateWithActions> | ((state: import("./types").MapStateWithActions) => import("./types").MapStateWithActions | Partial<import("./types").MapStateWithActions>), replace?: boolean | undefined, action?: A | undefined): void;
+}, "setState"> & {
+    setState(nextStateOrUpdater: import("./types").MapStateWithActions | Partial<import("./types").MapStateWithActions> | ((state: import("immer/dist/internal").WritableDraft<import("./types").MapStateWithActions>) => void), shouldReplace?: boolean | undefined, action?: string | {
+        type: unknown;
+    } | undefined): void;
+}) | null>;
+/**
+ * @description 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
+ */
+declare function MapProvider(props: MapProviderProps): import("react/jsx-runtime").JSX.Element;
+export { MapProvider, MapContext };

package/components/maps/components/Map/contexts/MapContext/helper.d.ts

@@ -0,0 +1,8 @@
+import { WritableDraft } from 'immer/dist/internal';
+import type { MapStateWithActions, LayerStore } from './types';
+export declare const DEFAULT_LAYER: Partial<LayerStore>;
+/**
+ * @description Actualiza la clases basado en owner state
+ * @param state immer State
+ */
+export declare const updateOwnerStateClasses: (state: WritableDraft<MapStateWithActions>) => void;

package/components/maps/components/Map/contexts/MapContext/index.d.ts

@@ -0,0 +1,2 @@
+export { MapProvider, MapContext } from './MapContext';
+export type { RendePropFeatureArgs, ComponentRenderPropFeature, FeatureId, FeatureCollection, Feature, Geometry } from './types';

package/components/maps/components/Map/contexts/MapContext/store.d.ts

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

package/components/maps/components/Map/contexts/MapContext/types.d.ts

@@ -0,0 +1,354 @@
+import { GetLabelType } from '@m4l/core';
+import { ReactNode } from 'react';
+import { MapClasses } from '../../classes/types';
+export declare type FeatureId = string | number;
+/**
+ * The valid values for the "type" property of GeoJSON* geometry objects.
+ * https://tools.ietf.org/html/rfc7946#section-1.4
+ */
+export declare type GeoJsonGeometryTypes = Geometry['type'];
+/**
+ * The value values for the "type" property of GeoJSON* Objects.
+ * https://tools.ietf.org/html/rfc7946#section-1.4
+ */
+export declare type GeoJsonTypes = GeoJSON['type'];
+/**
+ * Bounding box
+ * https://tools.ietf.org/html/rfc7946#section-5
+ */
+export declare type BBox = [number, number, number, number] | [number, number, number, number, number, number];
+/**
+ * A Position is an array of coordinates.
+ * https://tools.ietf.org/html/rfc7946#section-3.1.1
+ * Array should contain between two and three elements.
+ * The previous GeoJSON specification allowed more elements (e.g., which could be used to represent M values),
+ * but the current specification only allows X, Y, and (optionally) Z to be defined.
+ */
+export declare type Position = number[];
+/**
+ * The base GeoJSON object.
+ * https://tools.ietf.org/html/rfc7946#section-3
+ * The GeoJSON specification also allows foreign members
+ * (https://tools.ietf.org/html/rfc7946#section-6.1)
+ * Developers should use "&" type in TypeScript or extend the interface
+ * to add these foreign members.
+ */
+export interface GeoJsonObject {
+    /**
+     * Specifies the type of GeoJSON object.
+     */
+    type: GeoJsonTypes;
+    /**
+     * Bounding box of the coordinate range of the object's Geometries, Features, or Feature Collections.
+     * The value of the bbox member is an array of length 2*n where n is the number of dimensions
+     * represented in the contained geometries, with all axes of the most southwesterly point
+     * followed by all axes of the more northeasterly point.
+     * The axes order of a bbox follows the axes order of geometries.
+     * https://tools.ietf.org/html/rfc7946#section-5
+     */
+    bbox?: BBox | undefined;
+}
+/**
+ * Union of GeoJSON objects.
+ */
+export declare type GeoJSON = Geometry | Feature | FeatureCollection;
+/**
+ * Geometry object.
+ * https://tools.ietf.org/html/rfc7946#section-3
+ */
+export declare type Geometry = Point | MultiPoint | LineString | MultiLineString | Polygon | MultiPolygon | GeometryCollection;
+export declare type GeometryObject = Geometry;
+/**
+ * Point geometry object.
+ * https://tools.ietf.org/html/rfc7946#section-3.1.2
+ */
+export interface Point extends GeoJsonObject {
+    type: 'Point';
+    coordinates: Position;
+}
+/**
+ * MultiPoint geometry object.
+ *  https://tools.ietf.org/html/rfc7946#section-3.1.3
+ */
+export interface MultiPoint extends GeoJsonObject {
+    type: 'MultiPoint';
+    coordinates: Position[];
+}
+/**
+ * LineString geometry object.
+ * https://tools.ietf.org/html/rfc7946#section-3.1.4
+ */
+export interface LineString extends GeoJsonObject {
+    type: 'LineString';
+    coordinates: Position[];
+}
+/**
+ * MultiLineString geometry object.
+ * https://tools.ietf.org/html/rfc7946#section-3.1.5
+ */
+export interface MultiLineString extends GeoJsonObject {
+    type: 'MultiLineString';
+    coordinates: Position[][];
+}
+/**
+ * Polygon geometry object.
+ * https://tools.ietf.org/html/rfc7946#section-3.1.6
+ */
+export interface Polygon extends GeoJsonObject {
+    type: 'Polygon';
+    coordinates: Position[][];
+}
+/**
+ * MultiPolygon geometry object.
+ * https://tools.ietf.org/html/rfc7946#section-3.1.7
+ */
+export interface MultiPolygon extends GeoJsonObject {
+    type: 'MultiPolygon';
+    coordinates: Position[][][];
+}
+/**
+ * Geometry Collection
+ * https://tools.ietf.org/html/rfc7946#section-3.1.8
+ */
+export interface GeometryCollection<G extends Geometry = Geometry> extends GeoJsonObject {
+    type: 'GeometryCollection';
+    geometries: G[];
+}
+export declare type GeoJsonProperties = {
+    [name: string]: any;
+};
+/**
+ * A feature object which contains a geometry and associated properties.
+ * https://tools.ietf.org/html/rfc7946#section-3.2
+ */
+export interface Feature<G extends Geometry | null = Geometry, P = GeoJsonProperties> extends GeoJsonObject {
+    type: 'Feature';
+    /**
+     * The feature's geometry
+     */
+    geometry: G;
+    /**
+     * A value that uniquely identifies this feature in a
+     * https://tools.ietf.org/html/rfc7946#section-3.2.
+     */
+    id: FeatureId;
+    /**
+     * Properties associated with this feature.
+     */
+    properties: P;
+}
+/**
+ * A collection of feature objects.
+ *  https://tools.ietf.org/html/rfc7946#section-3.3
+ */
+export interface FeatureCollection<G extends Geometry | null = Geometry, P = GeoJsonProperties> extends GeoJsonObject {
+    type: 'FeatureCollection';
+    features: Array<Feature<G, P>>;
+}
+export declare type RealTimeConfig = {
+    /**
+     *  "active" si está activa la funcionalidad de tiempo real
+     */
+    active: boolean;
+    /**
+     *  "userCanDeactivateTail" El usario puede temporalmente desactivar la cola de un punto de tipo tiemo real.
+     */
+    userCanDeactivateTail: boolean;
+    /**
+     * "maxZoom" Maximo zoom donde se muestra la cola.
+     */
+    maxZoom: number;
+    /**
+     * qtyTailPointsMax Cantidad de puntos de la cola de tiempo real.
+     */
+    qtyTailPointsMax: number;
+    /**
+     * "windowTailTime" Ventana de tiempo para no generar una cola retrasa en el mapa. ejemplo 30 segundos.
+     * Eventos fuera de este tiempo con respecto al primer punto no se deberían visualizaar evitando colas fantasma por  tanto no confiables.
+     */
+    windowTailTime: number;
+};
+export declare type PointType = 'point' | 'cluster';
+/**
+ * Argumentos que recibe una Render Prop cuando se renderiza por renderFeature
+ * @interface
+ */
+export interface RendePropFeatureArgs {
+    id: FeatureId;
+    /**
+     *  "layerId" si está activa la funcionalidad de tiempo real
+     */
+    layerId: string;
+}
+/**
+ * Argumentos que recibe una Render Prop cuando se renderiza por renderFeature
+ * @interface
+ */
+export interface RendePropFeaturesCollectionArgs extends FeatureCollection {
+    /**
+     * "id" identificado unico del feature
+     * En la capa multipoints clusteable:
+     *        el id se forma con el patron: device_device_id O cluster_CRCDevicesIds_count
+     * Si la capa es multilines
+     *        el id normalmente es el indice del array de multilines
+     *
+     * TODO: Se debe hacer el esfuerzo de memonizar los ids
+     */
+    id: string;
+    /**
+     *  "layerId" si está activa la funcionalidad de tiempo real
+     */
+    layerId: string;
+}
+export interface GeoJsonImplementedObject {
+    /**
+     * Specifies the type of GeoJSON object.
+     */
+    object: Feature | FeatureCollection;
+    /**
+     *
+     */
+    bbox?: BBox | undefined;
+}
+export declare type LayerStore = {
+    /**
+     * "layerId" Indetificador unico entre todas las capas
+     */
+    layerId: string;
+    /**
+     * "description" Como se va a ver el listado de capas
+     */
+    description?: string;
+    geoJsonObject?: GeoJsonImplementedObject;
+    /**
+     * "renderFeature" render prop encarga de renderizar cada feature
+     */
+    renderFeature?: ComponentRenderPropFeature;
+};
+export declare type ComponentRenderPropFeature = React.FC<RendePropFeatureArgs>;
+export declare type ComponentRenderPropFeaturesCollection = React.FC<RendePropFeaturesCollectionArgs>;
+/**
+ * @description Interface usada para inicializar una capa tipo Multipoints desde el MapProvider
+ */
+export declare type InitialLayer = LayerStore;
+/**
+ * @description interfaz usada para actualizar un feature especifico de la capa
+ */
+export interface ForSetSingleFeatureData extends Feature {
+    featureId?: string;
+    jsonUri?: string;
+}
+export declare type MapStatus = 'init' | 'ready';
+export declare type OwnerState = {
+    status: MapStatus;
+    /**
+     *  "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;
+};
+/**
+ * @type
+ * @name ExternalOwnerState
+ * @description Estados que se actulizan por fuera del store, a través de hooks
+ */
+export declare type ExternalOwnerState = Pick<OwnerState, 'isMobile' | 'isSkeleton'>;
+export declare type AreaMapType = {
+    leftLowerLatitudeOffset: number;
+    leftLowerLengthOffset: number;
+    rigthUpperLatitudeOffset: number;
+    rigthUpperLengthOffset: number;
+    mapLengthDelta: number;
+    leftLowerLength: number;
+    mapLatBottomDegree: number;
+};
+/**
+ * @interface
+ * @description Interface que define el estado del componente (variables y funciones )
+ */
+export interface MapState<P = any, G extends GeometryObject = GeometryObject> {
+    ownerState: OwnerState;
+    /**
+     *  "classes" enfocado al funcionamiento de las clases a nivel de map
+     */
+    classes: MapClasses;
+    /**
+     *  "LayersIds" Layers de trabajo para saber en que orden se muestran en el LayersAdmin
+     */
+    layersIds: string[];
+    /**
+     *  "hashLayers" Layers de trabajo
+     */
+    hashLayers: Record<string, LayerStore>;
+    /**
+     *  "getLabel" funcion que usará para traducir las etiquetas de diccionario
+     */
+    getLabel: GetLabelType;
+}
+export interface MapStateWithActions extends MapState {
+    mapActions: {
+        /**
+         * @description
+         */
+        init(layersStore: LayerStore[]): void;
+        /**
+         * @description Cambia el estado del map
+         */
+        setMapState: (state: MapStatus) => void;
+        /**
+         * @description Modifica un feature de la capa
+         */
+        setDataLayer: (layerId: string, geoJson: GeoJsonImplementedObject) => void;
+        /**
+         * @description Agrega o modifica un feature especifico de la capa
+         */
+        setFeatureData: (layerId: string, featureId: FeatureId, geometry: GeometryObject, properties: GeoJsonProperties) => void;
+        /**
+         * @description Remueve un feature especifico de la capa
+         */
+        removeFeature: (layerId: string, featureId: FeatureId) => void;
+        /**
+         * @description Retorna el vector de featureIds para saber que que está renderizado en el mapa
+         */
+        getFeatureIds: (layerId: string) => FeatureId[];
+        /**
+         * @description Actualizar instancia la render prop de una capa
+         */
+        setLayerRenderProp: (layerId: string, value: ComponentRenderPropFeature) => void;
+        /**
+         * @description Agrega una capa nueva,
+         */
+        addLayer: (layer: LayerStore) => void;
+        /**
+         * @description Remueve un feature especifico de la capa
+         */
+        removeLayer: (layerId: string) => void;
+        /**
+         * @description 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;
+        /**
+         * @description Modifica los estados que se actualizan externamente al Store
+         * @param newIsMobile
+         * @returns
+         */
+        setExternalState: (newExternalState: ExternalOwnerState) => void;
+    };
+}
+export declare type DefaultMapStoreProps = Omit<MapState, 'currentLayer'>;
+export declare type InitialMapStoreProps = Pick<MapState, 'getLabel' | 'ownerState'> & Partial<DefaultMapStoreProps>;
+export interface MapProviderProps {
+    initialLayers?: InitialLayer[];
+    children: ReactNode;
+}

package/components/maps/components/Map/hooks/useMapStore/index.d.ts

@@ -0,0 +1,3 @@
+import { MapStateWithActions } from '../../contexts/MapContext/types';
+export declare function useMapStore<T>(selector: (state: MapStateWithActions) => T, equalityFn?: (left: T, right: T) => boolean): T;
+export default useMapStore;

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

@@ -0,0 +1,5 @@
+export { Map } from './Map';
+export type { MapProps } from './types';
+export { MapProvider, MapContext } from './contexts/MapContext/MapContext';
+export { useMapStore } from './hooks/useMapStore';
+export type { RendePropFeatureArgs, ComponentRenderPropFeature, FeatureId, FeatureCollection, Feature, Geometry } from './contexts/MapContext';