Skip to content

armgit / moli

Public Imported from GitHub
0

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

refactor(events): derive PointerEvent interface sequences

ldm0a2c0b604ea17
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 d2d029bd1..1caa168d8 100644
--- a/moli-renderer-v8/src/context_bootstrap/events/subclasses/pointer.rs
+++ b/moli-renderer-v8/src/context_bootstrap/events/subclasses/pointer.rs
@@ -6,26 +6,20 @@ use crate::webidl;
const POINTER_EVENT_COALESCED_EVENTS_SLOT: &str = "__moliPointerEventCoalescedEvents";
const POINTER_EVENT_PREDICTED_EVENTS_SLOT: &str = "__moliPointerEventPredictedEvents";
-struct PointerEventReference<'scope>(v8::Local<'scope, v8::Object>);
-
-impl<'scope> webidl::WebIdlConverter<'scope> for PointerEventReference<'scope> {
- type Options = ();
-
- fn convert(
- scope: &mut v8::PinScope<'scope, '_>,
- value: v8::Local<'scope, v8::Value>,
- context: webidl::Context,
- _options: &Self::Options,
- ) -> Result<Self, webidl::WebIdlError> {
- let event = webidl::convert::<v8::Local<'scope, v8::Object>>(scope, value, context)?;
- if super::super::event_subclass_kind(scope, event) != Some(EventSubclassKind::PointerEvent)
- {
- return Err(webidl::WebIdlError::custom_message(
- "PointerEventInit sequence members must be PointerEvent objects.",
- ));
- }
- Ok(Self(event))
- }
+#[derive(Default, webidl::WebIdlDictionary)]
+#[webidl(prefix = "PointerEventInit")]
+struct PointerEventSequences<'scope> {
+ #[webidl(sequence, interface = crate::web_api_interfaces::PointerEvent, brand_check = is_pointer_event_sequence_item, default = Vec::new())]
+ 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())]
+ predicted_events: Vec<v8::Local<'scope, 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)
}
#[derive(WebApiObject)]
@@ -285,24 +279,6 @@ fn pointer_event_angle_init<'s>(
Ok(angles)
}
-fn pointer_event_sequence_member<'s>(
- scope: &mut v8::PinScope<'s, '_>,
- init: Option<v8::Local<'s, v8::Object>>,
- key: &'static str,
-) -> Result<Vec<v8::Local<'s, v8::Object>>, webidl::WebIdlError> {
- let Some(init) = init else {
- return Ok(Vec::new());
- };
- webidl::optional_member_or::<webidl::Sequence<PointerEventReference<'s>>>(
- scope,
- init,
- key,
- webidl::Context::member("PointerEventInit", key),
- webidl::Sequence(Vec::new()),
- )
- .map(|sequence| sequence.0.into_iter().map(|event| event.0).collect())
-}
-
fn store_pointer_event_sequence<'s>(
scope: &mut v8::PinScope<'s, '_>,
event: v8::Local<'s, v8::Object>,
@@ -484,15 +460,11 @@ pub(in crate::context_bootstrap::events::subclasses) fn initialize_pointer_event
) -> bool {
let pointer_type = init_string_property(scope, init, "pointerType", "");
let pointer_type = v8_string(scope, &pointer_type).expect("PointerEvent pointerType");
- let coalesced_events = match pointer_event_sequence_member(scope, init, "coalescedEvents") {
- Ok(events) => events,
- Err(error) => {
- webidl::throw_error(scope, &error);
- return false;
- }
- };
- let predicted_events = match pointer_event_sequence_member(scope, init, "predictedEvents") {
- Ok(events) => events,
+ 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;
@@ -535,13 +507,13 @@ pub(in crate::context_bootstrap::events::subclasses) fn initialize_pointer_event
scope,
event,
POINTER_EVENT_COALESCED_EVENTS_SLOT,
- &coalesced_events,
+ &sequences.coalesced_events,
);
store_pointer_event_sequence(
scope,
event,
POINTER_EVENT_PREDICTED_EVENTS_SLOT,
- &predicted_events,
+ &sequences.predicted_events,
);
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 79eb757f3..7017a2cc5 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
@@ -1,5 +1,49 @@
use super::*;
+#[test]
+fn pointer_event_interface_sequences_preserve_backing_checks_and_getter_order() {
+ let mut vm = new_parsed_test_vm(
+ "https://pointer-sequence-conversion.test/",
+ "<!doctype html><body><iframe id=child></iframe></body>",
+ );
+ let result = vm.eval(r#"
+ (() => {
+ const assert = (ok, message) => { if (!ok) throw new Error(message); };
+ const child = document.getElementById('child').contentWindow;
+ const foreign = new child.PointerEvent('pointermove');
+ Object.setPrototypeOf(foreign, null);
+ const order = [];
+ const event = new PointerEvent('pointermove', {
+ get pointerType() {order.push('pointerType'); return 'mouse';},
+ get coalescedEvents() {order.push('coalesced'); return new Set([foreign]);},
+ get predictedEvents() {order.push('predicted'); return [foreign];},
+ get bubbles() {order.push('bubbles'); return false;},
+ 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);
+ let reads = 0, closes = 0;
+ let error;
+ try {
+ new child.PointerEvent('pointermove', {
+ coalescedEvents: {[Symbol.iterator]() {return {
+ next() {reads++; return {done: false, value: new Event('invalid')};},
+ return() {closes++; return {done: true};}
+ };}},
+ get predictedEvents() {reads++; throw 'late predicted';},
+ 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');
+ return 'ok';
+ })()
+ "#).unwrap();
+ assert_eq!(result, "ok");
+}
+
#[test]
fn event_listener_exceptions_report_window_error_and_continue_dispatch() {
let mut vm = new_storage_test_vm("https://event-listener-error-report.test/");