Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

fix(input): align mouse click targeting with Chromium

ldm068408732cb8d
diff --git a/moli-dom/src/native/host/flat_tree.rs b/moli-dom/src/native/host/flat_tree.rs
index 0e185eb66..8427535a7 100644
--- a/moli-dom/src/native/host/flat_tree.rs
+++ b/moli-dom/src/native/host/flat_tree.rs
@@ -1,6 +1,13 @@
use super::*;
impl DomHost {
+ /// Parent in the distributed tree used for rendering and click targeting.
+ /// Shadow roots are transparent; assigned light children belong to slots.
+ pub fn flat_tree_parent(&self, node: DomHandle) -> Option<DomHandle> {
+ let parent = self.composed_parent(node)?;
+ Some(self.shadow_root_host(parent).unwrap_or(parent))
+ }
+
/// Includes the ShadowRoot as a transparent link. Unassigned light nodes
/// and replaced slot fallback have no parent in the composed tree.
pub fn composed_parent(&self, node: DomHandle) -> Option<DomHandle> {
diff --git a/moli-renderer-v8/src/mutation_coordinator.rs b/moli-renderer-v8/src/mutation_coordinator.rs
index c62147d08..a043e2aae 100644
--- a/moli-renderer-v8/src/mutation_coordinator.rs
+++ b/moli-renderer-v8/src/mutation_coordinator.rs
@@ -173,6 +173,7 @@ impl MutationCoordinator {
if options.source == DomMutationSource::JsDomApi {
Self::note_script_children_changed_by_api(dom_host, &effects);
}
+ unsafe { &mut *host_ptr }.note_mouse_input_target_removals(dom_host, &effects);
let cpu_profile_enabled = moli_trace::cpu_profile_enabled();
let total_started = cpu_profile_enabled.then(Instant::now);
tracing::trace!(
diff --git a/moli-renderer-v8/src/native_bridge/context_host/core.rs b/moli-renderer-v8/src/native_bridge/context_host/core.rs
index bdfba522a..bb538fa69 100644
--- a/moli-renderer-v8/src/native_bridge/context_host/core.rs
+++ b/moli-renderer-v8/src/native_bridge/context_host/core.rs
@@ -458,6 +458,7 @@ impl JsContextHost {
active_pointer_capture_ids: HashSet::new(),
pending_pointer_capture_targets: HashMap::new(),
pointer_capture_targets: HashMap::new(),
+ mouse_input: mouse_click::MouseInputState::default(),
lazy_media_load_candidates: HashSet::new(),
canvas_resources: super::canvas_resources::CanvasResourceStore::new(
visual_resource_generation.clone(),
diff --git a/moli-renderer-v8/src/native_bridge/context_host/mod.rs b/moli-renderer-v8/src/native_bridge/context_host/mod.rs
index 0e81db50d..373c426c0 100644
--- a/moli-renderer-v8/src/native_bridge/context_host/mod.rs
+++ b/moli-renderer-v8/src/native_bridge/context_host/mod.rs
@@ -127,6 +127,8 @@ pub(crate) use text_track_loads::{
mod message_ports;
mod messages;
mod module_owner_tasks;
+mod mouse_click;
+pub(crate) use mouse_click::MouseReleaseFollowUp;
mod navigation;
mod navigator_overrides;
mod opfs_tasks;
@@ -935,6 +937,7 @@ pub(crate) struct JsContextHost {
active_pointer_capture_ids: HashSet<i32>,
pending_pointer_capture_targets: HashMap<i32, DomHandle>,
pointer_capture_targets: HashMap<i32, DomHandle>,
+ mouse_input: mouse_click::MouseInputState,
lazy_media_load_candidates: HashSet<DomHandle>,
canvas_resources: canvas_resources::CanvasResourceStore,
image_resources: image_resources::ImageResourceStore,
diff --git a/moli-renderer-v8/src/native_bridge/context_host/mouse_click.rs b/moli-renderer-v8/src/native_bridge/context_host/mouse_click.rs
new file mode 100644
index 000000000..f28479e87
--- /dev/null
+++ b/moli-renderer-v8/src/native_bridge/context_host/mouse_click.rs
@@ -0,0 +1,165 @@
+use super::*;
+use crate::dom::native::{DomHost, DomMutationEffects};
+
+#[derive(Clone, Copy)]
+struct MousePress {
+ handle: DomHandle,
+ button: i32,
+}
+
+#[derive(Default)]
+pub(super) struct MouseInputState {
+ press: Option<MousePress>,
+ element_under_mouse: Option<DomHandle>,
+}
+
+pub(crate) enum MouseReleaseFollowUp {
+ ActivateViaClick(DomHandle),
+ DispatchEvent {
+ name: &'static str,
+ target: DomHandle,
+ },
+}
+
+impl JsContextHost {
+ pub(crate) fn mouse_press_handle(&self) -> Option<DomHandle> {
+ self.mouse_input.press.map(|press| press.handle)
+ }
+
+ pub(crate) fn mouse_press_button(&self) -> Option<i32> {
+ self.mouse_input.press.map(|press| press.button)
+ }
+
+ pub(crate) fn begin_mouse_press(&mut self, handle: DomHandle, button: i32) {
+ self.mouse_input.press = Some(MousePress { handle, button });
+ }
+
+ pub(crate) fn clear_mouse_press(&mut self) {
+ self.mouse_input.press = None;
+ }
+
+ pub(crate) fn clear_mouse_input_state(&mut self) {
+ self.mouse_input = MouseInputState::default();
+ }
+
+ pub(crate) fn set_mouse_event_target(&mut self, target: DomHandle) {
+ self.mouse_input.element_under_mouse = Some(target);
+ }
+
+ pub(crate) fn mouse_event_target(&self) -> Option<DomHandle> {
+ self.mouse_input.element_under_mouse
+ }
+
+ pub(crate) fn note_mouse_input_target_removals(
+ &mut self,
+ dom: &DomHost,
+ effects: &DomMutationEffects,
+ ) {
+ if self.mouse_input.press.is_none() && self.mouse_input.element_under_mouse.is_none() {
+ return;
+ }
+ // These facts include removals followed by reinsertion, independently
+ // of MutationObserver registration. Unlike click targeting, removal
+ // uses shadow-including DOM ancestry: removing a slot does not remove
+ // its assigned light children. A moved press is itself a removed root.
+ for mutation in effects.style().child_list_mutations() {
+ for &root in mutation.removed_nodes() {
+ if self
+ .mouse_input
+ .press
+ .is_some_and(|press| in_shadow_including_subtree(dom, root, press.handle))
+ {
+ self.clear_mouse_press();
+ }
+ if self
+ .mouse_input
+ .element_under_mouse
+ .is_some_and(|target| in_shadow_including_subtree(dom, root, target))
+ {
+ // Like Blink's HandleRemoveSubtree, retarget immediately
+ // to the old DOM parent, even if the target is reinserted.
+ self.mouse_input.element_under_mouse =
+ std::iter::successors(Some(mutation.target()), |node| {
+ dom.parent_node(*node)
+ .or_else(|| dom.shadow_root_host(*node))
+ })
+ .find(|node| dom.node(*node).is_some_and(|node| node.is_element()));
+ }
+ }
+ }
+ }
+
+ pub(crate) fn mouse_release_follow_up(
+ &mut self,
+ released: DomHandle,
+ button: i32,
+ captured_click_target: Option<DomHandle>,
+ ) -> Option<MouseReleaseFollowUp> {
+ let press = self.mouse_input.press.take()?;
+ if press.button != button {
+ return None;
+ }
+ match button {
+ 0 | 1 => {
+ let dom = self.dom_host();
+ if !dom.is_connected(press.handle) {
+ return None;
+ }
+ let target = if let Some(target) = captured_click_target {
+ target
+ } else {
+ if dom.owner_document_handle(press.handle)
+ != dom.owner_document_handle(released)
+ {
+ return None;
+ }
+ common_flat_tree_ancestor(dom, press.handle, released)?
+ };
+ Some(if button == 0 {
+ MouseReleaseFollowUp::ActivateViaClick(target)
+ } else {
+ MouseReleaseFollowUp::DispatchEvent {
+ name: "auxclick",
+ target,
+ }
+ })
+ }
+ 2 if press.handle == released => Some(MouseReleaseFollowUp::DispatchEvent {
+ name: "contextmenu",
+ target: released,
+ }),
+ _ => None,
+ }
+ }
+}
+
+fn in_shadow_including_subtree(dom: &DomHost, root: DomHandle, target: DomHandle) -> bool {
+ std::iter::successors(Some(target), |node| {
+ dom.parent_node(*node)
+ .or_else(|| dom.shadow_root_host(*node))
+ })
+ .any(|ancestor| ancestor == root)
+}
+
+fn common_flat_tree_ancestor(
+ dom: &DomHost,
+ pressed: DomHandle,
+ released: DomHandle,
+) -> Option<DomHandle> {
+ if pressed == released {
+ return Some(pressed);
+ }
+ let pressed_ancestors =
+ std::iter::successors(Some(pressed), |node| dom.flat_tree_parent(*node))
+ .collect::<Vec<_>>();
+ let released_ancestors =
+ std::iter::successors(Some(released), |node| dom.flat_tree_parent(*node))
+ .collect::<Vec<_>>();
+ pressed_ancestors
+ .iter()
+ .rev()
+ .zip(released_ancestors.iter().rev())
+ .take_while(|(pressed, released)| pressed == released)
+ .last()
+ .map(|(ancestor, _)| *ancestor)
+}
diff --git a/moli-renderer-v8/src/native_bridge/context_host/pointer_capture.rs b/moli-renderer-v8/src/native_bridge/context_host/pointer_capture.rs
index da171376f..e805c69aa 100644
--- a/moli-renderer-v8/src/native_bridge/context_host/pointer_capture.rs
+++ b/moli-renderer-v8/src/native_bridge/context_host/pointer_capture.rs
@@ -43,6 +43,12 @@ impl JsContextHost {
.filter(|target| self.dom_host().is_connected(*target))
}
+ pub(crate) fn pointer_capture_target_for_click(&self, pointer_id: i32) -> Option<DomHandle> {
+ // Click keeps the active capture target even when a release listener
+ // detaches it. Capture cleanup still sends lostpointercapture.
+ self.pointer_capture_targets.get(&pointer_id).copied()
+ }
+
pub(crate) fn pointer_capture_target_is_connected(&self, target: DomHandle) -> bool {
self.dom_host().is_connected(target)
}
diff --git a/moli-renderer-v8/src/native_bridge/mod.rs b/moli-renderer-v8/src/native_bridge/mod.rs
index 7e677c128..fb533529f 100644
--- a/moli-renderer-v8/src/native_bridge/mod.rs
+++ b/moli-renderer-v8/src/native_bridge/mod.rs
@@ -7,8 +7,8 @@ mod collections;
mod context_host;
mod current_input;
pub(crate) use context_host::{
- JsContextHost, JsContextHostPageTaskCapabilities, PendingScrollObservableEffects,
- PostParseAutofocusAdmission, ServiceWorkerWindowOwner,
+ JsContextHost, JsContextHostPageTaskCapabilities, MouseReleaseFollowUp,
+ PendingScrollObservableEffects, PostParseAutofocusAdmission, ServiceWorkerWindowOwner,
};
pub(crate) use current_input::{
CurrentInputEvent, CurrentInputEventScope, InputNavigationPolicy, navigation_policy_from_event,
diff --git a/moli-renderer-v8/src/script_vm.rs b/moli-renderer-v8/src/script_vm.rs
index c35e0ee90..b680a393c 100644
--- a/moli-renderer-v8/src/script_vm.rs
+++ b/moli-renderer-v8/src/script_vm.rs
@@ -1028,7 +1028,6 @@ pub(super) struct ScriptVm {
runtime_observable_source_queue: RendererRuntimeObservableSourceQueue,
page_context_cancel_tx: RendererPageContextCancelSender,
pressed_mouse_buttons: i32,
- pending_mouse_press: Option<PendingMousePress>,
hovered_mouse_handle: Option<DomHandle>,
/// Root-frame to local-frame transform for `hovered_mouse_handle`. Blink
/// keeps this conversion on LocalFrameView; retaining the last affine map
@@ -2531,7 +2530,6 @@ impl ScriptVmDefaultWorldBootstrap {
script_execution_memory: ScriptExecutionMemoryCounters::default(),
runtime_observable_source_queue: RendererRuntimeObservableSourceQueue::default(),
pressed_mouse_buttons: 0,
- pending_mouse_press: None,
hovered_mouse_handle: None,
hovered_mouse_root_to_frame: moli_layout::LayoutTransform2D::IDENTITY,
active_touch_pointer_handle: None,
diff --git a/moli-renderer-v8/src/script_vm/input_dispatch.rs b/moli-renderer-v8/src/script_vm/input_dispatch.rs
index b4fc2b8db..31bc8e8c4 100644
--- a/moli-renderer-v8/src/script_vm/input_dispatch.rs
+++ b/moli-renderer-v8/src/script_vm/input_dispatch.rs
@@ -3,9 +3,7 @@ use std::cell::Cell;
use std::rc::Rc;
use super::input_dispatch_outcome;
-use super::input_helpers::{
- MouseReleaseFollowUp, PendingMousePress, mouse_button_mask, single_changed_mouse_button,
-};
+use super::input_helpers::{mouse_button_mask, single_changed_mouse_button};
use super::inspector::{
current_selection_state, is_space_key, key_target_info, option_is_disabled, radio_group_members,
};
@@ -33,7 +31,7 @@ use crate::native_bridge::element::{
text_control_set_selection_range_with_direction_internal, text_control_value, update_focus,
};
use crate::native_bridge::{
- CurrentInputEvent, CurrentInputEventScope, PointerCaptureDispatchEvent,
+ CurrentInputEvent, CurrentInputEventScope, MouseReleaseFollowUp, PointerCaptureDispatchEvent,
};
use crate::runtime::{
RendererDragData, RendererInputDispatchOutcome, RendererPointerEventProperties,
@@ -84,7 +82,6 @@ const TOUCH_POINTER_ID: i32 = 2;
struct PreparedMouseInputDispatch {
button: i32,
buttons: i32,
- released_press: Option<PendingMousePress>,
}
fn touch_pointer_id(touch_id: i32) -> i32 {
@@ -395,6 +392,9 @@ impl ScriptVm {
pointer,
modifiers,
);
+ if event_name == "mouseup" {
+ self._context_host.borrow_mut().clear_mouse_press();
+ }
self.finish_input_event_dispatch_turn(result)
}
@@ -454,7 +454,7 @@ impl ScriptVm {
Rc::clone(&self._context_host),
CurrentInputEvent::mouse(event_name, prepared.button, modifiers),
);
- self.dispatch_mouse_event_at_point_with_pointer_and_modifiers_body(
+ let result = self.dispatch_mouse_event_at_point_with_pointer_and_modifiers_body(
x,
y,
event_name,
@@ -465,7 +465,11 @@ impl ScriptVm {
delta_y,
pointer,
modifiers,
- )
+ );
+ if event_name == "mouseup" {
+ self._context_host.borrow_mut().clear_mouse_press();
+ }
+ result
}
pub(crate) fn mouse_input_surface_hit(
@@ -490,11 +494,6 @@ impl ScriptVm {
buttons: Option<i32>,
) -> PreparedMouseInputDispatch {
let previous_pressed_buttons = self.pressed_mouse_buttons;
- let released_press = if event_name == "mouseup" {
- self.pending_mouse_press.take()
- } else {
- None
- };
let button = if button >= 0 {
button
} else {
@@ -504,9 +503,10 @@ impl ScriptVm {
single_changed_mouse_button(current_buttons & !previous_pressed_buttons)
})
.unwrap_or(-1),
- "mouseup" => released_press
- .as_ref()
- .map(|press| press.button)
+ "mouseup" => self
+ ._context_host
+ .borrow()
+ .mouse_press_button()
.or_else(|| {
buttons.and_then(|current_buttons| {
single_changed_mouse_button(previous_pressed_buttons & !current_buttons)
@@ -523,7 +523,6 @@ impl ScriptVm {
} else {
match event_name {
"mousedown" => {
- self.pending_mouse_press = None;
if button_mask != 0 {
self.pressed_mouse_buttons |= button_mask;
}
@@ -535,11 +534,10 @@ impl ScriptVm {
}
}
let buttons = buttons.unwrap_or(self.pressed_mouse_buttons);
- PreparedMouseInputDispatch {
- button,
- buttons,
- released_press,
+ if event_name == "mousedown" {
+ self._context_host.borrow_mut().clear_mouse_press();
}
+ PreparedMouseInputDispatch { button, buttons }
}
#[allow(clippy::too_many_arguments)]
@@ -556,11 +554,7 @@ impl ScriptVm {
pointer: RendererPointerEventProperties,
modifiers: u8,
) -> Result<RendererInputDispatchOutcome> {
- let PreparedMouseInputDispatch {
- button,
- buttons,
- released_press,
- } = prepared;
+ let PreparedMouseInputDispatch { button, buttons } = prepared;
if let Some(outcome) =
self.dispatch_active_scrollbar_mouse_event(x, y, event_name, button, buttons)?
@@ -638,6 +632,11 @@ impl ScriptVm {
let Some(handle) = capture_handle.or(hit_handle).or(wheel_fallback_handle) else {
return Ok(input_dispatch_outcome(false));
};
+ if pointer_event_name.is_some() {
+ self._context_host
+ .borrow_mut()
+ .set_mouse_event_target(handle);
+ }
let root_to_frame = hit
.filter(|hit| hit.handle == handle)
.map(|hit| hit.root_to_frame)
@@ -663,30 +662,16 @@ impl ScriptVm {
&& buttons & 1 != 0
&& self.active_drag_session.is_none()
{
- self.pending_mouse_press.map(|press| press.handle)
+ self._context_host.borrow().mouse_press_handle()
} else {
None
};
- let follow_up = if event_name == "mouseup" {
- match released_press {
- Some(PendingMousePress {
- handle: pressed_handle,
- button: pressed_button,
- }) if pressed_handle == handle && pressed_button == button => match button {
- 0 => Some(MouseReleaseFollowUp::ActivateViaClick),
- 1 => Some(MouseReleaseFollowUp::DispatchEvent("auxclick")),
- 2 => Some(MouseReleaseFollowUp::DispatchEvent("contextmenu")),
- _ => None,
- },
- _ => None,
- }
- } else {
- if event_name == "mousedown" && button >= 0 {
- self.pending_mouse_press = Some(PendingMousePress { handle, button });
- }
- None
- };
+ if event_name == "mousedown" && button >= 0 {
+ self._context_host
+ .borrow_mut()
+ .begin_mouse_press(handle, button);
+ }
let active_drag_session: *mut Option<ActiveDragSession> = &mut self.active_drag_session;
@@ -794,6 +779,7 @@ impl ScriptVm {
.active_pointer_capture_target(MOUSE_POINTER_ID)
.or(hit_handle)
.unwrap_or(pointer_dispatch_handle);
+ unsafe { &mut *runtime_ptr }.set_mouse_event_target(pointer_dispatch_handle);
}
}
if let Some((Some(previous_handle), previous_root_to_frame)) = hover_transition {
@@ -873,22 +859,16 @@ impl ScriptVm {
suppress_compat_mouse_events = true;
}
}
- if event_name == "mouseup" {
- release_pointer_capture_after_pointer_end(
- scope,
- runtime_ptr,
- MOUSE_POINTER_ID,
- client_x,
- client_y,
- button,
- buttons,
- &pointer,
- modifiers,
- );
- }
+ let mouse_dispatch_handle = if pointer_event_name.is_some() {
+ unsafe { &*runtime_ptr }.mouse_event_target()
+ } else {
+ Some(pointer_dispatch_handle)
+ };
let suppress_current_mouse_event =
suppress_compat_mouse_events && can_suppress_compat_mouse_event(event_name);
- if !suppress_current_mouse_event {
+ if !suppress_current_mouse_event
+ && let Some(mouse_dispatch_handle) = mouse_dispatch_handle
+ {
let event = if event_name == "wheel" {
construct_wheel_event(
scope, event_name, client_x, client_y, delta_x, delta_y, button, buttons,
@@ -901,7 +881,7 @@ impl ScriptVm {
};
if let Some(event) = event {
let dispatched =
- dispatch_public_event(scope, runtime_ptr, pointer_dispatch_handle, event);
+ dispatch_public_event(scope, runtime_ptr, mouse_dispatch_handle, event);
if event_name == "wheel" && dispatched.allows_default() {
let _ = perform_wheel_scroll_default_action(
scope,
@@ -925,6 +905,24 @@ impl ScriptVm {
}
}
}
+ let captured_click_target = if event_name == "mouseup" {
+ let captured =
+ unsafe { &*runtime_ptr }.pointer_capture_target_for_click(MOUSE_POINTER_ID);
+ release_pointer_capture_after_pointer_end(
+ scope,
+ runtime_ptr,
+ MOUSE_POINTER_ID,
+ client_x,
+ client_y,
+ button,
+ buttons,
+ &pointer,
+ modifiers,
+ );
+ captured
+ } else {
+ None
+ };
if let Some(drag_start_handle) = drag_start_handle
&& !suppress_current_mouse_event
{
@@ -1011,15 +1009,28 @@ impl ScriptVm {
active_drag_session.take();
}
}
+ // Keep the host-owned press alive through the release listeners;
+ // synchronous DOM removals can invalidate it before click targeting.
+ let follow_up = if event_name == "mouseup" {
+ mouse_dispatch_handle.and_then(|target| {
+ unsafe { &mut *runtime_ptr }.mouse_release_follow_up(
+ target,
+ button,
+ captured_click_target,
+ )
+ })
+ } else {
+ None
+ };
match follow_up {
- Some(MouseReleaseFollowUp::ActivateViaClick) => {
+ Some(MouseReleaseFollowUp::ActivateViaClick(click_target)) => {
if event_name == "mouseup" {
suppress_compat_mouse_events = false;
}
let outcome = activate_handle_after_pointer_release(
scope,
runtime_ptr,
- handle,
+ click_target,
client_x,
client_y,
button,
@@ -1039,11 +1050,14 @@ impl ScriptVm {
modifiers,
)
{
- let _ = dispatch_public_event(scope, runtime_ptr, handle, event);
+ let _ = dispatch_public_event(scope, runtime_ptr, click_target, event);
}
return Ok(outcome);
}
- Some(MouseReleaseFollowUp::DispatchEvent(follow_up_event_name)) => {
+ Some(MouseReleaseFollowUp::DispatchEvent {
+ name: follow_up_event_name,
+ target,
+ }) => {
if event_name == "mouseup" {
suppress_compat_mouse_events = false;
}
@@ -1061,12 +1075,12 @@ impl ScriptVm {
buttons,
modifiers,
) {
- let dispatched = dispatch_public_event(scope, runtime_ptr, handle, event);
+ let dispatched = dispatch_public_event(scope, runtime_ptr, target, event);
if follow_up_event_name == "auxclick" && dispatched.allows_default() {
pending_download = perform_auxiliary_link_default_action(
scope,
runtime_ptr,
- handle,
+ target,
button,
modifiers,
&pending_child_navigations_before_event,
diff --git a/moli-renderer-v8/src/script_vm/input_helpers.rs b/moli-renderer-v8/src/script_vm/input_helpers.rs
index def624b8e..aea6de430 100644
--- a/moli-renderer-v8/src/script_vm/input_helpers.rs
+++ b/moli-renderer-v8/src/script_vm/input_helpers.rs
@@ -4,18 +4,6 @@ use crate::host::ModuleFailurePolicy;
use crate::module_runtime::{ModuleGraphHandle, ModuleLoadError, ModuleLoadStage};
use crate::types::ScriptErrorConstructorKind;
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub(super) struct PendingMousePress {
- pub(super) handle: DomHandle,
- pub(super) button: i32,
-}
-
-#[derive(Clone, Copy)]
-pub(super) enum MouseReleaseFollowUp {
- ActivateViaClick,
- DispatchEvent(&'static str),
-}
-
pub(super) fn mouse_button_mask(button: i32) -> i32 {
match button {
0 => 1,
@@ -48,7 +36,7 @@ pub(super) fn single_changed_mouse_button(mask: i32) -> Option<i32> {
pub(super) fn clear_input_dispatch_state(vm: &mut ScriptVm) {
vm.pressed_mouse_buttons = 0;
- vm.pending_mouse_press = None;
+ vm._context_host.borrow_mut().clear_mouse_input_state();
vm.hovered_mouse_handle = None;
vm.hovered_mouse_root_to_frame = moli_layout::LayoutTransform2D::IDENTITY;
vm._context_host
diff --git a/moli-renderer-v8/src/script_vm/tests/dom_xhr/dom.rs b/moli-renderer-v8/src/script_vm/tests/dom_xhr/dom.rs
index 44133f3b6..6cd821e66 100644
--- a/moli-renderer-v8/src/script_vm/tests/dom_xhr/dom.rs
+++ b/moli-renderer-v8/src/script_vm/tests/dom_xhr/dom.rs
@@ -19,6 +19,7 @@ mod dom_parser;
mod element_construction;
mod elements_and_events;
mod files_and_transfer;
+mod mouse_click_target;
mod pointer_and_mouse;
mod ranges;
mod rendered_text;
diff --git a/moli-renderer-v8/src/script_vm/tests/dom_xhr/dom/mouse_click_target.rs b/moli-renderer-v8/src/script_vm/tests/dom_xhr/dom/mouse_click_target.rs
new file mode 100644
index 000000000..020aadd8c
--- /dev/null
+++ b/moli-renderer-v8/src/script_vm/tests/dom_xhr/dom/mouse_click_target.rs
@@ -0,0 +1,452 @@
+use super::*;
+
+const SCAN_LINK: &str = r#"<!doctype html><body style="margin:0">
+ <a id="scan" href="/fingerprint-check"
+ style="position:absolute;left:0;top:0;width:240px;height:80px">
+ <span id="left" style="position:absolute;left:0;top:0;width:80px;height:80px">Scan</span>
+ <span id="right" style="position:absolute;left:80px;top:0;width:80px;height:80px">Now</span>
+ </a>
+</body>"#;
+
+fn scan_link_vm() -> StandaloneScriptVmHarness {
+ let mut vm = new_rendered_test_vm("https://mouse-click-target.test/", SCAN_LINK);
+ vm.eval(
+ r#"
+ window.events = [];
+ window.scans = 0;
+ for (const type of ['mousedown', 'mouseup', 'click']) {
+ document.addEventListener(type, event => {
+ events.push([type, event.target.id, event.isTrusted]);
+ });
+ }
+ document.getElementById('scan').addEventListener('click', event => {
+ event.preventDefault();
+ scans++;
+ history.pushState({}, '', '/fingerprint-check');
+ });
+ "#,
+ )
+ .expect("scan link listeners should install");
+ vm
+}
+
+fn mouse_button(vm: &mut StandaloneScriptVmHarness, x: f64, event: &str) {
+ vm.dispatch_mouse_event_at_point(x, 20.0, event, 0, None, 0.0, 0.0)
+ .expect("coordinate mouse input should dispatch");
+}
+
+#[test]
+fn mouse_click_uses_common_ancestor_of_press_and_release_targets() {
+ for (down_x, up_x, down_target, up_target, click_target) in [
+ (20.0, 20.0, "left", "left", "left"),
+ (20.0, 100.0, "left", "right", "scan"),
+ (20.0, 200.0, "left", "scan", "scan"),
+ (200.0, 20.0, "scan", "left", "scan"),
+ ] {
+ let mut vm = scan_link_vm();
+ mouse_button(&mut vm, down_x, "mousedown");
+ mouse_button(&mut vm, up_x, "mouseup");
+ assert_eq!(
+ vm.eval("JSON.stringify([events, scans, location.pathname])")
+ .expect("scan result should evaluate"),
+ serde_json::json!([
+ [
+ ["mousedown", down_target, true],
+ ["mouseup", up_target, true],
+ ["click", click_target, true]
+ ],
+ 1,
+ "/fingerprint-check"
+ ])
+ .to_string(),
+ "press {down_target}, release {up_target}"
+ );
+ }
+}
+
+#[test]
+fn mouse_click_survives_layout_shift_within_the_same_link() {
+ let mut vm = scan_link_vm();
+ mouse_button(&mut vm, 20.0, "mousedown");
+ vm.eval("document.getElementById('left').style.left = '100px'")
+ .expect("the pressed span should move within its link");
+ vm.publish_layout_for_test()
+ .expect("publish the changed layout before release");
+ mouse_button(&mut vm, 20.0, "mouseup");
+ assert_eq!(
+ vm.eval("JSON.stringify([events, scans, location.pathname])")
+ .expect("scan result should evaluate"),
+ r#"[[["mousedown","left",true],["mouseup","scan",true],["click","scan",true]],1,"/fingerprint-check"]"#
+ );
+}
+
+#[test]
+fn mouse_click_is_suppressed_when_a_press_or_release_target_is_removed() {
+ for remove in [
+ "document.getElementById('left').remove()",
+ "document.addEventListener('mouseup', () => document.getElementById('left').remove(), {once:true})",
+ "document.addEventListener('mouseup', event => event.target.remove(), {once:true})",
+ "document.addEventListener('mouseup', () => document.getElementById('right').appendChild(document.getElementById('left')), {once:true})",
+ "document.addEventListener('mouseup', () => { const left = document.getElementById('left'); left.remove(); document.getElementById('scan').prepend(left); }, {once:true})",
+ "document.addEventListener('mouseup', () => { const scan = document.getElementById('scan'); scan.remove(); document.body.appendChild(scan); }, {once:true})",
+ "document.addEventListener('mouseup', () => document.getElementById('right').moveBefore(document.getElementById('left'), null), {once:true})",
+ ] {
+ let mut vm = scan_link_vm();
+ mouse_button(&mut vm, 20.0, "mousedown");
+ vm.eval(remove).expect("target removal should install");
+ vm.publish_layout_for_test()
+ .expect("publish geometry before release");
+ mouse_button(&mut vm, 100.0, "mouseup");
+ assert_eq!(
+ vm.eval(
+ "JSON.stringify([events.filter(e => e[0] === 'click'), scans, location.pathname])"
+ )
+ .expect("scan result should evaluate"),
+ r#"[[],0,"/"]"#,
+ "removal: {remove}"
+ );
+ }
+}
+
+#[test]
+fn mouse_click_uses_current_ancestry_when_only_the_release_target_is_reinserted() {
+ for (mutation, target) in [
+ (
+ "const parent = event.target.parentNode; event.target.remove(); parent.appendChild(event.target);",
+ "scan",
+ ),
+ (
+ "document.getElementById('left').appendChild(event.target);",
+ "left",
+ ),
+ ] {
+ let mut vm = scan_link_vm();
+ vm.eval(&format!(
+ "document.addEventListener('mouseup', event => {{ {mutation} }}, {{once:true}})"
+ ))
+ .expect("release target mutation should install");
+ mouse_button(&mut vm, 20.0, "mousedown");
+ mouse_button(&mut vm, 100.0, "mouseup");
+ assert_eq!(
+ vm.eval("JSON.stringify([events, scans, location.pathname])")
+ .expect("scan result should evaluate"),
+ serde_json::json!([
+ [
+ ["mousedown", "left", true],
+ ["mouseup", "right", true],
+ ["click", target, true]
+ ],
+ 1,
+ "/fingerprint-check"
+ ])
+ .to_string(),
+ "release mutation: {mutation}"
+ );
+ }
+}
+
+#[test]
+fn mouse_click_targets_the_pointerup_capture_target_after_capture_is_released() {
+ let mut vm = scan_link_vm();
+ vm.eval(
+ "document.getElementById('left').addEventListener('pointerdown', event => document.getElementById('right').setPointerCapture(event.pointerId))",
+ )
+ .expect("capture transfer should install");
+ mouse_button(&mut vm, 20.0, "mousedown");
+ mouse_button(&mut vm, 20.0, "mouseup");
+ assert_eq!(
+ vm.eval("JSON.stringify([events, scans, location.pathname, document.getElementById('right').hasPointerCapture(1)])")
+ .expect("scan result should evaluate"),
+ r#"[[["mousedown","left",true],["mouseup","right",true],["click","right",true]],1,"/fingerprint-check",false]"#
+ );
+}
+
+const SHADOW_CLICK_HOST: &str = r#"<!doctype html><body style="margin:0">
+ <div id="host" style="position:absolute;left:0;top:0;width:240px;height:80px">
+ <span id="left" style="position:absolute;left:0;top:0;width:80px;height:80px">Left</span>
+ <span id="right" style="position:absolute;left:80px;top:0;width:80px;height:80px">Right</span>
+ </div>
+</body>"#;
+
+fn shadow_click_vm(setup: &str) -> StandaloneScriptVmHarness {
+ shadow_click_vm_with_options(setup, "{mode:'open'}")
+}
+
+fn shadow_click_vm_with_options(setup: &str, options: &str) -> StandaloneScriptVmHarness {
+ let mut vm = new_rendered_test_vm("https://shadow-click-target.test/", SHADOW_CLICK_HOST);
+ vm.eval(&format!(
+ r#"
+ window.host = document.getElementById('host');
+ window.left = document.getElementById('left');
+ window.right = document.getElementById('right');
+ window.root = host.attachShadow({options});
+ {setup}
+ window.clicks = [];
+ document.addEventListener('click', event => {{
+ clicks.push([event.target.id, event.composedPath()[0].id, event.isTrusted]);
+ }});
+ "#
+ ))
+ .expect("shadow click fixture should initialize");
+ vm.publish_layout_for_test()
+ .expect("publish distributed shadow content before input");
+ vm
+}
+
+#[test]
+fn mouse_click_uses_the_flat_tree_across_shadow_roots_and_slots() {
+ for (setup, target) in [
+ ("root.append(left, right);", "host"),
+ ("root.innerHTML = '<slot id=slot></slot>';", "slot"),
+ (
+ "left.slot = 'left'; right.slot = 'right'; root.innerHTML = '<a id=scan><slot name=left></slot><slot name=right></slot></a>';",
+ "scan",
+ ),
+ (
+ "root.innerHTML = '<a id=scan><slot></slot></a>'; root.querySelector('a').append(right);",
+ "scan",
+ ),
+ (
+ "root.innerHTML = '<slot id=slot name=fallback></slot>'; root.querySelector('slot').append(left, right);",
+ "slot",
+ ),
+ (
+ "const a = document.createElement('div'), b = document.createElement('div'); a.style.cssText = 'position:absolute;left:0;top:0;width:80px;height:80px'; b.style.cssText = 'position:absolute;left:80px;top:0;width:80px;height:80px'; right.style.left = '0'; a.attachShadow({mode:'open'}).append(left); b.attachShadow({mode:'open'}).append(right); root.append(a,b);",
+ "host",
+ ),
+ ] {
+ let mut vm = shadow_click_vm(setup);
+ mouse_button(&mut vm, 20.0, "mousedown");
+ mouse_button(&mut vm, 100.0, "mouseup");
+ assert_eq!(
+ vm.eval("JSON.stringify(clicks)")
+ .expect("clicks should evaluate"),
+ serde_json::json!([["host", target, true]]).to_string(),
+ "shadow setup: {setup}"
+ );
+ }
+}
+
+#[test]
+fn mouse_click_uses_slot_assignment_at_click_dispatch_time() {
+ for manual in [false, true] {
+ let setup = if manual {
+ "host.shadowRoot.innerHTML = '<slot id=first></slot><slot id=second></slot>'; root.querySelector('#first').assign(left); root.querySelector('#second').assign(right);"
+ } else {
+ "left.slot = 'first'; right.slot = 'second'; root.innerHTML = '<slot id=first name=first></slot><slot id=second name=second></slot>';"
+ };
+ let options = if manual {
+ "{mode:'open',slotAssignment:'manual'}"
+ } else {
+ "{mode:'open'}"
+ };
+ let mut vm = shadow_click_vm_with_options(setup, options);
+ vm.eval(if manual {
+ "document.addEventListener('mouseup', () => root.querySelector('#second').assign(left,right), {once:true})"
+ } else {
+ "document.addEventListener('mouseup', () => { left.slot = 'second'; }, {once:true})"
+ }).expect("slot reassignment listener should install");
+ mouse_button(&mut vm, 20.0, "mousedown");
+ mouse_button(&mut vm, 100.0, "mouseup");
+ assert_eq!(
+ vm.eval("JSON.stringify(clicks)")
+ .expect("clicks should evaluate"),
+ r#"[["host","second",true]]"#,
+ "manual slot assignment: {manual}"
+ );
+ }
+}
+
+#[test]
+fn mouse_click_removal_checks_dom_ancestry_instead_of_slot_distribution() {
+ for (mutation, expected) in [
+ (
+ "const slot = root.querySelector('slot'); slot.remove(); root.append(slot);",
+ r#"[["host","slot",true]]"#,
+ ),
+ ("host.remove(); document.body.append(host);", "[]"),
+ ] {
+ let mut vm = shadow_click_vm("root.innerHTML = '<slot id=slot></slot>';");
+ vm.eval(&format!(
+ "document.addEventListener('mouseup', () => {{ {mutation} }}, {{once:true}})"
+ ))
+ .expect("removal listener should install");
+ mouse_button(&mut vm, 20.0, "mousedown");
+ mouse_button(&mut vm, 100.0, "mouseup");
+ assert_eq!(
+ vm.eval("JSON.stringify(clicks)")
+ .expect("clicks should evaluate"),
+ expected,
+ "removal: {mutation}"
+ );
+ }
+}
+
+#[test]
+fn mouse_click_does_not_cross_unassigned_nodes_or_replaced_slot_fallback() {
+ for (setup, mutation) in [
+ (
+ "left.slot = 'first'; right.slot = 'second'; root.innerHTML = '<slot name=first></slot><slot name=second></slot>';",
+ "left.slot = 'missing';",
+ ),
+ (
+ "left.slot = 'first'; right.slot = 'second'; root.innerHTML = '<slot name=first></slot><slot name=second></slot>';",
+ "right.slot = 'missing';",
+ ),
+ (
+ "root.innerHTML = '<slot name=fallback></slot>'; root.querySelector('slot').append(left,right);",
+ "const assigned = document.createElement('span'); assigned.slot = 'fallback'; host.append(assigned);",
+ ),
+ ] {
+ let mut vm = shadow_click_vm(setup);
+ vm.eval(&format!(
+ "document.addEventListener('mouseup', () => {{ {mutation} }}, {{once:true}})"
+ ))
+ .expect("distribution change listener should install");
+ mouse_button(&mut vm, 20.0, "mousedown");
+ mouse_button(&mut vm, 100.0, "mouseup");
+ assert_eq!(
+ vm.eval("JSON.stringify(clicks)")
+ .expect("clicks should evaluate"),
+ "[]",
+ "distribution change: {mutation}"
+ );
+ }
+}
+
+#[test]
+fn mouse_auxclick_uses_the_flat_tree_common_ancestor() {
+ let mut vm = shadow_click_vm("root.innerHTML = '<slot id=slot></slot>';");
+ vm.eval(
+ "document.addEventListener('auxclick', event => { event.preventDefault(); clicks.push([event.target.id,event.composedPath()[0].id,event.isTrusted]); });",
+ ).expect("auxclick listener should install");
+ vm.dispatch_mouse_event_at_point(20.0, 20.0, "mousedown", 1, None, 0.0, 0.0)
+ .expect("middle button press should dispatch");
+ vm.dispatch_mouse_event_at_point(100.0, 20.0, "mouseup", 1, None, 0.0, 0.0)
+ .expect("middle button release should dispatch");
+ assert_eq!(
+ vm.eval("JSON.stringify(clicks)")
+ .expect("clicks should evaluate"),
+ r#"[["host","slot",true]]"#,
+ );
+}
+
+#[test]
+fn mouse_release_without_a_hit_clears_the_pending_click() {
+ let mut vm = scan_link_vm();
+ mouse_button(&mut vm, 20.0, "mousedown");
+ vm.dispatch_mouse_event_at_point(2000.0, 2000.0, "mouseup", 0, None, 0.0, 0.0)
+ .expect("release outside the viewport should complete");
+ mouse_button(&mut vm, 20.0, "mouseup");
+ assert_eq!(
+ vm.eval("JSON.stringify([events.filter(e => e[0] === 'click'), scans])")
+ .expect("clicks should evaluate"),
+ "[[],0]",
+ );
+}
+
+#[test]
+fn mouse_click_in_a_closed_shadow_tree_targets_the_slot_and_retargets_outside() {
+ let mut vm = shadow_click_vm_with_options(
+ "root.innerHTML = '<slot id=slot></slot>';",
+ "{mode:'closed'}",
+ );
+ vm.eval(
+ "root.addEventListener('click', event => clicks.push(['shadow',event.target.id,event.isTrusted]));",
+ ).expect("closed shadow listener should install");
+ mouse_button(&mut vm, 20.0, "mousedown");
+ mouse_button(&mut vm, 100.0, "mouseup");
+ assert_eq!(
+ vm.eval("JSON.stringify(clicks)")
+ .expect("clicks should evaluate"),
+ r#"[["shadow","slot",true],["host","host",true]]"#,
+ );
+}
+
+#[test]
+fn mouse_click_capture_overrides_the_flat_tree_for_an_unassigned_target() {
+ let mut vm = shadow_click_vm(
+ "left.slot = 'shown'; right.slot = 'hidden'; root.innerHTML = '<slot name=shown></slot>'; left.addEventListener('pointerdown', event => right.setPointerCapture(event.pointerId));",
+ );
+ mouse_button(&mut vm, 20.0, "mousedown");
+ mouse_button(&mut vm, 20.0, "mouseup");
+ assert_eq!(
+ vm.eval("JSON.stringify([clicks,right.hasPointerCapture(1)])")
+ .expect("capture result should evaluate"),
+ r#"[[["right","right",true]],false]"#,
+ );
+}
+
+#[test]
+fn mouse_release_retargets_when_pointerup_removes_or_reparents_its_target() {
+ for mutation in [
+ "event.target.remove();",
+ "document.getElementById('left').append(event.target);",
+ ] {
+ let mut vm = scan_link_vm();
+ vm.eval(&format!(
+ "document.addEventListener('pointerup', event => {{ {mutation} }}, {{once:true}})"
+ ))
+ .expect("pointerup mutation listener should install");
+ mouse_button(&mut vm, 20.0, "mousedown");
+ mouse_button(&mut vm, 100.0, "mouseup");
+ assert_eq!(
+ vm.eval("JSON.stringify([events,scans,location.pathname])")
+ .expect("release result should evaluate"),
+ r#"[[["mousedown","left",true],["mouseup","scan",true],["click","scan",true]],1,"/fingerprint-check"]"#,
+ "pointerup mutation: {mutation}"
+ );
+ }
+}
+
+#[test]
+fn mouse_release_retargets_a_removed_slotted_target_to_its_dom_parent() {
+ let mut vm = shadow_click_vm("root.innerHTML = '<slot id=slot></slot>';");
+ vm.eval(
+ "window.releases=[]; document.addEventListener('mouseup', e => releases.push(e.composedPath()[0].id)); document.addEventListener('pointerup', e => e.target.remove(), {once:true});",
+ ).expect("slotted removal listeners should install");
+ mouse_button(&mut vm, 20.0, "mousedown");
+ mouse_button(&mut vm, 100.0, "mouseup");
+ assert_eq!(
+ vm.eval("JSON.stringify([releases,clicks])")
+ .expect("slotted release result should evaluate"),
+ r#"[["host"],[["host","host",true]]]"#,
+ );
+}
+
+#[test]
+fn mouse_click_keeps_the_capture_target_when_release_listeners_move_or_remove_it() {
+ for event_type in ["pointerup", "mouseup"] {
+ for reinsert in [false, true] {
+ let mut vm = scan_link_vm();
+ let mutation = if reinsert {
+ "document.getElementById('left').append(event.target);"
+ } else {
+ "event.target.remove();"
+ };
+ vm.eval(&format!(
+ r#"
+ window.right = document.getElementById('right');
+ window.nodeClicks = [];
+ right.addEventListener('click', e => nodeClicks.push([e.target.id,e.isTrusted]));
+ document.getElementById('left').addEventListener('pointerdown', e => right.setPointerCapture(e.pointerId));
+ document.addEventListener('{event_type}', event => {{ {mutation} }}, {{once:true}});
+ "#
+ )).expect("captured release listeners should install");
+ mouse_button(&mut vm, 20.0, "mousedown");
+ mouse_button(&mut vm, 20.0, "mouseup");
+ assert_eq!(
+ vm.eval("JSON.stringify([events.filter(e=>e[0]==='mouseup'),events.filter(e=>e[0]==='click'),nodeClicks,scans,right.hasPointerCapture(1)])")
+ .expect("captured release result should evaluate"),
+ serde_json::json!([
+ [["mouseup", if event_type == "pointerup" { "scan" } else { "right" }, true]],
+ if reinsert { serde_json::json!([["click", "right", true]]) } else { serde_json::json!([]) },
+ [["right", true]],
+ if reinsert { 1 } else { 0 },
+ false,
+ ]).to_string(),
+ "release event: {event_type}, reinsert: {reinsert}",
+ );
+ }
+ }
+}
diff --git a/moli-renderer-v8/src/script_vm/tests/dom_xhr/dom/pointer_and_mouse.rs b/moli-renderer-v8/src/script_vm/tests/dom_xhr/dom/pointer_and_mouse.rs
index 3e1480b83..bc1007321 100644
--- a/moli-renderer-v8/src/script_vm/tests/dom_xhr/dom/pointer_and_mouse.rs
+++ b/moli-renderer-v8/src/script_vm/tests/dom_xhr/dom/pointer_and_mouse.rs
@@ -300,9 +300,9 @@ fn pointer_capture_routes_mouse_pointer_until_pointerup() {
}
#[test]
-fn pointer_capture_lost_dispatches_before_compat_mouseup() {
+fn pointer_capture_lost_dispatches_after_compat_mouseup() {
let mut vm = new_rendered_test_vm(
- "https://pointer-capture-lost-before-mouseup.test/",
+ "https://pointer-capture-lost-after-mouseup.test/",
r#"<html><body><div id="target0">capture</div></body></html>"#,
);
vm.eval(
@@ -329,14 +329,14 @@ fn pointer_capture_lost_dispatches_before_compat_mouseup() {
vm.dispatch_mouse_event_at_point(10.0, 11.0, "mousedown", 0, None, 0.0, 0.0)
.expect("mousedown should dispatch pointerdown");
vm.dispatch_mouse_event_at_point(10.0, 11.0, "mouseup", 0, None, 0.0, 0.0)
- .expect("mouseup should dispatch pointerup, lostpointercapture, mouseup");
+ .expect("mouseup should dispatch pointerup, mouseup, lostpointercapture");
let result = vm
.eval("window.__captureMouseupOrder.join('|')")
.expect("capture mouseup order log should evaluate");
assert_eq!(
result,
- "pointerdown|gotpointercapture|pointerup|lostpointercapture|mouseup"
+ "pointerdown|gotpointercapture|pointerup|mouseup|lostpointercapture"
);
}