umap-project 2.3.0__py3-none-any.whl → 2.4.0__py3-none-any.whl

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

@@ -0,0 +1,93 @@
+import { WebSocketTransport } from './websocket.js'
+import { MapUpdater, DataLayerUpdater, FeatureUpdater } from './updaters.js'
+
+export class SyncEngine {
+  constructor(map) {
+    this.updaters = {
+      map: new MapUpdater(map),
+      feature: new FeatureUpdater(map),
+      datalayer: new DataLayerUpdater(map),
+    }
+    this.transport = undefined
+  }
+
+  async authenticate(tokenURI, webSocketURI, server) {
+    const [response, _, error] = await server.get(tokenURI)
+    if (!error) {
+      this.start(webSocketURI, response.token)
+    }
+  }
+
+  start(webSocketURI, authToken) {
+    this.transport = new WebSocketTransport(webSocketURI, authToken, this)
+  }
+
+  stop() {
+    if (this.transport) this.transport.close()
+    this.transport = undefined
+  }
+
+  _getUpdater(subject, metadata) {
+    if (Object.keys(this.updaters).includes(subject)) {
+      return this.updaters[subject]
+    }
+    throw new Error(`Unknown updater ${subject}, ${metadata}`)
+  }
+
+  // This method is called by the transport layer on new messages
+  receive({ kind, ...payload }) {
+    if (kind == 'operation') {
+      let updater = this._getUpdater(payload.subject, payload.metadata)
+      updater.applyMessage(payload)
+    } else {
+      throw new Error(`Unknown dispatch kind: ${kind}`)
+    }
+  }
+
+  _send(message) {
+    if (this.transport) {
+      this.transport.send('operation', message)
+    }
+  }
+
+  upsert(subject, metadata, value) {
+    this._send({ verb: 'upsert', subject, metadata, value })
+  }
+
+  update(subject, metadata, key, value) {
+    this._send({ verb: 'update', subject, metadata, key, value })
+  }
+
+  delete(subject, metadata, key) {
+    this._send({ verb: 'delete', subject, metadata, key })
+  }
+
+  /**
+   * Create a proxy for this sync engine.
+   *
+   * The proxy will automatically call `object.getSyncMetadata` and inject the returned
+   * `subject` and `metadata`` to the `upsert`, `update` and `delete` calls.
+   *
+   * The proxy can be used as follows:
+   *
+   * ```
+   * const proxy = sync.proxy(object)
+   * proxy.update('key', 'value')
+   *```
+   */
+  proxy(object) {
+    const handler = {
+      get(target, prop) {
+        // Only proxy these methods
+        if (['upsert', 'update', 'delete'].includes(prop)) {
+          const { subject, metadata } = object.getSyncMetadata()
+          // Reflect.get is calling the original method.
+          // .bind is adding the parameters automatically
+          return Reflect.get(...arguments).bind(target, subject, metadata)
+        }
+        return Reflect.get(...arguments)
+      },
+    }
+    return new Proxy(this, handler)
+  }
+}

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

@@ -0,0 +1,109 @@
+/**
+ * This file contains the updaters: classes that are able to convert messages
+ * received from another party (or the server) to changes on the map.
+ */
+
+class BaseUpdater {
+  constructor(map) {
+    this.map = map
+  }
+
+  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) {
+    if (layerId) return this.map.getDataLayerByUmapId(layerId)
+    return this.map.defaultEditDataLayer()
+  }
+
+  applyMessage(payload) {
+    let { verb } = payload
+    return this[verb](payload)
+  }
+}
+
+export class MapUpdater extends BaseUpdater {
+  update({ key, value }) {
+    this.updateObjectValue(this.map, key, value)
+    this.map.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([])
+  }
+
+  update({ key, metadata, value }) {
+    const datalayer = this.getDataLayerFromID(metadata.id)
+    this.updateObjectValue(datalayer, key, value)
+    datalayer.render([key])
+  }
+}
+
+export class FeatureUpdater extends BaseUpdater {
+  getFeatureFromMetadata({ id, layerId }) {
+    const datalayer = this.getDataLayerFromID(layerId)
+    return datalayer.getFeatureById(id)
+  }
+
+  // Create or update an object at a specific position
+  upsert({ metadata, value }) {
+    let { id, layerId } = metadata
+    const datalayer = this.getDataLayerFromID(layerId)
+    let feature = this.getFeatureFromMetadata(metadata, value)
+
+    feature = datalayer.geoJSONToLeaflet({
+      geometry: value.geometry,
+      geojson: value,
+      id,
+      feature,
+    })
+    datalayer.addLayer(feature)
+  }
+
+  // Update a property of an object
+  update({ key, metadata, value }) {
+    let feature = this.getFeatureFromMetadata(metadata)
+    if (feature === undefined) {
+      console.error(`Unable to find feature with id = ${metadata.id}.`)
+    }
+    switch (key) {
+      case 'geometry':
+        const datalayer = this.getDataLayerFromID(metadata.layerId)
+        datalayer.geoJSONToLeaflet({ geometry: value, id: metadata.id, feature })
+      default:
+        this.updateObjectValue(feature, key, value)
+        feature.datalayer.indexProperties(feature)
+    }
+
+    feature.render([key])
+  }
+
+  delete({ metadata }) {
+    // XXX Distinguish between properties getting deleted
+    // and the wole feature getting deleted
+    let feature = this.getFeatureFromMetadata(metadata)
+    if (feature) feature.del(false)
+  }
+}

umap/static/umap/js/modules/sync/websocket.js

@@ -0,0 +1,25 @@
+export class WebSocketTransport {
+  constructor(webSocketURI, authToken, messagesReceiver) {
+    this.websocket = new WebSocket(webSocketURI)
+    this.websocket.onopen = () => {
+      this.send('join', { token: authToken })
+    }
+    this.websocket.addEventListener('message', this.onMessage.bind(this))
+    this.receiver = messagesReceiver
+  }
+
+  onMessage(wsMessage) {
+    this.receiver.receive(JSON.parse(wsMessage.data))
+  }
+
+  send(kind, payload) {
+    const message = { ...payload }
+    message.kind = kind
+    let encoded = JSON.stringify(message)
+    this.websocket.send(encoded)
+  }
+
+  close() {
+    this.websocket.close()
+  }
+}

umap/static/umap/js/modules/ui/dialog.js

@@ -0,0 +1,52 @@
+import { DomUtil, DomEvent } from '../../../vendors/leaflet/leaflet-src.esm.js'
+import { translate } from '../i18n.js'
+
+export default class Dialog {
+  constructor(parent) {
+    this.parent = parent
+    this.className = 'umap-dialog window'
+    this.container = DomUtil.create('dialog', this.className, this.parent)
+    DomEvent.disableClickPropagation(this.container)
+    DomEvent.on(this.container, 'contextmenu', DomEvent.stopPropagation) // Do not activate our custom context menu.
+    DomEvent.on(this.container, 'wheel', DomEvent.stopPropagation)
+    DomEvent.on(this.container, 'MozMousePixelScroll', DomEvent.stopPropagation)
+  }
+
+  get visible() {
+    return this.container.open
+  }
+
+  close() {
+    this.container.close()
+  }
+
+  currentZIndex() {
+    return Math.max(
+      ...Array.from(document.querySelectorAll('dialog')).map(
+        (el) => window.getComputedStyle(el).getPropertyValue('z-index') || 0
+      )
+    )
+  }
+
+  open({ className, content, modal } = {}) {
+    this.container.innerHTML = ''
+    const currentZIndex = this.currentZIndex()
+    if (currentZIndex) this.container.style.zIndex = currentZIndex + 1
+    if (modal) this.container.showModal()
+    else this.container.show()
+    if (className) {
+      // Reset
+      this.container.className = this.className
+      this.container.classList.add(...className.split(' '))
+    }
+    const buttonsContainer = DomUtil.create('ul', 'buttons', this.container)
+    const closeButton = DomUtil.createButtonIcon(
+      DomUtil.create('li', '', buttonsContainer),
+      'icon-close',
+      translate('Close')
+    )
+    DomEvent.on(closeButton, 'click', this.close, this)
+    this.container.appendChild(buttonsContainer)
+    this.container.appendChild(content)
+  }
+}

umap/static/umap/js/modules/{panel.js → ui/panel.js}

@@ -1,12 +1,14 @@
-import { DomUtil, DomEvent } from '../../vendors/leaflet/leaflet-src.esm.js'
-import { translate } from './i18n.js'
+import { DomUtil, DomEvent } from '../../../vendors/leaflet/leaflet-src.esm.js'
+import { translate } from '../i18n.js'
 
 export class Panel {
   constructor(map) {
     this.parent = map._controlContainer
     this.map = map
     this.container = DomUtil.create('div', '', this.parent)
-    this.mode = 'condensed'
+    // This will be set once according to the panel configurated at load
+    // or by using panels as popups
+    this.mode = null
     this.classname = 'left'
     DomEvent.disableClickPropagation(this.container)
     DomEvent.on(this.container, 'contextmenu', DomEvent.stopPropagation) // Do not activate our custom context menu.
@@ -14,40 +16,55 @@ export class Panel {
     DomEvent.on(this.container, 'MozMousePixelScroll', DomEvent.stopPropagation)
   }
 
+  setDefaultMode(mode) {
+    if (!this.mode) this.mode = mode
+  }
+
+  isOpen() {
+    return this.container.classList.contains('on')
+  }
+
   open({ content, className, actions = [] } = {}) {
-    this.container.className = `with-transition panel ${this.classname} ${this.mode}`
+    this.container.className = `with-transition panel window ${this.classname} ${
+      this.mode || ''
+    }`
     this.container.innerHTML = ''
-    const actionsContainer = DomUtil.create('ul', 'toolbox', this.container)
+    const actionsContainer = DomUtil.create('ul', 'buttons', this.container)
     const body = DomUtil.create('div', 'body', this.container)
     body.appendChild(content)
-    const closeLink = DomUtil.create('li', 'umap-close-link', actionsContainer)
-    DomUtil.add('i', 'icon icon-16 icon-close', closeLink)
-    closeLink.title = translate('Close')
-    const resizeLink = DomUtil.create('li', 'umap-resize-link', actionsContainer)
-    DomUtil.add('i', 'icon icon-16 icon-resize', resizeLink)
-    resizeLink.title = translate('Toggle size')
-    for (let action of actions) {
-      actionsContainer.appendChild(action)
+    const closeButton = DomUtil.createButtonIcon(
+      DomUtil.create('li', '', actionsContainer),
+      'icon-close',
+      translate('Close')
+    )
+    const resizeButton = DomUtil.createButtonIcon(
+      DomUtil.create('li', '', actionsContainer),
+      'icon-resize',
+      translate('Toggle size')
+    )
+    for (const action of actions) {
+      const element = DomUtil.element({ tagName: 'li', parent: actionsContainer })
+      element.appendChild(action)
     }
     if (className) DomUtil.addClass(body, className)
     const promise = new Promise((resolve, reject) => {
       DomUtil.addClass(this.container, 'on')
       resolve()
     })
-    DomEvent.on(closeLink, 'click', this.close, this)
-    DomEvent.on(resizeLink, 'click', this.resize, this)
+    DomEvent.on(closeButton, 'click', this.close, this)
+    DomEvent.on(resizeButton, 'click', this.resize, this)
     return promise
   }
 
   resize() {
-    if (this.mode === 'expanded') {
-      this.mode = 'condensed'
-      this.container.classList.remove('expanded')
-      this.container.classList.add('condensed')
-    } else {
+    if (this.mode === 'condensed') {
       this.mode = 'expanded'
       this.container.classList.remove('condensed')
       this.container.classList.add('expanded')
+    } else {
+      this.mode = 'condensed'
+      this.container.classList.remove('expanded')
+      this.container.classList.add('condensed')
     }
   }
 

umap/static/umap/js/modules/ui/tooltip.js

@@ -0,0 +1,116 @@
+import { DomUtil, DomEvent } from '../../../vendors/leaflet/leaflet-src.esm.js'
+import { translate } from '../i18n.js'
+
+export default class Tooltip {
+  constructor(parent) {
+    this.parent = parent
+    this.container = DomUtil.create('div', 'with-transition', this.parent)
+    this.container.id = 'umap-tooltip-container'
+    DomEvent.disableClickPropagation(this.container)
+    DomEvent.on(this.container, 'contextmenu', DomEvent.stopPropagation) // Do not activate our custom context menu.
+    DomEvent.on(this.container, 'wheel', DomEvent.stopPropagation)
+    DomEvent.on(this.container, 'MozMousePixelScroll', DomEvent.stopPropagation)
+  }
+
+  open(opts) {
+    function showIt() {
+      if (opts.anchor && opts.position === 'top') {
+        this.anchorTop(opts.anchor)
+      } else if (opts.anchor && opts.position === 'left') {
+        this.anchorLeft(opts.anchor)
+      } else if (opts.anchor && opts.position === 'bottom') {
+        this.anchorBottom(opts.anchor)
+      } else {
+        this.anchorAbsolute()
+      }
+      L.DomUtil.addClass(this.parent, 'umap-tooltip')
+      this.container.innerHTML = U.Utils.escapeHTML(opts.content)
+    }
+    this.TOOLTIP_ID = window.setTimeout(L.bind(showIt, this), opts.delay || 0)
+    const id = this.TOOLTIP_ID
+    const closeIt = () => {
+      this.close(id)
+    }
+    if (opts.anchor) {
+      L.DomEvent.once(opts.anchor, 'mouseout', closeIt)
+    }
+    if (opts.duration !== Infinity) {
+      window.setTimeout(closeIt, opts.duration || 3000)
+    }
+  }
+
+  anchorAbsolute() {
+    this.container.className = ''
+    const left =
+        this.parent.offsetLeft +
+        this.parent.clientWidth / 2 -
+        this.container.clientWidth / 2,
+      top = this.parent.offsetTop + 75
+    this.setPosition({ top: top, left: left })
+  }
+
+  anchorTop(el) {
+    this.container.className = 'tooltip-top'
+    const coords = this.getPosition(el)
+    this.setPosition({
+      left: coords.left - 10,
+      bottom: this.getDocHeight() - coords.top + 11,
+    })
+  }
+
+  anchorBottom(el) {
+    this.container.className = 'tooltip-bottom'
+    const coords = this.getPosition(el)
+    this.setPosition({
+      left: coords.left,
+      top: coords.bottom + 11,
+    })
+  }
+
+  anchorLeft(el) {
+    this.container.className = 'tooltip-left'
+    const coords = this.getPosition(el)
+    this.setPosition({
+      top: coords.top,
+      right: document.documentElement.offsetWidth - coords.left + 11,
+    })
+  }
+
+  close(id) {
+    // Clear timetout even if a new tooltip has been added
+    // in the meantime. Eg. after a mouseout from the anchor.
+    window.clearTimeout(id)
+    if (id && id !== this.TOOLTIP_ID) return
+    this.container.className = ''
+    this.container.innerHTML = ''
+    this.setPosition({})
+    L.DomUtil.removeClass(this.parent, 'umap-tooltip')
+  }
+
+  getPosition(el) {
+    return el.getBoundingClientRect()
+  }
+
+  setPosition(coords) {
+    if (coords.left) this.container.style.left = `${coords.left}px`
+    else this.container.style.left = 'initial'
+    if (coords.right) this.container.style.right = `${coords.right}px`
+    else this.container.style.right = 'initial'
+    if (coords.top) this.container.style.top = `${coords.top}px`
+    else this.container.style.top = 'initial'
+    if (coords.bottom) this.container.style.bottom = `${coords.bottom}px`
+    else this.container.style.bottom = 'initial'
+  }
+
+  getDocHeight() {
+    const D = document
+    return Math.max(
+      D.body.scrollHeight,
+      D.documentElement.scrollHeight,
+      D.body.offsetHeight,
+      D.documentElement.offsetHeight,
+      D.body.clientHeight,
+      D.documentElement.clientHeight
+    )
+  }
+}

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

@@ -30,7 +30,8 @@ export function checkId(string) {
  *
  * Return an array of unique impacts.
  *
- * @param {fields} list[fields]
+ * @param {fields}  list[fields]
+ * @param object schema object. If ommited, global U.SCHEMA will be used.
  * @returns Array[string]
  */
 export function getImpactsFromSchema(fields, schema) {
@@ -84,11 +85,23 @@ export function escapeHTML(s) {
       'div',
       'iframe',
       'img',
+      'audio',
+      'video',
+      'source',
       'br',
       'span',
+      'dt',
+      'dd',
     ],
-    ADD_ATTR: ['target', 'allow', 'allowfullscreen', 'frameborder', 'scrolling'],
-    ALLOWED_ATTR: ['href', 'src', 'width', 'height', 'style', 'dir', 'title'],
+    ADD_ATTR: [
+      'target',
+      'allow',
+      'allowfullscreen',
+      'frameborder',
+      'scrolling',
+      'controls',
+    ],
+    ALLOWED_ATTR: ['href', 'src', 'width', 'height', 'style', 'dir', 'title', 'type'],
     // Added: `geo:` URL scheme as defined in RFC5870:
     // https://www.rfc-editor.org/rfc/rfc5870.html
     // The base RegExp comes from:
@@ -102,27 +115,24 @@ export function escapeHTML(s) {
 export function toHTML(r, options) {
   if (!r) return ''
   const target = (options && options.target) || 'blank'
-  let ii
 
-  // detect newline format
-  const newline = r.indexOf('\r\n') != -1 ? '\r\n' : r.indexOf('\n') != -1 ? '\n' : ''
+  // unordered lists
+  r = r.replace(/^\*\* (.*)/gm, '<ul><ul><li>$1</li></ul></ul>')
+  r = r.replace(/^\* (.*)/gm, '<ul><li>$1</li></ul>')
+  for (let ii = 0; ii < 3; ii++) {
+    r = r.replace(new RegExp(`</ul>(\r\n|\r|\n)<ul>`, 'g'), '')
+  }
 
   // headings and hr
-  r = r.replace(/^### (.*)/gm, '<h5>$1</h5>')
-  r = r.replace(/^## (.*)/gm, '<h4>$1</h4>')
-  r = r.replace(/^# (.*)/gm, '<h3>$1</h3>')
+  r = r.replace(/^### (.*)(\r\n|\r|\n)?/gm, '<h6>$1</h6>')
+  r = r.replace(/^## (.*)(\r\n|\r|\n)?/gm, '<h5>$1</h5>')
+  r = r.replace(/^# (.*)(\r\n|\r|\n)?/gm, '<h4>$1</h4>')
   r = r.replace(/^---/gm, '<hr>')
 
   // bold, italics
   r = r.replace(/\*\*(.*?)\*\*/g, '<strong>$1</strong>')
   r = r.replace(/\*(.*?)\*/g, '<em>$1</em>')
 
-  // unordered lists
-  r = r.replace(/^\*\* (.*)/gm, '<ul><ul><li>$1</li></ul></ul>')
-  r = r.replace(/^\* (.*)/gm, '<ul><li>$1</li></ul>')
-  for (ii = 0; ii < 3; ii++)
-    r = r.replace(new RegExp(`</ul>${newline}<ul>`, 'g'), newline)
-
   // links
   r = r.replace(/(\[\[http)/g, '[[h_t_t_p') // Escape for avoiding clash between [[http://xxx]] and http://xxx
   r = r.replace(/({{http)/g, '{{h_t_t_p')
@@ -163,9 +173,6 @@ export function toHTML(r, options) {
   //Unescape http
   r = r.replace(/(h_t_t_p)/g, 'http')
 
-  // Preserver line breaks
-  if (newline) r = r.replace(new RegExp(`${newline}(?=[^]+)`, 'g'), `<br>${newline}`)
-
   r = escapeHTML(r)
 
   return r