@page-speed/maps 0.1.9 → 0.2.1

package/dist/components/index.cjs

@@ -658,12 +658,93 @@ function MapLibre({
     }
   );
 }
+var TILE_SIZE = 512;
+function latToMercatorY(lat) {
+  const latRad = lat * Math.PI / 180;
+  const mercN = Math.log(Math.tan(Math.PI / 4 + latRad / 2));
+  return TILE_SIZE / (2 * Math.PI) * (Math.PI - mercN);
+}
+function lngToMercatorX(lng) {
+  return TILE_SIZE / (2 * Math.PI) * ((lng + 180) / 360 * 2 * Math.PI);
+}
+function computeDefaultZoom(options) {
+  const {
+    coordinates,
+    mapWidth,
+    mapHeight,
+    padding = 50,
+    maxZoom = 18,
+    minZoom = 1
+  } = options;
+  if (coordinates.length === 0) return null;
+  if (coordinates.length === 1) return maxZoom;
+  if (mapWidth <= 0 || mapHeight <= 0) return null;
+  let minLat = Infinity;
+  let maxLat = -Infinity;
+  let minLng = Infinity;
+  let maxLng = -Infinity;
+  for (const coord of coordinates) {
+    if (coord.lat < minLat) minLat = coord.lat;
+    if (coord.lat > maxLat) maxLat = coord.lat;
+    if (coord.lng < minLng) minLng = coord.lng;
+    if (coord.lng > maxLng) maxLng = coord.lng;
+  }
+  const pixelXMin = lngToMercatorX(minLng);
+  const pixelXMax = lngToMercatorX(maxLng);
+  const pixelYMin = latToMercatorY(maxLat);
+  const pixelYMax = latToMercatorY(minLat);
+  const dx = Math.abs(pixelXMax - pixelXMin);
+  const dy = Math.abs(pixelYMax - pixelYMin);
+  const availableWidth = mapWidth - padding * 2;
+  const availableHeight = mapHeight - padding * 2;
+  if (availableWidth <= 0 || availableHeight <= 0) return minZoom;
+  let zoom;
+  if (dx === 0 && dy === 0) {
+    return maxZoom;
+  } else if (dx === 0) {
+    zoom = Math.log2(availableHeight / dy);
+  } else if (dy === 0) {
+    zoom = Math.log2(availableWidth / dx);
+  } else {
+    const zoomX = Math.log2(availableWidth / dx);
+    const zoomY = Math.log2(availableHeight / dy);
+    zoom = Math.min(zoomX, zoomY);
+  }
+  return Math.max(minZoom, Math.min(maxZoom, Math.floor(zoom * 100) / 100));
+}
+function useDefaultZoom(options) {
+  const { coordinates, mapWidth, mapHeight, padding, maxZoom, minZoom } = options;
+  return React3.useMemo(
+    () => computeDefaultZoom({
+      coordinates,
+      mapWidth,
+      mapHeight,
+      padding,
+      maxZoom,
+      minZoom
+    }),
+    [coordinates, mapWidth, mapHeight, padding, maxZoom, minZoom]
+  );
+}
 var PANEL_POSITION_CLASS = {
   "top-left": "left-4 top-4",
   "top-right": "right-4 top-4",
   "bottom-left": "bottom-4 left-4",
   "bottom-right": "bottom-4 right-4"
 };
+function getOptimalPanelPosition(markerLat, markerLng, mapCenter) {
+  const isNorth = markerLat >= mapCenter.latitude;
+  const isEast = markerLng >= mapCenter.longitude;
+  if (isNorth && isEast) {
+    return "bottom-left";
+  } else if (isNorth && !isEast) {
+    return "bottom-right";
+  } else if (!isNorth && isEast) {
+    return "top-left";
+  } else {
+    return "top-right";
+  }
+}
 var DEFAULT_VIEW_STATE = {
   latitude: 39.5,
   longitude: -98.35,
@@ -906,6 +987,13 @@ function GeoMap({
   IconComponent = FallbackIcon,
   ImgComponent = FallbackImg
 }) {
+  const containerRef = React3__namespace.useRef(null);
+  const [containerDimensions, setContainerDimensions] = React3__namespace.useState({
+    width: 800,
+    // Default width
+    height: 520
+    // Default height
+  });
   const [isMobile, setIsMobile] = React3__namespace.useState(false);
   React3__namespace.useEffect(() => {
     const checkMobile = () => {
@@ -921,6 +1009,24 @@ function GeoMap({
     }
     return isMobile ? 420 : 520;
   }, [mapSize, isMobile]);
+  React3__namespace.useEffect(() => {
+    if (!containerRef.current) return;
+    const updateDimensions = () => {
+      if (containerRef.current) {
+        const rect = containerRef.current.getBoundingClientRect();
+        setContainerDimensions({
+          width: rect.width || 800,
+          height: rect.height || calculatedHeight
+        });
+      }
+    };
+    updateDimensions();
+    if (typeof ResizeObserver !== "undefined") {
+      const resizeObserver = new ResizeObserver(updateDimensions);
+      resizeObserver.observe(containerRef.current);
+      return () => resizeObserver.disconnect();
+    }
+  }, [calculatedHeight]);
   const normalizedStandaloneMarkers = React3__namespace.useMemo(
     () => markers.map((marker, index) => ({
       ...marker,
@@ -1004,47 +1110,49 @@ function GeoMap({
       longitude: DEFAULT_VIEW_STATE.longitude
     };
   }, [normalizedClusters, normalizedStandaloneMarkers]);
-  const calculatedZoom = React3__namespace.useMemo(() => {
-    if (normalizedStandaloneMarkers.length + normalizedClusters.length <= 1) {
-      return markerFocusZoom;
-    }
-    const allCoords = [];
+  const zoomCoordinates = React3__namespace.useMemo(() => {
+    const coords = [];
     normalizedStandaloneMarkers.forEach((marker) => {
-      allCoords.push({
-        latitude: marker.latitude,
-        longitude: marker.longitude
+      coords.push({
+        lat: marker.latitude,
+        lng: marker.longitude
       });
     });
     normalizedClusters.forEach((cluster) => {
-      allCoords.push({
-        latitude: cluster.latitude,
-        longitude: cluster.longitude
+      coords.push({
+        lat: cluster.latitude,
+        lng: cluster.longitude
       });
     });
-    if (allCoords.length === 0) {
+    return coords;
+  }, [normalizedStandaloneMarkers, normalizedClusters]);
+  const properZoom = useDefaultZoom({
+    coordinates: zoomCoordinates,
+    mapWidth: containerDimensions.width,
+    mapHeight: containerDimensions.height,
+    padding: 80,
+    // Increased padding for better framing
+    maxZoom: 18,
+    minZoom: 1
+  });
+  const calculatedZoom = React3__namespace.useMemo(() => {
+    if (zoomCoordinates.length === 1) {
+      return markerFocusZoom;
+    }
+    if (zoomCoordinates.length === 0) {
       return DEFAULT_VIEW_STATE.zoom;
     }
-    const lats = allCoords.map((c) => c.latitude);
-    const lngs = allCoords.map((c) => c.longitude);
-    const latDiff = Math.max(...lats) - Math.min(...lats);
-    const lngDiff = Math.max(...lngs) - Math.min(...lngs);
-    const maxDiff = Math.max(latDiff, lngDiff);
-    const heightFactor = calculatedHeight / 520;
-    const paddingFactor = 0.85;
-    if (maxDiff > 10) return Math.max(2, 3 * heightFactor * paddingFactor);
-    if (maxDiff > 5) return Math.max(4, 5 * heightFactor * paddingFactor);
-    if (maxDiff > 2) return Math.max(6, 7 * heightFactor * paddingFactor);
-    if (maxDiff > 1) return Math.max(8, 9 * heightFactor * paddingFactor);
-    if (maxDiff > 0.5) return Math.max(9, 10 * heightFactor * paddingFactor);
-    if (maxDiff > 0.1) return Math.max(11, 12 * heightFactor * paddingFactor);
-    if (maxDiff > 0.01) return Math.max(12, 13 * heightFactor * paddingFactor);
-    return Math.max(11, 12 * heightFactor * paddingFactor);
-  }, [normalizedClusters, normalizedStandaloneMarkers, markerFocusZoom, calculatedHeight]);
+    const adjustedZoom = properZoom ? properZoom - 0.5 : DEFAULT_VIEW_STATE.zoom;
+    return Math.min(adjustedZoom, 15);
+  }, [properZoom, zoomCoordinates.length, markerFocusZoom]);
   const [uncontrolledViewState, setUncontrolledViewState] = React3__namespace.useState({
     latitude: defaultViewState?.latitude ?? firstCoordinate.latitude,
     longitude: defaultViewState?.longitude ?? firstCoordinate.longitude,
     zoom: defaultViewState?.zoom ?? calculatedZoom
   });
+  const [dynamicPanelPosition, setDynamicPanelPosition] = React3__namespace.useState(
+    panelPosition
+  );
   React3__namespace.useEffect(() => {
     if (!viewState && !defaultViewState) {
       setUncontrolledViewState({
@@ -1124,6 +1232,19 @@ function GeoMap({
         markerId: marker.id,
         clusterId: marker.clusterId
       });
+      const currentCenter = resolvedViewState || {
+        latitude: firstCoordinate.latitude,
+        longitude: firstCoordinate.longitude
+      };
+      const optimalPosition = getOptimalPanelPosition(
+        marker.latitude,
+        marker.longitude,
+        {
+          latitude: currentCenter.latitude ?? firstCoordinate.latitude,
+          longitude: currentCenter.longitude ?? firstCoordinate.longitude
+        }
+      );
+      setDynamicPanelPosition(optimalPosition);
       applyViewState({
         latitude: marker.latitude,
         longitude: marker.longitude,
@@ -1131,7 +1252,7 @@ function GeoMap({
       });
       emitSelectionChange({ type: "marker", marker });
     },
-    [applyViewState, emitSelectionChange, markerFocusZoom]
+    [applyViewState, emitSelectionChange, markerFocusZoom, resolvedViewState, firstCoordinate]
   );
   const selectCluster = React3__namespace.useCallback(
     (cluster) => {
@@ -1139,6 +1260,19 @@ function GeoMap({
         type: "cluster",
         clusterId: cluster.id
       });
+      const currentCenter = resolvedViewState || {
+        latitude: firstCoordinate.latitude,
+        longitude: firstCoordinate.longitude
+      };
+      const optimalPosition = getOptimalPanelPosition(
+        cluster.latitude,
+        cluster.longitude,
+        {
+          latitude: currentCenter.latitude ?? firstCoordinate.latitude,
+          longitude: currentCenter.longitude ?? firstCoordinate.longitude
+        }
+      );
+      setDynamicPanelPosition(optimalPosition);
       applyViewState({
         latitude: cluster.latitude,
         longitude: cluster.longitude,
@@ -1146,7 +1280,7 @@ function GeoMap({
       });
       emitSelectionChange({ type: "cluster", cluster });
     },
-    [applyViewState, clusterFocusZoom, emitSelectionChange]
+    [applyViewState, clusterFocusZoom, emitSelectionChange, resolvedViewState, firstCoordinate]
   );
   const clearSelection = React3__namespace.useCallback(() => {
     setSelection({ type: "none" });
@@ -1365,6 +1499,7 @@ function GeoMap({
   return /* @__PURE__ */ jsxRuntime.jsxs(
     "div",
     {
+      ref: containerRef,
       className: cn(
         "relative rounded-2xl border border-border bg-background",
         // Remove overflow-hidden from outer container to allow panel to overflow
@@ -1432,7 +1567,7 @@ function GeoMap({
           {
             className: cn(
               "pointer-events-none absolute z-30",
-              PANEL_POSITION_CLASS[panelPosition]
+              PANEL_POSITION_CLASS[dynamicPanelPosition]
             ),
             style: {
               // Ensure panel can overflow and has higher z-index