zenit-sdk 0.0.3 → 0.0.7

package/dist/{chunk-R73LRYVJ.mjs → chunk-ITF7QCUZ.mjs}

@@ -1,5 +1,5 @@
 // src/react/ZenitMap.tsx
-import { useCallback, useEffect, useImperativeHandle, useMemo, useRef, useState, forwardRef } from "react";
+import React, { useCallback, useEffect, useImperativeHandle, useMemo, useRef, useState, forwardRef } from "react";
 import { GeoJSON, MapContainer, Marker, TileLayer, ZoomControl, useMap } from "react-leaflet";
 import L from "leaflet";
 
@@ -297,6 +297,366 @@ function getFeatureLayerId(feature) {
 function escapeHtml(value) {
   return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
 }
+var DESCRIPTION_KEYS = /* @__PURE__ */ new Set(["descripcion", "description"]);
+var POPUP_EXCLUDED_KEYS = /* @__PURE__ */ new Set(["geom", "geometry"]);
+var POPUP_STYLE_ID = "zenit-leaflet-popup-styles";
+var DESKTOP_POPUP_DIMENSIONS = { maxWidth: 350, minWidth: 280, maxHeight: 480 };
+var MOBILE_POPUP_DIMENSIONS = { maxWidth: 280, minWidth: 240, maxHeight: 380 };
+var ZENIT_LEAFLET_POPUP_STYLES = `
+/* ===== Zenit Leaflet Popup - Modern Professional Styling ===== */
+
+/* Main popup wrapper */
+.zenit-leaflet-popup .leaflet-popup-content-wrapper {
+  border-radius: 12px;
+  box-shadow:
+    0 4px 6px -1px rgba(0, 0, 0, 0.1),
+    0 2px 4px -2px rgba(0, 0, 0, 0.1),
+    0 0 0 1px rgba(0, 0, 0, 0.05);
+  padding: 0;
+  background: #ffffff;
+  overflow: hidden;
+}
+
+/* Content area with scroll support */
+.zenit-leaflet-popup .leaflet-popup-content {
+  margin: 0;
+  padding: 0;
+  font-size: 13px;
+  line-height: 1.5;
+  color: #374151;
+  min-width: 100%;
+  overflow-y: auto;
+  overflow-x: hidden;
+  scrollbar-width: thin;
+  scrollbar-color: rgba(156, 163, 175, 0.5) transparent;
+}
+
+/* Popup tip/arrow shadow */
+.zenit-leaflet-popup .leaflet-popup-tip-container {
+  filter: drop-shadow(0 2px 4px rgba(0, 0, 0, 0.1));
+}
+
+.zenit-leaflet-popup .leaflet-popup-tip {
+  background: #ffffff;
+  box-shadow: none;
+}
+
+/* Close button styling */
+.zenit-leaflet-popup .leaflet-popup-close-button {
+  color: #9ca3af;
+  font-size: 18px;
+  font-weight: 400;
+  width: 28px;
+  height: 28px;
+  padding: 0;
+  margin: 8px 8px 0 0;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  border-radius: 6px;
+  transition: all 0.15s ease;
+  z-index: 10;
+}
+
+.zenit-leaflet-popup .leaflet-popup-close-button:hover {
+  color: #374151;
+  background-color: #f3f4f6;
+}
+
+.zenit-leaflet-popup .leaflet-popup-close-button:active {
+  background-color: #e5e7eb;
+}
+
+/* Main card container */
+.zenit-popup-card {
+  display: flex;
+  flex-direction: column;
+  gap: 0;
+  padding: 16px;
+}
+
+/* Individual row styling with subtle separator */
+.zenit-popup-row {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+  padding: 10px 0;
+  border-bottom: 1px solid #f3f4f6;
+}
+
+.zenit-popup-row:first-child {
+  padding-top: 0;
+}
+
+.zenit-popup-row:last-child {
+  border-bottom: none;
+  padding-bottom: 0;
+}
+
+/* Label styling - small, gray, uppercase */
+.zenit-popup-label {
+  font-size: 10px;
+  font-weight: 500;
+  color: #9ca3af;
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+  line-height: 1.4;
+}
+
+/* Value styling - darker, readable */
+.zenit-popup-value {
+  font-size: 13px;
+  font-weight: 400;
+  color: #1f2937;
+  overflow-wrap: break-word;
+  word-break: break-word;
+  line-height: 1.5;
+}
+
+/* Special styling for description field */
+.zenit-popup-row.zenit-popup-description {
+  background-color: #f9fafb;
+  margin: 0 -16px;
+  padding: 12px 16px;
+  border-bottom: 1px solid #e5e7eb;
+}
+
+.zenit-popup-row.zenit-popup-description:first-child {
+  margin-top: 0;
+  border-radius: 0;
+}
+
+.zenit-popup-row.zenit-popup-description .zenit-popup-value {
+  font-size: 13px;
+  line-height: 1.6;
+  color: #374151;
+  max-height: 150px;
+  overflow-y: auto;
+  padding-right: 4px;
+}
+
+/* Preformatted text (JSON objects) */
+.zenit-popup-pre {
+  margin: 0;
+  font-family: ui-monospace, SFMono-Regular, 'SF Mono', Menlo, Consolas, monospace;
+  font-size: 11px;
+  white-space: pre-wrap;
+  word-break: break-word;
+  color: #4b5563;
+  background-color: #f9fafb;
+  padding: 8px;
+  border-radius: 6px;
+  border: 1px solid #e5e7eb;
+}
+
+/* Empty state styling */
+.zenit-popup-empty {
+  font-size: 13px;
+  color: #9ca3af;
+  font-style: italic;
+  text-align: center;
+  padding: 20px 0;
+}
+
+/* Webkit scrollbar styling */
+.zenit-leaflet-popup .leaflet-popup-content::-webkit-scrollbar {
+  width: 6px;
+}
+
+.zenit-leaflet-popup .leaflet-popup-content::-webkit-scrollbar-track {
+  background: transparent;
+}
+
+.zenit-leaflet-popup .leaflet-popup-content::-webkit-scrollbar-thumb {
+  background-color: rgba(156, 163, 175, 0.4);
+  border-radius: 3px;
+}
+
+.zenit-leaflet-popup .leaflet-popup-content::-webkit-scrollbar-thumb:hover {
+  background-color: rgba(107, 114, 128, 0.6);
+}
+
+/* Scrollbar for description field */
+.zenit-popup-row.zenit-popup-description .zenit-popup-value::-webkit-scrollbar {
+  width: 4px;
+}
+
+.zenit-popup-row.zenit-popup-description .zenit-popup-value::-webkit-scrollbar-track {
+  background: transparent;
+}
+
+.zenit-popup-row.zenit-popup-description .zenit-popup-value::-webkit-scrollbar-thumb {
+  background-color: rgba(156, 163, 175, 0.4);
+  border-radius: 2px;
+}
+
+/* ===== Responsive: Mobile (<640px) ===== */
+@media (max-width: 640px) {
+  .zenit-leaflet-popup .leaflet-popup-content-wrapper {
+    border-radius: 10px;
+  }
+
+  .zenit-leaflet-popup .leaflet-popup-close-button {
+    width: 26px;
+    height: 26px;
+    font-size: 16px;
+    margin: 6px 6px 0 0;
+  }
+
+  .zenit-popup-card {
+    padding: 12px;
+  }
+
+  .zenit-popup-row {
+    padding: 8px 0;
+  }
+
+  .zenit-popup-label {
+    font-size: 9px;
+  }
+
+  .zenit-popup-value {
+    font-size: 12px;
+  }
+
+  .zenit-popup-row.zenit-popup-description {
+    margin: 0 -12px;
+    padding: 10px 12px;
+  }
+
+  .zenit-popup-row.zenit-popup-description .zenit-popup-value {
+    font-size: 12px;
+    max-height: 120px;
+  }
+
+  .zenit-popup-pre {
+    font-size: 10px;
+    padding: 6px;
+  }
+
+  .zenit-popup-empty {
+    font-size: 12px;
+    padding: 16px 0;
+  }
+}
+
+/* ===== Map tooltip styling ===== */
+.zenit-map-tooltip {
+  background-color: rgba(31, 41, 55, 0.95);
+  border: none;
+  border-radius: 6px;
+  color: #ffffff;
+  font-size: 12px;
+  font-weight: 500;
+  padding: 6px 10px;
+  box-shadow: 0 2px 8px rgba(0, 0, 0, 0.15);
+}
+
+.zenit-map-tooltip::before {
+  border-top-color: rgba(31, 41, 55, 0.95);
+}
+`;
+function ensurePopupStyles() {
+  if (typeof document === "undefined") return;
+  if (document.getElementById(POPUP_STYLE_ID)) return;
+  const styleTag = document.createElement("style");
+  styleTag.id = POPUP_STYLE_ID;
+  styleTag.textContent = ZENIT_LEAFLET_POPUP_STYLES;
+  document.head.appendChild(styleTag);
+}
+function getPopupDimensions() {
+  if (typeof window === "undefined" || typeof window.matchMedia !== "function") {
+    return DESKTOP_POPUP_DIMENSIONS;
+  }
+  return window.matchMedia("(max-width: 640px)").matches ? MOBILE_POPUP_DIMENSIONS : DESKTOP_POPUP_DIMENSIONS;
+}
+function normalizeDescriptionValue(value) {
+  if (value === void 0 || value === null) return null;
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    return trimmed ? trimmed : null;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  return null;
+}
+function extractDescriptionValue(properties) {
+  if (!properties) return null;
+  const matches = Object.entries(properties).find(
+    ([key]) => DESCRIPTION_KEYS.has(key.toLowerCase())
+  );
+  if (!matches) return null;
+  return normalizeDescriptionValue(matches[1]);
+}
+function safeJsonStringify(value) {
+  try {
+    const json = JSON.stringify(value, null, 2);
+    if (json !== void 0) return json;
+  } catch {
+  }
+  return String(value);
+}
+function renderPopupValue(value) {
+  if (value === null || value === void 0) {
+    return '<span class="zenit-popup-empty">Sin datos</span>';
+  }
+  if (typeof value === "object") {
+    const json = safeJsonStringify(value);
+    return `<pre class="zenit-popup-pre">${escapeHtml(json)}</pre>`;
+  }
+  return `<span>${escapeHtml(String(value))}</span>`;
+}
+function shouldIncludePopupEntry(key, value) {
+  if (!key) return false;
+  const normalized = key.trim().toLowerCase();
+  if (!normalized) return false;
+  if (normalized.startsWith("_")) return false;
+  if (POPUP_EXCLUDED_KEYS.has(normalized)) return false;
+  if (value === null || value === void 0) return false;
+  if (typeof value === "string" && !value.trim()) return false;
+  return true;
+}
+function isDescriptionKey(key) {
+  const normalized = key.trim().toLowerCase();
+  return DESCRIPTION_KEYS.has(normalized);
+}
+function formatLabel(key) {
+  return key.replace(/_/g, " ").replace(/([a-z])([A-Z])/g, "$1 $2").trim();
+}
+function createPopupContent(properties) {
+  const entries = Object.entries(properties).filter(
+    ([key, value]) => shouldIncludePopupEntry(key, value)
+  );
+  if (entries.length === 0) {
+    return `<div class="zenit-popup-card"><div class="zenit-popup-empty">Sin datos disponibles</div></div>`;
+  }
+  const descriptionEntry = entries.find(([key]) => isDescriptionKey(key));
+  const otherEntries = entries.filter(([key]) => !isDescriptionKey(key));
+  let rowsHtml = "";
+  if (descriptionEntry) {
+    const [key, value] = descriptionEntry;
+    const label = escapeHtml(formatLabel(key));
+    const valueHtml = renderPopupValue(value);
+    rowsHtml += `
+      <div class="zenit-popup-row zenit-popup-description">
+        <div class="zenit-popup-label">${label}</div>
+        <div class="zenit-popup-value">${valueHtml}</div>
+      </div>
+    `;
+  }
+  rowsHtml += otherEntries.map(([key, value]) => {
+    const label = escapeHtml(formatLabel(key));
+    const valueHtml = renderPopupValue(value);
+    return `
+        <div class="zenit-popup-row">
+          <div class="zenit-popup-label">${label}</div>
+          <div class="zenit-popup-value">${valueHtml}</div>
+        </div>
+      `;
+  }).join("");
+  return `<div class="zenit-popup-card">${rowsHtml}</div>`;
+}
 function withAlpha(color, alpha) {
   const trimmed = color.trim();
   if (trimmed.startsWith("#")) {
@@ -365,40 +725,39 @@ function getFeatureStyleOverrides(feature) {
 function buildFeaturePopupHtml(feature) {
   const properties = feature?.properties;
   if (!properties) return null;
-  const layerName = properties.layerName ?? properties.layer_name ?? properties.name;
-  const descripcion = properties.descripcion ?? properties.description;
-  const reservedKeys = /* @__PURE__ */ new Set([
-    "_style",
-    "layerId",
-    "layer_id",
-    "__zenit_layerId",
-    "layerName",
-    "layer_name",
-    "name",
-    "descripcion",
-    "description"
-  ]);
-  const extraEntries = Object.entries(properties).filter(([key, value]) => {
-    if (reservedKeys.has(key)) return false;
-    return ["string", "number", "boolean"].includes(typeof value);
-  }).slice(0, 5);
-  if (!layerName && !descripcion && extraEntries.length === 0) return null;
-  const parts = [];
-  if (layerName) {
-    parts.push(`<div style="font-weight:600;margin-bottom:4px;">${escapeHtml(layerName)}</div>`);
-  }
-  if (descripcion) {
-    parts.push(`<div style="margin-bottom:6px;">${escapeHtml(descripcion)}</div>`);
-  }
-  if (extraEntries.length > 0) {
-    const rows = extraEntries.map(([key, value]) => {
-      const label = escapeHtml(key.replace(/_/g, " "));
-      const val = escapeHtml(String(value));
-      return `<div><strong>${label}:</strong> ${val}</div>`;
-    }).join("");
-    parts.push(`<div style="font-size:12px;line-height:1.4;">${rows}</div>`);
+  const rendered = createPopupContent(properties);
+  return rendered ? rendered : null;
+}
+var POINT_GEOMETRY_TYPES = /* @__PURE__ */ new Set(["Point", "MultiPoint"]);
+function getGeometryType(feature) {
+  const t = feature?.geometry?.type;
+  return typeof t === "string" ? t : null;
+}
+function isPointGeometry(feature) {
+  const geometryType = getGeometryType(feature);
+  return geometryType !== null && POINT_GEOMETRY_TYPES.has(geometryType);
+}
+function isNonPointGeometry(feature) {
+  const geometryType = getGeometryType(feature);
+  return geometryType !== null && !POINT_GEOMETRY_TYPES.has(geometryType);
+}
+function buildFeatureCollection(features) {
+  return {
+    type: "FeatureCollection",
+    features
+  };
+}
+function pickIntersectFeature(baseFeature, candidates) {
+  if (!Array.isArray(candidates) || candidates.length === 0) return null;
+  const baseId = baseFeature?.id;
+  if (baseId !== void 0 && baseId !== null) {
+    const matchById = candidates.find((candidate) => candidate?.id === baseId);
+    if (matchById) return matchById;
   }
-  return `<div>${parts.join("")}</div>`;
+  const matchWithDescription = candidates.find(
+    (candidate) => extractDescriptionValue(candidate?.properties)
+  );
+  return matchWithDescription ?? candidates[0];
 }
 function normalizeCenterTuple(center) {
   if (!center) return null;
@@ -519,6 +878,7 @@ var ZenitMap = forwardRef(({
   const [loadingMap, setLoadingMap] = useState(false);
   const [mapError, setMapError] = useState(null);
   const [mapInstance, setMapInstance] = useState(null);
+  const [panesReady, setPanesReady] = useState(false);
   const [currentZoom, setCurrentZoom] = useState(initialZoom ?? DEFAULT_ZOOM);
   const [isMobile, setIsMobile] = useState(() => {
     if (typeof window === "undefined") return false;
@@ -543,6 +903,11 @@ var ZenitMap = forwardRef(({
     }
     return;
   }, []);
+  useEffect(() => {
+    if (featureInfoMode === "popup") {
+      ensurePopupStyles();
+    }
+  }, [featureInfoMode]);
   const layerStyleIndex = useMemo(() => {
     const index = /* @__PURE__ */ new Map();
     (map?.mapLayers ?? []).forEach((entry) => {
@@ -833,16 +1198,23 @@ var ZenitMap = forwardRef(({
     (targetMap, targetLayers) => {
       const baseZIndex = 400;
       targetLayers.forEach((layer) => {
-        const paneName = `zenit-layer-${layer.layerId}`;
-        const pane = targetMap.getPane(paneName) ?? targetMap.createPane(paneName);
         const order = Number.isFinite(layer.displayOrder) ? layer.displayOrder : 0;
-        pane.style.zIndex = String(baseZIndex + order);
+        const fillPaneName = `zenit-layer-${layer.layerId}-fill`;
+        const pointPaneName = `zenit-layer-${layer.layerId}-points`;
+        const labelPaneName = `zenit-layer-${layer.layerId}-labels`;
+        const fillPane = targetMap.getPane(fillPaneName) ?? targetMap.createPane(fillPaneName);
+        const pointPane = targetMap.getPane(pointPaneName) ?? targetMap.createPane(pointPaneName);
+        const labelPane = targetMap.getPane(labelPaneName) ?? targetMap.createPane(labelPaneName);
+        fillPane.style.zIndex = String(baseZIndex + order);
+        pointPane.style.zIndex = String(baseZIndex + order + 1e3);
+        labelPane.style.zIndex = String(baseZIndex + order + 2e3);
       });
     },
     []
   );
   const handleMapReady = useCallback(
     (instance) => {
+      setPanesReady(false);
       setMapInstance(instance);
       onMapReady?.(instance);
     },
@@ -850,6 +1222,7 @@ var ZenitMap = forwardRef(({
   );
   useEffect(() => {
     if (!mapInstance) {
+      setPanesReady(false);
       return;
     }
     if (orderedLayers.length === 0) {
@@ -860,6 +1233,11 @@ var ZenitMap = forwardRef(({
       displayOrder: layer.displayOrder
     }));
     ensureLayerPanes(mapInstance, layerTargets);
+    const first = layerTargets[0];
+    const testPane = mapInstance.getPane(`zenit-layer-${first.layerId}-labels`);
+    if (testPane) {
+      setPanesReady(true);
+    }
   }, [mapInstance, orderedLayers, ensureLayerPanes]);
   const overlayOnEachFeature = useMemo(() => {
     return (feature, layer) => {
@@ -877,7 +1255,17 @@ var ZenitMap = forwardRef(({
       if (featureInfoMode === "popup") {
         const content = buildFeaturePopupHtml(feature);
         if (content) {
-          layer.bindPopup(content, { maxWidth: 320 });
+          const { maxWidth, minWidth, maxHeight } = getPopupDimensions();
+          layer.bindPopup(content, {
+            maxWidth,
+            minWidth,
+            maxHeight,
+            className: "zenit-leaflet-popup",
+            autoPan: true,
+            closeButton: true,
+            keepInView: true,
+            offset: L.point(0, -24)
+          });
         }
       }
       if (isPointFeature && layer.bindTooltip) {
@@ -888,7 +1276,37 @@ var ZenitMap = forwardRef(({
           className: "zenit-map-tooltip"
         });
       }
-      layer.on("click", () => onFeatureClick?.(feature, layerId));
+      layer.on("click", () => {
+        if (featureInfoMode === "popup" && client && layerId !== void 0 && !extractDescriptionValue(feature?.properties) && feature?.geometry) {
+          const trackedFeature = feature;
+          if (!trackedFeature.__zenit_popup_loaded) {
+            trackedFeature.__zenit_popup_loaded = true;
+            client.layers.getLayerGeoJsonIntersect({
+              id: layerId,
+              geometry: feature.geometry
+            }).then((response) => {
+              const candidates = response.data?.features ?? [];
+              const resolved = pickIntersectFeature(feature, candidates);
+              if (!resolved?.properties) return;
+              const mergedProperties = {
+                ...trackedFeature.properties ?? {},
+                ...resolved.properties
+              };
+              trackedFeature.properties = mergedProperties;
+              const updatedHtml = buildFeaturePopupHtml({
+                ...feature,
+                properties: mergedProperties
+              });
+              if (updatedHtml && layer.setPopupContent) {
+                layer.setPopupContent(updatedHtml);
+              }
+            }).catch(() => {
+              trackedFeature.__zenit_popup_loaded = false;
+            });
+          }
+        }
+        onFeatureClick?.(feature, layerId);
+      });
       layer.on("mouseover", () => {
         if (layer instanceof L.Path && originalStyle) {
           layer.setStyle({
@@ -912,7 +1330,7 @@ var ZenitMap = forwardRef(({
         }
       });
     };
-  }, [featureInfoMode, onFeatureClick, onFeatureHover]);
+  }, [client, featureInfoMode, onFeatureClick, onFeatureHover]);
   const buildLayerStyle = (layerId, baseOpacity, feature, layerType) => {
     const style = resolveLayerStyle(layerId);
     const featureStyleOverrides = getFeatureStyleOverrides(feature);
@@ -1093,22 +1511,50 @@ var ZenitMap = forwardRef(({
               /* @__PURE__ */ jsx(ZoomBasedOpacityHandler, { onZoomChange: handleZoomChange }),
               orderedLayers.map((layerState) => {
                 const baseOpacity = layerState.effective?.baseOpacity ?? layerState.effective?.opacity ?? 1;
-                const paneName = `zenit-layer-${layerState.mapLayer.layerId}`;
+                const fillPaneName = `zenit-layer-${layerState.mapLayer.layerId}-fill`;
+                const pointsPaneName = `zenit-layer-${layerState.mapLayer.layerId}-points`;
+                const labelPaneName = `zenit-layer-${layerState.mapLayer.layerId}-labels`;
                 const layerType = layerState.layer?.layerType ?? layerState.mapLayer.layerType ?? void 0;
-                return /* @__PURE__ */ jsx(
-                  GeoJSON,
-                  {
-                    data: layerState.data,
-                    pane: mapInstance?.getPane(paneName) ? paneName : void 0,
-                    style: (feature) => buildLayerStyle(layerState.mapLayer.layerId, baseOpacity, feature, layerType),
-                    pointToLayer: (feature, latlng) => L.circleMarker(latlng, {
-                      radius: isMobile ? 8 : 6,
-                      ...buildLayerStyle(layerState.mapLayer.layerId, baseOpacity, feature, layerType)
-                    }),
-                    onEachFeature: overlayOnEachFeature
-                  },
-                  layerState.mapLayer.layerId.toString()
-                );
+                const data = layerState.data?.features ?? [];
+                const fillFeatures = data.filter(isNonPointGeometry);
+                const pointFeatures = data.filter(isPointGeometry);
+                const fillData = fillFeatures.length > 0 ? buildFeatureCollection(fillFeatures) : null;
+                const pointsData = pointFeatures.length > 0 ? buildFeatureCollection(pointFeatures) : null;
+                return /* @__PURE__ */ jsxs(React.Fragment, { children: [
+                  fillData && /* @__PURE__ */ jsx(
+                    GeoJSON,
+                    {
+                      data: fillData,
+                      pane: panesReady && mapInstance?.getPane(fillPaneName) ? fillPaneName : void 0,
+                      style: (feature) => buildLayerStyle(layerState.mapLayer.layerId, baseOpacity, feature, layerType),
+                      onEachFeature: overlayOnEachFeature
+                    }
+                  ),
+                  pointsData && /* @__PURE__ */ jsx(
+                    GeoJSON,
+                    {
+                      data: pointsData,
+                      pane: panesReady && mapInstance?.getPane(pointsPaneName) ? pointsPaneName : void 0,
+                      pointToLayer: (feature, latlng) => L.circleMarker(latlng, {
+                        radius: isMobile ? 8 : 6,
+                        ...buildLayerStyle(layerState.mapLayer.layerId, baseOpacity, feature, layerType)
+                      }),
+                      onEachFeature: overlayOnEachFeature
+                    }
+                  ),
+                  panesReady && mapInstance?.getPane(labelPaneName) ? labelMarkers.filter(
+                    (marker) => String(marker.layerId) === String(layerState.mapLayer.layerId)
+                  ).map((marker) => /* @__PURE__ */ jsx(
+                    Marker,
+                    {
+                      position: marker.position,
+                      icon: buildLabelIcon(marker.label, marker.opacity, marker.color),
+                      interactive: false,
+                      pane: labelPaneName
+                    },
+                    marker.key
+                  )) : null
+                ] }, layerState.mapLayer.layerId.toString());
               }),
               overlayGeojson && /* @__PURE__ */ jsx(
                 GeoJSON,
@@ -1118,16 +1564,7 @@ var ZenitMap = forwardRef(({
                   onEachFeature: overlayOnEachFeature
                 },
                 "zenit-overlay-geojson"
-              ),
-              labelMarkers.map((marker) => /* @__PURE__ */ jsx(
-                Marker,
-                {
-                  position: marker.position,
-                  icon: buildLabelIcon(marker.label, marker.opacity, marker.color),
-                  interactive: false
-                },
-                marker.key
-              ))
+              )
             ]
           },
           String(mapId)
@@ -2543,9 +2980,19 @@ var FloatingChatBox = ({
   getAccessToken,
   onActionClick,
   onOpenChange,
-  hideButton
+  hideButton,
+  open: openProp
 }) => {
-  const [open, setOpen] = useState4(false);
+  const isControlled = openProp !== void 0;
+  const [internalOpen, setInternalOpen] = useState4(false);
+  const open = isControlled ? openProp : internalOpen;
+  const setOpen = useCallback3((value) => {
+    const newValue = typeof value === "function" ? value(open) : value;
+    if (!isControlled) {
+      setInternalOpen(newValue);
+    }
+    onOpenChange?.(newValue);
+  }, [isControlled, open, onOpenChange]);
   const [expanded, setExpanded] = useState4(false);
   const [messages, setMessages] = useState4([]);
   const [inputValue, setInputValue] = useState4("");
@@ -2562,9 +3009,6 @@ var FloatingChatBox = ({
   }, [accessToken, baseUrl, getAccessToken]);
   const { sendMessage: sendMessage2, isStreaming, streamingText, completeResponse } = useSendMessageStream(chatConfig);
   const canSend = Boolean(mapId) && Boolean(baseUrl) && inputValue.trim().length > 0 && !isStreaming;
-  useEffect3(() => {
-    onOpenChange?.(open);
-  }, [open, onOpenChange]);
   useEffect3(() => {
     if (open && isMobile) {
       setExpanded(true);
@@ -2717,6 +3161,13 @@ var FloatingChatBox = ({
       ] }, index)) })
     ] });
   };
+  const handleActionClick = useCallback3((action) => {
+    if (isStreaming) return;
+    setOpen(false);
+    requestAnimationFrame(() => {
+      onActionClick?.(action);
+    });
+  }, [isStreaming, setOpen, onActionClick]);
   const renderActions = (response) => {
     if (!response?.suggestedActions?.length) return null;
     return /* @__PURE__ */ jsxs4("div", { style: styles.actionsSection, children: [
@@ -2730,7 +3181,7 @@ var FloatingChatBox = ({
             opacity: isStreaming ? 0.5 : 1,
             cursor: isStreaming ? "not-allowed" : "pointer"
           },
-          onClick: () => !isStreaming && onActionClick?.(action),
+          onClick: () => handleActionClick(action),
           disabled: isStreaming,
           onMouseEnter: (e) => {
             if (!isStreaming) {
@@ -3057,4 +3508,4 @@ export {
   useSendMessageStream,
   FloatingChatBox
 };
-//# sourceMappingURL=chunk-R73LRYVJ.mjs.map
+//# sourceMappingURL=chunk-ITF7QCUZ.mjs.map