feat: split dropped GPX files into named layers

Dragging or dropping a GPX file now yields separate Waypoints, Tracks,
and Routes layers with descriptive names instead of a single merged
layer, so each geometry type can be styled and toggled independently.

Author: giswqs

apps/geolibre-desktop/src/components/layout/DesktopShell.tsx

@@ -156,7 +156,7 @@ export function DesktopShell({
       let lastLayerId: string | null = null;
       for (const layer of importedLayers) {
         lastLayerId = addGeoJsonLayer(
-          layerNameFromPath(layer.path),
+          layer.name ?? layerNameFromPath(layer.path),
           layer.data,
           layer.path,
         );

apps/geolibre-desktop/src/lib/tauri-io.ts

@@ -10,6 +10,7 @@ import { unzip } from "fflate";
 import type { FeatureCollection } from "geojson";
 import shp from "shpjs";
 import type { DuckDbVectorFile } from "./duckdb-vector-loader";
+import { parseGpxLayer } from "./gpx";
 
 export function isTauri(): boolean {
   return typeof window !== "undefined" && "__TAURI_INTERNALS__" in window;
@@ -96,6 +97,12 @@ interface SaveBinaryFileOptions extends SaveTextFileOptions {}
 
 const SHAPEFILE_SIDECAR_EXTENSIONS = ["dbf", "shx", "prj", "cpg"];
 
+export interface LoadedVectorLayer {
+  data: FeatureCollection;
+  name?: string;
+  path: string;
+}
+
 // Auxiliary files that accompany Shapefiles (spatial indexes, metadata, etc.)
 // but are never standalone vector layers. Skipping them keeps a single such
 // file from aborting an otherwise valid drag-and-drop import.
@@ -191,6 +198,31 @@ async function parseGeoJsonText(
   return assertFeatureCollection(JSON.parse(text));
 }
 
+function parseGpxText(text: string): FeatureCollection {
+  const result = parseGpxLayer(text);
+  return mergeFeatureCollections([
+    result.waypoints,
+    result.tracks,
+    result.routes,
+  ]);
+}
+
+function parseGpxTextLayers(text: string, path: string): LoadedVectorLayer[] {
+  const result = parseGpxLayer(text);
+  const baseName = pathWithoutExtension(browserSafeFileName(path)) || "GPX";
+  return [
+    { data: result.waypoints, label: "Waypoints" },
+    { data: result.tracks, label: "Tracks" },
+    { data: result.routes, label: "Routes" },
+  ]
+    .filter((layer) => layer.data.features.length > 0)
+    .map((layer) => ({
+      data: layer.data,
+      name: `${baseName} ${layer.label}`,
+      path,
+    }));
+}
+
 async function parseShapefileZip(
   data: ArrayBuffer | Uint8Array,
 ): Promise<FeatureCollection> {
@@ -270,10 +302,7 @@ async function fileToDuckDbVectorFile(file: File): Promise<DuckDbVectorFile> {
 async function loadBrowserVectorFile(
   file: File,
   siblingFiles: DuckDbVectorFile[] = [],
-): Promise<{
-  data: FeatureCollection;
-  path: string;
-}> {
+): Promise<LoadedVectorLayer> {
   const extension = fileExtension(file.name);
   if (extension === "geojson" || extension === "json") {
     try {
@@ -305,6 +334,13 @@ async function loadBrowserVectorFile(
     };
   }
 
+  if (extension === "gpx") {
+    return {
+      data: parseGpxText(await file.text()),
+      path: file.name,
+    };
+  }
+
   return {
     data: await loadDuckDbVector({
       name: file.name,
@@ -391,6 +427,18 @@ async function loadTauriVectorFile(path: string): Promise<{
     }
   }
 
+  if (extension === "gpx") {
+    try {
+      return {
+        data: parseGpxText(await readTextFile(path)),
+        path,
+      };
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : "Unknown error";
+      throw new Error(`Could not read this GPX file. ${detail}`);
+    }
+  }
+
   try {
     const siblingFiles =
       extension === "shp" ? await readShapefileSiblings(path) : [];
@@ -884,7 +932,7 @@ export async function openVectorFileWithFallback(): Promise<{
 
 export async function loadDroppedVectorFiles(
   droppedFiles: FileList | File[],
-): Promise<Array<{ data: FeatureCollection; path: string }>> {
+): Promise<LoadedVectorLayer[]> {
   const droppedFileArray = Array.from(droppedFiles);
   const files = droppedFileArray.filter((file) =>
     isVectorFileName(file.name),
@@ -900,11 +948,16 @@ export async function loadDroppedVectorFiles(
     ]);
   }
 
-  const layers: Array<{ data: FeatureCollection; path: string }> = [];
+  const layers: LoadedVectorLayer[] = [];
   for (const file of files) {
     const extension = fileExtension(file.name);
     if (SHAPEFILE_SIDECAR_EXTENSIONS.includes(extension)) continue;
 
+    if (extension === "gpx") {
+      layers.push(...parseGpxTextLayers(await file.text(), file.name));
+      continue;
+    }
+
     const siblingFiles =
       extension === "shp"
         ? await Promise.all(
@@ -928,13 +981,23 @@ export async function loadDroppedVectorFiles(
 
 export async function loadDroppedVectorPaths(
   paths: string[],
-): Promise<Array<{ data: FeatureCollection; path: string }>> {
+): Promise<LoadedVectorLayer[]> {
   const vectorPaths = paths.filter(isVectorFileName);
   if (!vectorPaths.length) return [];
 
-  const layers: Array<{ data: FeatureCollection; path: string }> = [];
+  const layers: LoadedVectorLayer[] = [];
   for (const path of vectorPaths) {
-    if (SHAPEFILE_SIDECAR_EXTENSIONS.includes(fileExtension(path))) continue;
+    const extension = fileExtension(path);
+    if (SHAPEFILE_SIDECAR_EXTENSIONS.includes(extension)) continue;
+    if (extension === "gpx") {
+      try {
+        layers.push(...parseGpxTextLayers(await readTextFile(path), path));
+      } catch (error) {
+        const detail = error instanceof Error ? error.message : "Unknown error";
+        throw new Error(`Could not read this GPX file. ${detail}`);
+      }
+      continue;
+    }
     layers.push(await loadTauriVectorFile(path));
   }