From 29cd489287edaf5a81d4d3594c93ef0806180a12 Mon Sep 17 00:00:00 2001 From: rene Date: Sat, 6 Jun 2026 13:35:18 +0200 Subject: [PATCH] =?UTF-8?q?Offline-Karten=20Runde=207:=20'Alles=20loeschen?= =?UTF-8?q?'=20selektiv=20=E2=80=94=20Standort=20+=20Routen-Korridore=20bl?= =?UTF-8?q?eiben?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Idee Rene (spart Vorladezeit + Daten): statt loeschen-und-neu-laden bleiben - Standort-Gebiete (Regionen type 'standort') - Korridore der gespeicherten Routen (clear({keepTracks}) aus preview_track) - 5-km-Umkreis der aktuellen Position + Basis-Zooms 0-9 - Marker/Warnungen (p/) + Glyphs (f/) Geloescht: manuelle Gebiete/Ausschnitte + Funkloch-Kacheln (Zonen bleiben gemerkt, Nahe laden automatisch neu). Ohne Keep-Kandidaten: Komplett-Wipe. Batch-Delete in einer Transaktion. Tests r7 neu, r6 angepasst, Regression gruen. Bump v1235 --- VERSION | 2 +- backend/static/index.html | 24 ++++---- backend/static/js/app.js | 2 +- backend/static/js/map-offline.js | 94 +++++++++++++++++++++++++++----- backend/static/js/pages/map.js | 19 +++++-- backend/static/landing.html | 2 +- backend/static/sw.js | 2 +- docs/OFFLINE_MAPS_PLAN.md | 9 +++ tests/js/README.md | 1 + tests/js/test-map-offline-r6.js | 11 ++-- tests/js/test-map-offline-r7.js | 66 ++++++++++++++++++++++ 11 files changed, 193 insertions(+), 39 deletions(-) create mode 100644 tests/js/test-map-offline-r7.js diff --git a/VERSION b/VERSION index 274c005..8118744 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1234 \ No newline at end of file +1235 \ No newline at end of file diff --git a/backend/static/index.html b/backend/static/index.html index 9079a4c..cab567b 100644 --- a/backend/static/index.html +++ b/backend/static/index.html @@ -86,14 +86,14 @@ Ban Yaro - + - - - - - + + + + + @@ -612,11 +612,11 @@ - - - - - + + + + + @@ -626,7 +626,7 @@ - + diff --git a/backend/static/js/app.js b/backend/static/js/app.js index c5890c0..04a0e05 100644 --- a/backend/static/js/app.js +++ b/backend/static/js/app.js @@ -3,7 +3,7 @@ Router, State-Management, Navigation, Initialisierung. ============================================================ */ -const APP_VER = '1234'; // ← bei jedem Deploy mit Frontend-Änderungen erhöhen +const APP_VER = '1235'; // ← bei jedem Deploy mit Frontend-Änderungen erhöhen const APP_VERSION = '1.6.0'; // ← semantische Version, wird bei make release gesetzt window.APP_VER = APP_VER; // global verfügbar für andere Module (z.B. offline-indicator) window.APP_VERSION = APP_VERSION; diff --git a/backend/static/js/map-offline.js b/backend/static/js/map-offline.js index 221fdfb..4324bda 100644 --- a/backend/static/js/map-offline.js +++ b/backend/static/js/map-offline.js @@ -39,6 +39,16 @@ window.MapOffline = (function () { var _put = function (k, v) { return _req(STORE, 'readwrite', function (os) { os.put(v, k); }); }; var _del = function (k) { return _req(STORE, 'readwrite', function (os) { os.delete(k); }); }; var _count = function () { return _req(STORE, 'readonly', function (os) { return os.count(); }); }; + // Viele Keys in EINER Transaktion löschen (einzelne _del-Transaktionen wären zu langsam). + function _delMany(keys) { + if (!keys.length) return Promise.resolve(); + return _open().then(function (d) { return new Promise(function (res, rej) { + var tx = d.transaction(STORE, 'readwrite'), os = tx.objectStore(STORE); + keys.forEach(function (k) { os.delete(k); }); + tx.oncomplete = function () { res(); }; + tx.onerror = function () { rej(tx.error); }; + }); }); + } var _metaGet = function (k) { return _req(META, 'readonly', function (os) { return os.get(k); }); }; var _metaPut = function (k, v) { return _req(META, 'readwrite', function (os) { os.put(v, k); }); }; @@ -750,20 +760,78 @@ window.MapOffline = (function () { }); } function hasRegion() { return stats().then(function (s) { return s.count > 0; }).catch(function () { return false; }); } - // „Alles löschen" entfernt Kacheln/Marker/Regionen — das FUNKLOCH-GEDÄCHTNIS bleibt - // (Quelle der Wahrheit, Modell René 2026-06-08): Zonen werden auf filled:false gesetzt - // und beim nächsten Online-Start in Positionsnähe automatisch neu geladen. - function clear() { - return _req(STORE, 'readwrite', function (os) { os.clear(); }) - .then(function () { return _metaGet('deadzones'); }) - .then(function (zones) { - return _req(META, 'readwrite', function (os) { os.clear(); }).then(function () { - if (zones && zones.length) { - zones.forEach(function (z) { z.filled = false; }); - return _metaPut('deadzones', zones); - } - }); + // Kachel-Keys eines Umkreises (alle Zooms) ins Keep-Set legen. + function _keepRegionKeys(lat, lon, radiusKm, keep) { + var bb = _bboxAround(lat, lon, radiusKm); + for (var z = 10; z <= MAXZOOM; z++) { + var x0 = _x(bb.west, z), x1 = _x(bb.east, z), y0 = _y(bb.north, z), y1 = _y(bb.south, z); + for (var x = x0; x <= x1; x++) for (var y = y0; y <= y1; y++) keep[z + '/' + x + '/' + y] = 1; + } + } + // Korridor-Keys eines Tracks (±bufferKm, z10–14) ins Keep-Set legen. + function _keepCorridorKeys(track, bufferKm, keep) { + track.forEach(function (p) { + var d = Math.ceil(bufferKm / _tileKm(MAXZOOM, p.lat)); + var cx = _x(p.lon, MAXZOOM), cy = _y(p.lat, MAXZOOM); + for (var x = cx - d; x <= cx + d; x++) for (var y = cy - d; y <= cy + d; y++) { + keep[MAXZOOM + '/' + x + '/' + y] = 1; + for (var pz = 13; pz >= 10; pz--) { + keep[pz + '/' + (x >> (MAXZOOM - pz)) + '/' + (y >> (MAXZOOM - pz))] = 1; + } + } + }); + } + + // „Alles löschen" — SELEKTIV (René 2026-06-08, spart Vorladezeit): + // BLEIBEN: Standort-Gebiete (Regionen type 'standort'), Korridore der übergebenen + // Routen-Tracks (opts.keepTracks), der Umkreis von opts.center (5 km), Basis-Zooms 0–9 + // (winzig, von allem gebraucht), Marker/Warnungen ('p/') + Glyphs ('f/'). + // GEHEN: manuelle Gebiete/Ausschnitte + Funkloch-Kacheln (Zonen bleiben gemerkt, + // filled:false → Start-Check lädt Nahe automatisch neu). + // Ohne Keep-Kandidaten (alte Signatur/Tests): kompletter Wipe inkl. Basis-Zooms. + function clear(opts) { + opts = opts || {}; + var keep = {}; + return _metaGet('regions').then(function (regions) { + regions = regions || []; + var keptRegions = regions.filter(function (r) { return r.type === 'standort' || r.type === 'korridor'; }); + regions.forEach(function (r) { + if (r.type === 'standort' && r.radiusKm) _keepRegionKeys(r.lat, r.lon, r.radiusKm, keep); }); + if (opts.center) _keepRegionKeys(opts.center.lat, opts.center.lon, 5, keep); + (opts.keepTracks || []).forEach(function (t) { + if (t && t.length >= 2) _keepCorridorKeys(t, 1, keep); + }); + var keepBase = Object.keys(keep).length > 0; + if (!keepBase) keptRegions = []; // nichts zu behalten → echter Komplett-Wipe + + return _req(STORE, 'readonly', function (os) { return os.getAllKeys(); }).then(function (keys) { + // Komplett-Wipe (nichts zu behalten): alles inkl. Marker/Glyphs (altes Verhalten). + if (!keepBase) return _delMany((keys || []).slice()); + var doomed = (keys || []).filter(function (k) { + var m = /^(\d+)\//.exec(k); + if (!m) return false; // 'p/' + 'f/' bleiben + if (+m[1] <= 9) return false; // Basis-Zooms behalten + return !keep[k]; + }); + return _delMany(doomed); + }).then(function () { return _metaGet('deadzones'); }) + .then(function (zones) { + return _req(META, 'readwrite', function (os) { os.clear(); }).then(function () { + var jobs = []; + if (zones && zones.length) { + zones.forEach(function (z) { z.filled = false; }); + jobs.push(_metaPut('deadzones', zones)); + } + if (keptRegions.length) { + jobs.push(_metaPut('regions', keptRegions)); + jobs.push(_metaPut('region', keptRegions[keptRegions.length - 1])); + jobs.push(_metaPut('totalBytes', keptRegions.reduce(function (a, r) { return a + (r.bytes || 0); }, 0))); + } + return Promise.all(jobs); + }); + }); + }); } return { diff --git a/backend/static/js/pages/map.js b/backend/static/js/pages/map.js index 7569458..dc25e0d 100644 --- a/backend/static/js/pages/map.js +++ b/backend/static/js/pages/map.js @@ -2308,13 +2308,22 @@ window.Page_map = (() => { btn.innerHTML = `${UI.icon('trash')} Wirklich alles löschen?`; return; } - await MapOffline.clear().catch(() => {}); + // SELEKTIV löschen (René 2026-06-08, spart Vorladezeit): Standort-Gebiet + Korridore + // der gespeicherten Routen bleiben einfach stehen statt löschen-und-neu-laden. + let keepTracks = []; + try { + keepTracks = ((await API.routes.list()) || []) + .map(r => r.preview_track).filter(t => (t || []).length >= 2); + } catch (e) {} + await MapOffline.clear({ + center: _userPos ? { lat: _userPos.lat, lon: _userPos.lon } : null, + keepTracks, + }).catch(() => {}); _setCoverage(false); UI.modal.close(); - UI.toast.success('Offline-Karten gelöscht. Funkloch-Gebiete werden beim nächsten Start automatisch neu geladen.'); - // Standort-Grundversorgung sofort wiederherstellen (René 2026-06-08: das Gebiet am - // aktuellen Standort muss bleiben — es würde sonst nicht automatisch vorgeladen - // und die Offline-Funktionalität wäre genau hier weg). + UI.toast.success('Offline-Karten gelöscht — Standort-Gebiet und Routen-Korridore bleiben erhalten.'); + // Sicherheitsnetz: falls am Standort nichts zu behalten war (z.B. nie geladen), + // Grundversorgung jetzt herstellen. if (_userPos && navigator.onLine) { try { const r = await MapOffline.ensureHomeArea(_userPos.lat, _userPos.lon); diff --git a/backend/static/landing.html b/backend/static/landing.html index 2266243..dbf53df 100644 --- a/backend/static/landing.html +++ b/backend/static/landing.html @@ -4,7 +4,7 @@ - + Ban Yaro — Die Hunde-App für Deutschland, Österreich & Schweiz diff --git a/backend/static/sw.js b/backend/static/sw.js index cb819ee..c9ef6c8 100644 --- a/backend/static/sw.js +++ b/backend/static/sw.js @@ -4,7 +4,7 @@ ============================================================ */ // ← EINZIGE Stelle für die Version — STATIC_ASSETS und CACHE_VERSION leiten sich ab -const VER = '1234'; +const VER = '1235'; const CACHE_VERSION = `by-v${VER}`; const CACHE_STATIC = `${CACHE_VERSION}-static`; const CACHE_TILES = 'ban-yaro-tiles-v1'; // bleibt über SW-Updates erhalten diff --git a/docs/OFFLINE_MAPS_PLAN.md b/docs/OFFLINE_MAPS_PLAN.md index 1507083..274539b 100644 --- a/docs/OFFLINE_MAPS_PLAN.md +++ b/docs/OFFLINE_MAPS_PLAN.md @@ -128,6 +128,15 @@ type 'standort', Cap-gated). Greift: (a) im Start-Check (raw IDB-Check ohne GL-S Standort-Kachel da UND Zonen im 50-km-Umkreis gefüllt (ferne Zonen zählen nicht mehr — sie laden erst vor Ort). Tests: tests/js/test-map-offline-r6.js. +**✅ Runde 7 — selektives Löschen (2026-06-08, Idee René: Vorladezeit sparen):** +„Alles löschen" löscht nicht mehr alles-und-lädt-neu, sondern **behält** Standort-Gebiete +(`type 'standort'` aus der Regions-Meta), die **Korridore der gespeicherten Routen** +(`clear({keepTracks})`, Tracks via API.routes.list/preview_track), den 5-km-Umkreis der +aktuellen Position, Basis-Zooms 0–9 sowie Marker/Warnungen + Glyphs. Gelöscht werden manuelle +Gebiete/Ausschnitte + Funkloch-Kacheln (Zonen bleiben gemerkt → Nahe laden automatisch neu). +Ohne Keep-Kandidaten: Komplett-Wipe wie bisher. Batch-Delete in einer Transaktion. +Tests: r7 (+ r6 angepasst). + **🔲 Offen (Backlog):** - Echte LRU-Eviction (Refcounting/Region-Zuordnung der Kacheln), wenn Nutzer real ans Cap kommen. - Rechteck-Zeichnen als präzisere Bereichsauswahl (Viewport-Variante deckt den Hauptfall ab). diff --git a/tests/js/README.md b/tests/js/README.md index c37328d..1b5675e 100644 --- a/tests/js/README.md +++ b/tests/js/README.md @@ -11,6 +11,7 @@ for f in tests/js/test-map-offline*.js; do node "$f" backend/static/js/map-offli - 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 - r6: Standort-Grundversorgung (ensureHomeArea: lädt/skippt/Cap, überlebt clear) +- r7: selektives Löschen (Korridor-Keep via keepTracks, manuelle Gebiete weg, Komplett-Wipe-Fallback) ⚠️ Node 21+: eingebautes `navigator`-Global — Stubs via `Object.defineProperty(globalThis, 'navigator', …)`, ein einfaches `global.navigator =` wird still verschluckt. diff --git a/tests/js/test-map-offline-r6.js b/tests/js/test-map-offline-r6.js index b67b850..cfbf1d9 100644 --- a/tests/js/test-map-offline-r6.js +++ b/tests/js/test-map-offline-r6.js @@ -48,14 +48,15 @@ const MO = global.window.MapOffline; console.log('ensureHomeArea (vorhanden):', r2); if (r2 !== 0 || stores.tiles.size !== before) throw new Error('Doppel-Download trotz Bestand'); - // 3. clear() → Zonen bleiben, Standort weg → ensureHomeArea lädt neu + // 3. clear() SELEKTIV: standort-Region bleibt stehen, Zonen bleiben gemerkt await MO.markDeadZone(48.07, 11.96); + const beforeClear = stores.tiles.size; await MO.clear(); - if (stores.tiles.size !== 0) throw new Error('clear unvollständig'); - const r3 = await MO.ensureHomeArea(48.07, 11.96); - console.log('Nach clear neu geladen:', r3, '— Zonen erhalten:', (stores.meta.get('deadzones') || []).length); - if (r3 !== 1) throw new Error('Reload nach clear fehlt'); + console.log('Nach clear: tiles', beforeClear, '→', stores.tiles.size, '— Zonen:', (stores.meta.get('deadzones') || []).length); + if (stores.tiles.size === 0) throw new Error('Standort-Gebiet überlebte clear nicht'); if ((stores.meta.get('deadzones') || []).length !== 1) throw new Error('Zonen weg'); + const r3 = await MO.ensureHomeArea(48.07, 11.96); + if (r3 !== 0) throw new Error('Standort hätte NICHT neu geladen werden müssen'); // 4. Über Cap → Auto-Pfad lädt nicht stores.meta.set('totalBytes', 300 * 1048576); diff --git a/tests/js/test-map-offline-r7.js b/tests/js/test-map-offline-r7.js new file mode 100644 index 0000000..20d64a6 --- /dev/null +++ b/tests/js/test-map-offline-r7.js @@ -0,0 +1,66 @@ +// Runde-7-Tests: selektives Löschen (Korridor-Keep, manuelles Gebiet weg, Komplett-Wipe) +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' }; +global.fetch = () => Promise.resolve({ ok: true, arrayBuffer: () => Promise.resolve(new Uint8Array(50).buffer), json: () => Promise.resolve([{ id: 1, lat: 48.2, lon: 12.1 }]) }); +eval(fs.readFileSync(process.argv[2], 'utf8')); +const MO = global.window.MapOffline; + +(async () => { + // Setup: manuelles Gebiet weit weg (lon 8) + Routen-Korridor (lon 12.1) + await MO.downloadAround(50.0, 8.0, { budgetMB: 0.005 }); + const track = [{ lat: 48.20, lon: 12.10 }, { lat: 48.21, lon: 12.12 }, { lat: 48.22, lon: 12.14 }]; + await MO.downloadCorridor(track, { bufferKm: 1, name: 'R' }); + const before = stores.tiles.size; + const poisBefore = [...stores.tiles.keys()].filter(k => k.startsWith('p/')).length; + + // 1. Selektiv: Korridor bleibt, manuelles Gebiet verschwindet, Marker bleiben + await MO.clear({ keepTracks: [track] }); + const gj = await MO.coverage(); + const lons = gj.features.map(f => f.geometry.coordinates[0][0][0]); + console.log('Selektiv: tiles', before, '→', stores.tiles.size, '— Coverage-Features:', gj.features.length); + if (!gj.features.length) throw new Error('Korridor überlebte nicht'); + if (lons.some(l => l < 11.5)) throw new Error('Manuelles Gebiet (lon 8) überlebte'); + const poisAfter = [...stores.tiles.keys()].filter(k => k.startsWith('p/')).length; + if (poisAfter !== poisBefore) throw new Error('Marker-Stores überlebten nicht'); + const regs = stores.meta.get('regions') || []; + if (!regs.length || regs.some(r => r.type === 'gebiet')) throw new Error('Regions-Meta falsch gefiltert'); + + // 2. Komplett-Wipe ohne Keep-Kandidaten: alles weg (auch p/ + f/), Zonen bleiben + await MO.markDeadZone(48.2, 12.1); + await MO.clear(); + console.log('Komplett-Wipe: tiles =', stores.tiles.size, '— Zonen:', (stores.meta.get('deadzones') || []).length); + // Korridor-Region hat keinen Track in der Meta → kein Keep-Set → echter Wipe + if (stores.tiles.size !== 0) throw new Error('Komplett-Wipe unvollständig'); + if ((stores.meta.get('deadzones') || []).length !== 1) throw new Error('Zonen weg'); + + console.log('\nALLE RUNDE-7-TESTS BESTANDEN'); +})().catch(e => { console.error('FEHLER:', e.message); process.exit(1); });