feat: add function to decode feature properties

Signed-off-by: Aleksei Gurianov <[email protected]>

Author: Guria

src/gleojson.gleam

@@ -267,7 +267,6 @@ fn geometry_decoder(
   }
 }
 
-/// Decodes a FeatureId from a dynamic value.
 fn feature_id_decoder(
   dyn_value: dynamic.Dynamic,
 ) -> Result(FeatureId, List(dynamic.DecodeError)) {
@@ -377,3 +376,35 @@ pub fn geojson_decoder(dyn_value) -> Result(GeoJSON, List(dynamic.DecodeError))
     _ -> result.map(geometry_decoder(dyn_value), GeoJSONGeometry)
   }
 }
+
+/// Retrieves and decodes a specific property from a Feature's properties.
+///
+/// This function attempts to extract a property with the given key from the Feature's
+/// properties dictionary and decode it using the provided decoder.
+///
+/// ## Example
+///
+/// ```gleam
+/// let properties = option.Some(dict.from_list([#("height", dynamic.from(10.5))]))
+/// let result = get_feature_property(properties, "height", dynamic.float)
+/// // result will be Ok(10.5) if successful
+/// ```
+///
+/// Note: This function will return an Error if the properties are None, 
+/// if the key is not found in the properties, or if the decoder fails.
+pub fn get_feature_property(
+  properties: option.Option(dict.Dict(String, dynamic.Dynamic)),
+  key: String,
+  decoder: dynamic.Decoder(a),
+) -> Result(a, List(dynamic.DecodeError)) {
+  case properties {
+    option.Some(properties) -> {
+      dict.get(properties, key)
+    }
+    _ -> Error(Nil)
+  }
+  |> result.map_error(fn(_) {
+    [dynamic.DecodeError(expected: "Property", found: "Invalid", path: [key])]
+  })
+  |> result.try(decoder)
+}

test/gleojson_test.gleam

@@ -466,3 +466,80 @@ pub fn geometrycollection_example_test() {
 
   assert_decode(json_string, expected_geojson)
 }
+
+pub fn feature_decode_properties_test() {
+  let json_string =
+    "
+  {
+    \"type\": \"Feature\",
+    \"geometry\": {
+      \"type\": \"Point\",
+      \"coordinates\": [102.0, 0.5]
+    },
+    \"properties\": {
+      \"prop0\": \"value0\",
+      \"prop1\": 0.0,
+      \"prop2\": {
+        \"this\": \"that\"
+      },
+      \"prop3\": [1, 2, 3],
+      \"prop4\": true,
+      \"prop5\": null
+    }
+  }
+  "
+
+  let decoded_result =
+    json.decode(from: json_string, using: gleojson.geojson_decoder)
+
+  let assert Ok(gleojson.GeoJSONFeature(gleojson.Feature(
+    geometry,
+    properties,
+    id,
+  ))) = decoded_result
+
+  geometry
+  |> should.be_some
+  |> should.equal(gleojson.Point([102.0, 0.5]))
+
+  id
+  |> should.be_none
+
+  gleojson.get_feature_property(properties, "prop0", dynamic.string)
+  |> should.be_ok
+  |> should.equal("value0")
+
+  gleojson.get_feature_property(properties, "prop1", dynamic.float)
+  |> should.be_ok
+  |> should.equal(0.0)
+
+  gleojson.get_feature_property(
+    properties,
+    "prop2",
+    dynamic.dict(of: dynamic.string, to: dynamic.string),
+  )
+  |> should.be_ok
+  |> should.equal(dict.from_list([#("this", "that")]))
+
+  gleojson.get_feature_property(properties, "prop3", dynamic.list(dynamic.int))
+  |> should.be_ok
+  |> should.equal([1, 2, 3])
+
+  gleojson.get_feature_property(properties, "prop4", dynamic.bool)
+  |> should.be_ok
+  |> should.equal(True)
+
+  gleojson.get_feature_property(
+    properties,
+    "prop5",
+    dynamic.optional(dynamic.dynamic),
+  )
+  |> should.be_ok
+  |> should.equal(option.None)
+
+  gleojson.get_feature_property(properties, "missing", dynamic.string)
+  |> should.be_error
+
+  gleojson.get_feature_property(properties, "prop0", dynamic.float)
+  |> should.be_error
+}