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

umap/static/umap/js/umap.js

@@ -34,7 +34,7 @@ L.Map.mergeOptions({
   // we cannot rely on this because of the y is overriden by Leaflet
   // See https://github.com/Leaflet/Leaflet/pull/9201
   // And let's remove this -y when this PR is merged and released.
-  demoTileInfos: { s: 'a', z: 9, x: 265, y: 181, '-y': 181, r: '' },
+  demoTileInfos: { 's': 'a', 'z': 9, 'x': 265, 'y': 181, '-y': 181, 'r': '' },
   licences: [],
   licence: '',
   enableMarkerDraw: true,
@@ -55,19 +55,66 @@ L.Map.mergeOptions({
   featuresHaveOwner: false,
 })
 
-L.U.Map.include({
-  HIDDABLE_CONTROLS: [
-    'zoom',
-    'search',
-    'fullscreen',
-    'embed',
-    'locate',
-    'measure',
-    'editinosm',
-    'datalayers',
-    'star',
-    'tilelayers',
-  ],
+U.Map = L.Map.extend({
+  includes: [ControlsMixin],
+  editableOptions: {
+    'zoom': undefined,
+    'scrollWheelZoom': Boolean,
+    'scaleControl': Boolean,
+    'moreControl': Boolean,
+    'miniMap': Boolean,
+    'displayPopupFooter': undefined,
+    'onLoadPanel': String,
+    'defaultView': String,
+    'name': String,
+    'description': String,
+    'licence': undefined,
+    'tilelayer': undefined,
+    'overlay': undefined,
+    'limitBounds': undefined,
+    'color': String,
+    'iconClass': String,
+    'iconUrl': String,
+    'smoothFactor': undefined,
+    'iconOpacity': undefined,
+    'opacity': undefined,
+    'weight': undefined,
+    'fill': undefined,
+    'fillColor': undefined,
+    'fillOpacity': undefined,
+    'dashArray': undefined,
+    'popupShape': String,
+    'popupTemplate': String,
+    'popupContentTemplate': String,
+    'zoomTo': undefined,
+    'captionBar': Boolean,
+    'captionMenus': Boolean,
+    'slideshow': undefined,
+    'sortKey': undefined,
+    'labelKey': undefined,
+    'filterKey': undefined,
+    'facetKey': undefined,
+    'slugKey': undefined,
+    'showLabel': undefined,
+    'labelDirection': undefined,
+    'labelInteractive': undefined,
+    'outlinkTarget': undefined,
+    'shortCredit': undefined,
+    'longCredit': undefined,
+    'permanentCredit': undefined,
+    'permanentCreditBackground': undefined,
+    'zoomControl': 'NullableBoolean',
+    'datalayersControl': 'NullableBoolean',
+    'searchControl': 'NullableBoolean',
+    'locateControl': 'NullableBoolean',
+    'fullscreenControl': 'NullableBoolean',
+    'editinosmControl': 'NullableBoolean',
+    'embedControl': 'NullableBoolean',
+    'measureControl': 'NullableBoolean',
+    'tilelayersControl': 'NullableBoolean',
+    'starControl': 'NullableBoolean',
+    'easing': undefined,
+  },
 
   initialize: function (el, geojson) {
     // Locale name (pt_PT, en_US…)
@@ -89,18 +136,19 @@ L.U.Map.include({
         ? geojson.properties.fullscreenControl
         : true
     geojson.properties.fullscreenControl = false
-    L.Util.setBooleanFromQueryString(geojson.properties, 'scrollWheelZoom')
+    this.setOptionsFromQueryString(geojson.properties)
 
     L.Map.prototype.initialize.call(this, el, geojson.properties)
 
     // After calling parent initialize, as we are doing initCenter our-selves
     if (geojson.geometry) this.options.center = this.latLng(geojson.geometry)
-    this.urls = new window.umap.URLs(this.options.urls)
+    this.urls = new U.URLs(this.options.urls)
 
-    this.ui = new L.U.UI(this._container)
-    this.xhr = new L.U.Xhr(this.ui)
-    this.xhr.on('dataloading', (e) => this.fire('dataloading', e))
-    this.xhr.on('dataload', (e) => this.fire('dataload', e))
+    this.ui = new U.UI(this._container)
+    this.ui.on('dataloading', (e) => this.fire('dataloading', e))
+    this.ui.on('dataload', (e) => this.fire('dataload', e))
+    this.server = new U.ServerRequest(this.ui)
+    this.request = new U.Request(this.ui)
 
     this.initLoader()
     this.name = this.options.name
@@ -108,27 +156,10 @@ L.U.Map.include({
     this.demoTileInfos = this.options.demoTileInfos
     this.options.zoomControl = zoomControl
     this.options.fullscreenControl = fullscreenControl
-    L.Util.setBooleanFromQueryString(this.options, 'moreControl')
-    L.Util.setBooleanFromQueryString(this.options, 'scaleControl')
-    L.Util.setBooleanFromQueryString(this.options, 'miniMap')
-    L.Util.setFromQueryString(this.options, 'editMode')
-    L.Util.setBooleanFromQueryString(this.options, 'displayDataBrowserOnLoad')
-    L.Util.setBooleanFromQueryString(this.options, 'displayCaptionOnLoad')
-    L.Util.setBooleanFromQueryString(this.options, 'captionBar')
-    L.Util.setBooleanFromQueryString(this.options, 'captionMenus')
-    for (let i = 0; i < this.HIDDABLE_CONTROLS.length; i++) {
-      L.Util.setNullableBooleanFromQueryString(
-        this.options,
-        `${this.HIDDABLE_CONTROLS[i]}Control`
-      )
-    }
     this.datalayersOnLoad = L.Util.queryString('datalayers')
-    this.options.onLoadPanel = L.Util.queryString(
-      'onLoadPanel',
-      this.options.onLoadPanel
-    )
-    if (this.datalayersOnLoad)
+    if (this.datalayersOnLoad) {
       this.datalayersOnLoad = this.datalayersOnLoad.toString().split(',')
+    }
 
     if (L.Browser.ielt9) this.options.editMode = 'disabled' // TODO include ie9
 
@@ -169,7 +200,7 @@ L.U.Map.include({
     this.facets = {}
 
     // Needed for actions labels
-    this.help = new L.U.Help(this)
+    this.help = new U.Help(this)
 
     if (this.options.hash) this.addHash()
     this.initTileLayers()
@@ -178,7 +209,7 @@ L.U.Map.include({
     // Needs locate control and hash to exist
     this.initCenter()
     this.handleLimitBounds()
-    this.initDatalayers()
+    this.initDataLayers()
 
     if (this.options.displayCaptionOnLoad) {
       // Retrocompat
@@ -227,28 +258,33 @@ L.U.Map.include({
 
     // Creation mode
     if (!this.options.umap_id) {
-      this.isDirty = true
+      if (!this.options.preview) {
+        this.isDirty = true
+        this.enableEdit()
+      }
       this._default_extent = true
       this.options.name = L._('Untitled map')
-      this.options.editMode = 'advanced'
-      const datalayer = this.createDataLayer()
-      datalayer.connectToMap()
-      this.enableEdit()
+      let data = L.Util.queryString('data', null)
       let dataUrl = L.Util.queryString('dataUrl', null)
       const dataFormat = L.Util.queryString('dataFormat', 'geojson')
       if (dataUrl) {
         dataUrl = decodeURIComponent(dataUrl)
         dataUrl = this.localizeUrl(dataUrl)
         dataUrl = this.proxyUrl(dataUrl)
+        const datalayer = this.createDataLayer()
         datalayer.importFromUrl(dataUrl, dataFormat)
+      } else if (data) {
+        data = decodeURIComponent(data)
+        const datalayer = this.createDataLayer()
+        datalayer.importRaw(data, dataFormat)
       }
     }
 
-    this.slideshow = new L.U.Slideshow(this, this.options.slideshow)
-    this.permissions = new L.U.MapPermissions(this)
+    this.slideshow = new U.Slideshow(this, this.options.slideshow)
+    this.permissions = new U.MapPermissions(this)
     this.initCaptionBar()
     if (this.hasEditMode()) {
-      this.editTools = new L.U.Editable(this)
+      this.editTools = new U.Editable(this)
       this.ui.on(
         'panel:closed panel:open',
         function () {
@@ -268,8 +304,6 @@ L.U.Map.include({
         this.options.onLoadPanel === 'datafilters'
       )
         this.openFacet()
-    })
-    this.onceDataLoaded(function () {
       const slug = L.Util.queryString('feature')
       if (slug && this.features_index[slug]) this.features_index[slug].view()
       if (L.Util.queryString('edit')) {
@@ -288,36 +322,61 @@ L.U.Map.include({
       }
     })
 
-    window.onbeforeunload = () => this.isDirty || null
+    window.onbeforeunload = () => this.editEnabled && this.isDirty || null
     this.backup()
     this.initContextMenu()
     this.on('click contextmenu.show', this.closeInplaceToolbar)
   },
 
+  setOptionsFromQueryString: function (options) {
+    // This is not an editable option
+    L.Util.setFromQueryString(options, 'editMode')
+    // FIXME retrocompat
+    L.Util.setBooleanFromQueryString(options, 'displayDataBrowserOnLoad')
+    L.Util.setBooleanFromQueryString(options, 'displayCaptionOnLoad')
+    for (const [key, type] of Object.entries(this.editableOptions)) {
+      switch (type) {
+        case Boolean:
+          L.Util.setBooleanFromQueryString(options, key)
+          break
+        case 'NullableBoolean':
+          L.Util.setNullableBooleanFromQueryString(options, key)
+          break
+        case String:
+          L.Util.setFromQueryString(options, key)
+      }
+    }
+    // Specific case for datalayersControl
+    // which accepts "expanded" value, on top of true/false/null
+    if (L.Util.queryString('datalayersControl') === 'expanded') {
+      L.Util.setFromQueryString(options, 'datalayersControl')
+    }
+  },
+
   initControls: function () {
     this.helpMenuActions = {}
     this._controls = {}
 
     if (this.hasEditMode() && !this.options.noControl) {
-      new L.U.EditControl(this).addTo(this)
+      new U.EditControl(this).addTo(this)
 
-      new L.U.DrawToolbar({ map: this }).addTo(this)
+      new U.DrawToolbar({ map: this }).addTo(this)
 
       const editActions = [
-        L.U.ImportAction,
-        L.U.EditPropertiesAction,
-        L.U.ManageDatalayersAction,
-        L.U.ChangeTileLayerAction,
-        L.U.UpdateExtentAction,
-        L.U.UpdatePermsAction,
+        U.ImportAction,
+        U.EditPropertiesAction,
+        U.ManageDatalayersAction,
+        U.ChangeTileLayerAction,
+        U.UpdateExtentAction,
+        U.UpdatePermsAction,
       ]
-      new L.U.SettingsToolbar({ actions: editActions }).addTo(this)
+      new U.SettingsToolbar({ actions: editActions }).addTo(this)
     }
     this._controls.zoom = new L.Control.Zoom({
       zoomInTitle: L._('Zoom in'),
       zoomOutTitle: L._('Zoom out'),
     })
-    this._controls.datalayers = new L.U.DataLayersControl(this)
+    this._controls.datalayers = new U.DataLayersControl(this)
     this._controls.locate = L.control.locate({
       strings: {
         title: L._('Center map on your location'),
@@ -334,10 +393,10 @@ L.U.Map.include({
     this._controls.fullscreen = new L.Control.Fullscreen({
       title: { false: L._('View Fullscreen'), true: L._('Exit Fullscreen') },
     })
-    this._controls.search = new L.U.SearchControl()
+    this._controls.search = new U.SearchControl()
     this._controls.embed = new L.Control.Embed(this, this.options.embedOptions)
-    this._controls.tilelayersChooser = new L.U.TileLayerChooser(this)
-    this._controls.star = new L.U.StarControl(this)
+    this._controls.tilelayersChooser = new U.TileLayerChooser(this)
+    this._controls.star = new U.StarControl(this)
     this._controls.editinosm = new L.Control.EditInOSM({
       position: 'topleft',
       widgetOptions: {
@@ -347,16 +406,16 @@ L.U.Map.include({
       },
     })
     this._controls.measure = new L.MeasureControl().initHandler(this)
-    this._controls.more = new L.U.MoreControls()
+    this._controls.more = new U.MoreControls()
     this._controls.scale = L.control.scale()
-    this._controls.permanentCredit = new L.U.PermanentCreditsControl(this)
+    this._controls.permanentCredit = new U.PermanentCreditsControl(this)
     if (this.options.scrollWheelZoom) this.scrollWheelZoom.enable()
     else this.scrollWheelZoom.disable()
-    this.browser = new L.U.Browser(this)
-    this.importer = new L.U.Importer(this)
-    this.drop = new L.U.DropControl(this)
-    this.share = new L.U.Share(this)
-    this._controls.tilelayers = new L.U.TileLayerControl(this)
+    this.browser = new U.Browser(this)
+    this.importer = new U.Importer(this)
+    this.drop = new U.DropControl(this)
+    this.share = new U.Share(this)
+    this._controls.tilelayers = new U.TileLayerControl(this)
     this._controls.tilelayers.setLayers()
 
     this.renderControls()
@@ -379,7 +438,7 @@ L.U.Map.include({
     }
     if (this.options.noControl) return
 
-    this._controls.attribution = new L.U.AttributionControl().addTo(this)
+    this._controls.attribution = new U.AttributionControl().addTo(this)
     if (this.options.miniMap && !this.options.noControl) {
       this.whenReady(function () {
         if (this.selected_tilelayer) {
@@ -414,56 +473,22 @@ L.U.Map.include({
     if (this.options.scaleControl) this._controls.scale.addTo(this)
   },
 
-  initDatalayers: function () {
-    for (let j = 0; j < this.options.datalayers.length; j++) {
-      this.createDataLayer(this.options.datalayers[j])
+  initDataLayers: async function (datalayers) {
+    datalayers = datalayers || this.options.datalayers
+    for (const options of datalayers) {
+      this.createDataLayer(options)
     }
-    this.loadDatalayers()
+    await this.loadDataLayers()
   },
 
-  loadDatalayers: function (force) {
-    const total = this.datalayers_index.length
-    // toload => datalayer metadata remaining to load (synchronous)
-    // dataToload => datalayer data remaining to load (asynchronous)
-    let toload = total,
-      dataToload = total
-    let datalayer
-    const loaded = () => {
-      this.datalayersLoaded = true
-      this.fire('datalayersloaded')
-    }
-    const decrementToLoad = () => {
-      toload--
-      if (toload === 0) loaded()
-    }
-    const dataLoaded = () => {
-      this.dataLoaded = true
-      this.fire('dataloaded')
-    }
-    const decrementDataToLoad = () => {
-      dataToload--
-      if (dataToload === 0) dataLoaded()
-    }
-    this.eachDataLayer(function (datalayer) {
-      if (force && !datalayer.hasDataLoaded()) {
-        datalayer.show()
-      }
-      if (datalayer.showAtLoad() || force) {
-        datalayer.onceLoaded(decrementToLoad)
-      } else {
-        decrementToLoad()
-      }
-      if (datalayer.showAtLoad() || force) {
-        datalayer.onceDataLoaded(decrementDataToLoad)
-      } else {
-        decrementDataToLoad({ sourceTarget: datalayer })
-      }
-    })
-    if (total === 0) {
-      // no datalayer
-      loaded()
-      dataLoaded()
+  loadDataLayers: async function () {
+    this.datalayersLoaded = true
+    this.fire('datalayersloaded')
+    for (const datalayer of Object.values(this.datalayers)) {
+      if (datalayer.showAtLoad()) await datalayer.show()
     }
+    this.dataloaded = true
+    this.fire('dataloaded')
   },
 
   indexDatalayers: function () {
@@ -496,7 +521,7 @@ L.U.Map.include({
 
   onceDataLoaded: function (callback, context) {
     // Once datalayers **data** have been loaded
-    if (this.dataLoaded) {
+    if (this.dataloaded) {
       callback.call(context || this, this)
     } else {
       this.once('dataloaded', callback, context)
@@ -527,10 +552,10 @@ L.U.Map.include({
         modifierKey = e.ctrlKey || e.metaKey
 
       /* Generic shortcuts */
-      if (key === L.U.Keys.F && modifierKey) {
+      if (key === U.Keys.F && modifierKey) {
         L.DomEvent.stop(e)
         this.search()
-      } else if (e.keyCode === L.U.Keys.ESC) {
+      } else if (e.keyCode === U.Keys.ESC) {
         if (this.help.visible()) this.help.hide()
         else this.ui.closePanel()
       }
@@ -538,11 +563,11 @@ L.U.Map.include({
       if (!this.hasEditMode()) return
 
       /* Edit mode only shortcuts */
-      if (key === L.U.Keys.E && modifierKey && !this.editEnabled) {
+      if (key === U.Keys.E && modifierKey && !this.editEnabled) {
         L.DomEvent.stop(e)
         this.enableEdit()
       } else if (
-        key === L.U.Keys.E &&
+        key === U.Keys.E &&
         modifierKey &&
         this.editEnabled &&
         !this.isDirty
@@ -551,41 +576,41 @@ L.U.Map.include({
         this.disableEdit()
         this.ui.closePanel()
       }
-      if (key === L.U.Keys.S && modifierKey) {
+      if (key === U.Keys.S && modifierKey) {
         L.DomEvent.stop(e)
         if (this.isDirty) {
           this.save()
         }
       }
-      if (key === L.U.Keys.Z && modifierKey && this.isDirty) {
+      if (key === U.Keys.Z && modifierKey && this.isDirty) {
         L.DomEvent.stop(e)
         this.askForReset()
       }
-      if (key === L.U.Keys.M && modifierKey && this.editEnabled) {
+      if (key === U.Keys.M && modifierKey && this.editEnabled) {
         L.DomEvent.stop(e)
         this.editTools.startMarker()
       }
-      if (key === L.U.Keys.P && modifierKey && this.editEnabled) {
+      if (key === U.Keys.P && modifierKey && this.editEnabled) {
         L.DomEvent.stop(e)
         this.editTools.startPolygon()
       }
-      if (key === L.U.Keys.L && modifierKey && this.editEnabled) {
+      if (key === U.Keys.L && modifierKey && this.editEnabled) {
         L.DomEvent.stop(e)
         this.editTools.startPolyline()
       }
-      if (key === L.U.Keys.I && modifierKey && this.editEnabled) {
+      if (key === U.Keys.I && modifierKey && this.editEnabled) {
         L.DomEvent.stop(e)
         this.importer.open()
       }
-      if (key === L.U.Keys.O && modifierKey && this.editEnabled) {
+      if (key === U.Keys.O && modifierKey && this.editEnabled) {
         L.DomEvent.stop(e)
         this.importer.openFiles()
       }
-      if (key === L.U.Keys.H && modifierKey && this.editEnabled) {
+      if (key === U.Keys.H && modifierKey && this.editEnabled) {
         L.DomEvent.stop(e)
         this.help.show('edit')
       }
-      if (e.keyCode === L.U.Keys.ESC) {
+      if (e.keyCode === U.Keys.ESC) {
         if (this.editEnabled && this.editTools.drawing()) {
           this.editTools.stopDrawing()
         }
@@ -796,7 +821,7 @@ L.U.Map.include({
     datalayer = datalayer || {
       name: `${L._('Layer')} ${this.datalayers_index.length + 1}`,
     }
-    return new L.U.DataLayer(this, datalayer)
+    return new U.DataLayer(this, datalayer)
   },
 
   getDefaultOption: function (option) {
@@ -830,7 +855,10 @@ L.U.Map.include({
         self.isDirty = true
       }
     if (this._controls.tilelayersChooser)
-      this._controls.tilelayersChooser.openSwitcher({ callback: callback, className: 'dark' })
+      this._controls.tilelayersChooser.openSwitcher({
+        callback: callback,
+        className: 'dark',
+      })
   },
 
   manageDatalayers: function () {
@@ -881,8 +909,7 @@ L.U.Map.include({
 
     let mustReindex = false
 
-    for (let i = 0; i < this.editableOptions.length; i++) {
-      const option = this.editableOptions[i]
+    for (const option of Object.keys(this.editableOptions)) {
       if (typeof importedData.properties[option] !== 'undefined') {
         this.options[option] = importedData.properties[option]
         if (option === 'sortKey') mustReindex = true
@@ -1009,76 +1036,17 @@ L.U.Map.include({
     else this.fire('saved')
   },
 
-  editableOptions: [
-    'zoom',
-    'scrollWheelZoom',
-    'scaleControl',
-    'moreControl',
-    'miniMap',
-    'displayPopupFooter',
-    'onLoadPanel',
-    'defaultView',
-    'name',
-    'description',
-    'licence',
-    'tilelayer',
-    'overlay',
-    'limitBounds',
-    'color',
-    'iconClass',
-    'iconUrl',
-    'smoothFactor',
-    'iconOpacity',
-    'opacity',
-    'weight',
-    'fill',
-    'fillColor',
-    'fillOpacity',
-    'dashArray',
-    'popupShape',
-    'popupTemplate',
-    'popupContentTemplate',
-    'zoomTo',
-    'captionBar',
-    'captionMenus',
-    'slideshow',
-    'sortKey',
-    'labelKey',
-    'filterKey',
-    'facetKey',
-    'slugKey',
-    'showLabel',
-    'labelDirection',
-    'labelInteractive',
-    'outlinkTarget',
-    'shortCredit',
-    'longCredit',
-    'permanentCredit',
-    'permanentCreditBackground',
-    'zoomControl',
-    'datalayersControl',
-    'searchControl',
-    'locateControl',
-    'fullscreenControl',
-    'editinosmControl',
-    'embedControl',
-    'measureControl',
-    'tilelayersControl',
-    'starControl',
-    'easing',
-  ],
-
   exportOptions: function () {
     const properties = {}
-    for (let i = this.editableOptions.length - 1; i >= 0; i--) {
-      if (typeof this.options[this.editableOptions[i]] !== 'undefined') {
-        properties[this.editableOptions[i]] = this.options[this.editableOptions[i]]
+    for (const option of Object.keys(this.editableOptions)) {
+      if (typeof this.options[option] !== 'undefined') {
+        properties[option] = this.options[option]
       }
     }
     return properties
   },
 
-  saveSelf: function () {
+  saveSelf: async function () {
     const geojson = {
       type: 'Feature',
       geometry: this.geometry(),
@@ -1088,64 +1056,62 @@ L.U.Map.include({
     formData.append('name', this.options.name)
     formData.append('center', JSON.stringify(this.geometry()))
     formData.append('settings', JSON.stringify(geojson))
-    this.post(this.urls.get('map_save', { map_id: this.options.umap_id }), {
-      data: formData,
-      context: this,
-      callback: function (data) {
-        let duration = 3000,
-          alert = { content: L._('Map has been saved!'), level: 'info' }
-        if (!this.options.umap_id) {
-          alert.content = L._('Congratulations, your map has been created!')
-          this.options.umap_id = data.id
-          this.permissions.setOptions(data.permissions)
-          this.permissions.commit()
-          if (
-            data.permissions &&
-            data.permissions.anonymous_edit_url &&
-            this.options.urls.map_send_edit_link
-          ) {
-            alert.duration = Infinity
-            alert.content =
-              L._(
-                'Your map has been created! As you are not logged in, here is your secret link to edit the map, please keep it safe:'
-              ) + `<br>${data.permissions.anonymous_edit_url}`
-
-            alert.actions = [
-              {
-                label: L._('Send me the link'),
-                input: L._('Email'),
-                callback: this.sendEditLink,
-                callbackContext: this,
-              },
-              {
-                label: L._('Copy link'),
-                callback: () => {
-                  L.Util.copyToClipboard(data.permissions.anonymous_edit_url)
-                  this.ui.alert({
-                    content: L._('Secret edit link copied to clipboard!'),
-                    level: 'info',
-                  })
-                },
-                callbackContext: this,
+    const uri = this.urls.get('map_save', { map_id: this.options.umap_id })
+    const [data, response, error] = await this.server.post(uri, {}, formData)
+    if (!error) {
+      let duration = 3000,
+        alert = { content: L._('Map has been saved!'), level: 'info' }
+      if (!this.options.umap_id) {
+        alert.content = L._('Congratulations, your map has been created!')
+        this.options.umap_id = data.id
+        this.permissions.setOptions(data.permissions)
+        this.permissions.commit()
+        if (
+          data.permissions &&
+          data.permissions.anonymous_edit_url &&
+          this.options.urls.map_send_edit_link
+        ) {
+          alert.duration = Infinity
+          alert.content =
+            L._(
+              'Your map has been created! As you are not logged in, here is your secret link to edit the map, please keep it safe:'
+            ) + `<br>${data.permissions.anonymous_edit_url}`
+
+          alert.actions = [
+            {
+              label: L._('Send me the link'),
+              input: L._('Email'),
+              callback: this.sendEditLink,
+              callbackContext: this,
+            },
+            {
+              label: L._('Copy link'),
+              callback: () => {
+                L.Util.copyToClipboard(data.permissions.anonymous_edit_url)
+                this.ui.alert({
+                  content: L._('Secret edit link copied to clipboard!'),
+                  level: 'info',
+                })
               },
-            ]
-          }
-        } else if (!this.permissions.isDirty) {
-          // Do not override local changes to permissions,
-          // but update in case some other editors changed them in the meantime.
-          this.permissions.setOptions(data.permissions)
-          this.permissions.commit()
+              callbackContext: this,
+            },
+          ]
         }
-        // Update URL in case the name has changed.
-        if (history && history.pushState)
-          history.pushState({}, this.options.name, data.url)
-        else window.location = data.url
-        alert.content = data.info || alert.content
-        this.once('saved', () => this.ui.alert(alert))
-        this.ui.closePanel()
-        this.permissions.save()
-      },
-    })
+      } else if (!this.permissions.isDirty) {
+        // Do not override local changes to permissions,
+        // but update in case some other editors changed them in the meantime.
+        this.permissions.setOptions(data.permissions)
+        this.permissions.commit()
+      }
+      // Update URL in case the name has changed.
+      if (history && history.pushState)
+        history.pushState({}, this.options.name, data.url)
+      else window.location = data.url
+      alert.content = data.info || alert.content
+      this.once('saved', () => this.ui.alert(alert))
+      this.ui.closePanel()
+      this.permissions.save()
+    }
   },
 
   save: function () {
@@ -1220,13 +1186,13 @@ L.U.Map.include({
     if (
       datalayer &&
       !datalayer.isDataReadOnly() &&
-      datalayer.canBrowse() &&
+      datalayer.isBrowsable() &&
       datalayer.isVisible()
     ) {
       return datalayer
     }
     datalayer = this.findDataLayer((datalayer) => {
-      if (!datalayer.isDataReadOnly() && datalayer.canBrowse()) {
+      if (!datalayer.isDataReadOnly() && datalayer.isBrowsable()) {
         fallback = datalayer
         if (datalayer.isVisible()) return true
       }
@@ -1234,7 +1200,7 @@ L.U.Map.include({
     if (datalayer) return datalayer
     if (fallback) {
       // No datalayer visible, let's force one
-      this.addLayer(fallback.layer)
+      fallback.show()
       return fallback
     }
     return this.createDataLayer()
@@ -1260,7 +1226,7 @@ L.U.Map.include({
       'options.captionBar',
       'options.captionMenus',
     ])
-    builder = new L.U.FormBuilder(this, UIFields, {
+    builder = new U.FormBuilder(this, UIFields, {
       callback: function () {
         this.renderControls()
         this.initCaptionBar()
@@ -1289,7 +1255,7 @@ L.U.Map.include({
       'options.dashArray',
     ]
 
-    builder = new L.U.FormBuilder(this, shapeOptions, {
+    builder = new U.FormBuilder(this, shapeOptions, {
       callback: function (e) {
         if (this._controls.miniMap) this.renderControls()
         this.eachVisibleDataLayer((datalayer) => {
@@ -1349,7 +1315,7 @@ L.U.Map.include({
       ],
     ]
 
-    builder = new L.U.FormBuilder(this, optionsFields, {
+    builder = new U.FormBuilder(this, optionsFields, {
       callback: function (e) {
         this.initCaptionBar()
         if (e.helper.field === 'options.sortKey') {
@@ -1374,7 +1340,7 @@ L.U.Map.include({
       'options.labelInteractive',
       'options.outlinkTarget',
     ]
-    builder = new L.U.FormBuilder(this, popupFields, {
+    builder = new U.FormBuilder(this, popupFields, {
       callback: function (e) {
         if (
           e.helper.field === 'options.popupTemplate' ||
@@ -1441,7 +1407,7 @@ L.U.Map.include({
       container,
       L._('Custom background')
     )
-    builder = new L.U.FormBuilder(this, tilelayerFields, {
+    builder = new U.FormBuilder(this, tilelayerFields, {
       callback: this.initTileLayers,
       callbackContext: this,
     })
@@ -1492,7 +1458,7 @@ L.U.Map.include({
       ['options.overlay.tms', { handler: 'Switch', label: L._('TMS format') }],
     ]
     const overlay = L.DomUtil.createFieldset(container, L._('Custom overlay'))
-    builder = new L.U.FormBuilder(this, overlayFields, {
+    builder = new U.FormBuilder(this, overlayFields, {
       callback: this.initTileLayers,
       callbackContext: this,
     })
@@ -1522,7 +1488,7 @@ L.U.Map.include({
         { handler: 'BlurFloatInput', placeholder: L._('max East') },
       ],
     ]
-    const boundsBuilder = new L.U.FormBuilder(this, boundsFields, {
+    const boundsBuilder = new U.FormBuilder(this, boundsFields, {
       callback: this.handleLimitBounds,
       callbackContext: this,
     })
@@ -1588,7 +1554,7 @@ L.U.Map.include({
       this.slideshow.setOptions(this.options.slideshow)
       this.renderControls()
     }
-    const slideshowBuilder = new L.U.FormBuilder(this, slideshowFields, {
+    const slideshowBuilder = new U.FormBuilder(this, slideshowFields, {
       callback: slideshowHandler,
       callbackContext: this,
     })
@@ -1628,7 +1594,7 @@ L.U.Map.include({
         { handler: 'Switch', label: L._('Permanent credits background') },
       ],
     ]
-    const creditsBuilder = new L.U.FormBuilder(this, creditsFields, {
+    const creditsBuilder = new U.FormBuilder(this, creditsFields, {
       callback: this.renderControls,
       callbackContext: this,
     })
@@ -1684,7 +1650,7 @@ L.U.Map.include({
       metadataFields = ['options.name', 'options.description'],
       title = L.DomUtil.create('h3', '', container)
     title.textContent = L._('Edit map properties')
-    const builder = new L.U.FormBuilder(this, metadataFields)
+    const builder = new U.FormBuilder(this, metadataFields)
     const form = builder.build()
     container.appendChild(form)
     this._editControls(container)
@@ -1788,19 +1754,21 @@ L.U.Map.include({
     return this.editTools.startPolygon()
   },
 
-  del: function () {
+  del: async function () {
     if (confirm(L._('Are you sure you want to delete this map?'))) {
       const url = this.urls.get('map_delete', { map_id: this.options.umap_id })
-      this.post(url)
+      const [data, response, error] = await this.server.post(url)
+      if (data.redirect) window.location = data.redirect
     }
   },
 
-  clone: function () {
+  clone: async function () {
     if (
       confirm(L._('Are you sure you want to clone this map and all its datalayers?'))
     ) {
       const url = this.urls.get('map_clone', { map_id: this.options.umap_id })
-      this.post(url)
+      const [data, response, error] = await this.server.post(url)
+      if (data.redirect) window.location = data.redirect
     }
   },
 
@@ -1815,25 +1783,8 @@ L.U.Map.include({
     this.loader.onAdd(this)
   },
 
-  post: function (url, options) {
-    options = options || {}
-    options.listener = this
-    this.xhr.post(url, options)
-  },
-
-  get: function (url, options) {
-    options = options || {}
-    options.listener = this
-    this.xhr.get(url, options)
-  },
-
-  ajax: function (options) {
-    options.listener = this
-    this.xhr._ajax(options)
-  },
-
   initContextMenu: function () {
-    this.contextmenu = new L.U.ContextMenu(this)
+    this.contextmenu = new U.ContextMenu(this)
     this.contextmenu.enable()
   },