umap-project 3.0.5__py3-none-any.whl → 3.1.0__py3-none-any.whl

umap/static/umap/map.css

@@ -151,29 +151,6 @@ html[dir="rtl"] .leaflet-tooltip-pane > * {
     min-height: 23px;
     height: 23px;
 }
-.edit-enable [type="button"]:before {
-    content: ' ';
-    width: 24px;
-    height: 24px;
-    display: inline-block;
-    vertical-align: -20%;
-    background-image: url('./img/16-white.svg');
-    background-position: -48px -48px;
-}
-.edit-enable [type="button"] {
-    width: initial;
-    padding: 0 20px;
-    background-color: #353c3e;
-    color: #fff;
-    background-image: none;
-    border-radius: 20px;
-    height: var(--control-size);
-    line-height: var(--control-size);
-    display: block;
-}
-.edit-enable [type="button"]:hover {
-    background-color: #4d5759;
-}
 .umap-permanent-credits-container {
     max-width: 20rem;
     margin-inline-start: 5px!important;
@@ -468,6 +445,9 @@ ul.photon-autocomplete {
     width: 100%;
     margin-bottom: var(--text-margin);
 }
+.umap-help-links li {
+    margin-bottom: var(--text-margin);
+}
 .umap-help {
     font-style: italic;
 }

umap/static/umap/vendors/textpath/leaflet.textpath.js

@@ -0,0 +1,184 @@
+/*
+ * Leaflet.TextPath - Shows text along a polyline
+ * Inspired by Tom Mac Wright article :
+ * https://web.archive.org/web/20130312131812/http://mapbox.com/osmdev/2012/11/20/getting-serious-about-svg/
+ */
+
+(function () {
+
+var __onAdd = L.Polyline.prototype.onAdd,
+    __onRemove = L.Polyline.prototype.onRemove,
+    __updatePath = L.Polyline.prototype._updatePath,
+    __bringToFront = L.Polyline.prototype.bringToFront;
+
+
+var PolylineTextPath = {
+
+    onAdd: function (map) {
+        __onAdd.call(this, map);
+        this._textRedraw();
+    },
+
+    onRemove: function (map) {
+        map = map || this._map;
+        if (map && this._textNode && this._renderer._container)
+            this._renderer._container.removeChild(this._textNode);
+        __onRemove.call(this, map);
+    },
+
+    bringToFront: function () {
+        __bringToFront.call(this);
+        this._textRedraw();
+    },
+
+    _updatePath: function () {
+        __updatePath.call(this);
+        this._textRedraw();
+    },
+
+    _textRedraw: function () {
+        var text = this._text,
+            options = this._textOptions;
+        if (text) {
+            this.setText(null).setText(text, options);
+        }
+    },
+
+    setText: function (text, options) {
+        this._text = text;
+        this._textOptions = options;
+
+        /* If not in SVG mode or Polyline not added to map yet return */
+        /* setText will be called by onAdd, using value stored in this._text */
+        if (!L.Browser.svg || typeof this._map === 'undefined') {
+          return this;
+        }
+
+        var defaults = {
+            repeat: false,
+            fillColor: 'black',
+            attributes: {},
+            below: false,
+        };
+        options = L.Util.extend(defaults, options);
+
+        /* If empty text, hide */
+        if (!text) {
+            if (this._textNode && this._textNode.parentNode) {
+                this._renderer._container.removeChild(this._textNode);
+                
+                /* delete the node, so it will not be removed a 2nd time if the layer is later removed from the map */
+                delete this._textNode;
+            }
+            return this;
+        }
+
+        text = text.replace(/ /g, '\u00A0');  // Non breakable spaces
+        var id = 'pathdef-' + L.Util.stamp(this);
+        var svg = this._renderer._container;
+        this._path.setAttribute('id', id);
+
+        if (options.repeat) {
+            /* Compute single pattern length */
+            var pattern = L.SVG.create('text');
+            for (var attr in options.attributes)
+                pattern.setAttribute(attr, options.attributes[attr]);
+            pattern.appendChild(document.createTextNode(text));
+            svg.appendChild(pattern);
+            var alength = pattern.getComputedTextLength();
+            svg.removeChild(pattern);
+
+            /* Create string as long as path */
+            text = new Array(Math.ceil(isNaN(this._path.getTotalLength() / alength) ? 0 : this._path.getTotalLength() / alength)).join(text);
+        }
+
+        /* Put it along the path using textPath */
+        var textNode = L.SVG.create('text'),
+            textPath = L.SVG.create('textPath');
+
+        var dy = options.offset || this._path.getAttribute('stroke-width');
+
+        textPath.setAttributeNS("http://www.w3.org/1999/xlink", "xlink:href", '#'+id);
+        textNode.setAttribute('dy', dy);
+        for (var attr in options.attributes)
+            textNode.setAttribute(attr, options.attributes[attr]);
+        textPath.appendChild(document.createTextNode(text));
+        textNode.appendChild(textPath);
+        this._textNode = textNode;
+
+        if (options.below) {
+            svg.insertBefore(textNode, svg.firstChild);
+        }
+        else {
+            svg.appendChild(textNode);
+        }
+
+        /* Center text according to the path's bounding box */
+        if (options.position === 'center' || options.center) {
+            var textLength = textNode.getComputedTextLength();
+            var pathLength = this._path.getTotalLength();
+            /* Set the position for the left side of the textNode */
+            textNode.setAttribute('dx', ((pathLength / 2) - (textLength / 2)));
+        }
+        else if (options.position === 'end') {
+            var textLength = textNode.getComputedTextLength();
+            var pathLength = this._path.getTotalLength();
+            // We add pixels to try to counter-balance the space around the character.
+            const dx = pathLength - textLength + 6
+            textNode.setAttribute('dx', dx);
+        } else {
+            // "start", which is the default.
+        }
+
+        /* Change label rotation (if required) */
+        if (options.orientation) {
+            var rotateAngle = 0;
+            switch (options.orientation) {
+                case 'flip':
+                    rotateAngle = 180;
+                    break;
+                case 'perpendicular':
+                    rotateAngle = 90;
+                    break;
+                default:
+                    rotateAngle = options.orientation;
+            }
+
+            var rotatecenterX = (textNode.getBBox().x + textNode.getBBox().width / 2);
+            var rotatecenterY = (textNode.getBBox().y + textNode.getBBox().height / 2);
+            textNode.setAttribute('transform','rotate(' + rotateAngle + ' '  + rotatecenterX + ' ' + rotatecenterY + ')');
+        }
+
+        /* Initialize mouse events for the additional nodes */
+        if (this.options.interactive) {
+            if (L.Browser.svg || !L.Browser.vml) {
+                textPath.setAttribute('class', 'leaflet-interactive');
+            }
+
+            var events = ['click', 'dblclick', 'mousedown', 'mouseover',
+                          'mouseout', 'mousemove', 'contextmenu'];
+            for (var i = 0; i < events.length; i++) {
+                L.DomEvent.on(textNode, events[i], this.fire, this);
+            }
+        }
+
+        return this;
+    }
+};
+
+L.Polyline.include(PolylineTextPath);
+
+L.LayerGroup.include({
+    setText: function(text, options) {
+        for (var layer in this._layers) {
+            if (typeof this._layers[layer].setText === 'function') {
+                this._layers[layer].setText(text, options);
+            }
+        }
+        return this;
+    }
+});
+
+
+
+})();

umap/storage/fs.py

@@ -16,9 +16,15 @@ class FSDataStorage(FileSystemStorage):
         name = "%s_%s.geojson" % (instance.pk, int(time.time() * 1000))
         return root / name
 
-    def list_versions(self, instance):
+    def _get_names(self, instance):
         root = self._base_path(instance)
-        names = self.listdir(root)[1]
+        try:
+            return self.listdir(root)[1]
+        except FileNotFoundError:
+            return []
+
+    def list_versions(self, instance):
+        names = self._get_names(instance)
         names = [name for name in names if self._is_valid_version(name, instance)]
         versions = [self._version_metadata(name, instance) for name in names]
         versions.sort(reverse=True, key=operator.itemgetter("at"))
@@ -38,12 +44,12 @@ class FSDataStorage(FileSystemStorage):
         return fullpath
 
     def onDatalayerSave(self, instance):
-        self._purge_gzip(instance)
-        self._purge_old_versions(instance, keep=settings.UMAP_KEEP_VERSIONS)
+        self.purge_gzip(instance)
+        self.purge_old_versions(instance, keep=settings.UMAP_KEEP_VERSIONS)
 
     def onDatalayerDelete(self, instance):
-        self._purge_gzip(instance)
-        self._purge_old_versions(instance, keep=None)
+        self.purge_gzip(instance)
+        self.purge_old_versions(instance, keep=None)
 
     def _extract_version_ref(self, path):
         version = path.split(".")[0]
@@ -73,11 +79,12 @@ class FSDataStorage(FileSystemStorage):
             "size": self.size(self._base_path(instance) / name),
         }
 
-    def _purge_old_versions(self, instance, keep=None):
+    def purge_old_versions(self, instance, keep=None):
         root = self._base_path(instance)
         versions = self.list_versions(instance)
         if keep is not None:
             versions = versions[keep:]
+        deleted = 0
         for version in versions:
             name = version["name"]
             # Should not be in the list, but ensure to not delete the file
@@ -88,10 +95,13 @@ class FSDataStorage(FileSystemStorage):
                 self.delete(root / name)
             except FileNotFoundError:
                 pass
+            else:
+                deleted += 1
+        return deleted
 
-    def _purge_gzip(self, instance):
+    def purge_gzip(self, instance):
         root = self._base_path(instance)
-        names = self.listdir(root)[1]
+        names = self._get_names(instance)
         prefixes = [f"{instance.pk}_"]
         if instance.old_id:
             prefixes.append(f"{instance.old_id}_")

umap/templates/umap/dashboard_menu.html

@@ -7,6 +7,11 @@
     {% else %}
       <a href="{% url 'user_dashboard' %}">{% trans "My Maps" %}</a>
     {% endif %}
+    {% if selected == "templates" %}
+      <a class="selected" href="{% url 'user_templates' %}">{% blocktranslate with count=maps.paginator.count %}My Templates ({{ count }}){% endblocktranslate %}</a>
+    {% else %}
+      <a href="{% url 'user_templates' %}">{% trans "My Templates" %}</a>
+    {% endif %}
     {% if UMAP_ALLOW_EDIT_PROFILE %}
       <a {% if selected == "profile" %}class="selected"{% endif %}
          href="{% url 'user_profile' %}">{% trans "My profile" %}</a>

umap/templates/umap/design_system.html

@@ -301,6 +301,15 @@
             </form>
           </fieldset>
         </details>
+        <details open>
+          <summary>With tabs</summary>
+          <div class="flat-tabs" data-ref="tabs">
+            <button class="flat on" data-ref="recent">Récents</button>
+            <button class="flat" data-ref="symbols">Symbole</button>
+            <button class="flat" data-ref="chars">Emoji &amp; texte</button>
+            <button class="flat" data-ref="url">URL</button>
+          </div>
+        </details>
       </div>
       <h4>Importers</h4>
       <div class="umap-dialog window importers dark">

umap/templates/umap/js.html

@@ -34,9 +34,12 @@
 <script src="{% static 'umap/vendors/iconlayers/iconLayers.js' %}" defer></script>
 <script src="{% static 'umap/vendors/locatecontrol/L.Control.Locate.min.js' %}"
         defer></script>
+<script src="{% static 'umap/vendors/textpath/leaflet.textpath.js' %}"
+        defer></script>
 <script src="{% static 'umap/vendors/simple-statistics/simple-statistics.min.js' %}"
         defer></script>
 <script src="{% static 'umap/js/umap.core.js' %}" defer></script>
 <script src="{% static 'umap/js/umap.controls.js' %}" defer></script>
 <script type="module" src="{% static 'umap/js/components/fragment.js' %}" defer></script>
+<script type="module" src="{% static 'umap/js/components/modal.js' %}" defer></script>
 {% endautoescape %}

umap/templates/umap/map_init.html

@@ -4,10 +4,12 @@
 <div id="map">
 </div>
 <!-- djlint:off -->
+<script id="map-settings" data-settings="{{ map_settings|escape }}"></script>
 <script defer type="module">
     {% autoescape off %}
     import Umap from '{% static "umap/js/modules/umap.js" %}'
     {% endautoescape %}
-    U.MAP = new Umap("map", {{ map_settings|notag|safe }})
+    U.SETTINGS = JSON.parse(document.getElementById('map-settings').dataset.settings)
+    U.MAP = new Umap("map", U.SETTINGS)
 </script>
 <!-- djlint:on -->

umap/templates/umap/map_list.html

@@ -12,14 +12,14 @@
             {% endfor %}
           </ul>
         {% endif %}
-        <h3>{{ map_inst.name }}</h3>
+        <h3>{% if map_inst.is_template %}<mark class="template-map">[{% trans "template" %}]</mark>{% endif %} {{ map_inst.name }}</h3>
         {% with author=map_inst.get_author %}
           {% if author %}
             <p>{% trans "by" %} <a href="{{ author.get_url }}">{{ author }}</a></p>
           {% endif %}
         {% endwith %}
       </div>
-      <a class="main" href="{{ map_inst.get_absolute_url }}">{% translate "See the map" %}</a>
+      <a class="main" href="{{ map_inst.get_absolute_url }}">{% if map_inst.is_template %}{% translate "See the template" %}{% else %}{% translate "See the map" %}{% endif %}</a>
     </hgroup>
   </div>
 {% endfor %}

umap/templates/umap/map_table.html

@@ -35,24 +35,24 @@
               <a href="{{ map_inst.get_absolute_url }}">{{ map_inst.name }}</a>
             </th>
             <td>
-              {{ map_inst.preview_settings|json_script:unique_id }}
-              <button class="map-icon map-opener"
-                      data-map-id="{{ unique_id }}"
-                      title="{% translate "Open preview" %}">
-                <span class="icon-dashboard icon-view"></span>
-                <span class="sr-only">{% translate "Open preview" %}</span>
-              </button>
-              <dialog>
-                <form method="dialog">
-                  <div id="{{ unique_id }}_target" class="map_fragment">
-                  </div>
-                  <p class="close-dialog">
-                    <button class="button" type="submit">
-                      Close
-                    </button>
-                  </p>
-                </form>
-              </dialog>
+              <umap-modal data-settings='{{ map_inst.preview_settings|dumps|escape }}' data-map-id="{{ unique_id }}">
+                <button class="map-icon map-opener"
+                        title="{% translate "Open preview" %}">
+                  <span class="icon-dashboard icon-view"></span>
+                  <span class="sr-only">{% translate "Open preview" %}</span>
+                </button>
+                <dialog>
+                  <form method="dialog">
+                    <div id="{{ unique_id }}_target" class="map_fragment">
+                    </div>
+                    <p class="close-dialog">
+                      <button class="button" type="submit">
+                        Close
+                      </button>
+                    </p>
+                  </form>
+                </dialog>
+              </umap-modal>
             </td>
             <td>
               {{ map_inst.get_share_status_display }}

umap/templates/umap/user_dashboard.html

@@ -6,63 +6,14 @@
   {% translate "My Dashboard" %} - {{ SITE_DESCRIPTION }}
 {% endblock head_title %}
 {% block maincontent %}
-  {% trans "Search my maps" as placeholder %}
   {% include "umap/dashboard_menu.html" with selected="maps" %}
-  <div class="wrapper">
-    <div class="row">
-      <div class="table-header">
-        <form action="{{ request.get_full_path }}" method="get">
-          <span>
-            <label class="sr-only" for="q">
-              {% translate "Map’s title" %}
-            </label>
-            <input id="q"
-                   name="q"
-                   type="search"
-                   placeholder="{% translate "Map’s title" %}"
-                   value="{{ request.GET.q|default:"" }}" />
-          </span>
-          <input type="submit" value="{% trans "Search my maps" %}" />
-        </form>
-        {% if maps.object_list|length > 1 %}
-          <a href="{% url 'user_download' %}?{% spaceless %} {% for map_inst in maps %}map_id={{ map_inst.pk }}{% if not forloop.last %}&{% endif %}{% endfor %} {% endspaceless %}"
-             class="button button-download">
-            {% blocktranslate with count=maps.object_list|length trimmed %}
-              Download {{ count }} maps
-            {% endblocktranslate %}
-          </a>
-        {% endif %}
-      </div>
-      {% if maps or request.GET.q %}
-        {% include "umap/map_table.html" %}
-      {% else %}
-        <div>
-          {% blocktrans %}You have no map yet.{% endblocktrans %} <a href="{% url 'map_new' %}">{% translate "Create a map" %}</a>
-        </div>
-      {% endif %}
-    </div>
-  </div>
+  {% trans "Search my maps" as submit_label %}
+  {% trans "Map’s name" as label_title %}
+  {% blocktranslate asvar download_label with count=maps.object_list|length trimmed %}
+    Download {{ count }} maps
+  {% endblocktranslate %}
+  {% blocktranslate asvar empty_label %}You have no map yet.{% endblocktranslate %}
+  {% translate "Create a map" as create_label %}
+  {% translate "No map found." as empty_search_label %}
+  {% include "umap/user_map_table.html" with submit_label=submit_label label_title=label_title download_label=download_label empty_label=empty_label create_label=create_label empty_search_label=empty_search_label %}
 {% endblock maincontent %}
-{% block bottom_js %}
-  {{ block.super }}
-  <script type="module">
-    {% autoescape off %}
-    import Umap from '{% static "umap/js/modules/umap.js" %}'
-    {% endautoescape %}
-    const CACHE = {}
-    for (const mapOpener of document.querySelectorAll("button.map-opener")) {
-      mapOpener.addEventListener('click', (event) => {
-        const button = event.target.closest('button')
-        button.nextElementSibling.showModal()
-        const mapId = button.dataset.mapId
-        if (!document.querySelector(`#${mapId}_target`).children.length) {
-          const previewSettings = JSON.parse(document.getElementById(mapId).textContent)
-          const map = new Umap(`${mapId}_target`, previewSettings)
-          CACHE[mapId] = map
-        } else {
-          CACHE[mapId].invalidateSize()
-        }
-      })
-    }
-  </script>
-{% endblock bottom_js %}

umap/templates/umap/user_map_table.html

@@ -0,0 +1,36 @@
+<div class="wrapper">
+  <div class="row">
+    <div class="table-header">
+      <form action="{{ request.get_full_path }}" method="get">
+        <span>
+          <label class="sr-only" for="q">
+            {{ label_title }}
+          </label>
+          <input id="q"
+                 name="q"
+                 type="search"
+                 placeholder="{{ label_title }}"
+                 value="{{ request.GET.q|default:"" }}" />
+        </span>
+        <input type="submit" value="{{ submit_label }}" />
+      </form>
+      {% if maps.object_list|length > 1 %}
+        <a href="{% url 'user_download' %}?{% spaceless %} {% for map_inst in maps %}map_id={{ map_inst.pk }}{% if not forloop.last %}&{% endif %}{% endfor %} {% endspaceless %}"
+           class="button button-download">
+          {{ download_label }}
+        </a>
+      {% endif %}
+    </div>
+    {% if maps %}
+      {% include "umap/map_table.html" %}
+    {% else %}
+      <div>
+        {% if request.GET.q or request.GET.tags %}
+          {{ empty_search_label }}
+        {% else %}
+          {{ empty_label }} <a href="{% url 'map_new' %}">{{ create_label }}</a>
+        {% endif %}
+      </div>
+    {% endif %}
+  </div>
+</div>

umap/templates/umap/user_templates.html

@@ -0,0 +1,19 @@
+{% extends "umap/content.html" %}
+
+{% load i18n static %}
+
+{% block head_title %}
+  {% translate "My Templates" %} - {{ SITE_DESCRIPTION }}
+{% endblock head_title %}
+{% block maincontent %}
+  {% include "umap/dashboard_menu.html" with selected="templates" %}
+  {% trans "Search my templates" as submit_label %}
+  {% trans "Template’s name" as label_title %}
+  {% blocktranslate asvar download_label with count=maps.object_list|length trimmed %}
+    Download {{ count }} templates
+  {% endblocktranslate %}
+  {% blocktranslate asvar empty_label %}You have no template yet.{% endblocktranslate %}
+  {% translate "Create a template" as create_label %}
+  {% translate "No template found." as empty_search_label %}
+  {% include "umap/user_map_table.html" with submit_label=submit_label label_title=label_title download_label=download_label empty_label=empty_label create_label=create_label empty_search_label=empty_search_label %}
+{% endblock maincontent %}

umap/templatetags/umap_tags.py

@@ -43,6 +43,11 @@ def tilelayer_preview(tilelayer):
     return output
 
 
+@register.filter
+def dumps(dict_):
+    return json_dumps(dict_)
+
+
 @register.filter
 def can_delete_map(map, request):
     return map.can_delete(request)

umap/tests/integration/test_basics.py

@@ -61,13 +61,21 @@ def test_cannot_put_script_tag_in_datalayer_name_or_description(
     page.locator(".umap-field-description textarea").fill(
         '<p>before <script>alert("attack")</script> after</p>'
     )
-    page.get_by_role("button", name="Save").click()
+    page.wait_for_timeout(300)  # Wait for debounce
+    with page.expect_response(re.compile(".*/datalayer/create/.*")):
+        page.get_by_role("button", name="Save").click()
     page.get_by_role("button", name="About").click()
     # Title should contain raw HTML (we are using textContent)
     expect(page.get_by_text('<script>alert("attack")</script>')).to_be_visible()
     # Description should contain escaped HTML
     expect(page.get_by_text("before after")).to_be_visible()
 
+    # Reload the map
+    page.goto(f"{live_server.url}{openmap.get_absolute_url()}")
+    page.get_by_role("button", name="About").click()
+    expect(page.get_by_text('<script>alert("attack")</script>')).to_be_visible()
+    expect(page.get_by_text("before after")).to_be_visible()
+
 
 def test_login_from_map_page(live_server, page, tilelayer, settings, user, context):
     settings.ENABLE_ACCOUNT_LOGIN = True

umap/tests/integration/test_conditional_rules.py

@@ -1,3 +1,5 @@
+from copy import deepcopy
+
 import pytest
 from playwright.sync_api import expect
 
@@ -308,3 +310,58 @@ def test_autocomplete_datalist(live_server, page, openmap):
     expect(datalist).to_have_count(2)
     values = {option.inner_text() for option in datalist.all()}
     assert values == {"mytype=even", "mytype=odd"}
+
+
+def test_can_combine_rules(live_server, page, map):
+    map.settings["properties"]["rules"] = [
+        {"condition": "mytype=odd", "options": {"color": "aliceblue"}},
+        {"condition": "mynumber>10", "options": {"iconClass": "Drop"}},
+    ]
+    map.save()
+    DataLayerFactory(map=map, data=DATALAYER_DATA1)
+    DataLayerFactory(map=map, data=DATALAYER_DATA2)
+    page.goto(f"{live_server.url}{map.get_absolute_url()}#6/48.948/1.670")
+    markers = page.locator(".leaflet-marker-icon .icon_container")
+    drops = page.locator(".umap-drop-icon .icon_container")
+    expect(markers).to_have_count(5)
+    expect(drops).to_have_count(2)
+    colors = getColors(markers)
+    assert colors.count("rgb(240, 248, 255)") == 3
+    colors = getColors(drops)
+    assert colors.count("rgb(240, 248, 255)") == 2
+
+
+def test_first_matching_rule_wins_on_given_property(live_server, page, map):
+    map.settings["properties"]["rules"] = [
+        {"condition": "mytype=odd", "options": {"color": "aliceblue"}},
+        {"condition": "mytype!=even", "options": {"color": "darkred"}},
+    ]
+    map.save()
+    DataLayerFactory(map=map, data=DATALAYER_DATA1)
+    DataLayerFactory(map=map, data=DATALAYER_DATA2)
+    page.goto(f"{live_server.url}{map.get_absolute_url()}#6/48.948/1.670")
+    markers = page.locator(".leaflet-marker-icon .icon_container")
+    expect(markers).to_have_count(5)
+    colors = getColors(markers)
+    assert colors.count("rgb(240, 248, 255)") == 3
+
+
+def test_rules_from_datalayer(live_server, page, map):
+    map.settings["properties"]["rules"] = [
+        {"condition": "mytype=odd", "options": {"color": "darkred"}}
+    ]
+    map.save()
+    data = deepcopy(DATALAYER_DATA1)
+    data["_umap_options"]["rules"] = [
+        {"condition": "mytype=odd", "options": {"color": "aliceblue"}}
+    ]
+    DataLayerFactory(map=map, data=data)
+    DataLayerFactory(map=map, data=DATALAYER_DATA2)
+    page.goto(f"{live_server.url}{map.get_absolute_url()}#6/48.948/1.670")
+    markers = page.locator(".leaflet-marker-icon .icon_container")
+    expect(markers).to_have_count(5)
+    colors = getColors(markers)
+    # Alice Blue should only affect layer 1
+    assert colors.count("rgb(240, 248, 255)") == 1
+    # Dark Red as for map global rules
+    assert colors.count("rgb(139, 0, 0)") == 2