umap-project 2.4.0b2__py3-none-any.whl → 2.4.2__py3-none-any.whl

umap/static/umap/js/umap.features.js

@@ -6,7 +6,7 @@ U.FeatureMixin = {
       subject: 'feature',
       metadata: {
         id: this.id,
-        layerId: this.datalayer?.id || null,
+        layerId: this.datalayer?.umap_id || null,
         featureType: this.getClassName(),
       },
     }
@@ -15,7 +15,18 @@ U.FeatureMixin = {
   onCommit: function () {
     // When the layer is a remote layer, we don't want to sync the creation of the
     // points via the websocket, as the other peers will get them themselves.
-    if (this.datalayer.isRemoteLayer()) return
+    if (this.datalayer?.isRemoteLayer()) return
+
+    // The "endEdit" event is triggered at the end of an edition,
+    // and will trigger the sync.
+    // In the case of a deletion (or a change of layer), we don't want this
+    // event triggered to cause a sync event, as it would reintroduce
+    // deleted features.
+    // The `._marked_for_deletion` private property is here to track this status.
+    if (this._marked_for_deletion === true) {
+      this._marked_for_deletion = false
+      return
+    }
     this.sync.upsert(this.toGeoJSON())
   },
 
@@ -23,13 +34,10 @@ U.FeatureMixin = {
     return this.toGeoJSON().geometry
   },
 
-  syncDelete: function () {
-    this.sync.delete()
-  },
-
   initialize: function (map, latlng, options, id) {
     this.map = map
     this.sync = map.sync_engine.proxy(this)
+    this._marked_for_deletion = false
 
     if (typeof options === 'undefined') {
       options = {}
@@ -58,19 +66,16 @@ U.FeatureMixin = {
       }
     }
     let isDirty = false
-    const self = this
     try {
       Object.defineProperty(this, 'isDirty', {
-        get: function () {
-          return isDirty
-        },
-        set: function (status) {
+        get: () => isDirty,
+        set: (status) => {
           if (!isDirty && status) {
-            self.fire('isdirty')
+            this.fire('isdirty')
           }
           isDirty = status
-          if (self.datalayer) {
-            self.datalayer.isDirty = status
+          if (this.datalayer) {
+            this.datalayer.isDirty = status
           }
         },
       })
@@ -82,10 +87,10 @@ U.FeatureMixin = {
     this.parentClass.prototype.initialize.call(this, latlng, options)
   },
 
-  preInit: function () {},
+  preInit: () => {},
 
   isReadOnly: function () {
-    return this.datalayer && this.datalayer.isDataReadOnly()
+    return this.datalayer?.isDataReadOnly()
   },
 
   getSlug: function () {
@@ -144,7 +149,11 @@ U.FeatureMixin = {
   edit: function (e) {
     if (!this.map.editEnabled || this.isReadOnly()) return
     const container = L.DomUtil.create('div', 'umap-feature-container')
-    L.DomUtil.createTitle(container, L._('Feature properties'), `icon-${this.getClassName()}`)
+    L.DomUtil.createTitle(
+      container,
+      L._('Feature properties'),
+      `icon-${this.getClassName()}`
+    )
 
     let builder = new U.FormBuilder(
       this,
@@ -224,19 +233,17 @@ U.FeatureMixin = {
     popupFieldset.appendChild(builder.build())
   },
 
-  getInteractionOptions: function () {
-    return [
-      'properties._umap_options.popupShape',
-      'properties._umap_options.popupTemplate',
-      'properties._umap_options.showLabel',
-      'properties._umap_options.labelDirection',
-      'properties._umap_options.labelInteractive',
-      'properties._umap_options.outlink',
-      'properties._umap_options.outlinkTarget',
-    ]
-  },
+  getInteractionOptions: () => [
+    'properties._umap_options.popupShape',
+    'properties._umap_options.popupTemplate',
+    'properties._umap_options.showLabel',
+    'properties._umap_options.labelDirection',
+    'properties._umap_options.labelInteractive',
+    'properties._umap_options.outlink',
+    'properties._umap_options.outlinkTarget',
+  ],
 
-  endEdit: function () {},
+  endEdit: () => {},
 
   getDisplayName: function (fallback) {
     if (fallback === undefined) fallback = this.datalayer.options.name
@@ -272,14 +279,12 @@ U.FeatureMixin = {
     }
     return false
   },
+
   del: function (sync) {
     this.isDirty = true
     this.map.closePopup()
     if (this.datalayer) {
-      this.datalayer.removeLayer(this)
-      this.disconnectFromDataLayer(this.datalayer)
-
-      if (sync !== false) this.syncDelete()
+      this.datalayer.removeLayer(this, sync)
     }
   },
 
@@ -294,7 +299,7 @@ U.FeatureMixin = {
     }
   },
 
-  cleanProperty: function ([key, value]) {
+  cleanProperty: ([key, value]) => {
     // dot in key will break the dot based property access
     // while editing the feature
     key = key.replace('.', '_')
@@ -322,7 +327,9 @@ U.FeatureMixin = {
       this.datalayer.isDirty = true
       this.datalayer.removeLayer(this)
     }
+
     datalayer.addLayer(this)
+    this.sync.upsert(this.toGeoJSON())
     datalayer.isDirty = true
     this._redraw()
   },
@@ -407,7 +414,7 @@ U.FeatureMixin = {
   },
 
   _onClick: function (e) {
-    if (this.map.measureTools && this.map.measureTools.enabled()) return
+    if (this.map.measureTools?.enabled()) return
     this._popupHandlersAdded = true // Prevent leaflet from managing event
     if (!this.map.editEnabled) {
       this.view(e)
@@ -430,13 +437,9 @@ U.FeatureMixin = {
     L.DomEvent.stop(e)
   },
 
-  getPopupToolbarAnchor: function () {
-    return [0, 0]
-  },
+  getPopupToolbarAnchor: () => [0, 0],
 
-  getInplaceToolbarActions: function (e) {
-    return [U.ToggleEditAction, U.DeleteFeatureAction]
-  },
+  getInplaceToolbarActions: (e) => [U.ToggleEditAction, U.DeleteFeatureAction],
 
   _showContextMenu: function (e) {
     L.DomEvent.stop(e)
@@ -459,7 +462,7 @@ U.FeatureMixin = {
     if (permalink)
       items.push({
         text: L._('Permalink'),
-        callback: function () {
+        callback: () => {
           window.open(permalink)
         },
       })
@@ -473,7 +476,7 @@ U.FeatureMixin = {
     let items = ['-']
     if (this.map.editedFeature !== this) {
       items.push({
-        text: L._('Edit this feature') + ' (⇧+Click)',
+        text: `${L._('Edit this feature')} (⇧+Click)`,
         callback: this.edit,
         context: this,
         iconCls: 'umap-edit',
@@ -504,6 +507,7 @@ U.FeatureMixin = {
   onRemove: function (map) {
     this.parentClass.prototype.onRemove.call(this, map)
     if (this.map.editedFeature === this) {
+      this._marked_for_deletion = true
       this.endEdit()
       this.map.editPanel.close()
     }
@@ -528,7 +532,7 @@ U.FeatureMixin = {
   },
 
   isFiltered: function () {
-    const filterKeys = this.map.getFilterKeys()
+    const filterKeys = this.datalayer.getFilterKeys()
     const filter = this.map.browser.options.filter
     if (filter && !this.matchFilter(filter, filterKeys)) return true
     if (!this.matchFacets()) return true
@@ -537,8 +541,12 @@ U.FeatureMixin = {
 
   matchFilter: function (filter, keys) {
     filter = filter.toLowerCase()
+    if (U.Utils.hasVar(keys)) {
+      return this.getDisplayName().toLowerCase().indexOf(filter) !== -1
+    }
+    keys = keys.split(',')
     for (let i = 0, value; i < keys.length; i++) {
-      value = (this.properties[keys[i]] || '') + ''
+      value = `${this.properties[keys[i]] || ''}`
       if (value.toLowerCase().indexOf(filter) !== -1) return true
     }
     return false
@@ -546,16 +554,16 @@ U.FeatureMixin = {
 
   matchFacets: function () {
     const selected = this.map.facets.selected
-    for (let [name, { type, min, max, choices }] of Object.entries(selected)) {
+    for (const [name, { type, min, max, choices }] of Object.entries(selected)) {
       let value = this.properties[name]
-      let parser = this.map.facets.getParser(type)
+      const parser = this.map.facets.getParser(type)
       value = parser(value)
       switch (type) {
         case 'date':
         case 'datetime':
         case 'number':
-          if (!isNaN(min) && !isNaN(value) && min > value) return false
-          if (!isNaN(max) && !isNaN(value) && max < value) return false
+          if (!Number.isNaN(min) && !Number.isNaN(value) && min > value) return false
+          if (!Number.isNaN(max) && !Number.isNaN(value) && max < value) return false
           break
         default:
           value = value || L._('<empty value>')
@@ -573,13 +581,9 @@ U.FeatureMixin = {
     }).addTo(this.map, this, e.latlng, e.vertex)
   },
 
-  getVertexActions: function () {
-    return [U.DeleteVertexAction]
-  },
+  getVertexActions: () => [U.DeleteVertexAction],
 
-  isMulti: function () {
-    return false
-  },
+  isMulti: () => false,
 
   clone: function () {
     const geoJSON = this.toGeoJSON()
@@ -598,7 +602,7 @@ U.FeatureMixin = {
     if (locale) properties.locale = locale
     if (L.lang) properties.lang = L.lang
     properties.rank = this.getRank() + 1
-    if (this.hasGeom()) {
+    if (this._map && this.hasGeom()) {
       center = this.getCenter()
       properties.lat = center.lat
       properties.lon = center.lng
@@ -655,11 +659,7 @@ U.Marker = L.Marker.extend({
   },
 
   _onMouseOut: function () {
-    if (
-      this.dragging &&
-      this.dragging._draggable &&
-      !this.dragging._draggable._moving
-    ) {
+    if (this.dragging?._draggable && !this.dragging._draggable._moving) {
       // Do not disable if the mouse went out while dragging
       this._disableDragging()
     }
@@ -680,14 +680,14 @@ U.Marker = L.Marker.extend({
 
   _disableDragging: function () {
     if (this.map.editEnabled) {
-      if (this.editor && this.editor.drawing) return // when creating a new marker, the mouse can trigger the mouseover/mouseout event
+      if (this.editor?.drawing) return // when creating a new marker, the mouse can trigger the mouseover/mouseout event
       // do not listen to them
       this.disableEdit()
     }
   },
 
   _redraw: function () {
-    if (this.datalayer && this.datalayer.isVisible()) {
+    if (this.datalayer?.isVisible()) {
       this._initIcon()
       this.update()
     }
@@ -702,8 +702,8 @@ U.Marker = L.Marker.extend({
   },
 
   _getTooltipAnchor: function () {
-    const anchor = this.options.icon.options.tooltipAnchor.clone(),
-      direction = this.getOption('labelDirection')
+    const anchor = this.options.icon.options.tooltipAnchor.clone()
+    const direction = this.getOption('labelDirection')
     if (direction === 'left') {
       anchor.x *= -1
     } else if (direction === 'bottom') {
@@ -738,22 +738,16 @@ U.Marker = L.Marker.extend({
     return this._latlng
   },
 
-  getClassName: function () {
-    return 'marker'
-  },
+  getClassName: () => 'marker',
 
-  getShapeOptions: function () {
-    return [
-      'properties._umap_options.color',
-      'properties._umap_options.iconClass',
-      'properties._umap_options.iconUrl',
-      'properties._umap_options.iconOpacity',
-    ]
-  },
+  getShapeOptions: () => [
+    'properties._umap_options.color',
+    'properties._umap_options.iconClass',
+    'properties._umap_options.iconUrl',
+    'properties._umap_options.iconOpacity',
+  ],
 
-  getAdvancedOptions: function () {
-    return ['properties._umap_options.zoomTo']
-  },
+  getAdvancedOptions: () => ['properties._umap_options.zoomTo'],
 
   appendEditFieldsets: function (container) {
     U.FeatureMixin.appendEditFieldsets.call(this, container)
@@ -839,21 +833,17 @@ U.PathMixin = {
     'interactive',
   ],
 
-  getShapeOptions: function () {
-    return [
-      'properties._umap_options.color',
-      'properties._umap_options.opacity',
-      'properties._umap_options.weight',
-    ]
-  },
+  getShapeOptions: () => [
+    'properties._umap_options.color',
+    'properties._umap_options.opacity',
+    'properties._umap_options.weight',
+  ],
 
-  getAdvancedOptions: function () {
-    return [
-      'properties._umap_options.smoothFactor',
-      'properties._umap_options.dashArray',
-      'properties._umap_options.zoomTo',
-    ]
-  },
+  getAdvancedOptions: () => [
+    'properties._umap_options.smoothFactor',
+    'properties._umap_options.dashArray',
+    'properties._umap_options.zoomTo',
+  ],
 
   setStyle: function (options) {
     options = options || {}
@@ -868,7 +858,7 @@ U.PathMixin = {
   },
 
   _redraw: function () {
-    if (this.datalayer && this.datalayer.isVisible()) {
+    if (this.datalayer?.isVisible()) {
       this.setStyle()
       this.resetTooltip()
     }
@@ -882,14 +872,14 @@ U.PathMixin = {
     // this.map.on('showmeasure', this.showMeasureTooltip, this);
     // this.map.on('hidemeasure', this.removeTooltip, this);
     this.parentClass.prototype.onAdd.call(this, map)
-    if (this.editing && this.editing.enabled()) this.editing.addHooks()
+    if (this.editing?.enabled()) this.editing.addHooks()
     this.resetTooltip()
   },
 
   onRemove: function (map) {
     // this.map.off('showmeasure', this.showMeasureTooltip, this);
     // this.map.off('hidemeasure', this.removeTooltip, this);
-    if (this.editing && this.editing.enabled()) this.editing.removeHooks()
+    if (this.editing?.enabled()) this.editing.removeHooks()
     U.FeatureMixin.onRemove.call(this, map)
   },
 
@@ -911,7 +901,7 @@ U.PathMixin = {
   },
 
   _onMouseOver: function () {
-    if (this.map.measureTools && this.map.measureTools.enabled()) {
+    if (this.map.measureTools?.enabled()) {
       this.map.tooltip.open({ content: this.getMeasure(), anchor: this })
     } else if (this.map.editEnabled && !this.map.editedFeature) {
       this.map.tooltip.open({ content: L._('Click to edit'), anchor: this })
@@ -1062,13 +1052,9 @@ U.Polyline = L.Polyline.extend({
     mainColor: 'color',
   },
 
-  isSameClass: function (other) {
-    return other instanceof U.Polyline
-  },
+  isSameClass: (other) => other instanceof U.Polyline,
 
-  getClassName: function () {
-    return 'polyline'
-  },
+  getClassName: () => 'polyline',
 
   getMeasure: function (shape) {
     const length = L.GeoUtil.lineLength(this.map, shape || this._defaultShape())
@@ -1161,11 +1147,11 @@ U.Polyline = L.Polyline.extend({
       from.reverse()
       toMerge = [from, to]
     }
-    const a = toMerge[0],
-      b = toMerge[1],
-      p1 = this.map.latLngToContainerPoint(a[a.length - 1]),
-      p2 = this.map.latLngToContainerPoint(b[0]),
-      tolerance = 5 // px on screen
+    const a = toMerge[0]
+    const b = toMerge[1]
+    const p1 = this.map.latLngToContainerPoint(a[a.length - 1])
+    const p2 = this.map.latLngToContainerPoint(b[0])
+    const tolerance = 5 // px on screen
     if (Math.abs(p1.x - p2.x) <= tolerance && Math.abs(p1.y - p2.y) <= tolerance) {
       a.pop()
     }
@@ -1190,8 +1176,8 @@ U.Polyline = L.Polyline.extend({
   },
 
   getVertexActions: function (e) {
-    const actions = U.FeatureMixin.getVertexActions.call(this, e),
-      index = e.vertex.getIndex()
+    const actions = U.FeatureMixin.getVertexActions.call(this, e)
+    const index = e.vertex.getIndex()
     if (index === 0 || index === e.vertex.getLastIndex())
       actions.push(U.ContinueLineAction)
     else actions.push(U.SplitLineAction)
@@ -1206,15 +1192,11 @@ U.Polygon = L.Polygon.extend({
     mainColor: 'fillColor',
   },
 
-  isSameClass: function (other) {
-    return other instanceof U.Polygon
-  },
+  isSameClass: (other) => other instanceof U.Polygon,
 
-  getClassName: function () {
-    return 'polygon'
-  },
+  getClassName: () => 'polygon',
 
-  getShapeOptions: function () {
+  getShapeOptions: () => {
     const options = U.PathMixin.getShapeOptions()
     options.push(
       'properties._umap_options.stroke',
@@ -1225,7 +1207,7 @@ U.Polygon = L.Polygon.extend({
     return options
   },
 
-  getInteractionOptions: function () {
+  getInteractionOptions: () => {
     const options = U.FeatureMixin.getInteractionOptions()
     options.push('properties._umap_options.interactive')
     return options
@@ -1237,8 +1219,8 @@ U.Polygon = L.Polygon.extend({
   },
 
   getContextMenuEditItems: function (e) {
-    const items = U.PathMixin.getContextMenuEditItems.call(this, e),
-      shape = this.shapeAt(e.latlng)
+    const items = U.PathMixin.getContextMenuEditItems.call(this, e)
+    const shape = this.shapeAt(e.latlng)
     // No multi and no holes.
     if (shape && !this.isMulti() && (L.LineUtil.isFlat(shape) || shape.length === 1)) {
       items.push({