120 lines
4 KiB
TypeScript
120 lines
4 KiB
TypeScript
/**
|
|
* Keeps track of a dictionary 'elementID' -> UIEventSource<tags>
|
|
*/
|
|
import { UIEventSource } from "./UIEventSource"
|
|
import { GeoJSONObject } from "@turf/turf"
|
|
import { Feature, Geometry, Point } from "geojson"
|
|
import { OsmTags } from "../Models/OsmFeature"
|
|
|
|
export class ElementStorage {
|
|
public ContainingFeatures = new Map<string, Feature<Geometry, OsmTags>>()
|
|
private _elements = new Map<string, UIEventSource<any>>()
|
|
|
|
constructor() {}
|
|
|
|
addElementById(id: string, eventSource: UIEventSource<any>) {
|
|
this._elements.set(id, eventSource)
|
|
}
|
|
|
|
/**
|
|
* Creates a UIEventSource for the tags of the given feature.
|
|
* If an UIEventsource has been created previously, the same UIEventSource will be returned
|
|
*
|
|
* Note: it will cleverly merge the tags, if needed
|
|
*/
|
|
addOrGetElement(feature: Feature<Geometry, OsmTags>): UIEventSource<any> {
|
|
const elementId = feature.properties.id
|
|
const newProperties = feature.properties
|
|
|
|
const es = this.addOrGetById(elementId, newProperties)
|
|
|
|
// At last, we overwrite the tag of the new feature to use the tags in the already existing event source
|
|
feature.properties = es.data
|
|
|
|
if (!this.ContainingFeatures.has(elementId)) {
|
|
this.ContainingFeatures.set(elementId, feature)
|
|
}
|
|
|
|
return es
|
|
}
|
|
|
|
getEventSourceById(elementId): UIEventSource<any> {
|
|
if (elementId === undefined) {
|
|
return undefined
|
|
}
|
|
return this._elements.get(elementId)
|
|
}
|
|
|
|
has(id) {
|
|
return this._elements.has(id)
|
|
}
|
|
|
|
addAlias(oldId: string, newId: string) {
|
|
if (newId === undefined) {
|
|
// We removed the node/way/relation with type 'type' and id 'oldId' on openstreetmap!
|
|
const element = this.getEventSourceById(oldId)
|
|
element.data._deleted = "yes"
|
|
element.ping()
|
|
return
|
|
}
|
|
|
|
if (oldId == newId) {
|
|
return undefined
|
|
}
|
|
const element = this.getEventSourceById(oldId)
|
|
if (element === undefined) {
|
|
// Element to rewrite not found, probably a node or relation that is not rendered
|
|
return undefined
|
|
}
|
|
element.data.id = newId
|
|
this.addElementById(newId, element)
|
|
this.ContainingFeatures.set(newId, this.ContainingFeatures.get(oldId))
|
|
element.ping()
|
|
}
|
|
|
|
private addOrGetById(elementId: string, newProperties: any): UIEventSource<any> {
|
|
if (!this._elements.has(elementId)) {
|
|
const eventSource = new UIEventSource<any>(newProperties, "tags of " + elementId)
|
|
this._elements.set(elementId, eventSource)
|
|
return eventSource
|
|
}
|
|
|
|
const es = this._elements.get(elementId)
|
|
if (es.data == newProperties) {
|
|
// Reference comparison gives the same object! we can just return the event source
|
|
return es
|
|
}
|
|
const keptKeys = es.data
|
|
// The element already exists
|
|
// We use the new feature to overwrite all the properties in the already existing eventsource
|
|
const debug_msg = []
|
|
let somethingChanged = false
|
|
for (const k in newProperties) {
|
|
if (!newProperties.hasOwnProperty(k)) {
|
|
continue
|
|
}
|
|
const v = newProperties[k]
|
|
|
|
if (keptKeys[k] !== v) {
|
|
if (v === undefined) {
|
|
// The new value is undefined; the tag might have been removed
|
|
// It might be a metatag as well
|
|
// In the latter case, we do keep the tag!
|
|
if (!k.startsWith("_")) {
|
|
delete keptKeys[k]
|
|
debug_msg.push("Erased " + k)
|
|
}
|
|
} else {
|
|
keptKeys[k] = v
|
|
debug_msg.push(k + " --> " + v)
|
|
}
|
|
|
|
somethingChanged = true
|
|
}
|
|
}
|
|
if (somethingChanged) {
|
|
es.ping()
|
|
}
|
|
return es
|
|
}
|
|
}
|