chore: define Spinner to set spinner configs

Author: ynqa

examples/byop/src/byop.rs

@@ -169,6 +169,7 @@ struct BYOP {
     renderer: SharedRenderer<Index>,
     task_monitor: Arc<TaskMonitor>,
     readline: text_editor::State,
+    spinner: Arc<spinner::Spinner>,
 }
 
 #[async_trait::async_trait]
@@ -229,6 +230,12 @@ impl BYOP {
             task_monitor: Arc::new(TaskMonitor::new(renderer.clone())),
             renderer,
             readline,
+            spinner: Arc::new(
+                spinner::Spinner::default()
+                    .frames(spinner::frame::DOTS.clone())
+                    .suffix("Executing...")
+                    .duration(Duration::from_millis(100)),
+            ),
         })
     }
 
@@ -422,14 +429,14 @@ impl BYOP {
     async fn spawn(&mut self) -> anyhow::Result<()> {
         let renderer = self.renderer.clone();
         let task_monitor = Arc::clone(&self.task_monitor);
+        let spinner = Arc::clone(&self.spinner);
+
         let spinner_task = tokio::spawn(async move {
             spinner::run(
-                spinner::frame::DOTS.clone(),
-                "Executing...",
-                Duration::from_millis(100),
+                spinner.as_ref(),
                 task_monitor.as_ref(),
                 Index::Spinner,
-                renderer.clone(),
+                renderer,
             )
             .await
         });

promkit-widgets/src/spinner.rs

@@ -5,15 +5,55 @@ use crate::core::{Pane, grapheme::StyledGraphemes, render::SharedRenderer};
 pub mod frame;
 use frame::Frame;
 
+/// Trait to define the state of the spinner.
 pub trait State {
     fn is_idle(&self) -> impl Future<Output = bool> + Send;
 }
 
+/// A spinner that can be used to indicate loading or processing states.
+#[derive(Clone, Debug)]
+pub struct Spinner {
+    /// The frames of the spinner, which are the characters that will be displayed in a rotating manner.
+    pub frames: Frame,
+    /// A suffix that will be displayed alongside the spinner.
+    pub suffix: String,
+    /// The duration between frame updates.
+    pub duration: Duration,
+}
+
+impl Default for Spinner {
+    fn default() -> Self {
+        Self {
+            frames: frame::DOTS.clone(),
+            suffix: String::new(),
+            duration: Duration::from_millis(100),
+        }
+    }
+}
+
+impl Spinner {
+    /// Set frames for the spinner.
+    pub fn frames(mut self, frames: Frame) -> Self {
+        self.frames = frames;
+        self
+    }
+
+    /// Set a suffix for the spinner.
+    pub fn suffix(mut self, suffix: impl Into<String>) -> Self {
+        self.suffix = suffix.into();
+        self
+    }
+
+    /// Set the duration between frame updates.
+    pub fn duration(mut self, duration: Duration) -> Self {
+        self.duration = duration;
+        self
+    }
+}
+
 /// Spawn a background task that shows a spinner while the state is active.
 pub async fn run<S, I>(
-    spinner: Frame,
-    suffix: &str,
-    duration: Duration,
+    spinner: &Spinner,
     state: S,
     index: I,
     renderer: SharedRenderer<I>,
@@ -23,21 +63,21 @@ where
     I: Clone + Ord + Send,
 {
     let mut frame_index = 0;
-    let mut interval = tokio::time::interval(duration);
+    let mut interval = tokio::time::interval(spinner.duration);
 
     loop {
         interval.tick().await;
 
         if !state.is_idle().await {
-            frame_index = (frame_index + 1) % spinner.len();
+            frame_index = (frame_index + 1) % spinner.frames.len();
 
             renderer
                 .update([(
                     index.clone(),
                     Pane::new(
                         vec![StyledGraphemes::from(format!(
                             "{} {}",
-                            spinner[frame_index], suffix
+                            spinner.frames[frame_index], spinner.suffix
                         ))],
                         0,
                     ),