umap-project 3.0.4__py3-none-any.whl → 3.0.5__py3-none-any.whl

umap/static/umap/js/modules/data/layer.js

@@ -64,6 +64,9 @@ export class DataLayer {
 
     this.setOptions(data)
     this.pane.dataset.id = this.id
+    if (this.options.rank === undefined) {
+      this.options.rank = this._umap.datalayers.count()
+    }
 
     if (!Utils.isObject(this.options.remoteData)) {
       this.options.remoteData = {}
@@ -122,6 +125,20 @@ export class DataLayer {
     return `datalayer-${stamp(this)}`
   }
 
+  get rank() {
+    // Make sure we always have a valid rank. Undefined rank may happen
+    // after importing an old umap backup, and not touching the layers
+    // after that.
+    if (this.options.rank === undefined) {
+      this.options.rank = this.getDOMOrder()
+    }
+    return this.options.rank
+  }
+
+  set rank(value) {
+    this.options.rank = value
+  }
+
   getSyncMetadata() {
     return {
       subject: 'datalayer',
@@ -130,6 +147,10 @@ export class DataLayer {
   }
 
   render(fields, builder) {
+    // Propagate will remove the fields it has already
+    // processed
+    fields = this.propagate(fields)
+
     const impacts = Utils.getImpactsFromSchema(fields)
 
     for (const impact of impacts) {
@@ -149,8 +170,34 @@ export class DataLayer {
         case 'remote-data':
           this.fetchRemoteData()
           break
+        case 'datalayer-rank':
+          this._umap.reorderDataLayers()
+          break
+      }
+    }
+  }
+
+  // This method does a targeted update of the UI,
+  // it whould be merged with `render`` method and the
+  // SCHEMA at some point
+  propagate(fields = []) {
+    const impacts = {
+      'properties.name': () => {
+        Utils.eachElement('.datalayer-name', (el) => {
+          if (el.dataset.id === this.id) {
+            el.textContent = this.getName()
+            el.title = this.getName()
+          }
+        })
+      },
+    }
+    for (const [field, impact] of Object.entries(impacts)) {
+      if (!fields.length || fields.includes(field)) {
+        impact()
+        fields = fields.filter((item) => item !== field)
       }
     }
+    return fields
   }
 
   showAtLoad() {
@@ -222,16 +269,9 @@ export class DataLayer {
     if (!error) {
       this._umap.modifiedAt = response.headers.get('last-modified')
       this.setReferenceVersion({ response, sync: false })
-      // FIXME: for now the _umap_options 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
-      }
+      delete geojson._umap_options
       // In case of maps pre 1.0 still around
-      if (geojson._storage) geojson._storage.editMode = this.options.editMode
+      delete geojson._storage
       await this.fromUmapGeoJSON(geojson)
       this.backupOptions()
       this._loading = false
@@ -260,7 +300,6 @@ export class DataLayer {
 
   async fromUmapGeoJSON(geojson) {
     if (geojson._storage) geojson._umap_options = geojson._storage // Retrocompat
-    geojson._umap_options.id = this.id
     if (geojson._umap_options) this.setOptions(geojson._umap_options)
     if (this.isRemoteLayer()) {
       await this.fetchRemoteData()
@@ -269,15 +308,6 @@ export class DataLayer {
     }
   }
 
-  clear() {
-    this.sync.startBatch()
-    for (const feature of Object.values(this._features)) {
-      feature.del()
-    }
-    this.sync.commitBatch()
-    this.dataChanged()
-  }
-
   backupData() {
     if (this._geojson) {
       this._geojson_bk = Utils.CopyJSON(this._geojson)
@@ -328,7 +358,7 @@ export class DataLayer {
       url = this._umap.proxyUrl(url, this.options.remoteData.ttl)
     }
     return await this.getUrl(url, remoteUrl).then((raw) => {
-      this.clear()
+      this.clear(false)
       return this._umap.formatter
         .parse(raw, this.options.remoteData.format)
         .then((geojson) => this.fromGeoJSON(geojson, false))
@@ -368,12 +398,7 @@ export class DataLayer {
   }
 
   connectToMap() {
-    if (!this._umap.datalayers[this.id]) {
-      this._umap.datalayers[this.id] = this
-    }
-    if (!this._umap.datalayersIndex.includes(this)) {
-      this._umap.datalayersIndex.push(this)
-    }
+    this._umap.datalayers.add(this)
     this._umap.onDataLayersChanged()
   }
 
@@ -492,8 +517,19 @@ export class DataLayer {
     const features = []
     this.sortFeatures(collection)
     for (const featureJson of collection) {
-      const feature = this.makeFeature(featureJson, sync)
-      if (feature) features.push(feature)
+      if (featureJson.geometry?.type === 'GeometryCollection') {
+        for (const geometry of featureJson.geometry.geometries) {
+          const feature = this.makeFeature({
+            type: 'Feature',
+            geometry,
+            properties: featureJson.properties,
+          })
+          if (feature) features.push(feature)
+        }
+      } else {
+        const feature = this.makeFeature(featureJson, sync)
+        if (feature) features.push(feature)
+      }
     }
     return features
   }
@@ -606,16 +642,33 @@ export class DataLayer {
 
   del(sync = true) {
     const oldValue = Utils.CopyJSON(this.umapGeoJSON())
-    this.erase()
+    // TODO merge datalayer del and features del in same
+    // batch
+    this.clear()
     if (sync) {
       this.isDeleted = true
       this.sync.delete(oldValue)
     }
+    this.hide()
+    this.parentPane.removeChild(this.pane)
+    this._umap.onDataLayersChanged()
+    this.layer.onDelete(this._leafletMap)
+    this.propagateDelete()
+    this._leaflet_events_bk = this._leaflet_events
   }
 
   empty() {
     if (this.isRemoteLayer()) return
+    this.sync.startBatch()
     this.clear()
+    this.sync.commitBatch()
+  }
+
+  clear(sync = true) {
+    for (const feature of Object.values(this._features)) {
+      feature.del(sync)
+    }
+    this.dataChanged()
   }
 
   clone() {
@@ -628,24 +681,13 @@ export class DataLayer {
     return datalayer
   }
 
-  erase() {
-    this.hide()
-    this._umap.datalayersIndex.splice(this.getRank(), 1)
-    this.parentPane.removeChild(this.pane)
-    this._umap.onDataLayersChanged()
-    this.layer.onDelete(this._leafletMap)
-    this.propagateDelete()
-    this._leaflet_events_bk = this._leaflet_events
-    this.clear()
-  }
-
   redraw() {
     if (!this.isVisible()) return
     this.eachFeature((feature) => feature.redraw())
   }
 
   edit() {
-    if (!this._umap.editEnabled || !this.isLoaded()) {
+    if (!this._umap.editEnabled) {
       return
     }
     const container = DomUtil.create('div', 'umap-layer-properties-container')
@@ -1053,23 +1095,11 @@ export class DataLayer {
   }
 
   getPreviousBrowsable() {
-    let id = this.getRank()
-    let next
-    const index = this._umap.datalayersIndex
-    while (((id = index[++id] ? id : 0), (next = index[id]))) {
-      if (next === this || next.canBrowse()) break
-    }
-    return next
+    return this._umap.datalayers.prev(this)
   }
 
   getNextBrowsable() {
-    let id = this.getRank()
-    let prev
-    const index = this._umap.datalayersIndex
-    while (((id = index[--id] ? id : index.length - 1), (prev = index[id]))) {
-      if (prev === this || prev.canBrowse()) break
-    }
-    return prev
+    return this._umap.datalayers.next(this)
   }
 
   umapGeoJSON() {
@@ -1080,8 +1110,8 @@ export class DataLayer {
     }
   }
 
-  getRank() {
-    return this._umap.datalayersIndex.indexOf(this)
+  getDOMOrder() {
+    return Array.from(this.parentPane.children).indexOf(this.pane)
   }
 
   isReadOnly() {
@@ -1103,15 +1133,21 @@ export class DataLayer {
     }
   }
 
+  prepareOptions() {
+    const options = Utils.CopyJSON(this.options)
+    delete options.permissions
+    return JSON.stringify(options)
+  }
+
   async save() {
     if (this.isDeleted) return await this.saveDelete()
-    if (!this.isLoaded()) return
+    if (!this.isRemoteLayer() && !this.isLoaded()) return
     const geojson = this.umapGeoJSON()
     const formData = new FormData()
     formData.append('name', this.options.name)
     formData.append('display_on_load', !!this.options.displayOnLoad)
-    formData.append('rank', this.getRank())
-    formData.append('settings', JSON.stringify(this.options))
+    formData.append('rank', this.rank)
+    formData.append('settings', this.prepareOptions())
     // Filename support is shaky, don't do it for now.
     const blob = new Blob([JSON.stringify(geojson)], { type: 'application/json' })
     formData.append('geojson', blob)
@@ -1146,12 +1182,15 @@ export class DataLayer {
             await this._umap.saveAll()
           }
         )
+      } else {
+        console.debug(error)
+        Alert.error(translate('Cannot save layer, please try again in a few minutes.'))
       }
     } 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.clear(false)
         this.fromGeoJSON(data.geojson)
         delete data.geojson
       }

umap/static/umap/js/modules/facets.js

@@ -24,7 +24,7 @@ export default class Facets {
       this.selected[name] = selected
     }
 
-    this._umap.eachBrowsableDataLayer((datalayer) => {
+    this._umap.datalayers.browsable().map((datalayer) => {
       datalayer.eachFeature((feature) => {
         for (const name of names) {
           let value = feature.properties[name]

umap/static/umap/js/modules/form/fields.js

@@ -560,7 +560,7 @@ Fields.SlideshowDelay = class extends Fields.IntSelect {
 Fields.DataLayerSwitcher = class extends Fields.Select {
   getOptions() {
     const options = []
-    this.builder._umap.eachDataLayerReverse((datalayer) => {
+    this.builder._umap.datalayers.reverse().map((datalayer) => {
       if (
         datalayer.isLoaded() &&
         !datalayer.isDataReadOnly() &&

umap/static/umap/js/modules/importer.js

@@ -243,7 +243,7 @@ export default class Importer extends Utils.WithTemplate {
     this.raw = null
     const layerSelect = this.qs('[name="layer-id"]')
     layerSelect.innerHTML = ''
-    this._umap.eachDataLayerReverse((datalayer) => {
+    this._umap.datalayers.reverse().map((datalayer) => {
       if (datalayer.isLoaded() && !datalayer.isRemoteLayer()) {
         DomUtil.element({
           tagName: 'option',

umap/static/umap/js/modules/managers.js

@@ -0,0 +1,46 @@
+export class DataLayerManager extends Object {
+  add(datalayer) {
+    this[datalayer.id] = datalayer
+  }
+  active() {
+    return Object.values(this)
+      .filter((datalayer) => !datalayer.isDeleted)
+      .sort((a, b) => a.rank > b.rank)
+  }
+  reverse() {
+    return this.active().reverse()
+  }
+  count() {
+    return this.active().length
+  }
+  find(func) {
+    for (const datalayer of this.reverse()) {
+      if (func.call(datalayer, datalayer)) {
+        return datalayer
+      }
+    }
+  }
+  filter(func) {
+    return this.active().filter(func)
+  }
+  visible() {
+    return this.filter((datalayer) => datalayer.isVisible())
+  }
+  browsable() {
+    return this.reverse().filter((datalayer) => datalayer.allowBrowse())
+  }
+  prev(datalayer) {
+    const browsable = this.browsable()
+    const current = browsable.indexOf(datalayer)
+    const prev = browsable[current - 1] || browsable[browsable.length - 1]
+    if (!prev.canBrowse()) return this.prev(prev)
+    return prev
+  }
+  next(datalayer) {
+    const browsable = this.browsable()
+    const current = browsable.indexOf(datalayer)
+    const next = browsable[current + 1] || browsable[0]
+    if (!next.canBrowse()) return this.next(next)
+    return next
+  }
+}

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

@@ -159,7 +159,7 @@ export class MapPermissions {
         `<fieldset class="separator"><legend>${translate('Datalayers')}</legend></fieldset>`
       )
       container.appendChild(fieldset)
-      this._umap.eachDataLayer((datalayer) => {
+      this._umap.datalayers.active().map((datalayer) => {
         datalayer.permissions.edit(fieldset)
       })
     }

umap/static/umap/js/modules/rendering/controls.js

@@ -0,0 +1,251 @@
+import { Control } from '../../../vendors/leaflet/leaflet-src.esm.js'
+import * as Utils from '../utils.js'
+import { translate } from '../i18n.js'
+
+export const HomeControl = Control.extend({
+  options: {
+    position: 'topleft',
+  },
+
+  onAdd: (map) => {
+    const path = map._umap.getStaticPathFor('home.svg')
+    const container = Utils.loadTemplate(
+      `<a href="/" class="home-button" title="${translate('Back to home')}"><img src="${path}" alt="${translate('Home logo')}" width="38px" height="38px" /></a>`
+    )
+    return container
+  },
+})
+
+export const EditControl = Control.extend({
+  options: {
+    position: 'topright',
+  },
+
+  onAdd: (map) => {
+    const template = `
+      <div class="edit-enable">
+        <button type="button" data-ref="button">${translate('Edit')}</button>
+      </div>
+    `
+    const [container, { button }] = Utils.loadTemplateWithRefs(template)
+    button.addEventListener('click', () => map._umap.enableEdit())
+    button.addEventListener('mouseover', () => {
+      map._umap.tooltip.open({
+        content: map._umap.help.displayLabel('TOGGLE_EDIT'),
+        anchor: button,
+        position: 'bottom',
+        delay: 750,
+        duration: 5000,
+      })
+    })
+    return container
+  },
+})
+
+export const MoreControl = Control.extend({
+  options: {
+    position: 'topleft',
+  },
+
+  onAdd: function (map) {
+    const pos = this.getPosition()
+    const corner = map._controlCorners[pos]
+    const className = 'umap-more-controls'
+    const template = `
+      <div class="umap-control-text">
+        <button class="umap-control-more" type="button" data-ref="button"></button>
+      </div>
+    `
+    const [container, { button }] = Utils.loadTemplateWithRefs(template)
+    button.addEventListener('click', () => corner.classList.toggle(className))
+    button.addEventListener('mouseover', () => {
+      const extended = corner.classList.contains(className)
+      map._umap.tooltip.open({
+        content: extended ? translate('Hide controls') : translate('More controls'),
+        anchor: button,
+        position: 'right',
+        delay: 750,
+      })
+    })
+    return container
+  },
+})
+
+export const PermanentCreditsControl = Control.extend({
+  options: {
+    position: 'bottomleft',
+  },
+
+  onAdd: (map) => {
+    const container = Utils.loadTemplate(
+      `<div class="umap-permanent-credits-container text">${Utils.toHTML(map.options.permanentCredit)}</div>`
+    )
+    const background = map.options.permanentCreditBackground ? '#FFFFFFB0' : ''
+    container.style.backgroundColor = background
+    return container
+  },
+})
+
+const BaseButton = Control.extend({
+  initialize: function (umap, options) {
+    this._umap = umap
+    Control.prototype.initialize.call(this, options)
+  },
+
+  onAdd: function (map) {
+    const template = `
+      <div class="${this.options.className} umap-control">
+        <button type="button" title="${this.options.title}" data-ref="button"></button>
+      </div>
+    `
+    const [container, { button }] = Utils.loadTemplateWithRefs(template)
+    button.addEventListener('click', (event) => {
+      event.stopPropagation()
+      this.onClick()
+    })
+    button.addEventListener('dblclick', (event) => {
+      event.stopPropagation()
+    })
+    this.afterAdd(container)
+    return container
+  },
+
+  afterAdd: (container) => {},
+})
+
+export const DataLayersControl = BaseButton.extend({
+  options: {
+    position: 'topleft',
+    className: 'umap-control-browse',
+    title: translate('Open browser'),
+  },
+
+  afterAdd: function (container) {
+    Utils.toggleBadge(container, this._umap.browser?.hasFilters())
+  },
+
+  onClick: function () {
+    this._umap.openBrowser()
+  },
+})
+
+export const CaptionControl = BaseButton.extend({
+  options: {
+    position: 'topleft',
+    className: 'umap-control-caption',
+    title: translate('About'),
+  },
+
+  onClick: function () {
+    this._umap.openCaption()
+  },
+})
+
+export const EmbedControl = BaseButton.extend({
+  options: {
+    position: 'topleft',
+    title: translate('Share and download'),
+    className: 'leaflet-control-embed',
+  },
+
+  onClick: function () {
+    this._umap.share.open()
+  },
+})
+
+export const AttributionControl = Control.Attribution.extend({
+  options: {
+    prefix: '',
+  },
+
+  _update: function () {
+    // Layer is no more on the map
+    if (!this._map) return
+    Control.Attribution.prototype._update.call(this)
+    const shortCredit = this._map._umap.getProperty('shortCredit')
+    const captionMenus = this._map._umap.getProperty('captionMenus')
+    // Use our own container, so we can hide/show on small screens
+    const originalCredits = this._container.innerHTML
+    this._container.innerHTML = ''
+    const template = `
+      <div class="attribution-container">
+        ${originalCredits}
+        <span data-ref="short"> — ${Utils.toHTML(shortCredit)}</span>
+        <a  href="#" data-ref="caption"> — ${translate('Open caption')}</a>
+        <a href="/" data-ref="home"> — ${translate('Home')}</a>
+        <a href="https://umap-project.org/" data-ref="site"> — ${translate('Powered by uMap')}</a>
+        <a href="#" class="attribution-toggle"></a>
+      </div>
+    `
+    const [container, { short, caption, home, site }] =
+      Utils.loadTemplateWithRefs(template)
+    caption.addEventListener('click', () => this._map._umap.openCaption())
+    this._container.appendChild(container)
+    short.hidden = !shortCredit
+    caption.hidden = !captionMenus
+    site.hidden = !captionMenus
+    home.hidden = this._map._umap.isEmbed || !captionMenus
+  },
+})
+
+/* Used in edit mode to define the default tilelayer */
+export const TileLayerChooser = BaseButton.extend({
+  options: {
+    position: 'topleft',
+  },
+
+  onClick: function () {
+    this.openSwitcher({ edit: true })
+  },
+
+  openSwitcher: function (options = {}) {
+    const template = `
+      <div class="umap-edit-tilelayers">
+        <h3><i class="icon icon-16 icon-tilelayer" title=""></i><span class="">${translate('Change tilelayers')}</span></h3>
+        <ul data-ref="tileContainer"></ul>
+      </div>
+    `
+    const [container, { tileContainer }] = Utils.loadTemplateWithRefs(template)
+    this.buildList(tileContainer, options)
+    const panel = options.edit ? this._umap.editPanel : this._umap.panel
+    panel.open({ content: container, highlight: 'tilelayers' })
+  },
+
+  buildList: function (container, options) {
+    this._umap._leafletMap.eachTileLayer((tilelayer) => {
+      const browserIsHttps = window.location.protocol === 'https:'
+      const tileLayerIsHttp = tilelayer.options.url_template.indexOf('http:') === 0
+      if (browserIsHttps && tileLayerIsHttp) return
+      container.appendChild(this.addTileLayerElement(tilelayer, options))
+    })
+  },
+
+  addTileLayerElement: function (tilelayer, options) {
+    const selectedClass = this._umap._leafletMap.hasLayer(tilelayer) ? 'selected' : ''
+    const src = Utils.template(
+      tilelayer.options.url_template,
+      this._umap._leafletMap.options.demoTileInfos
+    )
+    const template = `
+      <li>
+        <img src="${src}" loading="lazy" />
+        <div>${tilelayer.options.name}</div>
+      </li>
+    `
+    const li = Utils.loadTemplate(template)
+    li.addEventListener('click', () => {
+      const oldTileLayer = this._umap.properties.tilelayer
+      this._umap._leafletMap.selectTileLayer(tilelayer)
+      this._umap._leafletMap._controls.tilelayers.setLayers()
+      if (options?.edit) {
+        this._umap.properties.tilelayer = tilelayer.toJSON()
+        this._umap.sync.update(
+          'properties.tilelayer',
+          this._umap.properties.tilelayer,
+          oldTileLayer
+        )
+      }
+    })
+    return li
+  },
+})

umap/static/umap/js/modules/rendering/layers/heat.js

@@ -41,6 +41,11 @@ export const Heat = L.HeatLayer.extend({
     }
   },
 
+  removeLayer: (layer) => {
+    // No op, there is no "removeLatLng" in Leaflet.heat
+    // but this method is expected by DataLayer
+  },
+
   onAdd: function (map) {
     LayerMixin.onAdd.call(this, map)
     return L.HeatLayer.prototype.onAdd.call(this, map)