umap-project 2.1.3__py3-none-any.whl → 2.2.0b0__py3-none-any.whl

umap/static/umap/js/umap.features.js

@@ -59,15 +59,14 @@ U.FeatureMixin = {
   getPermalink: function () {
     const slug = this.getSlug()
     if (slug)
-      return `${L.Util.getBaseUrl()}?${L.Util.buildQueryString({ feature: slug })}${
+      return `${U.Utils.getBaseUrl()}?${U.Utils.buildQueryString({ feature: slug })}${
         window.location.hash
       }`
   },
 
   view: function (e) {
-    if (this.map.editEnabled) return
-    const outlink = this.getOption('outlink'),
-      target = this.getOption('outlinkTarget')
+    const outlink = this.getOption('outlink')
+    const target = this.getOption('outlinkTarget')
     if (outlink) {
       switch (target) {
         case 'self':
@@ -77,31 +76,38 @@ U.FeatureMixin = {
           window.top.location = outlink
           break
         default:
-          const win = window.open(this.properties._umap_options.outlink)
+          window.open(this.properties._umap_options.outlink)
       }
       return
     }
     // TODO deal with an event instead?
-    if (this.map.slideshow) this.map.slideshow.current = this
+    if (this.map.slideshow) {
+      this.map.slideshow.current = this
+    }
     this.map.currentFeature = this
     this.attachPopup()
-    this.openPopup((e && e.latlng) || this.getCenter())
+    this.openPopup(e?.latlng || this.getCenter())
+  },
+
+  render: function (fields) {
+    const impactData = fields.some((field) => {
+      return field.startsWith('properties.')
+    })
+    if (impactData) {
+      if (this.map.currentFeature === this) {
+        this.view()
+      }
+    }
   },
 
   openPopup: function () {
-    if (this.map.editEnabled) return
     this.parentClass.prototype.openPopup.apply(this, arguments)
   },
 
   edit: function (e) {
     if (!this.map.editEnabled || this.isReadOnly()) return
     const container = L.DomUtil.create('div', 'umap-feature-container')
-    L.DomUtil.add(
-      'h3',
-      `umap-feature-properties ${this.getClassName()}`,
-      container,
-      L._('Feature properties')
-    )
+    L.DomUtil.createTitle(container, L._('Feature properties'), this.getClassName())
 
     let builder = new U.FormBuilder(
       this,
@@ -131,13 +137,13 @@ U.FeatureMixin = {
       callback: this._redraw, // In case we have dynamic options…
     })
     container.appendChild(builder.build())
-    this.map.ui.once('panel:ready', () => {
-      builder.helpers['properties.name'].input.focus()
-    })
     this.appendEditFieldsets(container)
     const advancedActions = L.DomUtil.createFieldset(container, L._('Advanced actions'))
     this.getAdvancedEditActions(advancedActions)
-    this.map.ui.openPanel({ data: { html: container }, className: 'dark' })
+    const onLoad = this.map.editPanel.open({ content: container })
+    onLoad.then(() => {
+      builder.helpers['properties.name'].input.focus()
+    })
     this.map.editedFeature = this
     if (!this.isOnScreen()) this.zoomTo(e)
   },
@@ -149,7 +155,7 @@ U.FeatureMixin = {
       L._('Delete'),
       function (e) {
         L.DomEvent.stop(e)
-        if (this.confirmDelete()) this.map.ui.closePanel()
+        if (this.confirmDelete()) this.map.editPanel.close()
       },
       this
     )
@@ -204,7 +210,8 @@ U.FeatureMixin = {
     if (fallback === undefined) fallback = this.datalayer.options.name
     const key = this.getOption('labelKey') || 'name'
     // Variables mode.
-    if (L.Util.hasVar(key)) return L.Util.greedyTemplate(key, this.extendedProperties())
+    if (U.Utils.hasVar(key))
+      return U.Utils.greedyTemplate(key, this.extendedProperties())
     // Simple mode.
     return this.properties[key] || this.properties.title || fallback
   },
@@ -291,7 +298,7 @@ U.FeatureMixin = {
     let value = fallback
     if (typeof this.staticOptions[option] !== 'undefined') {
       value = this.staticOptions[option]
-    } else if (L.Util.usableOption(this.properties._umap_options, option)) {
+    } else if (U.Utils.usableOption(this.properties._umap_options, option)) {
       value = this.properties._umap_options[option]
     } else if (this.datalayer) {
       value = this.datalayer.getOption(option, this)
@@ -304,23 +311,22 @@ U.FeatureMixin = {
   getDynamicOption: function (option, fallback) {
     let value = this.getOption(option, fallback)
     // There is a variable inside.
-    if (L.Util.hasVar(value)) {
-      value = L.Util.greedyTemplate(value, this.properties, true)
-      if (L.Util.hasVar(value)) value = this.map.getDefaultOption(option)
+    if (U.Utils.hasVar(value)) {
+      value = U.Utils.greedyTemplate(value, this.properties, true)
+      if (U.Utils.hasVar(value)) value = this.map.getDefaultOption(option)
     }
     return value
   },
 
-  zoomTo: function (e) {
-    e = e || {}
-    const easing = e.easing !== undefined ? e.easing : this.map.getOption('easing')
+  zoomTo: function ({ easing, latlng, callback } = {}) {
+    if (easing === undefined) easing = this.map.getOption('easing')
+    if (callback) this.map.once('moveend', callback.call(this))
     if (easing) {
       this.map.flyTo(this.getCenter(), this.getBestZoom())
     } else {
-      const latlng = e.latlng || this.getCenter()
+      latlng = latlng || this.getCenter()
       this.map.setView(latlng, this.getBestZoom() || this.map.getZoom())
     }
-    if (e.callback) e.callback.call(this)
   },
 
   getBestZoom: function () {
@@ -466,7 +472,7 @@ U.FeatureMixin = {
     this.parentClass.prototype.onRemove.call(this, map)
     if (this.map.editedFeature === this) {
       this.endEdit()
-      this.map.ui.closePanel()
+      this.map.editPanel.close()
     }
   },
 
@@ -485,7 +491,7 @@ U.FeatureMixin = {
     options.permanent = showLabel === true
     this.unbindTooltip()
     if ((showLabel === true || showLabel === null) && displayName)
-      this.bindTooltip(L.Util.escapeHTML(displayName), options)
+      this.bindTooltip(U.Utils.escapeHTML(displayName), options)
   },
 
   matchFilter: function (filter, keys) {
@@ -498,11 +504,24 @@ U.FeatureMixin = {
   },
 
   matchFacets: function () {
-    const facets = this.map.facets
-    for (const [property, expected] of Object.entries(facets)) {
-      if (expected.length) {
-        let value = this.properties[property]
-        if (!value || !expected.includes(value)) return false
+    const selected = this.map.facets.selected
+    for (let [name, { type, min, max, choices }] of Object.entries(selected)) {
+      let value = this.properties[name]
+      let parser = this.map.facets.getParser(type)
+      value = parser(value)
+      switch (type) {
+        case 'date':
+        case 'datetime':
+        case 'number':
+          min = parser(min)
+          max = parser(max)
+          if (!isNaN(min) && !isNaN(value) && min > value) return false
+          if (!isNaN(max) && !isNaN(value) && max < value) return false
+          break
+        default:
+          value = value || L._('<empty value>')
+          if (choices?.length && !choices.includes(value)) return false
+          break
       }
     }
     return true
@@ -533,7 +552,8 @@ U.FeatureMixin = {
   extendedProperties: function () {
     // Include context properties
     properties = this.map.getGeoContext()
-    if (L.locale) properties.locale = L.locale
+    const locale = L.getLocale()
+    if (locale) properties.locale = locale
     if (L.lang) properties.lang = L.lang
     properties.rank = this.getRank() + 1
     if (this.hasGeom()) {
@@ -757,7 +777,7 @@ U.PathMixin = {
     if (this.map.editEnabled) {
       if (this.editEnabled()) {
         this.endEdit()
-        this.map.ui.closePanel()
+        this.map.editPanel.close()
       } else {
         this.edit(e)
       }
@@ -1058,7 +1078,7 @@ U.Polyline = L.Polyline.extend({
     const geojson = this.toGeoJSON()
     geojson.geometry.type = 'Polygon'
     geojson.geometry.coordinates = [
-      L.Util.flattenCoordinates(geojson.geometry.coordinates),
+      U.Utils.flattenCoordinates(geojson.geometry.coordinates),
     ]
     const polygon = this.datalayer.geojsonToFeatures(geojson)
     polygon.edit()
@@ -1198,7 +1218,7 @@ U.Polygon = L.Polygon.extend({
   toPolyline: function () {
     const geojson = this.toGeoJSON()
     geojson.geometry.type = 'LineString'
-    geojson.geometry.coordinates = L.Util.flattenCoordinates(
+    geojson.geometry.coordinates = U.Utils.flattenCoordinates(
       geojson.geometry.coordinates
     )
     const polyline = this.datalayer.geojsonToFeatures(geojson)

umap/static/umap/js/umap.forms.js

@@ -492,8 +492,8 @@ L.FormBuilder.IconUrl = L.FormBuilder.BlurInput.extend({
     this.buildTabs()
     const value = this.value()
     if (U.Icon.RECENT.length) this.showRecentTab()
-    else if (!value || L.Util.isPath(value)) this.showSymbolsTab()
-    else if (L.Util.isRemoteUrl(value) || L.Util.isDataImage(value)) this.showURLTab()
+    else if (!value || U.Utils.isPath(value)) this.showSymbolsTab()
+    else if (U.Utils.isRemoteUrl(value) || U.Utils.isDataImage(value)) this.showURLTab()
     else this.showCharsTab()
     const closeButton = L.DomUtil.createButton(
       'button action-button',
@@ -567,7 +567,7 @@ L.FormBuilder.IconUrl = L.FormBuilder.BlurInput.extend({
   updatePreview: function () {
     this.buttons.innerHTML = ''
     if (this.isDefault()) return
-    if (!L.Util.hasVar(this.value())) {
+    if (!U.Utils.hasVar(this.value())) {
       // Do not try to render URL with variables
       const box = L.DomUtil.create('div', 'umap-pictogram-choice', this.buttons)
       L.DomEvent.on(box, 'click', this.onDefine, this)
@@ -585,11 +585,11 @@ L.FormBuilder.IconUrl = L.FormBuilder.BlurInput.extend({
   addIconPreview: function (pictogram, parent) {
     const baseClass = 'umap-pictogram-choice',
       value = pictogram.src,
-      search = L.Util.normalize(this.searchInput.value),
+      search = U.Utils.normalize(this.searchInput.value),
       title = pictogram.attribution
         ? `${pictogram.name} — © ${pictogram.attribution}`
         : pictogram.name || pictogram.src
-    if (search && L.Util.normalize(title).indexOf(search) === -1) return
+    if (search && U.Utils.normalize(title).indexOf(search) === -1) return
     const className = value === this.value() ? `${baseClass} selected` : baseClass,
       container = L.DomUtil.create('div', className, parent)
     U.Icon.makeIconElement(value, container)
@@ -637,7 +637,7 @@ L.FormBuilder.IconUrl = L.FormBuilder.BlurInput.extend({
       categories[category].push(props)
     }
     const sorted = Object.entries(categories).toSorted(([a], [b]) =>
-      L.Util.naturalSort(a, b)
+      U.Utils.naturalSort(a, b, L.lang)
     )
     for (let [name, items] of sorted) {
       this.addCategory(items, name)
@@ -688,7 +688,7 @@ L.FormBuilder.IconUrl = L.FormBuilder.BlurInput.extend({
   showURLTab: function () {
     this.openTab('url')
     const value =
-      L.Util.isRemoteUrl(this.value()) || L.Util.isDataImage(this.value())
+      U.Utils.isRemoteUrl(this.value()) || U.Utils.isDataImage(this.value())
         ? this.value()
         : null
     const input = this.buildInput(this.body, value)
@@ -744,34 +744,122 @@ L.FormBuilder.Switch = L.FormBuilder.CheckBox.extend({
   },
 })
 
-L.FormBuilder.FacetSearch = L.FormBuilder.Element.extend({
+L.FormBuilder.FacetSearchChoices = L.FormBuilder.Element.extend({
   build: function () {
-    this.container = L.DomUtil.create('div', 'umap-facet', this.parentNode)
+    this.container = L.DomUtil.create('fieldset', 'umap-facet', this.parentNode)
+    this.container.appendChild(this.label)
     this.ul = L.DomUtil.create('ul', '', this.container)
-    const choices = this.options.choices
+    this.type = this.options.criteria['type']
+
+    const choices = this.options.criteria['choices']
     choices.sort()
     choices.forEach((value) => this.buildLi(value))
   },
 
   buildLabel: function () {
-    this.label = L.DomUtil.add('h5', '', this.parentNode, this.options.label)
+    this.label = L.DomUtil.element('legend', {textContent: this.options.label})
   },
 
   buildLi: function (value) {
-    const property_li = L.DomUtil.create('li', '', this.ul),
-      input = L.DomUtil.create('input', '', property_li),
-      label = L.DomUtil.create('label', '', property_li)
-    input.type = 'checkbox'
-    input.id = `checkbox_${this.name}_${value}`
-    input.checked = this.get().includes(value)
+    const property_li = L.DomUtil.create('li', '', this.ul)
+    const label = L.DomUtil.add('label', '', property_li)
+    const input = L.DomUtil.create('input', '', label)
+    L.DomUtil.add('span', '', label, value)
+
+    input.type = this.type
+    input.name = `${this.type}_${this.name}`
+    input.checked = this.get()['choices'].includes(value)
     input.dataset.value = value
-    label.htmlFor = `checkbox_${this.name}_${value}`
-    label.innerHTML = value
+
     L.DomEvent.on(input, 'change', (e) => this.sync())
   },
 
   toJS: function () {
-    return [...this.ul.querySelectorAll('input:checked')].map((i) => i.dataset.value)
+    return {
+      type: this.type,
+      choices: [...this.ul.querySelectorAll('input:checked')].map(
+        (i) => i.dataset.value
+      ),
+    }
+  },
+})
+
+L.FormBuilder.MinMaxBase = L.FormBuilder.Element.extend({
+  getInputType: function (type) {
+    return type
+  },
+
+  getLabels: function () {
+    return [L._('Min'), L._('Max')]
+  },
+
+  castValue: function (value) {
+    return value.valueOf()
+  },
+
+  build: function () {
+    this.container = L.DomUtil.create('fieldset', 'umap-facet', this.parentNode)
+    this.container.appendChild(this.label)
+    const {min, max, type} = this.options.criteria
+    this.type = type
+    this.inputType = this.getInputType(this.type)
+
+    const [minLabel, maxLabel] = this.getLabels()
+
+    this.minLabel = L.DomUtil.create('label', '', this.container)
+    this.minLabel.innerHTML = minLabel
+
+    this.minInput = L.DomUtil.create('input', '', this.minLabel)
+    this.minInput.type = this.inputType
+    this.minInput.step = 'any'
+    if (min != null) {
+      this.minInput.valueAsNumber = this.castValue(min)
+      this.minInput.dataset.value = min
+    }
+
+
+    this.maxLabel = L.DomUtil.create('label', '', this.container)
+    this.maxLabel.innerHTML = maxLabel
+
+    this.maxInput = L.DomUtil.create('input', '', this.maxLabel)
+    this.maxInput.type = this.inputType
+    this.maxInput.step = 'any'
+    if (max != null) {
+      this.maxInput.valueAsNumber = this.castValue(max)
+      this.maxInput.dataset.value = max
+    }
+
+    L.DomEvent.on(this.minInput, 'change', (e) => this.sync())
+    L.DomEvent.on(this.maxInput, 'change', (e) => this.sync())
+  },
+
+  buildLabel: function () {
+    this.label = L.DomUtil.element('legend', {textContent: this.options.label})
+  },
+
+  toJS: function () {
+    return {
+      type: this.type,
+      min: this.minInput.value,
+      max: this.maxInput.value,
+    }
+  },
+})
+
+L.FormBuilder.FacetSearchNumber = L.FormBuilder.MinMaxBase.extend({})
+
+L.FormBuilder.FacetSearchDate = L.FormBuilder.MinMaxBase.extend({
+  castValue: function (value) {
+    return value.valueOf() - value.getTimezoneOffset() * 60000
+  },
+  getLabels: function () {
+    return [L._('From'), L._('Until')]
+  },
+})
+
+L.FormBuilder.FacetSearchDateTime = L.FormBuilder.FacetSearchDate.extend({
+  getInputType: function (type) {
+    return 'datetime-local'
   },
 })
 
@@ -1009,9 +1097,6 @@ U.FormBuilder = L.FormBuilder.extend({
           case 'iconUrl':
             schema.handler = 'IconUrl'
             break
-          case 'datalayersControl':
-            schema.handler = 'DataLayersControl'
-            break
           case 'licence':
             schema.handler = 'LicenceChooser'
             break
@@ -1032,10 +1117,11 @@ U.FormBuilder = L.FormBuilder.extend({
 
   setter: function (field, value) {
     L.FormBuilder.prototype.setter.call(this, field, value)
-    if (this.options.makeDirty !== false) this.obj.isDirty = true
+    this.obj.isDirty = true
+    if ('render' in this.obj) this.obj.render([field], this)
   },
 
   finish: function () {
-    this.map.ui.closePanel()
+    this.map.editPanel.close()
   },
 })

umap/static/umap/js/umap.icon.js

@@ -18,7 +18,7 @@ U.Icon = L.DivIcon.extend({
   },
 
   _setRecent: function (url) {
-    if (L.Util.hasVar(url)) return
+    if (U.Utils.hasVar(url)) return
     if (url === U.SCHEMA.iconUrl.default) return
     if (U.Icon.RECENT.indexOf(url) === -1) {
       U.Icon.RECENT.push(url)
@@ -50,7 +50,10 @@ U.Icon = L.DivIcon.extend({
   },
 
   formatUrl: function (url, feature) {
-    return L.Util.greedyTemplate(url || '', feature ? feature.extendedProperties() : {})
+    return U.Utils.greedyTemplate(
+      url || '',
+      feature ? feature.extendedProperties() : {}
+    )
   },
 
   onAdd: function () {},
@@ -206,7 +209,7 @@ U.Icon.Cluster = L.DivIcon.extend({
 })
 
 U.Icon.isImg = function (src) {
-  return L.Util.isPath(src) || L.Util.isRemoteUrl(src) || L.Util.isDataImage(src)
+  return U.Utils.isPath(src) || U.Utils.isRemoteUrl(src) || U.Utils.isDataImage(src)
 }
 
 U.Icon.makeIconElement = function (src, parent) {
@@ -236,7 +239,11 @@ U.Icon.setIconContrast = function (icon, parent, src, bgcolor) {
   if (L.DomUtil.contrastedColor(parent, bgcolor)) {
     // Decide whether to switch svg to white or not, but do it
     // only for internal SVG, as invert could do weird things
-    if (L.Util.isPath(src) && src.endsWith('.svg') && src !== U.SCHEMA.iconUrl.default) {
+    if (
+      U.Utils.isPath(src) &&
+      src.endsWith('.svg') &&
+      src !== U.SCHEMA.iconUrl.default
+    ) {
       // Must be called after icon container is added to the DOM
       // An image
       icon.style.filter = 'invert(1)'

umap/static/umap/js/umap.importer.js

@@ -7,7 +7,11 @@ U.Importer = L.Class.extend({
 
   build: function () {
     this.container = L.DomUtil.create('div', 'umap-upload')
-    this.title = L.DomUtil.add('h3', '', this.container, L._('Import data'))
+    this.title = L.DomUtil.createTitle(
+      this.container,
+      L._('Import data'),
+      'icon-upload'
+    )
     this.presetBox = L.DomUtil.create('div', 'formbox', this.container)
     this.presetSelect = L.DomUtil.create('select', '', this.presetBox)
     this.fileBox = L.DomUtil.create('div', 'formbox', this.container)
@@ -16,7 +20,6 @@ U.Importer = L.Class.extend({
       { type: 'file', multiple: 'multiple', autofocus: true },
       this.fileBox
     )
-    this.map.ui.once('panel:closed', () => (this.fileInput.value = null))
     this.urlInput = L.DomUtil.element(
       'input',
       { type: 'text', placeholder: L._('Provide an URL here') },
@@ -61,19 +64,6 @@ U.Importer = L.Class.extend({
       { type: 'checkbox', name: 'clear', id: 'datalayer-clear-check' },
       this.clearLabel
     )
-    let option
-    this.map.eachDataLayerReverse((datalayer) => {
-      if (datalayer.isLoaded() && !datalayer.isRemoteLayer()) {
-        const id = L.stamp(datalayer)
-        option = L.DomUtil.add('option', '', this.layerInput, datalayer.options.name)
-        option.value = id
-      }
-    })
-    L.DomUtil.element(
-      'option',
-      { value: '', textContent: L._('Import in a new layer') },
-      this.layerInput
-    )
     L.DomUtil.element(
       'option',
       { value: '', textContent: L._('Choose the data format') },
@@ -102,7 +92,7 @@ U.Importer = L.Class.extend({
         let type = '',
           newType
         for (let i = 0; i < e.target.files.length; i++) {
-          newType = L.Util.detectFileType(e.target.files[i])
+          newType = U.Utils.detectFileType(e.target.files[i])
           if (!type && newType) type = newType
           if (type && newType !== type) {
             type = ''
@@ -117,7 +107,24 @@ U.Importer = L.Class.extend({
 
   open: function () {
     if (!this.container) this.build()
-    this.map.ui.openPanel({ data: { html: this.container }, className: 'dark' })
+    const onLoad = this.map.editPanel.open({ content: this.container })
+    onLoad.then(() => {
+      this.fileInput.value = null
+      this.layerInput.innerHTML = ''
+      let option
+      this.map.eachDataLayerReverse((datalayer) => {
+        if (datalayer.isLoaded() && !datalayer.isRemoteLayer()) {
+          const id = L.stamp(datalayer)
+          option = L.DomUtil.add('option', '', this.layerInput, datalayer.options.name)
+          option.value = id
+        }
+      })
+      L.DomUtil.element(
+        'option',
+        { value: '', textContent: L._('Import in a new layer') },
+        this.layerInput
+      )
+    })
   },
 
   openFiles: function () {