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

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

@@ -44,6 +44,10 @@ export const SCHEMA = {
     type: Object,
     impacts: ['data'],
   },
+  center: {
+    type: Object,
+    impacts: [], // default center, doesn't need any update of the map
+  },
   color: {
     type: String,
     impacts: ['data'],
@@ -118,6 +122,9 @@ export const SCHEMA = {
     default: false,
     label: translate('Animated transitions'),
   },
+  edit_status: {
+    type: Number,
+  },
   editinosmControl: {
     type: Boolean,
     impacts: ['ui'],
@@ -125,6 +132,9 @@ export const SCHEMA = {
     label: translate('Display the control to open OpenStreetMap editor'),
     default: null,
   },
+  editors: {
+    type: Array,
+  },
   embedControl: {
     type: Boolean,
     impacts: ['ui'],
@@ -204,6 +214,7 @@ export const SCHEMA = {
       ['Circle', translate('Circle')],
       ['Drop', translate('Drop')],
       ['Ball', translate('Ball')],
+      ['Raw', translate('None')],
     ],
     default: 'Default',
   },
@@ -362,6 +373,9 @@ export const SCHEMA = {
     type: Object,
     impacts: ['background'],
   },
+  owner: {
+    type: Object,
+  },
   permanentCredit: {
     type: 'Text',
     impacts: ['ui'],
@@ -436,6 +450,9 @@ export const SCHEMA = {
     label: translate('Display the search control'),
     default: true,
   },
+  share_status: {
+    type: Number,
+  },
   shortCredit: {
     type: String,
     impacts: ['ui'],
@@ -500,6 +517,12 @@ export const SCHEMA = {
     helpEntries: ['sync'],
     default: false,
   },
+  tags: {
+    type: Array,
+  },
+  team: {
+    type: Object,
+  },
   tilelayer: {
     type: Object,
     impacts: ['background'],
@@ -566,7 +589,6 @@ export const SCHEMA = {
     type: Object,
     impacts: ['data'],
   },
-
   _referenceVersion: {
     type: Number,
     impacts: ['data'],

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

@@ -1,8 +1,8 @@
 import { DomUtil } from '../../vendors/leaflet/leaflet-src.esm.js'
+import { MutatingForm } from './form/builder.js'
 import { EXPORT_FORMATS } from './formatter.js'
 import { translate } from './i18n.js'
 import * as Utils from './utils.js'
-import { MutatingForm } from './form/builder.js'
 
 export default class Share {
   constructor(umap) {

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

@@ -18,6 +18,7 @@ export default class Slideshow extends WithTemplate {
     this._umap = umap
     this._id = null
     this.CLASSNAME = 'umap-slideshow-active'
+    this._umap.properties.slideshow ??= {}
     this.load()
     this._current = null
 

umap/static/umap/js/modules/sync/engine.js

@@ -1,8 +1,14 @@
 import * as Utils from '../utils.js'
 import { HybridLogicalClock } from './hlc.js'
-import { DataLayerUpdater, FeatureUpdater, MapUpdater } from './updaters.js'
+import { UndoManager } from './undo.js'
+import {
+  DataLayerUpdater,
+  FeatureUpdater,
+  MapUpdater,
+  MapPermissionsUpdater,
+  DataLayerPermissionsUpdater,
+} from './updaters.js'
 import { WebSocketTransport } from './websocket.js'
-import * as SaveManager from '../saving.js'
 
 // Start reconnecting after 2 seconds, then double the delay each time
 // maxing out at 32 seconds.
@@ -55,6 +61,8 @@ export class SyncEngine {
       map: new MapUpdater(umap),
       feature: new FeatureUpdater(umap),
       datalayer: new DataLayerUpdater(umap),
+      mappermissions: new MapPermissionsUpdater(umap),
+      datalayerpermissions: new DataLayerPermissionsUpdater(umap),
     }
     this.transport = undefined
     this._operations = new Operations()
@@ -64,6 +72,7 @@ export class SyncEngine {
     this.websocketConnected = false
     this.closeRequested = false
     this.peerId = Utils.generateId()
+    this._undoManager = new UndoManager(umap, this.updaters, this)
   }
 
   get isOpen() {
@@ -122,16 +131,107 @@ export class SyncEngine {
       await this.authenticate()
     }, this._reconnectDelay)
   }
-  upsert(subject, metadata, value) {
-    this._send({ verb: 'upsert', subject, metadata, value })
+
+  startBatch() {
+    this._batch = []
+  }
+
+  commitBatch(subject, metadata) {
+    if (!this._batch.length) {
+      this._batch = null
+      return
+    }
+    const operations = this._batch.map((stage) => stage.operation)
+    const operation = { verb: 'batch', operations, subject, metadata }
+    this._undoManager.add({ operation, stages: this._batch })
+    this._send(operation)
+    this._batch = null
+  }
+
+  upsert(subject, metadata, value, oldValue) {
+    const operation = {
+      verb: 'upsert',
+      subject,
+      metadata,
+      value,
+    }
+    const stage = {
+      operation,
+      newValue: value,
+      oldValue: oldValue,
+    }
+    if (this._batch) {
+      this._batch.push(stage)
+      return
+    }
+    this._undoManager.add(stage)
+    this._send(operation)
   }
 
-  update(subject, metadata, key, value) {
-    this._send({ verb: 'update', subject, metadata, key, value })
+  update(subject, metadata, key, value, oldValue, { undo } = { undo: true }) {
+    const operation = {
+      verb: 'update',
+      subject,
+      metadata,
+      key,
+      value,
+    }
+    const stage = {
+      operation,
+      oldValue: oldValue,
+      newValue: value,
+    }
+    if (this._batch) {
+      this._batch.push(stage)
+      return
+    }
+    if (undo) this._undoManager.add(stage)
+    this._send(operation)
+  }
+
+  delete(subject, metadata, oldValue) {
+    const operation = {
+      verb: 'delete',
+      subject,
+      metadata,
+    }
+    const stage = {
+      operation,
+      oldValue: oldValue,
+    }
+    if (this._batch) {
+      this._batch.push(stage)
+      return
+    }
+    this._undoManager.add(stage)
+    this._send(operation)
   }
 
-  delete(subject, metadata, key) {
-    this._send({ verb: 'delete', subject, metadata, key })
+  async save() {
+    const needSave = new Map()
+    if (!this._umap.id) {
+      // There is no operation for first map save
+      needSave.set(this._umap, [])
+    }
+    for (const operation of this._operations.sorted()) {
+      if (operation.dirty) {
+        const updater = this._getUpdater(operation.subject)
+        const obj = updater.getStoredObject(operation.metadata)
+        if (!needSave.has(obj)) {
+          needSave.set(obj, [])
+        }
+        needSave.get(obj).push(operation)
+      }
+    }
+    for (const [obj, operations] of needSave.entries()) {
+      const ok = await obj.save()
+      if (!ok) break
+      for (const operation of operations) {
+        operation.dirty = false
+      }
+    }
+    this.saved()
+    this._undoManager.toggleState()
   }
 
   saved() {
@@ -144,8 +244,8 @@ export class SyncEngine {
     }
   }
 
-  _send(inputMessage) {
-    const message = this._operations.addLocal(inputMessage)
+  _send(operation) {
+    const message = this._operations.addLocal(operation)
 
     if (this.offline) return
     if (this.transport) {
@@ -153,7 +253,11 @@ export class SyncEngine {
     }
   }
 
-  _getUpdater(subject, metadata) {
+  _getUpdater(subject, metadata, sync) {
+    // For now, prevent permissions to be synced, for security reasons
+    if (sync && (subject === 'mappermissions' || subject === 'datalayerpermissions')) {
+      return
+    }
     if (Object.keys(this.updaters).includes(subject)) {
       return this.updaters[subject]
     }
@@ -161,7 +265,15 @@ export class SyncEngine {
   }
 
   _applyOperation(operation) {
+    if (operation.verb === 'batch') {
+      operation.operations.map((op) => this._applyOperation(op))
+      return
+    }
     const updater = this._getUpdater(operation.subject, operation.metadata)
+    if (!updater) {
+      debug('No updater for', operation)
+      return
+    }
     updater.applyMessage(operation)
   }
 
@@ -304,9 +416,8 @@ export class SyncEngine {
 
   onSavedMessage({ sender, lastKnownHLC }) {
     debug(`received saved message from peer ${sender}`, lastKnownHLC)
-    if (lastKnownHLC === this._operations.getLastKnownHLC() && SaveManager.isDirty) {
-      SaveManager.clear()
-    }
+    this._operations.saved(lastKnownHLC)
+    this._undoManager.toggleState()
   }
 
   /**
@@ -356,7 +467,7 @@ export class SyncEngine {
     const handler = {
       get(target, prop) {
         // Only proxy these methods
-        if (['upsert', 'update', 'delete'].includes(prop)) {
+        if (['upsert', 'update', 'delete', 'commitBatch'].includes(prop)) {
           const { subject, metadata } = object.getSyncMetadata()
           // Reflect.get is calling the original method.
           // .bind is adding the parameters automatically
@@ -378,16 +489,22 @@ export class Operations {
     this._operations = new Array()
   }
 
+  saved(hlc) {
+    for (const operation of this.getOperationsBefore(hlc)) {
+      operation.dirty = false
+    }
+  }
+
   /**
    * Tick the clock and store the passed message in the operations list.
    *
    * @param {*} inputMessage
    * @returns {*} clock-aware message
    */
-  addLocal(inputMessage) {
-    const message = { ...inputMessage, hlc: this._hlc.tick() }
-    this._operations.push(message)
-    return message
+  addLocal(operation) {
+    operation.hlc = this._hlc.tick()
+    this._operations.push(operation)
+    return operation
   }
 
   /**
@@ -445,6 +562,11 @@ export class Operations {
     return this._operations.filter((op) => op.hlc > hlc)
   }
 
+  getOperationsBefore(hlc) {
+    if (!hlc) return this._operations
+    return this._operations.filter((op) => op.hlc <= hlc)
+  }
+
   /**
    * Returns the last known HLC value.
    */

umap/static/umap/js/modules/sync/undo.js

@@ -0,0 +1,101 @@
+import * as Utils from '../utils.js'
+import { DataLayerUpdater, FeatureUpdater, MapUpdater } from './updaters.js'
+
+export class UndoManager {
+  constructor(umap, updaters, syncEngine) {
+    this._umap = umap
+    this._syncEngine = syncEngine
+    this.updaters = updaters
+    this._undoStack = []
+    this._redoStack = []
+  }
+
+  toggleState() {
+    // document is undefined during unittests
+    if (typeof document === 'undefined') return
+    const undoButton = document.querySelector('.edit-undo')
+    const redoButton = document.querySelector('.edit-redo')
+    if (undoButton) undoButton.disabled = !this._undoStack.length
+    if (redoButton) redoButton.disabled = !this._redoStack.length
+    const dirty = this.isDirty()
+    document.body.classList.toggle('umap-is-dirty', dirty)
+    for (const button of document.querySelectorAll('.disabled-on-dirty')) {
+      button.disabled = dirty
+    }
+    for (const button of document.querySelectorAll('.enabled-on-dirty')) {
+      button.disabled = !dirty
+    }
+  }
+
+  isDirty() {
+    if (!this._umap.id) return true
+    for (const stage of this._undoStack) {
+      if (stage.operation.dirty) return true
+    }
+    for (const stage of this._redoStack) {
+      if (stage.operation.dirty) return true
+    }
+    return false
+  }
+
+  add(stage) {
+    stage.operation.dirty = true
+    this._redoStack = []
+    this._undoStack.push(stage)
+    this.toggleState()
+  }
+
+  copyOperation(stage, redo) {
+    const operation = Utils.CopyJSON(stage.operation)
+    const value = redo ? stage.newValue : stage.oldValue
+    operation.value = value
+    if (['delete', 'upsert'].includes(operation.verb)) {
+      operation.verb = value === null || value === undefined ? 'delete' : 'upsert'
+    }
+    return operation
+  }
+
+  undo(redo = false) {
+    const fromStack = redo ? this._redoStack : this._undoStack
+    const toStack = redo ? this._undoStack : this._redoStack
+    const stage = fromStack.pop()
+    if (!stage) return
+    stage.operation.dirty = !stage.operation.dirty
+    if (stage.operation.verb === 'batch') {
+      for (const st of stage.stages) {
+        this.applyOperation(this.copyOperation(st, redo))
+      }
+    } else {
+      this.applyOperation(this.copyOperation(stage, redo))
+    }
+    toStack.push(stage)
+    this.toggleState()
+  }
+
+  redo() {
+    this.undo(true)
+  }
+
+  applyOperation(operation) {
+    const updater = this._getUpdater(operation.subject, operation.metadata)
+    switch (operation.verb) {
+      case 'update':
+        updater.update(operation)
+        break
+      case 'delete':
+        updater.delete(operation)
+        break
+      case 'upsert':
+        updater.upsert(operation)
+        break
+    }
+    this._syncEngine._send(operation)
+  }
+
+  _getUpdater(subject, metadata) {
+    if (Object.keys(this.updaters).includes(subject)) {
+      return this.updaters[subject]
+    }
+    throw new Error(`Unknown updater ${subject}, ${metadata}`)
+  }
+}

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

@@ -1,4 +1,4 @@
-import { fieldInSchema } from '../utils.js'
+import * as Utils from '../utils.js'
 
 /**
  * Updaters are classes able to convert messages
@@ -10,27 +10,6 @@ class BaseUpdater {
     this._umap = umap
   }
 
-  updateObjectValue(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
-    }
-  }
-
   getDataLayerFromID(layerId) {
     return this._umap.getDataLayerByUmapId(layerId)
   }
@@ -43,12 +22,17 @@ class BaseUpdater {
 
 export class MapUpdater extends BaseUpdater {
   update({ key, value }) {
-    if (fieldInSchema(key)) {
-      this.updateObjectValue(this._umap, key, value)
+    if (Utils.fieldInSchema(key)) {
+      Utils.setObjectValue(this._umap, key, value)
     }
 
+    this._umap.onPropertiesUpdated([key])
     this._umap.render([key])
   }
+
+  getStoredObject() {
+    return this._umap
+  }
 }
 
 export class DataLayerUpdater extends BaseUpdater {
@@ -57,14 +41,21 @@ export class DataLayerUpdater extends BaseUpdater {
     try {
       this.getDataLayerFromID(value.id)
     } catch {
-      this._umap.createDataLayer(value, false)
+      const datalayer = this._umap.createDataLayer(value._umap_options || value, false)
+      if (value.features) {
+        // FIXME: this will create new stages in the undoStack, thus this will empty
+        // the redoStack
+        datalayer.addData(value)
+      }
     }
   }
 
   update({ key, metadata, value }) {
     const datalayer = this.getDataLayerFromID(metadata.id)
-    if (fieldInSchema(key)) {
-      this.updateObjectValue(datalayer, key, value)
+    if (key === 'options') {
+      datalayer.setOptions(value)
+    } else if (Utils.fieldInSchema(key)) {
+      Utils.setObjectValue(datalayer, key, value)
     } else {
       console.debug(
         'Not applying update for datalayer because key is not in the schema',
@@ -81,6 +72,10 @@ export class DataLayerUpdater extends BaseUpdater {
       datalayer.commitDelete()
     }
   }
+
+  getStoredObject(metadata) {
+    return this.getDataLayerFromID(metadata.id)
+  }
 }
 
 export class FeatureUpdater extends BaseUpdater {
@@ -113,7 +108,7 @@ export class FeatureUpdater extends BaseUpdater {
       const feature = this.getFeatureFromMetadata(metadata)
       feature.geometry = value
     } else {
-      this.updateObjectValue(feature, key, value)
+      Utils.setObjectValue(feature, key, value)
       feature.datalayer.indexProperties(feature)
     }
 
@@ -126,4 +121,32 @@ export class FeatureUpdater extends BaseUpdater {
     const feature = this.getFeatureFromMetadata(metadata)
     if (feature) feature.del(false)
   }
+
+  getStoredObject(metadata) {
+    return this.getDataLayerFromID(metadata.layerId)
+  }
+}
+
+export class MapPermissionsUpdater extends BaseUpdater {
+  update({ key, value }) {
+    if (Utils.fieldInSchema(key)) {
+      Utils.setObjectValue(this._umap.permissions, key, value)
+    }
+  }
+
+  getStoredObject(metadata) {
+    return this._umap.permissions
+  }
+}
+
+export class DataLayerPermissionsUpdater extends BaseUpdater {
+  update({ key, value, metadata }) {
+    if (Utils.fieldInSchema(key)) {
+      Utils.setObjectValue(this.getDataLayerFromID(metadata.id), key, value)
+    }
+  }
+
+  getStoredObject(metadata) {
+    return this.getDataLayerFromID(metadata.id).permissions
+  }
 }

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

@@ -1,8 +1,8 @@
 import { DomEvent, DomUtil } from '../../vendors/leaflet/leaflet-src.esm.js'
+import { MutatingForm } from './form/builder.js'
 import { translate } from './i18n.js'
 import ContextMenu from './ui/contextmenu.js'
 import { WithTemplate, loadTemplate } from './utils.js'
-import { MutatingForm } from './form/builder.js'
 
 const TEMPLATE = `
   <table>