@m4l/gclick 0.0.2

package/components/maps/components/GpsMap/contexts/MapContext/store.js

@@ -0,0 +1,375 @@
+import { createStore } from "zustand";
+import { devtools } from "zustand/middleware";
+import { immer } from "zustand/middleware/immer";
+import { u as useMapUtilityClasses } from "../../classes/index.js";
+import cloneDeep from "lodash-es/cloneDeep";
+import merge from "lodash-es/merge";
+import { T as TILE_LAYER_OSM } from "../../subcomponents/Controls/subcomponents/TopLeftTools/subcomponents/PopoverToolButton/subcomponentes/MapSourcesTool/sourceTypes/osm.js";
+import { T as TILE_LAYER_GOOGLE_HYBRID, a as TILE_LAYER_GOOGLE_SATELLITE, b as TILE_LAYER_GOOGLE } from "../../subcomponents/Controls/subcomponents/TopLeftTools/subcomponents/PopoverToolButton/subcomponentes/MapSourcesTool/sourceTypes/google.js";
+import { T as TILE_LAYER_BING } from "../../subcomponents/Controls/subcomponents/TopLeftTools/subcomponents/PopoverToolButton/subcomponentes/MapSourcesTool/sourceTypes/bing.js";
+const createDevtools = (immerMiddlewere, config) => {
+  const { enabled = false } = config;
+  if (enabled && process.env.NODE_ENV === "development") {
+    return devtools(immerMiddlewere, config);
+  }
+  return immerMiddlewere;
+};
+const createMapStore = (initProps, storeDevtoolsEnabled = false) => {
+  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(
+    createDevtools(
+      immer((set, get) => ({
+        ...startProps,
+        mapActions: {
+          /**
+           * TODO: Documentar
+           */
+          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);
+                }
+              }
+            });
+          },
+          /**
+           * TODO: Documentar
+           */
+          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);
+          //         // }
+          //     });
+          // },
+          /**
+           * TODO: Documentar
+           */
+          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;
+            });
+          },
+          /**
+           * TODO: Documentar
+           */
+          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 [];
+          },
+          /**
+           * TODO: Documentar
+           */
+          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 = merge(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);
+              }
+            });
+          },
+          /**
+           * TODO: Documentar
+           */
+          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" };
+              }
+            });
+          },
+          /**
+           * TODO: Documentar
+           */
+          setLayerRenderProp: (layerId, renderProp) => {
+            set((state) => {
+              state.hashLayers[layerId].renderFeature = renderProp;
+            });
+          },
+          /**
+           * TODO: Documentar
+           */
+          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);
+              }
+            });
+          },
+          /**
+           * TODO: Documentar
+           */
+          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((f) => f.id === featureId);
+                  if (feature) {
+                    feature.layerData = merge(feature.layerData || {}, layerData);
+                    feature.juan = "hola juan";
+                  }
+                } else if (state.hashLayers[layerId].geoJsonObject?.object.type === "Feature") {
+                  const feature = state.hashLayers[layerId].geoJsonObject?.object;
+                  if (feature.layerData) {
+                    feature.layerData = layerData;
+                  }
+                }
+              }
+            });
+          },
+          /**
+           * TODO: Documentar
+           */
+          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];
+            });
+          },
+          /**
+           * TODO: Documentar
+           */
+          featureOpenPoup: (layerId, featureId) => {
+            const layer = get().hashLayers[layerId];
+            let feature;
+            if (layer) {
+              if (layer.geoJsonObject?.object?.type === "FeatureCollection") {
+                const layerObject = layer.geoJsonObject?.object;
+                feature = layerObject.features.find(
+                  (currentFeature) => currentFeature.id === featureId
+                );
+              } else if (layer.geoJsonObject?.object.type === "Feature") {
+                feature = layer.geoJsonObject?.object;
+              }
+            }
+            if (feature !== void 0) {
+              feature.layerData?.getTarget()?.openPopup();
+            }
+          },
+          // 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;
+          //             }
+          //         }
+          //     });
+          // },
+          /**
+           * TODO: Documentar
+           */
+          setCheckedLayers: (checkedNameSet, newCheckedSet) => {
+            set((state) => {
+              state[`${checkedNameSet}CheckedLayers`] = new Set(newCheckedSet);
+              for (const layerId in state.hashLayers) {
+                state.hashLayers[layerId][checkedNameSet] = newCheckedSet.has(layerId);
+              }
+            });
+          },
+          /**
+           * TODO: Documentar
+           */
+          setCurrentMapSource: (newId) => {
+            set((state) => {
+              if (newId in state.hashMapSources) {
+                state.currentMapSourceId = newId;
+              }
+            });
+          },
+          /**
+           * TODO: Documentar
+           */
+          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
+              };
+            });
+          },
+          /**
+           * TODO: Documentar
+           */
+          setHandlerGetLabel: (newHandler) => {
+            set((state) => {
+              state.getLabel = newHandler;
+            });
+          },
+          /**
+           * TODO: Documentar
+           */
+          setExternalState: (newExternalState) => {
+            set((state) => {
+              state.ownerState = { ...state.ownerState, ...newExternalState };
+            });
+          }
+        }
+      })),
+      { name: `Map store: ${initProps.storeId}`, enabled: storeDevtoolsEnabled }
+    )
+  );
+};
+export {
+  createMapStore as c
+};