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

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)
+    }
+  }
+}

umap/static/umap/js/modules/managers.js

@@ -1,3 +1,5 @@
+import * as Utils from './utils.js'
+
 export class DataLayerManager extends Object {
   add(datalayer) {
     this[datalayer.id] = datalayer
@@ -43,4 +45,69 @@ export class DataLayerManager extends Object {
     if (!next.canBrowse()) return this.next(next)
     return next
   }
+  first() {
+    return this.active()[0]
+  }
+  last() {
+    const layers = this.active()
+    return layers[layers.length - 1]
+  }
+}
+
+export class FeatureManager extends Map {
+  add(feature) {
+    if (this.has(feature.id)) {
+      console.error('Duplicate id', feature, this.get(feature.id))
+      feature.id = Utils.generateId()
+    }
+    this.set(feature.id, feature)
+  }
+
+  all() {
+    return Array.from(this.values())
+  }
+
+  visible() {
+    return this.all().filter((feature) => !feature.isFiltered())
+  }
+
+  del(feature) {
+    this.delete(feature.id)
+  }
+
+  count() {
+    return this.size
+  }
+
+  sort(by) {
+    const features = this.all()
+    Utils.sortFeatures(features, by, U.lang)
+    this.clear()
+    for (const feature of features) {
+      this.set(feature.id, feature)
+    }
+  }
+
+  getIndex(feature) {
+    const entries = Array.from(this)
+    return entries.findIndex(([id]) => id === feature.id)
+  }
+
+  first() {
+    return this.values().next().value
+  }
+
+  last() {
+    return this.all()[this.size - 1]
+  }
+
+  next(feature) {
+    const index = this.getIndex(feature)
+    return this.all()[index + 1]
+  }
+
+  prev(feature) {
+    const index = this.getIndex(feature)
+    return this.all()[index - 1]
+  }
 }

umap/static/umap/js/modules/printer.js

@@ -0,0 +1,107 @@
+import { translate } from './i18n.js'
+import * as Utils from './utils.js'
+
+export default class Printer {
+  constructor(umap) {
+    this.umap = umap
+    this.dialog = this.umap.dialog
+  }
+
+  build() {
+    const [container, { format, mode, scale }] = Utils.loadTemplateWithRefs(`
+      <div>
+        <h3>${translate('Print map')}</h3>
+        <div class="formbox">
+          <label>${translate('Choose a format')}
+            <select name="format" data-ref="format">
+              <option value="a4">A4</option>
+              <option value="usletter">US Letter</option>
+            </select>
+          </label>
+          <label>${translate('Scale map')}
+            <input type="range" min="50" max="150" name="scale" data-ref="scale" />
+          </label>
+          <div class="umap-multiplechoice by2" data-ref="mode">
+              <input type="radio" name="mode" id="mode.0" value="portrait"><label for="mode.0">${translate('portrait')}</label>
+              <input type="radio" name="mode" id="mode.1" value="landscape" checked=""><label for="mode.1">${translate('landscape')}</label>
+          </div>
+        </div>
+      </div>
+    `)
+    this.container = container
+    format.addEventListener('change', () => this.resizeMap())
+    mode.addEventListener('change', () => this.resizeMap())
+    scale.addEventListener('change', () => this.resizeMap())
+  }
+
+  resetSize() {
+    const map = this.umap._leafletMap
+    for (const name of Array.from(map._container.classList)) {
+      if (name.startsWith('print-')) {
+        map._container.classList.remove(name)
+      }
+    }
+    map._container.removeAttribute('style')
+    map.invalidateSize()
+  }
+
+  resizeMap() {
+    const form = this.dialog.collectFormData()
+    this.resetSize()
+    const map = this.umap._leafletMap
+    if (form.format && form.mode) {
+      map._container.classList.add(`print-${form.format}`)
+      map._container.classList.add(`print-${form.mode}`)
+      map._container.style.width = `${form.scale}%`
+      map.invalidateSize()
+    }
+  }
+
+  open(action = 'print') {
+    if (!this.container) this.build()
+    this.action = action
+    const acceptLabel = action === 'print' ? translate('Print') : translate('Download')
+    this.dialog.on(
+      'close',
+      (event) => {
+        if (event.target.returnValue !== 'accept') {
+          this.resetSize()
+        }
+      },
+      { once: true }
+    )
+    this.dialog
+      .open({ template: this.container, cancel: false, accept: acceptLabel })
+      .then((form) => this.onSubmit(form))
+    this.resizeMap()
+  }
+
+  async onSubmit(form) {
+    this.umap.fire('dataloading', { id: 'screenshot' })
+    if (this.action === 'print') {
+      const win = window.open('', '_blank')
+      // Using document.body.appendChild here will end with black font
+      // on a black blackground, no idea why.
+      win.document.write(`<span>${translate('Preparing the print…')}</span>`)
+      // screenshot must be called after window.open, no idea why,
+      // otherwise window.open sometimes fails and returns null.
+      const screenshot = await this.umap.screenshot()
+      const img = await screenshot.toPng()
+      img.addEventListener('load', () => {
+        win.print()
+        win.close()
+      })
+      win.document.querySelector('span').remove()
+      win.document.body.appendChild(img)
+      win.focus()
+    } else {
+      const screenshot = await this.umap.screenshot()
+      await screenshot.download({
+        format: this.action,
+        filename: Utils.slugify(this.umap.properties.name),
+      })
+    }
+    this.resetSize()
+    this.umap.fire('dataload', { id: 'screenshot' })
+  }
+}

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

@@ -138,11 +138,21 @@ const BaseButton = Control.extend({
     button.addEventListener('dblclick', (event) => {
       event.stopPropagation()
     })
-    this.afterAdd(container)
+    if (this.options.icon) {
+      button.appendChild(
+        Utils.loadTemplate(`<i class="icon icon-24 ${this.options.icon}"></i>`)
+      )
+    }
+    this.afterAdd(container, map)
     return container
   },
 
-  afterAdd: (container) => {},
+  onRemove(map) {
+    this.afterRemove(map)
+  },
+
+  afterAdd: (container, map) => {},
+  afterRemove: (map) => {},
 })
 
 export const DataLayersControl = BaseButton.extend({
@@ -150,6 +160,7 @@ export const DataLayersControl = BaseButton.extend({
     position: 'topleft',
     className: 'umap-control-browse',
     title: translate('Open browser'),
+    icon: 'icon-layers',
   },
 
   afterAdd: function (container) {
@@ -166,6 +177,7 @@ export const CaptionControl = BaseButton.extend({
     position: 'topleft',
     className: 'umap-control-caption',
     title: translate('About'),
+    icon: 'icon-caption',
   },
 
   onClick: function () {
@@ -178,6 +190,7 @@ export const EmbedControl = BaseButton.extend({
     position: 'topleft',
     title: translate('Share and download'),
     className: 'leaflet-control-embed',
+    icon: 'icon-share',
   },
 
   onClick: function () {
@@ -185,6 +198,69 @@ export const EmbedControl = BaseButton.extend({
   },
 })
 
+export const PrintControl = BaseButton.extend({
+  options: {
+    position: 'topleft',
+    title: translate('Print'),
+    icon: 'icon-print',
+  },
+
+  onClick: function () {
+    this._umap.openPrinter('print')
+  },
+})
+
+export const SearchControl = BaseButton.extend({
+  options: {
+    position: 'topleft',
+    title: translate('Search location'),
+    className: 'leaflet-control-search',
+    icon: 'icon-search',
+  },
+
+  afterAdd(container, map) {
+    this.layer = L.layerGroup().addTo(map)
+    this.photonOptions = {
+      limit: 10,
+      noResultLabel: translate('No results'),
+    }
+    if (map.options.photonUrl) this.photonOptions.url = map.options.photonUrl
+  },
+
+  afterRemove: function (map) {
+    this.layer.remove()
+  },
+
+  onClick: function () {
+    const template = `
+      <div>
+        <h3><i class="icon icon-16 icon-search"></i>${translate('Search location')}</h3>
+        <input class="photon-input" data-ref=input />
+        <div class="photon-autocomplete" data-ref=resultsContainer></div>
+      </div>
+    `
+    const [container, { input, resultsContainer }] =
+      Utils.loadTemplateWithRefs(template)
+    const id = Math.random()
+    this._umap.panel.open({ content: container }).then(() => {
+      this.search = new U.Search(
+        this._umap._leafletMap,
+        input,
+        this.layer,
+        this.photonOptions
+      )
+      this.search.on('ajax:send', () => {
+        this._umap.fire('dataloading', { id: id })
+      })
+      this.search.on('ajax:return', () => {
+        this._umap.fire('dataload', { id: id })
+      })
+      this.search.resultsContainer = resultsContainer
+      input.focus()
+    })
+  },
+})
+
 export const AttributionControl = Control.Attribution.extend({
   options: {
     prefix: '',