Refactoring: move all code files into a src directory

src/Logic/FeatureSource/TiledFeatureSource/FullNodeDatabaseSource.ts

@@ -0,0 +1,95 @@
+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 {
+    private readonly loadedTiles = new Map<number, Map<number, OsmNode>>()
+    private readonly nodeByIds = new Map<number, OsmNode>()
+    private readonly parentWays = new Map<number, UIEventSource<OsmWay[]>>()
+
+    private smallestZoom = 99
+    private largestZoom = 0
+
+    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
+            }
+            const osmNode = <OsmNode>osmObj
+            nodesById.set(osmNode.id, osmNode)
+            this.nodeByIds.set(osmNode.id, osmNode)
+        }
+
+        for (const osmObj of allObjects) {
+            if (osmObj.type !== "way") {
+                continue
+            }
+            const osmWay = <OsmWay>osmObj
+            for (const nodeId of osmWay.nodes) {
+                if (!this.parentWays.has(nodeId)) {
+                    const src = new UIEventSource<OsmWay[]>([])
+                    this.parentWays.set(nodeId, src)
+                    src.addCallback((parentWays) => {
+                        const tgs = nodesById.get(nodeId).tags
+                        tgs["parent_ways"] = JSON.stringify(parentWays.map((w) => w.tags))
+                        tgs["parent_way_ids"] = JSON.stringify(parentWays.map((w) => w.id))
+                    })
+                }
+                const src = this.parentWays.get(nodeId)
+                src.data.push(osmWay)
+                src.ping()
+            }
+        }
+        const asGeojsonFeatures = Array.from(nodesById.values()).map((osmNode) =>
+            osmNode.asGeoJson()
+        )
+
+        const featureSource = new StaticFeatureSource(asGeojsonFeatures)
+        const tileId = Tiles.tile_index(z, x, y)
+        this.loadedTiles.set(tileId, nodesById)
+    }
+
+    /**
+     * Returns the OsmNode with the corresponding id (undefined if not found)
+     * Note that this OsmNode will have a calculated tag 'parent_ways' and 'parent_way_ids', which are resp. stringified lists of parent way tags and ids
+     * @param id
+     * @constructor
+     */
+    public GetNode(id: number): OsmNode {
+        return this.nodeByIds.get(id)
+    }
+
+    /**
+     * Gets all the ways that the given node is a part of
+     * @param nodeId
+     * @constructor
+     */
+    public GetParentWays(nodeId: number): UIEventSource<OsmWay[]> {
+        return this.parentWays.get(nodeId)
+    }
+
+    /**
+     * 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
+    }
+}