From 3e1bbd91c3e9dead8ce2825c7708763554c8aa24 Mon Sep 17 00:00:00 2001 From: ldm0 Date: Fri, 2 Oct 2026 15:32:23 +0800 Subject: [PATCH] fix(webidl): preserve UIEvent and CompositionEvent initialization --- .../src/context_bootstrap/event_legacy.rs | 3 +- .../src/context_bootstrap/event_template.rs | 4 +- .../src/context_bootstrap/events.rs | 3 + .../src/script_vm/tests/browser_api/mod.rs | 1 + .../tests/browser_api/ui_event_init.js | 227 ++++++++++++++++++ .../tests/browser_api/ui_event_init.rs | 16 ++ .../src/script_vm/tests/dom_xhr/xhr.rs | 2 +- moli-webapi/src/events/legacy.rs | 97 +------- moli-webapi/src/events/ui.rs | 92 +++++++ 9 files changed, 344 insertions(+), 101 deletions(-) create mode 100644 moli-renderer-v8/src/script_vm/tests/browser_api/ui_event_init.js create mode 100644 moli-renderer-v8/src/script_vm/tests/browser_api/ui_event_init.rs diff --git a/moli-renderer-v8/src/context_bootstrap/event_legacy.rs b/moli-renderer-v8/src/context_bootstrap/event_legacy.rs index 1fd287a7c3a..c2f8e03842a 100644 --- a/moli-renderer-v8/src/context_bootstrap/event_legacy.rs +++ b/moli-renderer-v8/src/context_bootstrap/event_legacy.rs @@ -2,8 +2,7 @@ use crate::util::context_host_ptr_from_window_object; use moli_webapi::events::legacy::initialize_legacy_text_event; pub(super) use moli_webapi::events::legacy::{ - composition_event_init_callback, event_init_event_callback, mouse_event_init_callback, - ui_event_init_callback, + event_init_event_callback, mouse_event_init_callback, }; pub(super) fn text_event_init_callback<'s>( diff --git a/moli-renderer-v8/src/context_bootstrap/event_template.rs b/moli-renderer-v8/src/context_bootstrap/event_template.rs index 9e0e59913e3..4d213200c48 100644 --- a/moli-renderer-v8/src/context_bootstrap/event_template.rs +++ b/moli-renderer-v8/src/context_bootstrap/event_template.rs @@ -1,10 +1,10 @@ use super::{ event_document::{document_create_event_callback, document_has_focus_callback}, event_legacy::{ - composition_event_init_callback, event_init_event_callback, mouse_event_init_callback, - text_event_init_callback, ui_event_init_callback, + event_init_event_callback, mouse_event_init_callback, text_event_init_callback, }, events::{ + composition_event_init_callback, ui_event_init_callback, event_bubbles_getter_function, event_cancel_bubble_getter_function, event_cancel_bubble_setter_function, event_cancelable_getter_function, event_composed_getter_function, event_composed_path_callback, diff --git a/moli-renderer-v8/src/context_bootstrap/events.rs b/moli-renderer-v8/src/context_bootstrap/events.rs index 4dab3de81ef..60e53ffa300 100644 --- a/moli-renderer-v8/src/context_bootstrap/events.rs +++ b/moli-renderer-v8/src/context_bootstrap/events.rs @@ -35,6 +35,9 @@ pub(in crate::context_bootstrap) use value::{ use moli_webapi::events::subclasses::{COMMAND_EVENT_COMMAND_SLOT, COMMAND_EVENT_SOURCE_SLOT, TOGGLE_EVENT_SOURCE_SLOT}; pub(in crate::context_bootstrap) use subclasses::keyboard_event_init_callback; +pub(in crate::context_bootstrap) use ui::{ + composition_event_init_callback, ui_event_init_callback, +}; #[derive(Default, WebApiObject)] #[webapi(fragment, prototype = "PointerEvent", enumerable)] 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 1e39145ab1c..f3c498e999e 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 @@ -118,6 +118,7 @@ mod traversal_coordinator; mod traversal_receivers; mod trusted_types; mod trusted_types_attributes; +mod ui_event_init; mod user_activation; mod value_event_init; mod value_events; diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/ui_event_init.js b/moli-renderer-v8/src/script_vm/tests/browser_api/ui_event_init.js new file mode 100644 index 00000000000..b48949b14a1 --- /dev/null +++ b/moli-renderer-v8/src/script_vm/tests/browser_api/ui_event_init.js @@ -0,0 +1,227 @@ +(() => { + const rows = [], observed = {}; + const check = (name, run) => { + try { + if (run() !== true) throw new Error('assertion failed'); + rows.push({name, passed: true}); + } catch (error) { + rows.push({name, passed: false, error: String(error), stack: error.stack}); + } + }; + const typeError = (run, realm = globalThis) => { + try { run(); } catch (error) { return error instanceof realm.TypeError; } + return false; + }; + const throws = (run, sentinel) => { + try { run(); } catch (error) { return error === sentinel; } + return false; + }; + const other = document.getElementById('child').contentWindow; + const texts = ['', '\ud800', '\udc00', '\ud83d\ude00', 'a\ud800b\udc00\u0000\ud83d\ude00']; + const snapshot = event => JSON.stringify([ + event.type, event.bubbles, event.cancelable, event.composed, event.defaultPrevented, + event.detail, event.which, event.data, event.timeStamp + ]); + for (const [name, method] of [['UIEvent', 'initUIEvent'], ['CompositionEvent', 'initCompositionEvent']]) { + const C = globalThis[name], remote = other[name]; + const order = ['bubbles', 'cancelable', 'composed', 'detail', 'view', 'which', + ...(name === 'CompositionEvent' ? ['data'] : [])]; + const legacy = (view, payload) => { + const e = new C('before'); + e[method]('after', false, false, view, payload); + return e; + }; + check(`${name} defaults`, () => { + const e = new C('x'); + return e.view === null && e.detail === 0 && e.which === 0 && !e.bubbles && !e.cancelable && + !e.composed && !e.isTrusted && (name !== 'CompositionEvent' || e.data === ''); + }); + check(`${name} inherits UIEvent and Event`, () => { + const e = new C('x'); + return e instanceof UIEvent && e instanceof Event; + }); + check(`${name} legacy omitted view`, () => { + const e = new C('before', {view: window, detail: 9, data: 'before'}); + return e[method]('after') === undefined && e.type === 'after' && e.view === null && e.detail === 0 && + (name !== 'CompositionEvent' || e.data === ''); + }); + check(`${name} constructor requires new and type`, () => typeError(() => C('x')) && typeError(() => new C())); + check(`${name} legacy requires type`, () => typeError(() => new C('x')[method]())); + for (const value of [undefined, null]) { + check(`${name} nullish dictionary ${String(value)}`, () => new C('x', value).view === null); + } + for (const value of [false, 1, '', Symbol(), 1n]) { + check(`${name} rejects ${typeof value} dictionary`, () => typeError(() => new C('x', value))); + } + for (const [value, expected] of [ + [4.9, 4], [-4.9, -4], [2147483648, -2147483648], [4294967297, 1], + [NaN, 0], [Infinity, 0], [-Infinity, 0], [null, 0], ['17.9', 17] + ]) { + check(`${name} detail long ${String(value)}`, () => new C('x', {detail: value}).detail === expected); + if (name === 'UIEvent') check(`legacy detail long ${String(value)}`, () => legacy(null, value).detail === expected); + } + for (const [value, expected] of [[-1, 4294967295], [4294967297, 1], [1.9, 1], [NaN, 0], [Infinity, 0]]) { + check(`${name} which unsigned long ${String(value)}`, () => new C('x', {which: value}).which === expected); + } + for (const field of ['detail', 'which']) { + for (const value of [Symbol(), 1n]) { + check(`${name} ${field} rejects ${typeof value}`, () => typeError(() => new C('x', {[field]: value}))); + } + } + check(`${name} base-first dictionary order`, () => { + const seen = []; + new C('x', new Proxy({}, {get(_target, key) {seen.push(key);}})); + observed[name + 'DictionaryReads'] = seen; + return seen.join() === order.join(); + }); + for (const stop of order) { + check(`${name} getter exception stops at ${stop}`, () => { + const seen = [], sentinel = {}; + return throws(() => new C('x', new Proxy({}, {get(_target, key) { + seen.push(key); if (key === stop) throw sentinel; + }})), sentinel) && seen.join() === order.slice(0, order.indexOf(stop) + 1).join(); + }); + } + for (const field of ['detail', 'which', ...(name === 'CompositionEvent' ? ['data'] : [])]) { + check(`${name} ${field} conversion exception stops`, () => { + const seen = [], sentinel = {}; + return throws(() => new C('x', new Proxy({}, {get(_target, key) { + seen.push(key); if (key === field) return {[Symbol.toPrimitive]() {throw sentinel;}}; + }})), sentinel) && seen.join() === order.slice(0, order.indexOf(field) + 1).join(); + }); + } + check(`${name} type converts before dictionary`, () => { + const seen = []; + const e = new C({toString() {seen.push('type'); return texts[4];}}, + new Proxy({}, {get(_target, key) {seen.push(key);}})); + return e.type === texts[4] && seen.join() === ['type', ...order].join(); + }); + check(`${name} inherited dictionary members`, () => { + const e = new C('x', Object.create({bubbles: true, composed: true, view: other, detail: 3.9, data: texts[4]})); + return e.view === other && e.detail === 3 && e.bubbles && e.composed && + (name !== 'CompositionEvent' || e.data === texts[4]); + }); + check(`${name} accepts callable dictionary`, () => { + const init = Object.assign(() => {}, {view: other, detail: 3.9}); + return new C('x', init).view === other && new C('x', init).detail === 3; + }); + for (const [label, view] of [['window', window], ['child', other], ['null', null], ['undefined', undefined]]) { + const expected = view === undefined ? null : view; + check(`${name} constructor accepts ${label} view`, () => new C('x', {view}).view === expected); + check(`${name} legacy accepts ${label} view`, () => legacy(view).view === expected); + } + let traps = 0; + const handler = {get() {traps++; throw new Error('get trap');}, getPrototypeOf() {traps++; throw new Error('prototype trap');}}; + const revoked = Proxy.revocable(window, handler); revoked.revoke(); + for (const [label, view] of [ + ['ordinary', {}], ['prototype', Object.create(window)], ['proxy', new Proxy(window, handler)], + ['revoked', revoked.proxy], ['number', 1] + ]) { + check(`${name} constructor rejects ${label} view before later conversion`, () => { + let converted = false; + return typeError(() => new C('x', {view, which: {valueOf() {converted = true; return 0;}}})) && !converted && traps === 0; + }); + check(`${name} legacy rejects ${label} view atomically`, () => { + const e = new C('before', {view: other, detail: 7, data: 'before', cancelable: true}); + e.preventDefault(); const before = snapshot(e); let converted = false; + const payload = {[Symbol.toPrimitive]() {converted = true; return 4;}}; + return typeError(() => e[method]('after', true, true, view, payload)) && + snapshot(e) === before && e.view === other && !converted && traps === 0; + }); + } + check(`${name} constructor TypeError belongs to callee realm`, () => typeError(() => new remote('x', {view: {}}), other)); + check(`${name} borrowed legacy accepts genuine other-realm event`, () => { + const e = new remote('before'); + C.prototype[method].call(e, 'after', true, false, window, name === 'UIEvent' ? 4.9 : texts[4]); + return e.type === 'after' && e.view === window && e.bubbles && + (name === 'UIEvent' ? e.detail === 4 : e.data === texts[4]); + }); + check(`${name} legacy argument TypeError belongs to function realm`, () => { + const e = new C('before'); + return typeError(() => remote.prototype[method].call(e, 'after', false, false, {}), other) && e.type === 'before'; + }); + const real = new C('before'), badProxy = Proxy.revocable(real, handler); badProxy.revoke(); + for (const [label, receiver] of [ + ['ordinary', {}], ['prototype', Object.create(real)], ['proxy', new Proxy(real, handler)], ['revoked', badProxy.proxy] + ]) { + check(`${name} ${label} receiver rejects before conversion in callee realm`, () => { + let converted = false; + const type = {toString() {converted = true; return 'after';}}; + return typeError(() => remote.prototype[method].call(receiver, type), other) && !converted && traps === 0; + }); + } + for (const payload of [Symbol(), {[Symbol.toPrimitive]() {throw 19;}}]) { + check(`${name} legacy payload error retains state ${typeof payload}`, () => { + const e = new C('before', {view: other, detail: 5, data: 'before', cancelable: true}); + e.preventDefault(); const before = snapshot(e); + const failed = typeof payload === 'symbol' ? typeError(() => e[method]('after', true, true, null, payload)) : + throws(() => e[method]('after', true, true, null, payload), 19); + return failed && snapshot(e) === before && e.view === other; + }); + } + check(`${name} legacy successful init preserves creation state`, () => { + const e = new C('before', {view: other, detail: 5, which: 8, data: 'before', composed: true, cancelable: true}); + const stamp = e.timeStamp, which = e.which; e.preventDefault(); e.stopImmediatePropagation(); + e[method]('after', true, false, null, name === 'UIEvent' ? 4.9 : texts[4]); + const target = document.createElement('div'); let fired = 0; + target.addEventListener('after', () => fired++); target.dispatchEvent(e); + return e.type === 'after' && e.bubbles && !e.cancelable && !e.defaultPrevented && e.composed && + e.timeStamp === stamp && e.which === which && fired === 1 && e.view === null && + (name === 'UIEvent' ? e.detail === 4 : e.detail === 0 && e.data === texts[4]); + }); + check(`${name} dispatch guard runs after argument conversion`, () => { + const e = new C('before', {view: other, detail: 7, data: 'before'}); + const target = document.createElement('div'); const before = snapshot(e), seen = []; let valid = false; + target.addEventListener('before', () => { + e[method]({toString() {seen.push('type'); return 'after';}}, false, false, window, + {[Symbol.toPrimitive](hint) {seen.push(hint); return name === 'UIEvent' ? 3 : 'after';}}); + valid = snapshot(e) === before && e.view === other; + }); + target.dispatchEvent(e); + return valid && seen.join() === (name === 'UIEvent' ? 'type,number' : 'type,string'); + }); + check(`${name} createEvent default view remains null`, () => { + const e = document.createEvent(name); e[method]('after'); + return e.view === null && e.detail === 0 && e.type === 'after'; + }); + } + for (let i = 0; i < texts.length; i++) { + const text = texts[i]; + check(`composition constructor data UTF-16 ${i}`, () => new CompositionEvent('x', {data: text}).data === text); + check(`composition legacy data UTF-16 ${i}`, () => { + const e = new CompositionEvent('x'); e.initCompositionEvent('after', false, false, null, text); + return e.data === text; + }); + } + for (const [value, expected] of [[undefined, ''], [null, 'null'], [23, '23'], [true, 'true']]) { + check(`composition data ${String(value)}`, () => new CompositionEvent('x', {data: value}).data === expected); + check(`composition legacy data ${String(value)}`, () => { + const e = new CompositionEvent('x'); e.initCompositionEvent('after', false, false, null, value); + return e.data === expected; + }); + } + check('composition data string hint once', () => { + let calls = 0; + const value = {[Symbol.toPrimitive](hint) {if (hint !== 'string') throw new Error(hint); calls++; return texts[4];}}; + return new CompositionEvent('x', {data: value}).data === texts[4] && calls === 1; + }); + check('composition data Symbol rejects', () => typeError(() => new CompositionEvent('x', {data: Symbol()}))); + check('borrowed initUIEvent preserves composition payload', () => { + const e = new CompositionEvent('before', {data: texts[4], composed: true}); + UIEvent.prototype.initUIEvent.call(e, 'after', true, false, other, 3.9); + return e.type === 'after' && e.view === other && e.detail === 3 && e.data === texts[4] && e.composed; + }); + check('borrowed initUIEvent preserves keyboard payload and modifiers', () => { + const e = new KeyboardEvent('before', {key: texts[4], code: 'KeyA', ctrlKey: true, which: 5, composed: true}); + const which = e.which; + UIEvent.prototype.initUIEvent.call(e, 'after', false, false, other, 3.9); + return e.key === texts[4] && e.code === 'KeyA' && e.ctrlKey && e.composed && e.which === which && e.view === other && e.detail === 3; + }); + check('initCompositionEvent rejects UIEvent before type conversion', () => { + let converted = false; + return typeError(() => CompositionEvent.prototype.initCompositionEvent.call(new UIEvent('x'), + {toString() {converted = true; return 'after';}})) && !converted; + }); + globalThis.__uiEventResults = {total: rows.length, passed: rows.filter(row => row.passed).length, rows, observed}; + return rows.every(row => row.passed); +})() diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/ui_event_init.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/ui_event_init.rs new file mode 100644 index 00000000000..d59397023af --- /dev/null +++ b/moli-renderer-v8/src/script_vm/tests/browser_api/ui_event_init.rs @@ -0,0 +1,16 @@ +use super::*; + +#[test] +fn ui_and_composition_events_convert_inherited_dictionaries_and_legacy_arguments() { + let mut vm = new_storage_html_test_vm("https://ui-event-init-webidl.test/"); + vm.eval("document.body.innerHTML = '';") + .unwrap(); + let result = vm.eval(include_str!("ui_event_init.js")).unwrap(); + assert_eq!( + result, + "true", + "{}", + vm.eval("JSON.stringify(__uiEventResults.rows.filter(row=>!row.passed))") + .unwrap() + ); +} diff --git a/moli-renderer-v8/src/script_vm/tests/dom_xhr/xhr.rs b/moli-renderer-v8/src/script_vm/tests/dom_xhr/xhr.rs index cbeeb4efa60..9ff6e4cf019 100644 --- a/moli-renderer-v8/src/script_vm/tests/dom_xhr/xhr.rs +++ b/moli-renderer-v8/src/script_vm/tests/dom_xhr/xhr.rs @@ -2471,7 +2471,7 @@ fn legacy_event_initializers_apply_webidl_conversion() { return [ `${base.type}:${base.bubbles}:${base.cancelable}`, `${created.constructor.name}:${created instanceof UIEvent}`, - `${ui.type}:${ui.bubbles}:${ui.cancelable}:${ui.view === window}:${ui.detail}`, + `${ui.type}:${ui.bubbles}:${ui.cancelable}:${ui.view === null}:${ui.detail}`, `${custom.type}:${custom.bubbles}:${custom.cancelable}:${custom.detail}`, `${text.type}:${text.bubbles}:${text.cancelable}:${text.view === window}:${text.data}`, `${composition.type}:${composition.bubbles}:${composition.cancelable}:${composition.view === window}:${composition.data}`, diff --git a/moli-webapi/src/events/legacy.rs b/moli-webapi/src/events/legacy.rs index bfc4fe12641..b176b3e40eb 100644 --- a/moli-webapi/src/events/legacy.rs +++ b/moli-webapi/src/events/legacy.rs @@ -1,8 +1,6 @@ use super::modifiers::initialize_legacy_event_modifiers; use super::state::{event_backing, reinitialize_event_object}; -use super::ui::{ - initialize_legacy_ui_event, initialize_legacy_ui_event_values, is_window_receiver, -}; +use super::ui::{initialize_legacy_ui_event, is_window_receiver}; use crate::interfaces as web_api_interfaces; use moli_v8_util::{throw_type_error, v8_string}; use moli_webapi_declare::WebApiObject; @@ -23,25 +21,6 @@ struct InitEventArgs { cancelable: bool, } -#[derive(webidl::WebIdlArgs)] -#[webidl(prefix = "UIEvent.initUIEvent")] -struct InitUiEventArgs<'s> { - #[webidl( - required, - converter = "raw", - missing_message = "Failed to execute 'initUIEvent': 1 argument required." - )] - event_type: webidl::DomString16, - #[webidl(default = false)] - bubbles: bool, - #[webidl(default = false)] - cancelable: bool, - #[webidl(index = 3, converter = "raw")] - view: Option>, - #[webidl(default = 0, index = 4)] - detail: i32, -} - #[derive(webidl::WebIdlArgs)] #[webidl(prefix = "MouseEvent.initMouseEvent")] struct InitMouseEventArgs<'s> { @@ -105,25 +84,6 @@ struct InitTextEventArgs<'s> { data: String, } -#[derive(webidl::WebIdlArgs)] -#[webidl(prefix = "CompositionEvent.initCompositionEvent")] -struct InitCompositionEventArgs<'s> { - #[webidl( - required, - converter = "raw", - missing_message = "Failed to execute 'initCompositionEvent': 1 argument required." - )] - event_type: webidl::DomString16, - #[webidl(default = false)] - bubbles: bool, - #[webidl(default = false)] - cancelable: bool, - #[webidl(index = 3, converter = "raw")] - view: Option>, - #[webidl(default = "", index = 4)] - data: String, -} - #[derive(WebApiObject)] #[webapi(plain, data_properties, enumerable)] struct LegacyTextEventInitDeclaration<'scope> { @@ -158,14 +118,6 @@ struct LegacyMouseEventTailInitDeclaration<'scope> { related_target: v8::Local<'scope, v8::Value>, } -fn legacy_event_view_or_global<'s>( - scope: &mut v8::PinScope<'s, '_>, - view: Option>, -) -> v8::Local<'s, v8::Value> { - view.filter(|value| !value.is_null_or_undefined()) - .unwrap_or_else(|| scope.get_current_context().global(scope).into()) -} - fn legacy_text_event_view_or_null<'s>( scope: &mut v8::PinScope<'s, '_>, view: Option>, @@ -209,28 +161,6 @@ pub fn event_init_event_callback<'s>( ); } -pub fn ui_event_init_callback<'s>( - scope: &mut v8::PinScope<'s, '_>, - args: v8::FunctionCallbackArguments<'s>, - _rv: v8::ReturnValue<'_, v8::Value>, -) { - let event = event_backing(scope, args.this()); - let Some(parsed) = webidl::parse_args::(scope, &args) else { - return; - }; - let view = legacy_event_view_or_global(scope, parsed.view); - if !reinitialize_event_object( - scope, - event, - &parsed.event_type.0, - parsed.bubbles, - parsed.cancelable, - ) { - return; - } - initialize_legacy_ui_event_values(scope, event, view, parsed.detail); -} - pub fn initialize_legacy_text_event<'s>( scope: &mut v8::PinScope<'s, '_>, args: v8::FunctionCallbackArguments<'s>, @@ -302,28 +232,3 @@ pub fn mouse_event_init_callback<'s>( .initialize(scope, event) .expect("legacy MouseEvent tail init declaration should initialize"); } - -pub fn composition_event_init_callback<'s>( - scope: &mut v8::PinScope<'s, '_>, - args: v8::FunctionCallbackArguments<'s>, - _rv: v8::ReturnValue<'_, v8::Value>, -) { - let event = event_backing(scope, args.this()); - let Some(parsed) = webidl::parse_args::(scope, &args) else { - return; - }; - let view = legacy_event_view_or_global(scope, parsed.view); - if !reinitialize_event_object( - scope, - event, - &parsed.event_type.0, - parsed.bubbles, - parsed.cancelable, - ) { - return; - } - let data = v8_string(scope, &parsed.data).expect("composition event data"); - LegacyTextEventInitDeclaration::new(view, 0.0, data) - .initialize(scope, event) - .expect("legacy CompositionEvent init declaration should initialize"); -} diff --git a/moli-webapi/src/events/ui.rs b/moli-webapi/src/events/ui.rs index 4bcd6bdeceb..4bbf7c1f6a3 100644 --- a/moli-webapi/src/events/ui.rs +++ b/moli-webapi/src/events/ui.rs @@ -1,4 +1,6 @@ +use super::state::{event_backing, reinitialize_event_object}; use crate::interfaces as web_api_interfaces; +use moli_v8_util::v8_string_from_utf16_units; use moli_webapi_declare::WebApiObject; use moli_webidl as webidl; use webidl::WebIdlDictionarySerialize; @@ -86,3 +88,93 @@ pub(crate) fn is_window_receiver<'s>( ) -> bool { (super::runtime(scope).is_window_receiver)(scope, receiver) } + +#[derive(WebApiObject)] +#[webapi(plain, data_properties, enumerable)] +struct CompositionEventData<'s> { + data: v8::Local<'s, v8::String>, +} + +fn initialize_composition_data<'s>( + scope: &mut v8::PinScope<'s, '_>, + event: v8::Local<'s, v8::Object>, + data: &[u16], +) { + // Both CompositionEventInit.data and initCompositionEvent's dataArg are + // DOMString inputs. Retain their UTF-16 code units without a Rust String. + let data = v8_string_from_utf16_units(scope, data).expect("CompositionEvent data"); + CompositionEventData::new(data) + .initialize(scope, event) + .expect("CompositionEvent data should initialize"); +} + +#[derive(webidl::WebIdlArgs)] +#[webidl(prefix = "UIEvent.initUIEvent")] +struct InitUiEventArgs<'s> { + #[webidl(required, converter = "raw")] + event_type: webidl::DomString16, + #[webidl(default = false)] + bubbles: bool, + #[webidl(default = false)] + cancelable: bool, + #[webidl(nullable, interface = web_api_interfaces::Window, brand_check = is_window_receiver)] + view: Option>, + #[webidl(default = 0)] + detail: i32, +} + +#[derive(webidl::WebIdlArgs)] +#[webidl(prefix = "CompositionEvent.initCompositionEvent")] +struct InitCompositionEventArgs<'s> { + #[webidl(required, converter = "raw")] + event_type: webidl::DomString16, + #[webidl(default = false)] + bubbles: bool, + #[webidl(default = false)] + cancelable: bool, + #[webidl(nullable, interface = web_api_interfaces::Window, brand_check = is_window_receiver)] + view: Option>, + #[webidl(default = webidl::DomString16(Vec::new()), converter = "raw")] + data: webidl::DomString16, +} + +pub fn ui_event_init_callback<'s>( + scope: &mut v8::PinScope<'s, '_>, + args: v8::FunctionCallbackArguments<'s>, + _rv: v8::ReturnValue<'_, v8::Value>, +) { + let Some(parsed) = webidl::parse_args::(scope, &args) else { + return; + }; + let event = event_backing(scope, args.this()); + if reinitialize_event_object( + scope, + event, + &parsed.event_type.0, + parsed.bubbles, + parsed.cancelable, + ) { + initialize_legacy_ui_event(scope, event, parsed.view, parsed.detail); + } +} + +pub fn composition_event_init_callback<'s>( + scope: &mut v8::PinScope<'s, '_>, + args: v8::FunctionCallbackArguments<'s>, + _rv: v8::ReturnValue<'_, v8::Value>, +) { + let Some(parsed) = webidl::parse_args::(scope, &args) else { + return; + }; + let event = event_backing(scope, args.this()); + if reinitialize_event_object( + scope, + event, + &parsed.event_type.0, + parsed.bubbles, + parsed.cancelable, + ) { + initialize_legacy_ui_event(scope, event, parsed.view, 0); + initialize_composition_data(scope, event, &parsed.data.0); + } +}