Small fixes

Logic/Actors/ChangeToElementsActor.ts

@@ -0,0 +1,36 @@
+import {ElementStorage} from "../ElementStorage";
+import {Changes} from "../Osm/Changes";
+
+export default class ChangeToElementsActor {
+    constructor(changes: Changes, allElements: ElementStorage) {
+        changes.pendingChanges.addCallbackAndRun(changes => {
+            for (const change of changes) {
+                const id = change.type + "/" + change.id;
+                if (!allElements.has(id)) {
+                    continue; // Ignored as the geometryFixer will introduce this
+                }
+                const src = allElements.getEventSourceById(id)
+
+                let changed = false;
+                for (const kv of change.tags ?? []) {
+                    // Apply tag changes and ping the consumers
+                    const k = kv.k
+                    let v = kv.v
+                    if (v === "") {
+                        v = undefined;
+                    }
+                    if (src.data[k] === v) {
+                        continue
+                    }
+                    changed = true;
+                    src.data[k] = v;
+                }
+                if (changed) {
+                    src.ping()
+                }
+
+
+            }
+        })
+    }
+}

Logic/Actors/ExportPDF.ts

@@ -23,12 +23,16 @@
          //minimap op index.html -> hidden daar alles op doen en dan weg
          //minimap - leaflet map ophalen - boundaries ophalen - State.state.featurePipeline
          screenshotter.addTo(State.state.leafletMap.data);
-         let doc = new jsPDF('l');
+         let doc = new jsPDF('landscape');
+         console.log("Taking screenshot")
          screenshotter.takeScreen('image').then(image => {
+             if(!(image instanceof Blob)){
+                 alert("Exporting failed :(")
+                 return;
+             }
              let file = new PDFLayout();
              file.AddLayout(layout, doc, image);
-             console.log("SCREENSHOTTER");
              doc.save(name);
          })
      }
- }
+ }

Logic/Actors/GeoLocationHandler.ts

@@ -1,11 +1,11 @@
 import * as L from "leaflet";
 import {UIEventSource} from "../UIEventSource";
-import {Utils} from "../../Utils";
 import Svg from "../../Svg";
 import Img from "../../UI/Base/Img";
 import {LocalStorageSource} from "../Web/LocalStorageSource";
 import LayoutConfig from "../../Customizations/JSON/LayoutConfig";
 import {VariableUiElement} from "../../UI/Base/VariableUIElement";
+import BaseUIElement from "../../UI/BaseUIElement";
 
 export default class GeoLocationHandler extends VariableUiElement {
     /**
@@ -44,11 +44,13 @@ export default class GeoLocationHandler extends VariableUiElement {
      * @private
      */
     private readonly _leafletMap: UIEventSource<L.Map>;
+    
     /**
      * The date when the user requested the geolocation. If we have a location, it'll autozoom to it the first 30 secs
      * @private
      */
     private _lastUserRequest: Date;
+    
     /**
      * A small flag on localstorage. If the user previously granted the geolocation, it will be set.
      * On firefox, the permissions api is broken (probably fingerprint resistiance) and "granted + don't ask again" doesn't stick between sessions.
@@ -77,19 +79,23 @@ export default class GeoLocationHandler extends VariableUiElement {
         super(
             hasLocation.map(
                 (hasLocationData) => {
+                    let icon: BaseUIElement;
+
                     if (isLocked.data) {
-                        return Svg.crosshair_locked_ui();
+                        icon = Svg.location_svg();
                     } else if (hasLocationData) {
-                        return Svg.crosshair_blue_ui();
+                        icon = Svg.location_empty_svg();
                     } else if (isActive.data) {
-                        return Svg.crosshair_blue_center_ui();
+                        icon = Svg.location_empty_svg();
                     } else {
-                        return Svg.crosshair_ui();
+                        icon = Svg.location_circle_svg();
                     }
+                    return icon
                 },
                 [isActive, isLocked]
             )
         );
+        this.SetClass("mapcontrol")
         this._isActive = isActive;
         this._isLocked = isLocked;
         this._permission = new UIEventSource<string>("");

Logic/Actors/PDFLayout.ts

@@ -23,4 +23,4 @@
          doc.addImage(image, 'PNG', 15, 30, 150*screenRatio, 150);
          return doc;
      }
- }
+ }

Logic/Actors/PendingChangesUploader.ts

@@ -9,7 +9,7 @@ export default class PendingChangesUploader {
     constructor(changes: Changes, selectedFeature: UIEventSource<any>) {
         const self = this;
         this.lastChange = new Date();
-        changes.pending.addCallback(() => {
+        changes.pendingChanges.addCallback(() => {
             self.lastChange = new Date();
 
             window.setTimeout(() => {
@@ -54,7 +54,7 @@ export default class PendingChangesUploader {
 
 
         function onunload(e) {
-            if (changes.pending.data.length == 0) {
+            if(changes.pendingChanges.data.length == 0){
                 return;
             }
             changes.flushChanges("onbeforeunload - probably closing or something similar");

Logic/Actors/SelectedFeatureHandler.ts

@@ -13,7 +13,7 @@ export default class SelectedFeatureHandler {
     private readonly _hash: UIEventSource<string>;
     private readonly _selectedFeature: UIEventSource<any>;
 
-    private static readonly _no_trigger_on = ["welcome","copyright","layers"]
+    private static readonly _no_trigger_on = ["welcome","copyright","layers","new"]
     private readonly _osmApiSource: OsmApiFeatureSource;
     
     constructor(hash: UIEventSource<string>, 
@@ -60,7 +60,9 @@ export default class SelectedFeatureHandler {
         if(hash === undefined || SelectedFeatureHandler._no_trigger_on.indexOf(hash) >= 0){
             return; // No valid feature selected
         }
-        // We should have a valid osm-ID and zoom to it
+        // We should have a valid osm-ID and zoom to it... But we wrap it in try-catch to be sure
+        try{
+            
         OsmObject.DownloadObject(hash).addCallbackAndRunD(element => {
             const centerpoint = element.centerpoint();
             console.log("Zooming to location for select point: ", centerpoint)
@@ -68,6 +70,9 @@ export default class SelectedFeatureHandler {
             location.data.lon = centerpoint[1]
             location.ping();
         })
+        }catch(e){
+            console.error("Could not download OSM-object with id", hash, " - probably a weird hash")
+        }
     }
     
     private downloadFeature(hash:  string){

Logic/ExtraFunction.ts

@@ -6,6 +6,8 @@ import {Utils} from "../Utils";
 import BaseUIElement from "../UI/BaseUIElement";
 import List from "../UI/Base/List";
 import Title from "../UI/Base/Title";
+import {UIEventSourceTools} from "./UIEventSource";
+import AspectedRouting from "./Osm/aspectedRouting";
 
 export class ExtraFunction {
 
@@ -38,12 +40,14 @@ export class ExtraFunction {
         ]),
         "Some advanced functions are available on **feat** as well:"
     ]).SetClass("flex-col").AsMarkdown();
-       
-    
+
+
     private static readonly OverlapFunc = new ExtraFunction(
-        "overlapWith",
-        "Gives a list of features from the specified layer which this feature (partly) overlaps with. If the current feature is a point, all features that embed the point are given. The returned value is `{ feat: GeoJSONFeature, overlap: number}[]` where `overlap` is the overlapping surface are (in m²) for areas, the overlapping length (in meter) if the current feature is a line or `undefined` if the current feature is a point",
-        ["...layerIds - one or more layer ids  of the layer from which every feature is checked for overlap)"],
+        {
+            name: "overlapWith",
+            doc: "Gives a list of features from the specified layer which this feature (partly) overlaps with. If the current feature is a point, all features that embed the point are given. The returned value is `{ feat: GeoJSONFeature, overlap: number}[]` where `overlap` is the overlapping surface are (in m²) for areas, the overlapping length (in meter) if the current feature is a line or `undefined` if the current feature is a point",
+            args: ["...layerIds - one or more layer ids  of the layer from which every feature is checked for overlap)"]
+        },
         (params, feat) => {
             return (...layerIds: string[]) => {
                 const result = []
@@ -62,9 +66,11 @@ export class ExtraFunction {
         }
     )
     private static readonly DistanceToFunc = new ExtraFunction(
-        "distanceTo",
-        "Calculates the distance between the feature and a specified point in kilometer. The input should either be a pair of coordinates, a geojson feature or the ID of an object",
-        ["longitude", "latitude"],
+        {
+            name: "distanceTo",
+            doc: "Calculates the distance between the feature and a specified point in kilometer. The input should either be a pair of coordinates, a geojson feature or the ID of an object",
+            args: ["longitude", "latitude"]
+        },
         (featuresPerLayer, feature) => {
             return (arg0, lat) => {
                 if (typeof arg0 === "number") {
@@ -88,9 +94,11 @@ export class ExtraFunction {
     )
 
     private static readonly ClosestObjectFunc = new ExtraFunction(
-        "closest",
-        "Given either a list of geojson features or a single layer name, gives the single object which is nearest to the feature. In the case of ways/polygons, only the centerpoint is considered.",
-        ["list of features"],
+        {
+            name: "closest",
+            doc: "Given either a list of geojson features or a single layer name, gives the single object which is nearest to the feature. In the case of ways/polygons, only the centerpoint is considered.",
+            args: ["list of features"]
+        },
         (params, feature) => {
             return (features) => {
                 if (typeof features === "string") {
@@ -139,28 +147,56 @@ export class ExtraFunction {
 
 
     private static readonly Memberships = new ExtraFunction(
-        "memberships",
-        "Gives a list of `{role: string, relation: Relation}`-objects, containing all the relations that this feature is part of. " +
-        "\n\n" +
-        "For example: `_part_of_walking_routes=feat.memberships().map(r => r.relation.tags.name).join(';')`",
-        [],
+        {
+            name: "memberships",
+            doc: "Gives a list of `{role: string, relation: Relation}`-objects, containing all the relations that this feature is part of. " +
+                "\n\n" +
+                "For example: `_part_of_walking_routes=feat.memberships().map(r => r.relation.tags.name).join(';')`",
+            args: []
+        },
         (params, _) => {
             return () => params.relations ?? [];
         }
     )
 
-    private static readonly allFuncs: ExtraFunction[] = [ExtraFunction.DistanceToFunc, ExtraFunction.OverlapFunc, ExtraFunction.ClosestObjectFunc, ExtraFunction.Memberships];
+    private static readonly AspectedRouting = new ExtraFunction(
+        {
+            name: "score",
+            doc: "Given the path of an aspected routing json file, will calculate the score. This score is wrapped in a UIEventSource, so for further calculations, use `.map(score => ...)`" +
+                "\n\n" +
+                "For example: `_comfort_score=feat.score('https://raw.githubusercontent.com/pietervdvn/AspectedRouting/master/Examples/bicycle/aspects/bicycle.comfort.json')`",
+            args: ["path"]
+        },
+        (_, feature) => {
+            return (path) => {
+                return UIEventSourceTools.downloadJsonCached(path).map(config => {
+                    if (config === undefined) {
+                        return
+                    }
+                    return new AspectedRouting(config).evaluate(feature.properties)
+                })
+            }
+        }
+    )
+
+    private static readonly allFuncs: ExtraFunction[] = [
+        ExtraFunction.DistanceToFunc,
+        ExtraFunction.OverlapFunc,
+        ExtraFunction.ClosestObjectFunc,
+        ExtraFunction.Memberships,
+        ExtraFunction.AspectedRouting
+    ];
     private readonly _name: string;
     private readonly _args: string[];
     private readonly _doc: string;
     private readonly _f: (params: { featuresPerLayer: Map<string, any[]>, relations: { role: string, relation: Relation }[] }, feat: any) => any;
 
-    constructor(name: string, doc: string, args: string[], f: ((params: { featuresPerLayer: Map<string, any[]>, relations: { role: string, relation: Relation }[] }, feat: any) => any)) {
-        this._name = name;
-        this._doc = doc;
-        this._args = args;
+    constructor(options: { name: string, doc: string, args: string[] },
+                f: ((params: { featuresPerLayer: Map<string, any[]>, relations: { role: string, relation: Relation }[] }, feat: any) => any)) {
+        this._name = options.name;
+        this._doc = options.doc;
+        this._args = options.args;
         this._f = f;
-
     }
 
     public static FullPatchFeature(featuresPerLayer: Map<string, any[]>, relations: { role: string, relation: Relation }[], feature) {
@@ -186,7 +222,6 @@ export class ExtraFunction {
     }
 
     public PatchFeature(featuresPerLayer: Map<string, any[]>, relations: { role: string, relation: Relation }[], feature: any) {
-
-        feature[this._name] = this._f({featuresPerLayer: featuresPerLayer, relations: relations}, feature);
+        feature[this._name] = this._f({featuresPerLayer: featuresPerLayer, relations: relations}, feature)
     }
 }

Logic/FeatureSource/ChangeApplicator.ts

@@ -0,0 +1,162 @@
+import FeatureSource from "./FeatureSource";
+import {UIEventSource} from "../UIEventSource";
+import {Changes} from "../Osm/Changes";
+import {ChangeDescription} from "../Osm/Actions/ChangeDescription";
+import {Utils} from "../../Utils";
+import {OsmNode, OsmRelation, OsmWay} from "../Osm/OsmObject";
+
+
+/**
+ * Applies changes from 'Changes' onto a featureSource
+ */
+export default class ChangeApplicator implements FeatureSource {
+    public readonly features: UIEventSource<{ feature: any; freshness: Date }[]>;
+    public readonly name: string;
+
+    constructor(source: FeatureSource, changes: Changes, mode?: {
+        generateNewGeometries: boolean
+    }) {
+
+        this.name = "ChangesApplied(" + source.name + ")"
+        this.features = source.features
+        const seenChanges = new Set<ChangeDescription>();
+        const self = this;
+        let runningUpdate = false;
+        source.features.addCallbackAndRunD(features => {
+            if (runningUpdate) {
+                return; // No need to ping again
+            }
+            ChangeApplicator.ApplyChanges(features, changes.pendingChanges.data, mode)
+            seenChanges.clear()
+        })
+
+        changes.pendingChanges.addCallbackAndRunD(changes => {
+            runningUpdate = true;
+            changes = changes.filter(ch => !seenChanges.has(ch))
+            changes.forEach(c => seenChanges.add(c))
+            ChangeApplicator.ApplyChanges(self.features.data, changes, mode)
+            source.features.ping()
+            runningUpdate = false;
+        })
+
+
+    }
+
+
+    /**
+     * Returns true if the geometry is changed and the source should be pinged
+     */
+    private static ApplyChanges(features: { feature: any; freshness: Date }[], cs: ChangeDescription[], mode: { generateNewGeometries: boolean }): boolean {
+        if (cs.length === 0 || features === undefined) {
+            return;
+        }
+
+        console.log("Applying changes ", this.name, cs)
+        let geometryChanged = false;
+        const changesPerId: Map<string, ChangeDescription[]> = new Map<string, ChangeDescription[]>()
+        for (const c of cs) {
+            const id = c.type + "/" + c.id
+            if (!changesPerId.has(id)) {
+                changesPerId.set(id, [])
+            }
+            changesPerId.get(id).push(c)
+        }
+
+
+        const now = new Date()
+
+        function add(feature) {
+            feature.id = feature.properties.id
+            features.push({
+                feature: feature,
+                freshness: now
+            })
+            console.log("Added a new feature: ", feature)
+            geometryChanged = true;
+        }
+
+        // First, create the new features - they have a negative ID
+        // We don't set the properties yet though
+        if (mode?.generateNewGeometries) {
+            changesPerId.forEach(cs => {
+                cs
+                    .forEach(change => {
+                        if (change.id >= 0) {
+                            return; // Nothing to do here, already created
+                        }
+
+                        if (change.changes === undefined) {
+                            // An update to the object - not the actual created
+                            return;
+                        }
+
+                        try {
+
+                            switch (change.type) {
+                                case "node":
+                                    const n = new OsmNode(change.id)
+                                    n.lat = change.changes["lat"]
+                                    n.lon = change.changes["lon"]
+                                    const geojson = n.asGeoJson()
+                                    add(geojson)
+                                    break;
+                                case "way":
+                                    const w = new OsmWay(change.id)
+                                    w.nodes = change.changes["nodes"]
+                                    add(w.asGeoJson())
+                                    break;
+                                case "relation":
+                                    const r = new OsmRelation(change.id)
+                                    r.members = change.changes["members"]
+                                    add(r.asGeoJson())
+                                    break;
+                            }
+
+                        } catch (e) {
+                            console.error(e)
+                        }
+                    })
+            })
+        }
+
+        for (const feature of features) {
+            const f = feature.feature;
+            const id = f.properties.id;
+            if (!changesPerId.has(id)) {
+                continue;
+            }
+
+
+            const changed = {}
+            // Copy all the properties
+            Utils.Merge(f, changed)
+            // play the changes onto the copied object
+
+            for (const change of changesPerId.get(id)) {
+                for (const kv of change.tags ?? []) {
+                    // Apply tag changes and ping the consumers
+                    f.properties[kv.k] = kv.v;
+                }
+
+                // Apply other changes to the object
+                if (change.changes !== undefined) {
+                    geometryChanged = true;
+                    switch (change.type) {
+                        case "node":
+                            // @ts-ignore
+                            const coor: { lat, lon } = change.changes;
+                            f.geometry.coordinates = [coor.lon, coor.lat]
+                            break;
+                        case "way":
+                            f.geometry.coordinates = change.changes["locations"]
+                            break;
+                        case "relation":
+                            console.error("Changes to relations are not yet supported")
+                            break;
+                    }
+                }
+            }
+        }
+        return geometryChanged
+    }
+}

Logic/FeatureSource/FeatureDuplicatorPerLayer.ts

@@ -1,6 +1,6 @@
 import FeatureSource from "./FeatureSource";
 import {UIEventSource} from "../UIEventSource";
-import LayerConfig from "../../Customizations/JSON/LayerConfig";
+import FilteredLayer from "../../Models/FilteredLayer";
 
 
 /**
@@ -13,7 +13,7 @@ export default class FeatureDuplicatorPerLayer implements FeatureSource {
 
     public readonly name;
 
-    constructor(layers: UIEventSource<{ layerDef: LayerConfig }[]>, upstream: FeatureSource) {
+    constructor(layers: UIEventSource<FilteredLayer[]>, upstream: FeatureSource) {
         this.name = "FeatureDuplicator of "+upstream.name;
         this.features = upstream.features.map(features => {
             const newFeatures: { feature: any, freshness: Date }[] = [];

Logic/FeatureSource/FeaturePipeline.ts

@@ -6,30 +6,32 @@ import FeatureDuplicatorPerLayer from "../FeatureSource/FeatureDuplicatorPerLaye
 import FeatureSource from "../FeatureSource/FeatureSource";
 import {UIEventSource} from "../UIEventSource";
 import LocalStorageSaver from "./LocalStorageSaver";
-import LayerConfig from "../../Customizations/JSON/LayerConfig";
 import LocalStorageSource from "./LocalStorageSource";
 import LayoutConfig from "../../Customizations/JSON/LayoutConfig";
 import Loc from "../../Models/Loc";
 import GeoJsonSource from "./GeoJsonSource";
 import MetaTaggingFeatureSource from "./MetaTaggingFeatureSource";
 import RegisteringFeatureSource from "./RegisteringFeatureSource";
+import FilteredLayer from "../../Models/FilteredLayer";
+import {Changes} from "../Osm/Changes";
+import ChangeApplicator from "./ChangeApplicator";
 
 export default class FeaturePipeline implements FeatureSource {
 
-    public features: UIEventSource<{ feature: any; freshness: Date }[]> ;
+    public features: UIEventSource<{ feature: any; freshness: Date }[]>;
 
     public readonly name = "FeaturePipeline"
 
-    constructor(flayers: UIEventSource<{ isDisplayed: UIEventSource<boolean>, layerDef: LayerConfig }[]>,
+    constructor(flayers: UIEventSource<FilteredLayer[]>,
+                changes: Changes,
                 updater: FeatureSource,
                 fromOsmApi: FeatureSource,
                 layout: UIEventSource<LayoutConfig>,
-                newPoints: FeatureSource,
                 locationControl: UIEventSource<Loc>,
                 selectedElement: UIEventSource<any>) {
 
         const allLoadedFeatures = new UIEventSource<{ feature: any; freshness: Date }[]>([])
-        
+
         // first we metatag, then we save to get the metatags into storage too
         // Note that we need to register before we do metatagging (as it expects the event sources)
 
@@ -40,39 +42,42 @@ export default class FeaturePipeline implements FeatureSource {
                     new MetaTaggingFeatureSource(allLoadedFeatures,
                         new FeatureDuplicatorPerLayer(flayers,
                             new RegisteringFeatureSource(
-                                updater)
+                                new ChangeApplicator(
+                                    updater, changes
+                                ))
                         )), layout));
 
         const geojsonSources: FeatureSource [] = GeoJsonSource
             .ConstructMultiSource(flayers.data, locationControl)
             .map(geojsonSource => {
-                let source = new RegisteringFeatureSource(new FeatureDuplicatorPerLayer(flayers, geojsonSource));
-                if(!geojsonSource.isOsmCache){
+                let source = new RegisteringFeatureSource(
+                    new FeatureDuplicatorPerLayer(flayers,
+                        new ChangeApplicator(geojsonSource, changes)));
+                if (!geojsonSource.isOsmCache) {
                     source = new MetaTaggingFeatureSource(allLoadedFeatures, source, updater.features);
                 }
                 return source
             });
 
         const amendedLocalStorageSource =
-            new RememberingSource(new RegisteringFeatureSource(new FeatureDuplicatorPerLayer(flayers, new LocalStorageSource(layout))
+            new RememberingSource(new RegisteringFeatureSource(new FeatureDuplicatorPerLayer(flayers, new ChangeApplicator(new LocalStorageSource(layout), changes))
             ));
 
-        newPoints = new MetaTaggingFeatureSource(allLoadedFeatures,
-            new FeatureDuplicatorPerLayer(flayers,
-                new RegisteringFeatureSource(newPoints)));
-
         const amendedOsmApiSource = new RememberingSource(
             new MetaTaggingFeatureSource(allLoadedFeatures,
                 new FeatureDuplicatorPerLayer(flayers,
-
-                    new RegisteringFeatureSource(fromOsmApi))));
+                    new RegisteringFeatureSource(new ChangeApplicator(fromOsmApi, changes,
+                        {
+                            // We lump in the new points here
+                            generateNewGeometries: true
+                        }
+                    )))));
 
         const merged =
             new FeatureSourceMerger([
                 amendedOverpassSource,
                 amendedOsmApiSource,
                 amendedLocalStorageSource,
-                newPoints,
                 ...geojsonSources
             ]);
 

Logic/FeatureSource/FeatureSourceMerger.ts

@@ -1,6 +1,10 @@
 import FeatureSource from "./FeatureSource";
 import {UIEventSource} from "../UIEventSource";
 
+/**
+ * Merges features from different featureSources
+ * Uses the freshest feature available in the case multiple sources offer data with the same identifier
+ */
 export default class FeatureSourceMerger implements FeatureSource {
 
     public features: UIEventSource<{ feature: any; freshness: Date }[]> = new UIEventSource<{ feature: any; freshness: Date }[]>([]);

Logic/FeatureSource/FilteringFeatureSource.ts

@@ -3,132 +3,160 @@ import {UIEventSource} from "../UIEventSource";
 import LayerConfig from "../../Customizations/JSON/LayerConfig";
 import Loc from "../../Models/Loc";
 import Hash from "../Web/Hash";
+import {TagsFilter} from "../Tags/TagsFilter";
 
 export default class FilteringFeatureSource implements FeatureSource {
-    public features: UIEventSource<{ feature: any; freshness: Date }[]> = new UIEventSource<{ feature: any; freshness: Date }[]>([]);
-    public readonly name = "FilteringFeatureSource"
-
-    constructor(layers: UIEventSource<{
-                    isDisplayed: UIEventSource<boolean>,
-                    layerDef: LayerConfig
-                }[]>,
-                location: UIEventSource<Loc>,
-                selectedElement: UIEventSource<any>,
-                upstream: FeatureSource) {
+    public features: UIEventSource<{ feature: any; freshness: Date }[]> =
+        new UIEventSource<{ feature: any; freshness: Date }[]>([]);
+    public readonly name = "FilteringFeatureSource";
 
+    constructor(
+        layers: UIEventSource<{
+            isDisplayed: UIEventSource<boolean>;
+            layerDef: LayerConfig;
+            appliedFilters: UIEventSource<TagsFilter>;
+        }[]>,
+        location: UIEventSource<Loc>,
+        selectedElement: UIEventSource<any>,
+        upstream: FeatureSource
+    ) {
         const self = this;
 
         function update() {
-
             const layerDict = {};
             if (layers.data.length == 0) {
-                console.warn("No layers defined!")
+                console.warn("No layers defined!");
                 return;
             }
             for (const layer of layers.data) {
+                const prev = layerDict[layer.layerDef.id]
+                if (prev !== undefined) {
+                    // We have seen this layer before!
+                    // We prefer the one which has a name
+                    if (layer.layerDef.name === undefined) {
+                        // This one is hidden, so we skip it
+                        console.log("Ignoring layer selection from ", layer)
+                        continue;
+                    }
+                }
                 layerDict[layer.layerDef.id] = layer;
             }
 
-            const features: { feature: any, freshness: Date }[] = upstream.features.data;
+            const features: { feature: any; freshness: Date }[] =
+                upstream.features.data;
 
             const missingLayers = new Set<string>();
 
-            const newFeatures = features.filter(f => {
+            const newFeatures = features.filter((f) => {
                 const layerId = f.feature._matching_layer_id;
-                
-                if(selectedElement.data?.id === f.feature.id || f.feature.id === Hash.hash.data){
-                    // This is the selected object - it gets a free pass even if zoom is not sufficient
+
+                if (
+                    selectedElement.data?.id === f.feature.id ||
+                    f.feature.id === Hash.hash.data) {
+                    // This is the selected object - it gets a free pass even if zoom is not sufficient or it is filtered away
                     return true;
                 }
+
+                if (layerId === undefined) {
+                    return false;
+                }
+                const layer: {
+                    isDisplayed: UIEventSource<boolean>;
+                    layerDef: LayerConfig;
+                    appliedFilters: UIEventSource<TagsFilter>;
+                } = layerDict[layerId];
+                if (layer === undefined) {
+                    missingLayers.add(layerId);
+                    return false;
+                }
+
+                const isShown = layer.layerDef.isShown;
+                const tags = f.feature.properties;
+                if (isShown.IsKnown(tags)) {
+                    const result = layer.layerDef.isShown.GetRenderValue(
+                        f.feature.properties
+                    ).txt;
+                    if (result !== "yes") {
+                        return false;
+                    }
+                } 
                 
-                if (layerId !== undefined) {
-                    const layer: {
-                        isDisplayed: UIEventSource<boolean>,
-                        layerDef: LayerConfig
-                    } = layerDict[layerId];
-                    if (layer === undefined) {
-                        missingLayers.add(layerId)
-                        return true;
-                    }
-
-                    const isShown = layer.layerDef.isShown
-                    const tags = f.feature.properties;
-                    if (isShown.IsKnown(tags)) {
-                        const result = layer.layerDef.isShown.GetRenderValue(f.feature.properties).txt;
-                        if (result !== "yes") {
-                            return false;
-                        }
-                    }
-
-                    if (FilteringFeatureSource.showLayer(layer, location)) {
-                        return true;
+                const tagsFilter = layer.appliedFilters.data;
+                if (tagsFilter) {
+                    if (!tagsFilter.matchesProperties(f.feature.properties)) {
+                        // Hidden by the filter on the layer itself - we want to hide it no matter wat
+                        return false;
                     }
                 }
-                // Does it match any other layer - e.g. because of a switch?
-                for (const toCheck of layers.data) {
-                    if (!FilteringFeatureSource.showLayer(toCheck, location)) {
-                        continue;
-                    }
-                    if (toCheck.layerDef.source.osmTags.matchesProperties(f.feature.properties)) {
-                        return true;
-                    }
+                if (!FilteringFeatureSource.showLayer(layer, location)) {
+                    // The layer itself is either disabled or hidden due to zoom constraints
+                    // We should return true, but it might still match some other layer
+                    return false;
                 }
-                return false;
 
+                return true;
             });
-            console.log("Filtering layer source: input: ", upstream.features.data?.length, "output:", newFeatures.length)
+
             self.features.setData(newFeatures);
             if (missingLayers.size > 0) {
-                console.error("Some layers were not found: ", Array.from(missingLayers))
+                console.error(
+                    "Some layers were not found: ",
+                    Array.from(missingLayers)
+                );
             }
         }
 
-
         upstream.features.addCallback(() => {
-            update()
-        });
-        location.map(l => {
-            // We want something that is stable for the shown layers
-            const displayedLayerIndexes = [];
-            for (let i = 0; i < layers.data.length; i++) {
-                const layer = layers.data[i];
-                if (l.zoom < layer.layerDef.minzoom) {
-                    continue;
-                }
-                if (l.zoom > layer.layerDef.maxzoom) {
-                    continue;
-                }
-                if (!layer.isDisplayed.data) {
-                    continue;
-                }
-                displayedLayerIndexes.push(i);
-            }
-            return displayedLayerIndexes.join(",")
-        }).addCallback(() => {
             update();
         });
+        location
+            .map((l) => {
+                // We want something that is stable for the shown layers
+                const displayedLayerIndexes = [];
+                for (let i = 0; i < layers.data.length; i++) {
+                    const layer = layers.data[i];
+                    if (l.zoom < layer.layerDef.minzoom) {
+                        continue;
+                    }
+                 
+                    if (!layer.isDisplayed.data) {
+                        continue;
+                    }
+                    displayedLayerIndexes.push(i);
+                }
+                return displayedLayerIndexes.join(",");
+            })
+            .addCallback(() => {
+                update();
+            });
 
         layers.addCallback(update);
 
         const registered = new Set<UIEventSource<boolean>>();
-        layers.addCallbackAndRun(layers => {
+        layers.addCallbackAndRun((layers) => {
             for (const layer of layers) {
                 if (registered.has(layer.isDisplayed)) {
                     continue;
                 }
                 registered.add(layer.isDisplayed);
                 layer.isDisplayed.addCallback(() => update());
+                layer.appliedFilters.addCallback(() => update());
             }
-        })
+        });
 
         update();
-
     }
 
-    private static showLayer(layer: {
-        isDisplayed: UIEventSource<boolean>,
-        layerDef: LayerConfig
-    }, location: UIEventSource<Loc>) {
-        return layer.isDisplayed.data && (layer.layerDef.minzoom <= location.data.zoom) && (layer.layerDef.maxzoom >= location.data.zoom)
+    private static showLayer(
+        layer: {
+            isDisplayed: UIEventSource<boolean>;
+            layerDef: LayerConfig;
+        },
+        location: UIEventSource<Loc>
+    ) {
+        return (
+            layer.isDisplayed.data &&
+            layer.layerDef.minzoomVisible <= location.data.zoom
+        );
     }
-}
+}

Logic/FeatureSource/GeoJsonSource.ts

@@ -25,7 +25,7 @@ export default class GeoJsonSource implements FeatureSource {
         let url = flayer.layerDef.source.geojsonSource.replace("{layer}", flayer.layerDef.id);
         this.name = "GeoJsonSource of " + url;
         const zoomLevel = flayer.layerDef.source.geojsonZoomLevel;
-        
+
         this.isOsmCache = flayer.layerDef.source.isOsmCacheLayer;
 
         this.features = new UIEventSource<{ feature: any; freshness: Date }[]>([])
@@ -112,7 +112,17 @@ export default class GeoJsonSource implements FeatureSource {
         }
 
         const neededTiles = locationControl.map(
-            _ => {
+            location => {
+                if (!flayer.isDisplayed.data) {
+                    // No need to download! - the layer is disabled
+                    return undefined;
+                }
+
+                if (location.zoom < flayer.layerDef.minzoom) {
+                    // No need to download! - the layer is disabled
+                    return undefined;
+                }
+
                 // Yup, this is cheating to just get the bounds here
                 const bounds = State.state.leafletMap.data.getBounds()
                 const tileRange = Utils.TileRangeBetween(zoomLevel, bounds.getNorth(), bounds.getEast(), bounds.getSouth(), bounds.getWest())
@@ -126,14 +136,6 @@ export default class GeoJsonSource implements FeatureSource {
             if (needed === undefined) {
                 return;
             }
-            if (!flayer.isDisplayed.data) {
-                // No need to download! - the layer is disabled
-                return;
-            }
-
-            if (locationControl.data.zoom < flayer.layerDef.minzoom) {
-                return;
-            }
 
             needed.forEach(neededTile => {
                 if (loadedTiles.has(neededTile)) {
@@ -153,42 +155,42 @@ export default class GeoJsonSource implements FeatureSource {
         const self = this;
         Utils.downloadJson(url)
             .then(json => {
-            if (json.elements === [] && json.remarks.indexOf("runtime error") > 0) {
-                self.onFail("Runtime error (timeout)", url)
-                return;
-            }
-            const time = new Date();
-            const newFeatures: { feature: any, freshness: Date } [] = []
-            let i = 0;
-            let skipped = 0;
-            for (const feature of json.features) {
-                if (feature.properties.id === undefined) {
-                    feature.properties.id = url + "/" + i;
-                    feature.id = url + "/" + i;
-                    i++;
+                if (json.elements === [] && json.remarks.indexOf("runtime error") > 0) {
+                    self.onFail("Runtime error (timeout)", url)
+                    return;
                 }
-                if (self.seenids.has(feature.properties.id)) {
-                    skipped++;
-                    continue;
-                }
-                self.seenids.add(feature.properties.id)
+                const time = new Date();
+                const newFeatures: { feature: any, freshness: Date } [] = []
+                let i = 0;
+                let skipped = 0;
+                for (const feature of json.features) {
+                    if (feature.properties.id === undefined) {
+                        feature.properties.id = url + "/" + i;
+                        feature.id = url + "/" + i;
+                        i++;
+                    }
+                    if (self.seenids.has(feature.properties.id)) {
+                        skipped++;
+                        continue;
+                    }
+                    self.seenids.add(feature.properties.id)
 
-                let freshness: Date = time;
-                if (feature.properties["_last_edit:timestamp"] !== undefined) {
-                    freshness = new Date(feature["_last_edit:timestamp"])
+                    let freshness: Date = time;
+                    if (feature.properties["_last_edit:timestamp"] !== undefined) {
+                        freshness = new Date(feature.properties["_last_edit:timestamp"])
+                    }
+
+                    newFeatures.push({feature: feature, freshness: freshness})
+                }
+                console.debug("Downloaded " + newFeatures.length + " new features and " + skipped + " already seen features from " + url);
+
+                if (newFeatures.length == 0) {
+                    return;
                 }
 
-                newFeatures.push({feature: feature, freshness: freshness})
-            }
-            console.debug("Downloaded " + newFeatures.length + " new features and " + skipped + " already seen features from " + url);
+                eventSource.setData(eventSource.data.concat(newFeatures))
 
-            if (newFeatures.length == 0) {
-                return;
-            }
-
-            eventSource.setData(eventSource.data.concat(newFeatures))
-
-        }).catch(msg => self.onFail(msg, url))
+            }).catch(msg => self.onFail(msg, url))
     }
 
 }

Logic/FeatureSource/OsmApiFeatureSource.ts

@@ -15,15 +15,19 @@ export default class OsmApiFeatureSource implements FeatureSource {
 
 
     public load(id: string) {
-        if(id.indexOf("-") >= 0){
+        if (id.indexOf("-") >= 0) {
             // Newly added point - not yet in OSM
             return;
         }
         console.debug("Downloading", id, "from the OSM-API")
         OsmObject.DownloadObject(id).addCallbackAndRunD(element => {
-            const geojson = element.asGeoJson();
-            geojson.id = geojson.properties.id;
-            this.features.setData([{feature: geojson, freshness: element.timestamp}])
+            try {
+                const geojson = element.asGeoJson();
+                geojson.id = geojson.properties.id;
+                this.features.setData([{feature: geojson, freshness: element.timestamp}])
+            } catch (e) {
+                console.error(e)
+            }
         })
     }
 
@@ -58,7 +62,7 @@ export default class OsmApiFeatureSource implements FeatureSource {
             const bounds = Utils.tile_bounds(z, x, y);
             console.log("Loading OSM data tile", z, x, y, " with bounds", bounds)
             OsmObject.LoadArea(bounds, objects => {
-                const keptGeoJson: {feature:any, freshness: Date}[] = []
+                const keptGeoJson: { feature: any, freshness: Date }[] = []
                 // Which layer does the object match?
                 for (const object of objects) {
 
@@ -69,7 +73,7 @@ export default class OsmApiFeatureSource implements FeatureSource {
                         if (doesMatch) {
                             const geoJson = object.asGeoJson();
                             geoJson._matching_layer_id = layer.id
-                            keptGeoJson.push({feature: geoJson, freshness:  object.timestamp})
+                            keptGeoJson.push({feature: geoJson, freshness: object.timestamp})
                             break;
                         }
 

Logic/GeoOperations.ts

@@ -6,11 +6,14 @@ export class GeoOperations {
         return turf.area(feature);
     }
 
+    /**
+     * Converts a GeoJSon feature to a point feature
+     * @param feature
+     */
     static centerpoint(feature: any) {
         const newFeature = turf.center(feature);
         newFeature.properties = feature.properties;
         newFeature.id = feature.id;
-
         return newFeature;
     }
 
@@ -273,14 +276,61 @@ export class GeoOperations {
         }
         return undefined;
     }
+
     /**
      * Generates the closest point on a way from a given point
      * @param way The road on which you want to find a point
      * @param point Point defined as [lon, lat]
      */
-    public static nearestPoint(way, point: [number, number]){
+    public static nearestPoint(way, point: [number, number]) {
         return turf.nearestPointOnLine(way, point, {units: "kilometers"});
     }
+
+    public static toCSV(features: any[]): string {
+
+        const headerValuesSeen = new Set<string>();
+        const headerValuesOrdered: string[] = []
+
+        function addH(key) {
+            if (!headerValuesSeen.has(key)) {
+                headerValuesSeen.add(key)
+                headerValuesOrdered.push(key)
+            }
+        }
+
+        addH("_lat")
+        addH("_lon")
+
+        const lines: string[] = []
+
+        for (const feature of features) {
+            const properties = feature.properties;
+            for (const key in properties) {
+                if (!properties.hasOwnProperty(key)) {
+                    continue;
+                }
+                addH(key)
+
+            }
+        }
+        headerValuesOrdered.sort()
+        for (const feature of features) {
+            const properties = feature.properties;
+            let line = ""
+            for (const key of headerValuesOrdered) {
+                const value = properties[key]
+                if (value === undefined) {
+                    line += ","
+                } else {
+                    line += JSON.stringify(value)+","
+                }
+            }
+            lines.push(line)
+        }
+
+        return headerValuesOrdered.map(v => JSON.stringify(v)).join(",") + "\n" + lines.join("\n")
+    }
+
 }
 
 

Logic/MetaTagging.ts

@@ -27,8 +27,8 @@ export default class MetaTagging {
                        relations: Map<string, { role: string, relation: Relation }[]>,
                        layers: LayerConfig[],
                        includeDates = true) {
-        
-        if(features === undefined || features.length === 0){
+
+        if (features === undefined || features.length === 0) {
             return;
         }
 
@@ -79,14 +79,10 @@ export default class MetaTagging {
                 }
 
             }
-            
-            
-            
-            
-            
-            
+
+
         })
-        
+
 
     }
 
@@ -115,6 +111,17 @@ export default class MetaTagging {
                 const f = (featuresPerLayer, feature: any) => {
                     try {
                         let result = func(feature);
+                        if(result instanceof UIEventSource){
+                            result.addCallbackAndRunD(d => {
+                                if (typeof d !== "string") {
+                                    // Make sure it is a string!
+                                    d = JSON.stringify(d);
+                                }
+                                feature.properties[key] = d;
+                            })
+                            result = result.data
+                        }
+                        
                         if (result === undefined || result === "") {
                             return;
                         }
@@ -124,11 +131,11 @@ export default class MetaTagging {
                         }
                         feature.properties[key] = result;
                     } catch (e) {
-                        if(MetaTagging. errorPrintCount < MetaTagging.stopErrorOutputAt){
+                        if (MetaTagging.errorPrintCount < MetaTagging.stopErrorOutputAt) {
                             console.warn("Could not calculate a calculated tag defined by " + code + " due to " + e + ". This is code defined in the theme. Are you the theme creator? Doublecheck your code. Note that the metatags might not be stable on new features", e)
-                            MetaTagging.   errorPrintCount ++;
-                            if(MetaTagging. errorPrintCount == MetaTagging.stopErrorOutputAt){
-                                console.error("Got ",MetaTagging.stopErrorOutputAt," errors calculating this metatagging - stopping output now")
+                            MetaTagging.errorPrintCount++;
+                            if (MetaTagging.errorPrintCount == MetaTagging.stopErrorOutputAt) {
+                                console.error("Got ", MetaTagging.stopErrorOutputAt, " errors calculating this metatagging - stopping output now")
                             }
                         }
                     }

Logic/Osm/Actions/ChangeDescription.ts

@@ -0,0 +1,30 @@
+export interface ChangeDescription {
+
+    type: "node" | "way" | "relation",
+    /**
+     * Negative for a new objects
+     */
+    id: number,
+    /*
+ v = "" or v = undefined to erase this tag
+ */
+    tags?: { k: string, v: string }[],
+
+    changes?: {
+        lat: number,
+        lon: number
+    } | {
+        // Coordinates are only used for rendering
+        locations: [number, number][]
+        nodes: number[],
+    } | {
+        members: { type: "node" | "way" | "relation", ref: number, role: string }[]
+    }
+
+    /*
+    Set to delete the object
+     */
+    doDelete?: boolean
+
+
+}

Logic/Osm/Actions/ChangeTagAction.ts

@@ -0,0 +1,52 @@
+import OsmChangeAction from "./OsmChangeAction";
+import {Changes} from "../Changes";
+import {ChangeDescription} from "./ChangeDescription";
+import {TagsFilter} from "../../Tags/TagsFilter";
+
+export default class ChangeTagAction extends OsmChangeAction {
+    private readonly _elementId: string;
+    private readonly _tagsFilter: TagsFilter;
+    private readonly _currentTags: any;
+
+    constructor(elementId: string, tagsFilter: TagsFilter, currentTags: any) {
+        super();
+        this._elementId = elementId;
+        this._tagsFilter = tagsFilter;
+        this._currentTags = currentTags;
+    }
+
+    /**
+     * Doublechecks that no stupid values are added
+     */
+    private static checkChange(kv: { k: string, v: string }): { k: string, v: string } {
+        const key = kv.k;
+        const value = kv.v;
+        if (key === undefined || key === null) {
+            console.log("Invalid key");
+            return undefined;
+        }
+        if (value === undefined || value === null) {
+            console.log("Invalid value for ", key);
+            return undefined;
+        }
+
+        if (key.startsWith(" ") || value.startsWith(" ") || value.endsWith(" ") || key.endsWith(" ")) {
+            console.warn("Tag starts with or ends with a space - trimming anyway")
+        }
+
+        return {k: key.trim(), v: value.trim()};
+    }
+
+    CreateChangeDescriptions(changes: Changes): ChangeDescription [] {
+        const changedTags: { k: string, v: string }[] = this._tagsFilter.asChange(this._currentTags).map(ChangeTagAction.checkChange)
+        const typeId = this._elementId.split("/")
+        const type = typeId[0]
+        const id = Number(typeId  [1])
+        return [{
+            // @ts-ignore
+            type: type,
+            id: id,
+            tags: changedTags
+        }]
+    }
+}

Logic/Osm/Actions/CreateNewNodeAction.ts

@@ -0,0 +1,48 @@
+import {Tag} from "../../Tags/Tag";
+import OsmChangeAction from "./OsmChangeAction";
+import {Changes} from "../Changes";
+import {ChangeDescription} from "./ChangeDescription";
+import {And} from "../../Tags/And";
+
+export default class CreateNewNodeAction extends OsmChangeAction {
+
+    private readonly _basicTags: Tag[];
+    private readonly _lat: number;
+    private readonly _lon: number;
+
+    public newElementId : string = undefined
+    
+    constructor(basicTags: Tag[], lat: number, lon: number) {
+        super()
+        this._basicTags = basicTags;
+        this._lat = lat;
+        this._lon = lon;
+    }
+
+    CreateChangeDescriptions(changes: Changes): ChangeDescription[] {
+        const id = changes.getNewID()
+        const properties = {
+            id: "node/" + id
+        }
+        this.newElementId = "node/"+id
+        for (const kv of this._basicTags) {
+            if (typeof kv.value !== "string") {
+                throw "Invalid value: don't use a regex in a preset"
+            }
+            properties[kv.key] = kv.value;
+        }
+
+        return [{
+            tags: new And(this._basicTags).asChange(properties),
+            type: "node",
+            id: id,
+            changes:{
+                lat: this._lat,
+                lon: this._lon
+            }
+        }]
+
+    }
+
+
+}

Logic/Osm/Actions/DeleteAction.ts

@@ -1,9 +1,9 @@
-import {UIEventSource} from "../UIEventSource";
-import {Translation} from "../../UI/i18n/Translation";
-import Translations from "../../UI/i18n/Translations";
-import {OsmObject} from "./OsmObject";
-import State from "../../State";
-import Constants from "../../Models/Constants";
+import {UIEventSource} from "../../UIEventSource";
+import {Translation} from "../../../UI/i18n/Translation";
+import State from "../../../State";
+import {OsmObject} from "../OsmObject";
+import Translations from "../../../UI/i18n/Translations";
+import Constants from "../../../Models/Constants";
 
 export default class DeleteAction {
 
@@ -30,7 +30,7 @@ export default class DeleteAction {
      * Does actually delete the feature; returns the event source 'this.isDeleted'
      * If deletion is not allowed, triggers the callback instead
      */
-    public DoDelete(reason: string, onNotAllowed : () => void): UIEventSource<boolean> {
+    public DoDelete(reason: string, onNotAllowed : () => void): void {
         const isDeleted = this.isDeleted
         const self = this;
         let deletionStarted = false;
@@ -75,8 +75,6 @@ export default class DeleteAction {
 
             }
         )
-
-        return isDeleted;
     }
 
     /**

Logic/Osm/Actions/OsmChangeAction.ts

@@ -0,0 +1,23 @@
+/**
+ * An action is a change to the OSM-database
+ * It will generate some new/modified/deleted objects, which are all bundled by the 'changes'-object
+ */
+import {Changes} from "../Changes";
+import {ChangeDescription} from "./ChangeDescription";
+
+export default abstract class OsmChangeAction {
+
+    private isUsed = false
+
+    public Perform(changes: Changes) {
+        if (this.isUsed) {
+            throw "This ChangeAction is already used: " + this.constructor.name
+        }
+        this.isUsed = true;
+        return this.CreateChangeDescriptions(changes)
+    }
+
+    protected abstract CreateChangeDescriptions(changes: Changes): ChangeDescription[]
+
+
+}

Logic/Osm/Actions/RelationSplitlHandler.ts

@@ -0,0 +1,20 @@
+/**
+ * The logic to handle relations after a way within 
+ */
+import OsmChangeAction from "./OsmChangeAction";
+import {Changes} from "../Changes";
+import {ChangeDescription} from "./ChangeDescription";
+import {OsmRelation, OsmWay} from "../OsmObject";
+
+export default class RelationSplitlHandler extends OsmChangeAction{
+
+    constructor(partOf: OsmRelation[], newWayIds: number[], originalNodes: number[]) {
+        super()
+    }
+
+    CreateChangeDescriptions(changes: Changes): ChangeDescription[] {
+        return [];
+    }
+
+
+}

Logic/Osm/Actions/SplitAction.ts

@@ -0,0 +1,238 @@
+import {OsmRelation, OsmWay} from "../OsmObject";
+import {Changes} from "../Changes";
+import {GeoOperations} from "../../GeoOperations";
+import OsmChangeAction from "./OsmChangeAction";
+import {ChangeDescription} from "./ChangeDescription";
+import RelationSplitlHandler from "./RelationSplitlHandler";
+
+interface SplitInfo {
+    originalIndex?: number, // or negative for new elements
+    lngLat: [number, number],
+    doSplit: boolean
+}
+
+export default class SplitAction extends OsmChangeAction {
+    private readonly roadObject: any;
+    private readonly osmWay: OsmWay;
+    private _partOf: OsmRelation[];
+    private readonly _splitPoints: any[];
+
+    constructor(osmWay: OsmWay, wayGeoJson: any, partOf: OsmRelation[], splitPoints: any[]) {
+        super()
+        this.osmWay = osmWay;
+        this.roadObject = wayGeoJson;
+        this._partOf = partOf;
+        this._splitPoints = splitPoints;
+    }
+
+    private static SegmentSplitInfo(splitInfo: SplitInfo[]): SplitInfo[][] {
+        const wayParts = []
+        let currentPart = []
+        for (const splitInfoElement of splitInfo) {
+            currentPart.push(splitInfoElement)
+
+            if (splitInfoElement.doSplit) {
+                // We have to do a split!
+                // We add the current index to the currentParts, flush it and add it again
+                wayParts.push(currentPart)
+                currentPart = [splitInfoElement]
+            }
+        }
+        wayParts.push(currentPart)
+        return wayParts.filter(wp => wp.length > 0)
+    }
+
+    CreateChangeDescriptions(changes: Changes): ChangeDescription[] {
+        const splitPoints = this._splitPoints
+        // We mark the new split points with a new id
+        console.log(splitPoints)
+        for (const splitPoint of splitPoints) {
+            splitPoint.properties["_is_split_point"] = true
+        }
+
+
+        const self = this;
+        const partOf = this._partOf
+        const originalElement = this.osmWay
+        const originalNodes = this.osmWay.nodes;
+
+        // First, calculate splitpoints and remove points close to one another
+        const splitInfo = self.CalculateSplitCoordinates(splitPoints)
+        // Now we have a list with e.g. 
+        // [ { originalIndex: 0}, {originalIndex: 1, doSplit: true}, {originalIndex: 2}, {originalIndex: undefined, doSplit: true}, {originalIndex: 3}]
+
+        // Lets change 'originalIndex' to the actual node id first:
+        for (const element of splitInfo) {
+            if (element.originalIndex >= 0) {
+                element.originalIndex = originalElement.nodes[element.originalIndex]
+            } else {
+                element.originalIndex = changes.getNewID();
+            }
+        }
+
+        // Next up is creating actual parts from this
+        const wayParts: SplitInfo[][] = SplitAction.SegmentSplitInfo(splitInfo);
+        // Allright! At this point, we have our new ways!
+        // Which one is the longest of them (and can keep the id)?
+
+        let longest = undefined;
+        for (const wayPart of wayParts) {
+            if (longest === undefined) {
+                longest = wayPart;
+                continue
+            }
+            if (wayPart.length > longest.length) {
+                longest = wayPart
+            }
+        }
+
+        const changeDescription: ChangeDescription[] = []
+        // Let's create the new points as needed
+        for (const element of splitInfo) {
+            if (element.originalIndex >= 0) {
+                continue;
+            }
+            changeDescription.push({
+                type: "node",
+                id: element.originalIndex,
+                changes: {
+                    lon: element.lngLat[0],
+                    lat: element.lngLat[1]
+                }
+            })
+        }
+
+        const newWayIds: number[] = []
+        // Lets create OsmWays based on them
+        for (const wayPart of wayParts) {
+
+            let isOriginal = wayPart === longest
+            if (isOriginal) {
+                // We change the actual element!
+                changeDescription.push({
+                    type: "way",
+                    id: originalElement.id,
+                    changes: {
+                        locations: wayPart.map(p => p.lngLat),
+                        nodes: wayPart.map(p => p.originalIndex)
+                    }
+                })
+            } else {
+                let id = changes.getNewID();
+                newWayIds.push(id)
+
+                const kv = []
+                for (const k in originalElement.tags) {
+                    if (!originalElement.tags.hasOwnProperty(k)) {
+                        continue
+                    }
+                    if (k.startsWith("_") || k === "id") {
+                        continue;
+                    }
+                    kv.push({k: k, v: originalElement.tags[k]})
+                }
+                changeDescription.push({
+                    type: "way",
+                    id: id,
+                    tags: kv,
+                    changes: {
+                        locations: wayPart.map(p => p.lngLat),
+                        nodes: wayPart.map(p => p.originalIndex)
+                    }
+                })
+            }
+
+        }
+
+        // At last, we still have to check that we aren't part of a relation...
+        // At least, the order of the ways is identical, so we can keep the same roles
+        changeDescription.push(...new RelationSplitlHandler(partOf, newWayIds, originalNodes).CreateChangeDescriptions(changes))
+
+        // And we have our objects!
+        // Time to upload
+
+        return changeDescription
+    }
+
+    /**
+     * Calculates the actual points to split
+     * If another point is closer then ~5m, we reuse that point
+     */
+    private CalculateSplitCoordinates(
+        splitPoints: any[],
+        toleranceInM = 5): SplitInfo[] {
+
+        const allPoints = [...splitPoints];
+        // We have a bunch of coordinates here: [ [lat, lon], [lat, lon], ...] ...
+        const originalPoints: [number, number][] = this.roadObject.geometry.coordinates
+        // We project them onto the line (which should yield pretty much the same point
+        for (let i = 0; i < originalPoints.length; i++) {
+            let originalPoint = originalPoints[i];
+            let projected = GeoOperations.nearestPoint(this.roadObject, originalPoint)
+            projected.properties["_is_split_point"] = false
+            projected.properties["_original_index"] = i
+            allPoints.push(projected)
+        }
+        // At this point, we have a list of both the split point and the old points, with some properties to discriminate between them
+        // We sort this list so that the new points are at the same location
+        allPoints.sort((a, b) => a.properties.location - b.properties.location)
+
+        // When this is done, we check that no now point is too close to an already existing point and no very small segments get created
+
+        /*   for (let i = allPoints.length - 1; i > 0; i--) {
+   
+               const point = allPoints[i];
+               if (point.properties._original_index !== undefined) {
+                   // This point is already in OSM - we have to keep it!
+                   continue;
+               }
+   
+               if (i != allPoints.length - 1) {
+                   const prevPoint = allPoints[i + 1]
+                   const diff = Math.abs(point.properties.location - prevPoint.properties.location) * 1000
+                   if (diff <= toleranceInM) {
+                       // To close to the previous point! We delete this point...
+                       allPoints.splice(i, 1)
+                       // ... and mark the previous point as a split point
+                       prevPoint.properties._is_split_point = true
+                       continue;
+                   }
+               }
+   
+               if (i > 0) {
+                   const nextPoint = allPoints[i - 1]
+                   const diff = Math.abs(point.properties.location - nextPoint.properties.location) * 1000
+                   if (diff <= toleranceInM) {
+                       // To close to the next point! We delete this point...
+                       allPoints.splice(i, 1)
+                       // ... and mark the next point as a split point
+                       nextPoint.properties._is_split_point = true
+                       // noinspection UnnecessaryContinueJS
+                       continue;
+                   }
+               }
+               // We don't have to remove this point...
+           }*/
+
+        const splitInfo: SplitInfo[] = []
+        let nextId = -1
+
+        for (const p of allPoints) {
+            let index = p.properties._original_index
+            if (index === undefined) {
+                index = nextId;
+                nextId--;
+            }
+            const splitInfoElement = {
+                originalIndex: index,
+                lngLat: p.geometry.coordinates,
+                doSplit: p.properties._is_split_point
+            }
+            splitInfo.push(splitInfoElement)
+        }
+
+        return splitInfo
+    }
+
+
+}

Logic/Osm/Changes.ts

@@ -1,81 +1,233 @@
-import {OsmNode, OsmObject} from "./OsmObject";
+import {OsmNode, OsmObject, OsmRelation, OsmWay} from "./OsmObject";
 import State from "../../State";
-import {Utils} from "../../Utils";
 import {UIEventSource} from "../UIEventSource";
 import Constants from "../../Models/Constants";
-import FeatureSource from "../FeatureSource/FeatureSource";
-import {TagsFilter} from "../Tags/TagsFilter";
-import {Tag} from "../Tags/Tag";
-import {OsmConnection} from "./OsmConnection";
+import OsmChangeAction from "./Actions/OsmChangeAction";
+import {ChangeDescription} from "./Actions/ChangeDescription";
+import {Utils} from "../../Utils";
 import {LocalStorageSource} from "../Web/LocalStorageSource";
 
 /**
  * Handles all changes made to OSM.
  * Needs an authenticator via OsmConnection
  */
-export class Changes implements FeatureSource {
+export class Changes {
 
 
     private static _nextId = -1; // Newly assigned ID's are negative
     public readonly name = "Newly added features"
     /**
-     * The newly created points, as a FeatureSource
+     * All the newly created features as featureSource + all the modified features
      */
     public features = new UIEventSource<{ feature: any, freshness: Date }[]>([]);
-    /**
-     * All the pending changes
-     */
-    public readonly pending = LocalStorageSource.GetParsed<{ elementId: string, key: string, value: string }[]>("pending-changes", [])
-
-    /**
-     * All the pending new objects to upload
-     */
-    private readonly newObjects = LocalStorageSource.GetParsed<{ id: number, lat: number, lon: number }[]>("newObjects", [])
 
+    public readonly pendingChanges = LocalStorageSource.GetParsed<ChangeDescription[]>("pending-changes", [])
     private readonly isUploading = new UIEventSource(false);
+    
+    private readonly previouslyCreated : OsmObject[] = []
 
-    /**
-     * Adds a change to the pending changes
-     */
-    private static checkChange(kv: { k: string, v: string }): { k: string, v: string } {
-        const key = kv.k;
-        const value = kv.v;
-        if (key === undefined || key === null) {
-            console.log("Invalid key");
-            return undefined;
-        }
-        if (value === undefined || value === null) {
-            console.log("Invalid value for ", key);
-            return undefined;
-        }
-
-        if (key.startsWith(" ") || value.startsWith(" ") || value.endsWith(" ") || key.endsWith(" ")) {
-            console.warn("Tag starts with or ends with a space - trimming anyway")
-        }
-
-        return {k: key.trim(), v: value.trim()};
+    constructor() {
+       
     }
 
+    private static createChangesetFor(csId: string,
+                                     allChanges: {
+                                         modifiedObjects: OsmObject[],
+                                         newObjects: OsmObject[],
+                                         deletedObjects: OsmObject[]
+                                     }): string {
 
-    addTag(elementId: string, tagsFilter: TagsFilter,
-           tags?: UIEventSource<any>) {
-        const eventSource = tags ?? State.state?.allElements.getEventSourceById(elementId);
-        const elementTags = eventSource.data;
-        const changes = tagsFilter.asChange(elementTags).map(Changes.checkChange)
-        if (changes.length == 0) {
-            return;
+        const changedElements = allChanges.modifiedObjects ?? []
+        const newElements = allChanges.newObjects ?? []
+        const deletedElements = allChanges.deletedObjects ?? []
+
+        let changes = `<osmChange version='0.6' generator='Mapcomplete ${Constants.vNumber}'>`;
+        if (newElements.length > 0) {
+            changes +=
+                "\n<create>\n" +
+                newElements.map(e => e.ChangesetXML(csId)).join("\n") +
+                "</create>";
+        }
+        if (changedElements.length > 0) {
+            changes +=
+                "\n<modify>\n" +
+                changedElements.map(e => e.ChangesetXML(csId)).join("\n") +
+                "\n</modify>";
         }
 
+        if (deletedElements.length > 0) {
+            changes +=
+                "\n<deleted>\n" +
+                deletedElements.map(e => e.ChangesetXML(csId)).join("\n") +
+                "\n</deleted>"
+        }
+
+        changes += "</osmChange>";
+        return changes;
+    }
+
+    private static GetNeededIds(changes: ChangeDescription[]) {
+        return Utils.Dedup(changes.filter(c => c.id >= 0)
+            .map(c => c.type + "/" + c.id))
+    }
+
+    private CreateChangesetObjects(changes: ChangeDescription[], downloadedOsmObjects: OsmObject[]): {
+        newObjects: OsmObject[],
+        modifiedObjects: OsmObject[]
+        deletedObjects: OsmObject[]
+
+    } {
+        const objects: Map<string, OsmObject> = new Map<string, OsmObject>()
+        const states: Map<string, "unchanged" | "created" | "modified" | "deleted"> = new Map();
+
+        for (const o of downloadedOsmObjects) {
+            objects.set(o.type + "/" + o.id, o)
+            states.set(o.type + "/" + o.id, "unchanged")
+        }
+
+        for (const o of this.previouslyCreated) {
+            objects.set(o.type + "/" + o.id, o) 
+            states.set(o.type + "/" + o.id, "unchanged")
+        }
+
+        let changed = false;
         for (const change of changes) {
-            if (elementTags[change.k] !== change.v) {
-                elementTags[change.k] = change.v;
-                console.log("Applied ", change.k, "=", change.v)
-                // We use 'elementTags.id' here, as we might have retrieved with the id 'node/-1' as new point, but should use the rewritten id
-                this.pending.data.push({elementId: elementTags.id, key: change.k, value: change.v});
+            const id = change.type + "/" + change.id
+            if (!objects.has(id)) {
+                if(change.id >= 0){
+                    throw "Did not get an object that should be known: "+id
+                }
+                // This is a new object that should be created
+                states.set(id, "created")
+                console.log("Creating object for changeDescription", change)
+                let osmObj: OsmObject = undefined;
+                switch (change.type) {
+                    case "node":
+                        const n = new OsmNode(change.id)
+                        n.lat = change.changes["lat"]
+                        n.lon = change.changes["lon"]
+                        osmObj = n
+                        break;
+                    case "way":
+                        const w = new OsmWay(change.id)
+                        w.nodes = change.changes["nodes"]
+                        osmObj = w
+                        break;
+                    case "relation":
+                        const r = new OsmRelation(change.id)
+                        r.members = change.changes["members"]
+                        osmObj = r
+                        break;
+                }
+                if (osmObj === undefined) {
+                    throw "Hmm? This is a bug"
+                }
+                objects.set(id, osmObj)
+                this.previouslyCreated.push(osmObj)
+            }
+
+            const state = states.get(id)
+            if (change.doDelete) {
+                if (state === "created") {
+                    states.set(id, "unchanged")
+                } else {
+                    states.set(id, "deleted")
+                }
+            }
+
+            const obj = objects.get(id)
+            // Apply tag changes
+            for (const kv of change.tags ?? []) {
+                const k = kv.k
+                let v = kv.v
+
+                if (v === "") {
+                    v = undefined;
+                }
+
+                const oldV = obj.type[k]
+                if (oldV === v) {
+                    continue;
+                }
+
+                obj.tags[k] = v;
+                changed = true;
+
+
+            }
+
+            if (change.changes !== undefined) {
+                switch (change.type) {
+                    case "node":
+                        // @ts-ignore
+                        const nlat = change.changes.lat;
+                        // @ts-ignore
+                        const nlon = change.changes.lon;
+                        const n = <OsmNode>obj
+                        if (n.lat !== nlat || n.lon !== nlon) {
+                            n.lat = nlat;
+                            n.lon = nlon;
+                            changed = true;
+                        }
+                        break;
+                    case "way":
+                        const nnodes = change.changes["nodes"]
+                        const w = <OsmWay>obj
+                        if (!Utils.Identical(nnodes, w.nodes)) {
+                            w.nodes = nnodes
+                            changed = true;
+                        }
+                        break;
+                    case "relation":
+                        const nmembers: { type: "node" | "way" | "relation", ref: number, role: string }[] = change.changes["members"]
+                        const r = <OsmRelation>obj
+                        if (!Utils.Identical(nmembers, r.members, (a, b) => {
+                            return a.role === b.role && a.type === b.type && a.ref === b.ref
+                        })) {
+                            r.members = nmembers;
+                            changed = true;
+                        }
+                        break;
+
+                }
+               
+            }
+
+            if (changed && state === "unchanged") {
+                states.set(id, "modified")
             }
         }
-        this.pending.ping();
-        eventSource.ping();
+
+
+        const result = {
+            newObjects: [],
+            modifiedObjects: [],
+            deletedObjects: []
+        }
+        
+        objects.forEach((v, id) => {
+
+            const state = states.get(id)
+            if (state === "created") {
+                result.newObjects.push(v)
+            }
+            if (state === "modified") {
+                result.modifiedObjects.push(v)
+            }
+            if (state === "deleted") {
+                result.deletedObjects.push(v)
+            }
+
+        })
+
+        return result
+    }
+
+    /**
+     * Returns a new ID and updates the value for the next ID
+     */
+    public getNewID() {
+        return Changes._nextId--;
     }
 
     /**
@@ -83,194 +235,65 @@ export class Changes implements FeatureSource {
      * Triggered by the 'PendingChangeUploader'-actor in Actors
      */
     public flushChanges(flushreason: string = undefined) {
-        if (this.pending.data.length === 0) {
+        if (this.pendingChanges.data.length === 0) {
             return;
         }
-        if (flushreason !== undefined) {
-            console.log(flushreason)
-        }
-        this.uploadAll();
-    }
-
-    /**
-     * Create a new node element at the given lat/long.
-     * An internal OsmObject is created to upload later on, a geojson represention is returned.
-     * Note that the geojson version shares the tags (properties) by pointer, but has _no_ id in properties
-     */
-    public createElement(basicTags: Tag[], lat: number, lon: number) {
-        console.log("Creating a new element with ", basicTags)
-        const newId = Changes._nextId;
-        Changes._nextId--;
-
-        const id = "node/" + newId;
-
-
-        const properties = {id: id};
-
-        const geojson = {
-            "type": "Feature",
-            "properties": properties,
-            "id": id,
-            "geometry": {
-                "type": "Point",
-                "coordinates": [
-                    lon,
-                    lat
-                ]
-            }
-        }
-
-        // The basictags are COPIED, the id is included in the properties
-        // The tags are not yet written into the OsmObject, but this is applied onto a 
-        const changes = [];
-        for (const kv of basicTags) {
-            if (typeof kv.value !== "string") {
-                throw "Invalid value: don't use a regex in a preset"
-            }
-            properties[kv.key] = kv.value;
-            changes.push({elementId: id, key: kv.key, value: kv.value})
-        }
-
-        console.log("New feature added and pinged")
-        this.features.data.push({feature: geojson, freshness: new Date()});
-        this.features.ping();
-
-        State.state.allElements.addOrGetElement(geojson).ping();
-
-        if (State.state.osmConnection.userDetails.data.backend !== OsmConnection.oauth_configs.osm.url) {
-            properties["_backend"] = State.state.osmConnection.userDetails.data.backend
-        }
-
-
-        this.newObjects.data.push({id: newId, lat: lat, lon: lon})
-        this.pending.data.push(...changes)
-        this.pending.ping();
-        this.newObjects.ping();
-        return geojson;
-    }
-
-    private uploadChangesWithLatestVersions(
-        knownElements: OsmObject[]) {
-        const knownById = new Map<string, OsmObject>();
-        knownElements.forEach(knownElement => {
-            knownById.set(knownElement.type + "/" + knownElement.id, knownElement)
-        })
-
-        const newElements: OsmNode [] = this.newObjects.data.map(spec => {
-            const newElement = new OsmNode(spec.id);
-            newElement.lat = spec.lat;
-            newElement.lon = spec.lon;
-            return newElement
-        })
-
-
-        // Here, inside the continuation, we know that all 'neededIds' are loaded in 'knownElements', which maps the ids onto the elements
-        // We apply the changes on them
-        for (const change of this.pending.data) {
-            if (parseInt(change.elementId.split("/")[1]) < 0) {
-                // This is a new element - we should apply this on one of the new elements
-                for (const newElement of newElements) {
-                    if (newElement.type + "/" + newElement.id === change.elementId) {
-                        newElement.addTag(change.key, change.value);
-                    }
-                }
-            } else {
-                knownById.get(change.elementId).addTag(change.key, change.value);
-            }
-        }
-
-        // Small sanity check for duplicate information
-        let changedElements = [];
-        for (const elementId in knownElements) {
-            const element = knownElements[elementId];
-            if (element.changed) {
-                changedElements.push(element);
-            }
-        }
-        if (changedElements.length == 0 && newElements.length == 0) {
-            console.log("No changes in any object - clearing");
-            this.pending.setData([])
-            this.newObjects.setData([])
-            return;
-        }
-        const self = this;
-
+        
         if (this.isUploading.data) {
+            console.log("Is already uploading... Abort")
             return;
         }
+        
+      
         this.isUploading.setData(true)
-
-        console.log("Beginning upload...");
+       
+        console.log("Beginning upload... "+flushreason ?? "");
         // At last, we build the changeset and upload
-        State.state.osmConnection.UploadChangeset(
-            State.state.layoutToUse.data,
-            State.state.allElements,
-            function (csId) {
-
-                let modifications = "";
-                for (const element of changedElements) {
-                    if (!element.changed) {
-                        continue;
-                    }
-                    modifications += element.ChangesetXML(csId) + "\n";
-                }
-
-
-                let creations = "";
-                for (const newElement of newElements) {
-                    creations += newElement.ChangesetXML(csId);
-                }
-
-
-                let changes = `<osmChange version='0.6' generator='Mapcomplete ${Constants.vNumber}'>`;
-
-                if (creations.length > 0) {
-                    changes +=
-                        "<create>" +
-                        creations +
-                        "</create>";
-                }
-
-                if (modifications.length > 0) {
-                    changes +=
-                        "<modify>\n" +
-                        modifications +
-                        "\n</modify>";
-                }
-
-                changes += "</osmChange>";
-
-                return changes;
-            },
-            () => {
-                console.log("Upload successfull!")
-                self.newObjects.setData([])
-                self.pending.setData([]);
-                self.isUploading.setData(false)
-            },
-            () => self.isUploading.setData(false)
-        );
-    };
-
-
-    private uploadAll() {
         const self = this;
+        const pending = self.pendingChanges.data;
+        const neededIds =  Changes.GetNeededIds(pending)
+        console.log("Needed ids", neededIds)
+        OsmObject.DownloadAll(neededIds, true).addCallbackAndRunD(osmObjects => {
+            console.log("Got the fresh objects!", osmObjects, "pending: ", pending)
+            const changes: {
+                newObjects: OsmObject[],
+                modifiedObjects: OsmObject[]
+                deletedObjects: OsmObject[]
 
-        const pending = this.pending.data;
-        let neededIds: string[] = [];
-        for (const change of pending) {
-            const id = change.elementId;
-            if (parseFloat(id.split("/")[1]) < 0) {
-                // New element - we don't have to download this
-            } else {
-                neededIds.push(id);
+            }  = self.CreateChangesetObjects(pending, osmObjects)
+            if (changes.newObjects.length + changes.deletedObjects.length + changes.modifiedObjects.length === 0) {
+                console.log("No changes to be made")
+                self.pendingChanges.setData([])
+                self.isUploading.setData(false)
+                return true; // Unregister the callback
             }
-        }
 
-        neededIds = Utils.Dedup(neededIds);
-        OsmObject.DownloadAll(neededIds).addCallbackAndRunD(knownElements => {
-            self.uploadChangesWithLatestVersions(knownElements)
-        })
+
+            State.state.osmConnection.UploadChangeset(
+                State.state.layoutToUse.data,
+                State.state.allElements,
+                (csId) => Changes.createChangesetFor(csId, changes),
+                () => {
+                    console.log("Upload successfull!")
+                    self.pendingChanges.setData([]);
+                    self.isUploading.setData(false)
+                },
+                () => {
+                    console.log("Upload failed - trying again later")
+                    return self.isUploading.setData(false);
+                } // Failed - mark to try again
+            )
+            return true;
+
+        });
+
+
     }
 
+    public applyAction(action: OsmChangeAction) {
+        const changes = action.Perform(this)
+        console.log("Received changes:", changes)
+        this.pendingChanges.data.push(...changes);
+        this.pendingChanges.ping();
+    }
 }

Logic/Osm/ChangesetHandler.ts

@@ -53,6 +53,8 @@ export class ChangesetHandler {
                 element.ping();
 
             }
+
+
         }
     }
 

Logic/Osm/OsmConnection.ts

@@ -249,8 +249,13 @@ export class OsmConnection {
         });
     }
 
+    private isChecking = false;
     private CheckForMessagesContinuously(){
         const self =this;
+        if(this.isChecking){
+            return;
+        }
+        this.isChecking = true;
         UIEventSource.Chronic(5 * 60 * 1000).addCallback(_ => {
             if (self.isLoggedIn .data) {
             console.log("Checking for messages")

Logic/Osm/OsmObject.ts

@@ -23,7 +23,7 @@ export abstract class OsmObject {
         this.id = id;
         this.type = type;
         this.tags = {
-            id: id
+            id: `${this.type}/${id}`
         }
     }
 
@@ -51,7 +51,10 @@ export abstract class OsmObject {
         }
         const splitted = id.split("/");
         const type = splitted[0];
-        const idN = splitted[1];
+        const idN = Number(splitted[1]);
+        if(idN <0){
+            return;
+        }
 
         OsmObject.objectCache.set(id, src);
         const newContinuation = (element: OsmObject) => {
@@ -68,6 +71,8 @@ export abstract class OsmObject {
             case("relation"):
                 new OsmRelation(idN).Download(newContinuation);
                 break;
+            default:
+                throw "Invalid object type:" + type + id;
 
         }
         return src;
@@ -103,7 +108,7 @@ export abstract class OsmObject {
         if (OsmObject.referencingRelationsCache.has(id)) {
             return OsmObject.referencingRelationsCache.get(id);
         }
-        const relsSrc = new UIEventSource<OsmRelation[]>([])
+        const relsSrc = new UIEventSource<OsmRelation[]>(undefined)
         OsmObject.referencingRelationsCache.set(id, relsSrc);
         Utils.downloadJson(`${OsmObject.backendURL}api/0.6/${id}/relations`)
             .then(data => {
@@ -123,7 +128,7 @@ export abstract class OsmObject {
         }
         const splitted = id.split("/");
         const type = splitted[0];
-        const idN = splitted[1];
+        const idN = Number(splitted[1]);
         const src = new UIEventSource<OsmObject[]>([]);
         OsmObject.historyCache.set(id, src);
         Utils.downloadJson(`${OsmObject.backendURL}api/0.6/${type}/${idN}/history`).then(data => {
@@ -312,20 +317,6 @@ export abstract class OsmObject {
         return this;
     }
 
-    public addTag(k: string, v: string): void {
-        if (k in this.tags) {
-            const oldV = this.tags[k];
-            if (oldV == v) {
-                return;
-            }
-            console.log("Overwriting ", oldV, " with ", v, " for key ", k)
-        }
-        this.tags[k] = v;
-        if (v === undefined || v === "") {
-            delete this.tags[k];
-        }
-        this.changed = true;
-    }
 
     abstract ChangesetXML(changesetId: string): string;
 
@@ -360,7 +351,7 @@ export class OsmNode extends OsmObject {
     lat: number;
     lon: number;
 
-    constructor(id) {
+    constructor(id: number) {
         super("node", id);
 
     }
@@ -368,9 +359,9 @@ export class OsmNode extends OsmObject {
     ChangesetXML(changesetId: string): string {
         let tags = this.TagsXML();
 
-        return '        <node id="' + this.id + '" changeset="' + changesetId + '" ' + this.VersionXML() + ' lat="' + this.lat + '" lon="' + this.lon + '">\n' +
+        return '    <node id="' + this.id + '" changeset="' + changesetId + '" ' + this.VersionXML() + ' lat="' + this.lat + '" lon="' + this.lon + '">\n' +
             tags +
-            '        </node>\n';
+            '    </node>\n';
     }
 
     SaveExtraData(element) {
@@ -413,9 +404,8 @@ export class OsmWay extends OsmObject {
     lat: number;
     lon: number;
 
-    constructor(id) {
+    constructor(id: number) {
         super("way", id);
-
     }
 
     centerpoint(): [number, number] {
@@ -432,7 +422,7 @@ export class OsmWay extends OsmObject {
         return '    <way id="' + this.id + '" changeset="' + changesetId + '" ' + this.VersionXML() + '>\n' +
             nds +
             tags +
-            '        </way>\n';
+            '    </way>\n';
     }
 
     SaveExtraData(element, allNodes: OsmNode[]) {
@@ -458,7 +448,7 @@ export class OsmWay extends OsmObject {
         this.nodes = element.nodes;
     }
 
-    asGeoJson() {
+    public asGeoJson() {
         return {
             "type": "Feature",
             "properties": this.tags,
@@ -480,11 +470,14 @@ export class OsmWay extends OsmObject {
 
 export class OsmRelation extends OsmObject {
 
-    members;
+    public members: {
+        type: "node" | "way" | "relation",
+        ref: number,
+        role: string
+    }[];
 
-    constructor(id) {
+    constructor(id: number) {
         super("relation", id);
-
     }
 
     centerpoint(): [number, number] {

Logic/Osm/aspectedRouting.ts

@@ -0,0 +1,194 @@
+export default class AspectedRouting {
+
+    public readonly name: string
+    public readonly description: string
+    public readonly units: string
+    public readonly program: any
+
+    public constructor(program) {
+        this.name = program.name;
+        this.description = program.description;
+        this.units = program.unit
+        this.program = JSON.parse(JSON.stringify(program))
+        delete this.program.name
+        delete this.program.description
+       delete this.program.unit
+    }
+
+    public evaluate(properties){
+        return AspectedRouting.interpret(this.program, properties)
+    }
+    /**
+     * Interprets the given Aspected-routing program for the given properties
+     */
+    public static interpret(program: any, properties: any) {
+        if (typeof program !== "object") {
+            return program;
+        }
+
+        let functionName /*: string*/ = undefined;
+        let functionArguments /*: any */ = undefined
+        let otherValues = {}
+        // @ts-ignore
+        Object.entries(program).forEach(tag => {
+                const [key, value] = tag;
+                if (key.startsWith("$")) {
+                    functionName = key
+                    functionArguments = value
+                } else {
+                    otherValues[key] = value
+                }
+            }
+        )
+
+        if (functionName === undefined) {
+            return AspectedRouting.interpretAsDictionary(program, properties)
+        }
+
+        if (functionName === '$multiply') {
+            return AspectedRouting.multiplyScore(properties, functionArguments);
+        } else if (functionName === '$firstMatchOf') {
+            return AspectedRouting.getFirstMatchScore(properties, functionArguments);
+        } else if (functionName === '$min') {
+            return AspectedRouting.getMinValue(properties, functionArguments);
+        } else if (functionName === '$max') {
+            return AspectedRouting.getMaxValue(properties, functionArguments);
+        } else if (functionName === '$default') {
+            return AspectedRouting.defaultV(functionArguments, otherValues, properties)
+        } else {
+            console.error(`Error: Program ${functionName} is not implemented yet. ${JSON.stringify(program)}`);
+        }
+    }
+
+    /**
+     * Given a 'program' without function invocation, interprets it as a dictionary
+     *
+     * E.g., given the program
+     *
+     * {
+     *     highway: {
+     *         residential: 30,
+     *         living_street: 20
+     *     },
+     *     surface: {
+     *         sett : 0.9
+     *     }
+     *     
+     * }
+     *
+     * in combination with the tags {highway: residential},
+     *
+     * the result should be [30, undefined];
+     *
+     * For the tags {highway: residential, surface: sett} we should get [30, 0.9]
+     *
+     *
+     * @param program
+     * @param tags
+     * @return {(undefined|*)[]}
+     */
+    private static interpretAsDictionary(program, tags) {
+        // @ts-ignore
+        return Object.entries(tags).map(tag => {
+            const [key, value] = tag;
+            const propertyValue = program[key]
+            if (propertyValue === undefined) {
+                return undefined
+            }
+            if (typeof propertyValue !== "object") {
+                return propertyValue
+            }
+            // @ts-ignore
+            return propertyValue[value]
+        });
+    }
+
+    private static defaultV(subProgram, otherArgs, tags) {
+        // @ts-ignore
+        const normalProgram = Object.entries(otherArgs)[0][1]
+        const value = AspectedRouting.interpret(normalProgram, tags)
+        if (value !== undefined) {
+            return value;
+        }
+        return AspectedRouting.interpret(subProgram, tags)
+    }
+
+    /**
+     * Multiplies the default score with the proper values
+     * @param tags {object} the active tags to check against
+     * @param subprograms which should generate a list of values
+     * @returns score after multiplication
+     */
+    private static multiplyScore(tags, subprograms) {
+        let number = 1
+
+        let subResults: any[]
+        if (subprograms.length !== undefined) {
+            subResults = AspectedRouting.concatMap(subprograms, subprogram => AspectedRouting.interpret(subprogram, tags))
+        } else {
+            subResults = AspectedRouting.interpret(subprograms, tags)
+        }
+
+        subResults.filter(r => r !== undefined).forEach(r => number *= parseFloat(r))
+        return number.toFixed(2);
+    }
+
+    private static getFirstMatchScore(tags, order: any) {
+        /*Order should be a list of arguments after evaluation*/
+        order = <string[]>AspectedRouting.interpret(order, tags)
+        for (let key of order) {
+            // @ts-ignore
+            for (let entry of Object.entries(JSON.parse(tags))) {
+                const [tagKey, value] = entry;
+                if (key === tagKey) {
+                    // We have a match... let's evaluate the subprogram
+                    const evaluated = AspectedRouting.interpret(value, tags)
+                    if (evaluated !== undefined) {
+                        return evaluated;
+                    }
+                }
+            }
+        }
+
+        // Not a single match found...
+        return undefined
+    }
+
+    private static getMinValue(tags, subprogram) {
+        const minArr = subprogram.map(part => {
+            if (typeof (part) === 'object') {
+                const calculatedValue = this.interpret(part, tags)
+                return parseFloat(calculatedValue)
+            } else {
+                return parseFloat(part);
+            }
+        }).filter(v => !isNaN(v));
+        return Math.min(...minArr);
+    }
+
+    private static getMaxValue(tags, subprogram) {
+        const maxArr = subprogram.map(part => {
+            if (typeof (part) === 'object') {
+                return parseFloat(AspectedRouting.interpret(part, tags))
+            } else {
+                return parseFloat(part);
+            }
+        }).filter(v => !isNaN(v));
+        return Math.max(...maxArr);
+    }
+
+    private static concatMap(list, f): any[] {
+        const result = []
+        list = list.map(f)
+        for (const elem of list) {
+            if (elem.length !== undefined) {
+                // This is a list
+                result.push(...elem)
+            } else {
+                result.push(elem)
+            }
+        }
+        return result;
+    }
+
+}

Logic/SimpleMetaTagger.ts

@@ -83,7 +83,7 @@ export default class SimpleMetaTagger {
 
         },
         (feature => {
-            const units = State.state.layoutToUse.data.units ?? [];
+            const units = State.state?.layoutToUse?.data?.units ?? [];
             let rewritten = false;
             for (const key in feature.properties) {
                 if (!feature.properties.hasOwnProperty(key)) {
@@ -100,10 +100,10 @@ export default class SimpleMetaTagger {
                         break;
                     }
                     console.log("Rewritten ", key, ` from '${value}' into '${canonical}'`)
-                    if(canonical === undefined && !unit.eraseInvalid) {
+                    if (canonical === undefined && !unit.eraseInvalid) {
                         break;
                     }
-                    
+
                     feature.properties[key] = canonical;
                     rewritten = true;
                     break;

Logic/Tags/ComparingTag.ts

@@ -0,0 +1,42 @@
+import {TagsFilter} from "./TagsFilter";
+
+export default class ComparingTag implements TagsFilter {
+    private readonly _key: string;
+    private readonly _predicate: (value: string) => boolean;
+    private readonly _representation: string;
+    
+    constructor(key: string, predicate : (value:string | undefined) => boolean, representation: string = "") {
+        this._key = key;
+        this._predicate = predicate;
+        this._representation = representation;
+    }
+    
+    asChange(properties: any): { k: string; v: string }[] {
+        throw "A comparable tag can not be used to be uploaded to OSM"
+    }
+
+    asHumanString(linkToWiki: boolean, shorten: boolean, properties: any) {
+        return this._key+this._representation
+    }
+
+    asOverpass(): string[] {
+        throw "A comparable tag can not be used as overpass filter"
+    }
+
+    isEquivalent(other: TagsFilter): boolean {
+        return other === this;
+    }
+
+    isUsableAsAnswer(): boolean {
+        return false;
+    }
+
+    matchesProperties(properties: any): boolean {
+        return this._predicate(properties[this._key]);
+    }
+
+    usedKeys(): string[] {
+        return [this._key];
+    }
+    
+}

Logic/Tags/Or.ts

@@ -8,7 +8,7 @@ export class Or extends TagsFilter {
         super();
         this.or = or;
     }
-    
+
     matchesProperties(properties: any): boolean {
         for (const tagsFilter of this.or) {
             if (tagsFilter.matchesProperties(properties)) {
@@ -23,9 +23,7 @@ export class Or extends TagsFilter {
         const choices = [];
         for (const tagsFilter of this.or) {
             const subChoices = tagsFilter.asOverpass();
-            for (const subChoice of subChoices) {
-                choices.push(subChoice)
-            }
+            choices.push(...subChoices)
         }
         return choices;
     }

Logic/Tags/RegexTag.ts

@@ -34,9 +34,9 @@ export class RegexTag extends TagsFilter {
 
     asOverpass(): string[] {
         if (typeof this.key === "string") {
-            return [`['${this.key}'${this.invert ? "!" : ""}~'${RegexTag.source(this.value)}']`];
+            return [`["${this.key}"${this.invert ? "!" : ""}~"${RegexTag.source(this.value)}"]`];
         }
-        return [`[~'${this.key.source}'${this.invert ? "!" : ""}~'${RegexTag.source(this.value)}']`];
+        return [`[~"${this.key.source}"${this.invert ? "!" : ""}~"${RegexTag.source(this.value)}"]`];
     }
 
     isUsableAsAnswer(): boolean {

Logic/Tags/Tag.ts

@@ -1,7 +1,6 @@
 import {Utils} from "../../Utils";
 import {RegexTag} from "./RegexTag";
 import {TagsFilter} from "./TagsFilter";
-import {TagUtils} from "./TagUtils";
 
 export class Tag extends TagsFilter {
     public key: string
@@ -25,12 +24,19 @@ export class Tag extends TagsFilter {
 
     matchesProperties(properties: any): boolean {
         for (const propertiesKey in properties) {
+            if(!properties.hasOwnProperty(propertiesKey)){
+                continue
+            }
             if (this.key === propertiesKey) {
                 const value = properties[propertiesKey];
+                if(value === undefined){
+                    continue
+                }
                 return value === this.value;
             }
         }
         // The tag was not found
+        
         if (this.value === "") {
             // and it shouldn't be found!
             return true;
@@ -46,11 +52,6 @@ export class Tag extends TagsFilter {
         }
         return [`["${this.key}"="${this.value}"]`];
     }
-
-    substituteValues(tags: any) {
-        return new Tag(this.key, TagUtils.ApplyTemplate(this.value as string, tags));
-    }
-
     asHumanString(linkToWiki?: boolean, shorten?: boolean) {
         let v = this.value;
         if (shorten) {

Logic/UIEventSource.ts

@@ -2,21 +2,27 @@ import {Utils} from "../Utils";
 
 export class UIEventSource<T> {
 
+    private static allSources: UIEventSource<any>[] = UIEventSource.PrepPerf();
     public data: T;
+    public trace: boolean;
     private readonly tag: string;
-    private _callbacks = [];
-    
-    private static allSources : UIEventSource<any>[] = UIEventSource.PrepPerf();
-    
-    static PrepPerf() : UIEventSource<any>[]{
-        if(Utils.runningFromConsole){
+    private _callbacks: ((t: T) => (boolean | void | any)) [] = [];
+
+    constructor(data: T, tag: string = "") {
+        this.tag = tag;
+        this.data = data;
+        UIEventSource.allSources.push(this);
+    }
+
+    static PrepPerf(): UIEventSource<any>[] {
+        if (Utils.runningFromConsole) {
             return [];
         }
         // @ts-ignore
         window.mapcomplete_performance = () => {
             console.log(UIEventSource.allSources.length, "uieventsources created");
             const copy = [...UIEventSource.allSources];
-            copy.sort((a,b) => b._callbacks.length - a._callbacks.length);
+            copy.sort((a, b) => b._callbacks.length - a._callbacks.length);
             console.log("Topten is:")
             for (let i = 0; i < 10; i++) {
                 console.log(copy[i].tag, copy[i]);
@@ -26,12 +32,6 @@ export class UIEventSource<T> {
         return [];
     }
 
-    constructor(data: T, tag: string = "") {
-        this.tag = tag;
-        this.data = data;
-        UIEventSource.allSources.push(this);
-    }
-
     public static flatten<X>(source: UIEventSource<UIEventSource<X>>, possibleSources: UIEventSource<any>[]): UIEventSource<X> {
         const sink = new UIEventSource<X>(source.data?.data);
 
@@ -63,11 +63,20 @@ export class UIEventSource<T> {
 
     }
 
-    public addCallback(callback: ((latestData: T) => void)): UIEventSource<T> {
+    /**
+     * Adds a callback
+     *
+     * If the result of the callback is 'true', the callback is considered finished and will be removed again
+     * @param callback
+     */
+    public addCallback(callback: ((latestData: T) => (boolean | void | any))): UIEventSource<T> {
         if (callback === console.log) {
             // This ^^^ actually works!
             throw "Don't add console.log directly as a callback - you'll won't be able to find it afterwards. Wrap it in a lambda instead."
         }
+        if (this.trace) {
+            console.trace("Added a callback")
+        }
         this._callbacks.push(callback);
         return this;
     }
@@ -87,8 +96,21 @@ export class UIEventSource<T> {
     }
 
     public ping(): void {
+        let toDelete = undefined
         for (const callback of this._callbacks) {
-            callback(this.data);
+            if (callback(this.data) === true) {
+                // This callback wants to be deleted
+                if (toDelete === undefined) {
+                    toDelete = [callback]
+                } else {
+                    toDelete.push(callback)
+                }
+            }
+        }
+        if (toDelete !== undefined) {
+            for (const toDeleteElement of toDelete) {
+                this._callbacks.splice(this._callbacks.indexOf(toDeleteElement), 1)
+            }
         }
     }
 
@@ -101,12 +123,12 @@ export class UIEventSource<T> {
      */
     public map<J>(f: ((t: T) => J),
                   extraSources: UIEventSource<any>[] = [],
-                  g: ((j:J, t:T) => T) = undefined): UIEventSource<J> {
+                  g: ((j: J, t: T) => T) = undefined): UIEventSource<J> {
         const self = this;
 
         const newSource = new UIEventSource<J>(
             f(this.data),
-            "map("+this.tag+")"
+            "map(" + this.tag + ")"
         );
 
         const update = function () {
@@ -159,11 +181,28 @@ export class UIEventSource<T> {
         return newSource;
     }
 
-    addCallbackAndRunD(callback: (data :T ) => void) {
+    addCallbackAndRunD(callback: (data: T) => void) {
         this.addCallbackAndRun(data => {
-            if(data !== undefined && data !== null){
-                callback(data)
+            if (data !== undefined && data !== null) {
+              return  callback(data)
             }
         })
     }
+}
+
+export class UIEventSourceTools {
+
+    private static readonly _download_cache = new Map<string, UIEventSource<any>>()
+
+    public static downloadJsonCached(url: string): UIEventSource<any>{
+        const cached = UIEventSourceTools._download_cache.get(url)
+        if(cached !== undefined){
+            return cached;
+        }
+        const src = new UIEventSource<any>(undefined)
+        UIEventSourceTools._download_cache.set(url, src)
+        Utils.downloadJson(url).then(r => src.setData(r))
+        return src;
+    }
+
 }