umap-project 3.1.2__py3-none-any.whl → 3.2.0__py3-none-any.whl

umap/static/umap/vendors/betterknown/betterknown.mjs

@@ -0,0 +1,287 @@
+var l = Object.defineProperty;
+var d = (t, n, e) => n in t ? l(t, n, { enumerable: !0, configurable: !0, writable: !0, value: e }) : t[n] = e;
+var p = (t, n, e) => (d(t, typeof n != "symbol" ? n + "" : n, e), e);
+const M = [
+  "Point",
+  "LineString",
+  "Polygon",
+  "MultiPoint",
+  "MultiLineString",
+  "MultiPolygon",
+  "GeometryCollection"
+], f = ["ZM", "Z", "M"], s = "EMPTY";
+class G {
+  constructor(n) {
+    p(this, "value");
+    p(this, "position");
+    this.value = n.toUpperCase(), this.position = 0;
+  }
+  match(n) {
+    this.skipWhitespaces();
+    for (const e of n) {
+      const r = e.toUpperCase();
+      if (this.value.startsWith(r, this.position))
+        return this.position += r.length, e;
+    }
+    return null;
+  }
+  matchRegex(n) {
+    this.skipWhitespaces();
+    for (const e of n) {
+      const r = this.value.substring(this.position).match(e);
+      if (r)
+        return this.position += r[0].length, r;
+    }
+    return null;
+  }
+  isMatch(n) {
+    return this.skipWhitespaces(), this.value.startsWith(n, this.position) ? (this.position += n.length, !0) : !1;
+  }
+  matchType() {
+    const n = this.match(M);
+    if (!n)
+      throw new Error("Expected geometry type");
+    return n;
+  }
+  matchDimension() {
+    switch (this.match(f)) {
+      case "ZM":
+        return { hasZ: !0, hasM: !0 };
+      case "Z":
+        return { hasZ: !0, hasM: !1 };
+      case "M":
+        return { hasZ: !1, hasM: !0 };
+      default:
+        return { hasZ: !1, hasM: !1 };
+    }
+  }
+  expectGroupStart() {
+    if (!this.isMatch("("))
+      throw new Error("Expected group start");
+  }
+  expectGroupEnd() {
+    if (!this.isMatch(")"))
+      throw new Error("Expected group end");
+  }
+  matchCoordinate(n) {
+    let e;
+    if (n.hasZ && n.hasM ? e = this.matchRegex([/^(\S*)\s+(\S*)\s+(\S*)\s+([^\s,)]*)/i]) : n.hasZ || n.hasM ? e = this.matchRegex([/^(\S*)\s+(\S*)\s+([^\s,)]*)/i]) : e = this.matchRegex([/^(\S*)\s+([^\s,)]*)/i]), !e)
+      throw new Error("Expected coordinates");
+    const r = n.hasZ && n.hasM ? [
+      parseFloat(e[1]),
+      parseFloat(e[2]),
+      parseFloat(e[3]),
+      parseFloat(e[4])
+    ] : n.hasZ ? [parseFloat(e[1]), parseFloat(e[2]), parseFloat(e[3])] : n.hasM ? [
+      parseFloat(e[1]),
+      parseFloat(e[2])
+    ] : [parseFloat(e[1]), parseFloat(e[2])];
+    if (n.srid && n.srid !== 4326) {
+      if (n.proj)
+        return n.proj(`EPSG:${n.srid}`, "EPSG:4326", r);
+      throw new Error(
+        `EWKT data in an unknown SRID (${n.srid}) was provided, but a proj function was not`
+      );
+    }
+    return r;
+  }
+  matchCoordinates(n) {
+    const e = [];
+    do {
+      const r = this.isMatch("(");
+      e.push(this.matchCoordinate(n)), r && this.expectGroupEnd();
+    } while (this.isMatch(","));
+    return e;
+  }
+  skipWhitespaces() {
+    for (; this.position < this.value.length && this.value[this.position] === " "; )
+      this.position++;
+  }
+}
+const g = (t, n) => {
+  if (t.isMatch(s))
+    return n.emptyAsNull ? null : { type: "Point", coordinates: [] };
+  t.expectGroupStart();
+  const e = t.matchCoordinate(n);
+  return t.expectGroupEnd(), {
+    type: "Point",
+    coordinates: e
+  };
+}, E = (t, n) => {
+  if (t.isMatch(s))
+    return n.emptyAsNull ? null : { type: "LineString", coordinates: [] };
+  t.expectGroupStart();
+  const e = t.matchCoordinates(n);
+  return t.expectGroupEnd(), {
+    type: "LineString",
+    coordinates: e
+  };
+}, m = (t, n) => {
+  if (t.isMatch(s))
+    return n.emptyAsNull ? null : { type: "Polygon", coordinates: [] };
+  const e = [];
+  for (t.expectGroupStart(), t.expectGroupStart(), e.push(t.matchCoordinates(n)), t.expectGroupEnd(); t.isMatch(","); )
+    t.expectGroupStart(), e.push(t.matchCoordinates(n)), t.expectGroupEnd();
+  return t.expectGroupEnd(), {
+    type: "Polygon",
+    coordinates: e
+  };
+}, S = (t, n) => {
+  if (t.isMatch(s))
+    return n.emptyAsNull ? null : { type: "MultiPoint", coordinates: [] };
+  t.expectGroupStart();
+  const e = t.matchCoordinates(n);
+  return t.expectGroupEnd(), {
+    type: "MultiPoint",
+    coordinates: e
+  };
+}, y = (t, n) => {
+  if (t.isMatch(s))
+    return n.emptyAsNull ? null : { type: "MultiLineString", coordinates: [] };
+  t.expectGroupStart();
+  const e = [];
+  do
+    t.expectGroupStart(), e.push(t.matchCoordinates(n)), t.expectGroupEnd();
+  while (t.isMatch(","));
+  return t.expectGroupEnd(), {
+    type: "MultiLineString",
+    coordinates: e
+  };
+}, x = (t, n) => {
+  if (t.isMatch(s))
+    return n.emptyAsNull ? null : { type: "MultiPolygon", coordinates: [] };
+  t.expectGroupStart();
+  const e = [];
+  do {
+    t.expectGroupStart();
+    const r = [], o = [];
+    for (t.expectGroupStart(), r.push.apply(r, t.matchCoordinates(n)), t.expectGroupEnd(); t.isMatch(","); )
+      t.expectGroupStart(), o.push(t.matchCoordinates(n)), t.expectGroupEnd();
+    e.push([r, ...o]), t.expectGroupEnd();
+  } while (t.isMatch(","));
+  return t.expectGroupEnd(), {
+    type: "MultiPolygon",
+    coordinates: e
+  };
+}, P = (t, n) => {
+  if (t.isMatch(s))
+    return n.emptyAsNull ? null : { type: "GeometryCollection", geometries: [] };
+  t.expectGroupStart();
+  const e = [];
+  do {
+    const r = u(t, n);
+    r && e.push(r);
+  } while (t.isMatch(","));
+  return t.expectGroupEnd(), {
+    type: "GeometryCollection",
+    geometries: e
+  };
+};
+function c(t) {
+  return t.join(" ");
+}
+function a(t) {
+  if (t === void 0)
+    return " ";
+  switch (t.length) {
+    case 3:
+      return " Z ";
+    default:
+      return " ";
+  }
+}
+function T(t) {
+  return t.coordinates.length === 0 ? "POINT EMPTY" : `POINT${a(t.coordinates)}(${c(
+    t.coordinates
+  )})`;
+}
+function L(t) {
+  return t.coordinates.length === 0 ? "MULTIPOINT EMPTY" : `MULTIPOINT${a(
+    t.coordinates[0]
+  )}(${t.coordinates.map((n) => c(n)).join(",")})`;
+}
+function N(t) {
+  if (t.coordinates.length === 0)
+    return "LINESTRING EMPTY";
+  const n = `(${t.coordinates.map((e) => c(e)).join(",")})`;
+  return `LINESTRING${a(t.coordinates[0])}${n}`;
+}
+function C(t) {
+  return t.geometries.length === 0 ? "GEOMETRYCOLLECTION EMPTY" : `GEOMETRYCOLLECTION${`(${t.geometries.map((e) => O(e)).join(",")})`}`;
+}
+function I(t) {
+  if (t.coordinates.length === 0)
+    return "MULTILINESTRING EMPTY";
+  const n = `(${t.coordinates.map((e) => `(${e.map((r) => c(r))})`)})`;
+  return `MULTILINESTRING${a(t.coordinates[0][0])}${n}`;
+}
+function W(t) {
+  var e;
+  if (t.coordinates.length === 0)
+    return "POLYGON EMPTY";
+  const n = `(${t.coordinates.map((r) => `(${r.map((o) => c(o))})`)})`;
+  return `POLYGON${a((e = t.coordinates[0]) == null ? void 0 : e[0])}${n}`;
+}
+function $(t) {
+  var e, r;
+  if (t.coordinates.length === 0)
+    return "MULTIPOLYGON EMPTY";
+  const n = `(${t.coordinates.map((o) => `(${o.map((h) => `(${h.map((i) => c(i))})`)})`)})`;
+  return `MULTIPOLYGON${a(
+    (r = (e = t.coordinates[0]) == null ? void 0 : e[0]) == null ? void 0 : r[0]
+  )}${n}`;
+}
+function u(t, n) {
+  let e = null;
+  const r = t.matchRegex([/^SRID=(\d+);/i]);
+  r && (e = parseInt(r[1], 10));
+  const o = t.matchType(), h = t.matchDimension(), i = {
+    ...n,
+    srid: e,
+    hasZ: h.hasZ,
+    hasM: h.hasM
+  };
+  switch (o) {
+    case "Point":
+      return g(t, i);
+    case "LineString":
+      return E(t, i);
+    case "Polygon":
+      return m(t, i);
+    case "MultiPoint":
+      return S(t, i);
+    case "MultiLineString":
+      return y(t, i);
+    case "MultiPolygon":
+      return x(t, i);
+    case "GeometryCollection":
+      return P(t, i);
+  }
+}
+function O(t) {
+  switch (t.type) {
+    case "Point":
+      return T(t);
+    case "LineString":
+      return N(t);
+    case "MultiPoint":
+      return L(t);
+    case "GeometryCollection":
+      return C(t);
+    case "Polygon":
+      return W(t);
+    case "MultiPolygon":
+      return $(t);
+    case "MultiLineString":
+      return I(t);
+  }
+}
+function Z(t, n = {
+  emptyAsNull: !0
+}) {
+  return u(new G(t), n);
+}
+export {
+  O as geoJSONToWkt,
+  Z as wktToGeoJSON
+};

umap/storage/fs.py

@@ -79,7 +79,7 @@ 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, dry_run=False):
         root = self._base_path(instance)
         versions = self.list_versions(instance)
         if keep is not None:
@@ -92,7 +92,8 @@ class FSDataStorage(FileSystemStorage):
             if keep is not None and instance.geojson.name.endswith(name):
                 continue
             try:
-                self.delete(root / name)
+                if not dry_run:
+                    self.delete(root / name)
             except FileNotFoundError:
                 pass
             else:

umap/templates/base.html

@@ -1,7 +1,10 @@
 {% load umap_tags i18n static %}
 
+{% get_current_language as LANGUAGE_CODE %}
+
 <!DOCTYPE html>
-<html {% if LANGUAGE_BIDI %}dir="rtl"{% endif %}>
+<html {% if LANGUAGE_BIDI %}dir="rtl"{% endif %}
+      lang="{{ LANGUAGE_CODE }}">
   <head>
     <title>
       {% block head_title %}

umap/tests/base.py

@@ -128,7 +128,15 @@ class DataLayerFactory(factory.django.DjangoModelFactory):
     def _adjust_kwargs(cls, **kwargs):
         if "data" in kwargs:
             data = copy.deepcopy(kwargs.pop("data"))
-            data.setdefault("_umap_options", {})
+            data.setdefault(
+                "_umap_options",
+                {
+                    "fields": [
+                        {"key": "name", "type": "String"},
+                        {"key": "description", "type": "Text"},
+                    ]
+                },
+            )
             if "name" in data["_umap_options"] and kwargs["name"] == cls.name:
                 kwargs["name"] = data["_umap_options"]["name"]
             kwargs.setdefault("settings", {})

umap/tests/integration/test_basics.py

@@ -43,7 +43,7 @@ def test_create_map_with_cursor(page, live_server, tilelayer):
             "margin-left: -16px; "
             "margin-top: -40px; "
             "transform: translate3d(200px, 200px, 0px); "
-            "z-index: 200;"
+            "z-index: 0;"
         ),
     )
 

umap/tests/integration/test_conditional_rules.py

@@ -27,6 +27,7 @@ DATALAYER_DATA1 = {
                 "myboolean": True,
                 "mydate": "2024/04/14 12:19:17",
                 "maybeempty": "not empty",
+                "onlyinone": "blah",
             },
             "geometry": {"type": "Point", "coordinates": [0.065918, 48.385442]},
         },
@@ -39,6 +40,7 @@ DATALAYER_DATA1 = {
                 "myboolean": False,
                 "mydate": "2024/03/13 12:20:20",
                 "maybeempty": "",
+                "onlyinone": "ffff",
             },
             "geometry": {"type": "Point", "coordinates": [3.55957, 49.767074]},
         },
@@ -95,7 +97,7 @@ DATALAYER_DATA2 = {
 
 def test_simple_equal_rule_at_load(live_server, page, map):
     map.settings["properties"]["rules"] = [
-        {"condition": "mytype=odd", "options": {"color": "aliceblue"}}
+        {"condition": "mytype=odd", "properties": {"color": "aliceblue"}}
     ]
     map.save()
     DataLayerFactory(map=map, data=DATALAYER_DATA1)
@@ -109,7 +111,7 @@ def test_simple_equal_rule_at_load(live_server, page, map):
 
 def test_simple_not_equal_rule_at_load(live_server, page, map):
     map.settings["properties"]["rules"] = [
-        {"condition": "mytype!=even", "options": {"color": "aliceblue"}}
+        {"condition": "mytype!=even", "properties": {"color": "aliceblue"}}
     ]
     map.save()
     DataLayerFactory(map=map, data=DATALAYER_DATA1)
@@ -123,7 +125,7 @@ def test_simple_not_equal_rule_at_load(live_server, page, map):
 
 def test_gt_rule_with_number_at_load(live_server, page, map):
     map.settings["properties"]["rules"] = [
-        {"condition": "mynumber>10", "options": {"color": "aliceblue"}}
+        {"condition": "mynumber>10", "properties": {"color": "aliceblue"}}
     ]
     map.save()
     DataLayerFactory(map=map, data=DATALAYER_DATA1)
@@ -137,7 +139,7 @@ def test_gt_rule_with_number_at_load(live_server, page, map):
 
 def test_lt_rule_with_number_at_load(live_server, page, map):
     map.settings["properties"]["rules"] = [
-        {"condition": "mynumber<14", "options": {"color": "aliceblue"}}
+        {"condition": "mynumber<14", "properties": {"color": "aliceblue"}}
     ]
     map.save()
     DataLayerFactory(map=map, data=DATALAYER_DATA1)
@@ -151,7 +153,7 @@ def test_lt_rule_with_number_at_load(live_server, page, map):
 
 def test_lt_rule_with_float_at_load(live_server, page, map):
     map.settings["properties"]["rules"] = [
-        {"condition": "mynumber<12.3", "options": {"color": "aliceblue"}}
+        {"condition": "mynumber<12.3", "properties": {"color": "aliceblue"}}
     ]
     map.save()
     DataLayerFactory(map=map, data=DATALAYER_DATA1)
@@ -165,7 +167,7 @@ def test_lt_rule_with_float_at_load(live_server, page, map):
 
 def test_equal_rule_with_boolean_at_load(live_server, page, map):
     map.settings["properties"]["rules"] = [
-        {"condition": "myboolean=true", "options": {"color": "aliceblue"}}
+        {"condition": "myboolean=true", "properties": {"color": "aliceblue"}}
     ]
     map.save()
     DataLayerFactory(map=map, data=DATALAYER_DATA1)
@@ -179,7 +181,7 @@ def test_equal_rule_with_boolean_at_load(live_server, page, map):
 
 def test_equal_rule_with_boolean_not_true_at_load(live_server, page, map):
     map.settings["properties"]["rules"] = [
-        {"condition": "myboolean!=true", "options": {"color": "aliceblue"}}
+        {"condition": "myboolean!=true", "properties": {"color": "aliceblue"}}
     ]
     map.save()
     DataLayerFactory(map=map, data=DATALAYER_DATA1)
@@ -193,7 +195,7 @@ def test_equal_rule_with_boolean_not_true_at_load(live_server, page, map):
 
 def test_equal_rule_with_boolean_false_at_load(live_server, page, map):
     map.settings["properties"]["rules"] = [
-        {"condition": "myboolean=false", "options": {"color": "aliceblue"}}
+        {"condition": "myboolean=false", "properties": {"color": "aliceblue"}}
     ]
     map.save()
     DataLayerFactory(map=map, data=DATALAYER_DATA1)
@@ -207,7 +209,7 @@ def test_equal_rule_with_boolean_false_at_load(live_server, page, map):
 
 def test_equal_rule_with_boolean_not_false_at_load(live_server, page, map):
     map.settings["properties"]["rules"] = [
-        {"condition": "myboolean!=false", "options": {"color": "aliceblue"}}
+        {"condition": "myboolean!=false", "properties": {"color": "aliceblue"}}
     ]
     map.save()
     DataLayerFactory(map=map, data=DATALAYER_DATA1)
@@ -221,7 +223,7 @@ def test_equal_rule_with_boolean_not_false_at_load(live_server, page, map):
 
 def test_empty_rule_at_load(live_server, page, map):
     map.settings["properties"]["rules"] = [
-        {"condition": "maybeempty=", "options": {"color": "aliceblue"}}
+        {"condition": "maybeempty=", "properties": {"color": "aliceblue"}}
     ]
     map.save()
     DataLayerFactory(map=map, data=DATALAYER_DATA1)
@@ -235,7 +237,7 @@ def test_empty_rule_at_load(live_server, page, map):
 
 def test_not_empty_rule_at_load(live_server, page, map):
     map.settings["properties"]["rules"] = [
-        {"condition": "maybeempty!=", "options": {"color": "aliceblue"}}
+        {"condition": "maybeempty!=", "properties": {"color": "aliceblue"}}
     ]
     map.save()
     DataLayerFactory(map=map, data=DATALAYER_DATA1)
@@ -270,7 +272,7 @@ def test_can_create_new_rule(live_server, page, openmap):
 
 def test_can_deactive_rule_from_list(live_server, page, openmap):
     openmap.settings["properties"]["rules"] = [
-        {"condition": "mytype=odd", "options": {"color": "aliceblue"}}
+        {"condition": "mytype=odd", "properties": {"color": "aliceblue"}}
     ]
     openmap.save()
     DataLayerFactory(map=openmap, data=DATALAYER_DATA1)
@@ -299,9 +301,17 @@ def test_autocomplete_datalist(live_server, page, openmap):
     page.get_by_role("button", name="Add rule").click()
     panel = page.locator(".panel.right.on")
     datalist = panel.locator(".umap-field-condition datalist option")
-    expect(datalist).to_have_count(6)
+    expect(datalist).to_have_count(7)
     values = {option.inner_text() for option in datalist.all()}
-    assert values == {"myboolean", "mytype", "mynumber", "mydate", "name", "maybeempty"}
+    assert values == {
+        "myboolean",
+        "mytype",
+        "mynumber",
+        "mydate",
+        "name",
+        "maybeempty",
+        "onlyinone",
+    }
     page.get_by_placeholder("key=value or key!=value").fill("mytype")
     expect(datalist).to_have_count(4)
     values = {option.inner_text() for option in datalist.all()}
@@ -314,8 +324,8 @@ def test_autocomplete_datalist(live_server, page, openmap):
 
 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"}},
+        {"condition": "mytype=odd", "properties": {"color": "aliceblue"}},
+        {"condition": "mynumber>10", "properties": {"iconClass": "Drop"}},
     ]
     map.save()
     DataLayerFactory(map=map, data=DATALAYER_DATA1)
@@ -333,8 +343,8 @@ def test_can_combine_rules(live_server, page, map):
 
 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"}},
+        {"condition": "mytype=odd", "properties": {"color": "aliceblue"}},
+        {"condition": "mytype!=even", "properties": {"color": "darkred"}},
     ]
     map.save()
     DataLayerFactory(map=map, data=DATALAYER_DATA1)
@@ -348,12 +358,12 @@ def test_first_matching_rule_wins_on_given_property(live_server, page, map):
 
 def test_rules_from_datalayer(live_server, page, map):
     map.settings["properties"]["rules"] = [
-        {"condition": "mytype=odd", "options": {"color": "darkred"}}
+        {"condition": "mytype=odd", "properties": {"color": "darkred"}}
     ]
     map.save()
     data = deepcopy(DATALAYER_DATA1)
     data["_umap_options"]["rules"] = [
-        {"condition": "mytype=odd", "options": {"color": "aliceblue"}}
+        {"condition": "mytype=odd", "properties": {"color": "aliceblue"}}
     ]
     DataLayerFactory(map=map, data=data)
     DataLayerFactory(map=map, data=DATALAYER_DATA2)
@@ -365,3 +375,35 @@ def test_rules_from_datalayer(live_server, page, map):
     assert colors.count("rgb(240, 248, 255)") == 1
     # Dark Red as for map global rules
     assert colors.count("rgb(139, 0, 0)") == 2
+
+
+def test_rules_in_caption(live_server, page, map):
+    map.settings["properties"]["rules"] = [
+        {
+            "condition": "mytype=odd",
+            "name": "Rule shown twice",
+            "properties": {"color": "darkred"},
+        },
+        {
+            "condition": "onlyinone=fff",
+            "name": "Rule shown once",
+            "properties": {"color": "darkred"},
+        },
+    ]
+    map.settings["properties"]["onLoadPanel"] = "caption"
+    map.save()
+    data = deepcopy(DATALAYER_DATA1)
+    data["_umap_options"]["rules"] = [
+        {
+            "condition": "myboolean=true",
+            "name": "Rule shown also once",
+            "properties": {"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")
+    panel = page.locator(".panel.left.on")
+    expect(panel.get_by_text("Rule shown twice")).to_have_count(2)
+    expect(panel.get_by_text("Rule shown once")).to_have_count(1)
+    expect(panel.get_by_text("Rule shown also once")).to_have_count(1)

umap/tests/integration/test_edit_datalayer.py

@@ -221,7 +221,7 @@ def test_deleting_datalayer_should_remove_from_caption(
 def test_can_edit_datalayer_name_in_list(live_server, openmap, datalayer, page):
     page.goto(f"{live_server.url}{openmap.get_absolute_url()}?edit")
     page.get_by_role("button", name="Manage layers").click()
-    page.get_by_text("test datalayer").click()
+    page.get_by_text("test datalayer").dblclick()
     page.get_by_text("test datalayer").fill("test datalayer foobar")
     page.get_by_role("button", name="Open browser").click()
     expect(

umap/tests/integration/test_edit_marker.py

@@ -125,7 +125,7 @@ def test_add_property_from_feature_properties_panel(
 ):
     page.goto(f"{live_server.url}{openmap.get_absolute_url()}?edit")
     page.locator(".leaflet-marker-icon").click(modifiers=["Shift"])
-    page.get_by_role("button", name="Add a new property").click()
+    page.get_by_role("button", name="Add a new field").click()
     page.locator('input[name="prompt"]').fill("newprop")
     page.get_by_role("button", name="OK").click()
     expect(page.locator(".panel.right").get_by_text("newprop")).to_be_visible()

umap/tests/integration/test_export_map.py

@@ -104,6 +104,16 @@ def test_umap_export(map, live_server, bootstrap, page):
                     "browsable": True,
                     "displayOnLoad": True,
                     "name": "test datalayer",
+                    "fields": [
+                        {
+                            "key": "name",
+                            "type": "String",
+                        },
+                        {
+                            "key": "description",
+                            "type": "Text",
+                        },
+                    ],
                 },
                 "features": [
                     {