umap-project 2.7.2__py3-none-any.whl → 2.8.0__py3-none-any.whl

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

@@ -3,8 +3,8 @@ import { translate } from './i18n.js'
 import * as Utils from './utils.js'
 
 export default class Facets {
-  constructor(map) {
-    this.map = map
+  constructor(umap) {
+    this._umap = umap
     this.selected = {}
   }
 
@@ -24,7 +24,7 @@ export default class Facets {
       this.selected[name] = selected
     }
 
-    this.map.eachBrowsableDataLayer((datalayer) => {
+    this._umap.eachBrowsableDataLayer((datalayer) => {
       datalayer.eachFeature((feature) => {
         for (const name of names) {
           let value = feature.properties[name]
@@ -108,8 +108,8 @@ export default class Facets {
     const defaultType = 'checkbox'
     const allowedTypes = [defaultType, 'radio', 'number', 'date', 'datetime']
     const defined = new Map()
-    if (!this.map.options.facetKey) return defined
-    return (this.map.options.facetKey || '').split(',').reduce((acc, curr) => {
+    if (!this._umap.properties.facetKey) return defined
+    return (this._umap.properties.facetKey || '').split(',').reduce((acc, curr) => {
       let [name, label, type] = curr.split('|')
       type = allowedTypes.includes(type) ? type : defaultType
       acc.set(name, { label: label || name, type: type })
@@ -146,15 +146,15 @@ export default class Facets {
     const defined = this.getDefined()
     if (!defined.has(property)) {
       defined.set(property, { label, type })
-      this.map.options.facetKey = this.dumps(defined)
-      this.map.isDirty = true
+      this._umap.properties.facetKey = this.dumps(defined)
+      this._umap.isDirty = true
     }
   }
 
   remove(property) {
     const defined = this.getDefined()
     defined.delete(property)
-    this.map.options.facetKey = this.dumps(defined)
-    this.map.isDirty = true
+    this._umap.properties.facetKey = this.dumps(defined)
+    this._umap.isDirty = true
   }
 }

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

@@ -3,24 +3,24 @@ import { translate } from './i18n.js'
 
 export const EXPORT_FORMATS = {
   geojson: {
-    formatter: async (map) => JSON.stringify(map.toGeoJSON(), null, 2),
+    formatter: async (umap) => JSON.stringify(umap.toGeoJSON(), null, 2),
     ext: '.geojson',
     filetype: 'application/json',
   },
   gpx: {
-    formatter: async (map) => await map.formatter.toGPX(map.toGeoJSON()),
+    formatter: async (umap) => await umap.formatter.toGPX(umap.toGeoJSON()),
     ext: '.gpx',
     filetype: 'application/gpx+xml',
   },
   kml: {
-    formatter: async (map) => await map.formatter.toKML(map.toGeoJSON()),
+    formatter: async (umap) => await umap.formatter.toKML(umap.toGeoJSON()),
     ext: '.kml',
     filetype: 'application/vnd.google-earth.kml+xml',
   },
   csv: {
-    formatter: async (map) => {
+    formatter: async (umap) => {
       const table = []
-      map.eachFeature((feature) => {
+      umap.eachFeature((feature) => {
         const row = feature.toGeoJSON().properties
         const center = feature.center
         delete row._umap_options

umap/static/umap/js/modules/global.js

@@ -1,34 +1,11 @@
-import {
-  uMapAlert as Alert,
-  uMapAlertCreation as AlertCreation,
-} from '../components/alerts/alert.js'
-import {
-  AjaxAutocomplete,
-  AjaxAutocompleteMultiple,
-  AutocompleteDatalist,
-} from './autocomplete.js'
-import Browser from './browser.js'
-import Caption from './caption.js'
-import ContextMenu from './ui/contextmenu.js'
-import Facets from './facets.js'
-import { Formatter } from './formatter.js'
+import { uMapAlert as Alert } from '../components/alerts/alert.js'
+import { AjaxAutocomplete, AjaxAutocompleteMultiple, AutocompleteDatalist } from './autocomplete.js'
 import Help from './help.js'
-import Importer from './importer.js'
-import Orderable from './orderable.js'
-import { HTTPError, NOKError, Request, RequestError, ServerRequest } from './request.js'
-import Rules from './rules.js'
+import { ServerRequest } from './request.js'
 import { SCHEMA } from './schema.js'
-import Share from './share.js'
-import Slideshow from './slideshow.js'
-import { SyncEngine } from './sync/engine.js'
-import Dialog from './ui/dialog.js'
-import { EditPanel, FullPanel, Panel } from './ui/panel.js'
-import Tooltip from './ui/tooltip.js'
-import URLs from './urls.js'
 import * as Utils from './utils.js'
 import * as Icon from './rendering/icon.js'
-import { DataLayer, LAYER_TYPES } from './data/layer.js'
-import { DataLayerPermissions, MapPermissions } from './permissions.js'
+import { LAYER_TYPES } from './data/layer.js'
 import { Point, LineString, Polygon } from './data/features.js'
 import { LeafletMarker, LeafletPolyline, LeafletPolygon } from './rendering/ui.js'
 
@@ -38,44 +15,19 @@ import { LeafletMarker, LeafletPolyline, LeafletPolygon } from './rendering/ui.j
 // By alphabetic order
 window.U = {
   Alert,
-  AlertCreation,
   AjaxAutocomplete,
   AjaxAutocompleteMultiple,
   AutocompleteDatalist,
-  Browser,
-  Caption,
-  ContextMenu,
-  DataLayer,
-  DataLayerPermissions,
-  Dialog,
-  EditPanel,
-  Facets,
-  Formatter,
-  FullPanel,
   Help,
-  HTTPError,
   Icon,
-  Importer,
   LAYER_TYPES,
   LeafletMarker,
   LeafletPolygon,
   LeafletPolyline,
   LineString,
-  MapPermissions,
-  NOKError,
-  Orderable,
-  Panel,
   Point,
   Polygon,
-  Request,
-  RequestError,
-  Rules,
   SCHEMA,
   ServerRequest,
-  Share,
-  Slideshow,
-  SyncEngine,
-  Tooltip,
-  URLs,
   Utils,
 }

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

@@ -1,5 +1,7 @@
 import { DomEvent, DomUtil } from '../../vendors/leaflet/leaflet-src.esm.js'
 import { translate } from './i18n.js'
+import * as Utils from './utils.js'
+import Dialog from './ui/dialog.js'
 
 const SHORTCUTS = {
   DRAW_MARKER: {
@@ -133,13 +135,13 @@ const ENTRIES = {
       <li>${translate('# one hash for main heading')}</li>
       <li>${translate('## two hashes for second heading')}</li>
       <li>${translate('### three hashes for third heading')}</li>
-      <li>${translate('Simple link: [[http://example.com]]')}</li>
-      <li>${translate('Link with text: [[http://example.com|text of the link]]')}</li>
-      <li>${translate('Image: {{http://image.url.com}}')}</li>
-      <li>${translate('Image with custom width (in px): {{http://image.url.com|width}}')}</li>
-      <li>${translate('Iframe: {{{http://iframe.url.com}}}')}</li>
-      <li>${translate('Iframe with custom height (in px): {{{http://iframe.url.com|height}}}')}</li>
-      <li>${translate('Iframe with custom height and width (in px): {{{http://iframe.url.com|height*width}}}')}</li>
+      <li>${translate('Simple link: [[https://example.com]]')}</li>
+      <li>${translate('Link with text: [[https://example.com|text of the link]]')}</li>
+      <li>${translate('Image: {{https://image.url.com}}')}</li>
+      <li>${translate('Image with custom width (in px): {{https://image.url.com|width}}')}</li>
+      <li>${translate('Iframe: {{{https://iframe.url.com}}}')}</li>
+      <li>${translate('Iframe with custom height (in px): {{{https://iframe.url.com|height}}}')}</li>
+      <li>${translate('Iframe with custom height and width (in px): {{{https://iframe.url.com|height*width}}}')}</li>
       <li>${translate('--- for a horizontal rule')}</li>
     </ul>
   </div>
@@ -163,9 +165,9 @@ const ENTRIES = {
 }
 
 export default class Help {
-  constructor(map) {
-    this.map = map
-    this.dialog = new U.Dialog()
+  constructor(umap) {
+    this.umap = umap
+    this.dialog = new Dialog({ className: 'dark', accept: false, cancel: false })
     this.isMacOS = /mac/i.test(
       // eslint-disable-next-line compat/compat -- Fallback available.
       navigator.userAgentData ? navigator.userAgentData.platform : navigator.platform
@@ -199,7 +201,7 @@ export default class Help {
         innerHTML: ENTRIES[name],
       })
     }
-    this.dialog.open({ template: container, className: 'dark', cancel: false, accept: false })
+    this.dialog.open({ template: container })
   }
 
   // Special dynamic case. Do we still think this dialog is useful?
@@ -211,7 +213,7 @@ export default class Help {
       className: 'umap-help-entry',
       parent: container,
     }).appendChild(this._buildEditEntry())
-    this.map.dialog.open({ content: container, className: 'dark' })
+    this.dialog.open({ template: container })
   }
 
   button(container, entries) {
@@ -224,13 +226,6 @@ export default class Help {
     return button
   }
 
-  getStartedLink(container) {
-    const button = DomUtil.createButton('umap-help-link', container, translate('Help'))
-    button.textContent = translate('Help')
-    button.addEventListener('click', () => this.showGetStarted())
-    return button
-  }
-
   parse(container) {
     for (const element of container.querySelectorAll('[data-help]')) {
       this.button(element, element.dataset.help.split(','))
@@ -247,9 +242,11 @@ export default class Help {
       DomEvent.on(actionContainer, 'click', action.addHooks, action)
       DomEvent.on(actionContainer, 'click', this.dialog.close, this.dialog)
     }
-    for (const id in this.map.helpMenuActions) {
-      addAction(this.map.helpMenuActions[id])
+    for (const action of Object.values(Help.MENU_ACTIONS)) {
+      addAction(action)
     }
     return container
   }
 }
+
+Help.MENU_ACTIONS = {}

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

@@ -1,4 +1,8 @@
-import { DomEvent, DomUtil } from '../../vendors/leaflet/leaflet-src.esm.js'
+import {
+  DomEvent,
+  DomUtil,
+  LatLngBounds,
+} from '../../vendors/leaflet/leaflet-src.esm.js'
 import { uMapAlert as Alert } from '../components/alerts/alert.js'
 import { translate } from './i18n.js'
 import { SCHEMA } from './schema.js'
@@ -6,17 +10,14 @@ import Dialog from './ui/dialog.js'
 import * as Utils from './utils.js'
 
 const TEMPLATE = `
+  <div class="umap-upload">
     <h3><i class="icon icon-16 icon-upload"></i><span>${translate('Import data')}</span></h3>
     <fieldset class="formbox">
       <legend class="counter">${translate('Choose data')}</legend>
       <input type="file" multiple autofocus onchange />
-      <input type="url" placeholder="${translate('Provide an URL here')}" onchange />
       <textarea onchange placeholder="${translate('Paste your data here')}"></textarea>
-      <div class="importers" hidden>
-        <h4>${translate('Import helpers:')}</h4>
-        <ul class="grid-container">
-        </ul>
-      </div>
+      <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>
     </fieldset>
     <fieldset class="formbox">
       <legend class="counter" data-help="importFormats">${translate(
@@ -36,30 +37,45 @@ const TEMPLATE = `
     <fieldset id="import-mode" class="formbox">
       <legend class="counter" data-help="importMode">${translate('Choose import mode')}</legend>
       <label>
-        <input type="radio" name="action" value="copy" />
+        <input type="radio" name="action" value="copy" checked onchange />
         ${translate('Copy into the layer')}
       </label>
       <label>
-        <input type="radio" name="action" value="link" />
+        <input type="radio" name="action" value="link" onchange />
         ${translate('Link to the layer as remote data')}
       </label>
     </fieldset>
-    <input type="button" class="button" name="submit" value="${translate('Import data')}" />
+    <input type="button" class="button primary" name="submit" value="${translate('Import data')}" disabled />
+  </div>
     `
 
-export default class Importer {
-  constructor(map) {
-    this.map = map
+const GRID_TEMPLATE = `
+  <div>
+    <h3><i class="icon icon-16 icon-magic"></i>${translate('Import helpers')}</h3>
+    <p>${translate('Import helpers will fill the URL field for you.')}</p>
+    <ul class="grid-container by4" data-ref="grid"></ul>
+  </div>
+`
+
+export default class Importer extends Utils.WithTemplate {
+  constructor(umap) {
+    super()
+    this._umap = umap
     this.TYPES = ['geojson', 'csv', 'gpx', 'kml', 'osm', 'georss', 'umap']
     this.IMPORTERS = []
     this.loadImporters()
-    this.dialog = new Dialog()
+    this.dialog = new Dialog({
+      className: 'importers dark',
+      back: () => this.showImporters(),
+    })
   }
 
   loadImporters() {
-    for (const [name, config] of Object.entries(this.map.options.importers || {})) {
+    for (const [name, config] of Object.entries(
+      this._umap.properties.importers || {}
+    )) {
       const register = (mod) => {
-        this.IMPORTERS.push(new mod.Importer(this.map, config))
+        this.IMPORTERS.push(new mod.Importer(this._umap, config))
       }
       // We need to have explicit static paths for Django's collectstatic with hashes.
       switch (name) {
@@ -112,6 +128,11 @@ export default class Importer {
     return this.qs('textarea').value
   }
 
+  set raw(value) {
+    this.qs('textarea').value = value
+    this.onChange()
+  }
+
   get clear() {
     return Boolean(this.qs('[name=clear]').checked)
   }
@@ -139,25 +160,31 @@ export default class Importer {
 
   get layer() {
     return (
-      this.map.datalayers[this.layerId] ||
-      this.map.createDataLayer({ name: this.layerName })
+      this._umap.datalayers[this.layerId] ||
+      this._umap.createDataLayer({ name: this.layerName })
     )
   }
 
+  showImporters() {
+    if (!this.IMPORTERS.length) return
+    const [element, { grid }] = Utils.loadTemplateWithRefs(GRID_TEMPLATE)
+    for (const plugin of this.IMPORTERS.sort((a, b) => (a.id > b.id ? 1 : -1))) {
+      const button = Utils.loadTemplate(
+        `<li><button type="button" class="${plugin.id}">${plugin.name}</button></li>`
+      )
+      button.addEventListener('click', () => plugin.open(this))
+      grid.appendChild(button)
+    }
+    this.dialog.open({ template: element, cancel: false, accept: false, back: false })
+  }
+
   build() {
-    this.container = DomUtil.create('div', 'umap-upload')
-    this.container.innerHTML = TEMPLATE
+    this.container = this.loadTemplate(TEMPLATE)
     if (this.IMPORTERS.length) {
-      const parent = this.container.querySelector('.importers ul')
-      for (const plugin of this.IMPORTERS.sort((a, b) => (a.id > b.id ? 1 : -1))) {
-        L.DomUtil.createButton(
-          plugin.id,
-          DomUtil.element({ tagName: 'li', parent }),
-          plugin.name,
-          () => plugin.open(this)
-        )
-      }
-      this.qs('.importers').toggleAttribute('hidden', false)
+      // TODO use this.elements instead of this.qs
+      const button = this.qs('[data-ref=importersButton]')
+      button.addEventListener('click', () => this.showImporters())
+      button.toggleAttribute('hidden', false)
     }
     for (const type of this.TYPES) {
       DomUtil.element({
@@ -167,8 +194,8 @@ export default class Importer {
         textContent: type,
       })
     }
-    this.map.help.parse(this.container)
-    DomEvent.on(this.qs('[name=submit]'), 'click', this.submit, this)
+    this._umap.help.parse(this.container)
+    this.qs('[name=submit]').addEventListener('click', () => this.submit())
     DomEvent.on(this.qs('[type=file]'), 'change', this.onFileChange, this)
     for (const element of this.container.querySelectorAll('[onchange]')) {
       DomEvent.on(element, 'change', this.onChange, this)
@@ -183,6 +210,7 @@ export default class Importer {
     )
     this.qs('[name=layer-name]').toggleAttribute('hidden', Boolean(this.layerId))
     this.qs('#clear').toggleAttribute('hidden', !this.layerId)
+    this.qs('[name=submit').toggleAttribute('disabled', !this.canSubmit())
   }
 
   onFileChange(e) {
@@ -204,9 +232,10 @@ export default class Importer {
     this.url = null
     this.format = undefined
     this.layerName = null
+    this.raw = null
     const layerSelect = this.qs('[name="layer-id"]')
     layerSelect.innerHTML = ''
-    this.map.eachDataLayerReverse((datalayer) => {
+    this._umap.eachDataLayerReverse((datalayer) => {
       if (datalayer.isLoaded() && !datalayer.isRemoteLayer()) {
         DomUtil.element({
           tagName: 'option',
@@ -227,7 +256,7 @@ export default class Importer {
 
   open() {
     if (!this.container) this.build()
-    const onLoad = this.map.editPanel.open({ content: this.container })
+    const onLoad = this._umap.editPanel.open({ content: this.container })
     onLoad.then(() => this.onLoad())
   }
 
@@ -236,34 +265,41 @@ export default class Importer {
     this.qs('[type=file]').showPicker()
   }
 
+  canSubmit() {
+    if (!this.format) return false
+    const hasFiles = Boolean(this.files.length)
+    const hasRaw = Boolean(this.raw)
+    const hasUrl = Boolean(this.url)
+    const hasAction = Boolean(this.action)
+    if (!hasFiles && !hasRaw && !hasUrl) return false
+    if (this.url) return hasAction
+    return true
+  }
+
   submit() {
-    let hasErrors
     if (this.format === 'umap') {
-      hasErrors = !this.full()
+      this.full()
     } else if (!this.url) {
-      hasErrors = !this.copy()
+      this.copy()
     } else if (this.action) {
-      hasErrors = !this[this.action]()
-    }
-    if (hasErrors === false) {
-      Alert.info(translate('Data successfully imported!'))
+      this[this.action]()
     }
   }
 
   full() {
-    this.map.once('postsync', this.map._setDefaultCenter)
     try {
       if (this.files.length) {
         for (const file of this.files) {
-          this.map.processFileToImport(file, null, 'umap')
+          this._umap.processFileToImport(file, null, 'umap')
         }
       } else if (this.raw) {
-        this.map.importRaw(this.raw)
+        this._umap.importRaw(this.raw)
       } else if (this.url) {
-        this.map.importFromUrl(this.url, this.format)
+        this._umap.importFromUrl(this.url, this.format)
       }
+      this.onSuccess()
     } catch (e) {
-      Alert.error(translate('Invalid umap data'))
+      this.onError(translate('Invalid umap data'))
       console.error(e)
       return false
     }
@@ -274,7 +310,7 @@ export default class Importer {
       return false
     }
     if (!this.format) {
-      Alert.error(translate('Please choose a format'))
+      this.onError(translate('Please choose a format'))
       return false
     }
     const layer = this.layer
@@ -282,30 +318,71 @@ export default class Importer {
       url: this.url,
       format: this.format,
     }
-    if (this.map.options.urls.ajax_proxy) {
+    if (this._umap.properties.urls.ajax_proxy) {
       layer.options.remoteData.proxy = true
       layer.options.remoteData.ttl = SCHEMA.ttl.default
     }
-    layer.fetchRemoteData(true)
+    layer.fetchRemoteData(true).then((features) => {
+      if (features?.length) {
+        layer.zoomTo()
+        this.onSuccess()
+      } else {
+        this.onError()
+      }
+    })
   }
 
-  copy() {
+  async copy() {
     // Format may be guessed from file later.
     // Usefull in case of multiple files with different formats.
     if (!this.format && !this.files.length) {
-      Alert.error(translate('Please choose a format'))
+      this.onError(translate('Please choose a format'))
       return false
     }
+    let promise
     const layer = this.layer
     if (this.clear) layer.empty()
     if (this.files.length) {
-      for (const file of this.files) {
-        this.map.processFileToImport(file, layer, this.format)
-      }
+      promise = layer.importFromFiles(this.files, this.format)
     } else if (this.raw) {
-      layer.importRaw(this.raw, this.format)
+      promise = layer.importRaw(this.raw, this.format)
     } else if (this.url) {
-      layer.importFromUrl(this.url, this.format)
+      promise = layer.importFromUrl(this.url, this.format)
+    }
+    if (promise) promise.then((data) => this.onCopyFinished(layer, data))
+  }
+
+  onError(message = translate('No data has been found for import')) {
+    Alert.error(message)
+  }
+
+  onSuccess(count) {
+    if (count) {
+      Alert.success(
+        translate('Successfully imported {count} feature(s)', {
+          count: count,
+        })
+      )
+    } else {
+      Alert.success(translate('Data successfully imported!'))
+    }
+  }
+
+  onCopyFinished(layer, features) {
+    // undefined features means error, let original error message pop
+    if (!features) return
+    if (!features.length) {
+      this.onError()
+    } else {
+      const bounds = new LatLngBounds()
+      for (const feature of features) {
+        const featureBounds = feature.ui.getBounds
+          ? feature.ui.getBounds()
+          : feature.ui.getCenter()
+        bounds.extend(featureBounds)
+      }
+      this.onSuccess(features.length)
+      layer.zoomTo(bounds)
     }
   }
 }

umap/static/umap/js/modules/importers/cadastrefr.js

@@ -2,6 +2,8 @@ import { DomUtil } from '../../../vendors/leaflet/leaflet-src.esm.js'
 import { BaseAjax, SingleMixin } from '../autocomplete.js'
 import * as Util from '../utils.js'
 import { AutocompleteCommunes } from './communesfr.js'
+import { translate } from '../i18n.js'
+import { uMapAlert as Alert } from '../../components/alerts/alert.js'
 
 const TEMPLATE = `
   <h3>Cadastre</h3>
@@ -56,6 +58,8 @@ export class Importer {
       .open({
         template: container,
         className: `${this.id} importer dark`,
+        cancel: false,
+        accept: translate('Choose this data'),
       })
       .then(confirm)
   }

umap/static/umap/js/modules/importers/geodatamine.js

@@ -37,8 +37,8 @@ class Autocomplete extends SingleMixin(BaseAjax) {
 }
 
 export class Importer {
-  constructor(map, options = {}) {
-    this.map = map
+  constructor(umap, options = {}) {
+    this.umap = umap
     this.name = options.name || 'GeoDataMine'
     this.baseUrl = options?.url || 'https://geodatamine.fr'
     this.id = 'geodatamine'
@@ -49,7 +49,7 @@ export class Importer {
     let boundaryName = null
     const container = DomUtil.create('div')
     container.innerHTML = TEMPLATE
-    const response = await importer.map.request.get(`${this.baseUrl}/themes`)
+    const response = await this.umap.request.get(`${this.baseUrl}/themes`)
     const select = container.querySelector('select')
     if (response?.ok) {
       const { themes } = await response.json()

umap/static/umap/js/modules/importers/overpass.js

@@ -53,11 +53,15 @@ export class Importer {
       'https://photon.komoot.io/api?q={q}&layer=county&layer=city&layer=state'
     this.id = 'overpass'
     this.boundaryChoice = null
+    this.expression = null
   }
 
   async open(importer) {
     const container = DomUtil.create('div')
     container.innerHTML = TEMPLATE
+    if (this.expression) {
+      container.querySelector('[name=tags]').value = this.expression
+    }
     this.autocomplete = new Autocomplete(container.querySelector('#area'), {
       url: this.searchUrl,
       placeholder: translate(
@@ -80,6 +84,7 @@ export class Importer {
         Alert.error(translate('Expression is empty'))
         return
       }
+      this.expression = form.tags
       let tags = form.tags
       if (!tags.startsWith('[')) tags = `[${tags}]`
       let area = '{south},{west},{north},{east}'