umap-project 2.7.2__py3-none-any.whl → 2.8.0__py3-none-any.whl

umap/static/umap/js/modules/rendering/ui.js

@@ -52,7 +52,7 @@ const FeatureMixin = {
   onClick: function (event) {
     if (this._map.measureTools?.enabled()) return
     this._popupHandlersAdded = true // Prevent leaflet from managing event
-    if (!this._map.editEnabled) {
+    if (!this._map._umap.editEnabled) {
       this.feature.view(event)
     } else if (!this.feature.isReadOnly()) {
       if (event.originalEvent.shiftKey) {
@@ -75,7 +75,7 @@ const FeatureMixin = {
 
   resetTooltip: function () {
     if (!this.feature.hasGeom()) return
-    const displayName = this.feature.getDisplayName(null)
+    const displayName = this.feature.getDisplayName()
     let showLabel = this.feature.getOption('showLabel')
     const oldLabelHover = this.feature.getOption('labelHover')
 
@@ -96,8 +96,8 @@ const FeatureMixin = {
     DomEvent.stop(event)
     const items = this.feature
       .getContextMenuItems(event)
-      .concat(this._map.getContextMenuItems(event))
-    this._map.contextmenu.open(event.originalEvent, items)
+      .concat(this._map._umap.getSharedContextMenuItems(event))
+    this._map._umap.contextmenu.open(event.originalEvent, items)
   },
 
   onCommit: function () {
@@ -134,7 +134,7 @@ const PointMixin = {
 
   _enableDragging: function () {
     // TODO: start dragging after 1 second on mouse down
-    if (this._map.editEnabled) {
+    if (this._map._umap.editEnabled) {
       if (!this.editEnabled()) this.enableEdit()
       // Enabling dragging on the marker override the Draggable._OnDown
       // event, which, as it stopPropagation, refrain the call of
@@ -146,7 +146,7 @@ const PointMixin = {
   },
 
   _disableDragging: function () {
-    if (this._map.editEnabled) {
+    if (this._map._umap.editEnabled) {
       if (this.editor?.drawing) return // when creating a new marker, the mouse can trigger the mouseover/mouseout event
       // do not listen to them
       this.disableEdit()
@@ -238,11 +238,15 @@ export const LeafletMarker = Marker.extend({
   },
 
   highlight: function () {
-    DomUtil.addClass(this.options.icon.elements.main, 'umap-icon-active')
+    this.feature.activate()
+    this._redraw()
+    this._bringToFront()
   },
 
   resetHighlight: function () {
-    DomUtil.removeClass(this.options.icon.elements.main, 'umap-icon-active')
+    this.feature.deactivate()
+    this._redraw()
+    this._resetZIndex()
   },
 
   getPopupToolbarAnchor: function () {
@@ -253,21 +257,26 @@ export const LeafletMarker = Marker.extend({
 const PathMixin = {
   _onMouseOver: function () {
     if (this._map.measureTools?.enabled()) {
-      this._map.tooltip.open({ content: this.getMeasure(), anchor: this })
-    } else if (this._map.editEnabled && !this._map.editedFeature) {
-      this._map.tooltip.open({ content: translate('Click to edit'), anchor: this })
+      this._map._umap.tooltip.open({ content: this.getMeasure(), anchor: this })
+    } else if (this._map._umap.editEnabled && !this._map._umap.editedFeature) {
+      this._map._umap.tooltip.open({
+        content: translate('Click to edit'),
+        anchor: this,
+      })
     }
   },
 
   makeGeometryEditable: function () {
-    if (this._map.editedFeature !== this.feature) {
+    if (this._map._umap.editedFeature !== this.feature) {
       this.disableEdit()
       return
     }
     this._map.once('moveend', this.makeGeometryEditable, this)
     const pointsCount = this._parts.reduce((acc, part) => acc + part.length, 0)
     if (pointsCount > 100 && this._map.getZoom() < this._map.getMaxZoom()) {
-      this._map.tooltip.open({ content: L._('Please zoom in to edit the geometry') })
+      this._map._umap.tooltip.open({
+        content: L._('Please zoom in to edit the geometry'),
+      })
       this.disableEdit()
     } else {
       this.enableEdit()
@@ -380,10 +389,50 @@ export const LeafletPolyline = Polyline.extend({
   },
 
   getMeasure: function (shape) {
+    let shapes
+    if (shape) {
+      shapes = [shape]
+    } else if (LineUtil.isFlat(this._latlngs)) {
+      shapes = [this._latlngs]
+    } else {
+      shapes = this._latlngs
+    }
     // FIXME: compute from data in feature (with TurfJS)
-    const length = L.GeoUtil.lineLength(this._map, shape || this._defaultShape())
+    const length = shapes.reduce(
+      (acc, shape) => acc + L.GeoUtil.lineLength(this._map, shape),
+      0
+    )
     return L.GeoUtil.readableDistance(length, this._map.measureTools.getMeasureUnit())
   },
+
+  getElevation: function () {
+    const lineElevation = (latlngs) => {
+      let gain = 0
+      let loss = 0
+      for (let i = 0, n = latlngs.length - 1; i < n; i++) {
+        const fromAlt = latlngs[i].alt
+        const toAlt = latlngs[i + 1].alt
+        if (fromAlt === undefined || toAlt === undefined) continue
+        if (fromAlt > toAlt) loss += fromAlt - toAlt
+        else gain += toAlt - fromAlt
+      }
+      return [gain, loss]
+    }
+    let shapes
+    if (LineUtil.isFlat(this._latlngs)) {
+      shapes = [this._latlngs]
+    } else {
+      shapes = this._latlngs
+    }
+    let totalGain = 0
+    let totalLoss = 0
+    for (const shape of shapes) {
+      const [gain, loss] = lineElevation(shape)
+      totalGain += gain
+      totalLoss += loss
+    }
+    return [Math.round(totalGain), Math.round(totalLoss)]
+  },
 })
 
 export const LeafletPolygon = Polygon.extend({

umap/static/umap/js/modules/request.js

@@ -47,8 +47,8 @@ class BaseRequest {
 // In case of error, an alert is sent, but non 20X status are not handled
 // The consumer must check the response status by hand
 export class Request extends BaseRequest {
-  fire(name, params) {
-    document.body.dispatchEvent(new CustomEvent(name, params))
+  fire(name, detail) {
+    document.body.dispatchEvent(new CustomEvent(name, { detail }))
   }
 
   async _fetch(method, uri, headers, data) {

umap/static/umap/js/modules/rules.js

@@ -2,6 +2,7 @@ import { DomEvent, DomUtil, stamp } from '../../vendors/leaflet/leaflet-src.esm.
 import { translate } from './i18n.js'
 import * as Utils from './utils.js'
 import { AutocompleteDatalist } from './autocomplete.js'
+import Orderable from './orderable.js'
 
 const EMPTY_VALUES = ['', undefined, null]
 
@@ -21,10 +22,10 @@ class Rule {
 
   set isDirty(status) {
     this._isDirty = status
-    if (status) this.map.isDirty = status
+    if (status) this._umap.isDirty = status
   }
 
-  constructor(map, condition = '', options = {}) {
+  constructor(umap, condition = '', options = {}) {
     // TODO make this public properties when browser coverage is ok
     // cf https://caniuse.com/?search=public%20class%20field
     this._condition = null
@@ -37,14 +38,14 @@ class Rule {
       ['!=', this.not_equal],
       ['=', this.equal],
     ]
-    this.map = map
+    this._umap = umap
     this.active = true
     this.options = options
     this.condition = condition
   }
 
   render(fields) {
-    this.map.render(fields)
+    this._umap.render(fields)
   }
 
   equal(other) {
@@ -101,10 +102,6 @@ class Rule {
     return this.operator(this.cast(props[this.key]))
   }
 
-  getMap() {
-    return this.map
-  }
-
   getOption(option) {
     return this.options[option]
   }
@@ -136,7 +133,7 @@ class Rule {
     const defaultShapeProperties = DomUtil.add('div', '', container)
     defaultShapeProperties.appendChild(builder.build())
     const autocomplete = new AutocompleteDatalist(builder.helpers.condition.input)
-    const properties = this.map.allProperties()
+    const properties = this._umap.allProperties()
     autocomplete.suggestions = properties
     autocomplete.input.addEventListener('input', (event) => {
       const value = event.target.value
@@ -144,12 +141,12 @@ class Rule {
         autocomplete.suggestions = [`${value}=`, `${value}!=`, `${value}>`, `${value}<`]
       } else if (value.endsWith('=')) {
         const key = value.split('!')[0].split('=')[0]
-        autocomplete.suggestions = this.map
+        autocomplete.suggestions = this._umap
           .sortedValues(key)
           .map((str) => `${value}${str || ''}`)
       }
     })
-    this.map.editPanel.open({ content: container })
+    this._umap.editPanel.open({ content: container })
   }
 
   renderToolbox(row) {
@@ -176,7 +173,7 @@ class Rule {
       function () {
         if (!confirm(translate('Are you sure you want to delete this rule?'))) return
         this._delete()
-        this.map.editPanel.close()
+        this._umap.editPanel.close()
       },
       this
     )
@@ -186,27 +183,27 @@ class Rule {
     DomEvent.on(toggle, 'click', () => {
       this.active = !this.active
       row.classList.toggle('off', !this.active)
-      this.map.render(['rules'])
+      this._umap.render(['rules'])
     })
   }
 
   _delete() {
-    this.map.rules.rules = this.map.rules.rules.filter((rule) => rule !== this)
+    this._umap.rules.rules = this._umap.rules.rules.filter((rule) => rule !== this)
   }
 }
 
 export default class Rules {
-  constructor(map) {
-    this.map = map
+  constructor(umap) {
+    this._umap = umap
     this.rules = []
-    this.loadRules()
+    this.load()
   }
 
-  loadRules() {
-    if (!this.map.options.rules?.length) return
-    for (const { condition, options } of this.map.options.rules) {
+  load() {
+    if (!this._umap.properties.rules?.length) return
+    for (const { condition, options } of this._umap.properties.rules) {
       if (!condition) continue
-      this.rules.push(new Rule(this.map, condition, options))
+      this.rules.push(new Rule(this._umap, condition, options))
     }
   }
 
@@ -225,7 +222,7 @@ export default class Rules {
     else newIdx = referenceIdx + 1
     this.rules.splice(newIdx, 0, moved)
     moved.isDirty = true
-    this.map.render(['rules'])
+    this._umap.render(['rules'])
   }
 
   edit(container) {
@@ -236,21 +233,21 @@ export default class Rules {
         rule.renderToolbox(DomUtil.create('li', 'orderable', ul))
       }
 
-      const orderable = new U.Orderable(ul, this.onReorder.bind(this))
+      const orderable = new Orderable(ul, this.onReorder.bind(this))
     }
 
     DomUtil.createButton('umap-add', body, translate('Add rule'), this.addRule, this)
   }
 
   addRule() {
-    const rule = new Rule(this.map)
+    const rule = new Rule(this._umap)
     rule.isDirty = true
     this.rules.push(rule)
     rule.edit(map)
   }
 
   commit() {
-    this.map.options.rules = this.rules.map((rule) => {
+    this._umap.properties.rules = this.rules.map((rule) => {
       return {
         condition: rule.condition,
         options: rule.options,

umap/static/umap/js/modules/saving.js

@@ -0,0 +1,47 @@
+const _queue = new Set()
+
+export let isDirty = false
+
+export async function save() {
+  for (const obj of _queue) {
+    const ok = await obj.save()
+    if (!ok) break
+    remove(obj)
+  }
+}
+
+function add(obj) {
+  _queue.add(obj)
+  onUpdate()
+}
+
+function remove(obj) {
+  _queue.delete(obj)
+  onUpdate()
+}
+
+function has(obj) {
+  return _queue.has(obj)
+}
+
+function onUpdate() {
+  isDirty = Boolean(_queue.size)
+  document.body.classList.toggle('umap-is-dirty', isDirty)
+}
+
+export class ServerStored {
+  set isDirty(status) {
+    if (status) {
+      add(this)
+    } else {
+      remove(this)
+    }
+    this.onDirty(status)
+  }
+
+  get isDirty() {
+    return has(this)
+  }
+
+  onDirty(status) {}
+}

umap/static/umap/js/modules/schema.js

@@ -404,6 +404,7 @@ export const SCHEMA = {
       ['GeoRSSImage', translate('GeoRSS (title + image)')],
       ['GeoRSSLink', translate('GeoRSS (only link)')],
       ['OSM', translate('OpenStreetMap')],
+      ['Wikipedia', translate('Wikipedia')],
     ],
     default: 'Default',
   },
@@ -563,4 +564,9 @@ export const SCHEMA = {
     type: Object,
     impacts: ['data'],
   },
+
+  _referenceVersion: {
+    type: Number,
+    impacts: ['data'],
+  },
 }

umap/static/umap/js/modules/share.js

@@ -4,8 +4,8 @@ import { translate } from './i18n.js'
 import * as Utils from './utils.js'
 
 export default class Share {
-  constructor(map) {
-    this.map = map
+  constructor(umap) {
+    this._umap = umap
   }
 
   build() {
@@ -22,11 +22,11 @@ export default class Share {
       window.location.protocol + Utils.getBaseUrl()
     )
 
-    if (this.map.options.shortUrl) {
+    if (this._umap.properties.shortUrl) {
       DomUtil.createCopiableInput(
         this.container,
         translate('Short link'),
-        this.map.options.shortUrl
+        this._umap.properties.shortUrl
       )
     }
 
@@ -60,8 +60,8 @@ export default class Share {
       this.container,
       translate('All data and settings of the map')
     )
-    const downloadUrl = Utils.template(this.map.options.urls.map_download, {
-      map_id: this.map.options.umap_id,
+    const downloadUrl = this._umap.urls.get('map_download', {
+      map_id: this._umap.id,
     })
     const link = Utils.loadTemplate(`
       <div>
@@ -115,10 +115,11 @@ export default class Share {
       'queryString.captionBar',
       'queryString.captionMenus',
     ]
-    for (let i = 0; i < this.map.HIDDABLE_CONTROLS.length; i++) {
-      UIFields.push(`queryString.${this.map.HIDDABLE_CONTROLS[i]}Control`)
+    // TODO: move HIDDABLE_CONTROLS to SCHEMA ?
+    for (const name of this._umap._leafletMap.HIDDABLE_CONTROLS) {
+      UIFields.push(`queryString.${name}Control`)
     }
-    const iframeExporter = new IframeExporter(this.map)
+    const iframeExporter = new IframeExporter(this._umap)
     const buildIframeCode = () => {
       iframe.textContent = iframeExporter.build()
       exportUrl.value = window.location.protocol + iframeExporter.buildUrl()
@@ -136,13 +137,13 @@ export default class Share {
 
   open() {
     if (!this.container) this.build()
-    this.map.panel.open({ content: this.container })
+    this._umap.panel.open({ content: this.container })
   }
 
   async format(mode) {
     const type = EXPORT_FORMATS[mode]
-    const content = await type.formatter(this.map)
-    const filename = Utils.slugify(this.map.options.name) + type.ext
+    const content = await type.formatter(this._umap)
+    const filename = Utils.slugify(this._umap.properties.name) + type.ext
     return { content, filetype: type.filetype, filename }
   }
 
@@ -161,8 +162,8 @@ export default class Share {
 }
 
 class IframeExporter {
-  constructor(map) {
-    this.map = map
+  constructor(umap) {
+    this._umap = umap
     this.baseUrl = Utils.getBaseUrl()
     this.options = {
       includeFullScreenLink: true,
@@ -192,24 +193,20 @@ class IframeExporter {
       height: '300px',
     }
     // Use map default, not generic default
-    this.queryString.onLoadPanel = this.map.getOption('onLoadPanel')
-  }
-
-  getMap() {
-    return this.map
+    this.queryString.onLoadPanel = this._umap.getProperty('onLoadPanel')
   }
 
   buildUrl(options) {
     const datalayers = []
-    if (this.options.viewCurrentFeature && this.map.currentFeature) {
-      this.queryString.feature = this.map.currentFeature.getSlug()
+    if (this.options.viewCurrentFeature && this._umap.currentFeature) {
+      this.queryString.feature = this._umap.currentFeature.getSlug()
     } else {
       delete this.queryString.feature
     }
     if (this.options.keepCurrentDatalayers) {
-      this.map.eachDataLayer((datalayer) => {
-        if (datalayer.isVisible() && datalayer.umap_id) {
-          datalayers.push(datalayer.umap_id)
+      this._umap.eachDataLayer((datalayer) => {
+        if (datalayer.isVisible() && datalayer.createdOnServer) {
+          datalayers.push(datalayer.id)
         }
       })
       this.queryString.datalayers = datalayers.join(',')

umap/static/umap/js/modules/slideshow.js

@@ -13,26 +13,22 @@ const TOOLBOX_TEMPLATE = `
 `
 
 export default class Slideshow extends WithTemplate {
-  constructor(map, options) {
+  constructor(umap, leafletMap, properties) {
     super()
-    this.map = map
+    this._umap = umap
     this._id = null
     this.CLASSNAME = 'umap-slideshow-active'
-    this.setOptions(options)
+    this.load()
     this._current = null
 
-    if (this.options.autoplay) {
-      this.map.onceDataLoaded(function () {
+    if (this.properties.autoplay) {
+      this._umap.onceDataLoaded(function () {
         this.play()
       }, this)
     }
-    this.map.on(
-      'edit:enabled',
-      function () {
-        this.stop()
-      },
-      this
-    )
+    leafletMap.on('edit:enabled', () => {
+      this.stop()
+    })
   }
 
   set current(feature) {
@@ -54,22 +50,26 @@ export default class Slideshow extends WithTemplate {
     return this.current.getNext()
   }
 
-  setOptions(options) {
-    this.options = Object.assign(
+  load() {
+    this.setProperties(this._umap.properties.slideshow)
+  }
+
+  setProperties(properties = {}) {
+    this.properties = Object.assign(
       {
         delay: 5000,
         autoplay: false,
       },
-      options
+      properties
     )
   }
 
   defaultDatalayer() {
-    return this.map.findDataLayer((d) => d.canBrowse())
+    return this._umap.findDataLayer((d) => d.canBrowse())
   }
 
   startSpinner() {
-    const time = Number.parseInt(this.options.delay, 10)
+    const time = Number.parseInt(this.properties.delay, 10)
     if (!time) return
     const css = `rotation ${time / 1000}s infinite linear`
     const spinner = document.querySelector('.umap-slideshow-toolbox .play .spinner')
@@ -81,11 +81,15 @@ export default class Slideshow extends WithTemplate {
     spinner.style.animation = 'none'
   }
 
+  isEnabled() {
+    return Boolean(this.properties.active)
+  }
+
   play() {
     if (this._id) return
-    if (this.map.editEnabled || !this.map.options.slideshow.active) return
+    if (this._umap.editEnabled || !this.isEnabled()) return
     L.DomUtil.addClass(document.body, this.CLASSNAME)
-    this._id = window.setInterval(L.bind(this.loop, this), this.options.delay)
+    this._id = window.setInterval(L.bind(this.loop, this), this.properties.delay)
     this.startSpinner()
     this.loop()
   }
@@ -123,7 +127,7 @@ export default class Slideshow extends WithTemplate {
 
   step() {
     if (!this.current) return this.stop()
-    this.current.zoomTo({ easing: this.options.easing })
+    this.current.zoomTo({ easing: this.properties.easing })
     this.current.view()
   }
 

umap/static/umap/js/modules/sync/updaters.js

@@ -6,8 +6,8 @@ import { fieldInSchema } from '../utils.js'
  */
 
 class BaseUpdater {
-  constructor(map) {
-    this.map = map
+  constructor(umap) {
+    this._umap = umap
   }
 
   updateObjectValue(obj, key, value) {
@@ -32,8 +32,7 @@ class BaseUpdater {
   }
 
   getDataLayerFromID(layerId) {
-    if (layerId) return this.map.getDataLayerByUmapId(layerId)
-    return this.map.defaultEditDataLayer()
+    return this._umap.getDataLayerByUmapId(layerId)
   }
 
   applyMessage(payload) {
@@ -45,18 +44,17 @@ class BaseUpdater {
 export class MapUpdater extends BaseUpdater {
   update({ key, value }) {
     if (fieldInSchema(key)) {
-      this.updateObjectValue(this.map, key, value)
+      this.updateObjectValue(this._umap, key, value)
     }
 
-    this.map.render([key])
+    this._umap.render([key])
   }
 }
 
 export class DataLayerUpdater extends BaseUpdater {
   upsert({ value }) {
-    // Inserts does not happen (we use multiple updates instead).
-    this.map.createDataLayer(value, false)
-    this.map.render([])
+    // Upsert only happens when a new datalayer is created.
+    this._umap.createDataLayer(value, false)
   }
 
   update({ key, metadata, value }) {