Add the possibility to snap onto another layer with imports, add location confirm on input, add metalayer exporting all nodes, various fixes

Logic/FeatureSource/TiledFeatureSource/FullNodeDatabaseSource.ts

@@ -0,0 +1,70 @@
+import TileHierarchy from "./TileHierarchy";
+import FeatureSource, {FeatureSourceForLayer, Tiled} from "../FeatureSource";
+import {OsmNode, OsmObject, OsmWay} from "../../Osm/OsmObject";
+import SimpleFeatureSource from "../Sources/SimpleFeatureSource";
+import {UIEventSource} from "../../UIEventSource";
+import FilteredLayer from "../../../Models/FilteredLayer";
+
+
+export default class FullNodeDatabaseSource implements TileHierarchy<FeatureSource & Tiled> {
+    public readonly loadedTiles = new Map<number, FeatureSource & Tiled>()
+    private readonly onTileLoaded: (tile: (Tiled & FeatureSourceForLayer)) => void;
+    private readonly layer : FilteredLayer
+    
+    constructor(
+        state: {
+            readonly filteredLayers: UIEventSource<FilteredLayer[]>},
+            osmFeatureSource: { rawDataHandlers: ((data: any, tileId: number) => void)[] }, 
+        onTileLoaded: ((tile: Tiled & FeatureSourceForLayer) => void)) {
+        this.onTileLoaded = onTileLoaded
+        this.layer = state.filteredLayers.data.filter(l => l.layerDef.id === "type_node")[0]
+        if(this.layer === undefined){
+            throw "Weird: tracking all nodes, but layer 'type_node' is not defined"
+        }
+        const self = this
+        osmFeatureSource.rawDataHandlers.push((osmJson, tileId) => self.handleOsmXml(osmJson, tileId))
+    }
+
+    private handleOsmXml(osmJson: any, tileId: number) {
+
+        const allObjects = OsmObject.ParseObjects(osmJson.elements)
+        const nodesById = new Map<number, OsmNode>()
+
+        for (const osmObj of allObjects) {
+            if (osmObj.type !== "node") {
+                continue
+            }
+            const osmNode = <OsmNode>osmObj;
+            nodesById.set(osmNode.id, osmNode)
+        }
+
+        const parentWaysByNodeId = new Map<number, OsmWay[]>()
+        for (const osmObj of allObjects) {
+            if (osmObj.type !== "way") {
+                continue
+            }
+            const osmWay = <OsmWay>osmObj;
+            for (const nodeId of osmWay.nodes) {
+
+                if (!parentWaysByNodeId.has(nodeId)) {
+                    parentWaysByNodeId.set(nodeId, [])
+                }
+                parentWaysByNodeId.get(nodeId).push(osmWay)
+            }
+        }
+        parentWaysByNodeId.forEach((allWays, nodeId) => {
+            nodesById.get(nodeId).tags["parent_ways"] = JSON.stringify(allWays.map(w => w.tags))
+        })
+        const now = new Date()
+        const asGeojsonFeatures = Array.from(nodesById.values()).map(osmNode => ({
+            feature: osmNode.asGeoJson(),freshness: now
+        }))
+
+        const featureSource = new SimpleFeatureSource(this.layer, tileId)
+        featureSource.features.setData(asGeojsonFeatures)
+        this.loadedTiles.set(tileId, featureSource)
+        this.onTileLoaded(featureSource)
+
+    }
+    
+}

Logic/FeatureSource/TiledFeatureSource/OsmFeatureSource.ts

@@ -30,6 +30,8 @@ export default class OsmFeatureSource {
     };
     public readonly downloadedTiles = new Set<number>()
     private readonly allowedTags: TagsFilter;
+    
+    public rawDataHandlers: ((osmJson: any, tileId: number) => void)[] = []
 
     constructor(options: {
         handleTile: (tile: FeatureSourceForLayer & Tiled) => void;
@@ -94,11 +96,11 @@ export default class OsmFeatureSource {
         try {
 
             console.log("Attempting to get tile", z, x, y, "from the osm api")
-            const osmXml = await Utils.download(url, {"accept": "application/xml"})
+            const osmJson = await Utils.downloadJson(url)
             try {
-                const parsed = new DOMParser().parseFromString(osmXml, "text/xml");
                 console.log("Got tile", z, x, y, "from the osm api")
-                const geojson = OsmToGeoJson.default(parsed,
+                this.rawDataHandlers.forEach(handler => handler(osmJson, Tiles.tile_index(z, x, y)))
+                const geojson = OsmToGeoJson.default(osmJson,
                     // @ts-ignore
                     {
                         flatProperties: true