Refactoring: port import flow

Logic/FeatureSource/TiledFeatureSource/FullNodeDatabaseSource.ts

@@ -1,31 +1,25 @@
-import {FeatureSource, FeatureSourceForLayer, Tiled } from "../FeatureSource"
-import { OsmNode, OsmObject, OsmWay } from "../../Osm/OsmObject"
-import SimpleFeatureSource from "../Sources/SimpleFeatureSource"
-import FilteredLayer from "../../../Models/FilteredLayer"
-import { UIEventSource } from "../../UIEventSource"
-import { OsmTags } from "../../../Models/OsmFeature";
-import { BBox } from "../../BBox";
-import { Feature, Point } from "geojson";
+import {OsmNode, OsmObject, OsmWay} from "../../Osm/OsmObject"
+import {UIEventSource} from "../../UIEventSource"
+import {BBox} from "../../BBox";
+import StaticFeatureSource from "../Sources/StaticFeatureSource";
+import {Tiles} from "../../../Models/TileRange";
 
 export default class FullNodeDatabaseSource {
-    public readonly loadedTiles = new Map<number, FeatureSource & Tiled>()
-    private readonly onTileLoaded: (tile: Tiled & FeatureSourceForLayer) => void
-    private readonly layer: FilteredLayer
+
+    private readonly loadedTiles = new Map<number, Map<number, OsmNode>>()
     private readonly nodeByIds = new Map<number, OsmNode>()
     private readonly parentWays = new Map<number, UIEventSource<OsmWay[]>>()
 
-    constructor(layer: FilteredLayer, onTileLoaded: (tile: Tiled & FeatureSourceForLayer) => void) {
-        this.onTileLoaded = onTileLoaded
-        this.layer = layer
-        if (this.layer === undefined) {
-            throw "Layer is undefined"
-        }
-    }
+    private smallestZoom = 99
+    private largestZoom = 0
 
-    public handleOsmJson(osmJson: any, tileId: number) {
+    public handleOsmJson(osmJson: any, z: number, x: number, y: number) : void {
         const allObjects = OsmObject.ParseObjects(osmJson.elements)
         const nodesById = new Map<number, OsmNode>()
 
+        this.smallestZoom = Math.min(this.smallestZoom, z)
+        this.largestZoom = Math.max(this.largestZoom, z)
+
         for (const osmObj of allObjects) {
             if (osmObj.type !== "node") {
                 continue
@@ -59,10 +53,9 @@ export default class FullNodeDatabaseSource {
             osmNode.asGeoJson()
         )
 
-        const featureSource = new SimpleFeatureSource(this.layer, tileId)
-        featureSource.features.setData(asGeojsonFeatures)
-        this.loadedTiles.set(tileId, featureSource)
-        this.onTileLoaded(featureSource)
+        const featureSource = new StaticFeatureSource(asGeojsonFeatures)
+        const tileId = Tiles.tile_index(z, x, y)
+        this.loadedTiles.set(tileId, nodesById)
     }
 
     /**
@@ -76,7 +69,7 @@ export default class FullNodeDatabaseSource {
     }
 
     /**
-     * Gets the parent way list
+     * Gets all the ways that the given node is a part of
      * @param nodeId
      * @constructor
      */
@@ -84,8 +77,20 @@ export default class FullNodeDatabaseSource {
         return this.parentWays.get(nodeId)
     }
 
-    getNodesWithin(bBox: BBox) : Feature<Point, OsmTags>[]{
-        // TODO
-        throw "TODO"
+    /**
+     * Gets (at least) all nodes which are part of this BBOX; might also return some nodes that fall outside of the bbox but are closeby
+     * @param bbox
+     */
+    getNodesWithin(bbox: BBox) : Map<number, OsmNode>{
+        const allById = new Map<number, OsmNode>()
+        for (let z = this.smallestZoom; z < this.largestZoom; z++) {
+            const range = Tiles.tileRangeFrom(bbox, z)
+            Tiles.MapRange(range, (x, y ) => {
+                const tileId = Tiles.tile_index(z, x, y)
+                const nodesById = this.loadedTiles.get(tileId)
+                nodesById?.forEach((v,k) => allById.set(k,v))
+            })
+        }
+        return allById
     }
 }

Logic/FeatureSource/TiledFeatureSource/LocalStorageFeatureSource.ts

@@ -1,9 +1,11 @@
 import DynamicTileSource from "./DynamicTileSource"
-import { Store } from "../../UIEventSource"
-import { BBox } from "../../BBox"
+import {Store} from "../../UIEventSource"
+import {BBox} from "../../BBox"
 import TileLocalStorage from "../Actors/TileLocalStorage"
-import { Feature } from "geojson"
+import {Feature} from "geojson"
 import StaticFeatureSource from "../Sources/StaticFeatureSource"
+import {constants} from "http2";
+import HTTP_STATUS_CONTINUE = module
 
 export default class LocalStorageFeatureSource extends DynamicTileSource {
     constructor(
@@ -15,18 +17,25 @@ export default class LocalStorageFeatureSource extends DynamicTileSource {
             zoom: Store<number>
         },
         options?: {
-            isActive?: Store<boolean>
+            isActive?: Store<boolean>,
+            maxAge?: number // In seconds
         }
     ) {
-        const storage = TileLocalStorage.construct<Feature[]>(backend, layername)
+        const storage = TileLocalStorage.construct<Feature[]>(backend, layername, options?.maxAge ?? 24 * 60 * 60)
         super(
             zoomlevel,
             (tileIndex) =>
                 new StaticFeatureSource(
                     storage
                         .getTileSource(tileIndex)
-                        .map((features) =>
-                            features?.filter((f) => !f.properties.id.match(/(node|way)\/-[0-9]+/))
+                        .mapD((features) => {
+                                if (features.length === undefined) {
+                                    console.trace("These are not features:", features)
+                                    storage.invalidate(zoomlevel, tileIndex)
+                                    return []
+                                }
+                                return features.filter((f) => !f.properties.id.match(/(node|way)\/-[0-9]+/));
+                            }
                         )
                 ),
             mapProperties,