Offline-Karten Runde 5: Geraetetest-Feedback (Indikator, Flugmodus-Signal, Ent-Funklochen, Warnungs-Aktualitaet, Routen-Start-Check)

- Indikator links unter die Zoom-Regler (rechts verdeckte Legenden-Chips)
- Flugmodus bei offener App -> Position raw als Funkloch-Zone (offline-Event)
- Ent-Funklochen: Zonen-Liste im Offline-Modal mit X (removeDeadZone)
- Warnungs-Aktualitaet: _mergeStore Bbox-Replace (aufgehobene Giftkoeder/
  gefundene Hunde verschwinden; Fetch-Kreis deckt Bbox via sqrt2 ab;
  fresh=null merged nie) + 24h-Refresh im 50km-Umkreis beim Start
- Routen offline nutzbar halten: ensureRouteCorridors beim Start-Check
  (Stichproben-Verify, Re-Download aus preview_track, Region-Dedupe)
- Stub-Tests ins Repo: tests/js/ (r1/r3/r4/r5, alle gruen)
Bump v1231

tests/js/README.md

@@ -0,0 +1,15 @@
+# JS-Logik-Tests (Node, ohne Browser)
+
+Stub-Tests für `backend/static/js/map-offline.js` (IndexedDB/pmtiles/fetch gemockt):
+
+```
+for f in tests/js/test-map-offline*.js; do node "$f" backend/static/js/map-offline.js; done
+```
+
+- r1: Budget-Download, Korridor, Coverage, Deadzone-Dedupe
+- r3: downloadBbox, Zu-groß-Schutz, totalBytes, Prefetch-Throttle, Cap-Guard, persist()
+- r4: Minimal-Speicher-Modell (Prune, Netz-Probe, clear behält Zonen, Nähe/Verify, Färbung)
+- r5: Bbox-Replace (aufgehobene Warnungen), 24h-Alert-Refresh, removeDeadZone, ensureRouteCorridors
+
+⚠️ Node 21+: eingebautes `navigator`-Global — Stubs via `Object.defineProperty(globalThis, 'navigator', …)`,
+ein einfaches `global.navigator =` wird still verschluckt.

tests/js/test-map-offline-r1.js

@@ -0,0 +1,82 @@
+// Isolierter Logik-Test für map-offline.js (IndexedDB/pmtiles/fetch gestubbt)
+const fs = require('fs');
+
+const stores = { tiles: new Map(), meta: new Map() };
+function mkReq(result) { return { result }; }
+global.indexedDB = {
+  open() {
+    const req = {};
+    setTimeout(() => {
+      const db = {
+        objectStoreNames: { contains: n => !!stores[n] },
+        transaction(name) {
+          const os = {
+            get: k => mkReq(stores[name].get(k)),
+            put: (v, k) => { stores[name].set(k, v); return mkReq(undefined); },
+            count: () => mkReq(stores[name].size),
+            getAllKeys: () => mkReq([...stores[name].keys()]),
+          };
+          const tx = { objectStore: () => os };
+          setTimeout(() => tx.oncomplete && tx.oncomplete());
+          return tx;
+        },
+        close() {},
+      };
+      req.result = db;
+      req.onsuccess && req.onsuccess();
+    });
+    return req;
+  },
+};
+global.window = {};
+Object.defineProperty(globalThis, 'navigator', { value: { onLine: true }, configurable: true });
+global.pmtiles = { PMTiles: class { getZxy() { return Promise.resolve({ data: new Uint8Array(100).buffer }); } } };
+global.MapGLStyle = { tilesUrl: () => 'http://test/dach.pmtiles' };
+global.fetch = (url) => Promise.resolve({
+  ok: true,
+  arrayBuffer: () => Promise.resolve(new Uint8Array(50).buffer),
+  json: () => Promise.resolve(url.includes('giftkoeder') ? [{ id: 1, lat: 48.08, lon: 11.97 }] : []),
+});
+
+eval(fs.readFileSync(process.argv[2], 'utf8'));
+const MO = global.window.MapOffline;
+
+(async () => {
+  // 1. Budget-Download: winziges Budget → muss nach wenigen Ringen stoppen
+  const r1 = await MO.downloadAround(48.07, 11.96, { budgetMB: 0.01, maxRadiusKm: 10 });
+  console.log('downloadAround:', JSON.stringify(r1));
+  if (!(r1.tiles > 0 && r1.bytes >= 10240)) throw new Error('Budget-Download speichert nichts');
+
+  // 2. Korridor
+  const track = [{ lat: 48.07, lon: 11.96 }, { lat: 48.08, lon: 11.99 }, { lat: 48.09, lon: 12.02 }];
+  const r2 = await MO.downloadCorridor(track, { bufferKm: 1, name: 'Test' });
+  console.log('downloadCorridor:', JSON.stringify(r2));
+  if (!(r2.tiles > 0)) throw new Error('Korridor speichert keine Kacheln');
+
+  // 3. Coverage muss die z14-Kacheln aus 1+2 enthalten
+  const gj = await MO.coverage();
+  const z14 = [...stores.tiles.keys()].filter(k => /^14\//.test(k)).length;
+  console.log('coverage-Features:', gj.features.length, '— z14-Keys im Store:', z14);
+  if (gj.features.length !== z14) throw new Error('Coverage != gespeicherte z14-Kacheln');
+  if (!gj.features.length) throw new Error('Coverage leer');
+
+  // 4. Geometrie-Plausibilität: Feature in Track-Nähe?
+  const c = gj.features[0].geometry.coordinates[0][0];
+  console.log('Beispiel-Ecke:', c);
+  if (Math.abs(c[1] - 48.08) > 0.3 || Math.abs(c[0] - 11.99) > 0.5) throw new Error('Coverage-Polygon liegt falsch');
+
+  // 5. Regions-Meta
+  const s = await MO.stats();
+  console.log('regions:', JSON.stringify(s.regions.map(r => ({ type: r.type || 'gebiet', tiles: r.tiles }))));
+  if (s.regions.length !== 2) throw new Error('Regions-Liste unvollständig');
+
+  // 6. Funkloch: markDeadZone + Dedupe
+  await MO.markDeadZone(48.5, 12.5);
+  await MO.markDeadZone(48.5005, 12.5005);   // < 2 km → Dedupe
+  await MO.markDeadZone(48.8, 12.9);
+  const zones = stores.meta.get('deadzones');
+  console.log('deadzones:', zones.length);
+  if (zones.length !== 2) throw new Error('Deadzone-Dedupe kaputt');
+
+  console.log('\nALLE TESTS BESTANDEN');
+})().catch(e => { console.error('FEHLER:', e.message); process.exit(1); });

tests/js/test-map-offline-r3.js

@@ -0,0 +1,78 @@
+// Runde-3-Tests: downloadBbox, rollendes Vorausladen (setGps), Cap
+const fs = require('fs');
+const stores = { tiles: new Map(), meta: new Map() };
+function mkReq(result) { return { result }; }
+global.indexedDB = { open() {
+  const req = {};
+  setTimeout(() => {
+    const db = {
+      objectStoreNames: { contains: n => !!stores[n] },
+      transaction(name) {
+        const os = {
+          get: k => mkReq(stores[name].get(k)),
+          put: (v, k) => { stores[name].set(k, v); return mkReq(undefined); },
+          count: () => mkReq(stores[name].size),
+          getAllKeys: () => mkReq([...stores[name].keys()]),
+        };
+        const tx = { objectStore: () => os };
+        setTimeout(() => tx.oncomplete && tx.oncomplete());
+        return tx;
+      },
+      close() {},
+    };
+    req.result = db; req.onsuccess && req.onsuccess();
+  });
+  return req;
+} };
+global.window = {};
+let persistCalled = 0;
+Object.defineProperty(globalThis, 'navigator', { value: { onLine: true, storage: { persist: () => { persistCalled++; return Promise.resolve(true); } } }, configurable: true });
+global.pmtiles = { PMTiles: class { getZxy() { return Promise.resolve({ data: new Uint8Array(100).buffer }); } } };
+global.MapGLStyle = { tilesUrl: () => 'http://test/dach.pmtiles' };
+global.fetch = () => Promise.resolve({ ok: true, arrayBuffer: () => Promise.resolve(new Uint8Array(50).buffer), json: () => Promise.resolve([]) });
+eval(fs.readFileSync(process.argv[2], 'utf8'));
+const MO = global.window.MapOffline;
+
+(async () => {
+  // 1. downloadBbox: kleiner Ausschnitt
+  const r1 = await MO.downloadBbox({ south: 48.06, west: 11.94, north: 48.09, east: 11.99 }, { capMB: 40 });
+  console.log('downloadBbox:', JSON.stringify(r1));
+  if (!(r1.tiles > 0)) throw new Error('Bbox-Download leer');
+  if (!persistCalled) throw new Error('storage.persist() nicht aufgerufen');
+
+  // 2. Zu-groß-Schutz
+  let threw = false;
+  await MO.downloadBbox({ south: 40, west: 0, north: 55, east: 20 }, {}).catch(e => { threw = /zu groß/.test(e.message); });
+  console.log('Zu-groß-Schutz:', threw);
+  if (!threw) throw new Error('Zu-groß-Schutz fehlt');
+
+  // 3. totalBytes-Zähler + stats
+  const s = await MO.stats();
+  console.log('totalBytes:', s.totalBytes);
+  if (!(s.totalBytes > 0)) throw new Error('totalBytes nicht gezählt');
+
+  // 4. Rollendes Vorausladen: setGps zweimal — erst > 400m Distanz lädt neu
+  const before = stores.tiles.size;
+  MO.setGps({ lat: 47.50, lon: 11.50 });
+  await new Promise(r => setTimeout(r, 300));
+  const afterFirst = stores.tiles.size;
+  console.log('Prefetch nach 1. setGps:', afterFirst - before, 'neue Keys');
+  if (afterFirst <= before) throw new Error('Rollendes Vorausladen lädt nichts');
+  MO.setGps({ lat: 47.5001, lon: 11.5001 });   // < 400 m → kein neuer Load
+  await new Promise(r => setTimeout(r, 200));
+  if (stores.tiles.size !== afterFirst) throw new Error('Distanz-Throttle greift nicht');
+  MO.setGps({ lat: 47.51, lon: 11.52 });        // > 400 m → neuer Ring
+  await new Promise(r => setTimeout(r, 300));
+  console.log('Prefetch nach Bewegung:', stores.tiles.size - afterFirst, 'neue Keys');
+  if (stores.tiles.size <= afterFirst) throw new Error('Vorausladen nach Bewegung fehlt');
+
+  // 5. Cap stoppt Vorausladen
+  stores.meta.set('totalBytes', 300 * 1048576);
+  const capBefore = stores.tiles.size;
+  MO.setGps({ lat: 47.60, lon: 11.60 });
+  await new Promise(r => setTimeout(r, 300));
+  if (stores.tiles.size !== capBefore) throw new Error('Cap stoppt Vorausladen nicht');
+  console.log('Cap-Guard: ok');
+
+  console.log('\nALLE RUNDE-3-TESTS BESTANDEN');
+})().catch(e => { console.error('FEHLER:', e.message); process.exit(1); });

tests/js/test-map-offline-r4.js

@@ -0,0 +1,99 @@
+// Runde-4-Tests: Minimal-Speicher-Modell (Prune, clear-behält-Zonen, Verify, Probe, Färbung)
+const fs = require('fs');
+const stores = { tiles: new Map(), meta: new Map() };
+function mkReq(result) { return { result }; }
+global.indexedDB = { open() {
+  const req = {};
+  setTimeout(() => {
+    const db = {
+      objectStoreNames: { contains: n => !!stores[n] },
+      transaction(name) {
+        const os = {
+          get: k => mkReq(stores[name].get(k)),
+          put: (v, k) => { stores[name].set(k, v); return mkReq(undefined); },
+          delete: k => { stores[name].delete(k); return mkReq(undefined); },
+          clear: () => { stores[name].clear(); return mkReq(undefined); },
+          count: () => mkReq(stores[name].size),
+          getAllKeys: () => mkReq([...stores[name].keys()]),
+        };
+        const tx = { objectStore: () => os };
+        setTimeout(() => tx.oncomplete && tx.oncomplete());
+        return tx;
+      },
+      close() {},
+    };
+    req.result = db; req.onsuccess && req.onsuccess();
+  });
+  return req;
+} };
+global.window = {};
+Object.defineProperty(globalThis, 'navigator', { value: { onLine: true, storage: { persist: () => Promise.resolve(true) } }, configurable: true });
+let tileFails = false;
+global.pmtiles = { PMTiles: class { getZxy() { return tileFails ? Promise.reject(new Error('offline')) : Promise.resolve({ data: new Uint8Array(100).buffer }); } } };
+global.MapGLStyle = { tilesUrl: () => 'http://t/d.pmtiles' };
+let apiFails = false;
+global.fetch = (url) => apiFails
+  ? Promise.reject(new Error('offline'))
+  : Promise.resolve({ ok: true, arrayBuffer: () => Promise.resolve(new Uint8Array(50).buffer), json: () => Promise.resolve([]) });
+eval(fs.readFileSync(process.argv[2], 'utf8'));
+const MO = global.window.MapOffline;
+const sleep = ms => new Promise(r => setTimeout(r, ms));
+
+(async () => {
+  // 1. Ephemeres Vorausladen: Runde OHNE Funkloch → Prefetch wird gelöscht
+  MO.setGps({ lat: 47.5, lon: 11.5 });
+  await sleep(300);
+  const afterPre = stores.tiles.size;
+  if (!(afterPre > 0)) throw new Error('Prefetch lief nicht');
+  MO.setGps(null);
+  await sleep(300);
+  console.log('Prune ohne Funkloch:', afterPre, '→', stores.tiles.size);
+  if (stores.tiles.size !== 0) throw new Error('Prefetch nicht gepruned');
+
+  // 2. Runde MIT Funkloch (Netz-Probe schlägt fehl) → Prefetch bleibt + Zone gemerkt
+  MO.setGps({ lat: 47.5, lon: 11.5 });
+  await sleep(300);
+  tileFails = true;                                  // Funkloch: Tile-Remote-Miss bei aktivem GPS
+  MO.setGps({ lat: 47.6, lon: 11.6 });
+  await MO.tile(14, 1, 1);                           // nicht gespeichert + remote weg -> _noteRemoteMiss
+  await sleep(300);
+  tileFails = false;
+  MO.setGps(null);
+  await sleep(300);
+  const zones1 = stores.meta.get('deadzones') || [];
+  console.log('Nach Funkloch-Runde: tiles=', stores.tiles.size, 'zones=', zones1.length);
+  if (!(stores.tiles.size > 0)) throw new Error('Prefetch trotz Funkloch gepruned');
+  if (!(zones1.length >= 1)) throw new Error('Netz-Probe hat Funkloch nicht gemerkt');
+
+  // 3. clear() behält Zonen (filled=false)
+  stores.meta.get('deadzones').forEach(z => z.filled = true);
+  stores.meta.set('deadzones', stores.meta.get('deadzones'));
+  await MO.clear();
+  const zones2 = stores.meta.get('deadzones') || [];
+  console.log('Nach clear(): tiles=', stores.tiles.size, 'zones=', zones2.length, 'filled=', zones2.filter(z => z.filled).length);
+  if (stores.tiles.size !== 0) throw new Error('clear löscht Kacheln nicht');
+  if (!zones2.length || zones2.some(z => z.filled)) throw new Error('clear behält/reset Zonen nicht');
+
+  // 4. autoFill mit Position: nahe Zone gefüllt (type funkloch), ferne (>50km) bleibt offen
+  await MO.markDeadZone(49.9, 13.9);                 // ~270 km entfernt
+  const n = await MO.autoFillDeadZones({ lat: 47.6, lon: 11.62 });
+  const zones3 = stores.meta.get('deadzones');
+  const near = zones3.find(z => Math.abs(z.lat - 47.6) < 0.2);
+  const far  = zones3.find(z => z.lat === 49.9);
+  console.log('autoFill nahe:', n, 'gefüllt; fern offen:', !far.filled);
+  if (!near.filled || far.filled) throw new Error('Nähe-Filter kaputt');
+
+  // 5. Verify: gefüllte Zone, Kacheln weg → wird beim nächsten autoFill neu geladen
+  stores.tiles.clear();
+  const n2 = await MO.autoFillDeadZones({ lat: 47.6, lon: 11.62 });
+  console.log('Re-Fill nach Kachel-Verlust:', n2);
+  if (n2 < 1) throw new Error('Coverage-Verify lädt nicht nach');
+
+  // 6. Coverage-Färbung: funkloch-Kacheln markiert
+  const gj = await MO.coverage();
+  const fz = gj.features.filter(f => f.properties.kind === 'funkloch').length;
+  console.log('Coverage:', gj.features.length, 'Features, davon funkloch:', fz);
+  if (!(fz > 0)) throw new Error('Funkloch-Kacheln nicht markiert');
+
+  console.log('\nALLE RUNDE-4-TESTS BESTANDEN');
+})().catch(e => { console.error('FEHLER:', e.message); process.exit(1); });

tests/js/test-map-offline-r5.js

@@ -0,0 +1,93 @@
+// Runde-5-Tests: Bbox-Replace, 24h-Refresh, removeDeadZone, ensureRouteCorridors
+const fs = require('fs');
+const stores = { tiles: new Map(), meta: new Map() };
+function mkReq(result) { return { result }; }
+global.indexedDB = { open() {
+  const req = {};
+  setTimeout(() => {
+    const db = {
+      objectStoreNames: { contains: n => !!stores[n] },
+      transaction(name) {
+        const os = {
+          get: k => mkReq(stores[name].get(k)),
+          put: (v, k) => { stores[name].set(k, v); return mkReq(undefined); },
+          delete: k => { stores[name].delete(k); return mkReq(undefined); },
+          clear: () => { stores[name].clear(); return mkReq(undefined); },
+          count: () => mkReq(stores[name].size),
+          getAllKeys: () => mkReq([...stores[name].keys()]),
+        };
+        const tx = { objectStore: () => os };
+        setTimeout(() => tx.oncomplete && tx.oncomplete());
+        return tx;
+      },
+      close() {},
+    };
+    req.result = db; req.onsuccess && req.onsuccess();
+  });
+  return req;
+} };
+global.window = {};
+Object.defineProperty(globalThis, 'navigator', { value: { onLine: true, storage: { persist: () => Promise.resolve(true) } }, configurable: true });
+global.pmtiles = { PMTiles: class { getZxy() { return Promise.resolve({ data: new Uint8Array(100).buffer }); } } };
+global.MapGLStyle = { tilesUrl: () => 'http://t/d.pmtiles' };
+// Giftköder-Szenario: 1. Laden liefert Alarm 1+2, 2. Laden nur noch Alarm 1 (Alarm 2 aufgehoben)
+let poisonRound = 0;
+global.fetch = (url) => {
+  if (url.includes('/api/poison')) {
+    poisonRound++;
+    const data = poisonRound === 1
+      ? [{ id: 1, lat: 48.07, lon: 11.96 }, { id: 2, lat: 48.075, lon: 11.965 }]
+      : [{ id: 1, lat: 48.07, lon: 11.96 }];
+    return Promise.resolve({ ok: true, json: () => Promise.resolve(data), arrayBuffer: () => Promise.resolve(new Uint8Array(0).buffer) });
+  }
+  return Promise.resolve({ ok: true, arrayBuffer: () => Promise.resolve(new Uint8Array(50).buffer), json: () => Promise.resolve([]) });
+};
+eval(fs.readFileSync(process.argv[2], 'utf8'));
+const MO = global.window.MapOffline;
+
+(async () => {
+  // 1. Bbox-Replace: aufgehobener Giftköder verschwindet beim Re-Download
+  await MO.downloadAround(48.07, 11.96, { budgetMB: 0.005 });
+  let p = stores.tiles.get('p/_poison');
+  console.log('Nach 1. Download Giftköder:', p.map(x => x.id));
+  if (p.length !== 2) throw new Error('Erster Snapshot falsch');
+  await MO.downloadAround(48.07, 11.96, { budgetMB: 0.005 });
+  p = stores.tiles.get('p/_poison');
+  console.log('Nach 2. Download (Alarm 2 aufgehoben):', p.map(x => x.id));
+  if (p.length !== 1 || p[0].id !== 1) throw new Error('Bbox-Replace räumt aufgehobenen Alarm nicht weg');
+
+  // 2. 24h-Refresh: alertsTs alt → autoFill refresht auch ohne offene Zonen
+  stores.meta.set('alertsTs', Date.now() - 2 * 86400000);
+  const before = poisonRound;
+  await MO.autoFillDeadZones({ lat: 48.07, lon: 11.96 });
+  console.log('Alert-Refresh gefeuert:', poisonRound > before, '— alertsTs erneuert:', Date.now() - stores.meta.get('alertsTs') < 5000);
+  if (poisonRound <= before) throw new Error('24h-Refresh feuert nicht');
+  const ts1 = stores.meta.get('alertsTs');
+  await MO.autoFillDeadZones({ lat: 48.07, lon: 11.96 });
+  if (stores.meta.get('alertsTs') !== ts1) throw new Error('Refresh-Throttle (24h) greift nicht');
+
+  // 3. removeDeadZone
+  await MO.markDeadZone(48.5, 12.5);
+  const z = stores.meta.get('deadzones')[0];
+  await MO.removeDeadZone(z.ts);
+  console.log('removeDeadZone:', stores.meta.get('deadzones').length === 0);
+  if (stores.meta.get('deadzones').length !== 0) throw new Error('removeDeadZone kaputt');
+
+  // 4. ensureRouteCorridors: fehlende Route wird geladen, vorhandene nicht doppelt
+  const route = { id: 7, name: 'Weiher-Runde', preview_track: [
+    { lat: 48.20, lon: 12.10 }, { lat: 48.21, lon: 12.12 }, { lat: 48.22, lon: 12.14 }] };
+  const k1 = await MO.ensureRouteCorridors([route], { lat: 48.20, lon: 12.10 });
+  const k2 = await MO.ensureRouteCorridors([route], { lat: 48.20, lon: 12.10 });
+  console.log('ensureRouteCorridors: 1. Lauf geladen:', k1, '— 2. Lauf (abgedeckt):', k2);
+  if (k1 !== 1 || k2 !== 0) throw new Error('Korridor-Ensure kaputt');
+  // ferne Route (>50km) wird ignoriert
+  const far = { id: 8, name: 'Fernroute', preview_track: [{ lat: 50.5, lon: 9.5 }, { lat: 50.6, lon: 9.6 }] };
+  const k3 = await MO.ensureRouteCorridors([far], { lat: 48.20, lon: 12.10 });
+  if (k3 !== 0) throw new Error('Nähe-Filter für Routen kaputt');
+  // Region-Dedupe: 'korridor'+Name nur einmal in der Liste
+  const kr = stores.meta.get('regions').filter(r => r.name === 'Weiher-Runde');
+  console.log('Korridor-Region dedupe:', kr.length === 1);
+  if (kr.length !== 1) throw new Error('_addRegion-Dedupe kaputt');
+
+  console.log('\nALLE RUNDE-5-TESTS BESTANDEN');
+})().catch(e => { console.error('FEHLER:', e.message); process.exit(1); });