umap-project 2.0.4__py3-none-any.whl → 2.1.0__py3-none-any.whl

umap/static/umap/js/modules/schema.js

@@ -0,0 +1,388 @@
+import { translate } from './i18n.js'
+
+export const SCHEMA = {
+  zoom: {
+    type: Number,
+  },
+  scrollWheelZoom: {
+    type: Boolean,
+    label: translate('Allow scroll wheel zoom?'),
+  },
+  scaleControl: {
+    type: Boolean,
+    label: translate('Do you want to display the scale control?'),
+    default: true,
+  },
+  moreControl: {
+    type: Boolean,
+    label: translate('Do you want to display the «more» control?'),
+    default: true,
+  },
+  miniMap: {
+    type: Boolean,
+    label: translate('Do you want to display a minimap?'),
+    default: false,
+  },
+  displayPopupFooter: {
+    type: Boolean,
+    label: translate('Do you want to display popup footer?'),
+    default: false,
+  },
+  onLoadPanel: {
+    type: String,
+    label: translate('Do you want to display a panel on load?'),
+    choices: [
+      ['none', translate('None')],
+      ['caption', translate('Caption')],
+      ['databrowser', translate('Data browser')],
+      ['facet', translate('Facet search')],
+    ],
+    default: 'none',
+  },
+  defaultView: {
+    type: String,
+    label: translate('Default view'),
+    choices: [
+      ['center', translate('Saved center and zoom')],
+      ['data', translate('Fit all data')],
+      ['latest', translate('Latest feature')],
+      ['locate', translate('User location')],
+    ],
+    default: 'center',
+  },
+  name: {
+    type: String,
+    label: translate('name'),
+  },
+  description: {
+    label: translate('description'),
+    type: 'Text',
+    helpEntries: 'textFormatting',
+  },
+  licence: {
+    type: String,
+    label: translate('licence'),
+  },
+  tilelayer: {
+    type: Object,
+  },
+  overlay: {
+    type: Object,
+  },
+  limitBounds: {
+    type: Object,
+  },
+  color: {
+    type: String,
+    handler: 'ColorPicker',
+    label: translate('color'),
+    helpEntries: 'colorValue',
+    inheritable: true,
+    default: 'DarkBlue',
+  },
+  iconClass: {
+    type: String,
+    label: translate('Icon shape'),
+    inheritable: true,
+    choices: [
+      ['Default', translate('Default')],
+      ['Circle', translate('Circle')],
+      ['Drop', translate('Drop')],
+      ['Ball', translate('Ball')],
+    ],
+    default: 'Default',
+  },
+  iconUrl: {
+    type: String,
+    handler: 'IconUrl',
+    label: translate('Icon symbol'),
+    inheritable: true,
+    // helpText: translate(
+    //   'Symbol can be either a unicode character or an URL. You can use feature properties as variables: ex.: with "http://myserver.org/images/{name}.png", the {name} variable will be replaced by the "name" value of each marker.'
+    // ),
+  },
+  smoothFactor: {
+    type: Number,
+    min: 0,
+    max: 10,
+    step: 0.5,
+    label: translate('Simplify'),
+    helpEntries: 'smoothFactor',
+    inheritable: true,
+    default: 1.0,
+  },
+  iconOpacity: {
+    type: Number,
+    min: 0.1,
+    max: 1,
+    step: 0.1,
+    label: translate('icon opacity'),
+    inheritable: true,
+    default: 1,
+  },
+  opacity: {
+    type: Number,
+    min: 0.1,
+    max: 1,
+    step: 0.1,
+    label: translate('opacity'),
+    inheritable: true,
+    default: 0.5,
+  },
+  weight: {
+    type: Number,
+    min: 1,
+    max: 20,
+    step: 1,
+    label: translate('weight'),
+    inheritable: true,
+    default: 3,
+  },
+  fill: {
+    type: Boolean,
+    label: translate('fill'),
+    helpEntries: 'fill',
+    inheritable: true,
+    default: true,
+  },
+  fillColor: {
+    type: String,
+    handler: 'ColorPicker',
+    label: translate('fill color'),
+    helpEntries: 'fillColor',
+    inheritable: true,
+  },
+  fillOpacity: {
+    type: Number,
+    min: 0.1,
+    max: 1,
+    step: 0.1,
+    label: translate('fill opacity'),
+    inheritable: true,
+    default: 0.3,
+  },
+  dashArray: {
+    type: String,
+    label: translate('dash array'),
+    helpEntries: 'dashArray',
+    inheritable: true,
+  },
+  popupShape: {
+    type: String,
+    label: translate('Popup shape'),
+    inheritable: true,
+    choices: [
+      ['Default', translate('Popup')],
+      ['Large', translate('Popup (large)')],
+      ['Panel', translate('Side panel')],
+    ],
+    default: 'Default',
+  },
+  popupTemplate: {
+    type: String,
+    label: translate('Popup content style'),
+    inheritable: true,
+    choices: [
+      ['Default', translate('Default')],
+      ['Table', translate('Table')],
+      ['GeoRSSImage', translate('GeoRSS (title + image)')],
+      ['GeoRSSLink', translate('GeoRSS (only link)')],
+      ['OSM', translate('OpenStreetMap')],
+    ],
+    default: 'Default',
+  },
+  popupContentTemplate: {
+    type: 'Text',
+    label: translate('Popup content template'),
+    helpEntries: ['dynamicProperties', 'textFormatting'],
+    placeholder: '# {name}',
+    inheritable: true,
+    default: '# {name}\n{description}',
+  },
+  zoomTo: {
+    type: Number,
+    placeholder: translate('Inherit'),
+    helpEntries: 'zoomTo',
+    label: translate('Default zoom level'),
+    inheritable: true,
+  },
+  captionBar: {
+    type: Boolean,
+    label: translate('Do you want to display a caption bar?'),
+    default: false,
+  },
+  captionMenus: {
+    type: Boolean,
+    label: translate('Do you want to display caption menus?'),
+    default: true,
+  },
+  slideshow: {
+    type: Object,
+  },
+  sortKey: {
+    type: String,
+  },
+  labelKey: {
+    type: String,
+    helpEntries: 'labelKey',
+    placeholder: translate('Default: name'),
+    label: translate('Label key'),
+    inheritable: true,
+  },
+  filterKey: {
+    type: String,
+  },
+  facetKey: {
+    type: String,
+  },
+  slugKey: {
+    type: String,
+  },
+  showLabel: {
+    type: Boolean,
+    nullable: true,
+    label: translate('Display label'),
+    inheritable: true,
+    default: false,
+  },
+  labelDirection: {
+    type: String,
+    label: translate('Label direction'),
+    inheritable: true,
+    choices: [
+      ['auto', translate('Automatic')],
+      ['left', translate('On the left')],
+      ['right', translate('On the right')],
+      ['top', translate('On the top')],
+      ['bottom', translate('On the bottom')],
+    ],
+    default: 'auto',
+  },
+  labelInteractive: {
+    type: Boolean,
+    label: translate('Labels are clickable'),
+    inheritable: true,
+  },
+  outlinkTarget: {
+    type: String,
+    label: translate('Open link in…'),
+    inheritable: true,
+    default: 'blank',
+    choices: [
+      ['blank', translate('new window')],
+      ['self', translate('iframe')],
+      ['parent', translate('parent window')],
+    ],
+  },
+  shortCredit: {
+    type: String,
+    label: translate('Short credits'),
+    helpEntries: ['shortCredit', 'textFormatting'],
+  },
+  longCredit: {
+    type: 'Text',
+    label: translate('Long credits'),
+    helpEntries: ['longCredit', 'textFormatting'],
+  },
+  permanentCredit: {
+    type: 'Text',
+    label: translate('Permanent credits'),
+    helpEntries: ['permanentCredit', 'textFormatting'],
+  },
+  permanentCreditBackground: {
+    type: Boolean,
+    label: translate('Permanent credits background'),
+    default: true,
+  },
+  zoomControl: {
+    type: Boolean,
+    nullable: true,
+    label: translate('Display the zoom control'),
+    default: true,
+  },
+  datalayersControl: {
+    type: Boolean,
+    nullable: true,
+    handler: 'DataLayersControl',
+    label: translate('Display the data layers control'),
+    default: true,
+  },
+  searchControl: {
+    type: Boolean,
+    nullable: true,
+    label: translate('Display the search control'),
+    default: true,
+  },
+  locateControl: {
+    type: Boolean,
+    nullable: true,
+    label: translate('Display the locate control'),
+  },
+  fullscreenControl: {
+    type: Boolean,
+    nullable: true,
+    label: translate('Display the fullscreen control'),
+    default: true,
+  },
+  editinosmControl: {
+    type: Boolean,
+    nullable: true,
+    label: translate('Display the control to open OpenStreetMap editor'),
+    default: null,
+  },
+  embedControl: {
+    type: Boolean,
+    nullable: true,
+    label: translate('Display the embed control'),
+    default: true,
+  },
+  measureControl: {
+    type: Boolean,
+    nullable: true,
+    label: translate('Display the measure control'),
+  },
+  tilelayersControl: {
+    type: Boolean,
+    nullable: true,
+    label: translate('Display the tile layers control'),
+  },
+  starControl: {
+    type: Boolean,
+    nullable: true,
+    label: translate('Display the star map button'),
+  },
+  easing: {
+    type: Boolean,
+    default: false,
+  },
+  interactive: {
+    type: Boolean,
+    label: translate('Allow interactions'),
+    helpEntries: 'interactive',
+    inheritable: true,
+    default: true,
+  },
+  fromZoom: {
+    type: Number,
+    label: translate('From zoom'),
+    helpText: translate('Optional.'),
+  },
+  toZoom: {
+    type: Number,
+    label: translate('To zoom'),
+    helpText: translate('Optional.'),
+  },
+  stroke: {
+    type: Boolean,
+    label: translate('stroke'),
+    helpEntries: 'stroke',
+    inheritable: true,
+    default: true,
+  },
+  outlink: {
+    label: translate('Link to…'),
+    helpEntries: 'outlink',
+    placeholder: 'http://...',
+    inheritable: true,
+  },
+}

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

@@ -1,4 +1,19 @@
-import { Util } from '../../vendors/leaflet/leaflet-src.esm.js'
+// 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
+  })
+}
 
 export default class URLs {
   constructor(serverUrls) {
@@ -9,7 +24,7 @@ export default class URLs {
     if (typeof this[urlName] === 'function') return this[urlName](params)
 
     if (this.urls.hasOwnProperty(urlName)) {
-      return Util.template(this.urls[urlName], params)
+      return template(this.urls[urlName], params)
     } else {
       throw `Unable to find a URL for route ${urlName}`
     }

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

@@ -0,0 +1,24 @@
+/**
+ * Generate a pseudo-unique identifier (5 chars long, mixed-case alphanumeric)
+ *
+ * Here's the collision risk:
+ * - for 6 chars, 1 in 100 000
+ * - for 5 chars, 5 in 100 000
+ * - for 4 chars, 500 in 100 000
+ *
+ * @returns string
+ */
+export function generateId() {
+  return btoa(Math.random().toString()).substring(10, 15)
+}
+
+/**
+ * Ensure the ID matches the expected format.
+ *
+ * @param {string} string
+ * @returns {boolean}
+ */
+export function checkId(string) {
+  if (typeof string !== 'string') return false
+  return /^[A-Za-z0-9]{5}$/.test(string)
+}

umap/static/umap/js/umap.controls.js

@@ -1184,25 +1184,22 @@ U.AttributionControl = L.Control.Attribution.extend({
       this._container,
       credits
     )
-    if (this._map.options.shortCredit) {
-      L.DomUtil.add(
-        'span',
-        '',
-        container,
-        ` — ${L.Util.toHTML(this._map.options.shortCredit)}`
-      )
+    const shortCredit = this._map.getOption('shortCredit'),
+      captionMenus = this._map.getOption('captionMenus')
+    if (shortCredit) {
+      L.DomUtil.add('span', '', container, ` — ${L.Util.toHTML(shortCredit)}`)
     }
-    if (this._map.options.captionMenus) {
+    if (captionMenus) {
       const link = L.DomUtil.add('a', '', container, ` — ${L._('About')}`)
       L.DomEvent.on(link, 'click', L.DomEvent.stop)
         .on(link, 'click', this._map.displayCaption, this._map)
         .on(link, 'dblclick', L.DomEvent.stop)
     }
-    if (window.top === window.self && this._map.options.captionMenus) {
+    if (window.top === window.self && captionMenus) {
       // We are not in iframe mode
       L.DomUtil.createLink('', container, ` — ${L._('Home')}`, '/')
     }
-    if (this._map.options.captionMenus) {
+    if (captionMenus) {
       L.DomUtil.createLink(
         '',
         container,
@@ -1240,6 +1237,7 @@ U.StarControl = L.Control.extend({
 U.Search = L.PhotonSearch.extend({
   initialize: function (map, input, options) {
     this.options.placeholder = L._('Type a place name or coordinates')
+    this.options.location_bias_scale = 0.5
     L.PhotonSearch.prototype.initialize.call(this, map, input, options)
     this.options.url = map.options.urls.search
     if (map.options.maxBounds) this.options.bbox = map.options.maxBounds.toBBoxString()
@@ -1279,6 +1277,7 @@ U.Search = L.PhotonSearch.extend({
     // Only numbers, abort.
     if (/^[\d .,]*$/.test(this.input.value)) return
     // Do normal search
+    this.options.includePosition = this.map.getZoom() > 10
     L.PhotonSearch.prototype.search.call(this)
   },
 

umap/static/umap/js/umap.core.js

@@ -415,7 +415,10 @@ L.DomUtil.TextColorFromBackgroundColor = (el, bgcolor) => {
 L.DomUtil.contrastWCAG21 = (rgb) => {
   const [r, g, b] = rgb
   // luminance of inputted colour
-  const lum = 0.2126 * L.DomUtil.colourMod(r) + 0.7152 * L.DomUtil.colourMod(g) + 0.0722 * L.DomUtil.colourMod(b)
+  const lum =
+    0.2126 * L.DomUtil.colourMod(r) +
+    0.7152 * L.DomUtil.colourMod(g) +
+    0.0722 * L.DomUtil.colourMod(b)
   // white has a luminance of 1
   const whiteLum = 1
   const contrast = (whiteLum + 0.05) / (lum + 0.05)
@@ -729,9 +732,6 @@ U.Help = L.Class.extend({
   formatURL: `${L._(
     'Supported variables that will be dynamically replaced'
   )}: {bbox}, {lat}, {lng}, {zoom}, {east}, {north}..., {left}, {top}..., locale, lang`,
-  formatIconSymbol: L._(
-    'Symbol can be either a unicode character or an URL. You can use feature properties as variables: ex.: with "http://myserver.org/images/{name}.png", the {name} variable will be replaced by the "name" value of each marker.'
-  ),
   colorValue: L._('Must be a valid CSS value (eg.: DarkBlue or #123456)'),
   smoothFactor: L._(
     'How much to simplify the polyline on each zoom level (more = better performance and smoother look, less = more accurate)'
@@ -741,7 +741,7 @@ U.Help = L.Class.extend({
   ),
   zoomTo: L._('Zoom level for automatic zooms'),
   labelKey: L._(
-    'The name of the property to use as feature label (eg.: "nom"). You can also use properties inside brackets to use more than one or mix with static content (eg.: "{name} in {place}")'
+    'The name of the property to use as feature label (eg.: "nom"). You can also use properties inside brackets to use more than one or mix with static content (eg.: "{name} in {place}")'
   ),
   stroke: L._('Whether to display or not polygons paths.'),
   fill: L._('Whether to fill polygons with color.'),

umap/static/umap/js/umap.features.js

@@ -9,8 +9,17 @@ U.FeatureMixin = {
     // DataLayer the marker belongs to
     this.datalayer = options.datalayer || null
     this.properties = { _umap_options: {} }
+    let geojson_id
     if (options.geojson) {
       this.populate(options.geojson)
+      geojson_id = options.geojson.id
+    }
+
+    // Each feature needs an unique identifier
+    if (U.Utils.checkId(geojson_id)) {
+      this.id = geojson_id
+    } else {
+      this.id = U.Utils.generateId()
     }
     let isDirty = false
     const self = this
@@ -44,7 +53,7 @@ U.FeatureMixin = {
   },
 
   getSlug: function () {
-    return this.properties[this.map.options.slugKey || 'name'] || ''
+    return this.properties[this.map.getOption('slugKey') || 'name'] || ''
   },
 
   getPermalink: function () {
@@ -94,11 +103,15 @@ U.FeatureMixin = {
       L._('Feature properties')
     )
 
-    let builder = new U.FormBuilder(this, ['datalayer'], {
-      callback: function () {
-        this.edit(e)
-      }, // removeLayer step will close the edit panel, let's reopen it
-    })
+    let builder = new U.FormBuilder(
+      this,
+      [['datalayer', { handler: 'DataLayerSwitcher' }]],
+      {
+        callback: function () {
+          this.edit(e)
+        }, // removeLayer step will close the edit panel, let's reopen it
+      }
+    )
     container.appendChild(builder.build())
 
     const properties = []
@@ -200,7 +213,7 @@ U.FeatureMixin = {
     if (L.Browser.ielt9) return false
     if (this.datalayer.isRemoteLayer() && this.datalayer.options.remoteData.dynamic)
       return false
-    return this.map.options.displayPopupFooter
+    return this.map.getOption('displayPopupFooter')
   },
 
   getPopupClass: function () {
@@ -300,7 +313,7 @@ U.FeatureMixin = {
 
   zoomTo: function (e) {
     e = e || {}
-    const easing = e.easing !== undefined ? e.easing : this.map.options.easing
+    const easing = e.easing !== undefined ? e.easing : this.map.getOption('easing')
     if (easing) {
       this.map.flyTo(this.getCenter(), this.getBestZoom())
     } else {
@@ -344,6 +357,7 @@ U.FeatureMixin = {
   toGeoJSON: function () {
     const geojson = this.parentClass.prototype.toGeoJSON.call(this)
     geojson.properties = this.cloneProperties()
+    geojson.id = this.id
     delete geojson.properties._storage_options
     return geojson
   },
@@ -965,7 +979,7 @@ U.PathMixin = {
   zoomTo: function (e) {
     // Use bounds instead of centroid for paths.
     e = e || {}
-    const easing = e.easing !== undefined ? e.easing : this.map.options.easing
+    const easing = e.easing !== undefined ? e.easing : this.map.getOption('easing')
     if (easing) {
       this.map.flyToBounds(this.getBounds(), this.getBestZoom())
     } else {