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

umap/static/umap/js/umap.share.js

@@ -0,0 +1,254 @@
+L.U.Share = L.Class.extend({
+  EXPORT_TYPES: {
+    geojson: {
+      formatter: function (map) {
+        return JSON.stringify(map.toGeoJSON(), null, 2)
+      },
+      ext: '.geojson',
+      filetype: 'application/json',
+    },
+    gpx: {
+      formatter: function (map) {
+        return togpx(map.toGeoJSON())
+      },
+      ext: '.gpx',
+      filetype: 'application/gpx+xml',
+    },
+    kml: {
+      formatter: function (map) {
+        return tokml(map.toGeoJSON())
+      },
+      ext: '.kml',
+      filetype: 'application/vnd.google-earth.kml+xml',
+    },
+    csv: {
+      formatter: function (map) {
+        const table = []
+        map.eachFeature((feature) => {
+          const row = feature.toGeoJSON()['properties'],
+            center = feature.getCenter()
+          delete row['_umap_options']
+          row['Latitude'] = center.lat
+          row['Longitude'] = center.lng
+          table.push(row)
+        })
+        return csv2geojson.dsv.csvFormat(table)
+      },
+      ext: '.csv',
+      filetype: 'text/csv',
+    },
+  },
+
+  initialize: function (map) {
+    this.map = map
+  },
+
+  build: function () {
+    this.container = L.DomUtil.create('div', 'umap-share')
+    this.title = L.DomUtil.create('h3', '', this.container)
+    this.title.textContent = L._('Share and download')
+
+    L.DomUtil.createCopiableInput(
+      this.container,
+      L._('Link to view the map'),
+      window.location.protocol + L.Util.getBaseUrl()
+    )
+
+    if (this.map.options.shortUrl) {
+      L.DomUtil.createCopiableInput(
+        this.container,
+        L._('Short link'),
+        this.map.options.shortUrl
+      )
+    }
+
+    L.DomUtil.create('hr', '', this.container)
+
+    L.DomUtil.add('h4', '', this.container, L._('Download'))
+    L.DomUtil.add('small', 'label', this.container, L._("Only visible layers' data"))
+    for (const key in this.EXPORT_TYPES) {
+      if (this.EXPORT_TYPES.hasOwnProperty(key)) {
+        L.DomUtil.createButton(
+          'download-file',
+          this.container,
+          this.EXPORT_TYPES[key].name || key,
+          () => this.download(key),
+          this
+        )
+      }
+    }
+    L.DomUtil.create('div', 'vspace', this.container)
+    L.DomUtil.add(
+      'small',
+      'label',
+      this.container,
+      L._('All data and settings of the map')
+    )
+    const downloadUrl = L.Util.template(this.map.options.urls.map_download, {
+      map_id: this.map.options.umap_id,
+    })
+    const link = L.DomUtil.createLink(
+      'download-backup',
+      this.container,
+      L._('full backup'),
+      downloadUrl
+    )
+    let name = this.map.options.name || 'data'
+    name = name.replace(/[^a-z0-9]/gi, '_').toLowerCase()
+    link.setAttribute('download', `${name}.umap`)
+    L.DomUtil.create('hr', '', this.container)
+
+    const embedTitle = L.DomUtil.add('h4', '', this.container, L._('Embed the map'))
+    const iframe = L.DomUtil.create('textarea', 'umap-share-iframe', this.container)
+    const urlTitle = L.DomUtil.add('h4', '', this.container, L._('Direct link'))
+    const exportUrl = L.DomUtil.createCopiableInput(
+      this.container,
+      L._('Share this link to open a customized map view'),
+      ''
+    )
+
+    exportUrl.type = 'text'
+    const UIFields = [
+      ['dimensions.width', { handler: 'Input', label: L._('width') }],
+      ['dimensions.height', { handler: 'Input', label: L._('height') }],
+      [
+        'options.includeFullScreenLink',
+        { handler: 'Switch', label: L._('Include full screen link?') },
+      ],
+      [
+        'options.currentView',
+        { handler: 'Switch', label: L._('Current view instead of default map view?') },
+      ],
+      [
+        'options.keepCurrentDatalayers',
+        { handler: 'Switch', label: L._('Keep current visible layers') },
+      ],
+      [
+        'options.viewCurrentFeature',
+        { handler: 'Switch', label: L._('Open current feature on load') },
+      ],
+      'queryString.moreControl',
+      'queryString.scrollWheelZoom',
+      'queryString.miniMap',
+      'queryString.scaleControl',
+      'queryString.onLoadPanel',
+      'queryString.captionBar',
+      'queryString.captionMenus',
+    ]
+    for (let i = 0; i < this.map.HIDDABLE_CONTROLS.length; i++) {
+      UIFields.push(`queryString.${this.map.HIDDABLE_CONTROLS[i]}Control`)
+    }
+    const iframeExporter = new L.U.IframeExporter(this.map)
+    const buildIframeCode = () => {
+      iframe.innerHTML = iframeExporter.build()
+      exportUrl.value = window.location.protocol + iframeExporter.buildUrl()
+    }
+    buildIframeCode()
+    const builder = new L.U.FormBuilder(iframeExporter, UIFields, {
+      callback: buildIframeCode,
+    })
+    const iframeOptions = L.DomUtil.createFieldset(
+      this.container,
+      L._('Embed and link options')
+    )
+    iframeOptions.appendChild(builder.build())
+  },
+
+  open: function () {
+    if (!this.container) this.build()
+    this.map.ui.openPanel({ data: { html: this.container } })
+  },
+
+  format: function (mode) {
+    const type = this.EXPORT_TYPES[mode]
+    const content = type.formatter(this.map)
+    let name = this.map.options.name || 'data'
+    name = name.replace(/[^a-z0-9]/gi, '_').toLowerCase()
+    const filename = name + type.ext
+    return { content, filetype: type.filetype, filename }
+  },
+
+  download: function (mode) {
+    const { content, filetype, filename } = this.format(mode)
+    const blob = new Blob([content], { type: filetype })
+    window.URL = window.URL || window.webkitURL
+    const el = document.createElement('a')
+    el.download = filename
+    el.href = window.URL.createObjectURL(blob)
+    el.style.display = 'none'
+    document.body.appendChild(el)
+    el.click()
+    document.body.removeChild(el)
+  },
+})
+
+L.U.IframeExporter = L.Evented.extend({
+  options: {
+    includeFullScreenLink: true,
+    currentView: false,
+    keepCurrentDatalayers: false,
+    viewCurrentFeature: false,
+  },
+
+  queryString: {
+    scaleControl: false,
+    miniMap: false,
+    scrollWheelZoom: false,
+    zoomControl: true,
+    editMode: 'disabled',
+    moreControl: true,
+    searchControl: null,
+    tilelayersControl: null,
+    embedControl: null,
+    datalayersControl: true,
+    onLoadPanel: 'none',
+    captionBar: false,
+    captionMenus: true,
+  },
+
+  dimensions: {
+    width: '100%',
+    height: '300px',
+  },
+
+  initialize: function (map) {
+    this.map = map
+    this.baseUrl = L.Util.getBaseUrl()
+    // Use map default, not generic default
+    this.queryString.onLoadPanel = this.map.options.onLoadPanel
+  },
+
+  getMap: function () {
+    return this.map
+  },
+
+  buildUrl: function (options) {
+    const datalayers = []
+    if (this.options.viewCurrentFeature && this.map.currentFeature) {
+      this.queryString.feature = this.map.currentFeature.getSlug()
+    }
+    if (this.options.keepCurrentDatalayers) {
+      this.map.eachDataLayer((datalayer) => {
+        if (datalayer.isVisible() && datalayer.umap_id) {
+          datalayers.push(datalayer.umap_id)
+        }
+      })
+      this.queryString.datalayers = datalayers.join(',')
+    } else {
+      delete this.queryString.datalayers
+    }
+    const currentView = this.options.currentView ? window.location.hash : ''
+    const queryString = L.extend({}, this.queryString, options)
+    return `${this.baseUrl}?${L.Util.buildQueryString(queryString)}${currentView}`
+  },
+
+  build: function () {
+    const iframeUrl = this.buildUrl()
+    let code = `<iframe width="${this.dimensions.width}" height="${this.dimensions.height}" frameborder="0" allowfullscreen allow="geolocation" src="${iframeUrl}"></iframe>`
+    if (this.options.includeFullScreenLink) {
+      const fullUrl = this.buildUrl({ scrollWheelZoom: true })
+      code += `<p><a href="${fullUrl}">${L._('See full screen')}</a></p>`
+    }
+    return code
+  },
+})

umap/static/umap/js/umap.slideshow.js

@@ -0,0 +1,165 @@
+L.U.Slideshow = L.Class.extend({
+  statics: {
+    CLASSNAME: 'umap-slideshow-active',
+  },
+
+  options: {
+    delay: 5000,
+    autoplay: false,
+  },
+
+  initialize: function (map, options) {
+    this.setOptions(options)
+    this.map = map
+    this._id = null
+
+    // current feature
+    let current = null
+
+    const self = this
+    try {
+      Object.defineProperty(this, 'current', {
+        get: function () {
+          if (!current) {
+            const datalayer = this.defaultDatalayer()
+            if (datalayer) current = datalayer.getFeatureByIndex(0)
+          }
+          return current
+        },
+        set: function (feature) {
+          current = feature
+        },
+      })
+    } catch (e) {
+      // Certainly IE8, which has a limited version of defineProperty
+    }
+    try {
+      Object.defineProperty(this, 'next', {
+        get: function () {
+          if (!current) {
+            return self.current
+          }
+          return current.getNext()
+        },
+      })
+    } catch (e) {
+      // Certainly IE8, which has a limited version of defineProperty
+    }
+    if (this.options.autoplay) {
+      this.map.onceDataLoaded(function () {
+        this.play()
+      }, this)
+    }
+    this.map.on(
+      'edit:enabled',
+      function () {
+        this.stop()
+      },
+      this
+    )
+  },
+
+  setOptions: function (options) {
+    L.setOptions(this, options)
+    this.timeSpinner()
+  },
+
+  defaultDatalayer: function () {
+    return this.map.findDataLayer((d) => d.allowBrowse() && d.hasData())
+  },
+
+  timeSpinner: function () {
+    const time = parseInt(this.options.delay, 10)
+    if (!time) return
+    const css = `rotation ${time / 1000}s infinite linear`,
+      spinners = document.querySelectorAll('.umap-slideshow-toolbox .play .spinner')
+    for (let i = 0; i < spinners.length; i++) {
+      spinners[i].style.animation = css
+      spinners[i].style['-webkit-animation'] = css
+      spinners[i].style['-moz-animation'] = css
+      spinners[i].style['-o-animation'] = css
+    }
+  },
+
+  resetSpinners: function () {
+    // Make that animnation is coordinated with user actions
+    const spinners = document.querySelectorAll('.umap-slideshow-toolbox .play .spinner')
+
+    let el
+    let newOne
+    for (let i = 0; i < spinners.length; i++) {
+      el = spinners[i]
+      newOne = el.cloneNode(true)
+      el.parentNode.replaceChild(newOne, el)
+    }
+  },
+
+  play: function () {
+    if (this._id) return
+    if (this.map.editEnabled || !this.map.options.slideshow.active) return
+    L.DomUtil.addClass(document.body, L.U.Slideshow.CLASSNAME)
+    this._id = window.setInterval(L.bind(this.loop, this), this.options.delay)
+    this.resetSpinners()
+    this.loop()
+  },
+
+  loop: function () {
+    this.current = this.next
+    this.step()
+  },
+
+  pause: function () {
+    if (this._id) {
+      L.DomUtil.removeClass(document.body, L.U.Slideshow.CLASSNAME)
+      window.clearInterval(this._id)
+      this._id = null
+    }
+  },
+
+  stop: function () {
+    this.pause()
+    this.current = null
+  },
+
+  forward: function () {
+    this.pause()
+    this.current = this.next
+    this.step()
+  },
+
+  backward: function () {
+    this.pause()
+    if (this.current) this.current = this.current.getPrevious()
+    this.step()
+  },
+
+  step: function () {
+    if (!this.current) return this.stop()
+    this.current.zoomTo({ easing: this.options.easing })
+    this.current.view()
+  },
+
+  renderToolbox: function (container) {
+    const box = L.DomUtil.create('ul', 'umap-slideshow-toolbox'),
+      play = L.DomUtil.create('li', 'play', box),
+      stop = L.DomUtil.create('li', 'stop', box),
+      prev = L.DomUtil.create('li', 'prev', box),
+      next = L.DomUtil.create('li', 'next', box)
+    L.DomUtil.create('div', 'spinner', play)
+    play.title = L._('Start slideshow')
+    stop.title = L._('Stop slideshow')
+    next.title = L._('Zoom to the next')
+    prev.title = L._('Zoom to the previous')
+    const toggle = function () {
+      if (this._id) this.pause()
+      else this.play()
+    }
+    L.DomEvent.on(play, 'click', L.DomEvent.stop).on(play, 'click', toggle, this)
+    L.DomEvent.on(stop, 'click', L.DomEvent.stop).on(stop, 'click', this.stop, this)
+    L.DomEvent.on(prev, 'click', L.DomEvent.stop).on(prev, 'click', this.backward, this)
+    L.DomEvent.on(next, 'click', L.DomEvent.stop).on(next, 'click', this.forward, this)
+    container.appendChild(box)
+    this.timeSpinner()
+    return box
+  },
+})

umap/static/umap/js/umap.tableeditor.js

@@ -0,0 +1,120 @@
+L.U.TableEditor = L.Class.extend({
+  initialize: function (datalayer) {
+    this.datalayer = datalayer
+    this.table = L.DomUtil.create('div', 'table')
+    this.header = L.DomUtil.create('div', 'thead', this.table)
+    this.body = L.DomUtil.create('div', 'tbody', this.table)
+    this.resetProperties()
+  },
+
+  renderHeaders: function () {
+    this.header.innerHTML = ''
+    for (let i = 0; i < this.properties.length; i++) {
+      this.renderHeader(this.properties[i])
+    }
+  },
+
+  renderHeader: function (property) {
+    const container = L.DomUtil.create('div', 'tcell', this.header),
+      title = L.DomUtil.add('span', '', container, property),
+      del = L.DomUtil.create('i', 'umap-delete', container),
+      rename = L.DomUtil.create('i', 'umap-edit', container)
+    del.title = L._('Delete this property on all the features')
+    rename.title = L._('Rename this property on all the features')
+    const doDelete = function () {
+      if (
+        confirm(
+          L._('Are you sure you want to delete this property on all the features?')
+        )
+      ) {
+        this.datalayer.eachLayer((feature) => {
+          feature.deleteProperty(property)
+        })
+        this.datalayer.deindexProperty(property)
+        this.resetProperties()
+        this.edit()
+      }
+    }
+    const doRename = function () {
+      const newName = prompt(
+        L._('Please enter the new name of this property'),
+        property
+      )
+      if (!newName || !this.validateName(newName)) return
+      this.datalayer.eachLayer((feature) => {
+        feature.renameProperty(property, newName)
+      })
+      this.datalayer.deindexProperty(property)
+      this.datalayer.indexProperty(newName)
+      this.resetProperties()
+      this.edit()
+    }
+    L.DomEvent.on(del, 'click', doDelete, this)
+    L.DomEvent.on(rename, 'click', doRename, this)
+  },
+
+  renderRow: function (feature) {
+    const builder = new L.U.FormBuilder(feature, this.field_properties, {
+      id: `umap-feature-properties_${L.stamp(feature)}`,
+      className: 'trow',
+      callback: feature.resetTooltip,
+    })
+    this.body.appendChild(builder.build())
+  },
+
+  compileProperties: function () {
+    if (this.properties.length === 0) this.properties = ['name']
+    // description is a forced textarea, don't edit it in a text input, or you lose cariage returns
+    if (this.properties.indexOf('description') !== -1)
+      this.properties.splice(this.properties.indexOf('description'), 1)
+    this.properties.sort()
+    this.field_properties = []
+    for (let i = 0; i < this.properties.length; i++) {
+      this.field_properties.push([
+        `properties.${this.properties[i]}`,
+        { wrapper: 'div', wrapperClass: 'tcell' },
+      ])
+    }
+  },
+
+  resetProperties: function () {
+    this.properties = this.datalayer._propertiesIndex
+  },
+
+  validateName: function (name) {
+    if (name.indexOf('.') !== -1) {
+      this.datalayer.map.ui.alert({
+        content: L._('Invalide property name: {name}', { name: name }),
+        level: 'error',
+      })
+      return false
+    }
+    return true
+  },
+
+  edit: function () {
+    const id = 'tableeditor:edit'
+    this.datalayer.map.fire('dataloading', { id: id })
+    this.compileProperties()
+    this.renderHeaders()
+    this.body.innerHTML = ''
+    this.datalayer.eachLayer(this.renderRow, this)
+    const addButton = L.DomUtil.create('li', 'add-property')
+    L.DomUtil.create('i', 'umap-icon-16 umap-add', addButton)
+    const label = L.DomUtil.create('span', '', addButton)
+    label.textContent = label.title = L._('Add a new property')
+    const addProperty = function () {
+      const newName = prompt(L._('Please enter the name of the property'))
+      if (!newName || !this.validateName(newName)) return
+      this.datalayer.indexProperty(newName)
+      this.edit()
+    }
+    L.DomEvent.on(addButton, 'click', addProperty, this)
+    this.datalayer.map.ui.openPanel({
+      data: { html: this.table },
+      className: 'umap-table-editor fullwidth dark',
+      actions: [addButton],
+    })
+    this.datalayer.map.fire('dataload', { id: id })
+  },
+})