T11b loading: progress bars and rings that glide, loading overlay, lazy load, suspense and async view, refresh and typing indicators, upload list; draw-time notifies ask for a frame

src/feedback/suspense.rs

@@ -0,0 +1,154 @@
+use std::{future::Future, rc::Rc};
+
+use gpui::{
+    Animation, AnimationExt, AnyElement, App, Context, ElementId, IntoElement, ParentElement,
+    Render, RenderOnce, Styled, Task, Window, div, prelude::*,
+};
+
+use super::ErrorBoundary;
+use crate::{
+    forms::Run,
+    motion::{self, Spinner},
+};
+
+/// Shows a fallback while its content is on the way, then the content as it fades in, or an error view of the failure.
+#[derive(IntoElement)]
+pub struct Suspense {
+    id: ElementId,
+    content: Option<anyhow::Result<AnyElement>>,
+    fallback: Option<AnyElement>,
+    on_retry: Option<Run>,
+}
+
+impl Suspense {
+    /// `None` while the content is on the way.
+    pub fn new<E: IntoElement>(
+        id: impl Into<ElementId>,
+        content: Option<anyhow::Result<E>>,
+    ) -> Self {
+        Self {
+            id: id.into(),
+            content: content.map(|content| content.map(IntoElement::into_any_element)),
+            fallback: None,
+            on_retry: None,
+        }
+    }
+
+    /// Shown while waiting instead of a centered spinner, such as a skeleton.
+    pub fn fallback(mut self, fallback: impl IntoElement) -> Self {
+        self.fallback = Some(fallback.into_any_element());
+        self
+    }
+
+    pub fn on_retry(mut self, handler: impl Fn(&mut Window, &mut App) + 'static) -> Self {
+        self.on_retry = Some(Rc::new(handler));
+        self
+    }
+}
+
+impl RenderOnce for Suspense {
+    fn render(self, _: &mut Window, cx: &mut App) -> impl IntoElement {
+        match self.content {
+            None => self.fallback.unwrap_or_else(|| {
+                div()
+                    .flex()
+                    .justify_center()
+                    .py_8()
+                    .child(Spinner::new((self.id.clone(), "waiting")))
+                    .into_any_element()
+            }),
+            Some(Ok(content)) => div()
+                .child(content)
+                .with_animation(
+                    (self.id, "ready"),
+                    Animation::new(motion::duration(motion::BASE, cx))
+                        .with_easing(motion::ease_out_cubic),
+                    |ready, t| ready.opacity(t),
+                )
+                .into_any_element(),
+            Some(Err(error)) => ErrorBoundary::new(self.id, Err::<AnyElement, _>(error))
+                .when_some(self.on_retry, |boundary, run| {
+                    boundary.on_retry(move |window, cx| run(window, cx))
+                })
+                .into_any_element(),
+        }
+    }
+}
+
+type Load<T> = Rc<dyn Fn() -> Task<anyhow::Result<T>>>;
+type Show<T> = Rc<dyn Fn(&T, &mut Window, &mut App) -> AnyElement>;
+
+/// Loads a value off the main thread and shows it through a `Suspense`: a spinner while it loads, then `show`'s view of it, or the error with Try again.
+pub struct AsyncView<T> {
+    id: ElementId,
+    load: Load<T>,
+    show: Show<T>,
+    state: Option<anyhow::Result<T>>,
+    _task: Task<()>,
+}
+
+impl<T: 'static> AsyncView<T> {
+    /// `load` runs once now, and again on each Try again.
+    pub fn new<F, E>(
+        id: impl Into<ElementId>,
+        load: impl Fn() -> F + 'static,
+        show: impl Fn(&T, &mut Window, &mut App) -> E + 'static,
+        cx: &mut Context<Self>,
+    ) -> Self
+    where
+        F: Future<Output = anyhow::Result<T>> + Send + 'static,
+        T: Send,
+        E: IntoElement,
+    {
+        let load: Load<T> = {
+            let executor = cx.background_executor().clone();
+            Rc::new(move || executor.spawn(load()))
+        };
+        let task = Self::start(&load, cx);
+        Self {
+            id: id.into(),
+            load,
+            show: Rc::new(move |value, window, cx| show(value, window, cx).into_any_element()),
+            state: None,
+            _task: task,
+        }
+    }
+
+    fn start(load: &Load<T>, cx: &mut Context<Self>) -> Task<()> {
+        let running = load();
+        cx.spawn(async move |view, cx| {
+            let result = running.await;
+            let landed = view.update(cx, |view, cx| {
+                match &result {
+                    Ok(_) => log::info!("async view {:?}: loaded", view.id),
+                    Err(error) => log::error!("async view {:?}: {error:#}", view.id),
+                }
+                view.state = Some(result);
+                cx.notify();
+            });
+            if landed.is_err() {
+                log::debug!("async view: dropped before its value landed");
+            }
+        })
+    }
+
+    /// Loads anew, showing the fallback until the value lands.
+    pub fn reload(&mut self, cx: &mut Context<Self>) {
+        log::info!("async view {:?}: loading again", self.id);
+        self.state = None;
+        self._task = Self::start(&self.load, cx);
+        cx.notify();
+    }
+}
+
+impl<T: 'static> Render for AsyncView<T> {
+    fn render(&mut self, window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        let content = self.state.as_ref().map(|state| match state {
+            Ok(value) => Ok((self.show)(value, window, cx)),
+            Err(error) => Err(anyhow::anyhow!("{error:#}")),
+        });
+        let view = cx.entity();
+        Suspense::new(self.id.clone(), content)
+            .on_retry(move |_, cx| view.update(cx, |view, cx| view.reload(cx)))
+    }
+}