Better tracking of cached data, only load data if needed

Logic/FeatureSource/TiledFeatureSource/OsmFeatureSource.ts

@@ -22,7 +22,8 @@ export default class OsmFeatureSource {
         neededTiles: UIEventSource<number[]>,
         state: {
             readonly osmConnection: OsmConnection;
-        };
+        },
+        markTileVisited?: (tileId: number) => void
     };
     private readonly downloadedTiles = new Set<number>()
 
@@ -33,7 +34,8 @@ export default class OsmFeatureSource {
         state: {
             readonly filteredLayers: UIEventSource<FilteredLayer[]>;
             readonly osmConnection: OsmConnection;
-        };
+        },
+        markTileVisited?: (tileId: number) => void
     }) {
         this.options = options;
         this._backend = options.state.osmConnection._oauth_config.url;
@@ -84,13 +86,17 @@ export default class OsmFeatureSource {
                         flatProperties: true
                     });
                 console.log("Tile geojson:", z, x, y, "is", geojson)
+                const index =  Tiles.tile_index(z, x, y);
                 new PerLayerFeatureSourceSplitter(this.filteredLayers,
                     this.handleTile,
                     new StaticFeatureSource(geojson.features, false),
                     {
-                        tileIndex: Tiles.tile_index(z, x, y)
+                        tileIndex:index
                     }
                 );
+                if(this.options.markTileVisited){
+                    this.options.markTileVisited(index)
+                }
             } catch (e) {
                 console.error("Weird error: ", e)
             }

Logic/FeatureSource/TiledFeatureSource/TileHierarchyMerger.ts

@@ -2,7 +2,6 @@ import TileHierarchy from "./TileHierarchy";
 import {UIEventSource} from "../../UIEventSource";
 import FeatureSource, {FeatureSourceForLayer, IndexedFeatureSource, Tiled} from "../FeatureSource";
 import FilteredLayer from "../../../Models/FilteredLayer";
-import {Utils} from "../../../Utils";
 import FeatureSourceMerger from "../Sources/FeatureSourceMerger";
 import {Tiles} from "../../../Models/TileRange";
 import {BBox} from "../../BBox";

Logic/FeatureSource/TiledFeatureSource/TiledFromLocalStorageSource.ts

@@ -3,15 +3,29 @@ import {FeatureSourceForLayer, Tiled} from "../FeatureSource";
 import {UIEventSource} from "../../UIEventSource";
 import Loc from "../../../Models/Loc";
 import TileHierarchy from "./TileHierarchy";
-import {Utils} from "../../../Utils";
 import SaveTileToLocalStorageActor from "../Actors/SaveTileToLocalStorageActor";
 import {Tiles} from "../../../Models/TileRange";
 import {BBox} from "../../BBox";
 
 export default class TiledFromLocalStorageSource implements TileHierarchy<FeatureSourceForLayer & Tiled> {
     public loadedTiles: Map<number, FeatureSourceForLayer & Tiled> = new Map<number, FeatureSourceForLayer & Tiled>();
-public tileFreshness : Map<number, Date> = new Map<number, Date>()
-    
+
+    public static GetFreshnesses(layerId: string): Map<number, Date> {
+        const prefix = SaveTileToLocalStorageActor.storageKey + "-" + layerId + "-"
+        const freshnesses = new Map<number, Date>()
+        for (const key of Object.keys(localStorage)) {
+            if(!(key.startsWith(prefix) && key.endsWith("-time"))){
+                continue
+            }
+            const index = Number(key.substring(prefix.length, key.length - "-time".length))
+            const time = Number(localStorage.getItem(key))
+            const freshness = new Date()
+            freshness.setTime(time)
+            freshnesses.set(index, freshness)
+        }
+        return freshnesses
+    }
+
     constructor(layer: FilteredLayer,
                 handleFeatureSource: (src: FeatureSourceForLayer & Tiled, index: number) => void,
                 state: {
@@ -33,21 +47,17 @@ public tileFreshness : Map<number, Date> = new Map<number, Date>()
 
         console.debug("Layer", layer.layerDef.id, "has following tiles in available in localstorage", indexes.map(i => Tiles.tile_from_index(i).join("/")).join(", "))
         for (const index of indexes) {
-            
-            const prefix = SaveTileToLocalStorageActor.storageKey + "-" + layer.layerDef.id + "-" +index;
-            const version = localStorage.getItem(prefix+"-format")
-            if(version === undefined || version !== SaveTileToLocalStorageActor.formatVersion){
+
+            const prefix = SaveTileToLocalStorageActor.storageKey + "-" + layer.layerDef.id + "-" + index;
+            const version = localStorage.getItem(prefix + "-format")
+            if (version === undefined || version !== SaveTileToLocalStorageActor.formatVersion) {
                 // Invalid version! Remove this tile from local storage
                 localStorage.removeItem(prefix)
+                localStorage.removeItem(prefix+"-time")
+                localStorage.removeItem(prefix+"-format")
                 undefinedTiles.add(index)
                 console.log("Dropped old format tile", prefix)
-                continue
             }
-            
-            const data = Number(localStorage.getItem(prefix+"-time"))
-            const freshness = new Date()
-            freshness.setTime(data)
-            this.tileFreshness.set(index, freshness)
         }
 
         const zLevels = indexes.map(i => i % 100)
@@ -91,8 +101,6 @@ public tileFreshness : Map<number, Date> = new Map<number, Date>()
             }
             , [layer.isDisplayed, state.leafletMap]).stabilized(50);
 
-        neededTiles.addCallbackAndRun(t => console.debug("Tiles to load from localstorage:", t))
-
         neededTiles.addCallbackAndRunD(neededIndexes => {
             for (const neededIndex of neededIndexes) {
                 // We load the features from localStorage