Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsnew file mode 100644index 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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_hostdiff --git a/moli-renderer-v8/src/script_vm/tests/dom_xhr/dom.rs b/moli-renderer-v8/src/script_vm/tests/dom_xhr/dom.rsindex 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.rsnew file mode 100644index 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.rsindex 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");}