feat: render PMTiles URLs as external native layers (#81)

* feat: render PMTiles URLs as external native layers

Adds the pmtiles dependency and registers the pmtiles:// protocol so
PMTiles vector and raster sources can be added directly to MapLibre.
Vector sources fan out into fill, line, and circle layers per source
layer, while raster sources render through a single raster layer.

* refactor: improve XYZ tile URL handling and add async URL resolution

Updated the XYZ tile URL rendering to bypass IPC for better performance in Tauri, allowing direct use of HTTPS image tiles. Introduced asynchronous functions for fetching and resolving URLs, with improved error handling and timeout settings for remote tile requests. This enhances responsiveness and reliability when dealing with external tile sources.

* Address Copilot review feedback

- Skip rendering when a PMTiles vector source has no known source layer
  instead of adding an invalid vector fill layer with no `source-layer`,
  which MapLibre would reject at runtime.
- URL-encode the source-layer part of PMTiles vector layer IDs to match
  the MBTiles/vector-tile convention and keep IDs stable and comparable.
- Register and add archives through a single shared PMTiles Protocol
  instance stored on globalThis, and let protocol-registration errors
  surface instead of being silently swallowed.

Author: giswqs

apps/geolibre-desktop/src-tauri/src/lib.rs

@@ -24,6 +24,9 @@ const MARTIN_VERSION: &str = "martin-v1.10.1";
 const MARTIN_RELEASE_BASE_URL: &str = "https://github.com/maplibre/martin/releases/download";
 const MARTIN_START_ATTEMPTS: usize = 3;
 const MARTIN_HEALTH_ATTEMPTS: usize = 30;
+const REMOTE_TILE_TIMEOUT_SECS: u64 = 8;
+const REMOTE_TILE_CONNECT_TIMEOUT_SECS: u64 = 4;
+const URL_RESOLVE_TIMEOUT_SECS: u64 = 15;
 
 struct MartinServerState {
     process: Mutex<Option<MartinProcess>>,
@@ -82,12 +85,25 @@ fn close_oauth_popups(app: tauri::AppHandle) {
 }
 
 #[tauri::command]
-fn fetch_url_bytes(url: String) -> Result<Vec<u8>, String> {
+async fn fetch_url_bytes(url: String) -> Result<Vec<u8>, String> {
+    tauri::async_runtime::spawn_blocking(move || fetch_url_bytes_blocking(url))
+        .await
+        .map_err(|error| format!("Tile fetch task failed: {error}"))?
+}
+
+fn fetch_url_bytes_blocking(url: String) -> Result<Vec<u8>, String> {
     if !url.starts_with("https://") && !url.starts_with("http://") {
         return Err("Only HTTP and HTTPS URLs can be fetched".to_string());
     }
 
-    let response = reqwest::blocking::Client::new()
+    let client = reqwest::blocking::Client::builder()
+        .timeout(Duration::from_secs(REMOTE_TILE_TIMEOUT_SECS))
+        .connect_timeout(Duration::from_secs(REMOTE_TILE_CONNECT_TIMEOUT_SECS))
+        .user_agent("GeoLibre Desktop")
+        .build()
+        .map_err(|error| format!("Could not create HTTP client: {error}"))?;
+
+    let response = client
         .get(&url)
         .send()
         .map_err(|error| format!("Request failed: {error}"))?;
@@ -103,13 +119,21 @@ fn fetch_url_bytes(url: String) -> Result<Vec<u8>, String> {
 }
 
 #[tauri::command]
-fn resolve_url_redirect(url: String) -> Result<String, String> {
+async fn resolve_url_redirect(url: String) -> Result<String, String> {
+    tauri::async_runtime::spawn_blocking(move || resolve_url_redirect_blocking(url))
+        .await
+        .map_err(|error| format!("URL resolve task failed: {error}"))?
+}
+
+fn resolve_url_redirect_blocking(url: String) -> Result<String, String> {
     if !url.starts_with("https://") && !url.starts_with("http://") {
         return Err("Only HTTP and HTTPS URLs can be resolved".to_string());
     }
 
     let client = reqwest::blocking::Client::builder()
-        .timeout(Duration::from_secs(15))
+        .timeout(Duration::from_secs(URL_RESOLVE_TIMEOUT_SECS))
+        .connect_timeout(Duration::from_secs(REMOTE_TILE_CONNECT_TIMEOUT_SECS))
+        .user_agent("GeoLibre Desktop")
         .build()
         .map_err(|error| format!("Could not create HTTP client: {error}"))?;
 

apps/geolibre-desktop/src/lib/xyz-url.ts

@@ -171,12 +171,10 @@ function getSavedXyzUrl(layer: GeoLibreLayer): string | null {
 }
 
 function renderableXyzTileUrl(url: string): string {
-  if (!isTauri() || !isHttpUrl(url)) return url;
-
-  registerXyzTileProtocol();
-  return `${XYZ_TILE_PROTOCOL}://tile/{z}/{x}/{y}?url=${encodeURIComponent(
-    url,
-  )}`;
+  // Tauri allows HTTPS image tiles via CSP, so keep the browser/WebView tile
+  // path. Routing every XYZ tile through IPC makes slow tile servers affect
+  // desktop responsiveness.
+  return url;
 }
 
 function parseXyzTileRequest(request: RequestParameters): string {
@@ -208,10 +206,24 @@ async function resolveShortXyzUrl(
   if (!isHttpUrl(url)) return url;
 
   if (isTauri()) {
+    try {
+      return await resolveShortXyzUrlWithFetch(url, signal);
+    } catch (error) {
+      if (isAbortError(error)) throw error;
+      console.warn("Falling back to desktop URL resolver", error);
+    }
+
     const { invoke } = await import("@tauri-apps/api/core");
     return invoke<string>("resolve_url_redirect", { url });
   }
 
+  return resolveShortXyzUrlWithFetch(url, signal);
+}
+
+async function resolveShortXyzUrlWithFetch(
+  url: string,
+  signal?: AbortSignal,
+): Promise<string> {
   const response = await fetch(url, {
     headers: { Accept: "application/json, text/plain;q=0.9, */*;q=0.8" },
     redirect: "follow",
@@ -229,6 +241,10 @@ async function resolveShortXyzUrl(
   return response.url || url;
 }
 
+function isAbortError(error: unknown): boolean {
+  return error instanceof DOMException && error.name === "AbortError";
+}
+
 function urlFromResolverResponse(response: Response): string | null {
   const resolvedUrl = normalizeTileUrlTemplate(response.url);
   return resolvedUrl && hasXyzTilePlaceholders(resolvedUrl)

package-lock.json

@@ -14,6 +14,7 @@
     "@turf/helpers": "^7.2.0",
     "maplibre-gl": "^5.24.0",
     "maplibre-gl-layer-control": "^0.14.1",
+    "pmtiles": "^4.4.1",
     "react": "^18.3.1",
     "react-dom": "^18.3.1"
   },