umap-project 3.0.6__py3-none-any.whl → 3.1.0__py3-none-any.whl

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

@@ -127,6 +127,12 @@ export class MutatingForm extends Form {
       facetKey: 'PropertyInput',
       slugKey: 'PropertyInput',
       labelKey: 'PropertyInput',
+      color: 'ColorPicker',
+      fillColor: 'ColorPicker',
+      textPathColor: 'ColorPicker',
+      iconUrl: 'IconUrl',
+      licence: 'LicenceChooser',
+      datalayersControl: 'DataLayersControl',
     }
     for (const [key, defaults] of Object.entries(SCHEMA)) {
       const properties = Object.assign({}, defaults)
@@ -153,21 +159,7 @@ export class MutatingForm extends Form {
       } else if (properties.type === Number) {
         if (properties.step) properties.handler = 'Range'
         else properties.handler = 'IntInput'
-      } else {
-        switch (key) {
-          case 'color':
-          case 'fillColor':
-            properties.handler = 'ColorPicker'
-            break
-          case 'iconUrl':
-            properties.handler = 'IconUrl'
-            break
-          case 'licence':
-            properties.handler = 'LicenceChooser'
-            break
-        }
       }
-
       if (customHandlers[key]) {
         properties.handler = customHandlers[key]
       }

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

@@ -725,7 +725,7 @@ Fields.IconUrl = class extends Fields.BlurInput {
         <button class="flat tab-url" data-ref=url>${translate('URL')}</button>
       </div>
     `)
-    this.tabs.appendChild(root)
+    ;[recent, symbols, chars, url].forEach((node) => this.tabs.appendChild(node))
     if (Icon.RECENT.length) {
       recent.addEventListener('click', (event) => {
         event.stopPropagation()
@@ -1269,7 +1269,7 @@ Fields.Range = class extends Fields.FloatInput {
     for (
       let i = this.properties.min;
       i <= this.properties.max;
-      i += this.properties.step
+      i += (this.properties.max - this.properties.min) / 10
     ) {
       const ii = i.toFixed(digits)
       options += `<option value="${ii}" label="${ii}"></option>`

umap/static/umap/js/modules/help.js

@@ -223,10 +223,12 @@ export default class Help {
 
   // Special dynamic case. Do we still think this dialog is useful?
   showGetStarted() {
-    const [container, { ul }] = Utils.loadTemplateWithRefs(`
+    const [container, { getstarted, links }] = Utils.loadTemplateWithRefs(`
       <div>
         <h3><i class="icon icon-16 icon-help"></i>${translate('Where do we go from here?')}</h3>
-        <ul data-ref=ul class="umap-getstarted"></ul>
+        <ul data-ref=getstarted class="umap-getstarted"></ul>
+        <h4>${translate('More help resources')}</h4>
+        <ul data-ref=links class="umap-help-links"></ul>
       </div>
     `)
     const elements = document.querySelectorAll('[data-getstarted]')
@@ -234,12 +236,18 @@ export default class Help {
       const [node, { button }] = Utils.loadTemplateWithRefs(
         `<li><button data-ref=button type="button" title="${el.title}">${el.innerHTML}${el.title}</button></li>`
       )
-      ul.appendChild(node)
+      getstarted.appendChild(node)
       button.addEventListener('click', () => {
         el.click()
         this.dialog.close()
       })
     }
+    for (const info of this.umap.properties.help_links) {
+      const [node, { button }] = Utils.loadTemplateWithRefs(
+        `<li><a href="${info.url}" target="_blank">${info.label} (${info.lang})</a><i class="icon icon-16 icon-external-link"></i></li>`
+      )
+      links.appendChild(node)
+    }
     this.dialog.open({ template: container })
   }
 

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

@@ -97,6 +97,9 @@ export default class Importer extends Utils.WithTemplate {
         case 'banfr':
           import('./importers/banfr.js').then(register)
           break
+        case 'opendata':
+          import('./importers/opendata.js').then(register)
+          break
       }
     }
   }
@@ -248,7 +251,7 @@ export default class Importer extends Utils.WithTemplate {
         DomUtil.element({
           tagName: 'option',
           parent: layerSelect,
-          textContent: datalayer.options.name,
+          textContent: datalayer.getName(),
           value: datalayer.id,
         })
       }
@@ -325,13 +328,13 @@ export default class Importer extends Utils.WithTemplate {
       return false
     }
     const layer = this.layer
-    layer.options.remoteData = {
+    layer.properties.remoteData = {
       url: this.url,
       format: this.format,
     }
     if (this._umap.properties.urls.ajax_proxy) {
-      layer.options.remoteData.proxy = true
-      layer.options.remoteData.ttl = SCHEMA.ttl.default
+      layer.properties.remoteData.proxy = true
+      layer.properties.remoteData.ttl = SCHEMA.ttl.default
     }
     layer.fetchRemoteData(true).then((features) => {
       if (features?.length) {

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

@@ -0,0 +1,142 @@
+import { uMapAlert as Alert } from '../../components/alerts/alert.js'
+import { translate } from '../i18n.js'
+import * as Utils from '../utils.js'
+
+const PORTALS = [
+  {
+    name: 'Aix-Marseille Métropole',
+    url: 'https://data.ampmetropole.fr',
+    platform: 'opendatasoft',
+  },
+  {
+    name: 'Bordeaux Métropole',
+    url: 'https://opendata.bordeaux-metropole.fr',
+    platform: 'opendatasoft',
+  },
+  {
+    name: 'Région Centre-Val de Loire',
+    url: 'https://data.centrevaldeloire.fr',
+    platform: 'opendatasoft',
+  },
+  {
+    name: 'Ville de Clermont-Ferrand',
+    url: 'https://opendata.clermont-ferrand.fr',
+    platform: 'opendatasoft',
+  },
+  {
+    name: 'Métropole de Dijon',
+    url: 'https://data.metropole-dijon.fr',
+    platform: 'opendatasoft',
+  },
+  {
+    name: 'Région Île-de-France',
+    url: 'https://data.iledefrance.fr',
+    platform: 'opendatasoft',
+  },
+  {
+    name: 'Toulouse Métropole',
+    url: 'https://data.toulouse-metropole.fr',
+    platform: 'opendatasoft',
+  },
+  {
+    name: 'Tours Métropole Val de Loire',
+    url: 'https://data.tours-metropole.fr/',
+    platform: 'opendatasoft',
+  },
+]
+
+const TEMPLATE = `
+  <div>
+    <h3>Open Data</h3>
+    <p>${translate('Import data from public open data portals')}.</p>
+    <div class="formbox">
+      <select name="instance" data-ref="portals">
+        <option disabled selected value="">${translate('Choose a portal')}</option>
+      </select>
+      <select name="dataset" hidden data-ref="datasets">
+        <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>
+    </div>
+  </div>
+`
+
+export class Importer {
+  constructor(umap, options = {}) {
+    this.umap = umap
+    this.name = options.name || 'Open Data'
+    this.id = 'opendata'
+    this.portals = options.choices || PORTALS
+  }
+
+  async open(importer) {
+    let fields_map = {}
+    const [container, { portals, datasets, geofield }] =
+      Utils.loadTemplateWithRefs(TEMPLATE)
+    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 el = Utils.loadTemplate(
+            `<option value="${result.dataset_id}">${result.metas.default.title} (${result.metas.default.records_count})</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>`
+      )
+      portals.appendChild(el)
+    }
+
+    const confirm = (form) => {
+      if (!form.instance) {
+        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`
+      if (form.in_bbox) {
+        url += `&where=in_bbox%28${form.geofield}%2C%20{south},{west},{north},{east}%29`
+      }
+      importer.url = url
+      importer.format = 'geojson'
+      importer.layerName = datasets.options[datasets.selectedIndex].textContent
+    }
+
+    importer.dialog
+      .open({
+        template: container,
+        className: `${this.id} importer dark`,
+        accept: translate('Choose this data'),
+        cancel: false,
+      })
+      .then(confirm)
+  }
+}

umap/static/umap/js/modules/permissions.js

@@ -258,7 +258,7 @@ export class DataLayerPermissions {
       {
         edit_status: null,
       },
-      datalayer.options.permissions
+      datalayer.properties.permissions
     )
 
     this.datalayer = datalayer
@@ -314,9 +314,9 @@ export class DataLayerPermissions {
   }
 
   commit() {
-    this.datalayer.options.permissions = Object.assign(
+    this.datalayer.properties.permissions = Object.assign(
       {},
-      this.datalayer.options.permissions,
+      this.datalayer.properties.permissions,
       this.properties
     )
   }

umap/static/umap/js/modules/rendering/controls.js

@@ -23,8 +23,8 @@ export const EditControl = Control.extend({
 
   onAdd: (map) => {
     const template = `
-      <div class="edit-enable">
-        <button type="button" data-ref="button">${translate('Edit')}</button>
+      <div class="edit-enable dark">
+        <button type="button" data-ref="button" class="round"><i class="icon icon-16 icon-edit"></i> ${translate('Edit')}</button>
       </div>
     `
     const [container, { button }] = Utils.loadTemplateWithRefs(template)
@@ -42,6 +42,38 @@ export const EditControl = Control.extend({
   },
 })
 
+export const LoadTemplateControl = Control.extend({
+  options: {
+    position: 'topright',
+  },
+
+  onAdd: (map) => {
+    const template = `
+      <div class="load-template dark hide-on-edit">
+        <button type="button" data-ref="button" class="round"><i class="icon icon-16 icon-template"></i>&nbsp;${translate('Reuse this template')}</button>
+      </div>
+    `
+    const [container, { button }] = Utils.loadTemplateWithRefs(template)
+    button.addEventListener('click', () => {
+      const downloadUrl = map._umap.urls.get('map_download', {
+        map_id: map._umap.id,
+      })
+      const targetUrl = `${map._umap.urls.get('map_new')}?templateUrl=${downloadUrl}`
+      window.open(targetUrl)
+    })
+    button.addEventListener('mouseover', () => {
+      map._umap.tooltip.open({
+        content: translate('Create a new map using this template'),
+        anchor: button,
+        position: 'bottom',
+        delay: 750,
+        duration: 5000,
+      })
+    })
+    return container
+  },
+})
+
 export const MoreControl = Control.extend({
   options: {
     position: 'topleft',

umap/static/umap/js/modules/rendering/icon.js

@@ -235,8 +235,8 @@ export const Cluster = DivIcon.extend({
   computeTextColor: function (el) {
     let color
     const backgroundColor = this.datalayer.getColor()
-    if (this.datalayer.options.cluster?.textColor) {
-      color = this.datalayer.options.cluster.textColor
+    if (this.datalayer.properties.cluster?.textColor) {
+      color = this.datalayer.properties.cluster.textColor
     }
     return color || DomUtil.TextColorFromBackgroundColor(el, backgroundColor)
   },

umap/static/umap/js/modules/rendering/layers/base.js

@@ -35,7 +35,7 @@ export const LayerMixin = {
     return this._layers
   },
 
-  getEditableOptions: () => [],
+  getEditableProperties: () => [],
 
   onEdit: () => {},
 

umap/static/umap/js/modules/rendering/layers/classified.js

@@ -15,11 +15,11 @@ const ClassifiedMixin = {
       .filter((k) => k !== 'schemeGroups')
       .sort()
     const key = this.getType().toLowerCase()
-    if (!Utils.isObject(this.datalayer.options[key])) {
-      this.datalayer.options[key] = {}
+    if (!Utils.isObject(this.datalayer.properties[key])) {
+      this.datalayer.properties[key] = {}
     }
-    this.ensureOptions(this.datalayer.options[key])
-    FeatureGroup.prototype.initialize.call(this, [], this.datalayer.options[key])
+    this.ensureOptions(this.datalayer.properties[key])
+    FeatureGroup.prototype.initialize.call(this, [], this.datalayer.properties[key])
     LayerMixin.onInit.call(this, this.datalayer._leafletMap)
   },
 
@@ -117,7 +117,7 @@ export const Choropleth = FeatureGroup.extend({
   },
 
   _getValue: function (feature) {
-    const key = this.datalayer.options.choropleth?.property || 'value'
+    const key = this.datalayer.properties.choropleth?.property || 'value'
     const value = +feature.properties[key]
     if (!Number.isNaN(value)) return value
   },
@@ -130,12 +130,12 @@ export const Choropleth = FeatureGroup.extend({
       this.options.colors = []
       return
     }
-    const mode = this.datalayer.options.choropleth?.mode
-    let classes = +this.datalayer.options.choropleth?.classes || 5
+    const mode = this.datalayer.properties.choropleth?.mode
+    let classes = +this.datalayer.properties.choropleth?.classes || 5
     let breaks
     classes = Math.min(classes, values.length)
     if (mode === 'manual') {
-      const manualBreaks = this.datalayer.options.choropleth?.breaks
+      const manualBreaks = this.datalayer.properties.choropleth?.breaks
       if (manualBreaks) {
         breaks = manualBreaks
           .split(',')
@@ -154,10 +154,10 @@ export const Choropleth = FeatureGroup.extend({
       breaks.push(ss.max(values)) // Needed for computing the legend
     }
     this.options.breaks = breaks || []
-    this.datalayer.options.choropleth.breaks = this.options.breaks
+    this.datalayer.properties.choropleth.breaks = this.options.breaks
       .map((b) => +b.toFixed(2))
       .join(',')
-    let colorScheme = this.datalayer.options.choropleth.brewer
+    let colorScheme = this.datalayer.properties.choropleth.brewer
     if (!colorbrewer[colorScheme]) colorScheme = 'Blues'
     this.options.colors = colorbrewer[colorScheme][this.options.breaks.length - 1] || []
   },
@@ -175,24 +175,27 @@ export const Choropleth = FeatureGroup.extend({
 
   onEdit: function (field, builder) {
     // Only compute the breaks if we're dealing with choropleth
-    if (!field.startsWith('options.choropleth')) return
+    if (!field.startsWith('properties.choropleth')) return
     // If user touches the breaks, then force manual mode
-    if (field === 'options.choropleth.breaks') {
-      this.datalayer.options.choropleth.mode = 'manual'
-      if (builder) builder.helpers['options.choropleth.mode'].fetch()
+    if (field === 'properties.choropleth.breaks') {
+      this.datalayer.properties.choropleth.mode = 'manual'
+      if (builder) builder.helpers['properties.choropleth.mode'].fetch()
     }
     this.compute()
     // If user changes the mode or the number of classes,
     // then update the breaks input value
-    if (field === 'options.choropleth.mode' || field === 'options.choropleth.classes') {
-      if (builder) builder.helpers['options.choropleth.breaks'].fetch()
+    if (
+      field === 'properties.choropleth.mode' ||
+      field === 'properties.choropleth.classes'
+    ) {
+      if (builder) builder.helpers['properties.choropleth.breaks'].fetch()
     }
   },
 
-  getEditableOptions: function () {
+  getEditableProperties: function () {
     return [
       [
-        'options.choropleth.property',
+        'properties.choropleth.property',
         {
           handler: 'Select',
           selectOptions: this.datalayer.allProperties(),
@@ -200,7 +203,7 @@ export const Choropleth = FeatureGroup.extend({
         },
       ],
       [
-        'options.choropleth.brewer',
+        'properties.choropleth.brewer',
         {
           handler: 'Select',
           label: translate('Choropleth color palette'),
@@ -208,7 +211,7 @@ export const Choropleth = FeatureGroup.extend({
         },
       ],
       [
-        'options.choropleth.classes',
+        'properties.choropleth.classes',
         {
           handler: 'Range',
           min: 3,
@@ -219,7 +222,7 @@ export const Choropleth = FeatureGroup.extend({
         },
       ],
       [
-        'options.choropleth.breaks',
+        'properties.choropleth.breaks',
         {
           handler: 'BlurInput',
           label: translate('Choropleth breakpoints'),
@@ -229,7 +232,7 @@ export const Choropleth = FeatureGroup.extend({
         },
       ],
       [
-        'options.choropleth.mode',
+        'properties.choropleth.mode',
         {
           handler: 'MultiChoice',
           default: 'kmeans',
@@ -261,13 +264,13 @@ export const Circles = FeatureGroup.extend({
   },
 
   ensureOptions: function (options) {
-    if (!Utils.isObject(this.datalayer.options.circles.radius)) {
-      this.datalayer.options.circles.radius = {}
+    if (!Utils.isObject(this.datalayer.properties.circles.radius)) {
+      this.datalayer.properties.circles.radius = {}
     }
   },
 
   _getValue: function (feature) {
-    const key = this.datalayer.options.circles.property || 'value'
+    const key = this.datalayer.properties.circles.property || 'value'
     const value = +feature.properties[key]
     if (!Number.isNaN(value)) return value
   },
@@ -276,8 +279,8 @@ export const Circles = FeatureGroup.extend({
     const values = this.getValues()
     this.options.minValue = Math.sqrt(Math.min(...values))
     this.options.maxValue = Math.sqrt(Math.max(...values))
-    this.options.minPX = this.datalayer.options.circles.radius?.min || 2
-    this.options.maxPX = this.datalayer.options.circles.radius?.max || 50
+    this.options.minPX = this.datalayer.properties.circles.radius?.min || 2
+    this.options.maxPX = this.datalayer.properties.circles.radius?.max || 50
   },
 
   onEdit: function (field, builder) {
@@ -298,10 +301,10 @@ export const Circles = FeatureGroup.extend({
     return this._computeRadius(this._getValue(feature))
   },
 
-  getEditableOptions: function () {
+  getEditableProperties: function () {
     return [
       [
-        'options.circles.property',
+        'properties.circles.property',
         {
           handler: 'Select',
           selectOptions: this.datalayer.allProperties(),
@@ -309,7 +312,7 @@ export const Circles = FeatureGroup.extend({
         },
       ],
       [
-        'options.circles.radius.min',
+        'properties.circles.radius.min',
         {
           handler: 'Range',
           label: translate('Min circle radius'),
@@ -319,7 +322,7 @@ export const Circles = FeatureGroup.extend({
         },
       ],
       [
-        'options.circles.radius.max',
+        'properties.circles.radius.max',
         {
           handler: 'Range',
           label: translate('Max circle radius'),
@@ -337,7 +340,7 @@ export const Circles = FeatureGroup.extend({
 
   renderLegend: function (container) {
     const parent = DomUtil.create('ul', 'circles-layer-legend', container)
-    const color = this.datalayer.getOption('color')
+    const color = this.datalayer.getProperty('color')
     const values = this.getValues()
     if (!values.length) return
     values.sort((a, b) => a - b)
@@ -355,7 +358,7 @@ export const Circles = FeatureGroup.extend({
       circleEl.style.backgroundColor = color
       circleEl.style.height = `${size * 2}px`
       circleEl.style.width = `${size * 2}px`
-      circleEl.style.opacity = this.datalayer.getOption('opacity')
+      circleEl.style.opacity = this.datalayer.getProperty('opacity')
       const labelEl = DomUtil.create('span', 'label', li)
       labelEl.textContent = label
     }
@@ -381,7 +384,8 @@ export const Categorized = FeatureGroup.extend({
 
   _getValue: function (feature) {
     const key =
-      this.datalayer.options.categorized.property || this.datalayer.allProperties()[0]
+      this.datalayer.properties.categorized.property ||
+      this.datalayer.allProperties()[0]
     return feature.properties[key]
   },
 
@@ -403,10 +407,10 @@ export const Categorized = FeatureGroup.extend({
       this.options.colors = []
       return
     }
-    const mode = this.datalayer.options.categorized.mode
+    const mode = this.datalayer.properties.categorized.mode
     let categories = []
     if (mode === 'manual') {
-      const manualCategories = this.datalayer.options.categorized.categories
+      const manualCategories = this.datalayer.properties.categorized.categories
       if (manualCategories) {
         categories = manualCategories.split(',')
       }
@@ -416,8 +420,8 @@ export const Categorized = FeatureGroup.extend({
         .sort(Utils.naturalSort)
     }
     this.options.categories = categories
-    this.datalayer.options.categorized.categories = this.options.categories.join(',')
-    const colorScheme = this.datalayer.options.categorized.brewer
+    this.datalayer.properties.categorized.categories = this.options.categories.join(',')
+    const colorScheme = this.datalayer.properties.categorized.brewer
     this._classes = this.options.categories.length
     if (colorbrewer[colorScheme]?.[this._classes]) {
       this.options.colors = colorbrewer[colorScheme][this._classes]
@@ -428,10 +432,10 @@ export const Categorized = FeatureGroup.extend({
     }
   },
 
-  getEditableOptions: function () {
+  getEditableProperties: function () {
     return [
       [
-        'options.categorized.property',
+        'properties.categorized.property',
         {
           handler: 'Select',
           selectOptions: this.datalayer.allProperties(),
@@ -439,7 +443,7 @@ export const Categorized = FeatureGroup.extend({
         },
       ],
       [
-        'options.categorized.brewer',
+        'properties.categorized.brewer',
         {
           handler: 'Select',
           label: translate('Color palette'),
@@ -447,7 +451,7 @@ export const Categorized = FeatureGroup.extend({
         },
       ],
       [
-        'options.categorized.categories',
+        'properties.categorized.categories',
         {
           handler: 'BlurInput',
           label: translate('Categories'),
@@ -455,7 +459,7 @@ export const Categorized = FeatureGroup.extend({
         },
       ],
       [
-        'options.categorized.mode',
+        'properties.categorized.mode',
         {
           handler: 'MultiChoice',
           default: 'alpha',
@@ -468,17 +472,19 @@ export const Categorized = FeatureGroup.extend({
 
   onEdit: function (field, builder) {
     // Only compute the categories if we're dealing with categorized
-    if (!field.startsWith('options.categorized') && field !== 'options.type') return
+    if (!field.startsWith('properties.categorized') && field !== 'properties.type') {
+      return
+    }
     // If user touches the categories, then force manual mode
-    if (field === 'options.categorized.categories') {
-      this.datalayer.options.categorized.mode = 'manual'
-      if (builder) builder.helpers['options.categorized.mode'].fetch()
+    if (field === 'properties.categorized.categories') {
+      this.datalayer.properties.categorized.mode = 'manual'
+      if (builder) builder.helpers['properties.categorized.mode'].fetch()
     }
     this.compute()
     // If user changes the mode
     // then update the categories input value
-    if (field === 'options.categorized.mode') {
-      if (builder) builder.helpers['options.categorized.categories'].fetch()
+    if (field === 'properties.categorized.mode') {
+      if (builder) builder.helpers['properties.categorized.categories'].fetch()
     }
   },