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

umap/static/umap/js/modules/data/layer.js

@@ -298,7 +298,7 @@ export class DataLayer {
   }
 
   dataChanged() {
-    if (!this.isLoaded()) return
+    if (!this.isLoaded() || this._batch) return
     this._umap.onDataLayersChanged()
     this.layer.dataChanged()
   }
@@ -547,22 +547,27 @@ export class DataLayer {
   }
 
   sortedValues(property) {
-    return Array.from(this.features.values())
+    return this.features
+      .all()
       .map((feature) => feature.properties[property])
       .filter((val, idx, arr) => arr.indexOf(val) === idx)
       .sort(Utils.naturalSort)
   }
 
   addData(geojson, sync) {
+    let data = []
+    this._batch = true
     try {
       // Do not fail if remote data is somehow invalid,
       // otherwise the layer becomes uneditable.
-      return this.makeFeatures(geojson, sync)
+      data = this.makeFeatures(geojson, sync)
     } catch (err) {
       console.debug('Error with DataLayer', this.id)
       console.error(err)
-      return []
     }
+    this._batch = false
+    this.dataChanged()
+    return data
   }
 
   makeFeatures(geojson = {}, sync = true) {
@@ -821,6 +826,7 @@ export class DataLayer {
     const fields = [
       'properties.color',
       'properties.iconClass',
+      'properties.iconSize',
       'properties.iconUrl',
       'properties.iconOpacity',
       'properties.opacity',
@@ -1176,12 +1182,6 @@ export class DataLayer {
       })
   }
 
-  featuresToGeoJSON() {
-    const features = []
-    this.features.forEach((feature) => features.push(feature.toGeoJSON()))
-    return features
-  }
-
   async show() {
     this._leafletMap.addLayer(this.layer)
     if (!this.isLoaded()) await this.fetchData()
@@ -1194,10 +1194,11 @@ export class DataLayer {
   }
 
   toggle(force) {
-    // From now on, do not try to how/hidedataChanged
-    // automatically this layer.
-    let display = force
+    // From now on, do not try to how/hide
+    // automatically this layer, as user
+    // has taken control on this.
     this._forcedVisibility = true
+    let display = force
     if (force === undefined) {
       if (!this.isVisible()) display = true
       else display = false
@@ -1267,11 +1268,9 @@ export class DataLayer {
   }
 
   umapGeoJSON() {
-    return {
-      type: 'FeatureCollection',
-      features: this.isRemoteLayer() ? [] : this.featuresToGeoJSON(),
-      _umap_options: this.properties,
-    }
+    const geojson = this._umap.formatter.toFeatureCollection(this.features.all())
+    geojson._umap_options = this.properties
+    return geojson
   }
 
   getDOMOrder() {

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

@@ -582,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() &&
@@ -595,7 +598,7 @@ Fields.DataLayerSwitcher = class extends Fields.Select {
   }
 
   toHTML() {
-    return this.obj.datalayer.id
+    return this.obj.datalayer?.id
   }
 
   toJS() {
@@ -604,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())
   }
 }
 
@@ -863,6 +866,7 @@ Fields.IconUrl = class extends Fields.BlurInput {
     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)
       )
@@ -1303,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

@@ -17,33 +17,18 @@ const parseTextGeom = async (geom) => {
 
 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',
   },
@@ -180,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,29 +82,54 @@ 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>
 `
 
-export class Importer {
-  constructor(umap, options = {}) {
+class Connector {
+  constructor(umap, baseUrl) {
     this.umap = umap
-    this.name = options.name || 'Open Data'
-    this.id = 'opendata'
-    this.portals = options.choices || PORTALS
+    this.baseUrl = baseUrl
   }
+}
 
-  async fetchDatasets(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(
-        `${baseUrl}/api/explore/v2.1/catalog/datasets?where=features%20in%20%28%22geo%22%29&limit=100&offset=${offset}&order_by=title asc`
+        `${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
+      if (!response?.ok) break
       const data = await response.json()
       if (total === null) {
         total = data.total_count
@@ -87,48 +137,85 @@ export class Importer {
       results = results.concat(data.results)
       if (total === null || results.length > hardLimit) break
     }
-    return results
+    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
+    this.name = options.name || 'Open Data'
+    this.id = 'opendata'
+    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 results = await this.fetchDatasets(event.target.value)
+      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) {
-        fields_map = {}
-        Array.from(datasets.children).forEach((option) => {
-          if (!option.disabled) {
-            option.remove()
-          } else {
-            option.selected = true
-          }
-        })
+        this.resetSelect(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)
-          }
-          fields_map[result.dataset_id] = fields[0].name
           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)
     }
@@ -138,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'

umap/static/umap/js/modules/importers/openrouteservice.js

@@ -0,0 +1,140 @@
+import { uMapAlert as Alert } from '../../components/alerts/alert.js'
+import { translate } from '../i18n.js'
+import * as Utils from '../utils.js'
+import { Form } from '../form/builder.js'
+
+export const PROFILES = [
+  ['foot-walking', translate('Walking')],
+  ['foot-hiking', translate('Hiking')],
+  ['driving-car', translate('By car')],
+  ['cycling-regular', translate('Cycling')],
+  ['wheelchair', translate('Wheelchair')],
+]
+
+export const PREFERENCES = [
+  ['recommended', translate('Recommended')],
+  ['fastest', translate('Fastest')],
+  ['shortest', translate('Shortest')],
+]
+
+export class Importer {
+  constructor(umap) {
+    this.umap = umap
+    this.id = 'openrouteservice'
+  }
+
+  async loadORS() {
+    const mod = await import('../../../vendors/openrouteservice/ors-js-client.js')
+    return mod.default
+  }
+
+  async isochrone(latlng) {
+    const ORS = await this.loadORS()
+    const properties = {
+      range: 10,
+      lines: 1,
+      profile: 'foot-walking',
+    }
+
+    const metadatas = [
+      ['datalayer', { handler: 'DataLayerSwitcher', allowEmpty: true }],
+      [
+        'profile',
+        { handler: 'Select', selectOptions: PROFILES, label: translate('Profile') },
+      ],
+      [
+        'range',
+        {
+          handler: 'Range',
+          min: 5,
+          max: 60,
+          step: 1,
+          ticks: 11,
+          label: translate('Max time (in minutes)'),
+        },
+      ],
+      [
+        'lines',
+        {
+          handler: 'Range',
+          min: 1,
+          max: 5,
+          step: 1,
+          label: translate('Number of lines'),
+        },
+      ],
+    ]
+    const form = new Form(properties, metadatas, { umap: this.umap })
+    // Needed for DataLayerSwitcher (which expects to be used with MutatingForm)
+    form._umap = this.umap
+
+    const Isochrones = new ORS.Isochrones({
+      api_key: this.umap.properties.ORSAPIKey,
+    })
+    this.umap.dialog.open({ template: form.build() }).then(async () => {
+      try {
+        const params = {
+          locations: [[latlng.lng, latlng.lat]],
+          profile: properties.profile,
+          range: [properties.range * 60],
+        }
+        if (properties.lines !== 1) {
+          params.interval = (properties.range / properties.lines) * 60
+        }
+        const data = await Isochrones.calculate(params)
+        this.umap.importer.build()
+        this.umap.importer.raw = JSON.stringify(data)
+        this.umap.importer.format = 'geojson'
+        this.umap.importer.layer = properties.datalayer
+        this.umap.importer.submit()
+      } catch (err) {
+        console.error(err)
+      }
+    })
+  }
+
+  async elevation(geometry) {
+    const ORS = await this.loadORS()
+
+    const Elevation = new ORS.Elevation({
+      api_key: this.umap.properties.ORSAPIKey,
+    })
+
+    try {
+      const data = await Elevation.lineElevation({
+        format_in: 'geojson',
+        format_out: 'geojson',
+        geometry: geometry,
+      })
+      return data?.geometry
+    } catch (err) {
+      console.debug(`An error occurred: ${err.status}`)
+      console.error(err)
+    }
+  }
+
+  async directions(properties) {
+    if (!properties?.coordinates || properties.coordinates.length < 2) {
+      console.error('Not enough coordinates to compute route', properties)
+      return
+    }
+    const ORS = await this.loadORS()
+    const Directions = new ORS.Directions({ api_key: this.umap.properties.ORSAPIKey })
+    try {
+      const featuresCollection = await Directions.calculate({
+        coordinates: properties.coordinates,
+        profile: properties.profile,
+        preference: properties.preference,
+        elevation: properties.elevation,
+        geometry_simplify: true,
+        instructions: false,
+        format: 'geojson',
+      })
+      const feature = featuresCollection.features[0]
+      return feature.geometry
+    } catch (err) {
+      console.debug(`An error occurred: ${err.status}`)
+      console.error(err)
+    }
+  }
+}