umap-project 3.4.2__py3-none-any.whl → 3.6.0__py3-none-any.whl

umap/static/umap/vendors/photon/leaflet.photon.esm.js

@@ -0,0 +1,472 @@
+import {
+  Control,
+  DomUtil,
+  DomEvent,
+  Evented,
+  latLng,
+  Util,
+} from '../leaflet/leaflet-src.esm.js'
+
+const PhotonBase = Evented.extend({
+  forEach: (els, callback) => {
+    Array.prototype.forEach.call(els, callback)
+  },
+
+  ajax: function () {
+    const url = this.options.url + this.buildQueryString(this.getParams())
+    this.fire('ajax:send')
+    return new Promise((resolve) => {
+        fetch(url).then(async (resp) => {
+            if (resp.ok) {
+                resolve(await resp.json())
+            }
+           this.fire('ajax:return')
+        })
+    })
+  },
+
+  buildQueryString: (params) => {
+    const queryString = []
+    for (const [key, param] of Object.entries(params)) {
+      if (param) {
+        queryString.push(`${encodeURIComponent(key)}=${encodeURIComponent(param)}`)
+      }
+    }
+    return queryString.join('&')
+  },
+
+  featureToPopupContent: (feature) => {
+    const container = DomUtil.create('div', 'leaflet-photon-popup')
+    const title = DomUtil.create('h3', '', container)
+    title.innerHTML = feature.properties.label
+    return container
+  },
+})
+
+const PhotonBaseSearch = PhotonBase.extend({
+  options: {
+    url: 'https://photon.komoot.io/api/?',
+    placeholder: 'Start typing...',
+    minChar: 3,
+    limit: 5,
+    submitDelay: 300,
+    includePosition: true,
+    bbox: null,
+    noResultLabel: 'No result',
+    feedbackEmail: 'photon@komoot.de', // Set to null to remove feedback box
+    feedbackLabel: 'Feedback',
+  },
+
+  CACHE: '',
+  RESULTS: [],
+  KEYS: {
+    LEFT: 37,
+    UP: 38,
+    RIGHT: 39,
+    DOWN: 40,
+    TAB: 9,
+    RETURN: 13,
+    ESC: 27,
+    APPLE: 91,
+    SHIFT: 16,
+    ALT: 17,
+    CTRL: 18,
+  },
+
+  initialize: function (input, options) {
+    this.input = input
+    Util.setOptions(this, options)
+    let CURRENT = null
+
+    Object.defineProperty(this, 'CURRENT', {
+      get: () => CURRENT,
+      set: function (index) {
+        if (typeof index === 'object') {
+          index = this.resultToIndex(index)
+        }
+        CURRENT = index
+      },
+    })
+
+    this.input.type = 'search'
+    this.input.placeholder = this.options.placeholder
+    this.input.autocomplete = 'off'
+    this.input.autocorrect = 'off'
+    DomEvent.disableClickPropagation(this.input)
+
+    DomEvent.on(this.input, 'keydown', this.onKeyDown, this)
+    DomEvent.on(this.input, 'input', this.onInput, this)
+    DomEvent.on(this.input, 'blur', this.onBlur, this)
+    DomEvent.on(this.input, 'focus', this.onFocus, this)
+    this.createResultsContainer()
+  },
+
+  createResultsContainer: function () {
+    this.resultsContainer =
+      this.options.resultsContainer ||
+      DomUtil.create('ul', 'photon-autocomplete', document.querySelector('body'))
+  },
+
+  resizeContainer: function () {
+    const l = this.getLeft(this.input)
+    const t = this.getTop(this.input) + this.input.offsetHeight
+    this.resultsContainer.style.left = `${l}px`
+    this.resultsContainer.style.top = `${t}px`
+    const width = this.options.width ? this.options.width : this.input.offsetWidth - 2
+    this.resultsContainer.style.width = `${width}px`
+  },
+
+  onKeyDown: function (e) {
+    switch (e.keyCode) {
+      case this.KEYS.TAB:
+        if (this.CURRENT !== null) {
+          this.setChoice()
+        }
+        DomEvent.stop(e)
+        break
+      case this.KEYS.RETURN:
+        DomEvent.stop(e)
+        this.setChoice()
+        break
+      case this.KEYS.ESC:
+        DomEvent.stop(e)
+        this.hide()
+        this.input.blur()
+        break
+      case this.KEYS.DOWN:
+        if (this.RESULTS.length > 0) {
+          if (this.CURRENT !== null && this.CURRENT < this.RESULTS.length - 1) {
+            // what if one resutl?
+            this.CURRENT++
+            this.highlight()
+          } else if (this.CURRENT === null) {
+            this.CURRENT = 0
+            this.highlight()
+          }
+        }
+        break
+      case this.KEYS.UP:
+        if (this.CURRENT !== null) {
+          DomEvent.stop(e)
+        }
+        if (this.RESULTS.length > 0) {
+          if (this.CURRENT > 0) {
+            this.CURRENT--
+            this.highlight()
+          } else if (this.CURRENT === 0) {
+            this.CURRENT = null
+            this.highlight()
+          }
+        }
+        break
+    }
+  },
+
+  onInput: function (_e) {
+    if (typeof this.submitDelay === 'number') {
+      window.clearTimeout(this.submitDelay)
+      delete this.submitDelay
+    }
+    this.submitDelay = window.setTimeout(
+      Util.bind(this.search, this),
+      this.options.submitDelay
+    )
+  },
+
+  onBlur: function (_e) {
+    this.fire('blur')
+    setTimeout(() => {
+      this.hide()
+    }, 100)
+  },
+
+  onFocus: function (_e) {
+    this.fire('focus')
+    this.input.select()
+    this.search() // In case we have a value from a previous search.
+  },
+
+  clear: function () {
+    this.RESULTS = []
+    this.CURRENT = null
+    this.CACHE = ''
+    this.resultsContainer.innerHTML = ''
+  },
+
+  hide: function () {
+    this.fire('hide')
+    this.clear()
+    this.resultsContainer.style.display = 'none'
+  },
+
+  setChoice: function (choice) {
+    choice = choice || this.RESULTS[this.CURRENT]
+    if (choice) {
+      this.hide()
+      this.fire('selected', { choice: choice.feature })
+      this.onSelected(choice.feature)
+      this.input.value = ''
+    }
+  },
+
+  search: function () {
+    const val = this.input.value
+    const minChar =
+      typeof this.options.minChar === 'function'
+        ? this.options.minChar(val)
+        : val.length >= this.options.minChar
+    if (!val || !minChar) return this.clear()
+    if (`${val}` === `${this.CACHE}`) return
+    this.CACHE = val
+    this._doSearch()
+  },
+
+  _doSearch: function () {
+    this.ajax().then((data) => this.handleResults(data))
+  },
+
+  _onSelected: (_feature) => {},
+
+  onSelected: function (choice) {
+    return (this.options.onSelected || this._onSelected).call(this, choice)
+  },
+
+  _formatResult: function (feature, el) {
+    const title = DomUtil.create('strong', '', el)
+    const detailsContainer = DomUtil.create('small', '', el)
+    const details = []
+    const type = this.formatType(feature)
+    if (feature.properties.name) {
+      title.innerHTML = feature.properties.name
+    } else if (feature.properties.housenumber) {
+      title.innerHTML = feature.properties.housenumber
+      if (feature.properties.street) {
+        title.innerHTML += ` ${feature.properties.street}`
+      }
+    }
+    if (type) details.push(type)
+    if (
+      feature.properties.city &&
+      feature.properties.city !== feature.properties.name
+    ) {
+      details.push(feature.properties.city)
+    }
+    if (
+      feature.properties.state &&
+      feature.properties.state !== feature.properties.name
+    ) {
+      details.push(feature.properties.state)
+    }
+    if (feature.properties.country) details.push(feature.properties.country)
+    detailsContainer.innerHTML = details.join(', ')
+  },
+
+  formatResult: function (feature, el) {
+    return (this.options.formatResult || this._formatResult).call(this, feature, el)
+  },
+
+  formatType: function (feature) {
+    return (this.options.formatType || this._formatType).call(this, feature)
+  },
+
+  _formatType: (feature) =>
+    feature.properties.osm_value === 'yes'
+      ? feature.properties.osm_key
+      : feature.properties.osm_value,
+
+  createResult: function (feature) {
+    const el = DomUtil.create('li', '', this.resultsContainer)
+    this.formatResult(feature, el)
+    const result = {
+      feature: feature,
+      el: el,
+    }
+    // Touch handling needed
+    DomEvent.on(
+      el,
+      'mouseover',
+      function (_e) {
+        this.CURRENT = result
+        this.highlight()
+      },
+      this
+    )
+    DomEvent.on(
+      el,
+      'mousedown',
+      function (_e) {
+        this.setChoice()
+      },
+      this
+    )
+    return result
+  },
+
+  resultToIndex: function (result) {
+    let out = null
+    this.forEach(this.RESULTS, (item, index) => {
+      if (item === result) {
+        out = index
+        return
+      }
+    })
+    return out
+  },
+
+  handleResults: function (geojson) {
+    this.clear()
+    this.resultsContainer.style.display = 'block'
+    this.resizeContainer()
+    this.forEach(geojson.features, (feature) => {
+      this.RESULTS.push(this.createResult(feature))
+    })
+    if (geojson.features.length === 0) {
+      const noresult = DomUtil.create('li', 'photon-no-result', this.resultsContainer)
+      noresult.innerHTML = this.options.noResultLabel
+    }
+    if (this.options.feedbackEmail) {
+      const feedback = DomUtil.create('a', 'photon-feedback', this.resultsContainer)
+      feedback.href = `mailto:${this.options.feedbackEmail}`
+      feedback.innerHTML = this.options.feedbackLabel
+    }
+    this.CURRENT = 0
+    this.highlight()
+    if (this.options.resultsHandler) {
+      this.options.resultsHandler(geojson)
+    }
+  },
+
+  highlight: function () {
+    this.forEach(this.RESULTS, (item, index) => {
+      if (index === this.CURRENT) {
+        DomUtil.addClass(item.el, 'on')
+      } else {
+        DomUtil.removeClass(item.el, 'on')
+      }
+    })
+  },
+
+  getLeft: (el) => {
+    let tmp = el.offsetLeft
+    el = el.offsetParent
+    while (el) {
+      tmp += el.offsetLeft
+      el = el.offsetParent
+    }
+    return tmp
+  },
+
+  getTop: (el) => {
+    let tmp = el.offsetTop
+    el = el.offsetParent
+    while (el) {
+      tmp += el.offsetTop
+      el = el.offsetParent
+    }
+    return tmp
+  },
+
+  getParams: function () {
+    return {
+      q: this.CACHE,
+      lang: this.options.lang,
+      limit: this.options.limit,
+      osm_tag: this.options.osm_tag,
+    }
+  },
+})
+
+export const PhotonSearch = PhotonBaseSearch.extend({
+  initialize: function (map, input, options) {
+    this.map = map
+    PhotonBaseSearch.prototype.initialize.call(this, input, options)
+  },
+
+  _onSelected: function (feature) {
+    this.map.setView(
+      [feature.geometry.coordinates[1], feature.geometry.coordinates[0]],
+      16
+    )
+  },
+
+  getParams: function () {
+    const params = PhotonBaseSearch.prototype.getParams.call(this)
+    if (this.options.includePosition) {
+      params.lat = this.map.getCenter().lat
+      params.lon = this.map.getCenter().lng
+      if (this.options.location_bias_scale) {
+        params.location_bias_scale = this.options.location_bias_scale
+      }
+    }
+    if (this.options.bbox && this.options.bbox.length === 4) {
+      params.bbox = this.options.bbox.join(',')
+    }
+    return params
+  },
+})
+
+Control.Photon = Control.extend({
+  includes: Evented.prototype,
+
+  onAdd: function (map, options) {
+    this.map = map
+    this.container = DomUtil.create('div', 'leaflet-photon')
+
+    this.options = Util.extend(this.options, options)
+
+    this.input = DomUtil.create('input', 'photon-input', this.container)
+    this.search = new PhotonSearch(map, this.input, this.options)
+    this.search.on('blur', this.forwardEvent, this)
+    this.search.on('focus', this.forwardEvent, this)
+    this.search.on('hide', this.forwardEvent, this)
+    this.search.on('selected', this.forwardEvent, this)
+    this.search.on('ajax:send', this.forwardEvent, this)
+    this.search.on('ajax:return', this.forwardEvent, this)
+    return this.container
+  },
+
+  // TODO onRemove
+
+  forwardEvent: function (e) {
+    this.fire(e.type, e)
+  },
+})
+
+export const PhotonReverse = PhotonBase.extend({
+  options: {
+    url: 'https://photon.komoot.io/reverse/?',
+    limit: 1,
+    handleResults: null,
+  },
+
+  initialize: function (options) {
+    Util.setOptions(this, options)
+  },
+
+  doReverse: function (latlng) {
+    latlng = latLng(latlng)
+    this.fire('reverse', { latlng: latlng })
+    this.latlng = latlng
+    this.ajax().then((data) => this.handleResults(data))
+  },
+
+  _handleResults: (data) => {
+    /*eslint-disable no-console */
+    console.log(data)
+    /*eslint-enable no-alert */
+  },
+
+  handleResults: function (data) {
+    return (this.options.handleResults || this._handleResults).call(this, data)
+  },
+
+  getParams: function () {
+    return {
+      lang: this.options.lang,
+      limit: this.options.limit,
+      lat: this.latlng.lat,
+      lon: this.latlng.lng,
+      osm_tag: this.options.osm_tag,
+    }
+  },
+})

umap/sync/app.py

@@ -184,4 +184,7 @@ class Peer:
             logging.debug(err)
 
 
-urlpatterns = [path("ws/sync/<str:map_id>", name="ws_sync", view=sync)]
+script_name = ""
+if settings.FORCE_SCRIPT_NAME:
+    script_name = f"{settings.FORCE_SCRIPT_NAME.strip('/')}/"
+urlpatterns = [path(f"{script_name}ws/sync/<str:map_id>", name="ws_sync", view=sync)]

umap/templates/umap/css.html

@@ -10,8 +10,6 @@
       href="{% static 'umap/vendors/measurable/Leaflet.Measurable.css' %}" />
 <link rel="stylesheet"
       href="{% static 'umap/vendors/fullscreen/leaflet.fullscreen.css' %}" />
-<link rel="stylesheet"
-      href="{% static 'umap/vendors/locatecontrol/L.Control.Locate.min.css' %}" />
 <link rel="stylesheet"
       href="{% static 'umap/vendors/iconlayers/iconLayers.css' %}" />
 <link rel="stylesheet" href="{% static 'umap/vars.css' %}" />

umap/templates/umap/js.html

@@ -16,20 +16,15 @@
 <script src="{% static 'umap/vendors/editable/Path.Drag.js' %}" defer></script>
 <script src="{% static 'umap/vendors/editable/Leaflet.Editable.js' %}" defer></script>
 <script type="module" src="{% static 'umap/js/modules/global.js' %}" defer></script>
-<script src="{% static 'umap/vendors/hash/leaflet-hash.js' %}" defer></script>
 <script src="{% static 'umap/vendors/minimap/Control.MiniMap.min.js' %}"
         defer></script>
 <script src="{% static 'umap/vendors/csv2geojson/csv2geojson.js' %}" defer></script>
 <script src="{% static 'umap/vendors/osmtogeojson/osmtogeojson.js' %}" defer></script>
-<script src="{% static 'umap/vendors/loading/Control.Loading.js' %}" defer></script>
-<script src="{% static 'umap/vendors/photon/leaflet.photon.js' %}" defer></script>
 <script src="{% static 'umap/vendors/fullscreen/Leaflet.fullscreen.min.js' %}"
         defer></script>
 <script src="{% static 'umap/vendors/measurable/Leaflet.Measurable.js' %}"
         defer></script>
 <script src="{% static 'umap/vendors/iconlayers/iconLayers.js' %}" defer></script>
-<script src="{% static 'umap/vendors/locatecontrol/L.Control.Locate.min.js' %}"
-        defer></script>
 <script src="{% static 'umap/vendors/textpath/leaflet.textpath.js' %}"
         defer></script>
 <script src="{% static 'umap/vendors/simple-statistics/simple-statistics.min.js' %}"

umap/templates/umap/team_form.html

@@ -48,7 +48,8 @@
         className: 'edit-team-members',
         on_select: onSelect,
         on_unselect: onUnselect,
-        placeholder: "{% trans "Add user" %}"
+        placeholder: "{% trans "Add user" %}",
+        url: "{% url 'agnocomplete:agnocomplete' 'AutocompleteUser' %}?q={q}"
       }
       const autocomplete = new U.AjaxAutocompleteMultiple(form, options)
       for (const option of select.options) {

umap/tests/integration/test_edit_map.py

@@ -115,6 +115,7 @@ def test_limitbounds_impacts_ui(live_server, page, tilelayer):
     page.get_by_text("Limit bounds").click()
     default_zoom_url = f"{live_server.url}/en/map/new/#5/51.110/7.053"
     page.goto(default_zoom_url)
+    page.wait_for_timeout(300)
     page.get_by_role("button", name="Use current bounds").click()
 
     zoom_in = page.get_by_label("Zoom in")
@@ -198,6 +199,7 @@ def test_sortkey_impacts_datalayerindex(map, live_server, page):
     page.locator(".panel .umap-field-sortKey .blur-container button").click()
 
     # Features should be sorted by key  (First, Second, Third)
+    page.locator(".umap-browser .datalayer-name").click()
     first_listed_feature = page.locator(".umap-browser .datalayer ul > li").nth(0)
     second_listed_feature = page.locator(".umap-browser .datalayer ul > li").nth(1)
     third_listed_feature = page.locator(".umap-browser .datalayer ul > li").nth(2)

umap/tests/integration/test_filters.py

@@ -219,6 +219,30 @@ def test_choice_with_empty_value(live_server, page, map):
     expect(markers).to_have_count(2)
 
 
+def test_choice_with_numbers(live_server, page, map):
+    map.settings["properties"]["onLoadPanel"] = "datafilters"
+    map.settings["properties"]["fields"] = [{"key": "mynumber", "type": "Number"}]
+    map.settings["properties"]["filters"] = [
+        {"fieldKey": "mynumber", "label": "My Number"}
+    ]
+    map.save()
+    data = copy.deepcopy(DATALAYER_DATA1)
+    data["features"][0]["properties"]["mynumber"] = ""
+    del data["features"][1]["properties"]["mynumber"]
+    DataLayerFactory(map=map, data=data)
+    DataLayerFactory(map=map, data=DATALAYER_DATA2)
+    page.goto(f"{live_server.url}{map.get_absolute_url()}#6/47.5/-1.5")
+    expect(page.get_by_text("<empty value>")).to_be_visible()
+    expect(page.get_by_text("14")).to_be_visible()
+    markers = page.locator(".leaflet-marker-icon")
+    expect(markers).to_have_count(4)
+    page.get_by_text("14", exact=True).click()
+    expect(markers).to_have_count(1)
+    page.get_by_text("14", exact=True).click()  # Unselect this filter.
+    page.get_by_text("<empty value>", exact=True).click()
+    expect(markers).to_have_count(2)
+
+
 def test_number_with_zero_value(live_server, page, map):
     map.settings["properties"]["onLoadPanel"] = "datafilters"
     map.settings["properties"]["filters"] = [