feat: Add documentation comments for various components and update version to 0.8.2

Author: dgsantana

README.md

@@ -8,11 +8,14 @@ For now only a few of the components are ported, and events must be set in the S
 
 NOTE: Current version support leptos 0.6.x, that removes all Scope usages from signals and effects.
 
+Support for leptos 0.7.x exists in the `leptos-0.7` branch. When Leptos 0.7 is released, this branch will be merged into main.
+
 ## Features
 - CSR/HYDRATE/SSR support
 
 ### Components
 - MapContainer
+- Control
 - TileLayer
 - TileLayerWms
 - ImageOverlay

leptos-leaflet/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "leptos-leaflet"
 authors = ["Daniel Santana <danielgsantana@gmail.com>", "Artur Leao <artur.leao@gmail.com>", "Lewin Probst <info@emirror.de>"]
-version = "0.8.1"
+version = "0.8.2"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/headless-studio/leptos-leaflet"

leptos-leaflet/src/components/bounds.rs

@@ -1,59 +1,92 @@
-use crate::Position;
 use leaflet::LatLng;
 use leaflet::LatLngBounds;
 
+use crate::Position;
+
+/// Represents a geographical area defined by its northeast and southwest corners.
+///
+/// The `Bounds` struct is used to define rectangular areas on a map. It provides methods to calculate
+/// the center, size, and check for containment or intersection with other bounds.
+///
+/// # Fields
+///
+/// - `ne_corner`: The northeast corner of the bounds.
+/// - `sw_corner`: The southwest corner of the bounds.
 #[derive(Debug, Default, Clone, Copy, PartialEq)]
 pub struct Bounds {
     pub ne_corner: Position,
     pub sw_corner: Position,
 }
 
 impl Bounds {
+    /// Creates a new `Bounds` instance with the given northeast and southwest corners.
+    /// 
+    /// # Arguments
+    /// 
+    /// - `ne_corner`: The northeast corner of the bounds.
+    /// - `sw_corner`: The southwest corner of the bounds.
     pub fn new(ne_corner: Position, sw_corner: Position) -> Self {
         Self {
             ne_corner,
             sw_corner,
         }
     }
 
+    /// Gets the center of the bounds.
     pub fn get_center(&self) -> Position {
         Position {
             lat: (self.ne_corner.lat + self.sw_corner.lat) / 2.0,
             lng: (self.ne_corner.lng + self.sw_corner.lng) / 2.0,
         }
     }
 
+    /// Gets the southwest corner of the bounds.
     pub fn get_bottom_left(&self) -> Position {
         Position::new(self.sw_corner.lat, self.sw_corner.lng)
     }
 
+    /// Gets the northeast corner of the bounds.
     pub fn get_top_right(&self) -> Position {
         Position::new(self.ne_corner.lat, self.ne_corner.lng)
     }
 
+    /// Gets the northwest corner of the bounds.
     pub fn get_top_left(&self) -> Position {
         Position::new(self.ne_corner.lat, self.sw_corner.lng)
     }
 
+    /// Gets the southeast corner of the bounds.
     pub fn get_bottom_right(&self) -> Position {
         Position::new(self.sw_corner.lat, self.ne_corner.lng)
     }
 
+    /// Gets the size of the bounds.
     pub fn get_size(&self) -> Position {
         Position {
             lat: (self.ne_corner.lat - self.sw_corner.lat).abs(),
             lng: (self.ne_corner.lng - self.sw_corner.lng).abs(),
         }
     }
 
+    /// Returns true if the rectangle contains the given bounds. 
+    /// A rectangle contains another bounds if it contains all of its points.
+    /// 
+    /// # Arguments
+    /// 
+    /// - `position`: The position to check for containment.
     pub fn contains(&self, position: Position) -> bool {
         self.sw_corner.lat <= position.lat
             && self.ne_corner.lat >= position.lat
             && self.sw_corner.lng <= position.lng
             && self.ne_corner.lng >= position.lng
     }
 
-    // Returns true if the rectangle intersects the given bounds. Two bounds intersect if they have at least one point in common.
+    /// Returns true if the rectangle intersects the given bounds.
+    /// Two bounds intersect if they have at least one point in common.
+    ///
+    /// # Arguments
+    /// 
+    /// - `other`: The bounds to check for intersection.
     pub fn intersects(&self, other: Bounds) -> bool {
         let lat_overlap =
             self.ne_corner.lat >= other.sw_corner.lat && self.sw_corner.lat <= other.ne_corner.lat;
@@ -63,7 +96,12 @@ impl Bounds {
         lat_overlap && lng_overlap
     }
 
-    // Returns true if the rectangle overlaps the given bounds. Two bounds overlap if their intersection is an area.
+    /// Returns true if the rectangle overlaps the given bounds.
+    /// Two bounds overlap if their intersection is an area.
+    /// 
+    /// # Arguments
+    /// 
+    /// - `other`: The bounds to check for overlap.
     pub fn overlaps(&self, other: Bounds) -> bool {
         let lat_overlap =
             self.ne_corner.lat > other.sw_corner.lat && self.sw_corner.lat < other.ne_corner.lat;
@@ -73,6 +111,7 @@ impl Bounds {
         lat_overlap && lng_overlap
     }
 
+    /// Returns true if the bounds are valid.
     pub fn is_valid(&self) -> bool {
         self.ne_corner.lat <= 90.0
             && self.ne_corner.lat >= -90.0
@@ -86,6 +125,7 @@ impl Bounds {
             && self.ne_corner.lng >= self.sw_corner.lng
     }
 
+    /// Returns a new bounds padded by the given ratio.
     pub fn pad(&self, buffer_ratio: f64) -> Bounds {
         let lat_diff = self.ne_corner.lat - self.sw_corner.lat;
         let lng_diff = self.ne_corner.lng - self.sw_corner.lng;
@@ -97,6 +137,7 @@ impl Bounds {
         }
     }
 
+    /// Checks if the bounds are equal to the given bounds.
     pub fn equals(&self, other: Bounds) -> bool {
         self.ne_corner == other.ne_corner && self.sw_corner == other.sw_corner
     }

leptos-leaflet/src/components/circle.rs

@@ -9,6 +9,10 @@ use crate::{
 use leaflet::CircleOptions;
 use leptos::*;
 
+/// A circle overlay that represents a circle on the map.
+/// 
+/// The `Circle` component is used to create a circle overlay on the map. It provides options to customize
+/// the appearance of the circle, such as the stroke color, fill color, and radius.
 #[component(transparent)]
 pub fn Circle(
     #[prop(into)] center: MaybeSignal<Position>,

leptos-leaflet/src/components/context.rs

@@ -1,12 +1,16 @@
 use leptos::*;
 use wasm_bindgen::JsCast;
 
+/// A context struct for the Leaflet map.
+/// 
+/// This struct provides a way to access the current state of the Leaflet map.
 #[derive(Debug, Clone, Copy)]
 pub struct LeafletMapContext {
     map: RwSignal<Option<leaflet::Map>>,
 }
 
 impl LeafletMapContext {
+    /// Creates a new `LeafletMapContext` instance.
     pub fn new() -> Self {
         Self {
             map: create_rw_signal(None),

leptos-leaflet/src/components/image_overlay.rs

@@ -3,6 +3,7 @@ use crate::components::context::LeafletMapContext;
 use leptos::logging::log;
 use leptos::*;
 
+/// An image overlay component.
 #[component(transparent)]
 pub fn ImageOverlay(
     #[prop(into)] url: String,

leptos-leaflet/src/components/map_container.rs

@@ -9,6 +9,10 @@ use crate::components::context::provide_leaflet_context;
 use crate::components::position::Position;
 use crate::{MapEvents, PopupEvents, TooltipEvents};
 
+/// A container for the Leaflet map.
+/// 
+/// This is the main container for the Leaflet map. It provides a way to add child nodes to the map.
+/// It also provides a signal to access the map instance, allowing to interact with the map from other components.
 #[component]
 pub fn MapContainer(
     #[prop(into, optional)] class: MaybeSignal<String>,

leptos-leaflet/src/components/marker.rs

@@ -10,6 +10,7 @@ use crate::{
     MouseEvents, MoveEvents, PopupEvents, TooltipEvents,
 };
 
+/// A marker component.
 #[component(transparent)]
 pub fn Marker(
     /// Position for the Marker

leptos-leaflet/src/components/path_options.rs

@@ -1,5 +1,6 @@
 use std::fmt::{Display, Formatter};
 
+/// Options for configuring the appearance of a path join.
 #[derive(Debug, Copy, Clone)]
 pub enum LineJoin {
     Arcs,
@@ -39,6 +40,7 @@ impl AsRef<str> for LineJoin {
     }
 }
 
+/// Options for configuring the appearance of a path cap.
 #[derive(Debug, Copy, Clone)]
 pub enum LineCap {
     Butt,
@@ -72,6 +74,7 @@ impl AsRef<str> for LineCap {
     }
 }
 
+/// Options for configuring the appearance of a path fill.
 #[derive(Debug, Copy, Clone)]
 pub enum FillRule {
     NonZero,

leptos-leaflet/src/components/polygon.rs

@@ -13,6 +13,7 @@ use crate::{
     PopupEvents, TooltipEvents,
 };
 
+/// A polygon overlay that represents a polygon on the map.
 #[component(transparent)]
 pub fn Polygon(
     #[prop(into)] positions: MaybeSignal<Vec<Position>>,