[Map] markers, polygons and polylines removal

src/Map/CHANGELOG.md

@@ -1,5 +1,11 @@
 # CHANGELOG
-
+
+## 2.23
+-   Add property `$identifier` to marker, polygon and polyline
+-   Add method `Symfony\UX\Map::removeMarker(Marker $marker)`, to allow removal of a marker from its identifier
+-   Add method `Symfony\UX\Map::removePolygon(Polygon $polygon)`, to allow removal of a polygon from its identifier
+-   Add method `Symfony\UX\Map::removePolyline(Polyline $polyline)`, to allow removal of a polyline from its identifier
+
 ## 2.22
 
 -   Add method `Symfony\UX\Map\Renderer\AbstractRenderer::tapOptions()`, to allow Renderer to modify options before rendering a Map.

src/Map/doc/index.rst

@@ -136,6 +136,29 @@ You can add markers to a map using the ``addMarker()`` method::
         ))
     ;
 
+Remove elements from Map
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+You can remove markers, polygons and polylines from a map using the ``removeMarker(Marker $marker)``, ``removePolyline(Polyline $polyline)`` and ``removePolygon(Polygon $polygon)`` methods::
+
+When you create Marker, Polygon or Polyne, you can add an identifier in construct : 
+
+    $departureMarker = new Marker (
+        position: new Point(45.7640, 4.8357),
+        title: 'Lyon',
+        identifier: 'departure'
+    )
+
+then retrieve the marker with ``Map::getMarker(string $identifier)``, also works with ``Map::getPolygon(string $identifier)`` and ``Map::getPolyline(string $identifier)``. It can be useful to remove an element from its identifier.
+
+    $map->addMarker($departureMarker);
+
+    // remove marker with
+    $map->removeMarker($departureMarker)
+    // or 
+    $map->removeMarker($map->getMarker('departure'));
+
+
 Add Polygons
 ~~~~~~~~~~~~
 

src/Map/src/Map.php

@@ -11,6 +11,7 @@
 
 namespace Symfony\UX\Map;
 
+use SplObjectStorage;
 use Symfony\UX\Map\Exception\InvalidArgumentException;
 
 /**
@@ -29,19 +30,18 @@ public function __construct(
         /**
          * @var array<Marker>
          */
-        private array $markers = [],
+        private SplObjectStorage $markers = new SplObjectStorage(),
 
         /**
          * @var array<Polygon>
          */
-        private array $polygons = [],
+        private SplObjectStorage $polygons = new SplObjectStorage(),
 
         /**
          * @var array<Polyline>
          */
-        private array $polylines = [],
-    ) {
-    }
+        private SplObjectStorage $polylines = new SplObjectStorage(),
+    ) {}
 
     public function getRendererName(): ?string
     {
@@ -86,23 +86,99 @@ public function hasOptions(): bool
         return null !== $this->options;
     }
 
+
+    public function getMarker(string $identifier): ?Marker
+    {
+        foreach ($this->markers as $marker) {
+            if ($this->markers->offsetGet($marker) === $identifier) {
+                return $marker;
+            }
+        }
+
+        return null;
+    }
+
     public function addMarker(Marker $marker): self
     {
-        $this->markers[] = $marker;
+        $this->markers->attach($marker, $marker->identifier ?? $this->markers->getHash($marker));
+
+
+        return $this;
+    }
+
+    public function removeMarker(?Marker $marker): self
+    {
+        if ($marker === null) {
+            return $this;
+        }
+
+        if ($this->markers->contains($marker)) {
+            $this->markers->detach($marker);
+        }
 
         return $this;
     }
 
+
+    public function getPolygon(string $identifier): ?Polygon
+    {
+        foreach ($this->polygons as $polygon) {
+            if ($this->polygons->offsetGet($polygon) === $identifier) {
+                return $polygon;
+            }
+        }
+
+        return null;
+    }
+
     public function addPolygon(Polygon $polygon): self
     {
-        $this->polygons[] = $polygon;
+        $this->polygons->attach($polygon, $polygon->identifier ?? $this->polygons->getHash($polygon));
 
         return $this;
     }
 
+    public function removePolygon(?Polygon $polygon): self
+    {
+        if ($polygon === null) {
+            return $this;
+        }
+
+        if ($this->polygons->contains($polygon)) {
+            $this->polygons->detach($polygon);
+        }
+
+        return $this;
+    }
+
+
+    public function getPolyline(string $identifier): ?Polyline
+    {
+        foreach ($this->polylines as $polyline) {
+            if ($this->polylines->offsetGet($polyline) === $identifier) {
+                return $polyline;
+            }
+        }
+
+        return null;
+    }
+
     public function addPolyline(Polyline $polyline): self
     {
-        $this->polylines[] = $polyline;
+        $this->polylines->attach($polyline, $polyline->identifier ?? $this->polylines->getHash($polyline));
+
+        return $this;
+    }
+
+    public function removePolyline(?Polyline $polyline): self
+    {
+        if ($polyline === null) {
+            return $this;
+        }
+
+        if ($this->polylines->contains($polyline)) {
+            $this->polylines->detach($polyline);
+        }
 
         return $this;
     }
@@ -124,12 +200,73 @@ public function toArray(): array
             'zoom' => $this->zoom,
             'fitBoundsToMarkers' => $this->fitBoundsToMarkers,
             'options' => $this->options ? MapOptionsNormalizer::normalize($this->options) : [],
-            'markers' => array_map(static fn (Marker $marker) => $marker->toArray(), $this->markers),
-            'polygons' => array_map(static fn (Polygon $polygon) => $polygon->toArray(), $this->polygons),
-            'polylines' => array_map(static fn (Polyline $polyline) => $polyline->toArray(), $this->polylines),
+            'markers' => $this->markersToArray(),
+            'polygons' => $this->polygonsToArray(),
+            'polylines' => $this->polylinesToArray(),
         ];
     }
 
+    private function markersToArray(): array
+    {
+        foreach ($this->markers as $marker) {
+            $markers[] = $marker->toArray();
+        }
+
+        return $markers ?? [];
+    }
+
+    private static function markersFromArray(array $markers): SplObjectStorage
+    {
+        $markerObjects = new SplObjectStorage();
+        foreach ($markers as $marker) {
+            $markerObject = Marker::fromArray($marker);
+            $markerObjects->attach($markerObject, $markerObject->identifier);
+        }
+
+        return $markerObjects;
+    }
+
+    private function polygonsToArray(): array
+    {
+        foreach ($this->polygons as $polygon) {
+            $polygons[] = $polygon->toArray();
+        }
+
+        return $polygons ?? [];
+    }
+
+    private static function polygonsFromArray(array $polygons): SplObjectStorage
+    {
+        $polygonObjects = new SplObjectStorage();
+        foreach ($polygons as $polygon) {
+            $polygonObject = Polygon::fromArray($polygon);
+            $polygonObjects->attach($polygonObject, $polygonObject->identifier);
+        }
+
+        return $polygonObjects;
+    }
+
+    private function polylinesToArray(): array
+    {
+        foreach ($this->polylines as $polyline) {
+            $polylines[] = $polyline->toArray();
+        }
+
+        return $polylines ?? [];
+    }
+
+    private static function polylinesFromArray(array $polylines): SplObjectStorage
+    {
+        $polylineObjects = new SplObjectStorage();
+        foreach ($polylines as $polyline) {
+            $polylineObject = Polyline::fromArray($polyline);
+            $polylineObjects->attach($polylineObject, $polylineObject->identifier);
+        }
+
+        return $polylineObjects;
+    }
+
+
     /**
      * @param array{
      *     center?: array{lat: float, lng: float},
@@ -159,23 +296,23 @@ public static function fromArray(array $map): self
             $map['fitBoundsToMarkers'] = false;
         }
 
-        $map['markers'] ??= [];
+        $map['markers'] ??= new SplObjectStorage();
         if (!\is_array($map['markers'])) {
             throw new InvalidArgumentException('The "markers" parameter must be an array.');
         }
-        $map['markers'] = array_map(Marker::fromArray(...), $map['markers']);
+        $map['markers'] = self::markersFromArray($map['markers']);
 
-        $map['polygons'] ??= [];
+        $map['polygons'] ??= new SplObjectStorage();
         if (!\is_array($map['polygons'])) {
             throw new InvalidArgumentException('The "polygons" parameter must be an array.');
         }
-        $map['polygons'] = array_map(Polygon::fromArray(...), $map['polygons']);
+        $map['polygons'] = self::polygonsFromArray($map['polygons']);
 
-        $map['polylines'] ??= [];
+        $map['polylines'] ??= new SplObjectStorage();
         if (!\is_array($map['polylines'])) {
             throw new InvalidArgumentException('The "polylines" parameter must be an array.');
         }
-        $map['polylines'] = array_map(Polyline::fromArray(...), $map['polylines']);
+        $map['polylines'] = self::polylinesFromArray($map['polylines']);
 
         return new self(...$map);
     }

src/Map/src/Marker.php

@@ -25,10 +25,11 @@
      *                                    use them later JavaScript side
      */
     public function __construct(
-        private Point $position,
-        private ?string $title = null,
-        private ?InfoWindow $infoWindow = null,
-        private array $extra = [],
+        public Point $position,
+        public ?string $title = null,
+        public ?InfoWindow $infoWindow = null,
+        public array $extra = [],
+        public ?string $identifier = null,
     ) {
     }
 
@@ -38,6 +39,7 @@ public function __construct(
      *     title: string|null,
      *     infoWindow: array<string, mixed>|null,
      *     extra: array,
+     *     identifier: string|null
      * }
      */
     public function toArray(): array
@@ -47,6 +49,7 @@ public function toArray(): array
             'title' => $this->title,
             'infoWindow' => $this->infoWindow?->toArray(),
             'extra' => $this->extra,
+            'identifier' => $this->identifier,
         ];
     }
 
@@ -56,6 +59,7 @@ public function toArray(): array
      *     title: string|null,
      *     infoWindow: array<string, mixed>|null,
      *     extra: array,
+     *     identifier: string|null
      * } $marker
      *
      * @internal

src/Map/src/Polygon.php

@@ -28,8 +28,8 @@ public function __construct(
         private ?string $title = null,
         private ?InfoWindow $infoWindow = null,
         private array $extra = [],
-    ) {
-    }
+        public ?string $identifier = null,
+    ) {}
 
     /**
      * Convert the polygon to an array representation.
@@ -39,15 +39,17 @@ public function __construct(
      *     title: string|null,
      *     infoWindow: array<string, mixed>|null,
      *     extra: array,
+     *     identifier: string|null
      * }
      */
     public function toArray(): array
     {
         return [
-            'points' => array_map(fn (Point $point) => $point->toArray(), $this->points),
+            'points' => array_map(fn(Point $point) => $point->toArray(), $this->points),
             'title' => $this->title,
             'infoWindow' => $this->infoWindow?->toArray(),
             'extra' => $this->extra,
+            'identifier' => $this->identifier,
         ];
     }
 
@@ -57,6 +59,7 @@ public function toArray(): array
      *     title: string|null,
      *     infoWindow: array<string, mixed>|null,
      *     extra: array,
+     *     identifier: string|null
      * } $polygon
      *
      * @internal