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);
+ }
+}