mirror of
https://github.com/lexmount/moli.git
synced 2026-11-21 16:03:10 +00:00
fix(webidl): preserve UIEvent and CompositionEvent initialization
This commit is contained in:
@@ -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>(
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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)]
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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);
|
||||
})()
|
||||
@@ -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 = '<iframe id=child></iframe>';")
|
||||
.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()
|
||||
);
|
||||
}
|
||||
@@ -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}`,
|
||||
|
||||
@@ -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<v8::Local<'s, v8::Value>>,
|
||||
#[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<v8::Local<'s, v8::Value>>,
|
||||
#[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>>,
|
||||
) -> 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<v8::Local<'s, v8::Value>>,
|
||||
@@ -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::<InitUiEventArgs>(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::<InitCompositionEventArgs>(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");
|
||||
}
|
||||
|
||||
@@ -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<v8::Local<'s, v8::Object>>,
|
||||
#[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<v8::Local<'s, v8::Object>>,
|
||||
#[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::<InitUiEventArgs>(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::<InitCompositionEventArgs>(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);
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user