feat(places): unified file import modal with drag-and-drop and deduplication

- Replace separate GPX and KML/KMZ import buttons with a single "Import
  file" modal accepting all three formats, with a drag-and-drop drop zone
- Support dragging files directly onto the Places sidebar panel; overlay
  appears on hover and pre-loads the file into the modal on drop
- Fix [object Object] description bug in KML imports caused by
  fast-xml-parser returning mixed-content nodes as objects; add stopNodes
  config and object guard in asTrimmedString
- Fix CDATA sections leaking into descriptions (e.g. "text.]]>") by
  unwrapping CDATA markers before tag stripping
- Add import deduplication across all import paths (GPX, KML/KMZ, Google
  list, Naver list): reimporting skips places already in the trip by name
  (case-insensitive) or by coordinates (within ~11 m tolerance), with
  intra-batch dedup so duplicate placemarks within the same file are
  also collapsed
- Fix KML route returning 400 "No valid Placemarks found" when all
  placemarks were valid but deduplicated; 400 now only fires when the
  file contains zero placemarks
- Show a warning toast "All places were already in the trip" instead of
  a misleading success toast when a reimport produces zero new places
  (GPX, KML/KMZ, Google list, Naver list)
- Add 8 new i18n keys across all 14 locales; remove 11 keys made unused
  by the modal consolidation

server/src/routes/places.ts

@@ -66,13 +66,13 @@ router.post('/import/gpx', authenticate, requireTripAccess, uploadMulter.single(
   const file = req.file as Express.Multer.File | undefined;
   if (!file) return res.status(400).json({ error: 'No file uploaded' });
 
-  const created = importGpx(tripId, file.buffer);
-  if (!created) {
+  const result = importGpx(tripId, file.buffer);
+  if (!result) {
     return res.status(400).json({ error: 'No waypoints found in GPX file' });
   }
 
-  res.status(201).json({ places: created, count: created.length });
-  for (const place of created) {
+  res.status(201).json({ places: result.places, count: result.count, skipped: result.skipped });
+  for (const place of result.places) {
     broadcast(tripId, 'place:created', { place }, req.headers['x-socket-id'] as string);
   }
 });
@@ -89,7 +89,7 @@ router.post('/import/map', authenticate, requireTripAccess, uploadMulter.single(
 
   try {
     const result = await importMapFile(tripId, file.buffer, file.originalname);
-    if (result.count === 0) {
+    if (result.summary?.totalPlacemarks === 0) {
       return res.status(400).json({ error: 'No valid Placemarks found in map file', summary: result.summary });
     }
 
@@ -120,7 +120,7 @@ router.post('/import/google-list', authenticate, requireTripAccess, async (req:
       return res.status(result.status).json({ error: result.error });
     }
 
-    res.status(201).json({ places: result.places, count: result.places.length, listName: result.listName });
+    res.status(201).json({ places: result.places, count: result.places.length, listName: result.listName, skipped: result.skipped });
     for (const place of result.places) {
       broadcast(tripId, 'place:created', { place }, req.headers['x-socket-id'] as string);
     }
@@ -150,7 +150,7 @@ router.post('/import/naver-list', authenticate, requireTripAccess, async (req: R
       return res.status(result.status).json({ error: result.error });
     }
 
-    res.status(201).json({ places: result.places, count: result.places.length, listName: result.listName });
+    res.status(201).json({ places: result.places, count: result.places.length, listName: result.listName, skipped: result.skipped });
     for (const place of result.places) {
       broadcast(tripId, 'place:created', { place }, req.headers['x-socket-id'] as string);
     }

server/src/services/kmlImport.ts

@@ -40,6 +40,13 @@ function asArray<T>(value: T | T[] | null | undefined): T[] {
 
 function asTrimmedString(value: unknown): string | null {
   if (value == null) return null;
+  // Parsed objects (mixed-content XML parsed without stopNodes) must not
+  // produce "[object Object]" — extract #text if present, else return null.
+  if (typeof value === 'object') {
+    const candidate = (value as Record<string, unknown>)['#text'];
+    if (typeof candidate === 'string') return candidate.trim() || null;
+    return null;
+  }
   const text = String(value).trim();
   return text.length > 0 ? text : null;
 }
@@ -73,7 +80,12 @@ export function sanitizeKmlDescription(value: unknown): string | null {
   const raw = asTrimmedString(value);
   if (!raw) return null;
 
-  const withLineBreaks = raw.replace(/<br\s*\/?>/gi, '\n');
+  // Unwrap CDATA sections — present when fast-xml-parser returns raw node text
+  // via stopNodes. Must happen before tag-stripping so the CDATA markers are
+  // not mis-parsed by the <[^>]+> regex.
+  const withoutCdata = raw.replace(/<!\[CDATA\[([\s\S]*?)\]\]>/g, '$1');
+
+  const withLineBreaks = withoutCdata.replace(/<br\s*\/?>/gi, '\n');
   const stripped = withLineBreaks.replace(/<[^>]+>/g, '');
   const decoded = decodeHtmlEntities(stripped)
     .replace(/\r\n/g, '\n')

server/src/services/placeService.ts

@@ -255,10 +255,77 @@ const kmlParser = new XMLParser({
   attributeNamePrefix: '@_',
   removeNSPrefix: true,
   isArray: (name) => ['Placemark', 'Folder', 'Document'].includes(name),
+  // Treat <description> as raw text so mixed-content HTML (e.g. <br/>, <i>)
+  // is returned as a string instead of a parsed object.
+  stopNodes: ['*.description'],
 });
 
 export const KMZ_DECOMPRESSED_SIZE_LIMIT = 50 * 1024 * 1024; // 50 MB
 
+// ---------------------------------------------------------------------------
+// Import deduplication helpers
+// ---------------------------------------------------------------------------
+
+const COORD_DEDUP_TOLERANCE = 0.0001; // ≈ 11 m
+
+interface DedupSet {
+  names: Set<string>;
+  coords: Array<{ lat: number; lng: number }>;
+}
+
+/** Build a lookup of names/coords for places already in a trip. */
+function buildDedupSet(tripId: string): DedupSet {
+  const rows = db.prepare('SELECT name, lat, lng FROM places WHERE trip_id = ?').all(tripId) as Array<{
+    name: string | null;
+    lat: number | null;
+    lng: number | null;
+  }>;
+  const names = new Set<string>();
+  const coords: Array<{ lat: number; lng: number }> = [];
+  for (const row of rows) {
+    if (row.name) {
+      names.add(row.name.trim().toLowerCase());
+    } else if (row.lat != null && row.lng != null) {
+      coords.push({ lat: row.lat, lng: row.lng });
+    }
+  }
+  return { names, coords };
+}
+
+/**
+ * Returns true if a candidate place is already represented in the dedup set.
+ * Named places match by case-insensitive name; unnamed places fall back to
+ * coordinate proximity.
+ */
+function isPlaceDuplicate(
+  candidate: { name: string | null | undefined; lat: number | null; lng: number | null },
+  dedup: DedupSet,
+): boolean {
+  const normalizedName = candidate.name?.trim().toLowerCase();
+  if (normalizedName) return dedup.names.has(normalizedName);
+  if (candidate.lat != null && candidate.lng != null) {
+    return dedup.coords.some(
+      (c) =>
+        Math.abs(c.lat - candidate.lat!) <= COORD_DEDUP_TOLERANCE &&
+        Math.abs(c.lng - candidate.lng!) <= COORD_DEDUP_TOLERANCE,
+    );
+  }
+  return false;
+}
+
+/** Record a newly inserted place so subsequent candidates in the same batch are checked against it. */
+function trackInsertedInDedupSet(
+  place: { name: string | null | undefined; lat: number | null; lng: number | null },
+  dedup: DedupSet,
+): void {
+  const normalizedName = place.name?.trim().toLowerCase();
+  if (normalizedName) {
+    dedup.names.add(normalizedName);
+  } else if (place.lat != null && place.lng != null) {
+    dedup.coords.push({ lat: place.lat, lng: place.lng });
+  }
+}
+
 export function importGpx(tripId: string, fileBuffer: Buffer) {
   const parsed = gpxParser.parse(fileBuffer.toString('utf-8'));
   const gpx = parsed?.gpx;
@@ -310,21 +377,28 @@ export function importGpx(tripId: string, fileBuffer: Buffer) {
 
   if (waypoints.length === 0) return null;
 
+  const dedup = buildDedupSet(tripId);
   const insertStmt = db.prepare(`
     INSERT INTO places (trip_id, name, description, lat, lng, transport_mode, route_geometry)
     VALUES (?, ?, ?, ?, ?, 'walking', ?)
   `);
   const created: any[] = [];
+  let skipped = 0;
   const insertAll = db.transaction(() => {
     for (const wp of waypoints) {
+      if (isPlaceDuplicate({ name: wp.name, lat: wp.lat, lng: wp.lng }, dedup)) {
+        skipped++;
+        continue;
+      }
       const result = insertStmt.run(tripId, wp.name, wp.description, wp.lat, wp.lng, wp.routeGeometry || null);
       const place = getPlaceWithTags(Number(result.lastInsertRowid));
       created.push(place);
+      trackInsertedInDedupSet({ name: wp.name, lat: wp.lat, lng: wp.lng }, dedup);
     }
   });
   insertAll();
 
-  return created;
+  return { places: created, count: created.length, skipped };
 }
 
 export function importKmlPlaces(tripId: string, fileBuffer: Buffer): PlaceImportResult {
@@ -351,7 +425,9 @@ export function importKmlPlaces(tripId: string, fileBuffer: Buffer): PlaceImport
 
   const categories = db.prepare('SELECT id, name FROM categories').all() as { id: number; name: string }[];
   const categoryLookup = buildCategoryNameLookup(categories);
+  const dedup = buildDedupSet(tripId);
   const created: any[] = [];
+  let dupCount = 0;
 
   const insertStmt = db.prepare(`
     INSERT INTO places (trip_id, name, description, lat, lng, category_id, transport_mode)
@@ -373,6 +449,14 @@ export function importKmlPlaces(tripId: string, fileBuffer: Buffer): PlaceImport
 
       const fallbackName = `Placemark ${fallbackIndex}`;
       const name = parsedPlacemark.name || fallbackName;
+
+      if (isPlaceDuplicate({ name, lat: parsedPlacemark.lat, lng: parsedPlacemark.lng }, dedup)) {
+        summary.skippedCount += 1;
+        dupCount++;
+        fallbackIndex += 1;
+        continue;
+      }
+
       const categoryId = resolveCategoryIdForFolder(parsedPlacemark.folderName, categoryLookup);
 
       const result = insertStmt.run(
@@ -386,6 +470,7 @@ export function importKmlPlaces(tripId: string, fileBuffer: Buffer): PlaceImport
 
       const place = getPlaceWithTags(Number(result.lastInsertRowid));
       created.push(place);
+      trackInsertedInDedupSet({ name, lat: parsedPlacemark.lat, lng: parsedPlacemark.lng }, dedup);
       summary.createdCount += 1;
       fallbackIndex += 1;
     }
@@ -393,6 +478,10 @@ export function importKmlPlaces(tripId: string, fileBuffer: Buffer): PlaceImport
 
   insertAll();
 
+  if (dupCount > 0) {
+    summary.warnings.push(`${dupCount} place${dupCount > 1 ? 's' : ''} skipped (already in trip).`);
+  }
+
   if (summary.totalPlacemarks === 0) {
     summary.errors.push('No Placemarks found in KML file.');
   }
@@ -514,30 +603,23 @@ export async function importGoogleList(tripId: string, url: string) {
     return { error: 'No places with coordinates found in list', status: 400 };
   }
 
-  // Skip places that already exist in this trip (same name + coordinates within ~10m)
-  const existingPlaces = db.prepare(
-    'SELECT name, lat, lng FROM places WHERE trip_id = ?'
-  ).all(tripId) as { name: string; lat: number; lng: number }[];
-
-  const isDuplicate = (p: { name: string; lat: number; lng: number }) =>
-    existingPlaces.some(e =>
-      e.name === p.name && Math.abs(e.lat - p.lat) < 0.0001 && Math.abs(e.lng - p.lng) < 0.0001
-    );
-
-  const newPlaces = places.filter(p => !isDuplicate(p));
-  const skipped = places.length - newPlaces.length;
-
-  // Insert only new places into trip
+  const dedup = buildDedupSet(tripId);
   const insertStmt = db.prepare(`
     INSERT INTO places (trip_id, name, lat, lng, notes, transport_mode)
     VALUES (?, ?, ?, ?, ?, 'walking')
   `);
   const created: any[] = [];
+  let skipped = 0;
   const insertAll = db.transaction(() => {
-    for (const p of newPlaces) {
+    for (const p of places) {
+      if (isPlaceDuplicate({ name: p.name, lat: p.lat, lng: p.lng }, dedup)) {
+        skipped++;
+        continue;
+      }
       const result = insertStmt.run(tripId, p.name, p.lat, p.lng, p.notes);
       const place = getPlaceWithTags(Number(result.lastInsertRowid));
       created.push(place);
+      trackInsertedInDedupSet({ name: p.name, lat: p.lat, lng: p.lng }, dedup);
     }
   });
   insertAll();
@@ -643,21 +725,28 @@ export async function importNaverList(
     return { error: 'No places with coordinates found in list', status: 400 };
   }
 
+  const dedup = buildDedupSet(tripId);
   const insertStmt = db.prepare(`
     INSERT INTO places (trip_id, name, lat, lng, address, notes, transport_mode)
     VALUES (?, ?, ?, ?, ?, ?, 'walking')
   `);
   const created: any[] = [];
+  let skipped = 0;
   const insertAll = db.transaction(() => {
     for (const p of places) {
+      if (isPlaceDuplicate({ name: p.name, lat: p.lat, lng: p.lng }, dedup)) {
+        skipped++;
+        continue;
+      }
       const result = insertStmt.run(tripId, p.name, p.lat, p.lng, p.address, p.notes);
       const place = getPlaceWithTags(Number(result.lastInsertRowid));
       created.push(place);
+      trackInsertedInDedupSet({ name: p.name, lat: p.lat, lng: p.lng }, dedup);
     }
   });
   insertAll();
 
-  return { places: created, listName };
+  return { places: created, listName, skipped };
 }
 
 // ---------------------------------------------------------------------------