umap-project 2.3.1__py3-none-any.whl → 2.4.0b0__py3-none-any.whl

umap/static/umap/js/umap.autocomplete.js

@@ -1,341 +0,0 @@
-U.AutoComplete = L.Class.extend({
-  options: {
-    placeholder: 'Start typing...',
-    emptyMessage: 'No result',
-    allowFree: true,
-    minChar: 2,
-    maxResults: 5,
-  },
-
-  CACHE: '',
-  RESULTS: [],
-
-  initialize: function (el, options) {
-    this.el = el
-    const ui = new U.UI(document.querySelector('header'))
-    this.server = new U.ServerRequest(ui)
-    L.setOptions(this, options)
-    let CURRENT = null
-    try {
-      Object.defineProperty(this, 'CURRENT', {
-        get: function () {
-          return CURRENT
-        },
-        set: function (index) {
-          if (typeof index === 'object') {
-            index = this.resultToIndex(index)
-          }
-          CURRENT = index
-        },
-      })
-    } catch (e) {
-      // Hello IE8
-    }
-    return this
-  },
-
-  createInput: function () {
-    this.input = L.DomUtil.element({
-      tagName: 'input',
-      type: 'text',
-      parent: this.el,
-      placeholder: this.options.placeholder,
-      autocomplete: 'off',
-      className: this.options.className,
-    })
-    L.DomEvent.on(this.input, 'keydown', this.onKeyDown, this)
-    L.DomEvent.on(this.input, 'keyup', this.onKeyUp, this)
-    L.DomEvent.on(this.input, 'blur', this.onBlur, this)
-  },
-
-  createContainer: function () {
-    this.container = L.DomUtil.element({
-      tagName: 'ul',
-      parent: document.body,
-      className: 'umap-autocomplete',
-    })
-  },
-
-  resizeContainer: function () {
-    const l = this.getLeft(this.input)
-    const t = this.getTop(this.input) + this.input.offsetHeight
-    this.container.style.left = `${l}px`
-    this.container.style.top = `${t}px`
-    const width = this.options.width ? this.options.width : this.input.offsetWidth - 2
-    this.container.style.width = `${width}px`
-  },
-
-  onKeyDown: function (e) {
-    switch (e.keyCode) {
-      case U.Keys.TAB:
-        if (this.CURRENT !== null) this.setChoice()
-        L.DomEvent.stop(e)
-        break
-      case U.Keys.ENTER:
-        L.DomEvent.stop(e)
-        this.setChoice()
-        break
-      case U.Keys.ESC:
-        L.DomEvent.stop(e)
-        this.hide()
-        break
-      case U.Keys.DOWN:
-        if (this.RESULTS.length > 0) {
-          if (this.CURRENT !== null && this.CURRENT < this.RESULTS.length - 1) {
-            // what if one result?
-            this.CURRENT++
-            this.highlight()
-          } else if (this.CURRENT === null) {
-            this.CURRENT = 0
-            this.highlight()
-          }
-        }
-        break
-      case U.Keys.UP:
-        if (this.CURRENT !== null) {
-          L.DomEvent.stop(e)
-        }
-        if (this.RESULTS.length > 0) {
-          if (this.CURRENT > 0) {
-            this.CURRENT--
-            this.highlight()
-          } else if (this.CURRENT === 0) {
-            this.CURRENT = null
-            this.highlight()
-          }
-        }
-        break
-    }
-  },
-
-  onKeyUp: function (e) {
-    const special = [
-      U.Keys.TAB,
-      U.Keys.ENTER,
-      U.Keys.LEFT,
-      U.Keys.RIGHT,
-      U.Keys.DOWN,
-      U.Keys.UP,
-      U.Keys.APPLE,
-      U.Keys.SHIFT,
-      U.Keys.ALT,
-      U.Keys.CTRL,
-    ]
-    if (special.indexOf(e.keyCode) === -1) {
-      this.search()
-    }
-  },
-
-  onBlur: function () {
-    setTimeout(() => this.hide(), 100)
-  },
-
-  clear: function () {
-    this.RESULTS = []
-    this.CURRENT = null
-    this.CACHE = ''
-    this.container.innerHTML = ''
-  },
-
-  hide: function () {
-    this.clear()
-    this.container.style.display = 'none'
-    this.input.value = ''
-  },
-
-  setChoice: function (choice) {
-    choice = choice || this.RESULTS[this.CURRENT]
-    if (choice) {
-      this.input.value = choice.item.label
-      this.options.on_select(choice)
-      this.displaySelected(choice)
-      this.hide()
-      if (this.options.callback) {
-        L.Util.bind(this.options.callback, this)(choice)
-      }
-    }
-  },
-
-  search: async function () {
-    let val = this.input.value
-    if (val.length < this.options.minChar) {
-      this.clear()
-      return
-    }
-    if (`${val}` === `${this.CACHE}`) return
-    else this.CACHE = val
-    val = val.toLowerCase()
-    const [{ data }, response] = await this.server.get(
-      `/agnocomplete/AutocompleteUser/?q=${encodeURIComponent(val)}`
-    )
-    this.handleResults(data)
-  },
-
-  createResult: function (item) {
-    const el = L.DomUtil.element({
-      tagName: 'li',
-      parent: this.container,
-      textContent: item.label,
-    })
-    const result = {
-      item: item,
-      el: el,
-    }
-    L.DomEvent.on(
-      el,
-      'mouseover',
-      function () {
-        this.CURRENT = result
-        this.highlight()
-      },
-      this
-    )
-    L.DomEvent.on(
-      el,
-      'mousedown',
-      function () {
-        this.setChoice()
-      },
-      this
-    )
-    return result
-  },
-
-  resultToIndex: function (result) {
-    let out = null
-    this.forEach(this.RESULTS, (item, index) => {
-      if (item.item.value == result.item.value) {
-        out = index
-        return
-      }
-    })
-    return out
-  },
-
-  handleResults: function (data) {
-    this.clear()
-    this.container.style.display = 'block'
-    this.resizeContainer()
-    this.forEach(data, (item) => {
-      this.RESULTS.push(this.createResult(item))
-    })
-    this.CURRENT = 0
-    this.highlight()
-    //TODO manage no results
-  },
-
-  highlight: function () {
-    this.forEach(this.RESULTS, (result, index) => {
-      if (index === this.CURRENT) L.DomUtil.addClass(result.el, 'on')
-      else L.DomUtil.removeClass(result.el, 'on')
-    })
-  },
-
-  getLeft: function (el) {
-    let tmp = el.offsetLeft
-    el = el.offsetParent
-    while (el) {
-      tmp += el.offsetLeft
-      el = el.offsetParent
-    }
-    return tmp
-  },
-
-  getTop: function (el) {
-    let tmp = el.offsetTop
-    el = el.offsetParent
-    while (el) {
-      tmp += el.offsetTop
-      el = el.offsetParent
-    }
-    return tmp
-  },
-
-  forEach: function (els, callback) {
-    Array.prototype.forEach.call(els, callback)
-  },
-})
-
-U.AutoComplete.Ajax = U.AutoComplete.extend({
-  initialize: function (el, options) {
-    U.AutoComplete.prototype.initialize.call(this, el, options)
-    if (!this.el) return this
-    this.createInput()
-    this.createContainer()
-    this.selected_container = this.initSelectedContainer()
-  },
-
-  optionToResult: function (option) {
-    return {
-      value: option.value,
-      label: option.innerHTML,
-    }
-  },
-})
-
-U.AutoComplete.Ajax.SelectMultiple = U.AutoComplete.Ajax.extend({
-  initSelectedContainer: function () {
-    return L.DomUtil.after(
-      this.input,
-      L.DomUtil.element({ tagName: 'ul', className: 'umap-multiresult' })
-    )
-  },
-
-  displaySelected: function (result) {
-    const result_el = L.DomUtil.element({
-      tagName: 'li',
-      parent: this.selected_container,
-    })
-    result_el.textContent = result.item.label
-    const close = L.DomUtil.element({
-      tagName: 'span',
-      parent: result_el,
-      className: 'close',
-      textContent: '×',
-    })
-    L.DomEvent.on(
-      close,
-      'click',
-      function () {
-        this.selected_container.removeChild(result_el)
-        this.options.on_unselect(result)
-      },
-      this
-    )
-    this.hide()
-  },
-})
-
-U.AutoComplete.Ajax.Select = U.AutoComplete.Ajax.extend({
-  initSelectedContainer: function () {
-    return L.DomUtil.after(
-      this.input,
-      L.DomUtil.element({ tagName: 'div', className: 'umap-singleresult' })
-    )
-  },
-
-  displaySelected: function (result) {
-    const result_el = L.DomUtil.element({
-      tagName: 'div',
-      parent: this.selected_container,
-    })
-    result_el.textContent = result.item.label
-    const close = L.DomUtil.element({
-      tagName: 'span',
-      parent: result_el,
-      className: 'close',
-      textContent: '×',
-    })
-    this.input.style.display = 'none'
-    L.DomEvent.on(
-      close,
-      'click',
-      function () {
-        this.selected_container.innerHTML = ''
-        this.input.style.display = 'block'
-      },
-      this
-    )
-    this.hide()
-  },
-})

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

@@ -1,187 +0,0 @@
-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.createTitle(
-      this.container,
-      L._('Import data'),
-      'icon-upload'
-    )
-    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({
-      tagName: 'input',
-      type: 'file',
-      parent: this.fileBox,
-      multiple: 'multiple',
-      autofocus: true,
-    })
-    this.urlInput = L.DomUtil.element({
-      tagName: 'input',
-      type: 'text',
-      parent: this.container,
-      placeholder: L._('Provide an URL here'),
-    })
-    this.rawInput = L.DomUtil.element({
-      tagName: 'textarea',
-      parent: this.container,
-      placeholder: L._('Paste your data here'),
-    })
-    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.element({
-      tagName: 'label',
-      parent: this.container,
-      textContent: L._('Replace layer content'),
-      for: 'datalayer-clear-check',
-    })
-    this.submitInput = L.DomUtil.element({
-      tagName: 'input',
-      type: 'button',
-      parent: this.container,
-      value: L._('Import'),
-      className: 'button',
-    })
-    this.map.help.button(this.typeLabel, 'importFormats')
-    this.typeInput = L.DomUtil.element({
-      tagName: 'select',
-      name: 'format',
-      parent: this.typeLabel,
-    })
-    this.layerInput = L.DomUtil.element({
-      tagName: 'select',
-      name: 'datalayer',
-      parent: this.layerLabel,
-    })
-    this.clearFlag = L.DomUtil.element({
-      tagName: 'input',
-      type: 'checkbox',
-      name: 'clear',
-      id: 'datalayer-clear-check',
-      parent: this.clearLabel,
-    })
-    L.DomUtil.element({
-      tagName: 'option',
-      value: '',
-      textContent: L._('Choose the data format'),
-      parent: 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 = U.Utils.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()
-    const onLoad = this.map.editPanel.open({ content: this.container })
-    onLoad.then(() => {
-      this.fileInput.value = null
-      this.layerInput.innerHTML = ''
-      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({
-        tagName: 'option',
-        value: '',
-        textContent: L._('Import in a new layer'),
-        parent: this.layerInput,
-      })
-    })
-  },
-
-  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
-          )
-      }
-    }
-  },
-})

umap/static/umap/js/umap.ui.js

@@ -1,190 +0,0 @@
-/*
- * Modals
- */
-U.UI = L.Evented.extend({
-  ALERTS: Array(),
-  ALERT_ID: null,
-  TOOLTIP_ID: null,
-
-  initialize: function (parent) {
-    this.parent = parent
-    this.container = L.DomUtil.create('div', 'leaflet-ui-container', this.parent)
-    L.DomEvent.disableClickPropagation(this.container)
-    L.DomEvent.on(this.container, 'contextmenu', L.DomEvent.stopPropagation) // Do not activate our custom context menu.
-    L.DomEvent.on(this.container, 'wheel', L.DomEvent.stopPropagation)
-    L.DomEvent.on(this.container, 'MozMousePixelScroll', L.DomEvent.stopPropagation)
-    this._alert = L.DomUtil.create('div', 'with-transition', this.container)
-    this._alert.id = 'umap-alert-container'
-    this._tooltip = L.DomUtil.create('div', '', this.container)
-    this._tooltip.id = 'umap-tooltip-container'
-  },
-
-  alert: function (e) {
-    if (L.DomUtil.hasClass(this.parent, 'umap-alert')) this.ALERTS.push(e)
-    else this.popAlert(e)
-  },
-
-  popAlert: function (e) {
-    if (!e) {
-      if (this.ALERTS.length) e = this.ALERTS.pop()
-      else return
-    }
-    let timeoutID
-    const level_class = e.level && e.level == 'info' ? 'info' : 'error'
-    this._alert.innerHTML = ''
-    L.DomUtil.addClass(this.parent, 'umap-alert')
-    L.DomUtil.addClass(this._alert, level_class)
-    const close = () => {
-      if (timeoutID && timeoutID !== this.ALERT_ID) {
-        return
-      } // Another alert has been forced
-      this._alert.innerHTML = ''
-      L.DomUtil.removeClass(this.parent, 'umap-alert')
-      L.DomUtil.removeClass(this._alert, level_class)
-      if (timeoutID) window.clearTimeout(timeoutID)
-      this.popAlert()
-    }
-    const closeButton = L.DomUtil.createButton(
-      'umap-close-link',
-      this._alert,
-      '',
-      close,
-      this
-    )
-    L.DomUtil.create('i', 'umap-close-icon', closeButton)
-    const label = L.DomUtil.create('span', '', closeButton)
-    label.title = label.textContent = L._('Close')
-    L.DomUtil.element({ tagName: 'div', innerHTML: e.content, parent: this._alert })
-    if (e.actions) {
-      let action, el, input
-      const form = L.DomUtil.create('div', 'umap-alert-actions', this._alert)
-      for (let i = 0; i < e.actions.length; i++) {
-        action = e.actions[i]
-        if (action.input) {
-          input = L.DomUtil.element({
-            tagName: 'input',
-            parent: form,
-            className: 'umap-alert-input',
-            placeholder: action.input,
-          })
-        }
-        el = L.DomUtil.createButton(
-          'umap-action',
-          form,
-          action.label,
-          action.callback,
-          action.callbackContext || this.map
-        )
-        L.DomEvent.on(el, 'click', close, this)
-      }
-    }
-    if (e.duration !== Infinity) {
-      this.ALERT_ID = timeoutID = window.setTimeout(
-        L.bind(close, this),
-        e.duration || 3000
-      )
-    }
-  },
-
-  tooltip: function (opts) {
-    function showIt() {
-      if (opts.anchor && opts.position === 'top') {
-        this.anchorTooltipTop(opts.anchor)
-      } else if (opts.anchor && opts.position === 'left') {
-        this.anchorTooltipLeft(opts.anchor)
-      } else if (opts.anchor && opts.position === 'bottom') {
-        this.anchorTooltipBottom(opts.anchor)
-      } else {
-        this.anchorTooltipAbsolute()
-      }
-      L.DomUtil.addClass(this.parent, 'umap-tooltip')
-      this._tooltip.innerHTML = U.Utils.escapeHTML(opts.content)
-    }
-    this.TOOLTIP_ID = window.setTimeout(L.bind(showIt, this), opts.delay || 0)
-    const id = this.TOOLTIP_ID
-    function closeIt() {
-      this.closeTooltip(id)
-    }
-    if (opts.anchor) {
-      L.DomEvent.once(opts.anchor, 'mouseout', closeIt, this)
-    }
-    if (opts.duration !== Infinity) {
-      window.setTimeout(L.bind(closeIt, this), opts.duration || 3000)
-    }
-  },
-
-  anchorTooltipAbsolute: function () {
-    this._tooltip.className = ''
-    const left =
-        this.parent.offsetLeft +
-        this.parent.clientWidth / 2 -
-        this._tooltip.clientWidth / 2,
-      top = this.parent.offsetTop + 75
-    this.setTooltipPosition({ top: top, left: left })
-  },
-
-  anchorTooltipTop: function (el) {
-    this._tooltip.className = 'tooltip-top'
-    const coords = this.getPosition(el)
-    this.setTooltipPosition({
-      left: coords.left - 10,
-      bottom: this.getDocHeight() - coords.top + 11,
-    })
-  },
-
-  anchorTooltipBottom: function (el) {
-    this._tooltip.className = 'tooltip-bottom'
-    const coords = this.getPosition(el)
-    this.setTooltipPosition({
-      left: coords.left,
-      top: coords.bottom + 11,
-    })
-  },
-
-  anchorTooltipLeft: function (el) {
-    this._tooltip.className = 'tooltip-left'
-    const coords = this.getPosition(el)
-    this.setTooltipPosition({
-      top: coords.top,
-      right: document.documentElement.offsetWidth - coords.left + 11,
-    })
-  },
-
-  closeTooltip: function (id) {
-    // Clear timetout even if a new tooltip has been added
-    // in the meantime. Eg. after a mouseout from the anchor.
-    window.clearTimeout(id)
-    if (id && id !== this.TOOLTIP_ID) return
-    this._tooltip.className = ''
-    this._tooltip.innerHTML = ''
-    this.setTooltipPosition({})
-    L.DomUtil.removeClass(this.parent, 'umap-tooltip')
-  },
-
-  getPosition: function (el) {
-    return el.getBoundingClientRect()
-  },
-
-  setTooltipPosition: function (coords) {
-    if (coords.left) this._tooltip.style.left = `${coords.left}px`
-    else this._tooltip.style.left = 'initial'
-    if (coords.right) this._tooltip.style.right = `${coords.right}px`
-    else this._tooltip.style.right = 'initial'
-    if (coords.top) this._tooltip.style.top = `${coords.top}px`
-    else this._tooltip.style.top = 'initial'
-    if (coords.bottom) this._tooltip.style.bottom = `${coords.bottom}px`
-    else this._tooltip.style.bottom = 'initial'
-  },
-
-  getDocHeight: function () {
-    const D = document
-    return Math.max(
-      D.body.scrollHeight,
-      D.documentElement.scrollHeight,
-      D.body.offsetHeight,
-      D.documentElement.offsetHeight,
-      D.body.clientHeight,
-      D.documentElement.clientHeight
-    )
-  },
-})