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

umap/static/umap/js/modules/importers/geodatamine.js

@@ -0,0 +1,95 @@
+import { DomUtil, DomEvent } from '../../../vendors/leaflet/leaflet-src.esm.js'
+import { BaseAjax, SingleMixin } from '../autocomplete.js'
+import { translate } from '../i18n.js'
+import * as Utils from '../utils.js'
+import { uMapAlert as Alert } from '../../components/alerts/alert.js'
+
+const BOUNDARY_TYPES = {
+  admin_6: 'département',
+  admin_7: 'pays (loi Voynet)',
+  admin_8: 'commune',
+  admin_9: 'quartier, hameau, arrondissement',
+  political: 'canton',
+  local_authority: 'EPCI',
+}
+
+const TEMPLATE = `
+  <h3>GeoDataMine</h3>
+  <p>${translate('GeoDataMine: thematic data from OpenStreetMap')}.</p>
+  <select name="theme">
+    <option value="">${translate('Choose a theme')}</option>
+  </select>
+  <label>
+    <input type="checkbox" name="aspoint" />
+    ${translate('Symplify all geometries to points')}
+  </label>
+  <label id="boundary">
+  </label>
+  <button class="button">${translate('Choose this data')}</button>
+`
+
+class Autocomplete extends SingleMixin(BaseAjax) {
+  createResult(item) {
+    return super.createResult({
+      value: item.id,
+      label: `${item.name} (${BOUNDARY_TYPES[item.type]} — ${item.ref})`,
+    })
+  }
+}
+
+export class Importer {
+  constructor(map, options = {}) {
+    this.map = map
+    this.name = options.name || 'GeoDataMine'
+    this.baseUrl = options?.url || 'https://geodatamine.fr'
+    this.id = 'geodatamine'
+  }
+
+  async open(importer) {
+    let boundary = null
+    let boundaryName = null
+    const container = DomUtil.create('div')
+    container.innerHTML = TEMPLATE
+    const response = await importer.map.request.get(`${this.baseUrl}/themes`)
+    const select = container.querySelector('select')
+    if (response && response.ok) {
+      const { themes } = await response.json()
+      themes.sort((a, b) => Utils.naturalSort(a['name:fr'], b ['name:fr']))
+      for (const theme of themes) {
+        DomUtil.element({
+          tagName: 'option',
+          value: theme.id,
+          textContent: theme['name:fr'],
+          parent: select,
+        })
+      }
+    } else {
+      console.error(response)
+    }
+    const asPoint = container.querySelector('[name=aspoint]')
+    this.autocomplete = new Autocomplete(container.querySelector('#boundary'), {
+      placeholder: translate('Search admin boundary'),
+      url: `${this.baseUrl}/boundaries/search?text={q}`,
+      on_select: (choice) => {
+        boundary = choice.item.value
+        boundaryName = choice.item.label
+      },
+    })
+    const confirm = () => {
+      if (!boundary || !select.value) {
+        Alert.error(translate('Please choose a theme and a boundary first.'))
+        return
+      }
+      importer.url = `${this.baseUrl}/data/${select.value}/${boundary}?format=geojson&aspoint=${asPoint.checked}`
+      importer.format = 'geojson'
+      importer.layerName = `${boundaryName} — ${select.options[select.selectedIndex].textContent}`
+      importer.dialog.close()
+    }
+    DomEvent.on(container.querySelector('button'), 'click', confirm)
+
+    importer.dialog.open({
+      content: container,
+      className: `${this.id} importer dark`,
+    })
+  }
+}

umap/static/umap/js/modules/importers/overpass.js

@@ -0,0 +1,84 @@
+import { DomUtil } from '../../../vendors/leaflet/leaflet-src.esm.js'
+import { BaseAjax, SingleMixin } from '../autocomplete.js'
+import { translate } from '../i18n.js'
+import { uMapAlert as Alert } from '../../components/alerts/alert.js'
+
+const TEMPLATE = `
+  <h3>Overpass</h3>
+  <label>
+    <span data-help="overpassImporter">${translate('Expression')}</span>
+    <input type="text" placeholder="amenity=drinking_water" name="tags" />
+  </label>
+  <label>
+    ${translate('Geometry mode')}
+    <select name="out-mode">
+      <option value="geom" selected>${translate('Default')}</option>
+      <option value="center">${translate('Only geometry centers')}</option>
+    </select>
+  </label>
+  <label id="area"><span>${translate('Search area')}</span></label>
+`
+
+class Autocomplete extends SingleMixin(BaseAjax) {
+  handleResults(data) {
+    return super.handleResults(data.features)
+  }
+
+  createResult(item) {
+    return super.createResult({
+      // Overpass convention to get their id from an osm one.
+      value: item.properties.osm_id + 3600000000,
+      label: `${item.properties.name}`,
+    })
+  }
+}
+
+export class Importer {
+  constructor(map, options) {
+    this.map = map
+    this.name = options.name || 'Overpass'
+    this.baseUrl = options?.url || 'https://overpass-api.de/api/interpreter'
+    this.id = 'overpass'
+  }
+
+  async open(importer) {
+    let boundary = null
+    let boundaryName = null
+    const container = DomUtil.create('div')
+    container.innerHTML = TEMPLATE
+    this.autocomplete = new Autocomplete(container.querySelector('#area'), {
+      url: 'https://photon.komoot.io/api?q={q}&osm_tag=place',
+      placeholder: translate(
+        'Type area name, or let empty to load data in current map view'
+      ),
+      on_select: (choice) => {
+        boundary = choice.item.value
+        boundaryName = choice.item.label
+      },
+    })
+    this.map.help.parse(container)
+
+    const confirm = () => {
+      let tags = container.querySelector('[name=tags]').value
+      if (!tags) {
+        Alert.error(translate('Please define an expression for the query first'))
+        return
+      }
+      const outMode = container.querySelector('[name=out-mode]').value
+      if (!tags.startsWith('[')) tags = `[${tags}]`
+      let area = '{south},{west},{north},{east}'
+      if (boundary) area = `area:${boundary}`
+      let query = `[out:json];nwr${tags}(${area});out ${outMode};`
+      importer.url = `${this.baseUrl}?data=${query}`
+      if (boundary) importer.layerName = boundaryName
+      importer.format = 'osm'
+      importer.dialog.close()
+    }
+    L.DomUtil.createButton('', container, translate('Choose this data'), confirm)
+
+    importer.dialog.open({
+      content: container,
+      className: `${this.id} importer dark`,
+    })
+  }
+}

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

@@ -1,5 +1,5 @@
-// Uses `L._`` from Leaflet.i18n which we cannot import as a module yet
-import { DomUtil } from '../../vendors/leaflet/leaflet-src.esm.js'
+import { translate } from './i18n.js'
+import { uMapAlert as Alert } from '../components/alerts/alert.js'
 
 export class RequestError extends Error {}
 
@@ -47,14 +47,13 @@ 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 {
-  constructor(ui) {
-    super()
-    this.ui = ui
+  fire(name, params) {
+    document.body.dispatchEvent(new CustomEvent(name, params))
   }
 
   async _fetch(method, uri, headers, data) {
     const id = Math.random()
-    this.ui.fire('dataloading', { id: id })
+    this.fire('dataloading', { id: id })
     try {
       const response = await BaseRequest.prototype._fetch.call(
         this,
@@ -68,7 +67,7 @@ export class Request extends BaseRequest {
       if (error instanceof NOKError) return this._onNOK(error)
       return this._onError(error)
     } finally {
-      this.ui.fire('dataload', { id: id })
+      this.fire('dataload', { id: id })
     }
   }
 
@@ -81,7 +80,7 @@ export class Request extends BaseRequest {
   }
 
   _onError(error) {
-    this.ui.alert({ content: L._('Problem in the response'), level: 'error' })
+    Alert.error(translate('Problem in the response'))
   }
 
   _onNOK(error) {
@@ -127,9 +126,9 @@ export class ServerRequest extends Request {
     try {
       const data = await response.json()
       if (data.info) {
-        this.ui.alert({ content: data.info, level: 'info' })
+        Alert.info(data.info)
       } else if (data.error) {
-        this.ui.alert({ content: data.error, level: 'error' })
+        Alert.error(data.error)
         return this._onError(new Error(data.error))
       }
       return [data, response, null]
@@ -144,10 +143,9 @@ export class ServerRequest extends Request {
 
   _onNOK(error) {
     if (error.status === 403) {
-      this.ui.alert({
-        content: error.message || L._('Action not allowed :('),
-        level: 'error',
-      })
+      Alert.error(error.message || translate('Action not allowed :('))
+    } else {
+      super._onError(error)
     }
     return [{}, error.response, error]
   }

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

@@ -0,0 +1,241 @@
+import { DomUtil, DomEvent, stamp } from '../../vendors/leaflet/leaflet-src.esm.js'
+import * as Utils from './utils.js'
+import { translate } from './i18n.js'
+
+class Rule {
+
+  get condition() {
+    return this._condition
+  }
+
+  set condition(value) {
+    this._condition = value
+    this.parse()
+  }
+
+
+  get isDirty() {
+    return this._isDirty
+  }
+
+  set isDirty(status) {
+    this._isDirty = status
+    if (status) this.map.isDirty = status
+  }
+
+  constructor(map, condition = '', options = {}) {
+    // TODO make this public properties when browser coverage is ok
+    // cf https://caniuse.com/?search=public%20class%20field
+    this._condition = null
+    this._isDirty = false
+    this.OPERATORS = [
+      ['>', this.gt],
+      ['<', this.lt],
+      // When sent by Django
+      ['&lt;', this.lt],
+      ['!=', this.not_equal],
+      ['=', this.equal],
+    ]
+    this.map = map
+    this.active = true
+    this.options = options
+    this.condition = condition
+  }
+
+  render(fields) {
+    this.map.render(fields)
+  }
+
+  equal(other) {
+    return this.expected === other
+  }
+
+  not_equal(other) {
+    return this.expected != other
+  }
+
+  gt(other) {
+    return other > this.expected
+  }
+
+  lt(other) {
+    return other < this.expected
+  }
+
+  parse() {
+    let vars = []
+    this.cast = (v) => v
+    this.operator = undefined
+    for (const [sign, func] of this.OPERATORS) {
+      if (this.condition.includes(sign)) {
+        this.operator = func
+        vars = this.condition.split(sign)
+        break
+      }
+    }
+    if (vars.length != 2) return
+    this.key = vars[0]
+    this.expected = vars[1]
+    if (!isNaN(this.expected)) this.cast = parseFloat
+    else if (['true', 'false'].includes(this.expected)) this.cast = (v) => !!v
+    this.expected = this.cast(this.expected)
+  }
+
+  match(props) {
+    if (!this.operator || !this.active) return false
+    return this.operator(this.cast(props[this.key]))
+  }
+
+  getMap() {
+    return this.map
+  }
+
+  getOption(option) {
+    return this.options[option]
+  }
+
+  edit() {
+    const options = [
+      [
+        'condition',
+        {
+          handler: 'BlurInput',
+          label: translate('Condition'),
+          placeholder: translate('key=value or key!=value'),
+        },
+      ],
+      'options.color',
+      'options.iconClass',
+      'options.iconUrl',
+      'options.iconOpacity',
+      'options.opacity',
+      'options.weight',
+      'options.fill',
+      'options.fillColor',
+      'options.fillOpacity',
+      'options.smoothFactor',
+      'options.dashArray',
+    ]
+    const container = DomUtil.create('div')
+    const builder = new U.FormBuilder(this, options)
+    const defaultShapeProperties = DomUtil.add('div', '', container)
+    defaultShapeProperties.appendChild(builder.build())
+
+    this.map.editPanel.open({ content: container })
+  }
+
+  renderToolbox(row) {
+    row.classList.toggle('off', !this.active)
+    const toggle = DomUtil.createButtonIcon(
+      row,
+      'icon-eye',
+      translate('Show/hide layer')
+    )
+    const edit = DomUtil.createButtonIcon(
+      row,
+      'icon-edit show-on-edit',
+      translate('Edit')
+    )
+    const remove = DomUtil.createButtonIcon(
+      row,
+      'icon-delete show-on-edit',
+      translate('Delete layer')
+    )
+    DomEvent.on(edit, 'click', this.edit, this)
+    DomEvent.on(
+      remove,
+      'click',
+      function () {
+        if (!confirm(translate('Are you sure you want to delete this rule?'))) return
+        this._delete()
+        this.map.editPanel.close()
+      },
+      this
+    )
+    DomUtil.add('span', '', row, this.condition || translate('empty rule'))
+    DomUtil.createIcon(row, 'icon-drag', translate('Drag to reorder'))
+    row.dataset.id = stamp(this)
+    DomEvent.on(toggle, 'click', () => {
+      this.active = !this.active
+      row.classList.toggle('off', !this.active)
+      this.map.render(['rules'])
+    })
+  }
+
+  _delete() {
+    this.map.rules.rules = this.map.rules.rules.filter((rule) => rule != this)
+  }
+}
+
+export default class Rules {
+  constructor(map) {
+    this.map = map
+    this.rules = []
+    this.loadRules()
+  }
+
+  loadRules() {
+    if (!this.map.options.rules?.length) return
+    for (const { condition, options } of this.map.options.rules) {
+      if (!condition) continue
+      this.rules.push(new Rule(this.map, condition, options))
+    }
+  }
+
+  onReorder(src, dst, initialIndex, finalIndex) {
+    const moved = this.rules.find((rule) => stamp(rule) == src.dataset.id)
+    const reference = this.rules.find((rule) => stamp(rule) == dst.dataset.id)
+    const movedIdx = this.rules.indexOf(moved)
+    let referenceIdx = this.rules.indexOf(reference)
+    const minIndex = Math.min(movedIdx, referenceIdx)
+    const maxIndex = Math.max(movedIdx, referenceIdx)
+    moved._delete() // Remove from array
+    referenceIdx = this.rules.indexOf(reference)
+    let newIdx
+    if (finalIndex === 0) newIdx = 0
+    else if (finalIndex > initialIndex) newIdx = referenceIdx
+    else newIdx = referenceIdx + 1
+    this.rules.splice(newIdx, 0, moved)
+    moved.isDirty = true
+    this.map.render(['rules'])
+  }
+
+  edit(container) {
+    const body = DomUtil.createFieldset(container, translate('Conditional style rules'))
+    if (this.rules.length) {
+      const ul = DomUtil.create('ul', '', body)
+      for (const rule of this.rules) {
+        rule.renderToolbox(DomUtil.create('li', 'orderable', ul))
+      }
+
+      const orderable = new U.Orderable(ul, this.onReorder.bind(this))
+    }
+
+    DomUtil.createButton('umap-add', body, translate('Add rule'), this.addRule, this)
+  }
+
+  addRule() {
+    const rule = new Rule(this.map)
+    rule.isDirty = true
+    this.rules.push(rule)
+    rule.edit(map)
+  }
+
+  commit() {
+    this.map.options.rules = this.rules.map((rule) => {
+      return {
+        condition: rule.condition,
+        options: rule.options,
+      }
+    })
+  }
+
+  getOption(option, feature) {
+    for (const rule of this.rules) {
+      if (rule.match(feature.properties)) {
+        if (Utils.usableOption(rule.options, option)) return rule.options[option]
+        break
+      }
+    }
+  }
+}

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

@@ -1,12 +1,25 @@
 import { translate } from './i18n.js'
 
-// Possible impacts
-// ['ui', 'data', 'limit-bounds', 'datalayer-index', 'remote-data', 'background']
+/**
+ * This SCHEMA defines metadata about properties.
+ *
+ * This is here in order to have a centered place where all properties are specified.
+ *
+ * Each property defines:
+ *
+ * - `type`:        The type of the data
+ * - `impacts`:     A list of impacts than happen when this property is updated, among
+ *                  'ui', 'data', 'limit-bounds', 'datalayer-index', 'remote-data',
+ *                  'background' 'sync'.
+ *
+ * - Extra keys are being passed to the FormBuilder automatically.
+ */
 
+// This is sorted alphabetically
 export const SCHEMA = {
   browsable: {
-    impacts: ['ui'],
     type: Boolean,
+    impacts: ['ui'],
   },
   captionBar: {
     type: Boolean,
@@ -14,6 +27,13 @@ export const SCHEMA = {
     label: translate('Do you want to display a caption bar?'),
     default: false,
   },
+  captionControl: {
+    type: Boolean,
+    impacts: ['ui'],
+    nullable: true,
+    label: translate('Display the caption control'),
+    default: true,
+  },
   captionMenus: {
     type: Boolean,
     impacts: ['ui'],
@@ -37,6 +57,10 @@ export const SCHEMA = {
     type: Object,
     impacts: ['data'],
   },
+  condition: {
+    type: String,
+    impacts: ['data'],
+  },
   dashArray: {
     type: String,
     impacts: ['data'],
@@ -146,6 +170,10 @@ export const SCHEMA = {
     label: translate('Display the fullscreen control'),
     default: true,
   },
+  geometry: {
+    type: Object,
+    impacts: ['data'],
+  },
   heat: {
     type: Object,
     impacts: ['data'],
@@ -184,7 +212,6 @@ export const SCHEMA = {
     type: Boolean,
     impacts: ['ui'],
   },
-
   interactive: {
     type: Boolean,
     impacts: ['data'],
@@ -272,9 +299,9 @@ export const SCHEMA = {
     choices: [
       ['none', translate('None')],
       ['caption', translate('Caption')],
-      ['databrowser', translate('Browser in data mode')],
-      ['datalayers', translate('Browser in layers mode')],
-      ['datafilters', translate('Browser in filters mode')],
+      ['databrowser', translate('Browser: data')],
+      ['datalayers', translate('Browser: layers')],
+      ['datafilters', translate('Browser: filters')],
     ],
     default: 'none',
   },
@@ -290,6 +317,7 @@ export const SCHEMA = {
   },
   outlink: {
     type: String,
+    impacts: [],
     label: translate('Link to…'),
     helpEntries: 'outlink',
     placeholder: 'http://...',
@@ -362,6 +390,10 @@ export const SCHEMA = {
     type: Object,
     impacts: ['remote-data'],
   },
+  rules: {
+    type: Object,
+    impacts: ['data'],
+  },
   scaleControl: {
     type: Boolean,
     impacts: ['ui'],
@@ -373,12 +405,6 @@ export const SCHEMA = {
     impacts: ['ui'],
     label: translate('Allow scroll wheel zoom?'),
   },
-  captionControl: {
-    type: Boolean,
-    nullable: true,
-    label: translate('Display the caption control'),
-    default: true,
-  },
   searchControl: {
     type: Boolean,
     impacts: ['ui'],
@@ -437,6 +463,13 @@ export const SCHEMA = {
     inheritable: true,
     default: true,
   },
+  syncEnabled: {
+    type: Boolean,
+    impacts: ['sync', 'ui'],
+    label: translate('Enable real-time collaboration'),
+    helpEntries: 'sync',
+    default: false,
+  },
   tilelayer: {
     type: Object,
     impacts: ['background'],
@@ -453,8 +486,19 @@ export const SCHEMA = {
     label: translate('To zoom'),
     helpText: translate('Optional.'),
   },
+  ttl: {
+    type: Number,
+    label: translate('Cache proxied request'),
+    choices: [
+      ['', translate('No cache')],
+      ['300', translate('5 min')],
+      ['3600', translate('1 hour')],
+      ['86400', translate('1 day')],
+    ],
+    default: '300',
+  },
   type: {
-    type: 'String',
+    type: String,
     impacts: ['data'],
   },
   weight: {
@@ -486,4 +530,9 @@ export const SCHEMA = {
     label: translate('Default zoom level'),
     inheritable: true,
   },
+  // FIXME This is an internal Leaflet property, we might want to do this differently.
+  _latlng: {
+    type: Object,
+    impacts: ['data'],
+  },
 }