umap-project 1.14.0a1__py3-none-any.whl → 1.14.0a2__py3-none-any.whl

umap/static/umap/js/umap.icon.js

@@ -0,0 +1,234 @@
+L.U.Icon = L.DivIcon.extend({
+  initialize: function (map, options) {
+    this.map = map
+    const default_options = {
+      iconSize: null, // Made in css
+      iconUrl: this.map.getDefaultOption('iconUrl'),
+      feature: null,
+    }
+    options = L.Util.extend({}, default_options, options)
+    L.Icon.prototype.initialize.call(this, options)
+    this.feature = this.options.feature
+    if (this.feature && this.feature.isReadOnly()) {
+      this.options.className += ' readonly'
+    }
+  },
+
+  _getIconUrl: function (name) {
+    let url
+    if (this.feature && this.feature._getIconUrl(name))
+      url = this.feature._getIconUrl(name)
+    else url = this.options[`${name}Url`]
+    return this.formatUrl(url, this.feature)
+  },
+
+  _getColor: function () {
+    let color
+    if (this.feature) color = this.feature.getDynamicOption('color')
+    else if (this.options.color) color = this.options.color
+    else color = this.map.getDefaultOption('color')
+    return color
+  },
+
+  _getOpacity: function () {
+    if (this.feature) return this.feature.getOption('iconOpacity')
+    return this.map.getDefaultOption('iconOpacity')
+  },
+
+  formatUrl: function (url, feature) {
+    return L.Util.greedyTemplate(url || '', feature ? feature.extendedProperties() : {})
+  },
+
+  onAdd: function () {},
+})
+
+L.U.Icon.Default = L.U.Icon.extend({
+  default_options: {
+    iconAnchor: new L.Point(16, 40),
+    popupAnchor: new L.Point(0, -40),
+    tooltipAnchor: new L.Point(16, -24),
+    className: 'umap-div-icon',
+  },
+
+  initialize: function (map, options) {
+    options = L.Util.extend({}, this.default_options, options)
+    L.U.Icon.prototype.initialize.call(this, map, options)
+  },
+
+  _setIconStyles: function (img, name) {
+    L.U.Icon.prototype._setIconStyles.call(this, img, name)
+    const color = this._getColor(),
+      opacity = this._getOpacity()
+    this.elements.container.style.backgroundColor = color
+    this.elements.arrow.style.borderTopColor = color
+    this.elements.container.style.opacity = opacity
+    this.elements.arrow.style.opacity = opacity
+  },
+
+  onAdd: function () {
+    const src = this._getIconUrl('icon')
+    const bgcolor = this._getColor()
+    L.U.Icon.setIconContrast(this.elements.icon, this.elements.container, src, bgcolor)
+  },
+
+  createIcon: function () {
+    this.elements = {}
+    this.elements.main = L.DomUtil.create('div')
+    this.elements.container = L.DomUtil.create(
+      'div',
+      'icon_container',
+      this.elements.main
+    )
+    this.elements.arrow = L.DomUtil.create('div', 'icon_arrow', this.elements.main)
+    const src = this._getIconUrl('icon')
+    if (src) {
+      this.elements.icon = L.U.Icon.makeIconElement(src, this.elements.container)
+    }
+    this._setIconStyles(this.elements.main, 'icon')
+    return this.elements.main
+  },
+})
+
+L.U.Icon.Circle = L.U.Icon.extend({
+  initialize: function (map, options) {
+    const default_options = {
+      popupAnchor: new L.Point(0, -6),
+      tooltipAnchor: new L.Point(6, 0),
+      className: 'umap-circle-icon',
+    }
+    options = L.Util.extend({}, default_options, options)
+    L.U.Icon.prototype.initialize.call(this, map, options)
+  },
+
+  _setIconStyles: function (img, name) {
+    L.U.Icon.prototype._setIconStyles.call(this, img, name)
+    this.elements.main.style.backgroundColor = this._getColor()
+    this.elements.main.style.opacity = this._getOpacity()
+  },
+
+  createIcon: function () {
+    this.elements = {}
+    this.elements.main = L.DomUtil.create('div')
+    this.elements.main.innerHTML = ' '
+    this._setIconStyles(this.elements.main, 'icon')
+    return this.elements.main
+  },
+})
+
+L.U.Icon.Drop = L.U.Icon.Default.extend({
+  default_options: {
+    iconAnchor: new L.Point(16, 42),
+    popupAnchor: new L.Point(0, -42),
+    tooltipAnchor: new L.Point(16, -24),
+    className: 'umap-drop-icon',
+  },
+})
+
+L.U.Icon.Ball = L.U.Icon.Default.extend({
+  default_options: {
+    iconAnchor: new L.Point(8, 30),
+    popupAnchor: new L.Point(0, -28),
+    tooltipAnchor: new L.Point(8, -23),
+    className: 'umap-ball-icon',
+  },
+
+  createIcon: function () {
+    this.elements = {}
+    this.elements.main = L.DomUtil.create('div')
+    this.elements.container = L.DomUtil.create(
+      'div',
+      'icon_container',
+      this.elements.main
+    )
+    this.elements.arrow = L.DomUtil.create('div', 'icon_arrow', this.elements.main)
+    this._setIconStyles(this.elements.main, 'icon')
+    return this.elements.main
+  },
+
+  _setIconStyles: function (img, name) {
+    L.U.Icon.prototype._setIconStyles.call(this, img, name)
+    const color = this._getColor('color')
+    let background
+    if (L.Browser.ielt9) {
+      background = color
+    } else if (L.Browser.webkit) {
+      background = `-webkit-gradient( radial, 6 38%, 0, 6 38%, 8, from(white), to(${color}) )`
+    } else {
+      background = `radial-gradient(circle at 6px 38% , white -4px, ${color} 8px) repeat scroll 0 0 transparent`
+    }
+    this.elements.container.style.background = background
+    this.elements.container.style.opacity = this._getOpacity()
+  },
+})
+
+L.U.Icon.Cluster = L.DivIcon.extend({
+  options: {
+    iconSize: [40, 40],
+  },
+
+  initialize: function (datalayer, cluster) {
+    this.datalayer = datalayer
+    this.cluster = cluster
+  },
+
+  createIcon: function () {
+    const container = L.DomUtil.create('div', 'leaflet-marker-icon marker-cluster'),
+      div = L.DomUtil.create('div', '', container),
+      span = L.DomUtil.create('span', '', div),
+      backgroundColor = this.datalayer.getColor()
+    span.textContent = this.cluster.getChildCount()
+    div.style.backgroundColor = backgroundColor
+    return container
+  },
+
+  computeTextColor: function (el) {
+    let color
+    const backgroundColor = this.datalayer.getColor()
+    if (this.datalayer.options.cluster && this.datalayer.options.cluster.textColor) {
+      color = this.datalayer.options.cluster.textColor
+    }
+    return color || L.DomUtil.TextColorFromBackgroundColor(el, backgroundColor)
+  },
+})
+
+L.U.Icon.isImg = function (src) {
+  return L.Util.isPath(src) || L.Util.isRemoteUrl(src) || L.Util.isDataImage(src)
+}
+
+L.U.Icon.makeIconElement = function (src, parent) {
+  let icon
+  if (L.U.Icon.isImg(src)) {
+    icon = L.DomUtil.create('img')
+    icon.src = src
+  } else {
+    icon = L.DomUtil.create('span')
+    icon.textContent = src
+  }
+  parent.appendChild(icon)
+  return icon
+}
+
+L.U.Icon.setIconContrast = function (icon, parent, src, bgcolor) {
+  /*
+   * icon: the element we'll adapt the style, it can be an image or text
+   * parent: the element we'll consider to decide whether to adapt the style,
+   * by looking at its background color
+   * src: the raw "icon" value, can be an URL, a path, text, emoticon, etc.
+   * bgcolor: the background color, used for caching and in case we cannot guess the
+   * parent background color
+  */
+  if (!icon) return
+
+  if (L.DomUtil.contrastedColor(parent, bgcolor)) {
+    // Decide whether to switch svg to white or not, but do it
+    // only for internal SVG, as invert could do weird things
+    if (L.Util.isPath(src) && src.endsWith('.svg')) {
+      // Must be called after icon container is added to the DOM
+      // An image
+      icon.style.filter = 'invert(1)'
+    } else if (!icon.src) {
+      // Text icon
+      icon.style.color = 'white'
+    }
+  }
+}

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

@@ -0,0 +1,166 @@
+L.U.Importer = L.Class.extend({
+  TYPES: ['geojson', 'csv', 'gpx', 'kml', 'osm', 'georss', 'umap'],
+  initialize: function (map) {
+    this.map = map
+    this.presets = map.options.importPresets
+  },
+
+  build: function () {
+    this.container = L.DomUtil.create('div', 'umap-upload')
+    this.title = L.DomUtil.add('h3', '', this.container, L._('Import data'))
+    this.presetBox = L.DomUtil.create('div', 'formbox', this.container)
+    this.presetSelect = L.DomUtil.create('select', '', this.presetBox)
+    this.fileBox = L.DomUtil.create('div', 'formbox', this.container)
+    this.fileInput = L.DomUtil.element(
+      'input',
+      { type: 'file', multiple: 'multiple', autofocus: true },
+      this.fileBox
+    )
+    this.urlInput = L.DomUtil.element(
+      'input',
+      { type: 'text', placeholder: L._('Provide an URL here') },
+      this.container
+    )
+    this.rawInput = L.DomUtil.element(
+      'textarea',
+      { placeholder: L._('Paste your data here') },
+      this.container
+    )
+    this.typeLabel = L.DomUtil.add(
+      'label',
+      '',
+      this.container,
+      L._('Choose the format of the data to import')
+    )
+    this.layerLabel = L.DomUtil.add(
+      'label',
+      '',
+      this.container,
+      L._('Choose the layer to import in')
+    )
+    this.clearLabel = L.DomUtil.add(
+      'label',
+      '',
+      this.container,
+      L._('Replace layer content')
+    )
+    this.submitInput = L.DomUtil.element(
+      'input',
+      { type: 'button', value: L._('Import'), className: 'button' },
+      this.container
+    )
+    this.map.help.button(this.typeLabel, 'importFormats')
+    this.typeInput = L.DomUtil.element('select', { name: 'format' }, this.typeLabel)
+    this.layerInput = L.DomUtil.element(
+      'select',
+      { name: 'datalayer' },
+      this.layerLabel
+    )
+    this.clearFlag = L.DomUtil.element(
+      'input',
+      { type: 'checkbox', name: 'clear' },
+      this.clearLabel
+    )
+    let option
+    this.map.eachDataLayerReverse((datalayer) => {
+      if (datalayer.isLoaded() && !datalayer.isRemoteLayer()) {
+        const id = L.stamp(datalayer)
+        option = L.DomUtil.add('option', '', this.layerInput, datalayer.options.name)
+        option.value = id
+      }
+    })
+    L.DomUtil.element(
+      'option',
+      { value: '', textContent: L._('Import in a new layer') },
+      this.layerInput
+    )
+    L.DomUtil.element(
+      'option',
+      { value: '', textContent: L._('Choose the data format') },
+      this.typeInput
+    )
+    for (let i = 0; i < this.TYPES.length; i++) {
+      option = L.DomUtil.create('option', '', this.typeInput)
+      option.value = option.textContent = this.TYPES[i]
+    }
+    if (this.presets.length) {
+      const noPreset = L.DomUtil.create('option', '', this.presetSelect)
+      noPreset.value = noPreset.textContent = L._('Choose a preset')
+      for (let j = 0; j < this.presets.length; j++) {
+        option = L.DomUtil.create('option', '', presetSelect)
+        option.value = this.presets[j].url
+        option.textContent = this.presets[j].label
+      }
+    } else {
+      this.presetBox.style.display = 'none'
+    }
+    L.DomEvent.on(this.submitInput, 'click', this.submit, this)
+    L.DomEvent.on(
+      this.fileInput,
+      'change',
+      (e) => {
+        let type = '',
+          newType
+        for (let i = 0; i < e.target.files.length; i++) {
+          newType = L.Util.detectFileType(e.target.files[i])
+          if (!type && newType) type = newType
+          if (type && newType !== type) {
+            type = ''
+            break
+          }
+        }
+        this.typeInput.value = type
+      },
+      this
+    )
+  },
+
+  open: function () {
+    if (!this.container) this.build()
+    this.map.ui.openPanel({ data: { html: this.container }, className: 'dark' })
+  },
+
+  openFiles: function () {
+    this.open()
+    this.fileInput.showPicker()
+  },
+
+  submit: function () {
+    let type = this.typeInput.value
+    const layerId = this.layerInput[this.layerInput.selectedIndex].value
+    let layer
+    if (type === 'umap') {
+      this.map.once('postsync', this.map._setDefaultCenter)
+    }
+    if (layerId) layer = this.map.datalayers[layerId]
+    if (layer && this.clearFlag.checked) layer.empty()
+    if (this.fileInput.files.length) {
+      for (let i = 0, file; (file = this.fileInput.files[i]); i++) {
+        this.map.processFileToImport(file, layer, type)
+      }
+    } else {
+      if (!type)
+        return this.map.ui.alert({
+          content: L._('Please choose a format'),
+          level: 'error',
+        })
+      if (this.rawInput.value && type === 'umap') {
+        try {
+          this.map.importRaw(this.rawInput.value, type)
+        } catch (e) {
+          this.ui.alert({ content: L._('Invalid umap data'), level: 'error' })
+          console.error(e)
+        }
+      } else {
+        if (!layer) layer = this.map.createDataLayer()
+        if (this.rawInput.value) layer.importRaw(this.rawInput.value, type)
+        else if (this.urlInput.value) layer.importFromUrl(this.urlInput.value, type)
+        else if (this.presetSelect.selectedIndex > 0)
+          layer.importFromUrl(
+            this.presetSelect[this.presetSelect.selectedIndex].value,
+            type
+          )
+      }
+    }
+  },
+})