feat(site-planner): frame the map to the coverage bounds with padding on import

After a coverage estimate imports, fit the map to the coverage geometry's
bounding box (computed from the returned GeoJSON) with ~15% margin, so the
whole overlay is visible with breathing room instead of a fixed span centered
on the transmitter. Falls back to the previous fixed span when no bounds can be
derived.

Author: garthvh

Meshtastic/Helpers/SitePlanner/CoverageEstimateRunner.swift

@@ -28,13 +28,23 @@ enum CoverageEstimateState: Equatable {
 	case failed(String)
 }
 
-/// The result of a successful run: the imported overlay's metadata plus the
-/// transmitter coordinate to recenter the map on. `Equatable` (by a per-result
+/// Geographic bounding box (degrees) of an imported coverage overlay, used to frame the map on it.
+struct CoverageBounds {
+	let minLatitude: Double
+	let maxLatitude: Double
+	let minLongitude: Double
+	let maxLongitude: Double
+}
+
+/// The result of a successful run: the imported overlay's metadata, the transmitter coordinate, and
+/// the coverage geometry's bounding box (to frame the map on it). `Equatable` (by a per-result
 /// token) so it can drive a SwiftUI `onChange`.
 struct CoverageEstimateResult: Equatable {
 	let token = UUID()
 	let metadata: MapDataMetadata
 	let coordinate: CLLocationCoordinate2D
+	/// Bounding box of the imported coverage geometry, when derivable from the GeoJSON.
+	let boundingBox: CoverageBounds?
 
 	static func == (lhs: CoverageEstimateResult, rhs: CoverageEstimateResult) -> Bool {
 		lhs.token == rhs.token
@@ -166,21 +176,48 @@ final class CoverageEstimateRunner: NSObject, ObservableObject {
 		let coordinate = CLLocationCoordinate2D(latitude: params.latitude, longitude: params.longitude)
 		let layerName = params.name.trimmingCharacters(in: .whitespacesAndNewlines)
 		let importName = layerName.isEmpty ? "Coverage" : layerName
+		let boundingBox = Self.boundingBox(fromGeoJSON: geoJSON)
 
 		// This method is `@MainActor`, so the Task inherits MainActor isolation — after each
 		// `await` we're back on the main actor and can assign published state directly.
 		Task { [weak self] in
 			do {
 				let metadata = try await MapDataManager.shared.importFromString(geoJSON, name: importName)
 				guard let self else { return }
-				self.importedResult = CoverageEstimateResult(metadata: metadata, coordinate: coordinate)
+				self.importedResult = CoverageEstimateResult(metadata: metadata, coordinate: coordinate, boundingBox: boundingBox)
 				self.state = .imported
 			} catch {
 				self?.state = .failed(error.localizedDescription)
 			}
 		}
 	}
 
+	/// Compute the bounding box of every position in a GeoJSON string. Walks the parsed JSON
+	/// generically: any array whose first element is a number is a `[lon, lat, …]` position, and
+	/// everything else is a container to recurse into — so it works for Point / LineString / Polygon /
+	/// MultiPolygon without a schema. Returns nil when no positions are found.
+	static func boundingBox(fromGeoJSON geoJSON: String) -> CoverageBounds? {
+		guard let data = geoJSON.data(using: .utf8),
+			  let root = try? JSONSerialization.jsonObject(with: data) else { return nil }
+		var minLat = Double.infinity, maxLat = -Double.infinity
+		var minLon = Double.infinity, maxLon = -Double.infinity
+		func walk(_ node: Any) {
+			if let array = node as? [Any] {
+				if let lon = array.first as? Double, array.count >= 2, let lat = array[1] as? Double {
+					minLat = min(minLat, lat); maxLat = max(maxLat, lat)
+					minLon = min(minLon, lon); maxLon = max(maxLon, lon)
+				} else {
+					array.forEach(walk)
+				}
+			} else if let dict = node as? [String: Any] {
+				dict.values.forEach(walk)
+			}
+		}
+		walk(root)
+		guard minLat <= maxLat, minLon <= maxLon else { return nil }
+		return CoverageBounds(minLatitude: minLat, maxLatitude: maxLat, minLongitude: minLon, maxLongitude: maxLon)
+	}
+
 	/// The foreground key window to host the headless WebView.
 	private static func keyWindow() -> UIWindow? {
 		UIApplication.shared.connectedScenes

Meshtastic/Views/Nodes/MeshMapMK.swift

@@ -615,12 +615,31 @@ struct MeshMapMK: View {
 		rebuildGeoJSONOverlays()
 		cameraCommand = ClusterMapCameraCommand(
 			id: UUID(),
-			region: MKCoordinateRegion(
+			region: coverageRegion(for: result),
+			animated: true
+		)
+	}
+
+	/// Frame the map on the imported coverage: fit its bounding box with padding so the whole
+	/// overlay is visible with breathing room. Falls back to a fixed span around the transmitter
+	/// when the GeoJSON yielded no bounds.
+	private func coverageRegion(for result: CoverageEstimateResult) -> MKCoordinateRegion {
+		guard let box = result.boundingBox else {
+			return MKCoordinateRegion(
 				center: result.coordinate,
 				span: MKCoordinateSpan(latitudeDelta: 0.05, longitudeDelta: 0.05)
-			),
-			animated: true
+			)
+		}
+		let padding = 1.3 // ~15% margin on each side
+		let center = CLLocationCoordinate2D(
+			latitude: (box.minLatitude + box.maxLatitude) / 2,
+			longitude: (box.minLongitude + box.maxLongitude) / 2
+		)
+		let span = MKCoordinateSpan(
+			latitudeDelta: min(max((box.maxLatitude - box.minLatitude) * padding, 0.01), 180),
+			longitudeDelta: min(max((box.maxLongitude - box.minLongitude) * padding, 0.01), 360)
 		)
+		return MKCoordinateRegion(center: center, span: span)
 	}
 
 	/// The connected radio's LoRa config, used to prefill frequency / power / sensitivity.