@m4l/components 3.1.9 → 4.0.0

package/components/hook-form/RHFUpload/RHFUploadImage/subcomponents/UploadImage/subcomponents/Skeleton/index-BDvEWltE.js

@@ -0,0 +1,23 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { Skeleton } from "@mui/material";
+import { g as getNameRHFUploadImageDataTestId } from "../../../../tests/utils-Y3oEheq4.js";
+import { T as TEST_PROP_ID } from "../../../../../../../../test/constants_no_mock-CF-669v-.js";
+const SkeletonUploadImage = (props) => {
+  const { classes } = props;
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: classes,
+      ...process.env.NODE_ENV !== "production" ? {
+        [TEST_PROP_ID]: getNameRHFUploadImageDataTestId("skeleton")
+      } : {},
+      children: [
+        "está con skeleton",
+        /* @__PURE__ */ jsx(Skeleton, { variant: "rectangular", width: "100%", height: "100%" })
+      ]
+    }
+  );
+};
+export {
+  SkeletonUploadImage as S
+};

package/components/hook-form/RHFUpload/RHFUploadImage/tests/constants-F0myRw5Z.js

@@ -0,0 +1,4 @@
+const ICON_PREFIX = "M4LRHFUploadImage";
+export {
+  ICON_PREFIX as I
+};

package/components/hook-form/RHFUpload/RHFUploadImage/tests/utils-Y3oEheq4.js

@@ -0,0 +1,7 @@
+import { I as ICON_PREFIX } from "./constants-F0myRw5Z.js";
+const getNameRHFUploadImageDataTestId = (KEY) => {
+  return `${ICON_PREFIX}-${KEY}`;
+};
+export {
+  getNameRHFUploadImageDataTestId as g
+};

package/components/hook-form/RHFUpload/index-l0sNRNKZ.js

@@ -0,0 +1 @@
+

package/components/hook-form/index-l0sNRNKZ.js

@@ -0,0 +1 @@
+

package/components/index-l0sNRNKZ.js

@@ -0,0 +1 @@
+

package/components/maps/components/Map/Map-4BNCT-Qx.js

@@ -0,0 +1,34 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { T as TileLayers } from "./subcomponents/TileLayers/index-3luovNVA.js";
+import { C as Controls } from "./subcomponents/Controls/index-C5gYiv6s.js";
+import { L as LayersContainer } from "./subcomponents/LayersContainer/index-DQItXTgO.js";
+import { m as mapClasses } from "./classes/index-DHIpfj2O.js";
+import { M as MapRootContainer } from "./styled-1N0XapIp.js";
+function Map(props) {
+  const {
+    gpsTools,
+    center = [6.215749485905093, -75.58622905191254],
+    initalZoom = 16,
+    maxZoom = 22
+  } = props;
+  return /* @__PURE__ */ jsxs(
+    MapRootContainer,
+    {
+      className: mapClasses.root,
+      center,
+      zoom: initalZoom,
+      maxZoom,
+      boxZoom: true,
+      preferCanvas: true,
+      zoomControl: false,
+      children: [
+        /* @__PURE__ */ jsx(TileLayers, {}),
+        /* @__PURE__ */ jsx(LayersContainer, {}),
+        /* @__PURE__ */ jsx(Controls, { gpsTools })
+      ]
+    }
+  );
+}
+export {
+  Map as M
+};

package/components/maps/components/Map/classes/index-DHIpfj2O.js

@@ -0,0 +1,110 @@
+import { generateUtilityClasses } from "@mui/material";
+import { unstable_composeClasses } from "@mui/base";
+import { g as getComponentUtilityClass } from "../../../../../utils/index-WXiWKKyo.js";
+import { C as COMPONENT_CLASS_NAME } from "../constants-B0E5r9Iy.js";
+const mapClasses = generateUtilityClasses(COMPONENT_CLASS_NAME, [
+  /* elements */
+  "root",
+  //Control tools
+  "topLeftToolsRoot",
+  "topRigthToolsRoot",
+  "zoomButtons",
+  //Tipos de capas de los features
+  "markerLayerRoot",
+  "markerLayerIcon",
+  "markerLayerLabel",
+  "markerLayerLabelInner",
+  //Etiqueta de los features
+  "featureLabel",
+  //Measure tool
+  "meaureToolRoot",
+  "measureToolFormValue",
+  "measureToolFormValueDistance",
+  "measureToolFormValueSymbol",
+  "measureToolLabel",
+  "meausureToolLabelDistance",
+  "meausureToolLabelSymbol",
+  //Meauser Marcas
+  "measureMarkerRoot",
+  "measureMarkerContainer",
+  "measureMarkerContainerRhomb",
+  "measureMarkerContainerSlot",
+  "measureMarkerContainerSlotNumber",
+  "measureLabelMarkerRoot",
+  "measureLabelMarkerContainer",
+  "measureLabelMarkerDistance",
+  "measureLabelMarkerRemove",
+  /**
+   * Map sources
+   */
+  "mapSourcesPopoverRoot",
+  "mapSourcesRoot",
+  "mapSourcesOption",
+  "mapSourcesOptionIconLabel",
+  "mapSourcesOptionRoadOptions",
+  "mapSourcesOptionRoadOptionsCheck",
+  /**
+   * Layers
+   */
+  "layersPopoverRoot",
+  /* states or variants of elements */
+  "active",
+  "disabled"
+]);
+const useMapUtilityClasses = (_ownerState) => {
+  const slots = {
+    root: ["root"],
+    //Control tools
+    topLeftToolsRoot: ["topLeftToolsRoot"],
+    topRigthToolsRoot: ["topRigthToolsRoot"],
+    zoomButtons: ["zoomButtons"],
+    markerLayerRoot: ["markerLayerRoot"],
+    markerLayerIcon: ["markerLayerIcon"],
+    markerLayerLabel: ["markerLayerLabel"],
+    markerLayerLabelInner: ["markerLayerLabelInner"],
+    //Etiqueta de los features
+    featureLabel: ["featureLabel"],
+    /**
+     * Measure Tool
+     */
+    //Measure form
+    meaureToolRoot: ["meaureToolRoot"],
+    measureToolFormValue: ["measureToolFormValue"],
+    measureToolFormValueDistance: ["measureToolFormValueDistance"],
+    measureToolFormValueSymbol: ["measureToolFormValueSymbol"],
+    measureToolLabel: ["measureToolLabel"],
+    meausureToolLabelDistance: ["meausureToolLabelDistance"],
+    meausureToolLabelSymbol: ["meausureToolLabelSymbol"],
+    //Meauser Marcas
+    measureMarkerRoot: ["measureMarkerRoot"],
+    measureMarkerContainer: ["measureMarkerContainer"],
+    measureMarkerContainerRhomb: ["measureMarkerContainerRhomb"],
+    measureMarkerContainerSlot: ["measureMarkerContainerSlot"],
+    measureMarkerContainerSlotNumber: ["measureMarkerContainerSlotNumber"],
+    measureLabelMarkerRoot: ["measureLabelMarkerRoot"],
+    measureLabelMarkerContainer: ["measureLabelMarkerContainer"],
+    measureLabelMarkerDistance: ["measureLabelMarkerDistance"],
+    measureLabelMarkerRemove: ["measureLabelMarkerRemove"],
+    /**
+     * Map sources
+     */
+    mapSourcesPopoverRoot: ["mapSourcesPopoverRoot"],
+    mapSourcesRoot: ["mapSourcesToolRoot"],
+    mapSourcesOption: ["mapSourcesToolOption"],
+    mapSourcesOptionIconLabel: ["mapSourcesToolOptionIconLabel"],
+    mapSourcesOptionRoadOptions: ["mapSourcesToolOptionRoadOptions"],
+    mapSourcesOptionRoadOptionsCheck: ["mapSourcesToolOptionRoadOptionsCheck"],
+    /**
+     * Layers
+     */
+    layersPopoverRoot: ["layersPopoverRoot"],
+    /* states or variants of elements */
+    active: ["active"],
+    disabled: ["disabled"]
+  };
+  return unstable_composeClasses(slots, getComponentUtilityClass(COMPONENT_CLASS_NAME), {});
+};
+export {
+  mapClasses as m,
+  useMapUtilityClasses as u
+};

package/components/maps/components/Map/constants-B0E5r9Iy.js

@@ -0,0 +1,49 @@
+const COMPONENT_CLASS_NAME = "M4LMap";
+const MAP_ZINDEX_DEFAULT = 0;
+const MAP_ZINDEX_OVER_MAP = 1100;
+const TIME_DOUBLE_CLICK = 250;
+const MARKER_COLOR_DEFAULT = "#1E96DC";
+const LABEL_BK_COLOR_DEFAULT = "#1E96DC";
+const LABEL_COLOR_DEFAULT = "#FFFFFF";
+const GPS_TOOLS_POPUP_ID = "gpsTools";
+const GPS_TOOLS_POPUP_DEFAULT_POSITION = {
+  vertical: { top: 50, bottom: 50 },
+  horizontal: { right: 50, width: 380 }
+};
+const MESURE_POPUP_DEFAULT_POSITION = {
+  vertical: { top: 50, height: 250 },
+  horizontal: { right: 50, width: 300 }
+};
+const SVG_ICON_DEFAULT = `<svg viewBox="0 0 640 640" height="32" width="32" xmlns="http://www.w3.org/2000/svg">
+<g>
+    <circle
+        cx="320"
+        cy="320"
+        r="280"
+        fill="#1E96DC"
+    />
+    <text
+        x="320"
+        y="320"
+        font-size="320"
+        font-family="sans-serif"
+        fill="#FFFFFF"
+        text-anchor="middle"
+        alignment-baseline="central"
+        dominant-baseline="central"
+    >P</text>
+</g>
+</svg>`;
+export {
+  COMPONENT_CLASS_NAME as C,
+  GPS_TOOLS_POPUP_ID as G,
+  LABEL_BK_COLOR_DEFAULT as L,
+  MARKER_COLOR_DEFAULT as M,
+  SVG_ICON_DEFAULT as S,
+  TIME_DOUBLE_CLICK as T,
+  LABEL_COLOR_DEFAULT as a,
+  MAP_ZINDEX_OVER_MAP as b,
+  GPS_TOOLS_POPUP_DEFAULT_POSITION as c,
+  MESURE_POPUP_DEFAULT_POSITION as d,
+  MAP_ZINDEX_DEFAULT as e
+};

package/components/maps/components/Map/contexts/MapContext/MapContext-Dtqt0G-8.js

@@ -0,0 +1,51 @@
+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 createMapStore } from "./store-Dqx2V1Ee.js";
+const MapContext = createContext(null);
+function MapProvider(props) {
+  const { children, initialLayers, googleApiKey: apiKey, googleMapVersion = "weekly" } = props;
+  const { getLabel } = useModuleDictionary();
+  const isDesktop = useResponsiveDesktop();
+  const isSkeleton = useModuleSkeleton();
+  const isFirstRender = useFirstRender([getLabel]);
+  const mapStoreRef = useRef();
+  if (!mapStoreRef.current) {
+    mapStoreRef.current = createMapStore({
+      getLabel,
+      ownerState: {
+        status: "init",
+        isMobile: !isDesktop,
+        isSkeleton,
+        focus: false
+      },
+      googleApiKey: apiKey,
+      googleMapVersion
+    });
+    mapStoreRef.current?.getState().mapActions.init(initialLayers || []);
+  }
+  const { setHandlerGetLabel, setExternalState } = useStore(
+    mapStoreRef.current,
+    (state) => state.mapActions,
+    shallow
+  );
+  useEffect(() => {
+    if (!isFirstRender) {
+      setHandlerGetLabel(getLabel);
+    }
+  }, [getLabel]);
+  useEffect(() => {
+    if (isFirstRender) {
+      return;
+    }
+    setExternalState({ isMobile: !isDesktop, isSkeleton });
+  }, [isDesktop, isSkeleton]);
+  return /* @__PURE__ */ jsx(MapContext.Provider, { value: mapStoreRef.current, children });
+}
+export {
+  MapContext as M,
+  MapProvider as a
+};

package/components/maps/components/Map/contexts/MapContext/helper-l0sNRNKZ.js

@@ -0,0 +1 @@
+

package/components/maps/components/Map/contexts/MapContext/store-Dqx2V1Ee.js

@@ -0,0 +1,303 @@
+import { createStore } from "zustand";
+import { devtools } from "zustand/middleware";
+import { immer } from "zustand/middleware/immer";
+import { u as useMapUtilityClasses } from "../../classes/index-DHIpfj2O.js";
+import { cloneDeep } from "lodash";
+import { T as TILE_LAYER_OSM } from "../../subcomponents/Controls/subcomponents/TopLeftTools/subcomponents/PopoverToolButton/subcomponentes/MapSourcesTool/sourceTypes/osm-j-4aemf0.js";
+import { T as TILE_LAYER_GOOGLE, a as TILE_LAYER_GOOGLE_SATELLITE, b as TILE_LAYER_GOOGLE_HYBRID } from "../../subcomponents/Controls/subcomponents/TopLeftTools/subcomponents/PopoverToolButton/subcomponentes/MapSourcesTool/sourceTypes/google-jSjEc0an.js";
+import { T as TILE_LAYER_BING } from "../../subcomponents/Controls/subcomponents/TopLeftTools/subcomponents/PopoverToolButton/subcomponentes/MapSourcesTool/sourceTypes/bing-54s62f3m.js";
+const createMapStore = (initProps) => {
+  const startProps = {
+    classes: useMapUtilityClasses(initProps.ownerState),
+    visibleCheckedLayers: /* @__PURE__ */ new Set(),
+    autoFocusCheckedLayers: /* @__PURE__ */ new Set(),
+    clusterCheckedLayers: /* @__PURE__ */ new Set(),
+    currentMapSourceId: "",
+    hashMapSources: {},
+    mapSourcesIds: [],
+    layersIds: [],
+    hashLayers: {},
+    ...initProps
+  };
+  return createStore(
+    devtools(
+      immer((set, get) => ({
+        ...startProps,
+        mapActions: {
+          init: (layersStore) => {
+            set((state) => {
+              state.hashMapSources = {
+                osm_roadmap: TILE_LAYER_OSM,
+                google_rodmap: TILE_LAYER_GOOGLE,
+                google_satellite: TILE_LAYER_GOOGLE_SATELLITE,
+                google_hybrid: TILE_LAYER_GOOGLE_HYBRID,
+                bing_rodmap: TILE_LAYER_BING
+              };
+              state.mapSourcesIds = [
+                "osm_roadmap",
+                "google_rodmap",
+                "google_satellite",
+                "google_hybrid",
+                "bing_rodmap"
+              ];
+              state.currentMapSourceId = "osm_roadmap";
+              for (let index = 0; index < layersStore.length; index++) {
+                state.hashLayers[layersStore[index].layerId] = cloneDeep(layersStore[index]);
+                state.layersIds.push(layersStore[index].layerId);
+                if (layersStore[index].visible !== false) {
+                  state.visibleCheckedLayers.add(layersStore[index].layerId);
+                }
+                if (state.hashLayers[layersStore[index].layerId].autoFocus !== false) {
+                  state.autoFocusCheckedLayers.add(layersStore[index].layerId);
+                }
+                if (state.hashLayers[layersStore[index].layerId].cluster !== false) {
+                  state.clusterCheckedLayers.add(layersStore[index].layerId);
+                }
+              }
+            });
+          },
+          setMapState: (status) => {
+            set((state) => {
+              state.ownerState.status = status;
+            });
+          },
+          // isEqualsMapProperties: (_newMapProperties: MapProperties) => {
+          //     // if (get().mapProperties === undefined) {
+          //     //     return false;
+          //     // }
+          //     // return (
+          //     //     JSON.stringify(get().mapProperties) === JSON.stringify(newMapProperties)
+          //     // );
+          //     return false;
+          // },
+          // setMapProperties: (newMapProperties: MapProperties) => {
+          //     if (!get().mapActions.isEqualsMapProperties(newMapProperties)) {
+          //         set(state => {
+          //             state.mapProperties = newMapProperties;
+          //             if (state.ownerState.status === 'init') {
+          //                 state.ownerState.status = 'ready';
+          //                 updateOwnerStateClasses(state);
+          //             }
+          //         });
+          //     }
+          // },
+          // setAllFeaturesDataLayer: (layerId: string, value: AllFeaturesDatalLayer) => {
+          //     set(state => {
+          //         // if (
+          //         //     value.geometry === 'multipoints' &&
+          //         //     state.hashLayers[layerId].geometry === value.geometry
+          //         // ) {
+          //         //     (
+          //         //         state.hashLayers[layerId] as WritableDraft<LayerMultiPointProps>
+          //         //     ).hashFeatures = cloneDeep(value.hashFeatures); // Valor puro
+          //         // }
+          //         // if (
+          //         //     value.geometry === 'multilines' &&
+          //         //     state.hashLayers[layerId].geometry === value.geometry
+          //         // ) {
+          //         //     (
+          //         //         state.hashLayers[layerId] as WritableDraft<LayerMultiLineProps>
+          //         //     ).hashFeatures = cloneDeep(value.hashFeatures);
+          //         // }
+          //     });
+          // },
+          setDataLayer: (layerId, geoJson) => {
+            if (!get().hashLayers[layerId]) {
+              throw new Error(`Layer with id ${layerId} not found`);
+            }
+            set((state) => {
+              const layer = state.hashLayers[layerId];
+              layer.geoJsonObject = geoJson;
+            });
+          },
+          getFeatureIds: (layerId) => {
+            if (!get().hashLayers[layerId]) {
+              throw new Error(`Layer with id ${layerId} not found`);
+            }
+            const geoJsonObject = get().hashLayers[layerId]?.geoJsonObject;
+            if (geoJsonObject && geoJsonObject.object.type === "Feature") {
+              return [geoJsonObject.object.id];
+            } else if (geoJsonObject && geoJsonObject.object.type === "FeatureCollection") {
+              return geoJsonObject.object.features.map((feature) => feature.id);
+            }
+            return [];
+          },
+          setFeatureData: (layerId, featureId, geometry, properties, featureLabel) => {
+            if (!get().hashLayers[layerId]) {
+              throw new Error(`Layer with id ${layerId} not found`);
+            }
+            set((state) => {
+              if (state.hashLayers[layerId].geoJsonObject?.object.type === "FeatureCollection") {
+                const layer = state.hashLayers[layerId].geoJsonObject?.object;
+                let feature = layer.features.find((f) => f.id === featureId);
+                if (feature) {
+                  feature.geometry = cloneDeep(geometry);
+                  feature.properties = { ...feature.properties, ...properties };
+                  feature.featureLabel = featureLabel;
+                } else {
+                  feature = {
+                    type: "Feature",
+                    geometry,
+                    id: featureId,
+                    properties,
+                    featureLabel
+                  };
+                  layer.features.push(feature);
+                }
+              } else if (state.hashLayers[layerId].geoJsonObject?.object.type === "Feature") {
+                const feature = state.hashLayers[layerId].geoJsonObject?.object;
+                feature.id = featureId;
+                feature.geometry = cloneDeep(geometry);
+                feature.properties = cloneDeep(properties);
+              }
+            });
+          },
+          removeFeature: (layerId, featureId) => {
+            if (!get().hashLayers[layerId]) {
+              throw new Error(`Layer with id ${layerId} not found`);
+            }
+            set((state) => {
+              if (state.hashLayers[layerId].geoJsonObject?.object.type === "FeatureCollection") {
+                const layer = state.hashLayers[layerId].geoJsonObject?.object;
+                const index = layer.features.findIndex((f) => f.id === featureId);
+                if (index !== -1) {
+                  layer.features.splice(index, 1);
+                }
+              } else if (state.hashLayers[layerId].geoJsonObject?.object.type === "Feature") {
+                const feature = state.hashLayers[layerId].geoJsonObject?.object;
+                feature.geometry = { type: "Point", coordinates: [0, 0] };
+                feature.properties = { subType: "Marker" };
+              }
+            });
+          },
+          setLayerRenderProp: (layerId, renderProp) => {
+            set((state) => {
+              state.hashLayers[layerId].renderFeature = renderProp;
+            });
+          },
+          addLayer: (layer) => {
+            if (get().hashLayers[layer.layerId]) {
+              throw new Error(`Layer with id ${layer.layerId} already exists`);
+            }
+            set((state) => {
+              state.hashLayers[layer.layerId] = layer;
+              state.layersIds.push(layer.layerId);
+              if (layer.visible !== false) {
+                state.hashLayers[layer.layerId].visible = true;
+                state.visibleCheckedLayers.add(layer.layerId);
+              }
+              if (layer.autoFocus !== false) {
+                state.hashLayers[layer.layerId].autoFocus = true;
+                state.autoFocusCheckedLayers.add(layer.layerId);
+              }
+              if (layer.clusterAble && layer.cluster !== false) {
+                state.hashLayers[layer.layerId].cluster = true;
+                state.clusterCheckedLayers.add(layer.layerId);
+              }
+            });
+          },
+          addLayerDataToFeature: (layerId, featureId, layerData) => {
+            set((state) => {
+              if (state.hashLayers[layerId]) {
+                if (state.hashLayers[layerId].geoJsonObject?.object.type === "FeatureCollection") {
+                  const layer = state.hashLayers[layerId].geoJsonObject?.object;
+                  const feature = layer.features.find(
+                    (currentFeature) => currentFeature.id === featureId
+                  );
+                  if (feature) {
+                    feature.layerData = layerData;
+                  }
+                } else if (state.hashLayers[layerId].geoJsonObject?.object.type === "Feature") {
+                  const feature = state.hashLayers[layerId].geoJsonObject?.object;
+                  if (feature.layerData) {
+                    feature.layerData = layerData;
+                  }
+                }
+              }
+            });
+          },
+          removeLayer: (layerId) => {
+            if (!get().hashLayers[layerId]) {
+              return;
+            }
+            set((state) => {
+              if (!state.hashLayers[layerId].visible) {
+                state.visibleCheckedLayers.delete(layerId);
+                state.autoFocusCheckedLayers.delete(layerId);
+              }
+              state.layersIds.splice(state.layersIds.indexOf(layerId), 1);
+              delete state.hashLayers[layerId];
+            });
+          },
+          // removeLefletLayerToFeature: (layerId, featureId ) => {
+          //     set(state => {
+          //         //se pon si existe, porque cuando se borran las capas, ya no hay forma
+          //         if (state.hashLayers[layerId]){
+          //             if (
+          //                 state.hashLayers[layerId].geoJsonObject?.object.type ===
+          //                 'FeatureCollection'
+          //             ) {
+          //                 //Remove feature from featureCollection
+          //                 const layer = state.hashLayers[layerId].geoJsonObject
+          //                     ?.object as FeatureCollection;
+          //                 const index = layer.features.findIndex(f => f.id === featureId);
+          //                 if (index !== -1) {
+          //                     layer.features[index].layerData = undefined;
+          //                 }
+          //             } else if (
+          //                 state.hashLayers[layerId].geoJsonObject?.object.type === 'Feature'
+          //             ) {
+          //                 const feature = state.hashLayers[layerId].geoJsonObject
+          //                     ?.object as Feature;
+          //                 feature.layerData = undefined;
+          //             }
+          //         }
+          //     });
+          // },
+          setCheckedLayers: (checkedNameSet, newCheckedSet) => {
+            set((state) => {
+              state[`${checkedNameSet}CheckedLayers`] = new Set(newCheckedSet);
+              for (const layerId in state.hashLayers) {
+                state.hashLayers[layerId][checkedNameSet] = newCheckedSet.has(layerId);
+              }
+            });
+          },
+          setCurrentMapSource: (newId) => {
+            set((state) => {
+              if (newId in state.hashMapSources) {
+                state.currentMapSourceId = newId;
+              }
+            });
+          },
+          setMapSourceRoadOptions: (partialRoadOptions) => {
+            set((state) => {
+              if (!state.hashMapSources[state.currentMapSourceId]) {
+                return;
+              }
+              state.hashMapSources[state.currentMapSourceId].roadSelectedOptions = {
+                bicyclingLayer: state.hashMapSources[state.currentMapSourceId]?.roadSelectedOptions?.bicyclingLayer || false,
+                trafficLayer: state.hashMapSources[state.currentMapSourceId]?.roadSelectedOptions?.trafficLayer || false,
+                transitLayer: state.hashMapSources[state.currentMapSourceId]?.roadSelectedOptions?.transitLayer || false,
+                ...partialRoadOptions
+              };
+            });
+          },
+          setHandlerGetLabel: (newHandler) => {
+            set((state) => {
+              state.getLabel = newHandler;
+            });
+          },
+          setExternalState: (newExternalState) => {
+            set((state) => {
+              state.ownerState = { ...state.ownerState, ...newExternalState };
+            });
+          }
+        }
+      })),
+      { name: `Map store` }
+    )
+  );
+};
+export {
+  createMapStore as c
+};