umap-project 2.5.1__py3-none-any.whl → 2.6.0b0__py3-none-any.whl

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

@@ -0,0 +1,182 @@
+// Uses global L.HeatLayer, not exposed as ESM
+import {
+  Marker,
+  LatLng,
+  latLngBounds,
+  Bounds,
+  point,
+} from '../../../../vendors/leaflet/leaflet-src.esm.js'
+import { LayerMixin } from './base.js'
+import * as Utils from '../../utils.js'
+import { translate } from '../../i18n.js'
+
+export const Heat = L.HeatLayer.extend({
+  statics: {
+    NAME: translate('Heatmap'),
+    TYPE: 'Heat',
+  },
+  includes: [LayerMixin],
+  browsable: false,
+
+  initialize: function (datalayer) {
+    this.datalayer = datalayer
+    L.HeatLayer.prototype.initialize.call(this, [], this.datalayer.options.heat)
+    LayerMixin.onInit.call(this, this.datalayer.map)
+    if (!Utils.isObject(this.datalayer.options.heat)) {
+      this.datalayer.options.heat = {}
+    }
+  },
+
+  addLayer: function (layer) {
+    if (layer instanceof Marker) {
+      let latlng = layer.getLatLng()
+      let alt
+      if (this.datalayer.options.heat?.intensityProperty) {
+        alt = Number.parseFloat(
+          layer.feature.properties[this.datalayer.options.heat.intensityProperty || 0]
+        )
+        latlng = new LatLng(latlng.lat, latlng.lng, alt)
+      }
+      this.addLatLng(latlng)
+    }
+  },
+
+  onAdd: function (map) {
+    LayerMixin.onAdd.call(this, map)
+    return L.HeatLayer.prototype.onAdd.call(this, map)
+  },
+
+  onRemove: function (map) {
+    LayerMixin.onRemove.call(this, map)
+    return L.HeatLayer.prototype.onRemove.call(this, map)
+  },
+
+  clearLayers: function () {
+    this.setLatLngs([])
+  },
+
+  getFeatures: () => ({}),
+
+  getBounds: function () {
+    return latLngBounds(this._latlngs)
+  },
+
+  getEditableOptions: () => [
+    [
+      'options.heat.radius',
+      {
+        handler: 'Range',
+        min: 10,
+        max: 100,
+        step: 5,
+        label: translate('Heatmap radius'),
+        helpText: translate('Override heatmap radius (default 25)'),
+      },
+    ],
+    [
+      'options.heat.intensityProperty',
+      {
+        handler: 'BlurInput',
+        placeholder: translate('Heatmap intensity property'),
+        helpText: translate('Optional intensity property for heatmap'),
+      },
+    ],
+  ],
+
+  onEdit: function (field, builder) {
+    if (field === 'options.heat.intensityProperty') {
+      this.datalayer.resetLayer(true) // We need to repopulate the latlngs
+      return
+    }
+    if (field === 'options.heat.radius') {
+      this.options.radius = this.datalayer.options.heat.radius
+    }
+    this._updateOptions()
+  },
+
+  redraw: function () {
+    // setlalngs call _redraw through setAnimFrame, thus async, so this
+    // can ends with race condition if we remove the layer very faslty after.
+    // TODO: PR in upstream Leaflet.heat
+    if (!this._map) return
+    L.HeatLayer.prototype.redraw.call(this)
+  },
+
+  _redraw: function () {
+    // Import patch from https://github.com/Leaflet/Leaflet.heat/pull/78
+    // Remove me when this get merged and released.
+    if (!this._map) {
+      return
+    }
+    const data = []
+    const r = this._heat._r
+    const size = this._map.getSize()
+    const bounds = new Bounds(point([-r, -r]), size.add([r, r]))
+    const cellSize = r / 2
+    const grid = []
+    const panePos = this._map._getMapPanePos()
+    const offsetX = panePos.x % cellSize
+    const offsetY = panePos.y % cellSize
+    let i
+    let len
+    let p
+    let cell
+    let x
+    let y
+    let j
+    let len2
+
+    this._max = 1
+
+    for (i = 0, len = this._latlngs.length; i < len; i++) {
+      p = this._map.latLngToContainerPoint(this._latlngs[i])
+      x = Math.floor((p.x - offsetX) / cellSize) + 2
+      y = Math.floor((p.y - offsetY) / cellSize) + 2
+
+      const alt =
+        this._latlngs[i].alt !== undefined
+          ? this._latlngs[i].alt
+          : this._latlngs[i][2] !== undefined
+            ? +this._latlngs[i][2]
+            : 1
+
+      grid[y] = grid[y] || []
+      cell = grid[y][x]
+
+      if (!cell) {
+        cell = grid[y][x] = [p.x, p.y, alt]
+        cell.p = p
+      } else {
+        cell[0] = (cell[0] * cell[2] + p.x * alt) / (cell[2] + alt) // x
+        cell[1] = (cell[1] * cell[2] + p.y * alt) / (cell[2] + alt) // y
+        cell[2] += alt // cumulated intensity value
+      }
+
+      // Set the max for the current zoom level
+      if (cell[2] > this._max) {
+        this._max = cell[2]
+      }
+    }
+
+    this._heat.max(this._max)
+
+    for (i = 0, len = grid.length; i < len; i++) {
+      if (grid[i]) {
+        for (j = 0, len2 = grid[i].length; j < len2; j++) {
+          cell = grid[i][j]
+          if (cell && bounds.contains(cell.p)) {
+            data.push([
+              Math.round(cell[0]),
+              Math.round(cell[1]),
+              Math.min(cell[2], this._max),
+            ])
+          }
+        }
+      }
+    }
+
+    this._heat.data(data).draw(this.options.minOpacity)
+
+    this._frame = null
+  },
+})

umap/static/umap/js/modules/rendering/popup.js

@@ -0,0 +1,99 @@
+import {
+  DomEvent,
+  DomUtil,
+  Path,
+  Popup as BasePopup,
+} from '../../../vendors/leaflet/leaflet-src.esm.js'
+import loadTemplate from './template.js'
+import Browser from '../browser.js'
+
+export default function loadPopup(name) {
+  switch (name) {
+    case 'Large':
+      return PopupLarge
+    case 'Panel':
+      return Panel
+    default:
+      return Popup
+  }
+}
+
+const Popup = BasePopup.extend({
+  initialize: function (feature) {
+    this.feature = feature
+    this.container = DomUtil.create('div', 'umap-popup')
+    this.format()
+    BasePopup.prototype.initialize.call(this, {}, feature)
+    this.setContent(this.container)
+  },
+
+  format: function () {
+    const name = this.feature.getOption('popupTemplate')
+    this.content = loadTemplate(name, this.feature, this.container)
+    const elements = this.container.querySelectorAll('img,iframe')
+    for (const element of elements) {
+      this.onElementLoaded(element)
+    }
+    if (!elements.length && this.container.textContent.replace('\n', '') === '') {
+      this.container.innerHTML = ''
+      DomUtil.add('h3', '', this.container, this.feature.getDisplayName())
+    }
+  },
+
+  onElementLoaded: function (el) {
+    DomEvent.on(el, 'load', () => {
+      this._updateLayout()
+      this._updatePosition()
+      this._adjustPan()
+    })
+  },
+})
+
+const PopupLarge = Popup.extend({
+  options: {
+    maxWidth: 500,
+    className: 'umap-popup-large',
+  },
+})
+
+const Panel = Popup.extend({
+  options: {
+    zoomAnimation: false,
+  },
+
+  onAdd: function (map) {
+    map.panel.setDefaultMode('expanded')
+    map.panel.open({
+      content: this._content,
+      actions: [Browser.backButton(map)],
+    })
+
+    // fire events as in base class Popup.js:onAdd
+    map.fire('popupopen', { popup: this })
+    if (this._source) {
+      this._source.fire('popupopen', { popup: this }, true)
+      if (!(this._source instanceof Path)) {
+        this._source.on('preclick', DomEvent.stopPropagation)
+      }
+    }
+  },
+
+  onRemove: function (map) {
+    map.panel.close()
+
+    // fire events as in base class Popup.js:onRemove
+    map.fire('popupclose', { popup: this })
+    if (this._source) {
+      this._source.fire('popupclose', { popup: this }, true)
+      if (!(this._source instanceof Path)) {
+        this._source.off('preclick', DomEvent.stopPropagation)
+      }
+    }
+  },
+
+  update: () => {},
+  _updateLayout: () => {},
+  _updatePosition: () => {},
+  _adjustPan: () => {},
+  _animateZoom: () => {},
+})

umap/static/umap/js/modules/rendering/template.js

@@ -0,0 +1,217 @@
+import { DomUtil, DomEvent } from '../../../vendors/leaflet/leaflet-src.esm.js'
+import { translate, getLocale } from '../i18n.js'
+import * as Utils from '../utils.js'
+import * as Icon from './icon.js'
+
+export default function loadTemplate(name, feature, container) {
+  let klass = PopupTemplate
+  switch (name) {
+    case 'GeoRSSLink':
+      klass = GeoRSSLink
+      break
+    case 'GeoRSSImage':
+      klass = GeoRSSImage
+      break
+    case 'Table':
+      klass = Table
+      break
+    case 'OSM':
+      klass = OSM
+      break
+  }
+  const content = new klass()
+  return content.render(feature, container)
+}
+
+class PopupTemplate {
+  renderTitle(feature) {}
+
+  renderBody(feature) {
+    const template = feature.getOption('popupContentTemplate')
+    const target = feature.getOption('outlinkTarget')
+    const properties = feature.extendedProperties()
+    // Resolve properties inside description
+    properties.description = Utils.greedyTemplate(
+      feature.properties.description || '',
+      properties
+    )
+    let content = Utils.greedyTemplate(template, properties)
+    content = Utils.toHTML(content, { target: target })
+    return Utils.loadTemplate(`<div class="umap-popup-container text">${content}</div>`)
+  }
+
+  renderFooter(feature) {
+    if (feature.hasPopupFooter()) {
+      const template = `
+      <ul class="umap-popup-footer dark">
+        <li rel="prev"><button class="icon icon-16 icon-back" data-ref="previous"></button></li>
+        <li class="zoom" title="${translate('Zoom to this feature')}"><button class="icon icon-16 icon-zoom" data-ref="zoom"></button></li>
+        <li rel="next"><button class="icon icon-16 icon-forward" data-ref="next"></button></li>
+      </ul>`
+      const [footer, { previous, zoom, next }] = Utils.loadTemplateWithRefs(template)
+      const nextFeature = feature.getNext()
+      const previousFeature = feature.getPrevious()
+      // Fixme: remove me when this is merged and released
+      // https://github.com/Leaflet/Leaflet/pull/9052
+      DomEvent.disableClickPropagation(footer)
+      if (nextFeature) {
+        next.title = translate('Go to «{feature}»', {
+          feature: nextFeature.properties.name || translate('next'),
+        })
+        DomEvent.on(next, 'click', () => {
+          nextFeature.zoomTo({ callback: nextFeature.view })
+        })
+      }
+      if (previousFeature) {
+        previous.title = translate('Go to «{feature}»', {
+          feature: previousFeature.properties.name || translate('previous'),
+        })
+        DomEvent.on(previous, 'click', () => {
+          previousFeature.zoomTo({ callback: previousFeature.view })
+        })
+      }
+      DomEvent.on(zoom, 'click', () => feature.zoomTo())
+      return footer
+    }
+  }
+
+  render(feature, container) {
+    const title = this.renderTitle(feature)
+    if (title) container.appendChild(title)
+    const body = this.renderBody(feature)
+    if (body) DomUtil.add('div', 'umap-popup-content', container, body)
+    const footer = this.renderFooter(feature)
+    if (footer) container.appendChild(footer)
+  }
+}
+export const TitleMixin = (Base) =>
+  class extends Base {
+    renderTitle(feature) {
+      const title = feature.getDisplayName()
+      if (title) {
+        return Utils.loadTemplate(`<h3 class="popup-title">${title}</h3>`)
+      }
+    }
+  }
+
+class Table extends TitleMixin(PopupTemplate) {
+  getValue(feature, key) {
+    // TODO, manage links (url, mailto, wikipedia...)
+    const value = Utils.escapeHTML(feature.properties[key]).trim()
+    if (value.indexOf('http') === 0) {
+      return `<a href="${value}" target="_blank">${value}</a>`
+    }
+    return value
+  }
+
+  makeRow(feature, key) {
+    return Utils.loadTemplate(
+      `<tr><th>${key}</th><td>${this.getValue(feature, key)}</td></tr>`
+    )
+  }
+
+  renderBody(feature) {
+    const table = document.createElement('table')
+
+    for (const key in feature.properties) {
+      if (typeof feature.properties[key] === 'object' || key === 'name') continue
+      table.appendChild(this.makeRow(feature, key))
+    }
+    return table
+  }
+}
+
+class GeoRSSImage extends TitleMixin(PopupTemplate) {
+  renderBody(feature) {
+    const body = DomUtil.create('a')
+    body.href = feature.properties.link
+    body.target = '_blank'
+    if (feature.properties.img) {
+      const img = DomUtil.create('img', '', body)
+      img.src = feature.properties.img
+      // Sadly, we are unable to override this from JS the clean way
+      // See https://github.com/Leaflet/Leaflet/commit/61d746818b99d362108545c151a27f09d60960ee#commitcomment-6061847
+      img.style.maxWidth = '500px'
+      img.style.maxHeight = '500px'
+    }
+    return body
+  }
+}
+
+class GeoRSSLink extends PopupTemplate {
+  renderBody(feature) {
+    if (feature.properties.link) {
+      return Utils.loadTemplate(
+        `<a href="${feature.properties.link}" target="_blank"><h3>${feature.getDisplayName()}</h3></a>`
+      )
+    }
+  }
+}
+
+class OSM extends TitleMixin(PopupTemplate) {
+  getName(feature) {
+    const props = feature.properties
+    const locale = getLocale()
+    if (locale && props[`name:${locale}`]) return props[`name:${locale}`]
+    return props.name
+  }
+
+  renderBody(feature) {
+    const props = feature.properties
+    const body = document.createElement('div')
+    const title = DomUtil.add('h3', 'popup-title', container)
+    const color = feature.getPreviewColor()
+    title.style.backgroundColor = color
+    const iconUrl = feature.getDynamicOption('iconUrl')
+    const icon = Icon.makeElement(iconUrl, title)
+    DomUtil.addClass(icon, 'icon')
+    Icon.setContrast(icon, title, iconUrl, color)
+    if (DomUtil.contrastedColor(title, color)) title.style.color = 'white'
+    DomUtil.add('span', '', title, this.getName(feature))
+    const street = props['addr:street']
+    if (street) {
+      const row = DomUtil.add('address', 'address', body)
+      const number = props['addr:housenumber']
+      if (number) {
+        // Poor way to deal with international forms of writting addresses
+        DomUtil.add('span', '', row, `${translate('No.')}: ${number}`)
+        DomUtil.add('span', '', row, `${translate('Street')}: ${street}`)
+      } else {
+        DomUtil.add('span', '', row, street)
+      }
+    }
+    if (props.website) {
+      body.appendChild(
+        Utils.loadTemplate(`<div><a href="${props.website}">${props.website}</a></div>`)
+      )
+    }
+    const phone = props.phone || props['contact:phone']
+    if (phone) {
+      body.appendChild(
+        Utils.loadTemplate(`<div><a href="tel:${phone}">${phone}</a></div>`)
+      )
+    }
+    if (props.mobile) {
+      body.appendChild(
+        Utils.loadTemplate(
+          `<div><a href="tel:${props.mobile}">${props.mobile}</a></div>`
+        )
+      )
+    }
+    const email = props.email || props['contact:email']
+    if (email) {
+      body.appendChild(
+        Utils.loadTemplate(`<div><a href="mailto:${email}">${email}</a></div>`)
+      )
+    }
+    const id = props['@id'] || props.id
+    if (id) {
+      body.appendChild(
+        Utils.loadTemplate(
+          `<div class="osm-link"><a href="https://www.openstreetmap.org/${id}">${translate('See on OpenStreetMap')}</a></div>`
+        )
+      )
+    }
+    return body
+  }
+}