umap-project 1.14.0a4__py3-none-any.whl → 2.0.0a0__py3-none-any.whl

umap/static/umap/js/umap.browser.js

@@ -1,148 +0,0 @@
-L.U.Browser = L.Class.extend({
-  options: {
-    filter: '',
-    inBbox: false,
-  },
-
-  initialize: function (map) {
-    this.map = map
-  },
-
-  addFeature: function (feature) {
-    const feature_li = L.DomUtil.create('li', `${feature.getClassName()} feature`),
-      zoom_to = L.DomUtil.create('i', 'feature-zoom_to', feature_li),
-      edit = L.DomUtil.create('i', 'show-on-edit feature-edit', feature_li),
-      del = L.DomUtil.create('i', 'show-on-edit feature-delete', feature_li),
-      colorBox = L.DomUtil.create('i', 'feature-color', feature_li),
-      title = L.DomUtil.create('span', 'feature-title', feature_li),
-      symbol = feature._getIconUrl
-        ? L.U.Icon.prototype.formatUrl(feature._getIconUrl(), feature)
-        : null
-    zoom_to.title = L._('Bring feature to center')
-    edit.title = L._('Edit this feature')
-    del.title = L._('Delete this feature')
-    title.textContent = feature.getDisplayName() || '—'
-    const bgcolor = feature.getOption('color')
-    colorBox.style.backgroundColor = bgcolor
-    if (symbol && symbol !== this.map.options.default_iconUrl) {
-      const icon = L.U.Icon.makeIconElement(symbol, colorBox)
-      L.U.Icon.setIconContrast(icon, colorBox, symbol, bgcolor)
-    }
-    L.DomEvent.on(
-      zoom_to,
-      'click',
-      function (e) {
-        e.callback = L.bind(this.view, this)
-        this.zoomTo(e)
-      },
-      feature
-    )
-    L.DomEvent.on(
-      title,
-      'click',
-      function (e) {
-        e.callback = L.bind(this.view, this)
-        this.zoomTo(e)
-      },
-      feature
-    )
-    L.DomEvent.on(edit, 'click', feature.edit, feature)
-    L.DomEvent.on(del, 'click', feature.confirmDelete, feature)
-    return feature_li
-  },
-
-  addDatalayer: function (datalayer, dataContainer) {
-    const filterKeys = this.map.getFilterKeys()
-    const container = L.DomUtil.create(
-        'div',
-        datalayer.getHidableClass(),
-        dataContainer
-      ),
-      headline = L.DomUtil.create('h5', '', container)
-    container.id = `browse_data_datalayer_${datalayer.umap_id}`
-    datalayer.renderToolbox(headline)
-    L.DomUtil.add('span', '', headline, datalayer.options.name)
-    const counter = L.DomUtil.add('span', 'datalayer-counter', headline, datalayer.count())
-    counter.title = L._('{count} features in this layer', {count: datalayer.count()})
-    const ul = L.DomUtil.create('ul', '', container)
-    L.DomUtil.classIf(container, 'off', !datalayer.isVisible())
-
-    const build = () => {
-      ul.innerHTML = ''
-      const bounds = this.map.getBounds()
-      datalayer.eachFeature((feature) => {
-        if (
-          this.options.filter &&
-          !feature.matchFilter(this.options.filter, filterKeys)
-        )
-          return
-        if (this.options.inBbox && !feature.isOnScreen(bounds)) return
-        ul.appendChild(this.addFeature(feature))
-      })
-    }
-
-    build()
-    datalayer.on('datachanged', build)
-    datalayer.map.ui.once('panel:closed', () => {
-      datalayer.off('datachanged', build)
-      this.map.off('moveend', build)
-    })
-    datalayer.map.ui.once('panel:ready', () => {
-      datalayer.map.ui.once('panel:ready', () => {
-        datalayer.off('datachanged', build)
-      })
-    })
-  },
-
-  open: function () {
-    const container = L.DomUtil.create('div', 'umap-browse-data')
-    // HOTFIX. Remove when this is merged and released:
-    // https://github.com/Leaflet/Leaflet/pull/9052
-    L.DomEvent.disableClickPropagation(container)
-
-    const title = L.DomUtil.add(
-      'h3',
-      'umap-browse-title',
-      container,
-      this.map.options.name
-    )
-
-    const formContainer = L.DomUtil.create('div', '', container)
-    const dataContainer = L.DomUtil.create('div', 'umap-browse-features', container)
-
-    const appendAll = () => {
-      dataContainer.innerHTML = ''
-      this.map.eachBrowsableDataLayer((datalayer) => {
-        this.addDatalayer(datalayer, dataContainer)
-      })
-    }
-    const resetLayers = () => {
-      this.map.eachBrowsableDataLayer((datalayer) => {
-        datalayer.resetLayer(true)
-      })
-    }
-    const fields = [
-      ['options.filter', { handler: 'Input', placeholder: L._('Filter') }],
-      ['options.inBbox', { handler: 'Switch', label: L._('Current map view') }],
-    ]
-    const builder = new L.U.FormBuilder(this, fields, {
-      makeDirty: false,
-      callback: (e) => {
-        if (e.helper.field === 'options.inBbox') {
-          if (this.options.inBbox) this.map.on('moveend', appendAll)
-          else this.map.off('moveend', appendAll)
-        }
-        appendAll()
-        resetLayers()
-      },
-    })
-    formContainer.appendChild(builder.build())
-
-    appendAll()
-
-    this.map.ui.openPanel({
-      data: { html: container },
-      actions: [this.map._aboutLink()],
-    })
-  },
-})

umap/static/umap/js/umap.xhr.js

@@ -1,304 +0,0 @@
-L.U.Xhr = L.Evented.extend({
-  initialize: function (ui) {
-    this.ui = ui
-  },
-
-  _wrapper: function () {
-    let wrapper
-    if (window.XMLHttpRequest === undefined) {
-      wrapper = () => {
-        try {
-          return new window.ActiveXObject('Microsoft.XMLHTTP.6.0')
-        } catch (e1) {
-          try {
-            return new window.ActiveXObject('Microsoft.XMLHTTP.3.0')
-          } catch (e2) {
-            throw new Error('XMLHttpRequest is not supported')
-          }
-        }
-      }
-    } else {
-      wrapper = window.XMLHttpRequest
-    }
-    return new wrapper()
-  },
-
-  _ajax: function (settings) {
-    const xhr = this._wrapper(),
-      id = Math.random(),
-      self = this
-    this.fire('dataloading', { id: id })
-    const loaded = () => {
-      self.fire('dataload', { id: id })
-    }
-
-    try {
-      xhr.open(settings.verb, settings.uri, true)
-    } catch (err) {
-      // Unknown protocol?
-      this.ui.alert({
-        content: L._('Error while fetching {url}', { url: settings.uri }),
-        level: 'error',
-      })
-      loaded()
-      return
-    }
-
-    if (
-      settings.uri.indexOf('http') !== 0 ||
-      settings.uri.indexOf(window.location.origin) === 0
-    ) {
-      // "X-" mode headers cause the request to be in preflight mode,
-      // we don"t want that by default for CORS requests
-      xhr.setRequestHeader('X-Requested-With', 'XMLHttpRequest')
-    }
-    if (settings.headers) {
-      for (const name in settings.headers) {
-        xhr.setRequestHeader(name, settings.headers[name])
-      }
-    }
-
-    xhr.onreadystatechange = () => {
-      if (xhr.readyState === 4) {
-        if (xhr.status == 200) {
-          settings.callback.call(settings.context || xhr, xhr.responseText, xhr)
-        } else if (xhr.status === 403) {
-          self.ui.alert({
-            content: xhr.responseText || L._('Action not allowed :('),
-            level: 'error',
-          })
-        } else if (xhr.status === 412) {
-          const msg = L._(
-            'Woops! Someone else seems to have edited the data. You can save anyway, but this will erase the changes made by others.'
-          )
-          const actions = [
-            {
-              label: L._('Save anyway'),
-              callback: function () {
-                delete settings.headers['If-Match']
-                self._ajax(settings)
-              },
-              callbackContext: self,
-            },
-            {
-              label: L._('Cancel'),
-            },
-          ]
-          self.ui.alert({
-            content: msg,
-            level: 'error',
-            duration: 100000,
-            actions: actions,
-          })
-        } else {
-          if (xhr.status === 0) {
-            // 0 === request cut by user or CORS
-            self.ui.alert({
-              content: L._(
-                'Issue reaching that URL (network problem or CORS protection): {url}',
-                { url: settings.uri }
-              ),
-              level: 'error',
-            })
-          } else {
-            self.ui.alert({ content: L._('Problem in the response'), level: 'error' })
-          }
-        }
-        loaded()
-      }
-    }
-
-    try {
-      xhr.send(settings.data)
-    } catch (e) {
-      // Pass
-      loaded()
-      console.error('Bad Request', e)
-    }
-  },
-
-  // supports only JSON as response data type
-  _json: function (verb, uri, options) {
-    const args = arguments,
-      self = this
-    const default_options = {
-      async: true,
-      callback: null,
-      responseType: 'text',
-      data: null,
-      listen_form: null, // optional form to listen in default callback
-    }
-    const settings = L.Util.extend({}, default_options, options)
-
-    if (verb === 'POST') {
-      // find a way not to make this django specific
-      const token = document.cookie.replace(
-        /(?:(?:^|.*;\s*)csrftoken\s*\=\s*([^;]*).*$)|^.*$/,
-        '$1'
-      )
-      if (token) {
-        settings.headers = settings.headers || {}
-        settings.headers['X-CSRFToken'] = token
-      }
-    }
-
-    const callback = function (responseText, response) {
-      let data
-      try {
-        data = JSON.parse(responseText)
-      } catch (err) {
-        console.log(err)
-        self.ui.alert({
-          content: L._('Problem in the response format'),
-          level: 'error',
-        })
-        return
-      }
-      if (data.errors) {
-        console.log(data.errors)
-        self.ui.alert({ content: L._('An error occured'), level: 'error' })
-      } else if (data.login_required) {
-        // login_required should be an URL for the login form
-        if (settings.login_callback) settings.login_callback(data)
-        else self.login(data, args)
-      } else {
-        if (settings.callback)
-          L.bind(settings.callback, settings.context || this)(data, response)
-        else self.default_callback(data, settings, response)
-      }
-    }
-
-    this._ajax({
-      verb: verb,
-      uri: uri,
-      data: settings.data,
-      callback: callback,
-      headers: settings.headers,
-      listener: settings.listener,
-    })
-  },
-
-  get: function (uri, options) {
-    this._json('GET', uri, options)
-  },
-
-  post: function (uri, options) {
-    this._json('POST', uri, options)
-  },
-
-  submit_form: function (form_id, options) {
-    if (typeof options === 'undefined') options = {}
-    const form = L.DomUtil.get(form_id)
-    const formData = new FormData(form)
-    if (options.extraFormData) formData.append(options.extraFormData)
-    options.data = formData
-    this.post(form.action, options)
-    return false
-  },
-
-  listen_form: function (form_id, options) {
-    const form = L.DomUtil.get(form_id),
-      self = this
-    if (!form) return
-    L.DomEvent.on(form, 'submit', L.DomEvent.stopPropagation)
-      .on(form, 'submit', L.DomEvent.preventDefault)
-      .on(form, 'submit', () => {
-        self.submit_form(form_id, options)
-      })
-  },
-
-  listen_link: function (link_id, options) {
-    const link = L.DomUtil.get(link_id),
-      self = this
-    if (link) {
-      L.DomEvent.on(link, 'click', L.DomEvent.stop).on(link, 'click', () => {
-        if (options.confirm && !confirm(options.confirm)) {
-          return
-        }
-        self.get(link.href, options)
-      })
-    }
-  },
-
-  default_callback: function (data, options) {
-    // default callback, to avoid boilerplate
-    if (data.redirect) {
-      const newPath = data.redirect
-      if (window.location.pathname == newPath)
-        window.location.reload() // Keep the hash, so the current view
-      else window.location = newPath
-    } else if (data.info) {
-      this.ui.alert({ content: data.info, level: 'info' })
-      this.ui.closePanel()
-    } else if (data.error) {
-      this.ui.alert({ content: data.error, level: 'error' })
-    } else if (data.html) {
-      const ui_options = { data: data }
-      let listen_options
-      if (options.className) ui_options.className = options.className
-      this.ui.openPanel(ui_options)
-      // To low boilerplate, if there is a form, listen it
-      if (options.listen_form) {
-        // Listen form again
-        listen_options = L.Util.extend({}, options, options.listen_form.options)
-        this.listen_form(options.listen_form.id, listen_options)
-      }
-      if (options.listen_link) {
-        for (let i = 0, l = options.listen_link.length; i < l; i++) {
-          // Listen link again
-          listen_options = L.Util.extend({}, options, options.listen_link[i].options)
-          this.listen_link(options.listen_link[i].id, listen_options)
-        }
-      }
-    } else if (options.success) {
-      // Success is called only if data contain no msg and no html
-      options.success(data)
-    }
-  },
-
-  login: function (data, args) {
-    // data.html: login form
-    // args: args of the first _json call, to call again at process end
-    const self = this
-    const proceed = () => {
-      self.ui.closePanel()
-      if (typeof args !== 'undefined') self._json.apply(self, args)
-      else self.default_callback(data, {})
-    }
-    const ask_for_login = (data) => {
-      self.ui.openPanel({ data: data, className: 'login-panel' })
-      self.listen_form('login_form', {
-        callback: function (data) {
-          if (data.html) ask_for_login(data) // Problem in the login - ask again
-          else proceed()
-        },
-      })
-      // Auth links
-      const links = document.getElementsByClassName('umap-login-popup')
-      Object.keys(links).forEach((el) => {
-        const link = links[el]
-        L.DomEvent.on(link, 'click', L.DomEvent.stop).on(link, 'click', () => {
-          self.ui.closePanel()
-          const win = window.open(link.href)
-          window.umap_proceed = () => {
-            proceed()
-            win.close()
-          }
-        })
-      })
-    }
-    if (data.login_required) {
-      this.get(data.login_required, {
-        callback: function (data) {
-          ask_for_login(data)
-        },
-      })
-    } else {
-      ask_for_login(data)
-    }
-  },
-
-  logout: function (url) {
-    this.get(url)
-  },
-})

umap/static/umap/test/Controls.js

@@ -1,100 +0,0 @@
-describe('L.U.Controls', function () {
-  before(function () {
-    this.server = sinon.fakeServer.create()
-    this.server.respondWith(
-      /\/datalayer\/62\/\?.*/,
-      JSON.stringify(RESPONSES.datalayer62_GET)
-    )
-    this.map = initMap({ umap_id: 99 })
-    this.server.respond()
-    this.datalayer = this.map.getDataLayerByUmapId(62)
-  })
-  after(function () {
-    this.server.restore()
-    resetMap()
-  })
-
-  describe('#databrowser()', function () {
-    let poly, marker, line
-    before(function () {
-      this.datalayer.eachLayer(function (layer) {
-        if (!poly && layer instanceof L.Polygon) {
-          poly = layer
-        } else if (!line && layer instanceof L.Polyline) {
-          line = layer
-        } else if (!marker && layer instanceof L.Marker) {
-          marker = layer
-        }
-      })
-    })
-
-    it('should be opened at datalayer button click', function () {
-      var button = qs('.umap-browse-actions .umap-browse-link')
-      assert.ok(button)
-      happen.click(button)
-      assert.ok(qs('#umap-ui-container .umap-browse-data'))
-    })
-
-    it('should contain datalayer section', function () {
-      assert.ok(qs('#browse_data_datalayer_62'))
-    })
-
-    it("should contain datalayer's features list", function () {
-      assert.equal(qsa('#browse_data_datalayer_62 ul li').length, 3)
-    })
-
-    it('should sort feature in natural order', function () {
-      poly.properties.name = '9. a poly'
-      marker.properties.name = '1. a marker'
-      line.properties.name = '100. a line'
-      this.datalayer.reindex()
-      this.map.openBrowser()
-      const els = qsa('.umap-browse-features li')
-      assert.equal(els.length, 3)
-      assert.equal(els[0].textContent, '1. a marker')
-      assert.equal(els[1].textContent, '9. a poly')
-      assert.equal(els[2].textContent, '100. a line')
-    })
-
-    it("should redraw datalayer's features list at feature delete", function () {
-      var oldConfirm = window.confirm
-      window.confirm = function () {
-        return true
-      }
-      enableEdit()
-      happen.once(qs('path[fill="DarkBlue"]'), { type: 'contextmenu' })
-      happen.click(qs('.leaflet-contextmenu .umap-delete'))
-      assert.equal(qsa('#browse_data_datalayer_62 ul li').length, 2)
-      window.confirm = oldConfirm
-    })
-
-    it("should redraw datalayer's features list on edit cancel", function () {
-      clickCancel()
-      happen.click(qs('.umap-browse-actions .umap-browse-link'))
-      assert.equal(qsa('#browse_data_datalayer_62 ul li').length, 3)
-    })
-  })
-
-  describe('#exportPanel()', function () {
-    it('should be opened at datalayer button click', function () {
-      let button = qs('.leaflet-control-embed button')
-      assert.ok(button)
-      happen.click(button)
-      assert.ok(qs('#umap-ui-container .umap-share'))
-    })
-    it('should update iframe link', function () {
-      let textarea = qs('.umap-share-iframe')
-      assert.ok(textarea)
-      console.log(textarea.textContent)
-      assert.include(textarea.textContent, 'src="')
-      assert.include(textarea.textContent, 'href="')
-      // We should ave both, once for iframe link, once for full screen
-      assert.include(textarea.textContent, 'scrollWheelZoom=true')
-      assert.include(textarea.textContent, 'scrollWheelZoom=false')
-      assert.notInclude(textarea.textContent, 'datalayers=62')
-      let switcher = qs('label[title="Keep current visible layers"]')
-      happen.click(switcher)
-      assert.include(textarea.textContent, 'datalayers=62')
-    })
-  })
-})

umap/static/umap/test/Map.Init.js

@@ -1,46 +0,0 @@
-describe('L.U.Map.initialize', function () {
-  afterEach(function () {
-    resetMap()
-  })
-
-  describe('Controls', function () {
-    it('should not show a minimap by default', function () {
-      this.map = initMap()
-      assert.notOk(qs('.leaflet-control-minimap'))
-    })
-
-    it('should show a minimap', function () {
-      this.map = initMap({ miniMap: true })
-      assert.ok(qs('.leaflet-control-minimap'))
-    })
-  })
-
-  describe('DefaultView', function () {
-    it('should set default view in default mode without data', function (done) {
-      this.map = initMap({ datalayers: [] })
-      // Did not find a better way to wait for tiles to be actually loaded
-      window.setTimeout(() => {
-        assert.ok(qs('#map .leaflet-tile-pane img.leaflet-tile.leaflet-tile-loaded'))
-        done()
-      }, 1000)
-    })
-
-    it("should set default view in 'data' mode without data", function (done) {
-      this.map = initMap({ datalayers: [], defaultView: 'data' })
-      // Did not find a better way to wait for tiles to be actually loaded
-      window.setTimeout(() => {
-        assert.ok(qs('#map .leaflet-tile-pane img.leaflet-tile.leaflet-tile-loaded'))
-        done()
-      }, 1000)
-    })
-
-    it("should set default view in 'latest' mode without data", function (done) {
-      this.map = initMap({ datalayers: [], defaultView: 'latest' })
-      // Did not find a better way to wait for tiles to be actually loaded
-      window.setTimeout(() => {
-        assert.ok(qs('#map .leaflet-tile-pane img.leaflet-tile.leaflet-tile-loaded'))
-        done()
-      }, 1000)
-    })
-  })
-})