zenit-sdk 0.0.3 → 0.0.5

package/dist/{chunk-R73LRYVJ.mjs → chunk-LX2N2BXV.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,121 @@ 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"]);
+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 renderPropertyValue(value) {
+  if (value === null || value === void 0) {
+    return '<span class="prop-empty">\u2014</span>';
+  }
+  if (typeof value === "object") {
+    const json = safeJsonStringify(value);
+    return `<pre class="prop-json">${escapeHtml(json)}</pre>`;
+  }
+  return `<span class="prop-text">${escapeHtml(String(value))}</span>`;
+}
+var POPUP_TITLE_KEYS = ["name", "title", "nombre", "label", "id"];
+var POPUP_CHIP_KEYS = /* @__PURE__ */ new Set(["churn", "color", "sector"]);
+function isChipValue(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function getSanitizedChipColor(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  if (/^#([0-9a-fA-F]{3}){1,2}$/.test(trimmed)) {
+    return trimmed;
+  }
+  if (/^rgb\((\s*\d+\s*,){2}\s*\d+\s*\)$/.test(trimmed)) {
+    return trimmed;
+  }
+  if (/^rgba\((\s*\d+\s*,){3}\s*(0|1|0?\.\d+)\s*\)$/.test(trimmed)) {
+    return trimmed;
+  }
+  return null;
+}
+function getPopupTitle(entries) {
+  for (const candidate of POPUP_TITLE_KEYS) {
+    const match = entries.find((entry) => entry.normalized === candidate);
+    if (!match || match.value === null || match.value === void 0) continue;
+    const value = String(match.value).trim();
+    if (!value) continue;
+    return { title: value, key: match.key };
+  }
+  return null;
+}
+function renderProperties(properties) {
+  const description = extractDescriptionValue(properties);
+  const entries = Object.entries(properties).filter(([key]) => !DESCRIPTION_KEYS.has(key.toLowerCase())).map(([key, value]) => ({
+    key,
+    value,
+    normalized: key.trim().toLowerCase()
+  }));
+  if (!description && entries.length === 0) return "";
+  const titleEntry = getPopupTitle(entries);
+  const titleText = titleEntry?.title ?? "Detalle del elemento";
+  const chipEntries = entries.filter(
+    (entry) => POPUP_CHIP_KEYS.has(entry.normalized) && isChipValue(entry.value)
+  );
+  const listEntries = entries.filter((entry) => {
+    if (titleEntry && entry.key === titleEntry.key) return false;
+    if (chipEntries.find((chip) => chip.key === entry.key)) return false;
+    return true;
+  });
+  const descriptionHtml = description ? `<div class="popup-description">${escapeHtml(description)}</div>` : "";
+  const chipsHtml = chipEntries.length ? `<div class="popup-chip-row">${chipEntries.map((entry) => {
+    const label = escapeHtml(entry.key.replace(/_/g, " "));
+    const value = escapeHtml(String(entry.value));
+    const color = getSanitizedChipColor(entry.value);
+    const colorStyle = color ? ` style="--chip-color: ${color}"` : "";
+    return `<span class="popup-chip"${colorStyle}><span class="popup-chip-label">${label}</span><span class="popup-chip-value">${value}</span></span>`;
+  }).join("")}</div>` : "";
+  const rowsHtml = listEntries.map((entry) => {
+    const label = escapeHtml(entry.key.replace(/_/g, " "));
+    const valueHtml = renderPropertyValue(entry.value);
+    return `<div class="prop-key">${label}</div><div class="prop-value">${valueHtml}</div>`;
+  }).join("");
+  const listHtml = rowsHtml ? `<div class="prop-list">${rowsHtml}</div>` : "";
+  return `
+    <div class="feature-popup">
+      <div class="feature-popup-card">
+        <div class="feature-popup-header">
+          <p class="popup-eyebrow">Informaci\xF3n</p>
+          <h3 class="popup-title">${escapeHtml(titleText)}</h3>
+        </div>
+        <div class="feature-popup-body">
+          ${descriptionHtml}
+          ${chipsHtml}
+          ${listHtml}
+        </div>
+      </div>
+    </div>
+  `;
+}
 function withAlpha(color, alpha) {
   const trimmed = color.trim();
   if (trimmed.startsWith("#")) {
@@ -365,40 +480,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 = renderProperties(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 +633,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;
@@ -833,16 +948,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 +972,7 @@ var ZenitMap = forwardRef(({
   );
   useEffect(() => {
     if (!mapInstance) {
+      setPanesReady(false);
       return;
     }
     if (orderedLayers.length === 0) {
@@ -860,6 +983,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 +1005,14 @@ var ZenitMap = forwardRef(({
       if (featureInfoMode === "popup") {
         const content = buildFeaturePopupHtml(feature);
         if (content) {
-          layer.bindPopup(content, { maxWidth: 320 });
+          layer.bindPopup(content, {
+            maxWidth: 420,
+            minWidth: 280,
+            className: "zenit-feature-popup-shell",
+            autoPan: true,
+            closeButton: true,
+            offset: L.point(0, -24)
+          });
         }
       }
       if (isPointFeature && layer.bindTooltip) {
@@ -888,7 +1023,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 +1077,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 +1258,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 +1311,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 +2727,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 +2756,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 +2908,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 +2928,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 +3255,4 @@ export {
   useSendMessageStream,
   FloatingChatBox
 };
-//# sourceMappingURL=chunk-R73LRYVJ.mjs.map
+//# sourceMappingURL=chunk-LX2N2BXV.mjs.map