umap-project 2.1.2__py3-none-any.whl → 2.2.0__py3-none-any.whl

umap/static/umap/js/modules/urls.js

@@ -1,19 +1,4 @@
-// Vendorized from leaflet.utils
-// https://github.com/Leaflet/Leaflet/blob/108c6717b70f57c63645498f9bd66b6677758786/src/core/Util.js#L132-L151
-var templateRe = /\{ *([\w_ -]+) *\}/g
-
-function template(str, data) {
-  return str.replace(templateRe, function (str, key) {
-    var value = data[key]
-
-    if (value === undefined) {
-      throw new Error('No value provided for variable ' + str)
-    } else if (typeof value === 'function') {
-      value = value(data)
-    }
-    return value
-  })
-}
+import { template } from "./utils.js"
 
 export default class URLs {
   constructor(serverUrls) {

umap/static/umap/js/modules/utils.js

@@ -1,3 +1,5 @@
+import { default as DOMPurifyInitializer } from '../../vendors/dompurify/purify.es.mjs'
+
 /**
  * Generate a pseudo-unique identifier (5 chars long, mixed-case alphanumeric)
  *
@@ -22,3 +24,341 @@ export function checkId(string) {
   if (typeof string !== 'string') return false
   return /^[A-Za-z0-9]{5}$/.test(string)
 }
+
+/**
+ * Compute the impacts for a given list of fields.
+ *
+ * Return an array of unique impacts.
+ *
+ * @param {fields} list[fields]
+ * @returns Array[string]
+ */
+export function getImpactsFromSchema(fields, schema) {
+  schema = schema || U.SCHEMA
+  let impacted = fields
+    .map((field) => {
+      // remove the option prefix for fields
+      // And only keep the first part in case of a subfield
+      // (e.g "options.limitBounds.foobar" will just return "limitBounds")
+      return field.replace('options.', '').split('.')[0]
+    })
+    .reduce((acc, field) => {
+      // retrieve the "impacts" field from the schema
+      // and merge them together using sets
+      const impacts = schema[field]?.impacts || []
+      impacts.forEach((impact) => acc.add(impact))
+      return acc
+    }, new Set())
+
+  return Array.from(impacted)
+}
+
+/**
+ * Import DOM purify, and initialize it.
+ *
+ * If the context is a node server, uses jsdom to provide
+ * DOM APIs
+ */
+export default function getPurify() {
+  if (typeof window === 'undefined') {
+    return DOMPurifyInitializer(new global.JSDOM('').window)
+  } else {
+    return DOMPurifyInitializer(window)
+  }
+}
+
+export function escapeHTML(s) {
+  s = s ? s.toString() : ''
+  s = getPurify().sanitize(s, {
+    ADD_TAGS: ['iframe'],
+    ALLOWED_TAGS: [
+      'h3',
+      'h4',
+      'h5',
+      'hr',
+      'strong',
+      'em',
+      'ul',
+      'li',
+      'a',
+      'div',
+      'iframe',
+      'img',
+      'br',
+      'span',
+    ],
+    ADD_ATTR: ['target', 'allow', 'allowfullscreen', 'frameborder', 'scrolling'],
+    ALLOWED_ATTR: ['href', 'src', 'width', 'height', 'style'],
+    // Added: `geo:` URL scheme as defined in RFC5870:
+    // https://www.rfc-editor.org/rfc/rfc5870.html
+    // The base RegExp comes from:
+    // https://github.com/cure53/DOMPurify/blob/main/src/regexp.js#L10
+    ALLOWED_URI_REGEXP:
+      /^(?:(?:(?:f|ht)tps?|mailto|tel|callto|sms|cid|xmpp|geo):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i,
+  })
+  return s
+}
+
+export function toHTML(r, options) {
+  if (!r) return ''
+  const target = (options && options.target) || 'blank'
+  let ii
+
+  // detect newline format
+  const newline = r.indexOf('\r\n') != -1 ? '\r\n' : r.indexOf('\n') != -1 ? '\n' : ''
+
+  // headings and hr
+  r = r.replace(/^### (.*)/gm, '<h5>$1</h5>')
+  r = r.replace(/^## (.*)/gm, '<h4>$1</h4>')
+  r = r.replace(/^# (.*)/gm, '<h3>$1</h3>')
+  r = r.replace(/^---/gm, '<hr>')
+
+  // bold, italics
+  r = r.replace(/\*\*(.*?)\*\*/g, '<strong>$1</strong>')
+  r = r.replace(/\*(.*?)\*/g, '<em>$1</em>')
+
+  // unordered lists
+  r = r.replace(/^\*\* (.*)/gm, '<ul><ul><li>$1</li></ul></ul>')
+  r = r.replace(/^\* (.*)/gm, '<ul><li>$1</li></ul>')
+  for (ii = 0; ii < 3; ii++)
+    r = r.replace(new RegExp(`</ul>${newline}<ul>`, 'g'), newline)
+
+  // links
+  r = r.replace(/(\[\[http)/g, '[[h_t_t_p') // Escape for avoiding clash between [[http://xxx]] and http://xxx
+  r = r.replace(/({{http)/g, '{{h_t_t_p')
+  r = r.replace(/(=http)/g, '=h_t_t_p') // http://xxx as query string, see https://github.com/umap-project/umap/issues/607
+  r = r.replace(/(https?:[^ \<)\n]*)/g, `<a target="_${target}" href="$1">$1</a>`)
+  r = r.replace(
+    /\[\[(h_t_t_ps?:[^\]|]*?)\]\]/g,
+    `<a target="_${target}" href="$1">$1</a>`
+  )
+  r = r.replace(
+    /\[\[(h_t_t_ps?:[^|]*?)\|(.*?)\]\]/g,
+    `<a target="_${target}" href="$1">$2</a>`
+  )
+  r = r.replace(/\[\[([^\]|]*?)\]\]/g, `<a target="_${target}" href="$1">$1</a>`)
+  r = r.replace(/\[\[([^|]*?)\|(.*?)\]\]/g, `<a target="_${target}" href="$1">$2</a>`)
+
+  // iframe
+  r = r.replace(
+    /{{{(h_t_t_ps?[^ |{]*)}}}/g,
+    '<div><iframe frameborder="0" src="$1" width="100%" height="300px"></iframe></div>'
+  )
+  r = r.replace(
+    /{{{(h_t_t_ps?[^ |{]*)\|(\d*)(px)?}}}/g,
+    '<div><iframe frameborder="0" src="$1" width="100%" height="$2px"></iframe></div>'
+  )
+  r = r.replace(
+    /{{{(h_t_t_ps?[^ |{]*)\|(\d*)(px)?\*(\d*)(px)?}}}/g,
+    '<div><iframe frameborder="0" src="$1" width="$4px" height="$2px"></iframe></div>'
+  )
+
+  // images
+  r = r.replace(/{{([^\]|]*?)}}/g, '<img src="$1">')
+  r = r.replace(
+    /{{([^|]*?)\|(\d*?)(px)?}}/g,
+    '<img src="$1" style="width:$2px;min-width:$2px;">'
+  )
+
+  //Unescape http
+  r = r.replace(/(h_t_t_p)/g, 'http')
+
+  // Preserver line breaks
+  if (newline) r = r.replace(new RegExp(`${newline}(?=[^]+)`, 'g'), `<br>${newline}`)
+
+  r = escapeHTML(r)
+
+  return r
+}
+
+export function isObject(what) {
+  return typeof what === 'object' && what !== null
+}
+
+export function CopyJSON(geojson) {
+  return JSON.parse(JSON.stringify(geojson))
+}
+
+export function detectFileType(f) {
+  const filename = f.name ? escape(f.name.toLowerCase()) : ''
+  function ext(_) {
+    return filename.indexOf(_) !== -1
+  }
+  if (f.type === 'application/vnd.google-earth.kml+xml' || ext('.kml')) {
+    return 'kml'
+  }
+  if (ext('.gpx')) return 'gpx'
+  if (ext('.geojson') || ext('.json')) return 'geojson'
+  if (f.type === 'text/csv' || ext('.csv') || ext('.tsv') || ext('.dsv')) {
+    return 'csv'
+  }
+  if (ext('.xml') || ext('.osm')) return 'osm'
+  if (ext('.umap')) return 'umap'
+}
+
+export function usableOption(options, option) {
+  return options[option] !== undefined && options[option] !== ''
+}
+
+/**
+ * Processes a template string by replacing placeholders with corresponding
+ * data values.
+ *
+ * Supports dot notation for nested objects and optional static fallbacks.
+ * If a value is not found, the placeholder is replaced with an empty string
+ * or left unchanged when 'ignore' is true.
+ *
+ * @param {string} str - The template string with placeholders.
+ * @param {Object} data - The data object from which to pull replacement values.
+ * @param {boolean} [ignore=false] - If true, leaves placeholders unchanged when no value is found.
+ * @returns {string} The processed string with placeholders replaced.
+ */
+export function greedyTemplate(str, data, ignore) {
+  function getValue(data, path) {
+    let value = data
+    for (let i = 0; i < path.length; i++) {
+      value = value[path[i]]
+      if (value === undefined) break
+    }
+    return value
+  }
+
+  if (typeof str !== 'string') return ''
+
+  return str.replace(
+    /\{ *([^\{\}/\-]+)(?:\|("[^"]*"))? *\}/g,
+    (str, key, staticFallback) => {
+      const vars = key.split('|')
+      let value
+      let path
+      if (staticFallback !== undefined) {
+        vars.push(staticFallback)
+      }
+      for (let i = 0; i < vars.length; i++) {
+        path = vars[i]
+        if (path.startsWith('"') && path.endsWith('"'))
+          value = path.substring(1, path.length - 1) // static default value.
+        else value = getValue(data, path.split('.'))
+        if (value !== undefined) break
+      }
+      if (value === undefined) {
+        if (ignore) value = str
+        else value = ''
+      }
+      return value
+    }
+  )
+}
+
+export function naturalSort(a, b, lang) {
+  return a
+    .toString()
+    .toLowerCase()
+    .localeCompare(b.toString().toLowerCase(), lang || 'en', {
+      sensitivity: 'base',
+      numeric: true,
+    })
+}
+
+export function sortFeatures(features, sortKey, lang) {
+  const sortKeys = (sortKey || 'name').split(',')
+
+  const sort = (a, b, i) => {
+    let sortKey = sortKeys[i],
+      reverse = 1
+    if (sortKey[0] === '-') {
+      reverse = -1
+      sortKey = sortKey.substring(1)
+    }
+    let score
+    const valA = a.properties[sortKey] || ''
+    const valB = b.properties[sortKey] || ''
+    if (!valA) score = -1
+    else if (!valB) score = 1
+    else score = naturalSort(valA, valB, lang)
+    if (score === 0 && sortKeys[i + 1]) return sort(a, b, i + 1)
+    return score * reverse
+  }
+
+  features.sort((a, b) => {
+    if (!a.properties || !b.properties) {
+      return 0
+    }
+    return sort(a, b, 0)
+  })
+
+  return features
+}
+
+export function flattenCoordinates(coords) {
+  while (coords[0] && typeof coords[0][0] !== 'number') coords = coords[0]
+  return coords
+}
+
+export function buildQueryString(params) {
+  const query_string = []
+  for (const key in params) {
+    query_string.push(`${encodeURIComponent(key)}=${encodeURIComponent(params[key])}`)
+  }
+  return query_string.join('&')
+}
+
+export function getBaseUrl() {
+  return `//${window.location.host}${window.location.pathname}`
+}
+
+export function hasVar(value) {
+  return typeof value === 'string' && value.indexOf('{') != -1
+}
+
+export function isPath(value) {
+  return value && value.length && value.startsWith('/')
+}
+
+export function isRemoteUrl(value) {
+  return value && value.length && value.startsWith('http')
+}
+
+export function isDataImage(value) {
+  return value && value.length && value.startsWith('data:image')
+}
+
+/**
+ * Normalizes the input string by converting to lowercase
+ * and removing diacritics.
+ *
+ * If the input is nullish, it defaults to an empty string.
+ *
+ * @param {string} s - The string to be normalized.
+ * @returns {string} - The normalized string with lowercase
+ *                     characters and no diacritics.
+ */
+export function normalize(s) {
+  return (s || '')
+    .toLowerCase()
+    .normalize('NFD')
+    .replace(/[\u0300-\u036f]/g, '')
+}
+
+// Vendorized from leaflet.utils
+// https://github.com/Leaflet/Leaflet/blob/108c6717b70f57c63645498f9bd66b6677758786/src/core/Util.js#L132-L151
+var templateRe = /\{ *([\w_ -]+) *\}/g
+
+export function template(str, data) {
+  return str.replace(templateRe, function (str, key) {
+    var value = data[key]
+
+    if (value === undefined) {
+      throw new Error('No value provided for variable ' + str)
+    } else if (typeof value === 'function') {
+      value = value(data)
+    }
+    return value
+  })
+}
+
+export function parseNaiveDate(value) {
+    const naive = new Date(value)
+    // Let's pretend naive date are UTC, and remove time…
+    return new Date(Date.UTC(naive.getFullYear(), naive.getMonth(), naive.getDate()))
+}

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

@@ -35,27 +35,25 @@ U.AutoComplete = L.Class.extend({
   },
 
   createInput: function () {
-    this.input = L.DomUtil.element(
-      'input',
-      {
-        type: 'text',
-        placeholder: this.options.placeholder,
-        autocomplete: 'off',
-        className: this.options.className,
-      },
-      this.el
-    )
+    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(
-      'ul',
-      { className: 'umap-autocomplete' },
-      document.body
-    )
+    this.container = L.DomUtil.element({
+      tagName: 'ul',
+      parent: document.body,
+      className: 'umap-autocomplete',
+    })
   },
 
   resizeContainer: function () {
@@ -174,8 +172,11 @@ U.AutoComplete = L.Class.extend({
   },
 
   createResult: function (item) {
-    const el = L.DomUtil.element('li', {}, this.container)
-    el.textContent = item.label
+    const el = L.DomUtil.element({
+      tagName: 'li',
+      parent: this.container,
+      textContent: item.label,
+    })
     const result = {
       item: item,
       el: el,
@@ -276,15 +277,22 @@ U.AutoComplete.Ajax.SelectMultiple = U.AutoComplete.Ajax.extend({
   initSelectedContainer: function () {
     return L.DomUtil.after(
       this.input,
-      L.DomUtil.element('ul', { className: 'umap-multiresult' })
+      L.DomUtil.element({ tagName: 'ul', className: 'umap-multiresult' })
     )
   },
 
   displaySelected: function (result) {
-    const result_el = L.DomUtil.element('li', {}, this.selected_container)
+    const result_el = L.DomUtil.element({
+      tagName: 'li',
+      parent: this.selected_container,
+    })
     result_el.textContent = result.item.label
-    const close = L.DomUtil.element('span', { className: 'close' }, result_el)
-    close.textContent = '×'
+    const close = L.DomUtil.element({
+      tagName: 'span',
+      parent: result_el,
+      className: 'close',
+      textContent: '×',
+    })
     L.DomEvent.on(
       close,
       'click',
@@ -302,15 +310,22 @@ U.AutoComplete.Ajax.Select = U.AutoComplete.Ajax.extend({
   initSelectedContainer: function () {
     return L.DomUtil.after(
       this.input,
-      L.DomUtil.element('div', { className: 'umap-singleresult' })
+      L.DomUtil.element({ tagName: 'div', className: 'umap-singleresult' })
     )
   },
 
   displaySelected: function (result) {
-    const result_el = L.DomUtil.element('div', {}, this.selected_container)
+    const result_el = L.DomUtil.element({
+      tagName: 'div',
+      parent: this.selected_container,
+    })
     result_el.textContent = result.item.label
-    const close = L.DomUtil.element('span', { className: 'close' }, result_el)
-    close.textContent = '×'
+    const close = L.DomUtil.element({
+      tagName: 'span',
+      parent: result_el,
+      className: 'close',
+      textContent: '×',
+    })
     this.input.style.display = 'none'
     L.DomEvent.on(
       close,