umap-project 3.1.2__py3-none-any.whl → 3.3.0__py3-none-any.whl

umap/static/umap/js/modules/facets.js

@@ -1,4 +1,4 @@
-import { DomEvent, DomUtil, stamp } from '../../vendors/leaflet/leaflet-src.esm.js'
+import { DomEvent, DomUtil } from '../../vendors/leaflet/leaflet-src.esm.js'
 import { translate } from './i18n.js'
 import * as Utils from './utils.js'
 
@@ -25,7 +25,7 @@ export default class Facets {
     }
 
     this._umap.datalayers.browsable().map((datalayer) => {
-      datalayer.eachFeature((feature) => {
+      datalayer.features.forEach((feature) => {
         for (const name of names) {
           let value = feature.properties[name]
           const type = defined.get(name).type

umap/static/umap/js/modules/form/builder.js

@@ -70,7 +70,11 @@ export class Form extends Utils.WithEvents {
   }
 
   setter(field, value) {
-    Utils.setObjectValue(this.obj, field, value)
+    if ('setter' in this.obj) {
+      this.obj.setter(field, value)
+    } else {
+      Utils.setObjectValue(this.obj, field, value)
+    }
   }
 
   restoreField(field) {
@@ -104,9 +108,13 @@ export class Form extends Utils.WithEvents {
   finish() {}
 
   getTemplate(helper) {
+    let tpl = helper.getTemplate()
+    if (helper.properties.label && !tpl.includes(helper.properties.label)) {
+      tpl = `<label>${helper.properties.label}${tpl}</label>`
+    }
     return `
       <div class="formbox" data-ref=container>
-        ${helper.getTemplate()}
+        ${tpl}
         <small class="help-text" data-ref=helpText></small>
       </div>`
   }
@@ -171,11 +179,7 @@ export class MutatingForm extends Form {
 
   setter(field, value) {
     const oldValue = this.getter(field)
-    if ('setter' in this.obj) {
-      this.obj.setter(field, value)
-    } else {
-      super.setter(field, value)
-    }
+    super.setter(field, value)
     if ('render' in this.obj) {
       this.obj.render([field], this)
     }

umap/static/umap/js/modules/form/fields.js

@@ -131,12 +131,13 @@ class BaseElement {
 
 Fields.Textarea = class extends BaseElement {
   getTemplate() {
-    return `<textarea placeholder="${this.properties.placeholder || ''}" data-ref=textarea></textarea>`
+    return `<textarea placeholder="${this.properties.placeholder || ''}" name="${this.name}" data-ref=textarea></textarea>`
   }
 
   build() {
     super.build()
     this.textarea = this.elements.textarea
+    this.input = this.textarea
     this.fetch()
     this.textarea.addEventListener(
       'input',
@@ -363,6 +364,9 @@ Fields.Select = class extends BaseElement {
   }
 
   getOptions() {
+    if (this.properties.getOptions) {
+      return this.properties.getOptions()
+    }
     return this.properties.selectOptions
   }
 
@@ -421,7 +425,7 @@ Fields.IntSelect = class extends Fields.Select {
 
 Fields.EditableText = class extends BaseElement {
   getTemplate() {
-    return `<span contentEditable class="${this.properties.className || ''}" data-ref=input></span>`
+    return `<span class="${this.properties.className || ''}" data-ref=input></span>`
   }
 
   buildTemplate() {
@@ -435,6 +439,24 @@ Fields.EditableText = class extends BaseElement {
     this.fetch()
     this.input.addEventListener('input', () => this.sync())
     this.input.addEventListener('keypress', (event) => this.onKeyPress(event))
+    this.input.addEventListener('dblclick', () => {
+      if (this.input.contentEditable !== true) {
+        this.input.contentEditable = true
+        this.input.focus()
+      }
+    })
+    this.input.addEventListener('blur', () => {
+      this.input.contentEditable = false
+    })
+    this.input.addEventListener('mouseover', () => {
+      this.builder._umap.tooltip.open({
+        content: translate('Double click to edit the name'),
+        anchor: this.input,
+        position: 'bottom',
+        delay: 500,
+        duration: 5000,
+      })
+    })
   }
 
   value() {
@@ -560,6 +582,9 @@ Fields.SlideshowDelay = class extends Fields.IntSelect {
 Fields.DataLayerSwitcher = class extends Fields.Select {
   getOptions() {
     const options = []
+    if (this.properties.allowEmpty) {
+      options.push([null, translate('Import in a new layer')])
+    }
     this.builder._umap.datalayers.reverse().map((datalayer) => {
       if (
         datalayer.isLoaded() &&
@@ -573,7 +598,7 @@ Fields.DataLayerSwitcher = class extends Fields.Select {
   }
 
   toHTML() {
-    return this.obj.datalayer.id
+    return this.obj.datalayer?.id
   }
 
   toJS() {
@@ -582,7 +607,7 @@ Fields.DataLayerSwitcher = class extends Fields.Select {
 
   set() {
     this.builder._umap.lastUsedDataLayer = this.toJS()
-    this.obj.changeDataLayer(this.toJS())
+    this.builder.setter(this.field, this.toJS())
   }
 }
 
@@ -654,7 +679,7 @@ Fields.PropertyInput = class extends Fields.BlurInput {
     super.build()
     const autocomplete = new AutocompleteDatalist(this.input)
     // Will be used on Umap and DataLayer
-    const properties = this.builder.obj.allProperties()
+    const properties = this.builder.obj.fieldKeys
     autocomplete.suggestions = properties
   }
 }
@@ -691,10 +716,10 @@ Fields.IconUrl = class extends Fields.BlurInput {
 
   async onDefine() {
     this.footer.innerHTML = ''
-    const [{ pictogram_list }, response, error] = await this.builder._umap.server.get(
+    const [{ data }, response, error] = await this.builder._umap.server.get(
       this.builder._umap.properties.urls.pictogram_list_json
     )
-    if (!error) this.pictogram_list = pictogram_list
+    if (!error) this.pictogramCollections = data
     this.buildTabs()
     const value = this.value()
     if (Icon.RECENT.length) this.showRecentTab()
@@ -807,36 +832,52 @@ Fields.IconUrl = class extends Fields.BlurInput {
     this.updatePreview()
   }
 
-  addCategory(items, name) {
+  addCategory(items, name, parent, attribution = null) {
     const hidden = name ? '' : ' hidden'
-    const [parent, { grid }] = Utils.loadTemplateWithRefs(`
+    const [container, { grid }] = Utils.loadTemplateWithRefs(`
       <div class="umap-pictogram-category">
         <h6${hidden}>${name}</h6>
         <div class="umap-pictogram-grid" data-ref=grid></div>
       </div>
     `)
     let hasIcons = false
-    for (const item of items) {
+    const sorted = items.sort((a, b) => Utils.naturalSort(a.name, b.name, U.lang))
+    for (const item of sorted) {
+      item.attribution ??= attribution
       hasIcons = this.addIconPreview(item, grid) || hasIcons
     }
-    if (hasIcons) this.grid.appendChild(parent)
+    if (hasIcons) parent.appendChild(container)
   }
 
   buildSymbolsList() {
     this.grid.innerHTML = ''
     const categories = {}
     let category
-    for (const props of this.pictogram_list) {
-      category = props.category || translate('Generic')
-      categories[category] = categories[category] || []
-      categories[category].push(props)
-    }
-    const sorted = Object.entries(categories).sort(([a], [b]) =>
-      Utils.naturalSort(a, b, U.lang)
+    const collectionsNames = Object.keys(this.pictogramCollections)
+    const [container, { select, icons }] = Utils.loadTemplateWithRefs(
+      '<div><select data-ref="select"></select><div data-ref="icons"></div></div>'
     )
-    for (const [name, items] of sorted) {
-      this.addCategory(items, name)
+    for (const name of collectionsNames) {
+      const option = Utils.loadTemplate(`<option value="${name}">${name}</option>`)
+      select.appendChild(option)
+    }
+    this.grid.appendChild(container)
+    select.hidden = collectionsNames.length === 1
+    const loadCollection = (name) => {
+      icons.innerHTML = ''
+      const collection = this.pictogramCollections[name || collectionsNames[0]]
+      if (!collection) return
+      const sorted = Object.entries(collection.categories).sort(([a], [b]) =>
+        Utils.naturalSort(a, b, U.lang)
+      )
+      for (const [name, items] of sorted) {
+        this.addCategory(items, name, icons, collection.attribution)
+      }
     }
+    loadCollection()
+    select.addEventListener('change', (event) => {
+      loadCollection(event.target.value)
+    })
   }
 
   buildRecentList() {
@@ -844,7 +885,7 @@ Fields.IconUrl = class extends Fields.BlurInput {
     const items = U.Icon.RECENT.map((src) => ({
       src,
     }))
-    this.addCategory(items)
+    this.addCategory(items, null, this.grid)
   }
 
   isDefault() {
@@ -1266,11 +1307,10 @@ Fields.Range = class extends Fields.FloatInput {
     const step = this.properties.step || 1
     const digits = step < 1 ? 1 : 0
     const id = `range-${this.properties.label || this.name}`
-    for (
-      let i = this.properties.min;
-      i <= this.properties.max;
-      i += (this.properties.max - this.properties.min) / 10
-    ) {
+    const range = this.properties.max - this.properties.min
+    const ticks = this.properties.ticks || Math.min(20, range / step)
+    const tickStep = range / ticks
+    for (let i = this.properties.min; i <= this.properties.max; i += tickStep) {
       const ii = i.toFixed(digits)
       options += `<option value="${ii}" label="${ii}"></option>`
     }

umap/static/umap/js/modules/formatter.js

@@ -2,35 +2,33 @@ import { uMapAlert as Alert } from '../components/alerts/alert.js'
 /* Uses globals for: csv2geojson, osmtogeojson (not available as ESM) */
 import { translate } from './i18n.js'
 
+const parseTextGeom = async (geom) => {
+  try {
+    return JSON.parse(geom)
+  } catch (e) {
+    try {
+      const betterknown = await import('../../vendors/betterknown/betterknown.mjs')
+      return betterknown.wktToGeoJSON(geom)
+    } catch {
+      return null
+    }
+  }
+}
+
 export const EXPORT_FORMATS = {
   geojson: {
-    formatter: async (umap) => JSON.stringify(umap.toGeoJSON(), null, 2),
     ext: '.geojson',
     filetype: 'application/json',
   },
   gpx: {
-    formatter: async (umap) => await umap.formatter.toGPX(umap.toGeoJSON()),
     ext: '.gpx',
     filetype: 'application/gpx+xml',
   },
   kml: {
-    formatter: async (umap) => await umap.formatter.toKML(umap.toGeoJSON()),
     ext: '.kml',
     filetype: 'application/vnd.google-earth.kml+xml',
   },
   csv: {
-    formatter: async (umap) => {
-      const table = []
-      umap.eachFeature((feature) => {
-        const row = feature.toGeoJSON().properties
-        const center = feature.center
-        delete row._umap_options
-        row.Latitude = center.lat
-        row.Longitude = center.lng
-        table.push(row)
-      })
-      return csv2geojson.dsv.csvFormat(table)
-    },
     ext: '.csv',
     filetype: 'text/csv',
   },
@@ -81,15 +79,30 @@ export class Formatter {
         sexagesimal: false,
         parseLatLon: (raw) => Number.parseFloat(raw.toString().replace(',', '.')),
       },
-      (err, result) => {
-        // csv2geojson fallback to null geometries when it cannot determine
-        // lat or lon columns. This is valid geojson, but unwanted from a user
-        // point of view.
+      async (err, result) => {
         if (result?.features.length) {
-          if (result.features[0].geometry === null) {
-            err = {
-              type: 'Error',
-              message: translate('Cannot determine latitude and longitude columns.'),
+          const first = result.features[0]
+          if (first.geometry === null) {
+            const geomFields = ['geom', 'geometry', 'wkt', 'geojson']
+            for (const field of geomFields) {
+              if (first.properties[field]) {
+                for (const feature of result.features) {
+                  feature.geometry = await parseTextGeom(feature.properties[field])
+                  delete feature.properties[field]
+                }
+                break
+              }
+            }
+            if (first.geometry === null) {
+              // csv2geojson fallback to null geometries when it cannot determine
+              // lat or lon columns. This is valid geojson, but unwanted from a user
+              // point of view.
+              err = {
+                type: 'Error',
+                message: translate(
+                  'No geo column found: must be either `lat(itude)` and `lon(gitude)` or `geom(etry)`.'
+                ),
+              }
             }
           }
         }
@@ -152,17 +165,54 @@ export class Formatter {
     }
   }
 
-  async toGPX(geojson) {
+  async stringify(features, format) {
+    switch (format) {
+      case 'csv':
+        return await this.toCSV(features)
+      case 'gpx':
+        return await this.toGPX(features)
+      case 'kml':
+        return await this.toKML(features)
+      case 'geojson':
+        return await this.toGeoJSON(features)
+    }
+  }
+
+  async toGPX(features) {
     const togpx = await import('../../vendors/geojson-to-gpx/index.js')
-    for (const feature of geojson.features) {
+    for (const feature of features) {
       feature.properties.desc = feature.properties.description
     }
-    const gpx = togpx.default(geojson)
+    const gpx = togpx.default(this.toFeatureCollection(features))
     return new XMLSerializer().serializeToString(gpx)
   }
 
-  async toKML(geojson) {
+  async toKML(features) {
     const tokml = await import('../../vendors/tokml/tokml.es.js')
-    return tokml.toKML(geojson)
+    return tokml.toKML(this.toFeatureCollection(features))
+  }
+
+  toFeatureCollection(features) {
+    return {
+      type: 'FeatureCollection',
+      features: features.map((f) => f.toGeoJSON()),
+    }
+  }
+
+  async toGeoJSON(features) {
+    return JSON.stringify(this.toFeatureCollection(features), null, 2)
+  }
+
+  async toCSV(features) {
+    const table = []
+    for (const feature of features) {
+      const row = feature.toGeoJSON().properties
+      const center = feature.center
+      delete row._umap_options
+      row.Latitude = center.lat
+      row.Longitude = center.lng
+      table.push(row)
+    }
+    return csv2geojson.dsv.csvFormat(table)
   }
 }

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

@@ -17,7 +17,7 @@ const TEMPLATE = `
       <input type="file" multiple autofocus onchange />
       <textarea onchange placeholder="${translate('Paste your data here')}"></textarea>
       <input class="highlightable" type="url" placeholder="${translate('Provide an URL here')}" onchange />
-      <button class="flat importers" hidden data-ref="importersButton"><i class="icon icon-16 icon-magic"></i>${translate('Import helpers')}</button>
+      <button type=button class="importers" hidden data-ref="importersButton"><i class="icon icon-16 icon-magic"></i>${translate('Import helpers')}</button>
     </fieldset>
     <fieldset class="formbox">
       <legend class="counter" data-help="importFormats">${translate(
@@ -169,8 +169,13 @@ export default class Importer extends Utils.WithTemplate {
     this.onChange()
   }
 
+  set layer(layer) {
+    this._layer = layer
+  }
+
   get layer() {
     return (
+      this._layer ||
       this._umap.datalayers[this.layerId] ||
       this._umap.createDirtyDataLayer({ name: this.layerName })
     )

umap/static/umap/js/modules/importers/opendata.js

@@ -8,11 +8,21 @@ const PORTALS = [
     url: 'https://data.ampmetropole.fr',
     platform: 'opendatasoft',
   },
+  {
+    name: 'Auverge-Rhône-Alpes',
+    url: 'https://admin.open-datara.fr',
+    platform: 'prodige',
+  },
   {
     name: 'Bordeaux Métropole',
     url: 'https://opendata.bordeaux-metropole.fr',
     platform: 'opendatasoft',
   },
+  {
+    name: 'Nouvelle Aquitaine',
+    url: 'https://admin.sigena.fr',
+    platform: 'prodige',
+  },
   {
     name: 'Région Centre-Val de Loire',
     url: 'https://data.centrevaldeloire.fr',
@@ -33,6 +43,21 @@ const PORTALS = [
     url: 'https://data.iledefrance.fr',
     platform: 'opendatasoft',
   },
+  {
+    name: 'Martinique',
+    url: 'https://admin.geomartinique.fr',
+    platform: 'prodige',
+  },
+  {
+    name: 'Région Pays de la Loire',
+    url: 'https://admin.sigloire.fr',
+    platform: 'prodige',
+  },
+  {
+    name: 'Saint-Pierre et Miquelon',
+    url: 'https://admin.geospm.com',
+    platform: 'prodige',
+  },
   {
     name: 'Toulouse Métropole',
     url: 'https://data.toulouse-metropole.fr',
@@ -57,11 +82,84 @@ const TEMPLATE = `
         <option disabled selected value="">${translate('Choose a dataset')}</option>
       </select>
       <input type="hidden" name="geofield" data-ref="geofield">
-      <label><input type="checkbox" name="in_bbox">${translate('Limit results to current map view')}</label>
+      <label data-ref="in_bbox" hidden><input type="checkbox" name="in_bbox">${translate('Limit results to current map view')}</label>
     </div>
   </div>
 `
 
+class Connector {
+  constructor(umap, baseUrl) {
+    this.umap = umap
+    this.baseUrl = baseUrl
+  }
+}
+
+class Prodige extends Connector {
+  async datasets() {
+    const datasets = []
+    const endpoint = this.umap.proxyUrl(
+      `${this.baseUrl}/api/ogc-features/collections.json`,
+      3600
+    )
+    const response = await this.umap.request.get(endpoint)
+    if (!response?.ok) return datasets
+    const data = await response.json()
+    for (const dataset of data.collections) {
+      let url
+      for (const link of dataset.links) {
+        if (link.type === 'application/geo+json') url = link.href
+      }
+      if (!url) continue
+      datasets.push({
+        label: dataset.title,
+        url: this.umap.proxyUrl(url, 3600),
+      })
+    }
+    return datasets.sort((a, b) => Utils.naturalSort(a.label, b.label, U.lang))
+  }
+}
+
+class OpenDataSoft extends Connector {
+  async datasets() {
+    let results = []
+    let total = null
+    const hardLimit = 500
+    while (total === null || results.length < total) {
+      const offset = results.length
+      const response = await this.umap.request.get(
+        `${this.baseUrl}/api/explore/v2.1/catalog/datasets?where=features%20in%20%28%22geo%22%29&limit=100&offset=${offset}&order_by=title asc`
+      )
+      if (!response?.ok) break
+      const data = await response.json()
+      if (total === null) {
+        total = data.total_count
+      }
+      results = results.concat(data.results)
+      if (total === null || results.length > hardLimit) break
+    }
+    const datasets = []
+    for (const result of results) {
+      const fields = result.fields.filter((field) => field.type === 'geo_point_2d')
+      if (!fields.length) {
+        console.debug('No geofield found for', result)
+        continue
+      }
+      if (fields.length > 1) {
+        console.debug('More than one geofield found for', result)
+      }
+      const url = `${this.baseUrl}/api/explore/v2.1/catalog/datasets/${result.dataset_id}/exports/geojson?select=%2A&limit=-1&timezone=UTC&use_labels=false&epsg=4326`
+      const bbox_url = `${url}&where=in_bbox%28${fields[0].name}%2C%20{south},{west},{north},{east}%29`
+      datasets.push({
+        id: result.dataset_id,
+        label: `${result.metas.default.title} (${result.metas.default.records_count})`,
+        url,
+        bbox_url,
+      })
+    }
+    return datasets
+  }
+}
+
 export class Importer {
   constructor(umap, options = {}) {
     this.umap = umap
@@ -70,48 +168,54 @@ export class Importer {
     this.portals = options.choices || PORTALS
   }
 
+  resetSelect(select) {
+    Array.from(select.children).forEach((option) => {
+      if (!option.disabled) {
+        option.remove()
+      } else {
+        option.selected = true
+      }
+    })
+  }
+
   async open(importer) {
-    let fields_map = {}
-    const [container, { portals, datasets, geofield }] =
+    const [container, { portals, datasets, in_bbox }] =
       Utils.loadTemplateWithRefs(TEMPLATE)
+    datasets.addEventListener('change', (event) => {
+      const select = event.target
+      const selected = select.options[select.selectedIndex]
+      const bbox_url = selected.dataset.bbox_url
+      in_bbox.checked = false
+      in_bbox.hidden = !bbox_url
+    })
     portals.addEventListener('change', async (event) => {
-      const response = await this.umap.request.get(
-        `${event.target.value}/api/explore/v2.1/catalog/datasets?where=features%20in%20%28%22geo%22%29&limit=-1&offset=0&timezone=UTC`
-      )
-      if (response.ok) {
-        fields_map = {}
-        Array.from(datasets.children).forEach((option) => {
-          if (!option.disabled) {
-            option.remove()
-          } else {
-            option.selected = true
-          }
-        })
-        const data = await response.json()
-        for (const result of data.results) {
-          const fields = result.fields.filter((field) => field.type === 'geo_point_2d')
-          if (!fields.length) {
-            console.debug('No geofield found for', result)
-            continue
-          }
-          if (fields.length > 1) {
-            console.debug('More than one geofield found for', result)
-          }
-          fields_map[result.dataset_id] = fields[0].name
+      const select = event.target
+      const selected = select.options[select.selectedIndex]
+      const platform = selected.dataset.platform
+      let connector
+      if (platform === 'opendatasoft') {
+        connector = new OpenDataSoft(this.umap, selected.value)
+      } else if (platform === 'prodige') {
+        connector = new Prodige(this.umap, selected.value)
+      } else {
+        console.error('Unknown platform', platform)
+        return
+      }
+      const results = await connector.datasets(event.target.value)
+      if (results) {
+        this.resetSelect(datasets)
+        for (const result of results) {
           const el = Utils.loadTemplate(
-            `<option value="${result.dataset_id}">${result.metas.default.title} (${result.metas.default.records_count})</option>`
+            `<option value="${result.url}" data-url="${result.url}" data-bbox_url="${result.bbox_url || ''}">${result.label}</option>`
           )
           datasets.appendChild(el)
         }
         datasets.hidden = false
       }
     })
-    datasets.addEventListener('change', (event) => {
-      geofield.value = fields_map[event.target.value]
-    })
     for (const instance of this.portals) {
       const el = Utils.loadTemplate(
-        `<option value="${instance.url}">${instance.name}</option>`
+        `<option value="${instance.url}" data-platform="${instance.platform}">${instance.name}</option>`
       )
       portals.appendChild(el)
     }
@@ -121,9 +225,10 @@ export class Importer {
         Alert.error(translate('Please choose an instance first.'))
         return
       }
-      let url = `${form.instance}/api/explore/v2.1/catalog/datasets/${form.dataset}/exports/geojson?select=%2A&limit=-1&timezone=UTC&use_labels=false&epsg=4326`
+      let url = form.dataset
       if (form.in_bbox) {
-        url += `&where=in_bbox%28${form.geofield}%2C%20{south},{west},{north},{east}%29`
+        const selected = datasets.options[datasets.selectedIndex]
+        url = selected.dataset.bbox_url
       }
       importer.url = url
       importer.format = 'geojson'