umap-project 2.5.0__py3-none-any.whl → 2.6.0__py3-none-any.whl

umap/static/umap/js/umap.controls.js

@@ -142,7 +142,7 @@ U.AddPolylineShapeAction = U.BaseAction.extend({
   },
 
   addHooks: function () {
-    this.map.editedFeature.editor.newShape()
+    this.map.editedFeature.ui.editor.newShape()
   },
 })
 
@@ -182,8 +182,8 @@ U.CreateHoleAction = U.BaseFeatureAction.extend({
     },
   },
 
-  onClick: function (e) {
-    this.feature.startHole(e)
+  onClick: function (event) {
+    this.feature.ui.startHole(event)
   },
 })
 
@@ -195,11 +195,11 @@ U.ToggleEditAction = U.BaseFeatureAction.extend({
     },
   },
 
-  onClick: function (e) {
+  onClick: function (event) {
     if (this.feature._toggleEditing) {
-      this.feature._toggleEditing(e) // Path
+      this.feature._toggleEditing(event) // Path
     } else {
-      this.feature.edit(e) // Marker
+      this.feature.edit(event) // Marker
     }
   },
 })
@@ -244,7 +244,7 @@ U.ExtractShapeFromMultiAction = U.BaseFeatureAction.extend({
   },
 
   onClick: function (e) {
-    this.feature.isolateShape(e.latlng)
+    this.feature.ui.isolateShape(e.latlng)
   },
 })
 
@@ -310,7 +310,7 @@ U.DrawToolbar = L.Toolbar.Control.extend({
     }
     if (this.map.options.enablePolylineDraw) {
       this.options.actions.push(U.DrawPolylineAction)
-      if (this.map.editedFeature && this.map.editedFeature instanceof U.Polyline) {
+      if (this.map.editedFeature && this.map.editedFeature instanceof U.LineString) {
         this.options.actions.push(U.AddPolylineShapeAction)
       }
     }
@@ -562,107 +562,6 @@ L.Control.Embed = L.Control.Button.extend({
   },
 })
 
-U.DataLayer.include({
-  renderLegend: function (container) {
-    if (this.layer.renderLegend) return this.layer.renderLegend(container)
-    const color = L.DomUtil.create('span', 'datalayer-color', container)
-    color.style.backgroundColor = this.getColor()
-  },
-
-  renderToolbox: function (container) {
-    const toggle = L.DomUtil.createButtonIcon(
-      container,
-      'icon-eye',
-      L._('Show/hide layer')
-    )
-    const zoomTo = L.DomUtil.createButtonIcon(
-      container,
-      'icon-zoom',
-      L._('Zoom to layer extent')
-    )
-    const edit = L.DomUtil.createButtonIcon(
-      container,
-      'icon-edit show-on-edit',
-      L._('Edit')
-    )
-    const table = L.DomUtil.createButtonIcon(
-      container,
-      'icon-table show-on-edit',
-      L._('Edit properties in a table')
-    )
-    const remove = L.DomUtil.createButtonIcon(
-      container,
-      'icon-delete show-on-edit',
-      L._('Delete layer')
-    )
-    if (this.isReadOnly()) {
-      L.DomUtil.addClass(container, 'readonly')
-    } else {
-      L.DomEvent.on(edit, 'click', this.edit, this)
-      L.DomEvent.on(table, 'click', this.tableEdit, this)
-      L.DomEvent.on(
-        remove,
-        'click',
-        function () {
-          if (!this.isVisible()) return
-          if (!confirm(L._('Are you sure you want to delete this layer?'))) return
-          this._delete()
-        },
-        this
-      )
-    }
-    L.DomEvent.on(toggle, 'click', this.toggle, this)
-    L.DomEvent.on(zoomTo, 'click', this.zoomTo, this)
-    container.classList.add(this.getHidableClass())
-    container.classList.toggle('off', !this.isVisible())
-  },
-
-  getHidableElements: function () {
-    return document.querySelectorAll(`.${this.getHidableClass()}`)
-  },
-
-  getHidableClass: function () {
-    return `show_with_datalayer_${L.stamp(this)}`
-  },
-
-  propagateDelete: function () {
-    const els = this.getHidableElements()
-    for (const el of els) {
-      L.DomUtil.remove(el)
-    }
-  },
-
-  propagateRemote: function () {
-    const els = this.getHidableElements()
-    for (const el of els) {
-      el.classList.toggle('remotelayer', this.isRemoteLayer())
-    }
-  },
-
-  propagateHide: function () {
-    const els = this.getHidableElements()
-    for (let i = 0; i < els.length; i++) {
-      L.DomUtil.addClass(els[i], 'off')
-    }
-  },
-
-  propagateShow: function () {
-    this.onceLoaded(function () {
-      const els = this.getHidableElements()
-      for (let i = 0; i < els.length; i++) {
-        L.DomUtil.removeClass(els[i], 'off')
-      }
-    }, this)
-  },
-})
-
-U.DataLayer.addInitHook(function () {
-  this.on('hide', this.propagateHide)
-  this.on('show', this.propagateShow)
-  this.on('erase', this.propagateDelete)
-  if (this.isVisible()) this.propagateShow()
-})
-
 const ControlsMixin = {
   HIDDABLE_CONTROLS: [
     'zoom',
@@ -741,7 +640,7 @@ const ControlsMixin = {
       L.DomEvent.on(shareStatusButton, 'click', this.permissions.edit, this.permissions)
     }
     this.on('postsync', L.bind(update, this))
-    if (this.options.user) {
+    if (this.options.user?.id) {
       L.DomUtil.createLink(
         'umap-user',
         rightContainer,
@@ -864,6 +763,7 @@ const ControlsMixin = {
 U.TileLayerControl = L.Control.IconLayers.extend({
   initialize: function (map, options) {
     this.map = map
+    this.maxShown = 9
     L.Control.IconLayers.prototype.initialize.call(this, {
       position: 'topleft',
       manageLayers: false,
@@ -895,10 +795,27 @@ U.TileLayerControl = L.Control.IconLayers.extend({
         }
       })
     }
-    const maxShown = 10
-    L.Control.IconLayers.prototype.setLayers.call(this, layers.slice(0, maxShown))
+    this._allLayers = layers
+    L.Control.IconLayers.prototype.setLayers.call(this, layers.slice(0, this.maxShown))
     if (this.map.selected_tilelayer) this.setActiveLayer(this.map.selected_tilelayer)
   },
+
+  _createLayerElements: function () {
+    L.Control.IconLayers.prototype._createLayerElements.call(this)
+    if (Object.keys(this._allLayers).length <= this.maxShown) return
+    const lastRow = this._container.querySelector(
+      '.leaflet-iconLayers-layersRow:last-child'
+    )
+    const button = L.DomUtil.element({
+      tagName: 'button',
+      className: 'leaflet-iconLayers-layerCell leaflet-iconLayers-layerCell-plus button',
+      textContent: '+',
+      parent: lastRow,
+    })
+    L.DomEvent.on(button, 'click', () =>
+      this.map._controls.tilelayersChooser.openSwitcher()
+    )
+  },
 })
 
 /* Used in edit mode to define the default tilelayer */
@@ -907,7 +824,7 @@ U.TileLayerChooser = L.Control.extend({
     position: 'topleft',
   },
 
-  initialize: function (map, options) {
+  initialize: function (map, options = {}) {
     this.map = map
     L.Control.prototype.initialize.call(this, options)
   },
@@ -925,15 +842,13 @@ U.TileLayerChooser = L.Control.extend({
     return container
   },
 
-  openSwitcher: function (options) {
+  openSwitcher: function (options = {}) {
     const container = L.DomUtil.create('div', 'umap-tilelayer-switcher-container')
     L.DomUtil.createTitle(container, L._('Change tilelayers'), 'icon-tilelayer')
     this._tilelayers_container = L.DomUtil.create('ul', '', container)
     this.buildList(options)
-    this.map.editPanel.open({
-      content: container,
-      className: options.className,
-    })
+    const panel = options.edit ? this.map.editPanel : this.map.panel
+    panel.open({ content: container })
   },
 
   buildList: function (options) {
@@ -1123,7 +1038,7 @@ U.Search = L.PhotonSearch.extend({
     L.DomEvent.on(edit, 'mousedown', (e) => {
       L.DomEvent.stop(e)
       const datalayer = this.map.defaultEditDataLayer()
-      const layer = datalayer.geojsonToFeatures(feature)
+      const layer = datalayer.makeFeature(feature)
       layer.isDirty = true
       layer.edit()
     })
@@ -1246,56 +1161,71 @@ U.Editable = L.Editable.extend({
   initialize: function (map, options) {
     L.Editable.prototype.initialize.call(this, map, options)
     this.on('editable:drawing:click editable:drawing:move', this.drawingTooltip)
-    this.on('editable:drawing:end', (e) => {
+    this.on('editable:drawing:end', (event) => {
       this.map.tooltip.close()
       // Leaflet.Editable will delete the drawn shape if invalid
       // (eg. line has only one drawn point)
       // So let's check if the layer has no more shape
-      if (!e.layer.hasGeom()) e.layer.del()
-      else e.layer.edit()
+      if (!event.layer.feature.hasGeom()) {
+        event.layer.feature.del()
+      } else {
+        event.layer.feature.edit()
+      }
     })
     // Layer for items added by users
-    this.on('editable:drawing:cancel', (e) => {
-      if (e.layer instanceof U.Marker) e.layer.del()
+    this.on('editable:drawing:cancel', (event) => {
+      if (event.layer instanceof U.LeafletMarker) event.layer.feature.del()
     })
-    this.on('editable:drawing:commit', function (e) {
-      e.layer.isDirty = true
-      if (this.map.editedFeature !== e.layer) e.layer.edit(e)
+    this.on('editable:drawing:commit', function (event) {
+      event.layer.feature.isDirty = true
+      if (this.map.editedFeature !== event.layer) event.layer.feature.edit(event)
     })
-    this.on('editable:editing', (e) => {
-      const layer = e.layer
-      layer.isDirty = true
-      if (layer._tooltip && layer.isTooltipOpen()) {
-        layer._tooltip.setLatLng(layer.getCenter())
-        layer._tooltip.update()
-      }
+    this.on('editable:editing', (event) => {
+      const layer = event.layer
+      layer.feature.isDirty = true
+      layer.feature.fromLatLngs(layer.getLatLngs())
     })
-    this.on('editable:vertex:ctrlclick', (e) => {
-      const index = e.vertex.getIndex()
-      if (index === 0 || (index === e.vertex.getLastIndex() && e.vertex.continue))
-        e.vertex.continue()
+    this.on('editable:vertex:ctrlclick', (event) => {
+      const index = event.vertex.getIndex()
+      if (
+        index === 0 ||
+        (index === event.vertex.getLastIndex() && event.vertex.continue)
+      )
+        event.vertex.continue()
     })
-    this.on('editable:vertex:altclick', (e) => {
-      if (e.vertex.editor.vertexCanBeDeleted(e.vertex)) e.vertex.delete()
+    this.on('editable:vertex:altclick', (event) => {
+      if (event.vertex.editor.vertexCanBeDeleted(event.vertex)) event.vertex.delete()
     })
     this.on('editable:vertex:rawclick', this.onVertexRawClick)
   },
 
   createPolyline: function (latlngs) {
-    return new U.Polyline(this.map, latlngs, this._getDefaultProperties())
+    const datalayer = this.map.defaultEditDataLayer()
+    const point = new U.LineString(datalayer, {
+      geometry: { type: 'LineString', coordinates: [] },
+    })
+    return point.ui
   },
 
   createPolygon: function (latlngs) {
-    return new U.Polygon(this.map, latlngs, this._getDefaultProperties())
+    const datalayer = this.map.defaultEditDataLayer()
+    const point = new U.Polygon(datalayer, {
+      geometry: { type: 'Polygon', coordinates: [] },
+    })
+    return point.ui
   },
 
   createMarker: function (latlng) {
-    return new U.Marker(this.map, latlng, this._getDefaultProperties())
+    const datalayer = this.map.defaultEditDataLayer()
+    const point = new U.Point(datalayer, {
+      geometry: { type: 'Point', coordinates: [latlng.lng, latlng.lat] },
+    })
+    return point.ui
   },
 
   _getDefaultProperties: function () {
     const result = {}
-    if (this.map.options.featuresHaveOwner && this.map.options.hasOwnProperty('user')) {
+    if (this.map.options.featuresHaveOwner?.user) {
       result.geojson = { properties: { owner: this.map.options.user.id } }
     }
     return result
@@ -1304,7 +1234,7 @@ U.Editable = L.Editable.extend({
   connectCreatedToMap: function (layer) {
     // Overrided from Leaflet.Editable
     const datalayer = this.map.defaultEditDataLayer()
-    datalayer.addLayer(layer)
+    datalayer.addFeature(layer.feature)
     layer.isDirty = true
     return layer
   },
@@ -1331,7 +1261,11 @@ U.Editable = L.Editable.extend({
         }
       } else {
         const tmpLatLngs = e.layer.editor._drawnLatLngs.slice()
-        tmpLatLngs.push(e.latlng)
+        if (e.layer.editor._drawing === L.Editable.BACKWARD) {
+          tmpLatLngs.unshift(e.latlng)
+        } else {
+          tmpLatLngs.push(e.latlng)
+        }
         measure = e.layer.getMeasure(tmpLatLngs)
 
         if (e.layer.editor._drawnLatLngs.length < e.layer.editor.MIN_VERTEX) {

umap/static/umap/js/umap.core.js

@@ -128,13 +128,17 @@ L.DomUtil.createIcon = (parent, className, title, size = 16) => {
   })
 }
 
-L.DomUtil.createButtonIcon = (parent, className, title, size = 16) => {
-  return L.DomUtil.element({
+L.DomUtil.createButtonIcon = (parent, className, title, callback, size = 16) => {
+  const el = L.DomUtil.element({
     tagName: 'button',
     parent: parent,
     className: `icon icon-${size} ${className}`,
     title: title || '',
   })
+  if (callback) {
+    L.DomEvent.on(el, 'click', L.DomEvent.stop).on(el, 'click', callback)
+  }
+  return el
 }
 
 L.DomUtil.createTitle = (parent, text, className, tag = 'h3') => {
@@ -151,14 +155,10 @@ L.DomUtil.createCopiableInput = (parent, label, value) => {
   input.type = 'text'
   input.readOnly = true
   input.value = value
-  const button = L.DomUtil.createButton(
-    '',
-    wrapper,
-    '',
-    () => L.Util.copyToClipboard(input.value),
-    this
+  const button = L.DomUtil.createButtonIcon(wrapper, 'icon-copy', L._('copy'), () =>
+    L.Util.copyToClipboard(input.value)
   )
-  button.title = L._('copy')
+  button.type = 'button'
   return input
 }
 

umap/static/umap/js/umap.forms.js

@@ -220,9 +220,9 @@ L.FormBuilder.Element.include({
     if (this.options.label) {
       this.label = L.DomUtil.create('label', '', this.getLabelParent())
       this.label.textContent = this.label.title = this.options.label
-      if (this.options.helpEntries)
+      if (this.options.helpEntries) {
         this.builder.map.help.button(this.label, this.options.helpEntries)
-      else if (this.options.helpTooltip) {
+      } else if (this.options.helpTooltip) {
         const info = L.DomUtil.create('i', 'info', this.label)
         L.DomEvent.on(
           info,
@@ -342,14 +342,7 @@ L.FormBuilder.TextColorPicker = L.FormBuilder.ColorPicker.extend({
 
 L.FormBuilder.LayerTypeChooser = L.FormBuilder.Select.extend({
   getOptions: () => {
-    const layer_classes = [
-      U.Layer.Default,
-      U.Layer.Cluster,
-      U.Layer.Heat,
-      U.Layer.Choropleth,
-      U.Layer.Categorized,
-    ]
-    return layer_classes.map((class_) => [class_.TYPE, class_.NAME])
+    return U.LAYER_TYPES.map((class_) => [class_.TYPE, class_.NAME])
   },
 })
 
@@ -557,7 +550,7 @@ L.FormBuilder.IconUrl = L.FormBuilder.BlurInput.extend({
       // Do not try to render URL with variables
       const box = L.DomUtil.create('div', 'umap-pictogram-choice', this.buttons)
       L.DomEvent.on(box, 'click', this.onDefine, this)
-      const icon = U.Icon.makeIconElement(this.value(), box)
+      const icon = U.Icon.makeElement(this.value(), box)
     }
     this.button = L.DomUtil.createButton(
       'button action-button',
@@ -578,7 +571,7 @@ L.FormBuilder.IconUrl = L.FormBuilder.BlurInput.extend({
     if (search && U.Utils.normalize(title).indexOf(search) === -1) return
     const className = value === this.value() ? `${baseClass} selected` : baseClass
     const container = L.DomUtil.create('div', className, parent)
-    U.Icon.makeIconElement(value, container)
+    U.Icon.makeElement(value, container)
     container.title = title
     L.DomEvent.on(
       container,
@@ -909,8 +902,8 @@ L.FormBuilder.MultiChoice = L.FormBuilder.Element.extend({
     if (!this.container.querySelector(`input[type="radio"][value="${value}"]`)) {
       value = this.options.default !== undefined ? this.options.default : this.default
     }
-    const choices = this.getChoices().map(([value, label]) => value)
-    if (choices.includes(value)) {
+    const choices = this.getChoices().map(([value, label]) => `${value}`)
+    if (choices.includes(`${value}`)) {
       this.container.querySelector(`input[type="radio"][value="${value}"]`).checked =
         true
     }
@@ -932,8 +925,8 @@ L.FormBuilder.MultiChoice = L.FormBuilder.Element.extend({
       `${this.className} by${choices.length}`,
       this.parentNode
     )
-    for (let i = 0; i < choices.length; i++) {
-      this.addChoice(choices[i][0], choices[i][1], i)
+    for (const [i, [value, label]] of choices.entries()) {
+      this.addChoice(value, label, i)
     }
     this.fetch()
   },
@@ -965,8 +958,12 @@ L.FormBuilder.TernaryChoices = L.FormBuilder.MultiChoice.extend({
       case false:
         value = false
         break
-      default:
+      case 'null':
+      case null:
         value = null
+        break
+      default:
+        value = undefined
     }
     return value
   },
@@ -1093,11 +1090,35 @@ L.FormBuilder.ManageEditors = L.FormBuilder.Element.extend({
   },
 })
 
+L.FormBuilder.ManageTeam = L.FormBuilder.IntSelect.extend({
+  getOptions: function () {
+    return [[null, L._('None')]].concat(
+      this.options.teams.map((team) => [team.id, team.name])
+    )
+  },
+  toHTML: function () {
+    return this.get()?.id
+  },
+  toJS: function () {
+    const value = this.value()
+    for (const team of this.options.teams) {
+      if (team.id === value) return team
+    }
+  },
+})
+
 U.FormBuilder = L.FormBuilder.extend({
   options: {
     className: 'umap-form',
   },
 
+  customHandlers: {
+    sortKey: 'BlurInput',
+    easing: 'Switch',
+    facetKey: 'BlurInput',
+    slugKey: 'BlurInput',
+  },
+
   computeDefaultOptions: function () {
     for (const [key, schema] of Object.entries(U.SCHEMA)) {
       if (schema.type === Boolean) {
@@ -1135,6 +1156,9 @@ U.FormBuilder = L.FormBuilder.extend({
             break
         }
       }
+      if (this.customHandlers[key]) {
+        schema.handler = this.customHandlers[key]
+      }
       // FormBuilder use this key for the input type itself
       delete schema.type
       this.defaultOptions[key] = schema