umap-project 2.9.3__py3-none-any.whl → 3.0.1__py3-none-any.whl

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

@@ -1,44 +1,41 @@
 import {
   DomUtil,
   Util as LeafletUtil,
-  stamp,
   latLngBounds,
+  stamp,
 } from '../../vendors/leaflet/leaflet-src.esm.js'
-import { translate, setLocale, getLocale } from './i18n.js'
-import * as Utils from './utils.js'
-import { ServerStored } from './saving.js'
-import * as SAVEMANAGER from './saving.js'
-import { SyncEngine } from './sync/engine.js'
-import { LeafletMap } from './rendering/map.js'
-import URLs from './urls.js'
-import { Panel, EditPanel, FullPanel } from './ui/panel.js'
-import Dialog from './ui/dialog.js'
-import { BottomBar, TopBar, EditBar } from './ui/bar.js'
-import Tooltip from './ui/tooltip.js'
-import ContextMenu from './ui/contextmenu.js'
-import { Request, ServerRequest } from './request.js'
-import Help from './help.js'
-import { Formatter } from './formatter.js'
-import Slideshow from './slideshow.js'
-import { MapPermissions } from './permissions.js'
-import { SCHEMA } from './schema.js'
-import { DataLayer } from './data/layer.js'
-import Facets from './facets.js'
+import {
+  uMapAlert as Alert,
+  uMapAlertCreation as AlertCreation,
+} from '../components/alerts/alert.js'
 import Browser from './browser.js'
 import Caption from './caption.js'
+import { DataLayer } from './data/layer.js'
+import Facets from './facets.js'
+import { MutatingForm } from './form/builder.js'
+import { Formatter } from './formatter.js'
+import Help from './help.js'
+import { getLocale, setLocale, translate } from './i18n.js'
 import Importer from './importer.js'
+import Orderable from './orderable.js'
+import { MapPermissions } from './permissions.js'
+import { LeafletMap } from './rendering/map.js'
+import { Request, ServerRequest } from './request.js'
 import Rules from './rules.js'
+import { SCHEMA } from './schema.js'
 import Share from './share.js'
-import {
-  uMapAlertCreation as AlertCreation,
-  uMapAlert as Alert,
-} from '../components/alerts/alert.js'
-import Orderable from './orderable.js'
-import { MutatingForm } from './form/builder.js'
+import Slideshow from './slideshow.js'
+import { SyncEngine } from './sync/engine.js'
+import { BottomBar, EditBar, TopBar } from './ui/bar.js'
+import ContextMenu from './ui/contextmenu.js'
+import Dialog from './ui/dialog.js'
+import { EditPanel, FullPanel, Panel } from './ui/panel.js'
+import Tooltip from './ui/tooltip.js'
+import URLs from './urls.js'
+import * as Utils from './utils.js'
 
-export default class Umap extends ServerStored {
+export default class Umap {
   constructor(element, geojson) {
-    super()
     // We need to call async function in the init process,
     // the init itself does not need to be awaited, but some calls
     // in the process must be blocker
@@ -96,15 +93,19 @@ export default class Umap extends ServerStored {
         this._leafletMap.latLng(center)
     }
 
+    // Needed for permissions
+    this.syncEngine = new SyncEngine(this)
+    this.sync = this.syncEngine.proxy(this)
+
     // Needed to render controls
     this.permissions = new MapPermissions(this)
     this.urls = new URLs(this.properties.urls)
     this.slideshow = new Slideshow(this, this._leafletMap)
 
-    this._leafletMap.setup()
-
     if (geojson.properties.schema) this.overrideSchema(geojson.properties.schema)
 
+    this._leafletMap.setup()
+
     this.panel = new Panel(this, this._leafletMap)
     this.dialog = new Dialog({ className: 'dark' })
     this.topBar = new TopBar(this, this._leafletMap._controlContainer)
@@ -130,9 +131,6 @@ export default class Umap extends ServerStored {
     this.share = new Share(this)
     this.rules = new Rules(this)
 
-    this.syncEngine = new SyncEngine(this)
-    this.sync = this.syncEngine.proxy(this)
-
     if (this.hasEditMode()) {
       this.editPanel = new EditPanel(this, this._leafletMap)
       this.fullPanel = new FullPanel(this, this._leafletMap)
@@ -196,7 +194,6 @@ export default class Umap extends ServerStored {
     // Creation mode
     if (!this.id) {
       if (!this.properties.preview) {
-        this.isDirty = true
         this.enableEdit()
       }
       this._defaultExtent = true
@@ -212,10 +209,14 @@ export default class Umap extends ServerStored {
       this.propagate()
     }
 
-    window.onbeforeunload = () => (this.editEnabled && SAVEMANAGER.isDirty) || null
+    window.onbeforeunload = () => (this.editEnabled && this.isDirty) || null
     this.backup()
   }
 
+  get isDirty() {
+    return this.sync._undoManager.isDirty()
+  }
+
   get editedFeature() {
     return this._editedFeature
   }
@@ -349,7 +350,7 @@ export default class Umap extends ServerStored {
     const items = []
     if (this.hasEditMode()) {
       if (this.editEnabled) {
-        if (!SAVEMANAGER.isDirty) {
+        if (!this.isDirty) {
           items.push({
             label: this.help.displayLabel('STOP_EDIT'),
             action: () => this.disableEdit(),
@@ -498,92 +499,88 @@ export default class Umap extends ServerStored {
   }
 
   initShortcuts() {
-    const globalShortcuts = (event) => {
-      if (event.key === 'Escape') {
-        if (this.importer.dialog.visible) {
-          this.importer.dialog.close()
-        } else if (this.editEnabled && this._leafletMap.editTools.drawing()) {
-          this._leafletMap.editTools.onEscape()
-        } else if (this._leafletMap.measureTools.enabled()) {
-          this._leafletMap.measureTools.stopDrawing()
-        } else if (this.fullPanel?.isOpen()) {
-          this.fullPanel?.close()
-        } else if (this.editPanel?.isOpen()) {
-          this.editPanel?.close()
-        } else if (this.panel.isOpen()) {
-          this.panel.close()
-        }
-      }
-
-      // From now on, only ctrl/meta shortcut
-      if (!(event.ctrlKey || event.metaKey) || event.shiftKey) return
-
-      if (event.key === 'f') {
-        event.stopPropagation()
-        event.preventDefault()
-        this.search()
-      }
-
-      /* Edit mode only shortcuts */
-      if (!this.hasEditMode()) return
-
-      // Edit mode Off
-      if (!this.editEnabled) {
-        switch (event.key) {
-          case 'e':
-            event.stopPropagation()
-            event.preventDefault()
-            this.enableEdit()
-            break
-        }
-        return
-      }
-
-      // Edit mode on
-      let used = true
-      switch (event.key) {
-        case 'e':
-          if (!SAVEMANAGER.isDirty) this.disableEdit()
-          break
-        case 's':
-          if (SAVEMANAGER.isDirty) this.saveAll()
-          break
-        case 'z':
-          if (Utils.isWritable(event.target)) {
-            used = false
-            break
+    const shortcuts = {
+      Escape: {
+        do: () => {
+          if (this.importer.dialog.visible) {
+            this.importer.dialog.close()
+          } else if (this.editEnabled && this._leafletMap.editTools.drawing()) {
+            this._leafletMap.editTools.onEscape()
+          } else if (this._leafletMap.measureTools.enabled()) {
+            this._leafletMap.measureTools.stopDrawing()
+          } else if (this.fullPanel?.isOpen()) {
+            this.fullPanel?.close()
+          } else if (this.editPanel?.isOpen()) {
+            this.editPanel?.close()
+          } else if (this.panel.isOpen()) {
+            this.panel.close()
           }
-          if (SAVEMANAGER.isDirty) {
-            this.askForReset()
-          }
-          break
-        case 'm':
-          this._leafletMap.editTools.startMarker()
-          break
-        case 'p':
-          this._leafletMap.editTools.startPolygon()
-          break
-        case 'l':
-          this._leafletMap.editTools.startPolyline()
-          break
-        case 'i':
-          this.importer.open()
-          break
-        case 'o':
-          this.importer.openFiles()
-          break
-        case 'h':
-          this.help.showGetStarted()
-          break
-        default:
-          used = false
-      }
-      if (used) {
+        },
+      },
+      'Ctrl+f': {
+        do: () => {
+          this.search()
+        },
+      },
+      'Ctrl+e': {
+        if: () => this.hasEditMode(),
+        do: () => {
+          console.log('doing')
+          if (!this.editEnabled) this.enableEdit()
+          else if (!this.isDirty) this.disableEdit()
+        },
+      },
+      'Ctrl+s': {
+        if: () => this.editEnabled && this.isDirty,
+        do: () => this.saveAll(),
+      },
+      'Ctrl+z': {
+        if: () => this.editEnabled && !Utils.isWritable(event.target),
+        do: () => this.sync._undoManager.undo(),
+      },
+      'Ctrl+Shift+Z': {
+        if: () => this.editEnabled && !Utils.isWritable(event.target),
+        do: () => this.sync._undoManager.redo(),
+      },
+      'Ctrl+m': {
+        if: () => this.editEnabled,
+        do: () => this._leafletMap.editTools.startMarker(),
+      },
+      'Ctrl+p': {
+        if: () => this.editEnabled,
+        do: () => this._leafletMap.editTools.startPolygon(),
+      },
+      'Ctrl+l': {
+        if: () => this.editEnabled,
+        do: () => this._leafletMap.editTools.startPolyline(),
+      },
+      'Ctrl+i': {
+        if: () => this.editEnabled,
+        do: () => this.importer.open(),
+      },
+      'Ctrl+o': {
+        if: () => this.editEnabled,
+        do: () => this.importer.openFiles(),
+      },
+      'Ctrl+h': {
+        if: () => this.editEnabled,
+        do: () => this.help.showGetStarted(),
+      },
+    }
+    const onKeyDown = (event) => {
+      const shiftKey = event.shiftKey ? 'Shift+' : ''
+      const altKey = event.altKey ? 'Alt+' : ''
+      const ctrlKey = event.ctrlKey || event.metaKey ? 'Ctrl+' : ''
+      const combination = `${ctrlKey}${shiftKey}${altKey}${event.key}`
+
+      const shortcut = shortcuts[combination]
+      if (shortcut && (!shortcut.if || shortcut.if())) {
+        shortcut.do()
         event.stopPropagation()
         event.preventDefault()
       }
     }
-    document.addEventListener('keydown', globalShortcuts)
+    document.addEventListener('keydown', onKeyDown)
   }
 
   async initDataLayers(datalayers) {
@@ -671,10 +668,10 @@ export default class Umap extends ServerStored {
   }
 
   async saveAll() {
-    if (!SAVEMANAGER.isDirty) return
+    if (!this.isDirty) return
     if (this._defaultExtent) this._setCenterAndZoom()
     this.backup()
-    await SAVEMANAGER.save()
+    await this.sync.save()
     // Do a blind render for now, as we are not sure what could
     // have changed, we'll be more subtil when we'll remove the
     // save action
@@ -685,7 +682,6 @@ export default class Umap extends ServerStored {
         Alert.success(translate('Map has been saved!'))
       })
     }
-    this.sync.saved()
     this.fire('saved')
   }
 
@@ -757,6 +753,12 @@ export default class Umap extends ServerStored {
     const form = builder.build()
     container.appendChild(form)
 
+    const tags = DomUtil.createFieldset(container, translate('Tags'))
+    const tagsFields = ['properties.tags']
+    const tagsBuilder = new MutatingForm(this, tagsFields, {
+      umap: this,
+    })
+    tags.appendChild(tagsBuilder.build())
     const credits = DomUtil.createFieldset(container, translate('Credits'))
     const creditsFields = [
       'properties.licence',
@@ -1019,35 +1021,36 @@ export default class Umap extends ServerStored {
       'button',
       boundsButtons,
       translate('Use current bounds'),
-      function () {
+      () => {
         const bounds = this._leafletMap.getBounds()
+        const oldLimitBounds = { ...this.properties.limitBounds }
         this.properties.limitBounds.south = LeafletUtil.formatNum(bounds.getSouth())
         this.properties.limitBounds.west = LeafletUtil.formatNum(bounds.getWest())
         this.properties.limitBounds.north = LeafletUtil.formatNum(bounds.getNorth())
         this.properties.limitBounds.east = LeafletUtil.formatNum(bounds.getEast())
         boundsBuilder.fetchAll()
-
-        this.sync.update(this, 'properties.limitBounds', this.properties.limitBounds)
-        this.isDirty = true
-        this._leafletMap.handleLimitBounds()
-      },
-      this
-    )
-    DomUtil.createButton(
-      'button',
-      boundsButtons,
-      translate('Empty'),
-      function () {
-        this.properties.limitBounds.south = null
-        this.properties.limitBounds.west = null
-        this.properties.limitBounds.north = null
-        this.properties.limitBounds.east = null
-        boundsBuilder.fetchAll()
-        this.isDirty = true
+        this.sync.update(
+          'properties.limitBounds',
+          this.properties.limitBounds,
+          oldLimitBounds
+        )
         this._leafletMap.handleLimitBounds()
-      },
-      this
+      }
     )
+    DomUtil.createButton('button', boundsButtons, translate('Empty'), () => {
+      const oldLimitBounds = { ...this.properties.limitBounds }
+      this.properties.limitBounds.south = null
+      this.properties.limitBounds.west = null
+      this.properties.limitBounds.north = null
+      this.properties.limitBounds.east = null
+      boundsBuilder.fetchAll()
+      this._leafletMap.handleLimitBounds()
+      this.sync.update(
+        'properties.limitBounds',
+        this.properties.limitBounds,
+        oldLimitBounds
+      )
+    })
   }
 
   _editSlideshow(container) {
@@ -1160,23 +1163,7 @@ export default class Umap extends ServerStored {
     })
   }
 
-  reset() {
-    if (this._leafletMap.editTools) this._leafletMap.editTools.stopDrawing()
-    this.resetProperties()
-    this.datalayersIndex = [].concat(this._datalayersIndex_bk)
-    // Iter over all datalayers, including deleted if any.
-    for (const datalayer of Object.values(this.datalayers)) {
-      if (datalayer.isDeleted) datalayer.connectToMap()
-      if (datalayer.isDirty) datalayer.reset()
-    }
-    this.ensurePanesOrder()
-    this._leafletMap.initTileLayers()
-    this.onDataLayersChanged()
-    this.isDirty = !this.id
-  }
-
   async save() {
-    this.rules.commit()
     const geojson = {
       type: 'Feature',
       geometry: this.geometry(),
@@ -1185,6 +1172,7 @@ export default class Umap extends ServerStored {
     const formData = new FormData()
     formData.append('name', this.properties.name)
     formData.append('center', JSON.stringify(this.geometry()))
+    formData.append('tags', this.properties.tags || [])
     formData.append('settings', JSON.stringify(geojson))
     const uri = this.urls.get('map_save', { map_id: this.id })
     const [data, _, error] = await this.server.post(uri, {}, formData)
@@ -1301,16 +1289,6 @@ export default class Umap extends ServerStored {
     this._leafletMap.fire(name)
   }
 
-  askForReset(e) {
-    if (this.getProperty('syncEnabled')) return
-    this.dialog
-      .confirm(translate('Are you sure you want to cancel your changes?'))
-      .then(() => {
-        this.reset()
-        this.disableEdit()
-      })
-  }
-
   async initSyncEngine() {
     // this.properties.websocketEnabled is set by the server admin
     if (this.properties.websocketEnabled === false) return
@@ -1324,11 +1302,14 @@ export default class Umap extends ServerStored {
 
   getSyncMetadata() {
     return {
-      engine: this.sync,
       subject: 'map',
     }
   }
 
+  onPropertiesUpdated(fields = []) {
+    this._leafletMap.pullProperties()
+  }
+
   render(fields = []) {
     // Propagate will remove the fields it has already
     // processed
@@ -1344,6 +1325,9 @@ export default class Umap extends ServerStored {
           this.bottomBar.redraw()
           break
         case 'data':
+          if (fields.includes('properties.rules')) {
+            this.rules.load()
+          }
           this.eachVisibleDataLayer((datalayer) => {
             datalayer.redraw()
           })
@@ -1518,7 +1502,7 @@ export default class Umap extends ServerStored {
       const form = builder.build()
       row.appendChild(form)
       row.classList.toggle('off', !datalayer.isVisible())
-      row.dataset.id = stamp(datalayer)
+      row.dataset.id = datalayer.id
     })
     const onReorder = (src, dst, initialIndex, finalIndex) => {
       const movedLayer = this.datalayers[src.dataset.id]
@@ -1549,7 +1533,7 @@ export default class Umap extends ServerStored {
   }
 
   getDataLayerByUmapId(id) {
-    const datalayer = this.findDataLayer((d) => d.id === id)
+    const datalayer = this.datalayers[id]
     if (!datalayer) throw new Error(`Can't find datalayer with id ${id}`)
     return datalayer
   }
@@ -1630,7 +1614,16 @@ export default class Umap extends ServerStored {
 
   importRaw(rawData) {
     const importedData = JSON.parse(rawData)
-
+    let remoteOrigin = ''
+    if (importedData.uri) {
+      const uri = new URL(importedData.uri)
+      if (uri.origin !== window.location.origin) {
+        remoteOrigin = uri.origin
+      }
+    }
+    if (importedData.properties?.iconUrl?.startsWith('/')) {
+      importedData.properties.iconUrl = remoteOrigin + importedData.properties.iconUrl
+    }
     this.setProperties(importedData.properties)
 
     if (importedData.geometry) {
@@ -1642,6 +1635,9 @@ export default class Umap extends ServerStored {
         delete geojson._storage
       }
       delete geojson._umap_options?.id // Never trust an id at this stage
+      if (geojson._umap_options?.iconUrl?.startsWith('/')) {
+        geojson._umap_options.iconUrl = remoteOrigin + geojson._umap_options.iconUrl
+      }
       const dataLayer = this.createDirtyDataLayer(geojson._umap_options)
       dataLayer.fromUmapGeoJSON(geojson)
     }
@@ -1653,7 +1649,6 @@ export default class Umap extends ServerStored {
     )
     this.render(fields)
     this._leafletMap._setDefaultCenter()
-    this.isDirty = true
   }
 
   importUmapFile(file) {
@@ -1747,14 +1742,33 @@ export default class Umap extends ServerStored {
   }
 
   setCenterAndZoom() {
-    this._setCenterAndZoom()
+    this._setCenterAndZoom(true)
     Alert.success(translate('The zoom and center have been modified.'))
   }
 
-  _setCenterAndZoom() {
+  _setCenterAndZoom(manual) {
+    const oldCenter = { ...this.properties.center }
+    const oldZoom = this.properties.zoom
     this.properties.center = this._leafletMap.getCenter()
     this.properties.zoom = this._leafletMap.getZoom()
-    this.isDirty = true
     this._defaultExtent = false
+    if (manual) {
+      this.sync.startBatch()
+      this.sync.update('properties.center', this.properties.center, oldCenter)
+      this.sync.update('properties.zoom', this.properties.zoom, oldZoom)
+      this.sync.commitBatch()
+    }
+  }
+
+  getStaticPathFor(name) {
+    return SCHEMA.iconUrl.default.replace('marker.svg', name)
+  }
+
+  undo() {
+    this.sync._undoManager.undo()
+  }
+
+  redo() {
+    this.sync._undoManager.redo()
   }
 }

umap/static/umap/js/modules/utils.js

@@ -117,6 +117,7 @@ export function escapeHTML(s) {
       'dd',
       'b',
       'i',
+      'kbd',
     ],
     ADD_ATTR: [
       'target',
@@ -125,6 +126,7 @@ export function escapeHTML(s) {
       'frameborder',
       'scrolling',
       'controls',
+      'class',
     ],
     ALLOWED_ATTR: ['href', 'src', 'width', 'height', 'style', 'dir', 'title', 'type'],
     // Added: `geo:` URL scheme as defined in RFC5870:
@@ -368,10 +370,13 @@ export function isDataImage(value) {
  *                     characters and no diacritics.
  */
 export function normalize(s) {
-  return (s || '')
-    .toLowerCase()
-    .normalize('NFD')
-    .replace(/[\u0300-\u036f]/g, '')
+  return (
+    (s || '')
+      .toLowerCase()
+      .normalize('NFD')
+      // biome-ignore lint/suspicious/noMisleadingCharacterClass: <explanation>
+      .replace(/[\u0300-\u036f]/g, '')
+  )
 }
 
 // Vendorized from leaflet.utils
@@ -481,6 +486,27 @@ export const debounce = (callback, wait) => {
   }
 }
 
+export function setObjectValue(obj, key, value) {
+  const parts = key.split('.')
+  const lastKey = parts.pop()
+
+  // Reduce the current list of attributes,
+  // to find the object to set the property onto
+  const objectToSet = parts.reduce((currentObj, part) => {
+    if (currentObj !== undefined && part in currentObj) return currentObj[part]
+  }, obj)
+
+  // In case the given path doesn't exist, stop here
+  if (objectToSet === undefined) return
+
+  // Set the value (or delete it)
+  if (typeof value === 'undefined') {
+    delete objectToSet[lastKey]
+  } else {
+    objectToSet[lastKey] = value
+  }
+}
+
 export const COLORS = [
   'Black',
   'Navy',