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(events): derive inherited pointing event dictionaries
ldm0c3bc716f53b1
diff --git a/moli-renderer-v8/src/context_bootstrap/event_template.rs b/moli-renderer-v8/src/context_bootstrap/event_template.rsindex 4944fc601..a01a27e96 100644--- a/moli-renderer-v8/src/context_bootstrap/event_template.rs+++ b/moli-renderer-v8/src/context_bootstrap/event_template.rs@@ -314,6 +314,9 @@ struct KeyboardEventTemplateMethodsDeclaration {#[derive(WebApiFunctionTemplate)]#[webapi(interface = web_api_interfaces::MouseEvent, enumerable, receiver)]struct MouseEventTemplateMethodsDeclaration {+ #[webapi(method = "getModifierState", length = 1, callback = event_get_modifier_state_callback)]+ get_modifier_state: (),+#[webapi(accessor_property = "relatedTarget",getter = mouse_event_related_target_getter_function@@ -331,8 +334,15 @@ struct MouseEventTemplateMethodsDeclaration {}#[derive(WebApiFunctionTemplate)]-#[webapi(interface = web_api_interfaces::WheelEvent, enumerable)]+#[webapi(interface = web_api_interfaces::WheelEvent, enumerable, receiver)]struct WheelEventTemplateConstantsDeclaration {+ #[webapi(accessor_property, getter = event_value_attribute_getter, data = crate::util::v8str(scope, "wheelDeltaX"))]+ wheel_delta_x: (),+ #[webapi(accessor_property, getter = event_value_attribute_getter, data = crate::util::v8str(scope, "wheelDeltaY"))]+ wheel_delta_y: (),+ #[webapi(accessor_property, getter = event_value_attribute_getter, data = crate::util::v8str(scope, "wheelDelta"))]+ wheel_delta: (),+#[webapi(constant = "DOM_DELTA_PIXEL", value = 0u32)]dom_delta_pixel: (),@@ -346,6 +356,9 @@ struct WheelEventTemplateConstantsDeclaration {#[derive(WebApiFunctionTemplate)]#[webapi(interface = web_api_interfaces::PointerEvent, enumerable, receiver)]struct PointerEventTemplateMethodsDeclaration {+ #[webapi(accessor_property, getter = event_value_attribute_getter, data = crate::util::v8str(scope, "persistentDeviceId"))]+ persistent_device_id: (),+#[webapi(method = "getPredictedEvents",length = 0,diff --git a/moli-renderer-v8/src/context_bootstrap/events/subclasses/constructor.rs b/moli-renderer-v8/src/context_bootstrap/events/subclasses/constructor.rsindex 0c4d2573b..8ab64db11 100644--- a/moli-renderer-v8/src/context_bootstrap/events/subclasses/constructor.rs+++ b/moli-renderer-v8/src/context_bootstrap/events/subclasses/constructor.rs@@ -57,6 +57,20 @@ fn event_subclass_constructor_callback<'s>(} else {None};+ let pointer_event_init = if matches!(+ kind,+ EventSubclassKind::MouseEvent+ | EventSubclassKind::WheelEvent+ | EventSubclassKind::PointerEvent+ | EventSubclassKind::DragEvent+ ) {+ let Some(init) = pointer::PointerEventInitPayload::parse(scope, &args, kind) else {+ return;+ };+ Some(init)+ } else {+ None+ };let storage_event_init = if kind == EventSubclassKind::StorageEvent {let Some(init) = data::parse_storage_event_init(scope, &args) else {return;@@ -122,6 +136,11 @@ fn event_subclass_constructor_callback<'s>(.as_ref().map(basic::BasicEventInit::event_flags)})+ .or_else(|| {+ pointer_event_init+ .as_ref()+ .map(pointer::PointerEventInitPayload::event_flags)+ }).or_else(|| read_event_init(scope, &args))else {return;@@ -147,15 +166,13 @@ fn event_subclass_constructor_callback<'s>(.expect("basic event init is parsed").initialize(scope, event);}- EventSubclassKind::MouseEvent => {- if !pointer::initialize_mouse_event(scope, event, init) {- return;- }- }- EventSubclassKind::DragEvent => {- if !data::initialize_drag_event(scope, event, init) {- return;- }+ EventSubclassKind::MouseEvent+ | EventSubclassKind::WheelEvent+ | EventSubclassKind::PointerEvent+ | EventSubclassKind::DragEvent => {+ pointer_event_init+ .expect("pointing event init is parsed")+ .initialize(scope, event);}EventSubclassKind::ClipboardEvent => {data::initialize_clipboard_event(scope, event, init);@@ -173,16 +190,6 @@ fn event_subclass_constructor_callback<'s>();}EventSubclassKind::InputEvent => data::initialize_input_event(scope, event, init),- EventSubclassKind::WheelEvent => {- if !pointer::initialize_wheel_event(scope, event, init) {- return;- }- }- EventSubclassKind::PointerEvent => {- if !pointer::initialize_pointer_event(scope, event, init) {- return;- }- }EventSubclassKind::TouchEvent => {crate::context_bootstrap::touch_runtime::initialize_touch_event(scope, event, init);}diff --git a/moli-renderer-v8/src/context_bootstrap/events/subclasses/data.rs b/moli-renderer-v8/src/context_bootstrap/events/subclasses/data.rsindex 3a2a5cc49..bb7f74ba9 100644--- a/moli-renderer-v8/src/context_bootstrap/events/subclasses/data.rs+++ b/moli-renderer-v8/src/context_bootstrap/events/subclasses/data.rs@@ -1,6 +1,5 @@use super::*;use crate::context_bootstrap::events::EventInit;-use crate::context_bootstrap::file_api::is_branded_data_transfer_object;use crate::context_bootstrap::navigation_activation::install_navigation_transition;use crate::context_bootstrap::navigation_events::navigation_scroll_event_is_active;use crate::context_bootstrap::navigation_handler_callbacks::{@@ -131,12 +130,6 @@ struct NavigateEventMethodsDeclaration {scroll: (),}-#[derive(WebApiObject)]-#[webapi(plain, data_properties, enumerable)]-struct DragEventInitDeclaration<'scope> {- data_transfer: v8::Local<'scope, v8::Value>,-}-#[derive(WebApiObject)]#[webapi(plain, data_properties, enumerable)]struct ClipboardEventInitDeclaration<'scope> {@@ -293,53 +286,6 @@ pub(super) fn parse_storage_event_init<'s>(crate::context_bootstrap::events::parse_event_dictionary(scope, args, "StorageEvent")}-pub(in crate::context_bootstrap::events::subclasses) fn initialize_drag_event<'s>(- scope: &mut v8::PinScope<'s, '_>,- event: v8::Local<'s, v8::Object>,- init: Option<v8::Local<'s, v8::Object>>,-) -> bool {- if !pointer::initialize_mouse_event(scope, event, init) {- return false;- }- let data_transfer = match init {- None => v8::null(scope).into(),- Some(init) => match webidl::property_result(- scope,- init,- "dataTransfer",- webidl::Context::member("DragEventInit", "dataTransfer"),- ) {- Err(error) => {- webidl::throw_error(scope, &error);- return false;- }- Ok(None) => v8::null(scope).into(),- Ok(Some(value)) if value.is_null_or_undefined() => v8::null(scope).into(),- Ok(Some(value)) => {- let Ok(object) = v8::Local::<v8::Object>::try_from(value) else {- throw_type_error(- scope,- "Failed to construct 'DragEvent': member dataTransfer is not of type DataTransfer.",- );- return false;- };- if !is_branded_data_transfer_object(scope, object) {- throw_type_error(- scope,- "Failed to construct 'DragEvent': member dataTransfer is not of type DataTransfer.",- );- return false;- }- value- }- },- };- DragEventInitDeclaration::new(data_transfer)- .initialize(scope, event)- .expect("DragEvent init declaration should initialize");- true-}-pub(in crate::context_bootstrap::events::subclasses) fn initialize_clipboard_event<'s>(scope: &mut v8::PinScope<'s, '_>,event: v8::Local<'s, v8::Object>,diff --git a/moli-renderer-v8/src/context_bootstrap/events/subclasses/pointer.rs b/moli-renderer-v8/src/context_bootstrap/events/subclasses/pointer.rsindex f97ca961f..6ce6b38c3 100644--- a/moli-renderer-v8/src/context_bootstrap/events/subclasses/pointer.rs+++ b/moli-renderer-v8/src/context_bootstrap/events/subclasses/pointer.rs@@ -1,35 +1,267 @@-use super::*;+use super::EventSubclassKind;use moli_webapi_declare::WebApiObject;+use crate::context_bootstrap::events::modifiers::EventModifierInit;+use crate::context_bootstrap::file_api::is_branded_data_transfer_object;+use crate::util::throw_type_error;+use crate::web_api_interfaces;use crate::webidl;-use webidl::WebIdlDictionarySerialize;const POINTER_EVENT_COALESCED_EVENTS_SLOT: &str = "__moliPointerEventCoalescedEvents";const POINTER_EVENT_PREDICTED_EVENTS_SLOT: &str = "__moliPointerEventPredictedEvents";-#[derive(Default, webidl::WebIdlDictionary)]-#[webidl(prefix = "PointerEventInit", snapshot)]-struct PointerEventSequences<'scope> {- #[webidl(sequence, interface = crate::web_api_interfaces::PointerEvent, brand_check = is_pointer_event_sequence_item, default = Vec::new())]- #[webidl(snapshot_slot = POINTER_EVENT_COALESCED_EVENTS_SLOT)]- coalesced_events: Vec<v8::Local<'scope, v8::Object>>,- #[webidl(sequence, interface = crate::web_api_interfaces::PointerEvent, brand_check = is_pointer_event_sequence_item, default = Vec::new())]- #[webidl(snapshot_slot = POINTER_EVENT_PREDICTED_EVENTS_SLOT)]- predicted_events: Vec<v8::Local<'scope, v8::Object>>,+#[derive(WebApiObject)]+#[webapi(plain)]+struct PointerEventSequences<'s> {+ #[webapi(slot = POINTER_EVENT_COALESCED_EVENTS_SLOT)]+ coalesced_events: Vec<v8::Local<'s, v8::Object>>,+ #[webapi(slot = POINTER_EVENT_PREDICTED_EVENTS_SLOT)]+ predicted_events: Vec<v8::Local<'s, v8::Object>>,}-fn is_pointer_event_sequence_item<'s>(- scope: &mut v8::PinScope<'s, '_>,- event: v8::Local<'s, v8::Object>,-) -> bool {- super::super::event_subclass_kind(scope, event) == Some(EventSubclassKind::PointerEvent)+/// MouseEventInit includes the CSSOM View and Pointer Lock double members.+/// Each derived dictionary delegates to this base before reading its own members.+#[derive(webidl::WebIdlDictionary)]+#[webidl(prefix = "MouseEventInit")]+pub(super) struct MouseEventInit<'s> {+ #[webidl(inherit)]+ modifiers: EventModifierInit<'s>,+ #[webidl(default = 0)]+ button: i16,+ #[webidl(default = 0)]+ buttons: u16,+ #[webidl(default = 0.0, converter = "double")]+ client_x: f64,+ #[webidl(default = 0.0, converter = "double")]+ client_y: f64,+ #[webidl(default = 0.0, converter = "double")]+ movement_x: f64,+ #[webidl(default = 0.0, converter = "double")]+ movement_y: f64,+ // Blink still converts the obsolete hit-region member, without exposing it.+ #[webidl(name = "region", nullable, converter = "raw")]+ _region: Option<webidl::DomString16>,+ #[webidl(nullable, interface = web_api_interfaces::EventTarget)]+ related_target: Option<v8::Local<'s, v8::Object>>,+ #[webidl(default = 0.0, converter = "double")]+ screen_x: f64,+ #[webidl(default = 0.0, converter = "double")]+ screen_y: f64,+}++impl<'s> MouseEventInit<'s> {+ pub(super) fn event_flags(&self) -> (bool, bool, bool) {+ self.modifiers.event_flags()+ }++ pub(super) fn initialize(+ &self,+ scope: &mut v8::PinScope<'s, '_>,+ event: v8::Local<'s, v8::Object>,+ ) {+ self.modifiers.initialize(scope, event);+ MouseEventBaseInitDeclaration::new(+ self.screen_x,+ self.screen_y,+ self.client_x,+ self.client_y,+ self.client_x,+ self.client_y,+ self.client_x,+ self.client_y,+ self.button,+ self.buttons,+ self.movement_x,+ self.movement_y,+ )+ .initialize(scope, event)+ .expect("MouseEvent state should initialize");+ let related_target = self+ .related_target+ .map(Into::into)+ .unwrap_or_else(|| v8::null(scope).into());+ MouseEventRelatedTargetDeclaration::new(related_target)+ .initialize(scope, event)+ .expect("MouseEvent relatedTarget should initialize");+ }+}++#[derive(webidl::WebIdlDictionary)]+#[webidl(prefix = "WheelEventInit")]+pub(super) struct WheelEventInit<'s> {+ #[webidl(inherit)]+ mouse: MouseEventInit<'s>,+ #[webidl(default = 0)]+ delta_mode: u32,+ #[webidl(default = 0.0, converter = "double")]+ delta_x: f64,+ #[webidl(default = 0.0, converter = "double")]+ delta_y: f64,+ #[webidl(default = 0.0, converter = "double")]+ delta_z: f64,+ #[webidl(default = 0)]+ wheel_delta_x: i32,+ #[webidl(default = 0)]+ wheel_delta_y: i32,+}++impl<'s> WheelEventInit<'s> {+ pub(super) fn event_flags(&self) -> (bool, bool, bool) {+ self.mouse.event_flags()+ }++ pub(super) fn initialize(+ self,+ scope: &mut v8::PinScope<'s, '_>,+ event: v8::Local<'s, v8::Object>,+ ) {+ self.mouse.initialize(scope, event);+ // Legacy deltas use their nonzero initializer or a saturating,+ // truncating projection of the CSSOM delta. This follows Blink's+ // constructor and is separate from WebIDL's wrapping long conversion.+ let wheel_delta_x = if self.wheel_delta_x != 0 {+ self.wheel_delta_x+ } else {+ self.delta_x as i32+ };+ let wheel_delta_y = if self.wheel_delta_y != 0 {+ self.wheel_delta_y+ } else {+ self.delta_y as i32+ };+ WheelEventDeltaInitDeclaration::new(+ self.delta_x,+ self.delta_y,+ self.delta_z,+ self.delta_mode,+ wheel_delta_x,+ wheel_delta_y,+ if wheel_delta_y != 0 {+ wheel_delta_y+ } else {+ wheel_delta_x+ },+ )+ .initialize(scope, event)+ .expect("WheelEvent state should initialize");+ }+}++#[derive(webidl::WebIdlDictionary)]+#[webidl(prefix = "PointerEventInit")]+pub(super) struct PointerEventInit<'s> {+ #[webidl(inherit)]+ mouse: MouseEventInit<'s>,+ #[webidl(converter = "double")]+ altitude_angle: Option<f64>,+ #[webidl(converter = "double")]+ azimuth_angle: Option<f64>,+ #[webidl(sequence, interface = web_api_interfaces::PointerEvent, brand_check = is_pointer_event_sequence_item, default = Vec::new())]+ coalesced_events: Vec<v8::Local<'s, v8::Object>>,+ #[webidl(default = 1.0, converter = "double")]+ height: f64,+ #[webidl(default = false)]+ is_primary: bool,+ #[webidl(default = 0)]+ persistent_device_id: i32,+ #[webidl(default = 0)]+ pointer_id: i32,+ #[webidl(default = webidl::DomString16(Vec::new()), converter = "raw")]+ pointer_type: webidl::DomString16,+ #[webidl(sequence, interface = web_api_interfaces::PointerEvent, brand_check = is_pointer_event_sequence_item, default = Vec::new())]+ predicted_events: Vec<v8::Local<'s, v8::Object>>,+ #[webidl(default = 0.0)]+ pressure: f32,+ #[webidl(default = 0.0)]+ tangential_pressure: f32,+ tilt_x: Option<i32>,+ tilt_y: Option<i32>,+ #[webidl(default = 0)]+ twist: i32,+ #[webidl(default = 1.0, converter = "double")]+ width: f64,+}++impl<'s> PointerEventInit<'s> {+ pub(super) fn event_flags(&self) -> (bool, bool, bool) {+ self.mouse.event_flags()+ }++ pub(super) fn initialize(+ self,+ scope: &mut v8::PinScope<'s, '_>,+ event: v8::Local<'s, v8::Object>,+ ) {+ self.mouse.initialize(scope, event);+ let angles = pointer_event_angle_init(&self);+ PointerEventNumberInitDeclaration::new(+ self.pointer_id,+ self.width,+ self.height,+ self.pressure,+ self.tangential_pressure,+ angles.tilt_x,+ angles.tilt_y,+ angles.azimuth_angle,+ angles.altitude_angle,+ self.twist,+ self.persistent_device_id,+ )+ .initialize(scope, event)+ .expect("PointerEvent state should initialize");+ let pointer_type = crate::util::v8_string_from_utf16_units(scope, &self.pointer_type.0)+ .expect("PointerEvent pointerType should fit in a V8 string");+ PointerEventTailInitDeclaration::new(self.is_primary, pointer_type)+ .initialize(scope, event)+ .expect("PointerEvent tail should initialize");+ PointerEventSequences {+ coalesced_events: self.coalesced_events,+ predicted_events: self.predicted_events,+ }+ .initialize(scope, event)+ .expect("PointerEvent sequence state");+ }+}++#[derive(webidl::WebIdlDictionary)]+#[webidl(prefix = "DragEventInit")]+pub(super) struct DragEventInit<'s> {+ #[webidl(inherit)]+ mouse: MouseEventInit<'s>,+ #[webidl(nullable, interface = web_api_interfaces::DataTransfer, brand_check = is_branded_data_transfer_object)]+ data_transfer: Option<v8::Local<'s, v8::Object>>,+}++impl<'s> DragEventInit<'s> {+ pub(super) fn event_flags(&self) -> (bool, bool, bool) {+ self.mouse.event_flags()+ }++ pub(super) fn initialize(+ self,+ scope: &mut v8::PinScope<'s, '_>,+ event: v8::Local<'s, v8::Object>,+ ) {+ self.mouse.initialize(scope, event);+ let data_transfer = self+ .data_transfer+ .map(Into::into)+ .unwrap_or_else(|| v8::null(scope).into());+ DragEventInitDeclaration::new(data_transfer)+ .initialize(scope, event)+ .expect("DragEvent state should initialize");+ }+}++#[derive(WebApiObject)]+#[webapi(plain, data_properties, enumerable)]+struct DragEventInitDeclaration<'s> {+ data_transfer: v8::Local<'s, v8::Value>,}#[derive(WebApiObject)]#[webapi(plain, data_properties, enumerable)]-struct MouseEventBaseInitDeclaration<'scope> {- view: v8::Local<'scope, v8::Value>,- detail: f64,+struct MouseEventBaseInitDeclaration {screen_x: f64,screen_y: f64,client_x: f64,@@ -38,21 +270,12 @@ struct MouseEventBaseInitDeclaration<'scope> {y: f64,page_x: f64,page_y: f64,- button: f64,- buttons: f64,+ button: i16,+ buttons: u16,movement_x: f64,movement_y: f64,}-#[derive(WebApiObject)]-#[webapi(plain, data_properties, enumerable)]-struct MouseEventModifierInitDeclaration {- ctrl_key: bool,- shift_key: bool,- alt_key: bool,- meta_key: bool,-}-#[derive(WebApiObject)]#[webapi(plain, data_properties, enumerable)]struct MouseEventRelatedTargetDeclaration<'scope> {@@ -65,22 +288,26 @@ struct WheelEventDeltaInitDeclaration {delta_x: f64,delta_y: f64,delta_z: f64,- delta_mode: f64,+ delta_mode: u32,+ wheel_delta_x: i32,+ wheel_delta_y: i32,+ wheel_delta: i32,}#[derive(WebApiObject)]#[webapi(plain, data_properties, enumerable)]struct PointerEventNumberInitDeclaration {- pointer_id: f64,+ pointer_id: i32,width: f64,height: f64,- pressure: f64,- tangential_pressure: f64,- tilt_x: f64,- tilt_y: f64,+ pressure: f32,+ tangential_pressure: f32,+ tilt_x: i32,+ tilt_y: i32,azimuth_angle: f64,altitude_angle: f64,- twist: f64,+ twist: i32,+ persistent_device_id: i32,}#[derive(WebApiObject)]@@ -98,17 +325,6 @@ struct PointerEventAngleInit {altitude_angle: f64,}-impl Default for PointerEventAngleInit {- fn default() -> Self {- Self {- tilt_x: 0,- tilt_y: 0,- azimuth_angle: 0.0,- altitude_angle: std::f64::consts::FRAC_PI_2,- }- }-}-fn normalized_tilt_degrees(tilt_degrees: i32) -> i32 {if (-90..=90).contains(&tilt_degrees) {return tilt_degrees;@@ -223,41 +439,11 @@ fn tilt_y_from_spherical(azimuth_angle: f64, altitude_angle: f64) -> i32 {}}-fn pointer_event_angle_init<'s>(- scope: &mut v8::PinScope<'s, '_>,- init: Option<v8::Local<'s, v8::Object>>,-) -> Result<PointerEventAngleInit, webidl::WebIdlError> {- let Some(init) = init else {- return Ok(PointerEventAngleInit::default());- };- let tilt_x = webidl::optional_member::<webidl::Long>(- scope,- init,- "tiltX",- webidl::Context::member("PointerEventInit", "tiltX"),- )?- .map(|value| value.0);- let tilt_y = webidl::optional_member::<webidl::Long>(- scope,- init,- "tiltY",- webidl::Context::member("PointerEventInit", "tiltY"),- )?- .map(|value| value.0);- let azimuth_angle = webidl::optional_member::<webidl::Double>(- scope,- init,- "azimuthAngle",- webidl::Context::member("PointerEventInit", "azimuthAngle"),- )?- .map(|value| value.0);- let altitude_angle = webidl::optional_member::<webidl::Double>(- scope,- init,- "altitudeAngle",- webidl::Context::member("PointerEventInit", "altitudeAngle"),- )?- .map(|value| value.0);+fn pointer_event_angle_init(init: &PointerEventInit<'_>) -> PointerEventAngleInit {+ let tilt_x = init.tilt_x;+ let tilt_y = init.tilt_y;+ let azimuth_angle = init.azimuth_angle;+ let altitude_angle = init.altitude_angle;let has_tilt = tilt_x.is_some() || tilt_y.is_some();let has_spherical_angles = azimuth_angle.is_some() || altitude_angle.is_some();@@ -279,7 +465,7 @@ fn pointer_event_angle_init<'s>(angles.tilt_x = tilt_x_from_spherical(normalized_azimuth, normalized_altitude);angles.tilt_y = tilt_y_from_spherical(normalized_azimuth, normalized_altitude);}- Ok(angles)+ angles}fn pointer_event_sequence_copy<'s>(@@ -345,155 +531,61 @@ pub(in crate::context_bootstrap) fn pointer_event_get_predicted_events_callback<);}-fn define_mouse_event_base_fields<'s>(- scope: &mut v8::PinScope<'s, '_>,- event: v8::Local<'s, v8::Object>,- init: Option<v8::Local<'s, v8::Object>>,- constructor_name: &'static str,-) -> Option<v8::Local<'s, v8::Value>> {- let Ok(view) = init_window_view_property(scope, init, constructor_name) else {- return None;- };- let client_x = init_number_property(scope, init, "clientX", 0.0);- let client_y = init_number_property(scope, init, "clientY", 0.0);- let detail = init_number_property(scope, init, "detail", 0.0);- let related_target =- init_value_property(scope, init, "relatedTarget").unwrap_or_else(|| v8::null(scope).into());-- MouseEventBaseInitDeclaration::new(- view,- detail,- init_number_property(scope, init, "screenX", 0.0),- init_number_property(scope, init, "screenY", 0.0),- client_x,- client_y,- client_x,- client_y,- client_x,- client_y,- init_number_property(scope, init, "button", 0.0),- init_number_property(scope, init, "buttons", 0.0),- init_number_property(scope, init, "movementX", 0.0),- init_number_property(scope, init, "movementY", 0.0),- )- .initialize(scope, event)- .expect("MouseEvent base init declaration should initialize");- Some(related_target)-}--fn define_mouse_event_modifier_fields<'s>(- scope: &mut v8::PinScope<'s, '_>,- event: v8::Local<'s, v8::Object>,- init: Option<v8::Local<'s, v8::Object>>,-) {- MouseEventModifierInitDeclaration::new(- init_bool_property(scope, init, "ctrlKey", false),- init_bool_property(scope, init, "shiftKey", false),- init_bool_property(scope, init, "altKey", false),- init_bool_property(scope, init, "metaKey", false),- )- .initialize(scope, event)- .expect("MouseEvent modifier init declaration should initialize");-}--fn define_mouse_event_related_target<'s>(- scope: &mut v8::PinScope<'s, '_>,- event: v8::Local<'s, v8::Object>,- related_target: v8::Local<'s, v8::Value>,-) {- MouseEventRelatedTargetDeclaration::new(related_target)- .initialize(scope, event)- .expect("MouseEvent relatedTarget declaration should initialize");-}--pub(in crate::context_bootstrap::events::subclasses) fn initialize_mouse_event<'s>(+fn is_pointer_event_sequence_item<'s>(scope: &mut v8::PinScope<'s, '_>,event: v8::Local<'s, v8::Object>,- init: Option<v8::Local<'s, v8::Object>>,) -> bool {- let Some(related_target) = define_mouse_event_base_fields(scope, event, init, "MouseEvent")- else {- return false;- };- define_mouse_event_modifier_fields(scope, event, init);- define_mouse_event_related_target(scope, event, related_target);- true+ super::super::event_subclass_kind(scope, event) == Some(super::EventSubclassKind::PointerEvent)}-pub(in crate::context_bootstrap::events::subclasses) fn initialize_wheel_event<'s>(- scope: &mut v8::PinScope<'s, '_>,- event: v8::Local<'s, v8::Object>,- init: Option<v8::Local<'s, v8::Object>>,-) -> bool {- let Some(related_target) = define_mouse_event_base_fields(scope, event, init, "WheelEvent")- else {- return false;- };- WheelEventDeltaInitDeclaration::new(- init_number_property(scope, init, "deltaX", 0.0),- init_number_property(scope, init, "deltaY", 0.0),- init_number_property(scope, init, "deltaZ", 0.0),- init_number_property(scope, init, "deltaMode", 0.0),- )- .initialize(scope, event)- .expect("WheelEvent delta init declaration should initialize");- define_mouse_event_modifier_fields(scope, event, init);- define_mouse_event_related_target(scope, event, related_target);- true-}--pub(in crate::context_bootstrap::events::subclasses) fn initialize_pointer_event<'s>(- scope: &mut v8::PinScope<'s, '_>,- event: v8::Local<'s, v8::Object>,- init: Option<v8::Local<'s, v8::Object>>,-) -> bool {- let pointer_type = init_string_property(scope, init, "pointerType", "");- let pointer_type = v8_string(scope, &pointer_type).expect("PointerEvent pointerType");- let sequences = match init- .map(|init| webidl::parse_dictionary_object::<PointerEventSequences>(scope, init))- .transpose()- {- Ok(sequences) => sequences.unwrap_or_default(),- Err(error) => {- webidl::throw_error(scope, &error);- return false;+pub(super) enum PointerEventInitPayload<'s> {+ Mouse(MouseEventInit<'s>),+ Wheel(WheelEventInit<'s>),+ Pointer(PointerEventInit<'s>),+ Drag(DragEventInit<'s>),+}+impl<'s> PointerEventInitPayload<'s> {+ pub(super) fn parse(+ scope: &mut v8::PinScope<'s, '_>,+ args: &v8::FunctionCallbackArguments<'s>,+ kind: super::EventSubclassKind,+ ) -> Option<Self> {+ use super::super::parse_event_dictionary;+ use super::EventSubclassKind;+ Some(match kind {+ EventSubclassKind::MouseEvent => {+ Self::Mouse(parse_event_dictionary(scope, args, "MouseEvent")?)+ }+ EventSubclassKind::WheelEvent => {+ Self::Wheel(parse_event_dictionary(scope, args, "WheelEvent")?)+ }+ EventSubclassKind::PointerEvent => {+ Self::Pointer(parse_event_dictionary(scope, args, "PointerEvent")?)+ }+ EventSubclassKind::DragEvent => {+ Self::Drag(parse_event_dictionary(scope, args, "DragEvent")?)+ }+ _ => unreachable!("only pointing event kinds use PointerEventInitPayload"),+ })+ }+ pub(super) fn event_flags(&self) -> (bool, bool, bool) {+ match self {+ Self::Mouse(init) => init.event_flags(),+ Self::Wheel(init) => init.event_flags(),+ Self::Pointer(init) => init.event_flags(),+ Self::Drag(init) => init.event_flags(),}- };- let Some(related_target) = define_mouse_event_base_fields(scope, event, init, "PointerEvent")- else {- return false;- };- let angles = match pointer_event_angle_init(scope, init) {- Ok(angles) => angles,- Err(error) => {- webidl::throw_error(scope, &error);- return false;+ }+ pub(super) fn initialize(+ self,+ scope: &mut v8::PinScope<'s, '_>,+ event: v8::Local<'s, v8::Object>,+ ) {+ match self {+ Self::Mouse(init) => init.initialize(scope, event),+ Self::Wheel(init) => init.initialize(scope, event),+ Self::Pointer(init) => init.initialize(scope, event),+ Self::Drag(init) => init.initialize(scope, event),}- };- PointerEventNumberInitDeclaration::new(- init_number_property(scope, init, "pointerId", 0.0),- init_number_property(scope, init, "width", 1.0),- init_number_property(scope, init, "height", 1.0),- init_number_property(scope, init, "pressure", 0.0),- init_number_property(scope, init, "tangentialPressure", 0.0),- f64::from(angles.tilt_x),- f64::from(angles.tilt_y),- angles.azimuth_angle,- angles.altitude_angle,- init_number_property(scope, init, "twist", 0.0),- )- .initialize(scope, event)- .expect("PointerEvent number init declaration should initialize");- define_mouse_event_modifier_fields(scope, event, init);- PointerEventTailInitDeclaration::new(- init_bool_property(scope, init, "isPrimary", false),- pointer_type,- )- .initialize(scope, event)- .expect("PointerEvent tail init declaration should initialize");- define_mouse_event_related_target(scope, event, related_target);- sequences- .initialize_snapshot(scope, event)- .expect("PointerEvent sequences");- true+ }}diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/events_selection_storage/event_classes_ranges_and_selection.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/events_selection_storage/event_classes_ranges_and_selection.rsindex 7017a2cc5..166aac7ce 100644--- a/moli-renderer-v8/src/script_vm/tests/browser_api/events_selection_storage/event_classes_ranges_and_selection.rs+++ b/moli-renderer-v8/src/script_vm/tests/browser_api/events_selection_storage/event_classes_ranges_and_selection.rs@@ -21,10 +21,8 @@ fn pointer_event_interface_sequences_preserve_backing_checks_and_getter_order()get view() {order.push('view'); return null;}});assert(event.getCoalescedEvents()[0] === foreign && event.getPredictedEvents()[0] === foreign, 'cross realm backing identity');- assert(order.indexOf('bubbles') < order.indexOf('pointerType') &&- order.indexOf('pointerType') < order.indexOf('coalesced') &&- order.indexOf('coalesced') < order.indexOf('predicted') &&- order.indexOf('predicted') < order.indexOf('view'), 'sequence conversion position: ' + order);+ assert(order.join() === 'bubbles,view,coalesced,pointerType,predicted',+ 'inherited UI members precede lexical pointer members: ' + order);let reads = 0, closes = 0;let error;try {@@ -37,7 +35,22 @@ fn pointer_event_interface_sequences_preserve_backing_checks_and_getter_order()get view() {reads++; throw 'late view';}});} catch (caught) {error = caught;}- assert(error instanceof child.TypeError && reads === 1 && closes === 0, 'backing rejection must stop before later fields');+ assert(error === 'late view' && reads === 1 && closes === 0,+ 'ancestor conversion failure must precede the pointer sequence');+ reads = 0;+ const conversionOrder = [];+ try {+ new child.PointerEvent('pointermove', {+ get view() {conversionOrder.push('view'); return null;},+ coalescedEvents: {[Symbol.iterator]() {return {+ next() {reads++; conversionOrder.push('next'); return {done:false,value:new Event('invalid')};},+ return() {closes++; return {done:true};}+ };}},+ get predictedEvents() {reads++; throw 'late predicted';}+ });+ } catch (caught) {error=caught;}+ assert(error instanceof child.TypeError && reads === 1 && closes === 0 &&+ conversionOrder.join() === 'view,next', 'backing rejection must stop before later pointer fields');return 'ok';})()"#).unwrap();diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/mod.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/mod.rsindex 637050d87..8325b96d1 100644--- a/moli-renderer-v8/src/script_vm/tests/browser_api/mod.rs+++ b/moli-renderer-v8/src/script_vm/tests/browser_api/mod.rs@@ -47,6 +47,7 @@ mod performance_memory;mod platform_identity;mod pointer_capture;mod pointer_lock;+mod pointing_event_init;mod popup_hyperlinks;mod promise_rejection;mod rtc_error;diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/pointing_event_init.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/pointing_event_init.rsnew file mode 100644index 000000000..e450f5e7e--- /dev/null+++ b/moli-renderer-v8/src/script_vm/tests/browser_api/pointing_event_init.rs@@ -0,0 +1,13 @@+use super::*;++#[test]+fn pointing_events_convert_inherited_dictionaries_and_interface_sequences_once() {+ let mut vm = new_storage_html_test_vm("https://pointing-event-dictionaries.test/");+ assert_eq!(+ vm.eval(include_str!(+ "../../../../tests/fixtures/pointing-event-dictionaries.js"+ ))+ .unwrap(),+ "true"+ );+}diff --git a/moli-renderer-v8/tests/fixtures/pointing-event-dictionaries.js b/moli-renderer-v8/tests/fixtures/pointing-event-dictionaries.jsnew file mode 100644index 000000000..54d568dce--- /dev/null+++ b/moli-renderer-v8/tests/fixtures/pointing-event-dictionaries.js@@ -0,0 +1,76 @@+(() => {+ const assert = (ok, label) => {if (!ok) throw Error(label);};+ const base = ['bubbles','cancelable','composed','detail','sourceCapabilities','view'];+ // Existing Moli modifier extensions remain supported; compare the common+ // Chromium 145 members and preserve all unfiltered observations separately.+ const extensions = new Set(['modifierFnLock','modifierHyper','modifierSuper','modifierSymbolLock']);+ const modifiers = ['altKey','ctrlKey','metaKey','modifierAltGraph','modifierCapsLock',+ 'modifierFn','modifierNumLock','modifierScrollLock','modifierSymbol','shiftKey'];+ const mouse = [...base, ...modifiers, 'button','buttons','clientX','clientY',+ 'movementX','movementY','region','relatedTarget','screenX','screenY'];+ const pointer = ['altitudeAngle','azimuthAngle','coalescedEvents','height','isPrimary',+ 'persistentDeviceId','pointerId','pointerType','predictedEvents','pressure',+ 'tangentialPressure','tiltX','tiltY','twist','width'];+ const cases = [[MouseEvent,mouse], [WheelEvent,[...mouse,'deltaMode','deltaX','deltaY','deltaZ','wheelDeltaX','wheelDeltaY']],+ [DragEvent,[...mouse,'dataTransfer']], [PointerEvent,[...mouse,...pointer]]];+ for (const [Constructor, members] of cases) {+ const trace = [];+ new Constructor('audit', new Proxy({}, {get(_target,key) {if (!extensions.has(key)) trace.push(String(key));}}));+ assert(trace.join() === members.join(), Constructor.name + ' order: ' + trace);+ for (const stop of members) {+ const sentinel = {};+ trace.length = 0;+ let error;+ try {new Constructor('audit', new Proxy({}, {get(_target,key) {+ if (!extensions.has(key)) trace.push(String(key)); if (key === stop) throw sentinel;+ }}));} catch (caught) {error = caught;}+ assert(error === sentinel, Constructor.name + '/' + stop + ' exception identity');+ assert(trace.join() === members.slice(0,members.indexOf(stop)+1).join(),+ Constructor.name + '/' + stop + ' stops conversion');+ }+ for (const relatedTarget of [{}, new Proxy(document.body,{})]) {+ let error;+ try {new Constructor('audit',{relatedTarget});} catch (caught) {error=caught;}+ assert(error instanceof TypeError, Constructor.name + ' relatedTarget native brand');+ }+ const event = new Constructor('audit', {relatedTarget:document.body, detail:2147483648,+ clientX:12, button:1, buttons:-1, modifierAltGraph:true});+ assert(event.relatedTarget === document.body && event.detail === -2147483648 &&+ event.clientX === 12 && event.button === 1 && event.buttons === 65535 &&+ event.getModifierState('AltGraph'), Constructor.name + ' converted state');+ for (const value of [1,true,Symbol('init')]) {+ let error;+ try {new Constructor('audit',value);} catch (caught) {error=caught;}+ assert(error instanceof TypeError, Constructor.name + ' primitive init');+ }+ }+ for (const member of ['coalescedEvents','predictedEvents']) {+ let next = 0, error;+ const sentinel = {};+ const values = {[Symbol.iterator]() {return {next() {+ if (next++) throw sentinel;+ return {done:false,value:{}};+ }};}};+ try {new PointerEvent('audit',{[member]:values});} catch (caught) {error=caught;}+ assert(error instanceof TypeError && next === 1, member + ' validates each item before advancing');+ const item = new PointerEvent('move');+ const event = new PointerEvent('audit',{[member]:new Set([item])});+ const method = member === 'coalescedEvents' ? 'getCoalescedEvents' : 'getPredictedEvents';+ const first=event[method](); first.length=0;+ assert(event[method]()[0] === item, member + ' identity and independent arrays');+ }+ assert(new WheelEvent('audit',{deltaMode:-1}).deltaMode === 4294967295, 'WheelEvent unsigned long');+ const transfer=new DataTransfer();+ assert(new DragEvent('audit',{dataTransfer:transfer}).dataTransfer===transfer, 'DataTransfer identity');+ for (const [init, expected] of [[{deltaX:2.5,deltaY:-4.5},[2,-4,-4]],+ [{wheelDeltaX:13,wheelDeltaY:27},[13,27,27]], [{deltaY:1e300},[0,2147483647,2147483647]],+ [{wheelDeltaX:2147483648,wheelDeltaY:-1.5},[-2147483648,-1,-1]]]) {+ const e=new WheelEvent('audit',init);+ assert([e.wheelDeltaX,e.wheelDeltaY,e.wheelDelta].join()===expected.join(), 'WheelEvent legacy delta state');+ }+ const event=new PointerEvent('audit',{pressure:0.1,pointerId:2147483648,pointerType:'\ud800',tiltX:-45});+ assert(event.pressure===Math.fround(0.1) && event.pointerId===-2147483648 &&+ event.pointerType==='\ud800' && event.azimuthAngle===Math.PI &&+ Math.abs(event.altitudeAngle-Math.PI/4)<1e-14, 'PointerEvent numeric and UTF-16 state');+ return true;+})()