umap-project 1.14.0a5__py3-none-any.whl → 2.0.0a0__py3-none-any.whl

umap/static/umap/js/umap.layer.js

@@ -1,5 +1,5 @@
-L.U.Layer = {
-  canBrowse: true,
+U.Layer = {
+  browsable: true,
 
   getType: function () {
     const proto = Object.getPrototypeOf(this)
@@ -26,12 +26,12 @@ L.U.Layer = {
   },
 }
 
-L.U.Layer.Default = L.FeatureGroup.extend({
+U.Layer.Default = L.FeatureGroup.extend({
   statics: {
     NAME: L._('Default'),
     TYPE: 'Default',
   },
-  includes: [L.U.Layer],
+  includes: [U.Layer],
 
   initialize: function (datalayer) {
     this.datalayer = datalayer
@@ -39,7 +39,7 @@ L.U.Layer.Default = L.FeatureGroup.extend({
   },
 })
 
-L.U.MarkerCluster = L.MarkerCluster.extend({
+U.MarkerCluster = L.MarkerCluster.extend({
   // Custom class so we can call computeTextColor
   // when element is already on the DOM.
 
@@ -51,12 +51,12 @@ L.U.MarkerCluster = L.MarkerCluster.extend({
   },
 })
 
-L.U.Layer.Cluster = L.MarkerClusterGroup.extend({
+U.Layer.Cluster = L.MarkerClusterGroup.extend({
   statics: {
     NAME: L._('Clustered'),
     TYPE: 'Cluster',
   },
-  includes: [L.U.Layer],
+  includes: [U.Layer],
 
   initialize: function (datalayer) {
     this.datalayer = datalayer
@@ -65,14 +65,14 @@ L.U.Layer.Cluster = L.MarkerClusterGroup.extend({
         color: this.datalayer.getColor(),
       },
       iconCreateFunction: function (cluster) {
-        return new L.U.Icon.Cluster(datalayer, cluster)
+        return new U.Icon.Cluster(datalayer, cluster)
       },
     }
     if (this.datalayer.options.cluster && this.datalayer.options.cluster.radius) {
       options.maxClusterRadius = this.datalayer.options.cluster.radius
     }
     L.MarkerClusterGroup.prototype.initialize.call(this, options)
-    this._markerCluster = L.U.MarkerCluster
+    this._markerCluster = U.MarkerCluster
     this._layers = []
   },
 
@@ -132,13 +132,12 @@ L.U.Layer.Cluster = L.MarkerClusterGroup.extend({
   },
 })
 
-L.U.Layer.Choropleth = L.FeatureGroup.extend({
+U.Layer.Choropleth = L.FeatureGroup.extend({
   statics: {
     NAME: L._('Choropleth'),
     TYPE: 'Choropleth',
   },
-  includes: [L.U.Layer],
-  canBrowse: true,
+  includes: [U.Layer],
   // Have defaults that better suit the choropleth mode.
   defaults: {
     color: 'white',
@@ -194,6 +193,7 @@ L.U.Layer.Choropleth = L.FeatureGroup.extend({
     let mode = this.datalayer.options.choropleth.mode,
       classes = +this.datalayer.options.choropleth.classes || 5,
       breaks
+    classes = Math.min(classes, values.length)
     if (mode === 'manual') {
       const manualBreaks = this.datalayer.options.choropleth.breaks
       if (manualBreaks) {
@@ -338,13 +338,13 @@ L.U.Layer.Choropleth = L.FeatureGroup.extend({
   },
 })
 
-L.U.Layer.Heat = L.HeatLayer.extend({
+U.Layer.Heat = L.HeatLayer.extend({
   statics: {
     NAME: L._('Heatmap'),
     TYPE: 'Heat',
   },
-  includes: [L.U.Layer],
-  canBrowse: false,
+  includes: [U.Layer],
+  browsable: false,
 
   initialize: function (datalayer) {
     this.datalayer = datalayer
@@ -505,7 +505,7 @@ L.U.Layer.Heat = L.HeatLayer.extend({
   },
 })
 
-L.U.DataLayer = L.Evented.extend({
+U.DataLayer = L.Evented.extend({
   options: {
     displayOnLoad: true,
     inCaption: true,
@@ -579,9 +579,11 @@ L.U.DataLayer = L.Evented.extend({
     }
     this.backupOptions()
     this.connectToMap()
-    this.permissions = new L.U.DataLayerPermissions(this)
-    if (this.showAtLoad()) this.show()
-    if (!this.umap_id) this.isDirty = true
+    this.permissions = new U.DataLayerPermissions(this)
+    if (!this.umap_id) {
+      if (this.showAtLoad()) this.show()
+      this.isDirty = true
+    }
 
     this.onceLoaded(function () {
       this.map.on('moveend', this.onMoveEnd, this)
@@ -646,7 +648,7 @@ L.U.DataLayer = L.Evented.extend({
     if (this.layer) this.layer.clearLayers()
     // delete this.layer?
     if (visible) this.map.removeLayer(this.layer)
-    const Class = L.U.Layer[this.options.type] || L.U.Layer.Default
+    const Class = U.Layer[this.options.type] || U.Layer.Default
     this.layer = new Class(this)
     this.eachLayer(this.showFeature)
     if (visible) this.show()
@@ -661,7 +663,7 @@ L.U.DataLayer = L.Evented.extend({
   },
 
   eachFeature: function (method, context) {
-    if (this.layer && this.layer.canBrowse) {
+    if (this.isBrowsable()) {
       for (let i = 0; i < this._index.length; i++) {
         method.call(context || this, this._layers[this._index[i]])
       }
@@ -669,30 +671,28 @@ L.U.DataLayer = L.Evented.extend({
     return this
   },
 
-  fetchData: function () {
+  fetchData: async function () {
     if (!this.umap_id) return
     if (this._loading) return
     this._loading = true
-    this.map.get(this._dataUrl(), {
-      callback: function (geojson, response) {
-        this._last_modified = response.getResponseHeader('Last-Modified')
-        // FIXME: for now this property is set dynamically from backend
-        // And thus it's not in the geojson file in the server
-        // So do not let all options to be reset
-        // Fix is a proper migration so all datalayers settings are
-        // in DB, and we remove it from geojson flat files.
-        if (geojson._umap_options) {
-          geojson._umap_options.editMode = this.options.editMode
-        }
-        // In case of maps pre 1.0 still around
-        if (geojson._storage) geojson._storage.editMode = this.options.editMode
-        this.fromUmapGeoJSON(geojson)
-        this.backupOptions()
-        this.fire('loaded')
-        this._loading = false
-      },
-      context: this,
-    })
+    const [geojson, response, error] = await this.map.server.get(this._dataUrl())
+    if (!error) {
+      this._last_modified = response.headers.get('last-modified')
+      // FIXME: for now this property is set dynamically from backend
+      // And thus it's not in the geojson file in the server
+      // So do not let all options to be reset
+      // Fix is a proper migration so all datalayers settings are
+      // in DB, and we remove it from geojson flat files.
+      if (geojson._umap_options) {
+        geojson._umap_options.editMode = this.options.editMode
+      }
+      // In case of maps pre 1.0 still around
+      if (geojson._storage) geojson._storage.editMode = this.options.editMode
+      this.fromUmapGeoJSON(geojson)
+      this.backupOptions()
+      this.fire('loaded')
+      this._loading = false
+    }
   },
 
   fromGeoJSON: function (geojson) {
@@ -743,23 +743,27 @@ L.U.DataLayer = L.Evented.extend({
     return !((!isNaN(from) && zoom < from) || (!isNaN(to) && zoom > to))
   },
 
-  fetchRemoteData: function (force) {
+  hasDynamicData: function () {
+    return !!(this.options.remoteData && this.options.remoteData.dynamic)
+  },
+
+  fetchRemoteData: async function (force) {
     if (!this.isRemoteLayer()) return
-    if (!this.options.remoteData.dynamic && this.hasDataLoaded() && !force) return
+    if (!this.hasDynamicData() && this.hasDataLoaded() && !force) return
     if (!this.isVisible()) return
     let url = this.map.localizeUrl(this.options.remoteData.url)
-    if (this.options.remoteData.proxy)
+    if (this.options.remoteData.proxy) {
       url = this.map.proxyUrl(url, this.options.remoteData.ttl)
-    this.map.ajax({
-      uri: url,
-      verb: 'GET',
-      callback: (raw) => {
-        this.clear()
-        this.rawToGeoJSON(raw, this.options.remoteData.format, (geojson) =>
-          this.fromGeoJSON(geojson)
-        )
-      },
-    })
+    }
+    const response = await this.map.request.get(url)
+    if (response && response.ok) {
+      this.clear()
+      this.rawToGeoJSON(
+        await response.text(),
+        this.options.remoteData.format,
+        (geojson) => this.fromGeoJSON(geojson)
+      )
+    }
   },
 
   onceLoaded: function (callback, context) {
@@ -796,7 +800,8 @@ L.U.DataLayer = L.Evented.extend({
   },
 
   setOptions: function (options) {
-    this.options = L.Util.CopyJSON(L.U.DataLayer.prototype.options) // Start from fresh.
+    delete options.geojson
+    this.options = L.Util.CopyJSON(U.DataLayer.prototype.options) // Start from fresh.
     this.updateOptions(options)
   },
 
@@ -924,7 +929,7 @@ L.U.DataLayer = L.Evented.extend({
               })
             }
             this.map.ui.alert({ content: message, level: 'error', duration: 10000 })
-            console.log(err)
+            console.error(err)
           }
           if (result && result.features.length) {
             callback(result)
@@ -1022,11 +1027,11 @@ L.U.DataLayer = L.Evented.extend({
   },
 
   _pointToLayer: function (geojson, latlng) {
-    return new L.U.Marker(this.map, latlng, { geojson: geojson, datalayer: this })
+    return new U.Marker(this.map, latlng, { geojson: geojson, datalayer: this })
   },
 
   _lineToLayer: function (geojson, latlngs) {
-    return new L.U.Polyline(this.map, latlngs, {
+    return new U.Polyline(this.map, latlngs, {
       geojson: geojson,
       datalayer: this,
       color: null,
@@ -1038,7 +1043,7 @@ L.U.DataLayer = L.Evented.extend({
     // for (let i = latlngs.length - 1; i > 0; i--) {
     //     if (!latlngs.slice()[i].length) latlngs.splice(i, 1);
     // }
-    return new L.U.Polygon(this.map, latlngs, { geojson: geojson, datalayer: this })
+    return new U.Polygon(this.map, latlngs, { geojson: geojson, datalayer: this })
   },
 
   importRaw: function (raw, type) {
@@ -1060,13 +1065,12 @@ L.U.DataLayer = L.Evented.extend({
     reader.onload = (e) => this.importRaw(e.target.result, type)
   },
 
-  importFromUrl: function (url, type) {
-    url = this.map.localizeUrl(url)
-    this.map.xhr._ajax({
-      verb: 'GET',
-      uri: url,
-      callback: (data) => this.importRaw(data, type),
-    })
+  importFromUrl: async function (uri, type) {
+    uri = this.map.localizeUrl(uri)
+    const response = await this.map.request.get(uri)
+    if (response && response.ok) {
+      this.importRaw(await response.text(), type)
+    }
   },
 
   getColor: function () {
@@ -1182,7 +1186,7 @@ L.U.DataLayer = L.Evented.extend({
         ],
       ]
     const title = L.DomUtil.add('h3', '', container, L._('Layer properties'))
-    let builder = new L.U.FormBuilder(this, metadataFields, {
+    let builder = new U.FormBuilder(this, metadataFields, {
       callback: function (e) {
         this.map.updateDatalayersControl()
         if (e.helper.field === 'options.type') {
@@ -1204,7 +1208,7 @@ L.U.DataLayer = L.Evented.extend({
     const layerOptions = this.layer.getEditableOptions()
 
     if (layerOptions.length) {
-      builder = new L.U.FormBuilder(this, layerOptions, {
+      builder = new U.FormBuilder(this, layerOptions, {
         id: 'datalayer-layer-properties',
         callback: redrawCallback,
       })
@@ -1228,7 +1232,7 @@ L.U.DataLayer = L.Evented.extend({
       'options.fillOpacity',
     ]
 
-    builder = new L.U.FormBuilder(this, shapeOptions, {
+    builder = new U.FormBuilder(this, shapeOptions, {
       id: 'datalayer-advanced-properties',
       callback: redrawCallback,
     })
@@ -1244,7 +1248,7 @@ L.U.DataLayer = L.Evented.extend({
       'options.labelKey',
     ]
 
-    builder = new L.U.FormBuilder(this, optionsFields, {
+    builder = new U.FormBuilder(this, optionsFields, {
       id: 'datalayer-advanced-properties',
       callback: redrawCallback,
     })
@@ -1264,7 +1268,7 @@ L.U.DataLayer = L.Evented.extend({
       'options.outlinkTarget',
       'options.interactive',
     ]
-    builder = new L.U.FormBuilder(this, popupFields, { callback: redrawCallback })
+    builder = new U.FormBuilder(this, popupFields, { callback: redrawCallback })
     const popupFieldset = L.DomUtil.createFieldset(
       container,
       L._('Interaction options')
@@ -1310,7 +1314,7 @@ L.U.DataLayer = L.Evented.extend({
     }
 
     const remoteDataContainer = L.DomUtil.createFieldset(container, L._('Remote data'))
-    builder = new L.U.FormBuilder(this, remoteDataFields)
+    builder = new U.FormBuilder(this, remoteDataFields)
     remoteDataContainer.appendChild(builder.build())
     L.DomUtil.createButton(
       'button umap-verify',
@@ -1383,8 +1387,8 @@ L.U.DataLayer = L.Evented.extend({
     }
   },
 
-  buildVersionsFieldset: function (container) {
-    const appendVersion = function (data) {
+  buildVersionsFieldset: async function (container) {
+    const appendVersion = (data) => {
       const date = new Date(parseInt(data.at, 10))
       const content = `${date.toLocaleString(L.lang)} (${parseInt(data.size) / 1000}Kb)`
       const el = L.DomUtil.create('div', 'umap-datalayer-version', versionsContainer)
@@ -1400,34 +1404,30 @@ L.U.DataLayer = L.Evented.extend({
     }
 
     const versionsContainer = L.DomUtil.createFieldset(container, L._('Versions'), {
-      callback: function () {
-        this.map.xhr.get(this.getVersionsUrl(), {
-          callback: function (data) {
-            for (let i = 0; i < data.versions.length; i++) {
-              appendVersion.call(this, data.versions[i])
-            }
-          },
-          context: this,
-        })
+      callback: async function () {
+        const [{ versions }, response, error] = await this.map.server.get(
+          this.getVersionsUrl()
+        )
+        if (!error) versions.forEach(appendVersion)
       },
       context: this,
     })
   },
 
-  restore: function (version) {
+  restore: async function (version) {
     if (!this.map.editEnabled) return
     if (!confirm(L._('Are you sure you want to restore this version?'))) return
-    this.map.xhr.get(this.getVersionUrl(version), {
-      callback: function (geojson) {
-        if (geojson._storage) geojson._umap_options = geojson._storage // Retrocompat.
-        if (geojson._umap_options) this.setOptions(geojson._umap_options)
-        this.empty()
-        if (this.isRemoteLayer()) this.fetchRemoteData()
-        else this.addData(geojson)
-        this.isDirty = true
-      },
-      context: this,
-    })
+    const [geojson, response, error] = await this.map.server.get(
+      this.getVersionUrl(version)
+    )
+    if (!error) {
+      if (geojson._storage) geojson._umap_options = geojson._storage // Retrocompat.
+      if (geojson._umap_options) this.setOptions(geojson._umap_options)
+      this.empty()
+      if (this.isRemoteLayer()) this.fetchRemoteData()
+      else this.addData(geojson)
+      this.isDirty = true
+    }
   },
 
   featuresToGeoJSON: function () {
@@ -1436,9 +1436,9 @@ L.U.DataLayer = L.Evented.extend({
     return features
   },
 
-  show: function () {
-    if (!this.isLoaded()) this.fetchData()
+  show: async function () {
     this.map.addLayer(this.layer)
+    if (!this.isLoaded()) await this.fetchData()
     this.fire('show')
   },
 
@@ -1461,8 +1461,22 @@ L.U.DataLayer = L.Evented.extend({
     if (bounds.isValid()) this.map.fitBounds(bounds)
   },
 
+  // Is this layer type browsable in theorie
+  isBrowsable: function () {
+    return this.layer && this.layer.browsable
+  },
+
+  // Is this layer browsable in theorie
+  // AND the user allows it
   allowBrowse: function () {
-    return !!this.options.browsable && this.canBrowse() && this.isVisible()
+    return !!this.options.browsable && this.isBrowsable()
+  },
+
+  // Is this layer browsable in theorie
+  // AND the user allows it
+  // AND it makes actually sense (is visible, it has data…)
+  canBrowse: function () {
+    return this.allowBrowse() && this.isVisible() && this.hasData()
   },
 
   count: function () {
@@ -1477,10 +1491,6 @@ L.U.DataLayer = L.Evented.extend({
     return this.layer && this.map.hasLayer(this.layer)
   },
 
-  canBrowse: function () {
-    return this.layer && this.layer.canBrowse
-  },
-
   getFeatureByIndex: function (index) {
     if (index === -1) index = this._index.length - 1
     const id = this._index[index]
@@ -1509,7 +1519,7 @@ L.U.DataLayer = L.Evented.extend({
     let next
     const index = this.map.datalayers_index
     while (((id = index[++id] ? id : 0), (next = index[id]))) {
-      if (next === this || (next.allowBrowse() && next.hasData())) break
+      if (next === this || next.canBrowse()) break
     }
     return next
   },
@@ -1519,7 +1529,7 @@ L.U.DataLayer = L.Evented.extend({
     let prev
     const index = this.map.datalayers_index
     while (((id = index[--id] ? id : index.length - 1), (prev = index[id]))) {
-      if (prev === this || (prev.allowBrowse() && prev.hasData())) break
+      if (prev === this || prev.canBrowse()) break
     }
     return prev
   },
@@ -1546,7 +1556,7 @@ L.U.DataLayer = L.Evented.extend({
     return this.isReadOnly() || this.isRemoteLayer()
   },
 
-  save: function () {
+  save: async function () {
     if (this.isDeleted) return this.saveDelete()
     if (!this.isLoaded()) {
       return
@@ -1564,44 +1574,66 @@ L.U.DataLayer = L.Evented.extend({
       map_id: this.map.options.umap_id,
       pk: this.umap_id,
     })
-    this.map.post(saveUrl, {
-      data: formData,
-      callback: function (data, response) {
-        // Response contains geojson only if save has conflicted and conflicts have
-        // been resolved. So we need to reload to get extra data (saved from someone else)
-        if (data.geojson) {
-          this.clear()
-          this.fromGeoJSON(data.geojson)
-          delete data.geojson
-        }
-        this._geojson = geojson
-        this._last_modified = response.getResponseHeader('Last-Modified')
-        this.setUmapId(data.id)
-        this.updateOptions(data)
-        this.backupOptions()
-        this.connectToMap()
-        this._loaded = true
-        this.redraw() // Needed for reordering features
-        this.isDirty = false
-        this.permissions.save()
-      },
-      context: this,
-      headers: this._last_modified
-        ? { 'If-Unmodified-Since': this._last_modified }
-        : {},
-    })
+    const headers = this._last_modified
+      ? { 'If-Unmodified-Since': this._last_modified }
+      : {}
+    await this._trySave(saveUrl, headers, formData)
+    this._geojson = geojson
   },
 
-  saveDelete: function () {
-    const callback = function () {
+  _trySave: async function (url, headers, formData) {
+    const [data, response, error] = await this.map.server.post(url, headers, formData)
+    if (error) {
+      if (response && response.status === 412) {
+        const msg = L._(
+          'Woops! Someone else seems to have edited the data. You can save anyway, but this will erase the changes made by others.'
+        )
+        const actions = [
+          {
+            label: L._('Save anyway'),
+            callback: async () => {
+              // Save again,
+              // but do not pass If-Unmodified-Since this time
+              await this._trySave(url, {}, formData)
+            },
+          },
+          {
+            label: L._('Cancel'),
+          },
+        ]
+        this.map.ui.alert({
+          content: msg,
+          level: 'error',
+          duration: 100000,
+          actions: actions,
+        })
+      }
+    } else {
+      // Response contains geojson only if save has conflicted and conflicts have
+      // been resolved. So we need to reload to get extra data (added by someone else)
+      if (data.geojson) {
+        this.clear()
+        this.fromGeoJSON(data.geojson)
+        delete data.geojson
+      }
+      this._last_modified = response.headers.get('last-modified')
+      this.setUmapId(data.id)
+      this.updateOptions(data)
+      this.backupOptions()
+      this.connectToMap()
+      this._loaded = true
+      this.redraw() // Needed for reordering features
       this.isDirty = false
-      this.map.continueSaving()
+      this.permissions.save()
     }
-    if (!this.umap_id) return callback.call(this)
-    this.map.xhr.post(this.getDeleteUrl(), {
-      callback: callback,
-      context: this,
-    })
+  },
+
+  saveDelete: async function () {
+    if (this.umap_id) {
+      await this.map.server.post(this.getDeleteUrl())
+    }
+    this.isDirty = false
+    this.map.continueSaving()
   },
 
   getMap: function () {
@@ -1614,7 +1646,7 @@ L.U.DataLayer = L.Evented.extend({
 
   tableEdit: function () {
     if (this.isRemoteLayer() || !this.isVisible()) return
-    const editor = new L.U.TableEditor(this)
+    const editor = new U.TableEditor(this)
     editor.edit()
   },
 })

umap/static/umap/js/umap.permissions.js

@@ -1,6 +1,6 @@
 // Dedicated object so we can deal with a separate dirty status, and thus
 // call the endpoint only when needed, saving one call at each save.
-L.U.MapPermissions = L.Class.extend({
+U.MapPermissions = L.Class.extend({
   options: {
     owner: null,
     editors: [],
@@ -105,7 +105,7 @@ L.U.MapPermissions = L.Class.extend({
       ])
     }
     title.textContent = L._('Update permissions')
-    const builder = new L.U.FormBuilder(this, fields)
+    const builder = new U.FormBuilder(this, fields)
     const form = builder.build()
     container.appendChild(form)
     if (this.isAnonymousMap() && this.map.options.user) {
@@ -131,21 +131,19 @@ L.U.MapPermissions = L.Class.extend({
     this.map.ui.openPanel({ data: { html: container }, className: 'dark' })
   },
 
-  attach: function () {
-    this.map.post(this.getAttachUrl(), {
-      callback: function () {
-        this.options.owner = this.map.options.user
-        this.map.ui.alert({
-          content: L._('Map has been attached to your account'),
-          level: 'info',
-        })
-        this.map.ui.closePanel()
-      },
-      context: this,
-    })
+  attach: async function () {
+    const [data, response, error] = await this.map.server.post(this.getAttachUrl())
+    if (!error) {
+      this.options.owner = this.map.options.user
+      this.map.ui.alert({
+        content: L._('Map has been attached to your account'),
+        level: 'info',
+      })
+      this.map.ui.closePanel()
+    }
   },
 
-  save: function () {
+  save: async function () {
     if (!this.isDirty) return this.map.continueSaving()
     const formData = new FormData()
     if (!this.isAnonymousMap() && this.options.editors) {
@@ -159,16 +157,17 @@ L.U.MapPermissions = L.Class.extend({
       formData.append('owner', this.options.owner && this.options.owner.id)
       formData.append('share_status', this.options.share_status)
     }
-    this.map.post(this.getUrl(), {
-      data: formData,
-      context: this,
-      callback: function (data) {
-        this.commit()
-        this.isDirty = false
-        this.map.continueSaving()
-        this.map.fire('postsync')
-      },
-    })
+    const [data, response, error] = await this.map.server.post(
+      this.getUrl(),
+      {},
+      formData
+    )
+    if (!error) {
+      this.commit()
+      this.isDirty = false
+      this.map.continueSaving()
+      this.map.fire('postsync')
+    }
   },
 
   getUrl: function () {