@perspective-dev/viewer 4.5.2 → 5.1.0

package/src/rust/utils/pending_effects.rs

@@ -0,0 +1,62 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ Copyright (c) 2017, the Perspective Authors.                              ┃
+// ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
+// ┃ This file is part of the Perspective library, distributed under the terms ┃
+// ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+use std::cell::Cell;
+use std::rc::Rc;
+
+use super::pubsub::PubSub;
+
+/// The element-scoped ledger of in-flight EFFECTS: every effectful public
+/// method (and the internal flows they schedule, e.g. the `before-resize`
+/// presize) registers an [`EffectGuard`] for the duration of its async
+/// work, whether or not the caller awaited it. `flush()` resolves only
+/// after the ledger drains, so "called before `flush`" implies "applied
+/// before `flush` resolves".
+#[derive(Clone, Default)]
+pub struct EffectLedger(Rc<EffectLedgerData>);
+
+#[derive(Default)]
+struct EffectLedgerData {
+    count: Cell<u32>,
+    on_drain: PubSub<()>,
+}
+
+pub struct EffectGuard(EffectLedger);
+
+impl EffectLedger {
+    pub fn guard(&self) -> EffectGuard {
+        self.0.count.set(self.0.count.get() + 1);
+        EffectGuard(self.clone())
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.0.count.get() == 0
+    }
+
+    pub async fn settle(&self) {
+        while self.0.count.get() > 0 {
+            if self.0.on_drain.read_next().await.is_err() {
+                break;
+            }
+        }
+    }
+}
+
+impl Drop for EffectGuard {
+    fn drop(&mut self) {
+        let data = &self.0.0;
+        data.count.set(data.count.get() - 1);
+        if data.count.get() == 0 {
+            data.on_drain.emit(());
+        }
+    }
+}

package/src/rust/utils/spawn.rs

@@ -0,0 +1,33 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ Copyright (c) 2017, the Perspective Authors.                              ┃
+// ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
+// ┃ This file is part of the Perspective library, distributed under the terms ┃
+// ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+use std::future::Future;
+
+use perspective_js::utils::*;
+
+/// Spawn a fire-and-forget task whose ERRORS ARE OWNED: a failure lands in a
+/// `tracing::error` tagged with `tag` instead of a dangling `Promise`
+/// rejection (which `ApiFuture::spawn` produces, invisibly to callers and
+/// tests). "View already deleted" cancellations are not failures.
+///
+/// Prefer RETURNING the future so the caller owns completion and error
+/// (invariant I6); use this only at event-listener leaves where no caller
+/// exists.
+pub fn spawn_owned(tag: &'static str, fut: impl Future<Output = ApiResult<()>> + 'static) {
+    ApiFuture::spawn(async move {
+        if let Err(e) = fut.await.ignore_view_delete() {
+            tracing::error!("[{}] unhandled task error: {}", tag, e);
+        }
+
+        Ok(())
+    });
+}

package/src/rust/utils/weak_scope.rs

@@ -37,13 +37,3 @@ impl<C: Component> PartialEq for WeakScope<C> {
         Rc::ptr_eq(&self.0, &other.0)
     }
 }
-
-// #[extend::ext]
-// pub impl<T: Component> Context<T> {
-//     fn context<U: Clone + PartialEq + 'static>(&self) -> U {
-//         self.link()
-//             .context::<U>(Callback::from(|_| {}))
-//             .map(|(c, _)| c)
-//             .unwrap()
-//     }
-// }