Skip to content

armgit / moli

Public Imported from GitHub
0

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

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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
new file mode 100644
index 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.js
new file mode 100644
index 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;
+})()