umap-project 2.4.0b2__py3-none-any.whl → 2.4.2__py3-none-any.whl

umap/static/umap/js/umap.layer.js

@@ -15,11 +15,9 @@ U.Layer = {
     return this._layers
   },
 
-  getEditableOptions: function () {
-    return []
-  },
+  getEditableOptions: () => [],
 
-  onEdit: function () {},
+  onEdit: () => {},
 
   hasDataVisible: function () {
     return !!Object.keys(this._layers).length
@@ -67,11 +65,9 @@ U.Layer.Cluster = L.MarkerClusterGroup.extend({
       polygonOptions: {
         color: this.datalayer.getColor(),
       },
-      iconCreateFunction: function (cluster) {
-        return new U.Icon.Cluster(datalayer, cluster)
-      },
+      iconCreateFunction: (cluster) => new U.Icon.Cluster(datalayer, cluster),
     }
-    if (this.datalayer.options.cluster && this.datalayer.options.cluster.radius) {
+    if (this.datalayer.options.cluster?.radius) {
       options.maxClusterRadius = this.datalayer.options.cluster.radius
     }
     L.MarkerClusterGroup.prototype.initialize.call(this, options)
@@ -99,26 +95,24 @@ U.Layer.Cluster = L.MarkerClusterGroup.extend({
     return L.MarkerClusterGroup.prototype.removeLayer.call(this, layer)
   },
 
-  getEditableOptions: function () {
-    return [
-      [
-        'options.cluster.radius',
-        {
-          handler: 'BlurIntInput',
-          placeholder: L._('Clustering radius'),
-          helpText: L._('Override clustering radius (default 80)'),
-        },
-      ],
-      [
-        'options.cluster.textColor',
-        {
-          handler: 'TextColorPicker',
-          placeholder: L._('Auto'),
-          helpText: L._('Text color for the cluster label'),
-        },
-      ],
-    ]
-  },
+  getEditableOptions: () => [
+    [
+      'options.cluster.radius',
+      {
+        handler: 'BlurIntInput',
+        placeholder: L._('Clustering radius'),
+        helpText: L._('Override clustering radius (default 80)'),
+      },
+    ],
+    [
+      'options.cluster.textColor',
+      {
+        handler: 'TextColorPicker',
+        placeholder: L._('Auto'),
+        helpText: L._('Text color for the cluster label'),
+      },
+    ],
+  ],
 
   onEdit: function (field, builder) {
     if (field === 'options.cluster.radius') {
@@ -182,8 +176,8 @@ U.Layer.Choropleth = L.FeatureGroup.extend({
   getValues: function () {
     const values = []
     this.datalayer.eachLayer((layer) => {
-      let value = this._getValue(layer)
-      if (!isNaN(value)) values.push(value)
+      const value = this._getValue(layer)
+      if (!Number.isNaN(value)) values.push(value)
     })
     return values
   },
@@ -196,9 +190,9 @@ U.Layer.Choropleth = L.FeatureGroup.extend({
       this.options.colors = []
       return
     }
-    let mode = this.datalayer.options.choropleth.mode,
-      classes = +this.datalayer.options.choropleth.classes || 5,
-      breaks
+    const mode = this.datalayer.options.choropleth.mode
+    let classes = +this.datalayer.options.choropleth.classes || 5
+    let breaks
     classes = Math.min(classes, values.length)
     if (mode === 'manual') {
       const manualBreaks = this.datalayer.options.choropleth.breaks
@@ -206,7 +200,7 @@ U.Layer.Choropleth = L.FeatureGroup.extend({
         breaks = manualBreaks
           .split(',')
           .map((b) => +b)
-          .filter((b) => !isNaN(b))
+          .filter((b) => !Number.isNaN(b))
       }
     } else if (mode === 'equidistant') {
       breaks = ss.equalIntervalBreaks(values, classes)
@@ -249,7 +243,7 @@ U.Layer.Choropleth = L.FeatureGroup.extend({
   addLayer: function (layer) {
     // Do not add yet the layer to the map
     // wait for datachanged event, so we want compute breaks once
-    var id = this.getLayerId(layer)
+    const id = this.getLayerId(layer)
     this._layers[id] = layer
     return this
   },
@@ -332,7 +326,9 @@ U.Layer.Choropleth = L.FeatureGroup.extend({
 
   renderLegend: function (container) {
     const parent = L.DomUtil.create('ul', '', container)
-    let li, color, label
+    let li
+    let color
+    let label
 
     this.options.breaks.slice(0, -1).forEach((limit, index) => {
       li = L.DomUtil.create('li', '', parent)
@@ -364,13 +360,10 @@ U.Layer.Heat = L.HeatLayer.extend({
 
   addLayer: function (layer) {
     if (layer instanceof L.Marker) {
-      let latlng = layer.getLatLng(),
-        alt
-      if (
-        this.datalayer.options.heat &&
-        this.datalayer.options.heat.intensityProperty
-      ) {
-        alt = parseFloat(
+      let latlng = layer.getLatLng()
+      let alt
+      if (this.datalayer.options.heat?.intensityProperty) {
+        alt = Number.parseFloat(
           layer.properties[this.datalayer.options.heat.intensityProperty || 0]
         )
         latlng = new L.LatLng(latlng.lat, latlng.lng, alt)
@@ -383,37 +376,33 @@ U.Layer.Heat = L.HeatLayer.extend({
     this.setLatLngs([])
   },
 
-  getFeatures: function () {
-    return {}
-  },
+  getFeatures: () => ({}),
 
   getBounds: function () {
     return L.latLngBounds(this._latlngs)
   },
 
-  getEditableOptions: function () {
-    return [
-      [
-        'options.heat.radius',
-        {
-          handler: 'Range',
-          min: 10,
-          max: 100,
-          step: 5,
-          label: L._('Heatmap radius'),
-          helpText: L._('Override heatmap radius (default 25)'),
-        },
-      ],
-      [
-        'options.heat.intensityProperty',
-        {
-          handler: 'BlurInput',
-          placeholder: L._('Heatmap intensity property'),
-          helpText: L._('Optional intensity property for heatmap'),
-        },
-      ],
-    ]
-  },
+  getEditableOptions: () => [
+    [
+      'options.heat.radius',
+      {
+        handler: 'Range',
+        min: 10,
+        max: 100,
+        step: 5,
+        label: L._('Heatmap radius'),
+        helpText: L._('Override heatmap radius (default 25)'),
+      },
+    ],
+    [
+      'options.heat.intensityProperty',
+      {
+        handler: 'BlurInput',
+        placeholder: L._('Heatmap intensity property'),
+        helpText: L._('Optional intensity property for heatmap'),
+      },
+    ],
+  ],
 
   onEdit: function (field, builder) {
     if (field === 'options.heat.intensityProperty') {
@@ -440,23 +429,23 @@ U.Layer.Heat = L.HeatLayer.extend({
     if (!this._map) {
       return
     }
-    var data = [],
-      r = this._heat._r,
-      size = this._map.getSize(),
-      bounds = new L.Bounds(L.point([-r, -r]), size.add([r, r])),
-      cellSize = r / 2,
-      grid = [],
-      panePos = this._map._getMapPanePos(),
-      offsetX = panePos.x % cellSize,
-      offsetY = panePos.y % cellSize,
-      i,
-      len,
-      p,
-      cell,
-      x,
-      y,
-      j,
-      len2
+    const data = []
+    const r = this._heat._r
+    const size = this._map.getSize()
+    const bounds = new L.Bounds(L.point([-r, -r]), size.add([r, r]))
+    const cellSize = r / 2
+    const grid = []
+    const panePos = this._map._getMapPanePos()
+    const offsetX = panePos.x % cellSize
+    const offsetY = panePos.y % cellSize
+    let i
+    let len
+    let p
+    let cell
+    let x
+    let y
+    let j
+    let len2
 
     this._max = 1
 
@@ -465,7 +454,7 @@ U.Layer.Heat = L.HeatLayer.extend({
       x = Math.floor((p.x - offsetX) / cellSize) + 2
       y = Math.floor((p.y - offsetY) / cellSize) + 2
 
-      var alt =
+      const alt =
         this._latlngs[i].alt !== undefined
           ? this._latlngs[i].alt
           : this._latlngs[i][2] !== undefined
@@ -538,23 +527,20 @@ U.DataLayer = L.Evented.extend({
 
     let isDirty = false
     let isDeleted = false
-    const self = this
     try {
       Object.defineProperty(this, 'isDirty', {
-        get: function () {
-          return isDirty
-        },
-        set: function (status) {
-          if (!isDirty && status) self.fire('dirty')
+        get: () => isDirty,
+        set: (status) => {
+          if (!isDirty && status) this.fire('dirty')
           isDirty = status
           if (status) {
-            self.map.addDirtyDatalayer(self)
+            this.map.addDirtyDatalayer(this)
             // A layer can be made dirty by indirect action (like dragging layers)
             // we need to have it loaded before saving it.
-            if (!self.isLoaded()) self.fetchData()
+            if (!this.isLoaded()) this.fetchData()
           } else {
-            self.map.removeDirtyDatalayer(self)
-            self.isDeleted = false
+            this.map.removeDirtyDatalayer(this)
+            this.isDeleted = false
           }
         },
       })
@@ -563,13 +549,11 @@ U.DataLayer = L.Evented.extend({
     }
     try {
       Object.defineProperty(this, 'isDeleted', {
-        get: function () {
-          return isDeleted
-        },
-        set: function (status) {
-          if (!isDeleted && status) self.fire('deleted')
+        get: () => isDeleted,
+        set: (status) => {
+          if (!isDeleted && status) this.fire('deleted')
           isDeleted = status
-          if (status) self.isDirty = status
+          if (status) this.isDirty = status
         },
       })
     } catch (e) {
@@ -582,11 +566,11 @@ U.DataLayer = L.Evented.extend({
       this.options.remoteData = {}
     }
     // Retrocompat
-    if (this.options.remoteData && this.options.remoteData.from) {
+    if (this.options.remoteData?.from) {
       this.options.fromZoom = this.options.remoteData.from
       delete this.options.remoteData.from
     }
-    if (this.options.remoteData && this.options.remoteData.to) {
+    if (this.options.remoteData?.to) {
       this.options.toZoom = this.options.remoteData.to
       delete this.options.remoteData.to
     }
@@ -618,9 +602,9 @@ U.DataLayer = L.Evented.extend({
   },
 
   render: function (fields, builder) {
-    let impacts = U.Utils.getImpactsFromSchema(fields)
+    const impacts = U.Utils.getImpactsFromSchema(fields)
 
-    for (let impact of impacts) {
+    for (const impact of impacts) {
       switch (impact) {
         case 'ui':
           this.map.onDataLayersChanged()
@@ -745,8 +729,8 @@ U.DataLayer = L.Evented.extend({
     }
   },
 
-  fromGeoJSON: function (geojson) {
-    this.addData(geojson)
+  fromGeoJSON: function (geojson, sync = true) {
+    this.addData(geojson, sync)
     this._geojson = geojson
     this._dataloaded = true
     this.fire('dataloaded')
@@ -757,7 +741,7 @@ U.DataLayer = L.Evented.extend({
     if (geojson._storage) geojson._umap_options = geojson._storage // Retrocompat
     if (geojson._umap_options) this.setOptions(geojson._umap_options)
     if (this.isRemoteLayer()) await this.fetchRemoteData()
-    else this.fromGeoJSON(geojson)
+    else this.fromGeoJSON(geojson, false)
     this._loaded = true
   },
 
@@ -787,14 +771,14 @@ U.DataLayer = L.Evented.extend({
   },
 
   showAtZoom: function () {
-    const from = parseInt(this.options.fromZoom, 10),
-      to = parseInt(this.options.toZoom, 10),
-      zoom = this.map.getZoom()
-    return !((!isNaN(from) && zoom < from) || (!isNaN(to) && zoom > to))
+    const from = Number.parseInt(this.options.fromZoom, 10)
+    const to = Number.parseInt(this.options.toZoom, 10)
+    const zoom = this.map.getZoom()
+    return !((!Number.isNaN(from) && zoom < from) || (!Number.isNaN(to) && zoom > to))
   },
 
   hasDynamicData: function () {
-    return !!(this.options.remoteData && this.options.remoteData.dynamic)
+    return !!this.options.remoteData?.dynamic
   },
 
   fetchRemoteData: async function (force) {
@@ -806,7 +790,7 @@ U.DataLayer = L.Evented.extend({
       url = this.map.proxyUrl(url, this.options.remoteData.ttl)
     }
     const response = await this.map.request.get(url)
-    if (response && response.ok) {
+    if (response?.ok) {
       this.clear()
       this.rawToGeoJSON(
         await response.text(),
@@ -884,11 +868,7 @@ U.DataLayer = L.Evented.extend({
   },
 
   isRemoteLayer: function () {
-    return Boolean(
-      this.options.remoteData &&
-        this.options.remoteData.url &&
-        this.options.remoteData.format
-    )
+    return Boolean(this.options.remoteData?.url && this.options.remoteData.format)
   },
 
   isClustered: function () {
@@ -911,12 +891,13 @@ U.DataLayer = L.Evented.extend({
     if (this.hasDataLoaded()) this.fire('datachanged')
   },
 
-  removeLayer: function (feature) {
+  removeLayer: function (feature, sync) {
     const id = L.stamp(feature)
+    if (sync !== false) feature.sync.delete()
+    this.layer.removeLayer(feature)
     feature.disconnectFromDataLayer(this)
     this._index.splice(this._index.indexOf(id), 1)
     delete this._layers[id]
-    this.layer.removeLayer(feature)
     delete this.map.features_index[feature.getSlug()]
     if (this.hasDataLoaded()) this.fire('datachanged')
   },
@@ -938,11 +919,11 @@ U.DataLayer = L.Evented.extend({
     if (idx !== -1) this._propertiesIndex.splice(idx, 1)
   },
 
-  addData: function (geojson) {
+  addData: function (geojson, sync) {
     try {
       // Do not fail if remote data is somehow invalid,
       // otherwise the layer becomes uneditable.
-      this.geojsonToFeatures(geojson)
+      this.geojsonToFeatures(geojson, sync)
     } catch (err) {
       console.log('Error with DataLayer', this.umap_id)
       console.error(err)
@@ -953,7 +934,7 @@ U.DataLayer = L.Evented.extend({
     this.rawToGeoJSON(c, type, (geojson) => this.addData(geojson))
   },
 
-  rawToGeoJSON: function (c, type, callback) {
+  rawToGeoJSON: (c, type, callback) => {
     const toDom = (x) => {
       const doc = new DOMParser().parseFromString(x, 'text/xml')
       const errorNode = doc.querySelector('parsererror')
@@ -975,7 +956,7 @@ U.DataLayer = L.Evented.extend({
           // csv2geojson fallback to null geometries when it cannot determine
           // lat or lon columns. This is valid geojson, but unwanted from a user
           // point of view.
-          if (result && result.features.length) {
+          if (result?.features.length) {
             if (result.features[0].geometry === null) {
               err = {
                 type: 'Error',
@@ -996,7 +977,7 @@ U.DataLayer = L.Evented.extend({
             U.Alert.error(message, 10000)
             console.error(err)
           }
-          if (result && result.features.length) {
+          if (result?.features.length) {
             callback(result)
           }
         }
@@ -1029,9 +1010,9 @@ U.DataLayer = L.Evented.extend({
   // The choice of the name is not ours, because it is required by Leaflet.
   // It is misleading, as the returned objects are uMap objects, and not
   // GeoJSON features.
-  geojsonToFeatures: function (geojson) {
+  geojsonToFeatures: function (geojson, sync) {
     if (!geojson) return
-    const features = geojson instanceof Array ? geojson : geojson.features
+    const features = Array.isArray(geojson) ? geojson : geojson.features
     let i
     let len
 
@@ -1045,10 +1026,10 @@ U.DataLayer = L.Evented.extend({
 
     const geometry = geojson.type === 'Feature' ? geojson.geometry : geojson
 
-    let feature = this.geoJSONToLeaflet({ geometry, geojson })
+    const feature = this.geoJSONToLeaflet({ geometry, geojson })
     if (feature) {
       this.addLayer(feature)
-      feature.onCommit()
+      if (sync) feature.onCommit()
       return feature
     }
   },
@@ -1077,7 +1058,8 @@ U.DataLayer = L.Evented.extend({
   } = {}) {
     if (!geometry) return // null geometry is valid geojson.
     const coords = geometry.coordinates
-    let latlng, latlngs
+    let latlng
+    let latlngs
 
     // Create a default geojson if none is provided
     if (geojson === undefined) geojson = { type: 'Feature', geometry: geometry }
@@ -1176,7 +1158,7 @@ U.DataLayer = L.Evented.extend({
   importFromUrl: async function (uri, type) {
     uri = this.map.localizeUrl(uri)
     const response = await this.map.request.get(uri)
-    if (response && response.ok) {
+    if (response?.ok) {
       this.importRaw(await response.text(), type)
     }
   },
@@ -1222,8 +1204,8 @@ U.DataLayer = L.Evented.extend({
     const options = U.Utils.CopyJSON(this.options)
     options.name = L._('Clone of {name}', { name: this.options.name })
     delete options.id
-    const geojson = U.Utils.CopyJSON(this._geojson),
-      datalayer = this.map.createDataLayer(options)
+    const geojson = U.Utils.CopyJSON(this._geojson)
+    const datalayer = this.map.createDataLayer(options)
     datalayer.fromGeoJSON(geojson)
     return datalayer
   },
@@ -1272,28 +1254,28 @@ U.DataLayer = L.Evented.extend({
     if (!this.map.editEnabled || !this.isLoaded()) {
       return
     }
-    const container = L.DomUtil.create('div', 'umap-layer-properties-container'),
-      metadataFields = [
-        'options.name',
-        'options.description',
-        ['options.type', { handler: 'LayerTypeChooser', label: L._('Type of layer') }],
-        ['options.displayOnLoad', { label: L._('Display on load'), handler: 'Switch' }],
-        [
-          'options.browsable',
-          {
-            label: L._('Data is browsable'),
-            handler: 'Switch',
-            helpEntries: 'browsable',
-          },
-        ],
-        [
-          'options.inCaption',
-          {
-            label: L._('Show this layer in the caption'),
-            handler: 'Switch',
-          },
-        ],
-      ]
+    const container = L.DomUtil.create('div', 'umap-layer-properties-container')
+    const metadataFields = [
+      'options.name',
+      'options.description',
+      ['options.type', { handler: 'LayerTypeChooser', label: L._('Type of layer') }],
+      ['options.displayOnLoad', { label: L._('Display on load'), handler: 'Switch' }],
+      [
+        'options.browsable',
+        {
+          label: L._('Data is browsable'),
+          handler: 'Switch',
+          helpEntries: 'browsable',
+        },
+      ],
+      [
+        'options.inCaption',
+        {
+          label: L._('Show this layer in the caption'),
+          handler: 'Switch',
+        },
+      ],
+    ]
     L.DomUtil.createTitle(container, L._('Layer properties'), 'icon-layers')
     let builder = new U.FormBuilder(this, metadataFields, {
       callback: function (e) {
@@ -1318,7 +1300,7 @@ U.DataLayer = L.Evented.extend({
       layerProperties.appendChild(builder.build())
     }
 
-    let shapeOptions = [
+    const shapeOptions = [
       'options.color',
       'options.iconClass',
       'options.iconUrl',
@@ -1337,7 +1319,7 @@ U.DataLayer = L.Evented.extend({
     const shapeProperties = L.DomUtil.createFieldset(container, L._('Shape properties'))
     shapeProperties.appendChild(builder.build())
 
-    let optionsFields = [
+    const optionsFields = [
       'options.smoothFactor',
       'options.dashArray',
       'options.zoomTo',
@@ -1484,23 +1466,23 @@ U.DataLayer = L.Evented.extend({
   },
 
   getOption: function (option, feature) {
-    if (this.layer && this.layer.getOption) {
+    if (this.layer?.getOption) {
       const value = this.layer.getOption(option, feature)
       if (typeof value !== 'undefined') return value
     }
     if (typeof this.getOwnOption(option) !== 'undefined') {
       return this.getOwnOption(option)
-    } else if (this.layer && this.layer.defaults && this.layer.defaults[option]) {
+    }
+    if (this.layer?.defaults?.[option]) {
       return this.layer.defaults[option]
-    } else {
-      return this.map.getOption(option, feature)
     }
+    return this.map.getOption(option, feature)
   },
 
   buildVersionsFieldset: async function (container) {
     const appendVersion = (data) => {
-      const date = new Date(parseInt(data.at, 10))
-      const content = `${date.toLocaleString(L.lang)} (${parseInt(data.size) / 1000}Kb)`
+      const date = new Date(Number.parseInt(data.at, 10))
+      const content = `${date.toLocaleString(L.lang)} (${Number.parseInt(data.size) / 1000}Kb)`
       const el = L.DomUtil.create('div', 'umap-datalayer-version', versionsContainer)
       const button = L.DomUtil.createButton(
         '',
@@ -1576,7 +1558,7 @@ U.DataLayer = L.Evented.extend({
 
   // Is this layer type browsable in theorie
   isBrowsable: function () {
-    return this.layer && this.layer.browsable
+    return this.layer?.browsable
   },
 
   // Is this layer browsable in theorie
@@ -1757,6 +1739,16 @@ U.DataLayer = L.Evented.extend({
     const editor = new U.TableEditor(this)
     editor.edit()
   },
+
+  getFilterKeys: function () {
+    // This keys will be used to filter feature from the browser text input.
+    // By default, it will we use the "name" property, which is also the one used as label in the features list.
+    // When map owner has configured another label or sort key, we try to be smart and search in the same keys.
+    if (this.map.options.filterKey) return this.map.options.filterKey
+    if (this.options.labelKey) return this.options.labelKey
+    if (this.map.options.sortKey) return this.map.options.sortKey
+    return 'name'
+  },
 })
 
 L.TileLayer.include({

umap/static/umap/js/umap.permissions.js

@@ -12,16 +12,13 @@ U.MapPermissions = L.Class.extend({
     this.setOptions(map.options.permissions)
     this.map = map
     let isDirty = false
-    const self = this
     try {
       Object.defineProperty(this, 'isDirty', {
-        get: function () {
-          return isDirty
-        },
-        set: function (status) {
+        get: () => isDirty,
+        set: (status) => {
           isDirty = status
           if (status) {
-            self.map.isDirty = status
+            this.map.isDirty = status
           }
         },
       })
@@ -38,7 +35,7 @@ U.MapPermissions = L.Class.extend({
     return (
       this.map.options.user &&
       this.map.options.permissions.owner &&
-      this.map.options.user.id == this.map.options.permissions.owner.id
+      this.map.options.user.id === this.map.options.permissions.owner.id
     )
   },
 
@@ -154,7 +151,7 @@ U.MapPermissions = L.Class.extend({
     if (this.isOwner() || this.isAnonymousMap())
       formData.append('edit_status', this.options.edit_status)
     if (this.isOwner()) {
-      formData.append('owner', this.options.owner && this.options.owner.id)
+      formData.append('owner', this.options.owner?.id)
       formData.append('share_status', this.options.share_status)
     }
     const [data, response, error] = await this.map.server.post(
@@ -183,7 +180,7 @@ U.MapPermissions = L.Class.extend({
   },
 
   addOwnerLink: function (element, container) {
-    if (this.options.owner && this.options.owner.name && this.options.owner.url) {
+    if (this.options.owner?.name && this.options.owner.url) {
       const ownerContainer = L.DomUtil.add(
         element,
         'umap-map-owner',