Documented

src/component/scope.rs

@@ -1,15 +1,28 @@
+//! # Scope Module
+//!
+//! Provides the Scope type for managing component hierarchies.
+//! Scopes group child components and manage their lifecycle.
+
 use std::sync::{Arc, Mutex};
 
 use crate::{engine::CommandExecutor, View, ViewWrapper};
 
 use super::{context::Context, ComponentImpl};
 
+/// A scope groups child components and manages their rendering
+/// 
+/// Scopes form the hierarchical structure of a component tree.
+/// Each scope contains references to its child components and their
+/// optional view wrappers (for layout/styling).
 pub struct Scope {
+    /// Child components with optional view wrappers
     pub children: Mutex<Vec<(Arc<Context>, Option<ViewWrapper>)>>,
+    /// Command executor for this scope's children
     executor: Arc<dyn CommandExecutor>,
 }
 
 impl Scope {
+    /// Creates a new scope with the given command executor
     pub fn new(executor: Arc<dyn CommandExecutor>) -> Arc<Self> {
         Arc::new(Self {
             children: Mutex::new(Vec::new()),
@@ -17,6 +30,9 @@ impl Scope {
         })
     }
 
+    /// Adds a child component to this scope
+    /// 
+    /// The view_wrapper is optional and can be used for layout or styling.
     pub fn child<F: ComponentImpl + 'static>(
         self: &Arc<Self>,
         child: F,
@@ -29,6 +45,7 @@ impl Scope {
         self.children.lock().unwrap().push((ctx, view_wrapper));
     }
 
+    /// Adds a view directly to this scope
     pub fn view(self: &Arc<Self>, view: View) {
         let ctx = Context::new(view, self.executor.clone());