use std::sync::{
Arc,
atomic::{AtomicBool, Ordering},
};
use leptos::portal::Portal;
use leptos::prelude::*;
use leptos::wasm_bindgen::JsCast;
use leptos_use::use_event_listener;
use crate::node::NodeElement;
use crate::types::{Rect, ViewportTransform};
#[derive(Clone, Copy)]
pub struct NodeOverlayLayer {
pub mount: NodeRef<leptos::html::Div>,
pub viewport: Signal<ViewportTransform>,
}
#[derive(Clone, Default)]
pub enum OverlayAnchor {
#[default]
Node,
Selector(String),
Element(Arc<dyn Fn() -> Option<web_sys::Element> + Send + Sync>),
Pane(Rect),
}
impl OverlayAnchor {
pub fn element<E>(node_ref: NodeRef<E>) -> Self
where
E: leptos::html::ElementType + 'static,
E::Output: JsCast + Clone + 'static,
{
Self::Element(Arc::new(move || {
node_ref
.get()
.map(|el| el.unchecked_into::<web_sys::Element>())
}))
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
pub enum OverlaySide {
#[default]
Right,
Left,
Top,
Bottom,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
pub enum OverlayAlign {
#[default]
Start,
Center,
End,
}
#[derive(Clone, Copy, Debug, Default)]
struct PaneRect {
x: f64,
y: f64,
w: f64,
h: f64,
}
#[component]
pub fn NodeOverlay(
#[prop(optional)]
anchor: OverlayAnchor,
#[prop(optional)] side: OverlaySide,
#[prop(optional)] align: OverlayAlign,
#[prop(default = 8.0)]
offset: f64,
#[prop(default = true)]
keep_in_view: bool,
#[prop(default = true)]
track_anchor: bool,
#[prop(optional)]
backdrop: bool,
#[prop(optional, into)]
on_dismiss: Option<Callback<()>>,
#[prop(optional, into)]
style: Option<String>,
children: ChildrenFn,
) -> impl IntoView {
let Some(layer) = use_context::<NodeOverlayLayer>() else {
leptos::logging::warn!(
"<NodeOverlay> rendered outside a <NodeEditor>; nothing will be shown"
);
return ().into_any();
};
let node_el = use_context::<NodeElement>();
let panel_ref = NodeRef::<leptos::html::Div>::new();
let placement = RwSignal::new(None::<(f64, f64)>);
let anchor = Arc::new(anchor);
let anchor_for_place = Arc::clone(&anchor);
let extra_style = style.unwrap_or_default();
let resolve_anchor = move |layer_el: &web_sys::Element| -> Option<PaneRect> {
let lr = layer_el.get_bounding_client_rect();
let from_element = |el: web_sys::Element| {
let r = el.get_bounding_client_rect();
PaneRect {
x: r.left() - lr.left(),
y: r.top() - lr.top(),
w: r.width(),
h: r.height(),
}
};
match anchor_for_place.as_ref() {
OverlayAnchor::Node => node_el
.and_then(|n| n.0.get_untracked())
.map(|el| from_element(el.unchecked_into())),
OverlayAnchor::Selector(sel) => node_el
.and_then(|n| n.0.get_untracked())
.and_then(|el| {
el.unchecked_into::<web_sys::Element>()
.query_selector(sel)
.ok()
.flatten()
})
.map(from_element),
OverlayAnchor::Element(get) => get().map(from_element),
OverlayAnchor::Pane(rect) => Some(PaneRect {
x: rect.position.x,
y: rect.position.y,
w: rect.size.width,
h: rect.size.height,
}),
}
};
let place = move || {
let Some(layer_el) = layer.mount.get_untracked() else {
return;
};
let layer_el: web_sys::Element = layer_el.unchecked_into();
let Some(a) = resolve_anchor(&layer_el) else {
return;
};
let Some(panel) = panel_ref.get_untracked() else {
return;
};
let lr = layer_el.get_bounding_client_rect();
let (pane_w, pane_h) = (lr.width(), lr.height());
let (pw, ph) = (panel.offset_width() as f64, panel.offset_height() as f64);
let cross = |start: f64, extent: f64, size: f64| match align {
OverlayAlign::Start => start,
OverlayAlign::Center => start + (extent - size) / 2.0,
OverlayAlign::End => start + extent - size,
};
let main = |side: OverlaySide| match side {
OverlaySide::Right => (a.x + a.w + offset, cross(a.y, a.h, ph)),
OverlaySide::Left => (a.x - offset - pw, cross(a.y, a.h, ph)),
OverlaySide::Bottom => (cross(a.x, a.w, pw), a.y + a.h + offset),
OverlaySide::Top => (cross(a.x, a.w, pw), a.y - offset - ph),
};
let (mut x, mut y) = main(side);
if keep_in_view {
let overflows = match side {
OverlaySide::Right => x + pw > pane_w,
OverlaySide::Left => x < 0.0,
OverlaySide::Bottom => y + ph > pane_h,
OverlaySide::Top => y < 0.0,
};
if overflows {
let opposite = match side {
OverlaySide::Right => OverlaySide::Left,
OverlaySide::Left => OverlaySide::Right,
OverlaySide::Bottom => OverlaySide::Top,
OverlaySide::Top => OverlaySide::Bottom,
};
let (fx, fy) = main(opposite);
let fits = match opposite {
OverlaySide::Right => fx + pw <= pane_w,
OverlaySide::Left => fx >= 0.0,
OverlaySide::Bottom => fy + ph <= pane_h,
OverlaySide::Top => fy >= 0.0,
};
if fits {
(x, y) = (fx, fy);
}
}
x = x.min(pane_w - pw).max(0.0);
y = y.min(pane_h - ph).max(0.0);
}
if placement.get_untracked() != Some((x, y)) {
placement.set(Some((x, y)));
}
};
let place: Arc<dyn Fn() + Send + Sync> = Arc::new(place);
let place_vp = Arc::clone(&place);
Effect::new(move || {
let _ = layer.viewport.get();
let _ = panel_ref.get();
place_vp();
});
if track_anchor {
let state = Arc::new(AtomicBool::new(true));
let cleanup_state = state.clone();
on_cleanup(move || cleanup_state.store(false, Ordering::Relaxed));
fn tick(f: Arc<dyn Fn() + Send + Sync>, state: Arc<AtomicBool>) {
if !state.load(Ordering::Relaxed) {
return;
}
f();
crate::raf::request_animation_frame(move || tick(f, state));
}
tick(place, state);
}
if let Some(on_dismiss) = on_dismiss {
let _ = use_event_listener(
leptos::prelude::document(),
leptos::ev::pointerdown,
move |ev: web_sys::PointerEvent| {
let Some(panel) = panel_ref.get_untracked() else {
return;
};
let inside = ev
.target()
.and_then(|t| t.dyn_into::<web_sys::Node>().ok())
.is_some_and(|n| panel.contains(Some(&n)));
if !inside {
on_dismiss.run(());
}
},
);
let _ = use_event_listener(
leptos::prelude::document(),
leptos::ev::keydown,
move |ev: web_sys::KeyboardEvent| {
if ev.key() == "Escape" {
on_dismiss.run(());
}
},
);
}
let panel_style = Signal::derive(move || {
let placed = placement.get();
let (x, y) = placed.unwrap_or((0.0, 0.0));
let vis = if placed.is_some() {
""
} else {
"visibility: hidden;"
};
format!(
"position: absolute; left: {x}px; top: {y}px; pointer-events: auto; \
{vis} {extra_style}"
)
});
let backdrop_view = backdrop.then(|| {
let dismiss = on_dismiss;
view! {
<div
data-node-overlay-backdrop=""
style="position: absolute; inset: 0; pointer-events: auto;"
on:pointerdown=move |_| {
if let Some(cb) = dismiss {
cb.run(());
}
}
/>
}
});
view! {
{move || {
layer.mount.get().map(|mount_el| {
let mount_el: web_sys::Element = mount_el.unchecked_into();
let children = children.clone();
let backdrop_view = backdrop_view.clone();
view! {
<Portal mount=mount_el>
{backdrop_view.clone()}
<div data-node-overlay="" node_ref=panel_ref style=panel_style>
{children()}
</div>
</Portal>
}
})
}}
}
.into_any()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn animation_loop_state_survives_owner_cleanup() {
let owner = Owner::new();
let state = Arc::new(AtomicBool::new(true));
let cleanup_state = state.clone();
owner.with(|| on_cleanup(move || cleanup_state.store(false, Ordering::Relaxed)));
owner.cleanup();
assert!(!state.load(Ordering::Relaxed));
}
}